1
/* Renesas / SuperH SH specific support for 32-bit ELF
2
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3
2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
4
Free Software Foundation, Inc.
5
Contributed by Ian Lance Taylor, Cygnus Support.
7
This file is part of BFD, the Binary File Descriptor library.
9
This program is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 3 of the License, or
12
(at your option) any later version.
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
GNU General Public License for more details.
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
MA 02110-1301, USA. */
29
#include "elf-vxworks.h"
32
#include "libiberty.h"
33
#include "../opcodes/sh-opc.h"
35
static bfd_reloc_status_type sh_elf_reloc
36
(bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
37
static bfd_reloc_status_type sh_elf_ignore_reloc
38
(bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
39
static bfd_boolean sh_elf_relax_delete_bytes
40
(bfd *, asection *, bfd_vma, int);
41
static bfd_boolean sh_elf_align_loads
42
(bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
44
static bfd_boolean sh_elf_swap_insns
45
(bfd *, asection *, void *, bfd_byte *, bfd_vma);
47
static int sh_elf_optimized_tls_reloc
48
(struct bfd_link_info *, int, int);
49
static bfd_vma dtpoff_base
50
(struct bfd_link_info *);
52
(struct bfd_link_info *, bfd_vma);
54
/* The name of the dynamic interpreter. This is put in the .interp
57
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
59
/* FDPIC binaries have a default 128K stack. */
60
#define DEFAULT_STACK_SIZE 0x20000
62
#define MINUS_ONE ((bfd_vma) 0 - 1)
64
/* Decide whether a reference to a symbol can be resolved locally or
65
not. If the symbol is protected, we want the local address, but
66
its function descriptor must be assigned by the dynamic linker. */
67
#define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
68
(SYMBOL_REFERENCES_LOCAL (INFO, H) \
69
|| ! elf_hash_table (INFO)->dynamic_sections_created)
71
#define SH_PARTIAL32 TRUE
72
#define SH_SRC_MASK32 0xffffffff
73
#define SH_ELF_RELOC sh_elf_reloc
74
static reloc_howto_type sh_elf_howto_table[] =
76
#include "elf32-sh-relocs.h"
79
#define SH_PARTIAL32 FALSE
80
#define SH_SRC_MASK32 0
81
#define SH_ELF_RELOC bfd_elf_generic_reloc
82
static reloc_howto_type sh_vxworks_howto_table[] =
84
#include "elf32-sh-relocs.h"
87
/* Return true if OUTPUT_BFD is a VxWorks object. */
90
vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
92
#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
93
extern const bfd_target bfd_elf32_shlvxworks_vec;
94
extern const bfd_target bfd_elf32_shvxworks_vec;
96
return (abfd->xvec == &bfd_elf32_shlvxworks_vec
97
|| abfd->xvec == &bfd_elf32_shvxworks_vec);
103
/* Return true if OUTPUT_BFD is an FDPIC object. */
106
fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
108
#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
109
extern const bfd_target bfd_elf32_shfd_vec;
110
extern const bfd_target bfd_elf32_shbfd_vec;
112
return (abfd->xvec == &bfd_elf32_shfd_vec
113
|| abfd->xvec == &bfd_elf32_shbfd_vec);
119
/* Return the howto table for ABFD. */
121
static reloc_howto_type *
122
get_howto_table (bfd *abfd)
124
if (vxworks_object_p (abfd))
125
return sh_vxworks_howto_table;
126
return sh_elf_howto_table;
129
static bfd_reloc_status_type
130
sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED, bfd *input_bfd,
131
asection *input_section, bfd_byte *contents,
132
bfd_vma addr, asection *symbol_section,
133
bfd_vma start, bfd_vma end)
135
static bfd_vma last_addr;
136
static asection *last_symbol_section;
137
bfd_byte *start_ptr, *ptr, *last_ptr;
142
/* Sanity check the address. */
143
if (addr > bfd_get_section_limit (input_bfd, input_section))
144
return bfd_reloc_outofrange;
146
/* We require the start and end relocations to be processed consecutively -
147
although we allow then to be processed forwards or backwards. */
151
last_symbol_section = symbol_section;
154
if (last_addr != addr)
158
if (! symbol_section || last_symbol_section != symbol_section || end < start)
159
return bfd_reloc_outofrange;
161
/* Get the symbol_section contents. */
162
if (symbol_section != input_section)
164
if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
165
contents = elf_section_data (symbol_section)->this_hdr.contents;
168
if (!bfd_malloc_and_get_section (input_bfd, symbol_section,
171
if (contents != NULL)
173
return bfd_reloc_outofrange;
177
#define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
178
start_ptr = contents + start;
179
for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
181
for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
184
diff = (last_ptr - ptr) >> 1;
185
cum_diff += diff & 1;
188
/* Calculate the start / end values to load into rs / re minus four -
189
so that will cancel out the four we would otherwise have to add to
190
addr to get the value to subtract in order to get relative addressing. */
194
end = (ptr + cum_diff * 2) - contents;
198
bfd_vma start0 = start - 4;
200
while (start0 && IS_PPI (contents + start0))
202
start0 = start - 2 - ((start - start0) & 2);
203
start = start0 - cum_diff - 2;
208
&& elf_section_data (symbol_section)->this_hdr.contents != contents)
211
insn = bfd_get_16 (input_bfd, contents + addr);
213
x = (insn & 0x200 ? end : start) - addr;
214
if (input_section != symbol_section)
215
x += ((symbol_section->output_section->vma + symbol_section->output_offset)
216
- (input_section->output_section->vma
217
+ input_section->output_offset));
219
if (x < -128 || x > 127)
220
return bfd_reloc_overflow;
222
x = (insn & ~0xff) | (x & 0xff);
223
bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
228
/* This function is used for normal relocs. This used to be like the COFF
229
function, and is almost certainly incorrect for other ELF targets. */
231
static bfd_reloc_status_type
232
sh_elf_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
233
void *data, asection *input_section, bfd *output_bfd,
234
char **error_message ATTRIBUTE_UNUSED)
238
enum elf_sh_reloc_type r_type;
239
bfd_vma addr = reloc_entry->address;
240
bfd_byte *hit_data = addr + (bfd_byte *) data;
242
r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
244
if (output_bfd != NULL)
246
/* Partial linking--do nothing. */
247
reloc_entry->address += input_section->output_offset;
251
/* Almost all relocs have to do with relaxing. If any work must be
252
done for them, it has been done in sh_relax_section. */
253
if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
256
if (symbol_in != NULL
257
&& bfd_is_und_section (symbol_in->section))
258
return bfd_reloc_undefined;
260
if (bfd_is_com_section (symbol_in->section))
263
sym_value = (symbol_in->value +
264
symbol_in->section->output_section->vma +
265
symbol_in->section->output_offset);
270
insn = bfd_get_32 (abfd, hit_data);
271
insn += sym_value + reloc_entry->addend;
272
bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
275
insn = bfd_get_16 (abfd, hit_data);
276
sym_value += reloc_entry->addend;
277
sym_value -= (input_section->output_section->vma
278
+ input_section->output_offset
281
sym_value += (insn & 0xfff) << 1;
284
insn = (insn & 0xf000) | (sym_value & 0xfff);
285
bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
286
if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
287
return bfd_reloc_overflow;
297
/* This function is used for relocs which are only used for relaxing,
298
which the linker should otherwise ignore. */
300
static bfd_reloc_status_type
301
sh_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
302
asymbol *symbol ATTRIBUTE_UNUSED,
303
void *data ATTRIBUTE_UNUSED, asection *input_section,
305
char **error_message ATTRIBUTE_UNUSED)
307
if (output_bfd != NULL)
308
reloc_entry->address += input_section->output_offset;
312
/* This structure is used to map BFD reloc codes to SH ELF relocs. */
316
bfd_reloc_code_real_type bfd_reloc_val;
317
unsigned char elf_reloc_val;
320
/* An array mapping BFD reloc codes to SH ELF relocs. */
322
static const struct elf_reloc_map sh_reloc_map[] =
324
{ BFD_RELOC_NONE, R_SH_NONE },
325
{ BFD_RELOC_32, R_SH_DIR32 },
326
{ BFD_RELOC_16, R_SH_DIR16 },
327
{ BFD_RELOC_8, R_SH_DIR8 },
328
{ BFD_RELOC_CTOR, R_SH_DIR32 },
329
{ BFD_RELOC_32_PCREL, R_SH_REL32 },
330
{ BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
331
{ BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
332
{ BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
333
{ BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
334
{ BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
335
{ BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
336
{ BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
337
{ BFD_RELOC_SH_USES, R_SH_USES },
338
{ BFD_RELOC_SH_COUNT, R_SH_COUNT },
339
{ BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
340
{ BFD_RELOC_SH_CODE, R_SH_CODE },
341
{ BFD_RELOC_SH_DATA, R_SH_DATA },
342
{ BFD_RELOC_SH_LABEL, R_SH_LABEL },
343
{ BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
344
{ BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
345
{ BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
346
{ BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
347
{ BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
348
{ BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
349
{ BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
350
{ BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
351
{ BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
352
{ BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
353
{ BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
354
{ BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
355
{ BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
356
{ BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
357
{ BFD_RELOC_SH_COPY, R_SH_COPY },
358
{ BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
359
{ BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
360
{ BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
361
{ BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
362
{ BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
363
{ BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
364
{ BFD_RELOC_SH_GOT20, R_SH_GOT20 },
365
{ BFD_RELOC_SH_GOTOFF20, R_SH_GOTOFF20 },
366
{ BFD_RELOC_SH_GOTFUNCDESC, R_SH_GOTFUNCDESC },
367
{ BFD_RELOC_SH_GOTFUNCDESC20, R_SH_GOTFUNCDESC20 },
368
{ BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC },
369
{ BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 },
370
{ BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC },
371
#ifdef INCLUDE_SHMEDIA
372
{ BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
373
{ BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
374
{ BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
375
{ BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
376
{ BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
377
{ BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
378
{ BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
379
{ BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
380
{ BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
381
{ BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
382
{ BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
383
{ BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
384
{ BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
385
{ BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
386
{ BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
387
{ BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
388
{ BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
389
{ BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
390
{ BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
391
{ BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
392
{ BFD_RELOC_SH_COPY64, R_SH_COPY64 },
393
{ BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
394
{ BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
395
{ BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
396
{ BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
397
{ BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
398
{ BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
399
{ BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
400
{ BFD_RELOC_SH_PT_16, R_SH_PT_16 },
401
{ BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
402
{ BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
403
{ BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
404
{ BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
405
{ BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
406
{ BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
407
{ BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
408
{ BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
409
{ BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
410
{ BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
411
{ BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
412
{ BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
413
{ BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
414
{ BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
415
{ BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
416
{ BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
417
{ BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
418
{ BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
419
{ BFD_RELOC_64, R_SH_64 },
420
{ BFD_RELOC_64_PCREL, R_SH_64_PCREL },
421
#endif /* not INCLUDE_SHMEDIA */
424
/* Given a BFD reloc code, return the howto structure for the
425
corresponding SH ELF reloc. */
427
static reloc_howto_type *
428
sh_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
432
for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
434
if (sh_reloc_map[i].bfd_reloc_val == code)
435
return get_howto_table (abfd) + (int) sh_reloc_map[i].elf_reloc_val;
441
static reloc_howto_type *
442
sh_elf_reloc_name_lookup (bfd *abfd, const char *r_name)
446
if (vxworks_object_p (abfd))
449
i < (sizeof (sh_vxworks_howto_table)
450
/ sizeof (sh_vxworks_howto_table[0]));
452
if (sh_vxworks_howto_table[i].name != NULL
453
&& strcasecmp (sh_vxworks_howto_table[i].name, r_name) == 0)
454
return &sh_vxworks_howto_table[i];
459
i < (sizeof (sh_elf_howto_table)
460
/ sizeof (sh_elf_howto_table[0]));
462
if (sh_elf_howto_table[i].name != NULL
463
&& strcasecmp (sh_elf_howto_table[i].name, r_name) == 0)
464
return &sh_elf_howto_table[i];
470
/* Given an ELF reloc, fill in the howto field of a relent. */
473
sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
477
r = ELF32_R_TYPE (dst->r_info);
479
BFD_ASSERT (r < (unsigned int) R_SH_max);
480
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
481
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
482
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
483
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
484
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
485
BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_6 || r > R_SH_LAST_INVALID_RELOC_6);
487
cache_ptr->howto = get_howto_table (abfd) + r;
490
/* This function handles relaxing for SH ELF. See the corresponding
491
function in coff-sh.c for a description of what this does. FIXME:
492
There is a lot of duplication here between this code and the COFF
493
specific code. The format of relocs and symbols is wound deeply
494
into this code, but it would still be better if the duplication
495
could be eliminated somehow. Note in particular that although both
496
functions use symbols like R_SH_CODE, those symbols have different
497
values; in coff-sh.c they come from include/coff/sh.h, whereas here
498
they come from enum elf_sh_reloc_type in include/elf/sh.h. */
501
sh_elf_relax_section (bfd *abfd, asection *sec,
502
struct bfd_link_info *link_info, bfd_boolean *again)
504
Elf_Internal_Shdr *symtab_hdr;
505
Elf_Internal_Rela *internal_relocs;
506
bfd_boolean have_code;
507
Elf_Internal_Rela *irel, *irelend;
508
bfd_byte *contents = NULL;
509
Elf_Internal_Sym *isymbuf = NULL;
513
if (link_info->relocatable
514
|| (sec->flags & SEC_RELOC) == 0
515
|| sec->reloc_count == 0)
518
#ifdef INCLUDE_SHMEDIA
519
if (elf_section_data (sec)->this_hdr.sh_flags
520
& (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
526
symtab_hdr = &elf_symtab_hdr (abfd);
528
internal_relocs = (_bfd_elf_link_read_relocs
529
(abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
530
link_info->keep_memory));
531
if (internal_relocs == NULL)
536
irelend = internal_relocs + sec->reloc_count;
537
for (irel = internal_relocs; irel < irelend; irel++)
539
bfd_vma laddr, paddr, symval;
541
Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
544
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
547
if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
550
/* Get the section contents. */
551
if (contents == NULL)
553
if (elf_section_data (sec)->this_hdr.contents != NULL)
554
contents = elf_section_data (sec)->this_hdr.contents;
557
if (!bfd_malloc_and_get_section (abfd, sec, &contents))
562
/* The r_addend field of the R_SH_USES reloc will point us to
563
the register load. The 4 is because the r_addend field is
564
computed as though it were a jump offset, which are based
565
from 4 bytes after the jump instruction. */
566
laddr = irel->r_offset + 4 + irel->r_addend;
567
if (laddr >= sec->size)
569
(*_bfd_error_handler) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
571
(unsigned long) irel->r_offset);
574
insn = bfd_get_16 (abfd, contents + laddr);
576
/* If the instruction is not mov.l NN,rN, we don't know what to
578
if ((insn & 0xf000) != 0xd000)
580
((*_bfd_error_handler)
581
(_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
582
abfd, (unsigned long) irel->r_offset, insn));
586
/* Get the address from which the register is being loaded. The
587
displacement in the mov.l instruction is quadrupled. It is a
588
displacement from four bytes after the movl instruction, but,
589
before adding in the PC address, two least significant bits
590
of the PC are cleared. We assume that the section is aligned
591
on a four byte boundary. */
594
paddr += (laddr + 4) &~ (bfd_vma) 3;
595
if (paddr >= sec->size)
597
((*_bfd_error_handler)
598
(_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
599
abfd, (unsigned long) irel->r_offset));
603
/* Get the reloc for the address from which the register is
604
being loaded. This reloc will tell us which function is
605
actually being called. */
606
for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
607
if (irelfn->r_offset == paddr
608
&& ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
610
if (irelfn >= irelend)
612
((*_bfd_error_handler)
613
(_("%B: 0x%lx: warning: could not find expected reloc"),
614
abfd, (unsigned long) paddr));
618
/* Read this BFD's symbols if we haven't done so already. */
619
if (isymbuf == NULL && symtab_hdr->sh_info != 0)
621
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
623
isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
624
symtab_hdr->sh_info, 0,
630
/* Get the value of the symbol referred to by the reloc. */
631
if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
633
/* A local symbol. */
634
Elf_Internal_Sym *isym;
636
isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
638
!= (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
640
((*_bfd_error_handler)
641
(_("%B: 0x%lx: warning: symbol in unexpected section"),
642
abfd, (unsigned long) paddr));
646
symval = (isym->st_value
647
+ sec->output_section->vma
648
+ sec->output_offset);
653
struct elf_link_hash_entry *h;
655
indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
656
h = elf_sym_hashes (abfd)[indx];
657
BFD_ASSERT (h != NULL);
658
if (h->root.type != bfd_link_hash_defined
659
&& h->root.type != bfd_link_hash_defweak)
661
/* This appears to be a reference to an undefined
662
symbol. Just ignore it--it will be caught by the
663
regular reloc processing. */
667
symval = (h->root.u.def.value
668
+ h->root.u.def.section->output_section->vma
669
+ h->root.u.def.section->output_offset);
672
if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
673
symval += bfd_get_32 (abfd, contents + paddr);
675
symval += irelfn->r_addend;
677
/* See if this function call can be shortened. */
680
+ sec->output_section->vma
683
/* A branch to an address beyond ours might be increased by an
684
.align that doesn't move when bytes behind us are deleted.
685
So, we add some slop in this calculation to allow for
687
if (foff < -0x1000 || foff >= 0x1000 - 8)
689
/* After all that work, we can't shorten this function call. */
693
/* Shorten the function call. */
695
/* For simplicity of coding, we are going to modify the section
696
contents, the section relocs, and the BFD symbol table. We
697
must tell the rest of the code not to free up this
698
information. It would be possible to instead create a table
699
of changes which have to be made, as is done in coff-mips.c;
700
that would be more work, but would require less memory when
701
the linker is run. */
703
elf_section_data (sec)->relocs = internal_relocs;
704
elf_section_data (sec)->this_hdr.contents = contents;
705
symtab_hdr->contents = (unsigned char *) isymbuf;
707
/* Replace the jsr with a bsr. */
709
/* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
710
replace the jsr with a bsr. */
711
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
712
/* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
713
here, but that only checks if the symbol is an external symbol,
714
not if the symbol is in a different section. Besides, we need
715
a consistent meaning for the relocation, so we just assume here that
716
the value of the symbol is not available. */
718
/* We can't fully resolve this yet, because the external
719
symbol value may be changed by future relaxing. We let
720
the final link phase handle it. */
721
bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
725
/* When we calculated the symbol "value" we had an offset in the
726
DIR32's word in memory (we read and add it above). However,
727
the jsr we create does NOT have this offset encoded, so we
728
have to add it to the addend to preserve it. */
729
irel->r_addend += bfd_get_32 (abfd, contents + paddr);
731
/* See if there is another R_SH_USES reloc referring to the same
733
for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
734
if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
735
&& laddr == irelscan->r_offset + 4 + irelscan->r_addend)
737
if (irelscan < irelend)
739
/* Some other function call depends upon this register load,
740
and we have not yet converted that function call.
741
Indeed, we may never be able to convert it. There is
742
nothing else we can do at this point. */
746
/* Look for a R_SH_COUNT reloc on the location where the
747
function address is stored. Do this before deleting any
748
bytes, to avoid confusion about the address. */
749
for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
750
if (irelcount->r_offset == paddr
751
&& ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
754
/* Delete the register load. */
755
if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
758
/* That will change things, so, just in case it permits some
759
other function call to come within range, we should relax
760
again. Note that this is not required, and it may be slow. */
763
/* Now check whether we got a COUNT reloc. */
764
if (irelcount >= irelend)
766
((*_bfd_error_handler)
767
(_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
768
abfd, (unsigned long) paddr));
772
/* The number of uses is stored in the r_addend field. We've
774
if (irelcount->r_addend == 0)
776
((*_bfd_error_handler) (_("%B: 0x%lx: warning: bad count"),
778
(unsigned long) paddr));
782
--irelcount->r_addend;
784
/* If there are no more uses, we can delete the address. Reload
785
the address from irelfn, in case it was changed by the
786
previous call to sh_elf_relax_delete_bytes. */
787
if (irelcount->r_addend == 0)
789
if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
793
/* We've done all we can with that function call. */
796
/* Look for load and store instructions that we can align on four
798
if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
803
/* Get the section contents. */
804
if (contents == NULL)
806
if (elf_section_data (sec)->this_hdr.contents != NULL)
807
contents = elf_section_data (sec)->this_hdr.contents;
810
if (!bfd_malloc_and_get_section (abfd, sec, &contents))
815
if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
821
elf_section_data (sec)->relocs = internal_relocs;
822
elf_section_data (sec)->this_hdr.contents = contents;
823
symtab_hdr->contents = (unsigned char *) isymbuf;
828
&& symtab_hdr->contents != (unsigned char *) isymbuf)
830
if (! link_info->keep_memory)
834
/* Cache the symbols for elf_link_input_bfd. */
835
symtab_hdr->contents = (unsigned char *) isymbuf;
840
&& elf_section_data (sec)->this_hdr.contents != contents)
842
if (! link_info->keep_memory)
846
/* Cache the section contents for elf_link_input_bfd. */
847
elf_section_data (sec)->this_hdr.contents = contents;
851
if (internal_relocs != NULL
852
&& elf_section_data (sec)->relocs != internal_relocs)
853
free (internal_relocs);
859
&& symtab_hdr->contents != (unsigned char *) isymbuf)
862
&& elf_section_data (sec)->this_hdr.contents != contents)
864
if (internal_relocs != NULL
865
&& elf_section_data (sec)->relocs != internal_relocs)
866
free (internal_relocs);
871
/* Delete some bytes from a section while relaxing. FIXME: There is a
872
lot of duplication between this function and sh_relax_delete_bytes
876
sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr,
879
Elf_Internal_Shdr *symtab_hdr;
880
unsigned int sec_shndx;
882
Elf_Internal_Rela *irel, *irelend;
883
Elf_Internal_Rela *irelalign;
885
Elf_Internal_Sym *isymbuf, *isym, *isymend;
886
struct elf_link_hash_entry **sym_hashes;
887
struct elf_link_hash_entry **end_hashes;
888
unsigned int symcount;
891
symtab_hdr = &elf_symtab_hdr (abfd);
892
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
894
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
896
contents = elf_section_data (sec)->this_hdr.contents;
898
/* The deletion must stop at the next ALIGN reloc for an aligment
899
power larger than the number of bytes we are deleting. */
904
irel = elf_section_data (sec)->relocs;
905
irelend = irel + sec->reloc_count;
906
for (; irel < irelend; irel++)
908
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
909
&& irel->r_offset > addr
910
&& count < (1 << irel->r_addend))
913
toaddr = irel->r_offset;
918
/* Actually delete the bytes. */
919
memmove (contents + addr, contents + addr + count,
920
(size_t) (toaddr - addr - count));
921
if (irelalign == NULL)
927
#define NOP_OPCODE (0x0009)
929
BFD_ASSERT ((count & 1) == 0);
930
for (i = 0; i < count; i += 2)
931
bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
934
/* Adjust all the relocs. */
935
for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
937
bfd_vma nraddr, stop;
940
int off, adjust, oinsn;
941
bfd_signed_vma voff = 0;
942
bfd_boolean overflow;
944
/* Get the new reloc address. */
945
nraddr = irel->r_offset;
946
if ((irel->r_offset > addr
947
&& irel->r_offset < toaddr)
948
|| (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
949
&& irel->r_offset == toaddr))
952
/* See if this reloc was for the bytes we have deleted, in which
953
case we no longer care about it. Don't delete relocs which
954
represent addresses, though. */
955
if (irel->r_offset >= addr
956
&& irel->r_offset < addr + count
957
&& ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
958
&& ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
959
&& ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
960
&& ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
961
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
964
/* If this is a PC relative reloc, see if the range it covers
965
includes the bytes we have deleted. */
966
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
975
start = irel->r_offset;
976
insn = bfd_get_16 (abfd, contents + nraddr);
980
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
987
/* If this reloc is against a symbol defined in this
988
section, and the symbol will not be adjusted below, we
989
must check the addend to see it will put the value in
990
range to be adjusted, and hence must be changed. */
991
if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
993
isym = isymbuf + ELF32_R_SYM (irel->r_info);
994
if (isym->st_shndx == sec_shndx
995
&& (isym->st_value <= addr
996
|| isym->st_value >= toaddr))
1000
if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
1002
val = bfd_get_32 (abfd, contents + nraddr);
1003
val += isym->st_value;
1004
if (val > addr && val < toaddr)
1005
bfd_put_32 (abfd, val - count, contents + nraddr);
1009
val = isym->st_value + irel->r_addend;
1010
if (val > addr && val < toaddr)
1011
irel->r_addend -= count;
1015
start = stop = addr;
1022
stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1029
/* This has been made by previous relaxation. Since the
1030
relocation will be against an external symbol, the
1031
final relocation will just do the right thing. */
1032
start = stop = addr;
1038
stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1040
/* The addend will be against the section symbol, thus
1041
for adjusting the addend, the relevant start is the
1042
start of the section.
1043
N.B. If we want to abandon in-place changes here and
1044
test directly using symbol + addend, we have to take into
1045
account that the addend has already been adjusted by -4. */
1046
if (stop > addr && stop < toaddr)
1047
irel->r_addend -= count;
1053
stop = start + 4 + off * 2;
1058
stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1064
/* These relocs types represent
1066
The r_addend field holds the difference between the reloc
1067
address and L1. That is the start of the reloc, and
1068
adding in the contents gives us the top. We must adjust
1069
both the r_offset field and the section contents.
1070
N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1071
and the elf bfd r_offset is called r_vaddr. */
1073
stop = irel->r_offset;
1074
start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1078
&& (stop <= addr || stop >= toaddr))
1079
irel->r_addend += count;
1080
else if (stop > addr
1082
&& (start <= addr || start >= toaddr))
1083
irel->r_addend -= count;
1085
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1086
voff = bfd_get_signed_16 (abfd, contents + nraddr);
1087
else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1088
voff = bfd_get_8 (abfd, contents + nraddr);
1090
voff = bfd_get_signed_32 (abfd, contents + nraddr);
1091
stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1096
start = irel->r_offset;
1097
stop = (bfd_vma) ((bfd_signed_vma) start
1098
+ (long) irel->r_addend
1105
&& (stop <= addr || stop >= toaddr))
1107
else if (stop > addr
1109
&& (start <= addr || start >= toaddr))
1118
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1127
if ((oinsn & 0xff00) != (insn & 0xff00))
1129
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1134
if ((oinsn & 0xf000) != (insn & 0xf000))
1136
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1140
BFD_ASSERT (adjust == count || count >= 4);
1145
if ((irel->r_offset & 3) == 0)
1148
if ((oinsn & 0xff00) != (insn & 0xff00))
1150
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1155
if (voff < 0 || voff >= 0xff)
1157
bfd_put_8 (abfd, voff, contents + nraddr);
1162
if (voff < - 0x8000 || voff >= 0x8000)
1164
bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
1169
bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
1173
irel->r_addend += adjust;
1179
((*_bfd_error_handler)
1180
(_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1181
abfd, (unsigned long) irel->r_offset));
1182
bfd_set_error (bfd_error_bad_value);
1187
irel->r_offset = nraddr;
1190
/* Look through all the other sections. If there contain any IMM32
1191
relocs against internal symbols which we are not going to adjust
1192
below, we may need to adjust the addends. */
1193
for (o = abfd->sections; o != NULL; o = o->next)
1195
Elf_Internal_Rela *internal_relocs;
1196
Elf_Internal_Rela *irelscan, *irelscanend;
1197
bfd_byte *ocontents;
1200
|| (o->flags & SEC_RELOC) == 0
1201
|| o->reloc_count == 0)
1204
/* We always cache the relocs. Perhaps, if info->keep_memory is
1205
FALSE, we should free them, if we are permitted to, when we
1206
leave sh_coff_relax_section. */
1207
internal_relocs = (_bfd_elf_link_read_relocs
1208
(abfd, o, NULL, (Elf_Internal_Rela *) NULL, TRUE));
1209
if (internal_relocs == NULL)
1213
irelscanend = internal_relocs + o->reloc_count;
1214
for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1216
/* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1217
if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1219
bfd_vma start, stop;
1220
bfd_signed_vma voff;
1222
if (ocontents == NULL)
1224
if (elf_section_data (o)->this_hdr.contents != NULL)
1225
ocontents = elf_section_data (o)->this_hdr.contents;
1228
/* We always cache the section contents.
1229
Perhaps, if info->keep_memory is FALSE, we
1230
should free them, if we are permitted to,
1231
when we leave sh_coff_relax_section. */
1232
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1234
if (ocontents != NULL)
1239
elf_section_data (o)->this_hdr.contents = ocontents;
1243
stop = irelscan->r_offset;
1245
= (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1247
/* STOP is in a different section, so it won't change. */
1248
if (start > addr && start < toaddr)
1249
irelscan->r_addend += count;
1251
voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1252
stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1256
&& (stop <= addr || stop >= toaddr))
1257
bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
1258
ocontents + irelscan->r_offset);
1259
else if (stop > addr
1261
&& (start <= addr || start >= toaddr))
1262
bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
1263
ocontents + irelscan->r_offset);
1266
if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1269
if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1273
isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1274
if (isym->st_shndx == sec_shndx
1275
&& (isym->st_value <= addr
1276
|| isym->st_value >= toaddr))
1280
if (ocontents == NULL)
1282
if (elf_section_data (o)->this_hdr.contents != NULL)
1283
ocontents = elf_section_data (o)->this_hdr.contents;
1286
/* We always cache the section contents.
1287
Perhaps, if info->keep_memory is FALSE, we
1288
should free them, if we are permitted to,
1289
when we leave sh_coff_relax_section. */
1290
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1292
if (ocontents != NULL)
1297
elf_section_data (o)->this_hdr.contents = ocontents;
1301
val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1302
val += isym->st_value;
1303
if (val > addr && val < toaddr)
1304
bfd_put_32 (abfd, val - count,
1305
ocontents + irelscan->r_offset);
1310
/* Adjust the local symbols defined in this section. */
1311
isymend = isymbuf + symtab_hdr->sh_info;
1312
for (isym = isymbuf; isym < isymend; isym++)
1314
if (isym->st_shndx == sec_shndx
1315
&& isym->st_value > addr
1316
&& isym->st_value < toaddr)
1317
isym->st_value -= count;
1320
/* Now adjust the global symbols defined in this section. */
1321
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1322
- symtab_hdr->sh_info);
1323
sym_hashes = elf_sym_hashes (abfd);
1324
end_hashes = sym_hashes + symcount;
1325
for (; sym_hashes < end_hashes; sym_hashes++)
1327
struct elf_link_hash_entry *sym_hash = *sym_hashes;
1328
if ((sym_hash->root.type == bfd_link_hash_defined
1329
|| sym_hash->root.type == bfd_link_hash_defweak)
1330
&& sym_hash->root.u.def.section == sec
1331
&& sym_hash->root.u.def.value > addr
1332
&& sym_hash->root.u.def.value < toaddr)
1334
sym_hash->root.u.def.value -= count;
1338
/* See if we can move the ALIGN reloc forward. We have adjusted
1339
r_offset for it already. */
1340
if (irelalign != NULL)
1342
bfd_vma alignto, alignaddr;
1344
alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1345
alignaddr = BFD_ALIGN (irelalign->r_offset,
1346
1 << irelalign->r_addend);
1347
if (alignto != alignaddr)
1349
/* Tail recursion. */
1350
return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1351
(int) (alignto - alignaddr));
1358
/* Look for loads and stores which we can align to four byte
1359
boundaries. This is like sh_align_loads in coff-sh.c. */
1362
sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
1363
Elf_Internal_Rela *internal_relocs,
1364
bfd_byte *contents ATTRIBUTE_UNUSED,
1365
bfd_boolean *pswapped)
1367
Elf_Internal_Rela *irel, *irelend;
1368
bfd_vma *labels = NULL;
1369
bfd_vma *label, *label_end;
1374
irelend = internal_relocs + sec->reloc_count;
1376
/* Get all the addresses with labels on them. */
1377
amt = sec->reloc_count;
1378
amt *= sizeof (bfd_vma);
1379
labels = (bfd_vma *) bfd_malloc (amt);
1383
for (irel = internal_relocs; irel < irelend; irel++)
1385
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1387
*label_end = irel->r_offset;
1392
/* Note that the assembler currently always outputs relocs in
1393
address order. If that ever changes, this code will need to sort
1394
the label values and the relocs. */
1398
for (irel = internal_relocs; irel < irelend; irel++)
1400
bfd_vma start, stop;
1402
if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1405
start = irel->r_offset;
1407
for (irel++; irel < irelend; irel++)
1408
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1411
stop = irel->r_offset;
1415
if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1416
internal_relocs, &label,
1417
label_end, start, stop, pswapped))
1432
/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1435
sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs,
1436
bfd_byte *contents, bfd_vma addr)
1438
Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1439
unsigned short i1, i2;
1440
Elf_Internal_Rela *irel, *irelend;
1442
/* Swap the instructions themselves. */
1443
i1 = bfd_get_16 (abfd, contents + addr);
1444
i2 = bfd_get_16 (abfd, contents + addr + 2);
1445
bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
1446
bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
1448
/* Adjust all reloc addresses. */
1449
irelend = internal_relocs + sec->reloc_count;
1450
for (irel = internal_relocs; irel < irelend; irel++)
1452
enum elf_sh_reloc_type type;
1455
/* There are a few special types of relocs that we don't want to
1456
adjust. These relocs do not apply to the instruction itself,
1457
but are only associated with the address. */
1458
type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1459
if (type == R_SH_ALIGN
1460
|| type == R_SH_CODE
1461
|| type == R_SH_DATA
1462
|| type == R_SH_LABEL)
1465
/* If an R_SH_USES reloc points to one of the addresses being
1466
swapped, we must adjust it. It would be incorrect to do this
1467
for a jump, though, since we want to execute both
1468
instructions after the jump. (We have avoided swapping
1469
around a label, so the jump will not wind up executing an
1470
instruction it shouldn't). */
1471
if (type == R_SH_USES)
1475
off = irel->r_offset + 4 + irel->r_addend;
1477
irel->r_offset += 2;
1478
else if (off == addr + 2)
1479
irel->r_offset -= 2;
1482
if (irel->r_offset == addr)
1484
irel->r_offset += 2;
1487
else if (irel->r_offset == addr + 2)
1489
irel->r_offset -= 2;
1498
unsigned short insn, oinsn;
1499
bfd_boolean overflow;
1501
loc = contents + irel->r_offset;
1510
insn = bfd_get_16 (abfd, loc);
1513
if ((oinsn & 0xff00) != (insn & 0xff00))
1515
bfd_put_16 (abfd, (bfd_vma) insn, loc);
1519
insn = bfd_get_16 (abfd, loc);
1522
if ((oinsn & 0xf000) != (insn & 0xf000))
1524
bfd_put_16 (abfd, (bfd_vma) insn, loc);
1528
/* This reloc ignores the least significant 3 bits of
1529
the program counter before adding in the offset.
1530
This means that if ADDR is at an even address, the
1531
swap will not affect the offset. If ADDR is an at an
1532
odd address, then the instruction will be crossing a
1533
four byte boundary, and must be adjusted. */
1534
if ((addr & 3) != 0)
1536
insn = bfd_get_16 (abfd, loc);
1539
if ((oinsn & 0xff00) != (insn & 0xff00))
1541
bfd_put_16 (abfd, (bfd_vma) insn, loc);
1549
((*_bfd_error_handler)
1550
(_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1551
abfd, (unsigned long) irel->r_offset));
1552
bfd_set_error (bfd_error_bad_value);
1560
#endif /* defined SH64_ELF */
1562
/* Describes one of the various PLT styles. */
1564
struct elf_sh_plt_info
1566
/* The template for the first PLT entry, or NULL if there is no special
1568
const bfd_byte *plt0_entry;
1570
/* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1571
bfd_vma plt0_entry_size;
1573
/* Index I is the offset into PLT0_ENTRY of a pointer to
1574
_GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1575
if there is no such pointer. */
1576
bfd_vma plt0_got_fields[3];
1578
/* The template for a symbol's PLT entry. */
1579
const bfd_byte *symbol_entry;
1581
/* The size of SYMBOL_ENTRY in bytes. */
1582
bfd_vma symbol_entry_size;
1584
/* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1585
on all targets. The comments by each member indicate the value
1586
that the field must hold. */
1588
bfd_vma got_entry; /* the address of the symbol's .got.plt entry */
1589
bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */
1590
bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */
1591
bfd_boolean got20; /* TRUE if got_entry points to a movi20
1592
instruction (instead of a constant pool
1596
/* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1597
bfd_vma symbol_resolve_offset;
1599
/* A different PLT layout which can be used for the first
1600
MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1602
const struct elf_sh_plt_info *short_plt;
1605
#ifdef INCLUDE_SHMEDIA
1607
/* The size in bytes of an entry in the procedure linkage table. */
1609
#define ELF_PLT_ENTRY_SIZE 64
1611
/* First entry in an absolute procedure linkage table look like this. */
1613
static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1615
0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1616
0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1617
0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1618
0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1619
0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1620
0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1621
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1622
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1623
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1624
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1625
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1626
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1627
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1628
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1629
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1630
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1633
static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1635
0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1636
0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1637
0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1638
0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1639
0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1640
0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1641
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1642
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1643
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1644
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1645
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1646
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1647
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1648
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1649
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1650
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1653
/* Sebsequent entries in an absolute procedure linkage table look like
1656
static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1658
0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1659
0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1660
0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1661
0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1662
0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1663
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1664
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1665
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1666
0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1667
0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1668
0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1669
0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1670
0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1671
0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1672
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1673
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1676
static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1678
0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1679
0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1680
0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1681
0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1682
0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1683
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1684
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1685
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1686
0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1687
0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1688
0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1689
0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1690
0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1691
0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1692
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1693
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1696
/* Entries in a PIC procedure linkage table look like this. */
1698
static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1700
0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1701
0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1702
0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1703
0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1704
0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1705
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1706
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1707
0x6f, 0xf0, 0xff, 0xf0, /* nop */
1708
0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1709
0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1710
0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1711
0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1712
0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1713
0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1714
0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1715
0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1718
static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1720
0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1721
0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1722
0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1723
0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1724
0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1725
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1726
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1727
0xf0, 0xff, 0xf0, 0x6f, /* nop */
1728
0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1729
0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1730
0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1731
0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1732
0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1733
0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1734
0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1735
0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1738
static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1741
/* Big-endian non-PIC. */
1742
elf_sh_plt0_entry_be,
1744
{ 0, MINUS_ONE, MINUS_ONE },
1745
elf_sh_plt_entry_be,
1747
{ 0, 32, 48, FALSE },
1748
33, /* includes ISA encoding */
1752
/* Little-endian non-PIC. */
1753
elf_sh_plt0_entry_le,
1755
{ 0, MINUS_ONE, MINUS_ONE },
1756
elf_sh_plt_entry_le,
1758
{ 0, 32, 48, FALSE },
1759
33, /* includes ISA encoding */
1765
/* Big-endian PIC. */
1766
elf_sh_plt0_entry_be,
1768
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
1769
elf_sh_pic_plt_entry_be,
1771
{ 0, MINUS_ONE, 52, FALSE },
1772
33, /* includes ISA encoding */
1776
/* Little-endian PIC. */
1777
elf_sh_plt0_entry_le,
1779
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
1780
elf_sh_pic_plt_entry_le,
1782
{ 0, MINUS_ONE, 52, FALSE },
1783
33, /* includes ISA encoding */
1789
/* Return offset of the linker in PLT0 entry. */
1790
#define elf_sh_plt0_gotplt_offset(info) 0
1792
/* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1793
VALUE is the field's value and CODE_P is true if VALUE refers to code,
1796
On SH64, each 32-bit field is loaded by a movi/shori pair. */
1799
install_plt_field (bfd *output_bfd, bfd_boolean code_p,
1800
unsigned long value, bfd_byte *addr)
1803
bfd_put_32 (output_bfd,
1804
bfd_get_32 (output_bfd, addr)
1805
| ((value >> 6) & 0x3fffc00),
1807
bfd_put_32 (output_bfd,
1808
bfd_get_32 (output_bfd, addr + 4)
1809
| ((value << 10) & 0x3fffc00),
1813
/* Return the type of PLT associated with ABFD. PIC_P is true if
1814
the object is position-independent. */
1816
static const struct elf_sh_plt_info *
1817
get_plt_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean pic_p)
1819
return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
1822
/* The size in bytes of an entry in the procedure linkage table. */
1824
#define ELF_PLT_ENTRY_SIZE 28
1826
/* First entry in an absolute procedure linkage table look like this. */
1828
/* Note - this code has been "optimised" not to use r2. r2 is used by
1829
GCC to return the address of large structures, so it should not be
1830
corrupted here. This does mean however, that this PLT does not conform
1831
to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1832
and r2 contains the GOT id. This version stores the GOT id in r0 and
1833
ignores the type. Loaders can easily detect this difference however,
1834
since the type will always be 0 or 8, and the GOT ids will always be
1835
greater than or equal to 12. */
1836
static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1838
0xd0, 0x05, /* mov.l 2f,r0 */
1839
0x60, 0x02, /* mov.l @r0,r0 */
1840
0x2f, 0x06, /* mov.l r0,@-r15 */
1841
0xd0, 0x03, /* mov.l 1f,r0 */
1842
0x60, 0x02, /* mov.l @r0,r0 */
1843
0x40, 0x2b, /* jmp @r0 */
1844
0x60, 0xf6, /* mov.l @r15+,r0 */
1845
0x00, 0x09, /* nop */
1846
0x00, 0x09, /* nop */
1847
0x00, 0x09, /* nop */
1848
0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1849
0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1852
static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1854
0x05, 0xd0, /* mov.l 2f,r0 */
1855
0x02, 0x60, /* mov.l @r0,r0 */
1856
0x06, 0x2f, /* mov.l r0,@-r15 */
1857
0x03, 0xd0, /* mov.l 1f,r0 */
1858
0x02, 0x60, /* mov.l @r0,r0 */
1859
0x2b, 0x40, /* jmp @r0 */
1860
0xf6, 0x60, /* mov.l @r15+,r0 */
1861
0x09, 0x00, /* nop */
1862
0x09, 0x00, /* nop */
1863
0x09, 0x00, /* nop */
1864
0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1865
0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1868
/* Sebsequent entries in an absolute procedure linkage table look like
1871
static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1873
0xd0, 0x04, /* mov.l 1f,r0 */
1874
0x60, 0x02, /* mov.l @(r0,r12),r0 */
1875
0xd1, 0x02, /* mov.l 0f,r1 */
1876
0x40, 0x2b, /* jmp @r0 */
1877
0x60, 0x13, /* mov r1,r0 */
1878
0xd1, 0x03, /* mov.l 2f,r1 */
1879
0x40, 0x2b, /* jmp @r0 */
1880
0x00, 0x09, /* nop */
1881
0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1882
0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1883
0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1886
static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1888
0x04, 0xd0, /* mov.l 1f,r0 */
1889
0x02, 0x60, /* mov.l @r0,r0 */
1890
0x02, 0xd1, /* mov.l 0f,r1 */
1891
0x2b, 0x40, /* jmp @r0 */
1892
0x13, 0x60, /* mov r1,r0 */
1893
0x03, 0xd1, /* mov.l 2f,r1 */
1894
0x2b, 0x40, /* jmp @r0 */
1895
0x09, 0x00, /* nop */
1896
0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1897
0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1898
0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1901
/* Entries in a PIC procedure linkage table look like this. */
1903
static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1905
0xd0, 0x04, /* mov.l 1f,r0 */
1906
0x00, 0xce, /* mov.l @(r0,r12),r0 */
1907
0x40, 0x2b, /* jmp @r0 */
1908
0x00, 0x09, /* nop */
1909
0x50, 0xc2, /* mov.l @(8,r12),r0 */
1910
0xd1, 0x03, /* mov.l 2f,r1 */
1911
0x40, 0x2b, /* jmp @r0 */
1912
0x50, 0xc1, /* mov.l @(4,r12),r0 */
1913
0x00, 0x09, /* nop */
1914
0x00, 0x09, /* nop */
1915
0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1916
0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1919
static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1921
0x04, 0xd0, /* mov.l 1f,r0 */
1922
0xce, 0x00, /* mov.l @(r0,r12),r0 */
1923
0x2b, 0x40, /* jmp @r0 */
1924
0x09, 0x00, /* nop */
1925
0xc2, 0x50, /* mov.l @(8,r12),r0 */
1926
0x03, 0xd1, /* mov.l 2f,r1 */
1927
0x2b, 0x40, /* jmp @r0 */
1928
0xc1, 0x50, /* mov.l @(4,r12),r0 */
1929
0x09, 0x00, /* nop */
1930
0x09, 0x00, /* nop */
1931
0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1932
0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1935
static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1938
/* Big-endian non-PIC. */
1939
elf_sh_plt0_entry_be,
1941
{ MINUS_ONE, 24, 20 },
1942
elf_sh_plt_entry_be,
1944
{ 20, 16, 24, FALSE },
1949
/* Little-endian non-PIC. */
1950
elf_sh_plt0_entry_le,
1952
{ MINUS_ONE, 24, 20 },
1953
elf_sh_plt_entry_le,
1955
{ 20, 16, 24, FALSE },
1962
/* Big-endian PIC. */
1963
elf_sh_plt0_entry_be,
1965
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
1966
elf_sh_pic_plt_entry_be,
1968
{ 20, MINUS_ONE, 24, FALSE },
1973
/* Little-endian PIC. */
1974
elf_sh_plt0_entry_le,
1976
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
1977
elf_sh_pic_plt_entry_le,
1979
{ 20, MINUS_ONE, 24, FALSE },
1986
#define VXWORKS_PLT_HEADER_SIZE 12
1987
#define VXWORKS_PLT_ENTRY_SIZE 24
1989
static const bfd_byte vxworks_sh_plt0_entry_be[VXWORKS_PLT_HEADER_SIZE] =
1991
0xd1, 0x01, /* mov.l @(8,pc),r1 */
1992
0x61, 0x12, /* mov.l @r1,r1 */
1993
0x41, 0x2b, /* jmp @r1 */
1994
0x00, 0x09, /* nop */
1995
0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1998
static const bfd_byte vxworks_sh_plt0_entry_le[VXWORKS_PLT_HEADER_SIZE] =
2000
0x01, 0xd1, /* mov.l @(8,pc),r1 */
2001
0x12, 0x61, /* mov.l @r1,r1 */
2002
0x2b, 0x41, /* jmp @r1 */
2003
0x09, 0x00, /* nop */
2004
0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2007
static const bfd_byte vxworks_sh_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2009
0xd0, 0x01, /* mov.l @(8,pc),r0 */
2010
0x60, 0x02, /* mov.l @r0,r0 */
2011
0x40, 0x2b, /* jmp @r0 */
2012
0x00, 0x09, /* nop */
2013
0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2014
0xd0, 0x01, /* mov.l @(8,pc),r0 */
2015
0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
2016
0x00, 0x09, /* nop */
2017
0x00, 0x09, /* nop */
2018
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2021
static const bfd_byte vxworks_sh_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2023
0x01, 0xd0, /* mov.l @(8,pc),r0 */
2024
0x02, 0x60, /* mov.l @r0,r0 */
2025
0x2b, 0x40, /* jmp @r0 */
2026
0x09, 0x00, /* nop */
2027
0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2028
0x01, 0xd0, /* mov.l @(8,pc),r0 */
2029
0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
2030
0x09, 0x00, /* nop */
2031
0x09, 0x00, /* nop */
2032
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2035
static const bfd_byte vxworks_sh_pic_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2037
0xd0, 0x01, /* mov.l @(8,pc),r0 */
2038
0x00, 0xce, /* mov.l @(r0,r12),r0 */
2039
0x40, 0x2b, /* jmp @r0 */
2040
0x00, 0x09, /* nop */
2041
0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2042
0xd0, 0x01, /* mov.l @(8,pc),r0 */
2043
0x51, 0xc2, /* mov.l @(8,r12),r1 */
2044
0x41, 0x2b, /* jmp @r1 */
2045
0x00, 0x09, /* nop */
2046
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2049
static const bfd_byte vxworks_sh_pic_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2051
0x01, 0xd0, /* mov.l @(8,pc),r0 */
2052
0xce, 0x00, /* mov.l @(r0,r12),r0 */
2053
0x2b, 0x40, /* jmp @r0 */
2054
0x09, 0x00, /* nop */
2055
0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2056
0x01, 0xd0, /* mov.l @(8,pc),r0 */
2057
0xc2, 0x51, /* mov.l @(8,r12),r1 */
2058
0x2b, 0x41, /* jmp @r1 */
2059
0x09, 0x00, /* nop */
2060
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2063
static const struct elf_sh_plt_info vxworks_sh_plts[2][2] = {
2066
/* Big-endian non-PIC. */
2067
vxworks_sh_plt0_entry_be,
2068
VXWORKS_PLT_HEADER_SIZE,
2069
{ MINUS_ONE, MINUS_ONE, 8 },
2070
vxworks_sh_plt_entry_be,
2071
VXWORKS_PLT_ENTRY_SIZE,
2072
{ 8, 14, 20, FALSE },
2077
/* Little-endian non-PIC. */
2078
vxworks_sh_plt0_entry_le,
2079
VXWORKS_PLT_HEADER_SIZE,
2080
{ MINUS_ONE, MINUS_ONE, 8 },
2081
vxworks_sh_plt_entry_le,
2082
VXWORKS_PLT_ENTRY_SIZE,
2083
{ 8, 14, 20, FALSE },
2090
/* Big-endian PIC. */
2093
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2094
vxworks_sh_pic_plt_entry_be,
2095
VXWORKS_PLT_ENTRY_SIZE,
2096
{ 8, MINUS_ONE, 20, FALSE },
2101
/* Little-endian PIC. */
2104
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2105
vxworks_sh_pic_plt_entry_le,
2106
VXWORKS_PLT_ENTRY_SIZE,
2107
{ 8, MINUS_ONE, 20, FALSE },
2114
/* FDPIC PLT entries. Two unimplemented optimizations for lazy
2115
binding are to omit the lazy binding stub when linking with -z now
2116
and to move lazy binding stubs into a separate region for better
2119
#define FDPIC_PLT_ENTRY_SIZE 28
2120
#define FDPIC_PLT_LAZY_OFFSET 20
2122
/* FIXME: The lazy binding stub requires a plt0 - which may need to be
2123
duplicated if it is out of range, or which can be inlined. So
2124
right now it is always inlined, which wastes a word per stub. It
2125
might be easier to handle the duplication if we put the lazy
2126
stubs separately. */
2128
static const bfd_byte fdpic_sh_plt_entry_be[FDPIC_PLT_ENTRY_SIZE] =
2130
0xd0, 0x02, /* mov.l @(12,pc),r0 */
2131
0x01, 0xce, /* mov.l @(r0,r12),r1 */
2132
0x70, 0x04, /* add #4, r0 */
2133
0x41, 0x2b, /* jmp @r1 */
2134
0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2135
0x00, 0x09, /* nop */
2136
0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2137
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2138
0x60, 0xc2, /* mov.l @r12,r0 */
2139
0x40, 0x2b, /* jmp @r0 */
2140
0x53, 0xc1, /* mov.l @(4,r12),r3 */
2141
0x00, 0x09, /* nop */
2144
static const bfd_byte fdpic_sh_plt_entry_le[FDPIC_PLT_ENTRY_SIZE] =
2146
0x02, 0xd0, /* mov.l @(12,pc),r0 */
2147
0xce, 0x01, /* mov.l @(r0,r12),r1 */
2148
0x04, 0x70, /* add #4, r0 */
2149
0x2b, 0x41, /* jmp @r1 */
2150
0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2151
0x09, 0x00, /* nop */
2152
0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2153
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2154
0xc2, 0x60, /* mov.l @r12,r0 */
2155
0x2b, 0x40, /* jmp @r0 */
2156
0xc1, 0x53, /* mov.l @(4,r12),r3 */
2157
0x09, 0x00, /* nop */
2160
static const struct elf_sh_plt_info fdpic_sh_plts[2] = {
2162
/* Big-endian PIC. */
2165
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2166
fdpic_sh_plt_entry_be,
2167
FDPIC_PLT_ENTRY_SIZE,
2168
{ 12, MINUS_ONE, 16, FALSE },
2169
FDPIC_PLT_LAZY_OFFSET,
2173
/* Little-endian PIC. */
2176
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2177
fdpic_sh_plt_entry_le,
2178
FDPIC_PLT_ENTRY_SIZE,
2179
{ 12, MINUS_ONE, 16, FALSE },
2180
FDPIC_PLT_LAZY_OFFSET,
2185
/* On SH2A, we can use the movi20 instruction to generate shorter PLT
2186
entries for the first 64K slots. We use the normal FDPIC PLT entry
2187
past that point; we could also use movi20s, which might be faster,
2188
but would not be any smaller. */
2190
#define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2191
#define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2193
static const bfd_byte fdpic_sh2a_plt_entry_be[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2195
0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2196
0x01, 0xce, /* mov.l @(r0,r12),r1 */
2197
0x70, 0x04, /* add #4, r0 */
2198
0x41, 0x2b, /* jmp @r1 */
2199
0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2200
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2201
0x60, 0xc2, /* mov.l @r12,r0 */
2202
0x40, 0x2b, /* jmp @r0 */
2203
0x53, 0xc1, /* mov.l @(4,r12),r3 */
2204
0x00, 0x09, /* nop */
2207
static const bfd_byte fdpic_sh2a_plt_entry_le[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2209
0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2210
0xce, 0x01, /* mov.l @(r0,r12),r1 */
2211
0x04, 0x70, /* add #4, r0 */
2212
0x2b, 0x41, /* jmp @r1 */
2213
0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2214
0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2215
0xc2, 0x60, /* mov.l @r12,r0 */
2216
0x2b, 0x40, /* jmp @r0 */
2217
0xc1, 0x53, /* mov.l @(4,r12),r3 */
2218
0x09, 0x00, /* nop */
2221
static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be = {
2222
/* Big-endian FDPIC, max index 64K. */
2225
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2226
fdpic_sh2a_plt_entry_be,
2227
FDPIC_SH2A_PLT_ENTRY_SIZE,
2228
{ 0, MINUS_ONE, 12, TRUE },
2229
FDPIC_SH2A_PLT_LAZY_OFFSET,
2233
static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le = {
2234
/* Little-endian FDPIC, max index 64K. */
2237
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2238
fdpic_sh2a_plt_entry_le,
2239
FDPIC_SH2A_PLT_ENTRY_SIZE,
2240
{ 0, MINUS_ONE, 12, TRUE },
2241
FDPIC_SH2A_PLT_LAZY_OFFSET,
2245
static const struct elf_sh_plt_info fdpic_sh2a_plts[2] = {
2247
/* Big-endian PIC. */
2250
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2251
fdpic_sh_plt_entry_be,
2252
FDPIC_PLT_ENTRY_SIZE,
2253
{ 12, MINUS_ONE, 16, FALSE },
2254
FDPIC_PLT_LAZY_OFFSET,
2255
&fdpic_sh2a_short_plt_be
2258
/* Little-endian PIC. */
2261
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
2262
fdpic_sh_plt_entry_le,
2263
FDPIC_PLT_ENTRY_SIZE,
2264
{ 12, MINUS_ONE, 16, FALSE },
2265
FDPIC_PLT_LAZY_OFFSET,
2266
&fdpic_sh2a_short_plt_le
2270
/* Return the type of PLT associated with ABFD. PIC_P is true if
2271
the object is position-independent. */
2273
static const struct elf_sh_plt_info *
2274
get_plt_info (bfd *abfd, bfd_boolean pic_p)
2276
if (fdpic_object_p (abfd))
2278
/* If any input file requires SH2A we can use a shorter PLT
2280
if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd)) & arch_sh2a_base)
2281
return &fdpic_sh2a_plts[!bfd_big_endian (abfd)];
2283
return &fdpic_sh_plts[!bfd_big_endian (abfd)];
2285
if (vxworks_object_p (abfd))
2286
return &vxworks_sh_plts[pic_p][!bfd_big_endian (abfd)];
2287
return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
2290
/* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2291
VALUE is the field's value and CODE_P is true if VALUE refers to code,
2295
install_plt_field (bfd *output_bfd, bfd_boolean code_p ATTRIBUTE_UNUSED,
2296
unsigned long value, bfd_byte *addr)
2298
bfd_put_32 (output_bfd, value, addr);
2302
/* The number of PLT entries which can use a shorter PLT, if any.
2303
Currently always 64K, since only SH-2A FDPIC uses this; a
2304
20-bit movi20 can address that many function descriptors below
2305
_GLOBAL_OFFSET_TABLE_. */
2306
#define MAX_SHORT_PLT 65536
2308
/* Return the index of the PLT entry at byte offset OFFSET. */
2311
get_plt_index (const struct elf_sh_plt_info *info, bfd_vma offset)
2313
bfd_vma plt_index = 0;
2315
offset -= info->plt0_entry_size;
2316
if (info->short_plt != NULL)
2318
if (offset > MAX_SHORT_PLT * info->short_plt->symbol_entry_size)
2320
plt_index = MAX_SHORT_PLT;
2321
offset -= MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2324
info = info->short_plt;
2326
return plt_index + offset / info->symbol_entry_size;
2329
/* Do the inverse operation. */
2332
get_plt_offset (const struct elf_sh_plt_info *info, bfd_vma plt_index)
2336
if (info->short_plt != NULL)
2338
if (plt_index > MAX_SHORT_PLT)
2340
offset = MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2341
plt_index -= MAX_SHORT_PLT;
2344
info = info->short_plt;
2346
return (offset + info->plt0_entry_size
2347
+ (plt_index * info->symbol_entry_size));
2350
/* The sh linker needs to keep track of the number of relocs that it
2351
decides to copy as dynamic relocs in check_relocs for each symbol.
2352
This is so that it can later discard them if they are found to be
2353
unnecessary. We store the information in a field extending the
2354
regular ELF linker hash table. */
2356
struct elf_sh_dyn_relocs
2358
struct elf_sh_dyn_relocs *next;
2360
/* The input section of the reloc. */
2363
/* Total number of relocs copied for the input section. */
2364
bfd_size_type count;
2366
/* Number of pc-relative relocs copied for the input section. */
2367
bfd_size_type pc_count;
2372
bfd_signed_vma refcount;
2376
/* sh ELF linker hash entry. */
2378
struct elf_sh_link_hash_entry
2380
struct elf_link_hash_entry root;
2382
#ifdef INCLUDE_SHMEDIA
2385
bfd_signed_vma refcount;
2390
/* Track dynamic relocs copied for this symbol. */
2391
struct elf_sh_dyn_relocs *dyn_relocs;
2393
bfd_signed_vma gotplt_refcount;
2395
/* A local function descriptor, for FDPIC. The refcount counts
2396
R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2397
relocations; the PLT and GOT entry are accounted
2398
for separately. After adjust_dynamic_symbol, the offset is
2399
MINUS_ONE if there is no local descriptor (dynamic linker
2400
managed and no PLT entry, or undefined weak non-dynamic).
2401
During check_relocs we do not yet know whether the local
2402
descriptor will be canonical. */
2403
union gotref funcdesc;
2405
/* How many of the above refcounted relocations were R_SH_FUNCDESC,
2406
and thus require fixups or relocations. */
2407
bfd_signed_vma abs_funcdesc_refcount;
2410
GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC
2414
#define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2416
struct sh_elf_obj_tdata
2418
struct elf_obj_tdata root;
2420
/* got_type for each local got entry. */
2421
char *local_got_type;
2423
/* Function descriptor refcount and offset for each local symbol. */
2424
union gotref *local_funcdesc;
2427
#define sh_elf_tdata(abfd) \
2428
((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2430
#define sh_elf_local_got_type(abfd) \
2431
(sh_elf_tdata (abfd)->local_got_type)
2433
#define sh_elf_local_funcdesc(abfd) \
2434
(sh_elf_tdata (abfd)->local_funcdesc)
2436
#define is_sh_elf(bfd) \
2437
(bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2438
&& elf_tdata (bfd) != NULL \
2439
&& elf_object_id (bfd) == SH_ELF_DATA)
2441
/* Override the generic function because we need to store sh_elf_obj_tdata
2442
as the specific tdata. */
2445
sh_elf_mkobject (bfd *abfd)
2447
return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata),
2451
/* sh ELF linker hash table. */
2453
struct elf_sh_link_hash_table
2455
struct elf_link_hash_table root;
2457
/* Short-cuts to get to dynamic linker sections. */
2465
asection *sfuncdesc;
2466
asection *srelfuncdesc;
2469
/* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2472
/* Small local sym cache. */
2473
struct sym_cache sym_cache;
2475
/* A counter or offset to track a TLS got entry. */
2478
bfd_signed_vma refcount;
2482
/* The type of PLT to use. */
2483
const struct elf_sh_plt_info *plt_info;
2485
/* True if the target system is VxWorks. */
2486
bfd_boolean vxworks_p;
2488
/* True if the target system uses FDPIC. */
2489
bfd_boolean fdpic_p;
2492
/* Traverse an sh ELF linker hash table. */
2494
#define sh_elf_link_hash_traverse(table, func, info) \
2495
(elf_link_hash_traverse \
2497
(bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2500
/* Get the sh ELF linker hash table from a link_info structure. */
2502
#define sh_elf_hash_table(p) \
2503
(elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2504
== SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2506
/* Create an entry in an sh ELF linker hash table. */
2508
static struct bfd_hash_entry *
2509
sh_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2510
struct bfd_hash_table *table,
2513
struct elf_sh_link_hash_entry *ret =
2514
(struct elf_sh_link_hash_entry *) entry;
2516
/* Allocate the structure if it has not already been allocated by a
2518
if (ret == (struct elf_sh_link_hash_entry *) NULL)
2519
ret = ((struct elf_sh_link_hash_entry *)
2520
bfd_hash_allocate (table,
2521
sizeof (struct elf_sh_link_hash_entry)));
2522
if (ret == (struct elf_sh_link_hash_entry *) NULL)
2523
return (struct bfd_hash_entry *) ret;
2525
/* Call the allocation method of the superclass. */
2526
ret = ((struct elf_sh_link_hash_entry *)
2527
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2529
if (ret != (struct elf_sh_link_hash_entry *) NULL)
2531
ret->dyn_relocs = NULL;
2532
ret->gotplt_refcount = 0;
2533
#ifdef INCLUDE_SHMEDIA
2534
ret->datalabel_got.refcount = ret->root.got.refcount;
2536
ret->funcdesc.refcount = 0;
2537
ret->abs_funcdesc_refcount = 0;
2538
ret->got_type = GOT_UNKNOWN;
2541
return (struct bfd_hash_entry *) ret;
2544
/* Create an sh ELF linker hash table. */
2546
static struct bfd_link_hash_table *
2547
sh_elf_link_hash_table_create (bfd *abfd)
2549
struct elf_sh_link_hash_table *ret;
2550
bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
2552
ret = (struct elf_sh_link_hash_table *) bfd_zmalloc (amt);
2553
if (ret == (struct elf_sh_link_hash_table *) NULL)
2556
if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
2557
sh_elf_link_hash_newfunc,
2558
sizeof (struct elf_sh_link_hash_entry),
2565
ret->vxworks_p = vxworks_object_p (abfd);
2566
ret->fdpic_p = fdpic_object_p (abfd);
2568
return &ret->root.root;
2572
sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2573
struct bfd_link_info *info, asection *p)
2575
struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
2577
/* Non-FDPIC binaries do not need dynamic symbols for sections. */
2581
/* We need dynamic symbols for every section, since segments can
2582
relocate independently. */
2583
switch (elf_section_data (p)->this_hdr.sh_type)
2587
/* If sh_type is yet undecided, assume it could be
2588
SHT_PROGBITS/SHT_NOBITS. */
2592
/* There shouldn't be section relative relocations
2593
against any other section. */
2599
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2600
shortcuts to them in our hash table. */
2603
create_got_section (bfd *dynobj, struct bfd_link_info *info)
2605
struct elf_sh_link_hash_table *htab;
2607
if (! _bfd_elf_create_got_section (dynobj, info))
2610
htab = sh_elf_hash_table (info);
2614
htab->sgot = bfd_get_linker_section (dynobj, ".got");
2615
htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
2616
htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2617
if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
2620
htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
2621
(SEC_ALLOC | SEC_LOAD
2624
| SEC_LINKER_CREATED));
2625
if (htab->sfuncdesc == NULL
2626
|| ! bfd_set_section_alignment (dynobj, htab->sfuncdesc, 2))
2629
htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
2630
".rela.got.funcdesc",
2631
(SEC_ALLOC | SEC_LOAD
2634
| SEC_LINKER_CREATED
2636
if (htab->srelfuncdesc == NULL
2637
|| ! bfd_set_section_alignment (dynobj, htab->srelfuncdesc, 2))
2640
/* Also create .rofixup. */
2641
htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
2642
(SEC_ALLOC | SEC_LOAD
2645
| SEC_LINKER_CREATED
2647
if (htab->srofixup == NULL
2648
|| ! bfd_set_section_alignment (dynobj, htab->srofixup, 2))
2654
/* Create dynamic sections when linking against a dynamic object. */
2657
sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2659
struct elf_sh_link_hash_table *htab;
2660
flagword flags, pltflags;
2662
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2665
switch (bed->s->arch_size)
2676
bfd_set_error (bfd_error_bad_value);
2680
htab = sh_elf_hash_table (info);
2684
if (htab->root.dynamic_sections_created)
2687
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2688
.rel[a].bss sections. */
2690
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2691
| SEC_LINKER_CREATED);
2694
pltflags |= SEC_CODE;
2695
if (bed->plt_not_loaded)
2696
pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2697
if (bed->plt_readonly)
2698
pltflags |= SEC_READONLY;
2700
s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2703
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2706
if (bed->want_plt_sym)
2708
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2710
struct elf_link_hash_entry *h;
2711
struct bfd_link_hash_entry *bh = NULL;
2713
if (! (_bfd_generic_link_add_one_symbol
2714
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2715
(bfd_vma) 0, (const char *) NULL, FALSE,
2716
get_elf_backend_data (abfd)->collect, &bh)))
2719
h = (struct elf_link_hash_entry *) bh;
2721
h->type = STT_OBJECT;
2722
htab->root.hplt = h;
2725
&& ! bfd_elf_link_record_dynamic_symbol (info, h))
2729
s = bfd_make_section_anyway_with_flags (abfd,
2730
bed->default_use_rela_p
2731
? ".rela.plt" : ".rel.plt",
2732
flags | SEC_READONLY);
2735
|| ! bfd_set_section_alignment (abfd, s, ptralign))
2738
if (htab->sgot == NULL
2739
&& !create_got_section (abfd, info))
2742
if (bed->want_dynbss)
2744
/* The .dynbss section is a place to put symbols which are defined
2745
by dynamic objects, are referenced by regular objects, and are
2746
not functions. We must allocate space for them in the process
2747
image and use a R_*_COPY reloc to tell the dynamic linker to
2748
initialize them at run time. The linker script puts the .dynbss
2749
section into the .bss section of the final image. */
2750
s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2751
SEC_ALLOC | SEC_LINKER_CREATED);
2756
/* The .rel[a].bss section holds copy relocs. This section is not
2757
normally needed. We need to create it here, though, so that the
2758
linker will map it to an output section. We can't just create it
2759
only if we need it, because we will not know whether we need it
2760
until we have seen all the input files, and the first time the
2761
main linker code calls BFD after examining all the input files
2762
(size_dynamic_sections) the input sections have already been
2763
mapped to the output sections. If the section turns out not to
2764
be needed, we can discard it later. We will never need this
2765
section when generating a shared object, since they do not use
2769
s = bfd_make_section_anyway_with_flags (abfd,
2770
(bed->default_use_rela_p
2771
? ".rela.bss" : ".rel.bss"),
2772
flags | SEC_READONLY);
2775
|| ! bfd_set_section_alignment (abfd, s, ptralign))
2780
if (htab->vxworks_p)
2782
if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2789
/* Adjust a symbol defined by a dynamic object and referenced by a
2790
regular object. The current definition is in some section of the
2791
dynamic object, but we're not including those sections. We have to
2792
change the definition to something the rest of the link can
2796
sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2797
struct elf_link_hash_entry *h)
2799
struct elf_sh_link_hash_table *htab;
2800
struct elf_sh_link_hash_entry *eh;
2801
struct elf_sh_dyn_relocs *p;
2804
htab = sh_elf_hash_table (info);
2808
/* Make sure we know what is going on here. */
2809
BFD_ASSERT (htab->root.dynobj != NULL
2811
|| h->u.weakdef != NULL
2814
&& !h->def_regular)));
2816
/* If this is a function, put it in the procedure linkage table. We
2817
will fill in the contents of the procedure linkage table later,
2818
when we know the address of the .got section. */
2819
if (h->type == STT_FUNC
2822
if (h->plt.refcount <= 0
2823
|| SYMBOL_CALLS_LOCAL (info, h)
2824
|| (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2825
&& h->root.type == bfd_link_hash_undefweak))
2827
/* This case can occur if we saw a PLT reloc in an input
2828
file, but the symbol was never referred to by a dynamic
2829
object. In such a case, we don't actually need to build
2830
a procedure linkage table, and we can just do a REL32
2832
h->plt.offset = (bfd_vma) -1;
2839
h->plt.offset = (bfd_vma) -1;
2841
/* If this is a weak symbol, and there is a real definition, the
2842
processor independent code will have arranged for us to see the
2843
real definition first, and we can just use the same value. */
2844
if (h->u.weakdef != NULL)
2846
BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2847
|| h->u.weakdef->root.type == bfd_link_hash_defweak);
2848
h->root.u.def.section = h->u.weakdef->root.u.def.section;
2849
h->root.u.def.value = h->u.weakdef->root.u.def.value;
2850
if (info->nocopyreloc)
2851
h->non_got_ref = h->u.weakdef->non_got_ref;
2855
/* This is a reference to a symbol defined by a dynamic object which
2856
is not a function. */
2858
/* If we are creating a shared library, we must presume that the
2859
only references to the symbol are via the global offset table.
2860
For such cases we need not do anything here; the relocations will
2861
be handled correctly by relocate_section. */
2865
/* If there are no references to this symbol that do not use the
2866
GOT, we don't need to generate a copy reloc. */
2867
if (!h->non_got_ref)
2870
/* If -z nocopyreloc was given, we won't generate them either. */
2871
if (info->nocopyreloc)
2877
eh = (struct elf_sh_link_hash_entry *) h;
2878
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2880
s = p->sec->output_section;
2881
if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
2885
/* If we didn't find any dynamic relocs in sections which needs the
2886
copy reloc, then we'll be keeping the dynamic relocs and avoiding
2894
/* We must allocate the symbol in our .dynbss section, which will
2895
become part of the .bss section of the executable. There will be
2896
an entry for this symbol in the .dynsym section. The dynamic
2897
object will contain position independent code, so all references
2898
from the dynamic object to this symbol will go through the global
2899
offset table. The dynamic linker will use the .dynsym entry to
2900
determine the address it must put in the global offset table, so
2901
both the dynamic object and the regular object will refer to the
2902
same memory location for the variable. */
2905
BFD_ASSERT (s != NULL);
2907
/* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2908
copy the initial value out of the dynamic object and into the
2909
runtime process image. We need to remember the offset into the
2910
.rela.bss section we are going to use. */
2911
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2915
srel = htab->srelbss;
2916
BFD_ASSERT (srel != NULL);
2917
srel->size += sizeof (Elf32_External_Rela);
2921
return _bfd_elf_adjust_dynamic_copy (h, s);
2924
/* Allocate space in .plt, .got and associated reloc sections for
2928
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2930
struct bfd_link_info *info;
2931
struct elf_sh_link_hash_table *htab;
2932
struct elf_sh_link_hash_entry *eh;
2933
struct elf_sh_dyn_relocs *p;
2935
if (h->root.type == bfd_link_hash_indirect)
2938
info = (struct bfd_link_info *) inf;
2939
htab = sh_elf_hash_table (info);
2943
eh = (struct elf_sh_link_hash_entry *) h;
2944
if ((h->got.refcount > 0
2946
&& eh->gotplt_refcount > 0)
2948
/* The symbol has been forced local, or we have some direct got refs,
2949
so treat all the gotplt refs as got refs. */
2950
h->got.refcount += eh->gotplt_refcount;
2951
if (h->plt.refcount >= eh->gotplt_refcount)
2952
h->plt.refcount -= eh->gotplt_refcount;
2955
if (htab->root.dynamic_sections_created
2956
&& h->plt.refcount > 0
2957
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2958
|| h->root.type != bfd_link_hash_undefweak))
2960
/* Make sure this symbol is output as a dynamic symbol.
2961
Undefined weak syms won't yet be marked as dynamic. */
2962
if (h->dynindx == -1
2963
&& !h->forced_local)
2965
if (! bfd_elf_link_record_dynamic_symbol (info, h))
2970
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2972
asection *s = htab->splt;
2973
const struct elf_sh_plt_info *plt_info;
2975
/* If this is the first .plt entry, make room for the special
2978
s->size += htab->plt_info->plt0_entry_size;
2980
h->plt.offset = s->size;
2982
/* If this symbol is not defined in a regular file, and we are
2983
not generating a shared library, then set the symbol to this
2984
location in the .plt. This is required to make function
2985
pointers compare as equal between the normal executable and
2986
the shared library. Skip this for FDPIC, since the
2987
function's address will be the address of the canonical
2988
function descriptor. */
2989
if (!htab->fdpic_p && !info->shared && !h->def_regular)
2991
h->root.u.def.section = s;
2992
h->root.u.def.value = h->plt.offset;
2995
/* Make room for this entry. */
2996
plt_info = htab->plt_info;
2997
if (plt_info->short_plt != NULL
2998
&& (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT))
2999
plt_info = plt_info->short_plt;
3000
s->size += plt_info->symbol_entry_size;
3002
/* We also need to make an entry in the .got.plt section, which
3003
will be placed in the .got section by the linker script. */
3005
htab->sgotplt->size += 4;
3007
htab->sgotplt->size += 8;
3009
/* We also need to make an entry in the .rel.plt section. */
3010
htab->srelplt->size += sizeof (Elf32_External_Rela);
3012
if (htab->vxworks_p && !info->shared)
3014
/* VxWorks executables have a second set of relocations
3015
for each PLT entry. They go in a separate relocation
3016
section, which is processed by the kernel loader. */
3018
/* There is a relocation for the initial PLT entry:
3019
an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3020
if (h->plt.offset == htab->plt_info->plt0_entry_size)
3021
htab->srelplt2->size += sizeof (Elf32_External_Rela);
3023
/* There are two extra relocations for each subsequent
3024
PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3025
and an R_SH_DIR32 relocation for the PLT entry. */
3026
htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2;
3031
h->plt.offset = (bfd_vma) -1;
3037
h->plt.offset = (bfd_vma) -1;
3041
if (h->got.refcount > 0)
3045
enum got_type got_type = sh_elf_hash_entry (h)->got_type;
3047
/* Make sure this symbol is output as a dynamic symbol.
3048
Undefined weak syms won't yet be marked as dynamic. */
3049
if (h->dynindx == -1
3050
&& !h->forced_local)
3052
if (! bfd_elf_link_record_dynamic_symbol (info, h))
3057
h->got.offset = s->size;
3059
/* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3060
if (got_type == GOT_TLS_GD)
3062
dyn = htab->root.dynamic_sections_created;
3065
/* No dynamic relocations required. */
3066
if (htab->fdpic_p && !info->shared
3067
&& h->root.type != bfd_link_hash_undefweak
3068
&& (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
3069
htab->srofixup->size += 4;
3071
/* No dynamic relocations required when IE->LE conversion happens. */
3072
else if (got_type == GOT_TLS_IE && !h->def_dynamic && !info->shared)
3074
/* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3075
R_SH_TLS_GD needs one if local symbol and two if global. */
3076
else if ((got_type == GOT_TLS_GD && h->dynindx == -1)
3077
|| got_type == GOT_TLS_IE)
3078
htab->srelgot->size += sizeof (Elf32_External_Rela);
3079
else if (got_type == GOT_TLS_GD)
3080
htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
3081
else if (got_type == GOT_FUNCDESC)
3083
if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
3084
htab->srofixup->size += 4;
3086
htab->srelgot->size += sizeof (Elf32_External_Rela);
3088
else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3089
|| h->root.type != bfd_link_hash_undefweak)
3091
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3092
htab->srelgot->size += sizeof (Elf32_External_Rela);
3093
else if (htab->fdpic_p && !info->shared && got_type == GOT_NORMAL
3094
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3095
|| h->root.type != bfd_link_hash_undefweak))
3096
htab->srofixup->size += 4;
3099
h->got.offset = (bfd_vma) -1;
3101
#ifdef INCLUDE_SHMEDIA
3102
if (eh->datalabel_got.refcount > 0)
3107
/* Make sure this symbol is output as a dynamic symbol.
3108
Undefined weak syms won't yet be marked as dynamic. */
3109
if (h->dynindx == -1
3110
&& !h->forced_local)
3112
if (! bfd_elf_link_record_dynamic_symbol (info, h))
3117
eh->datalabel_got.offset = s->size;
3119
dyn = htab->root.dynamic_sections_created;
3120
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
3121
htab->srelgot->size += sizeof (Elf32_External_Rela);
3124
eh->datalabel_got.offset = (bfd_vma) -1;
3127
/* Allocate space for any dynamic relocations to function
3128
descriptors, canonical or otherwise. We need to relocate the
3129
reference unless it resolves to zero, which only happens for
3130
undefined weak symbols (either non-default visibility, or when
3131
static linking). Any GOT slot is accounted for elsewhere. */
3132
if (eh->abs_funcdesc_refcount > 0
3133
&& (h->root.type != bfd_link_hash_undefweak
3134
|| (htab->root.dynamic_sections_created
3135
&& ! SYMBOL_CALLS_LOCAL (info, h))))
3137
if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
3138
htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
3141
+= eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
3144
/* We must allocate a function descriptor if there are references to
3145
a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3146
the dynamic linker isn't going to allocate it. None of this
3147
applies if we already created one in .got.plt, but if the
3148
canonical function descriptor can be in this object, there
3149
won't be a PLT entry at all. */
3150
if ((eh->funcdesc.refcount > 0
3151
|| (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC))
3152
&& h->root.type != bfd_link_hash_undefweak
3153
&& SYMBOL_FUNCDESC_LOCAL (info, h))
3155
/* Make room for this function descriptor. */
3156
eh->funcdesc.offset = htab->sfuncdesc->size;
3157
htab->sfuncdesc->size += 8;
3159
/* We will need a relocation or two fixups to initialize the
3160
function descriptor, so allocate those too. */
3161
if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
3162
htab->srofixup->size += 8;
3164
htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3167
if (eh->dyn_relocs == NULL)
3170
/* In the shared -Bsymbolic case, discard space allocated for
3171
dynamic pc-relative relocs against symbols which turn out to be
3172
defined in regular objects. For the normal shared case, discard
3173
space for pc-relative relocs that have become local due to symbol
3174
visibility changes. */
3178
if (SYMBOL_CALLS_LOCAL (info, h))
3180
struct elf_sh_dyn_relocs **pp;
3182
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3184
p->count -= p->pc_count;
3193
if (htab->vxworks_p)
3195
struct elf_sh_dyn_relocs **pp;
3197
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3199
if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
3206
/* Also discard relocs on undefined weak syms with non-default
3208
if (eh->dyn_relocs != NULL
3209
&& h->root.type == bfd_link_hash_undefweak)
3211
if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3212
eh->dyn_relocs = NULL;
3214
/* Make sure undefined weak symbols are output as a dynamic
3216
else if (h->dynindx == -1
3217
&& !h->forced_local)
3219
if (! bfd_elf_link_record_dynamic_symbol (info, h))
3226
/* For the non-shared case, discard space for relocs against
3227
symbols which turn out to need copy relocs or are not
3233
|| (htab->root.dynamic_sections_created
3234
&& (h->root.type == bfd_link_hash_undefweak
3235
|| h->root.type == bfd_link_hash_undefined))))
3237
/* Make sure this symbol is output as a dynamic symbol.
3238
Undefined weak syms won't yet be marked as dynamic. */
3239
if (h->dynindx == -1
3240
&& !h->forced_local)
3242
if (! bfd_elf_link_record_dynamic_symbol (info, h))
3246
/* If that succeeded, we know we'll be keeping all the
3248
if (h->dynindx != -1)
3252
eh->dyn_relocs = NULL;
3257
/* Finally, allocate space. */
3258
for (p = eh->dyn_relocs; p != NULL; p = p->next)
3260
asection *sreloc = elf_section_data (p->sec)->sreloc;
3261
sreloc->size += p->count * sizeof (Elf32_External_Rela);
3263
/* If we need relocations, we do not need fixups. */
3264
if (htab->fdpic_p && !info->shared)
3265
htab->srofixup->size -= 4 * (p->count - p->pc_count);
3271
/* Find any dynamic relocs that apply to read-only sections. */
3274
readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3276
struct elf_sh_link_hash_entry *eh;
3277
struct elf_sh_dyn_relocs *p;
3279
eh = (struct elf_sh_link_hash_entry *) h;
3280
for (p = eh->dyn_relocs; p != NULL; p = p->next)
3282
asection *s = p->sec->output_section;
3284
if (s != NULL && (s->flags & SEC_READONLY) != 0)
3286
struct bfd_link_info *info = (struct bfd_link_info *) inf;
3288
info->flags |= DF_TEXTREL;
3290
/* Not an error, just cut short the traversal. */
3297
/* This function is called after all the input files have been read,
3298
and the input sections have been assigned to output sections.
3299
It's a convenient place to determine the PLT style. */
3302
sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3304
sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd, info->shared);
3306
if (sh_elf_hash_table (info)->fdpic_p && !info->relocatable
3307
&& !bfd_elf_stack_segment_size (output_bfd, info,
3308
"__stacksize", DEFAULT_STACK_SIZE))
3313
/* Set the sizes of the dynamic sections. */
3316
sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3317
struct bfd_link_info *info)
3319
struct elf_sh_link_hash_table *htab;
3325
htab = sh_elf_hash_table (info);
3329
dynobj = htab->root.dynobj;
3330
BFD_ASSERT (dynobj != NULL);
3332
if (htab->root.dynamic_sections_created)
3334
/* Set the contents of the .interp section to the interpreter. */
3335
if (info->executable)
3337
s = bfd_get_linker_section (dynobj, ".interp");
3338
BFD_ASSERT (s != NULL);
3339
s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3340
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3344
/* Set up .got offsets for local syms, and space for local dynamic
3346
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3348
bfd_signed_vma *local_got;
3349
bfd_signed_vma *end_local_got;
3350
union gotref *local_funcdesc, *end_local_funcdesc;
3351
char *local_got_type;
3352
bfd_size_type locsymcount;
3353
Elf_Internal_Shdr *symtab_hdr;
3356
if (! is_sh_elf (ibfd))
3359
for (s = ibfd->sections; s != NULL; s = s->next)
3361
struct elf_sh_dyn_relocs *p;
3363
for (p = ((struct elf_sh_dyn_relocs *)
3364
elf_section_data (s)->local_dynrel);
3368
if (! bfd_is_abs_section (p->sec)
3369
&& bfd_is_abs_section (p->sec->output_section))
3371
/* Input section has been discarded, either because
3372
it is a copy of a linkonce section or due to
3373
linker script /DISCARD/, so we'll be discarding
3376
else if (htab->vxworks_p
3377
&& strcmp (p->sec->output_section->name,
3380
/* Relocations in vxworks .tls_vars sections are
3381
handled specially by the loader. */
3383
else if (p->count != 0)
3385
srel = elf_section_data (p->sec)->sreloc;
3386
srel->size += p->count * sizeof (Elf32_External_Rela);
3387
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3388
info->flags |= DF_TEXTREL;
3390
/* If we need relocations, we do not need fixups. */
3391
if (htab->fdpic_p && !info->shared)
3392
htab->srofixup->size -= 4 * (p->count - p->pc_count);
3397
symtab_hdr = &elf_symtab_hdr (ibfd);
3398
locsymcount = symtab_hdr->sh_info;
3399
#ifdef INCLUDE_SHMEDIA
3400
/* Count datalabel local GOT. */
3404
srel = htab->srelgot;
3406
local_got = elf_local_got_refcounts (ibfd);
3409
end_local_got = local_got + locsymcount;
3410
local_got_type = sh_elf_local_got_type (ibfd);
3411
local_funcdesc = sh_elf_local_funcdesc (ibfd);
3412
for (; local_got < end_local_got; ++local_got)
3416
*local_got = s->size;
3418
if (*local_got_type == GOT_TLS_GD)
3421
srel->size += sizeof (Elf32_External_Rela);
3423
htab->srofixup->size += 4;
3425
if (*local_got_type == GOT_FUNCDESC)
3427
if (local_funcdesc == NULL)
3431
size = locsymcount * sizeof (union gotref);
3432
local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
3434
if (local_funcdesc == NULL)
3436
sh_elf_local_funcdesc (ibfd) = local_funcdesc;
3437
local_funcdesc += (local_got
3438
- elf_local_got_refcounts (ibfd));
3440
local_funcdesc->refcount++;
3445
*local_got = (bfd_vma) -1;
3450
local_funcdesc = sh_elf_local_funcdesc (ibfd);
3453
end_local_funcdesc = local_funcdesc + locsymcount;
3455
for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc)
3457
if (local_funcdesc->refcount > 0)
3459
local_funcdesc->offset = htab->sfuncdesc->size;
3460
htab->sfuncdesc->size += 8;
3462
htab->srofixup->size += 8;
3464
htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3467
local_funcdesc->offset = MINUS_ONE;
3473
if (htab->tls_ldm_got.refcount > 0)
3475
/* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3477
htab->tls_ldm_got.offset = htab->sgot->size;
3478
htab->sgot->size += 8;
3479
htab->srelgot->size += sizeof (Elf32_External_Rela);
3482
htab->tls_ldm_got.offset = -1;
3484
/* Only the reserved entries should be present. For FDPIC, they go at
3485
the end of .got.plt. */
3488
BFD_ASSERT (htab->sgotplt && htab->sgotplt->size == 12);
3489
htab->sgotplt->size = 0;
3492
/* Allocate global sym .plt and .got entries, and space for global
3493
sym dynamic relocs. */
3494
elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
3496
/* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3497
end of the FDPIC .got.plt. */
3500
htab->root.hgot->root.u.def.value = htab->sgotplt->size;
3501
htab->sgotplt->size += 12;
3504
/* At the very end of the .rofixup section is a pointer to the GOT. */
3505
if (htab->fdpic_p && htab->srofixup != NULL)
3506
htab->srofixup->size += 4;
3508
/* We now have determined the sizes of the various dynamic sections.
3509
Allocate memory for them. */
3511
for (s = dynobj->sections; s != NULL; s = s->next)
3513
if ((s->flags & SEC_LINKER_CREATED) == 0)
3518
|| s == htab->sgotplt
3519
|| s == htab->sfuncdesc
3520
|| s == htab->srofixup
3521
|| s == htab->sdynbss)
3523
/* Strip this section if we don't need it; see the
3526
else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3528
if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
3531
/* We use the reloc_count field as a counter if we need
3532
to copy relocs into the output file. */
3537
/* It's not one of our sections, so don't allocate space. */
3543
/* If we don't need this section, strip it from the
3544
output file. This is mostly to handle .rela.bss and
3545
.rela.plt. We must create both sections in
3546
create_dynamic_sections, because they must be created
3547
before the linker maps input sections to output
3548
sections. The linker does that before
3549
adjust_dynamic_symbol is called, and it is that
3550
function which decides whether anything needs to go
3551
into these sections. */
3553
s->flags |= SEC_EXCLUDE;
3557
if ((s->flags & SEC_HAS_CONTENTS) == 0)
3560
/* Allocate memory for the section contents. We use bfd_zalloc
3561
here in case unused entries are not reclaimed before the
3562
section's contents are written out. This should not happen,
3563
but this way if it does, we get a R_SH_NONE reloc instead
3565
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3566
if (s->contents == NULL)
3570
if (htab->root.dynamic_sections_created)
3572
/* Add some entries to the .dynamic section. We fill in the
3573
values later, in sh_elf_finish_dynamic_sections, but we
3574
must add the entries now so that we get the correct size for
3575
the .dynamic section. The DT_DEBUG entry is filled in by the
3576
dynamic linker and used by the debugger. */
3577
#define add_dynamic_entry(TAG, VAL) \
3578
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
3580
if (info->executable)
3582
if (! add_dynamic_entry (DT_DEBUG, 0))
3586
if (htab->splt->size != 0)
3588
if (! add_dynamic_entry (DT_PLTGOT, 0)
3589
|| ! add_dynamic_entry (DT_PLTRELSZ, 0)
3590
|| ! add_dynamic_entry (DT_PLTREL, DT_RELA)
3591
|| ! add_dynamic_entry (DT_JMPREL, 0))
3594
else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC)
3595
&& htab->sgot->size != 0)
3597
if (! add_dynamic_entry (DT_PLTGOT, 0))
3603
if (! add_dynamic_entry (DT_RELA, 0)
3604
|| ! add_dynamic_entry (DT_RELASZ, 0)
3605
|| ! add_dynamic_entry (DT_RELAENT,
3606
sizeof (Elf32_External_Rela)))
3609
/* If any dynamic relocs apply to a read-only section,
3610
then we need a DT_TEXTREL entry. */
3611
if ((info->flags & DF_TEXTREL) == 0)
3612
elf_link_hash_traverse (&htab->root, readonly_dynrelocs, info);
3614
if ((info->flags & DF_TEXTREL) != 0)
3616
if (! add_dynamic_entry (DT_TEXTREL, 0))
3621
&& !elf_vxworks_add_dynamic_entries (output_bfd, info))
3624
#undef add_dynamic_entry
3629
/* Add a dynamic relocation to the SRELOC section. */
3631
inline static bfd_vma
3632
sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
3633
int reloc_type, long dynindx, bfd_vma addend)
3635
Elf_Internal_Rela outrel;
3636
bfd_vma reloc_offset;
3638
outrel.r_offset = offset;
3639
outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
3640
outrel.r_addend = addend;
3642
reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela);
3643
BFD_ASSERT (reloc_offset < sreloc->size);
3644
bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3645
sreloc->contents + reloc_offset);
3646
sreloc->reloc_count++;
3648
return reloc_offset;
3651
/* Add an FDPIC read-only fixup. */
3654
sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset)
3656
bfd_vma fixup_offset;
3658
fixup_offset = srofixup->reloc_count++ * 4;
3659
BFD_ASSERT (fixup_offset < srofixup->size);
3660
bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset);
3663
/* Return the offset of the generated .got section from the
3664
_GLOBAL_OFFSET_TABLE_ symbol. */
3666
static bfd_signed_vma
3667
sh_elf_got_offset (struct elf_sh_link_hash_table *htab)
3669
return (htab->sgot->output_offset - htab->sgotplt->output_offset
3670
- htab->root.hgot->root.u.def.value);
3673
/* Find the segment number in which OSEC, and output section, is
3677
sh_elf_osec_to_segment (bfd *output_bfd, asection *osec)
3679
Elf_Internal_Phdr *p = NULL;
3681
if (output_bfd->xvec->flavour == bfd_target_elf_flavour)
3682
p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
3684
/* FIXME: Nothing ever says what this index is relative to. The kernel
3685
supplies data in terms of the number of load segments but this is
3686
a phdr index and the first phdr may not be a load segment. */
3687
return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
3691
sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
3693
unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
3695
return (seg != (unsigned) -1
3696
&& ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W));
3699
/* Generate the initial contents of a local function descriptor, along
3700
with any relocations or fixups required. */
3702
sh_elf_initialize_funcdesc (bfd *output_bfd,
3703
struct bfd_link_info *info,
3704
struct elf_link_hash_entry *h,
3709
struct elf_sh_link_hash_table *htab;
3713
htab = sh_elf_hash_table (info);
3715
/* FIXME: The ABI says that the offset to the function goes in the
3716
descriptor, along with the segment index. We're RELA, so it could
3717
go in the reloc instead... */
3719
if (h != NULL && SYMBOL_CALLS_LOCAL (info, h))
3721
section = h->root.u.def.section;
3722
value = h->root.u.def.value;
3725
if (h == NULL || SYMBOL_CALLS_LOCAL (info, h))
3727
dynindx = elf_section_data (section->output_section)->dynindx;
3728
addr = value + section->output_offset;
3729
seg = sh_elf_osec_to_segment (output_bfd, section->output_section);
3733
BFD_ASSERT (h->dynindx != -1);
3734
dynindx = h->dynindx;
3738
if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
3740
if (h == NULL || h->root.type != bfd_link_hash_undefweak)
3742
sh_elf_add_rofixup (output_bfd, htab->srofixup,
3744
+ htab->sfuncdesc->output_section->vma
3745
+ htab->sfuncdesc->output_offset);
3746
sh_elf_add_rofixup (output_bfd, htab->srofixup,
3748
+ htab->sfuncdesc->output_section->vma
3749
+ htab->sfuncdesc->output_offset);
3752
/* There are no dynamic relocations so fill in the final
3753
address and gp value (barring fixups). */
3754
addr += section->output_section->vma;
3755
seg = htab->root.hgot->root.u.def.value
3756
+ htab->root.hgot->root.u.def.section->output_section->vma
3757
+ htab->root.hgot->root.u.def.section->output_offset;
3760
sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc,
3762
+ htab->sfuncdesc->output_section->vma
3763
+ htab->sfuncdesc->output_offset,
3764
R_SH_FUNCDESC_VALUE, dynindx, 0);
3766
bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
3767
bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
3772
/* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3773
VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3776
static bfd_reloc_status_type
3777
install_movi20_field (bfd *output_bfd, unsigned long relocation,
3778
bfd *input_bfd, asection *input_section,
3779
bfd_byte *contents, bfd_vma offset)
3781
unsigned long cur_val;
3783
bfd_reloc_status_type r;
3785
if (offset > bfd_get_section_limit (input_bfd, input_section))
3786
return bfd_reloc_outofrange;
3788
r = bfd_check_overflow (complain_overflow_signed, 20, 0,
3789
bfd_arch_bits_per_address (input_bfd), relocation);
3790
if (r != bfd_reloc_ok)
3793
addr = contents + offset;
3794
cur_val = bfd_get_16 (output_bfd, addr);
3795
bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr);
3796
bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2);
3798
return bfd_reloc_ok;
3801
/* Relocate an SH ELF section. */
3804
sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
3805
bfd *input_bfd, asection *input_section,
3806
bfd_byte *contents, Elf_Internal_Rela *relocs,
3807
Elf_Internal_Sym *local_syms,
3808
asection **local_sections)
3810
struct elf_sh_link_hash_table *htab;
3811
Elf_Internal_Shdr *symtab_hdr;
3812
struct elf_link_hash_entry **sym_hashes;
3813
Elf_Internal_Rela *rel, *relend;
3815
bfd_vma *local_got_offsets;
3816
asection *sgot = NULL;
3817
asection *sgotplt = NULL;
3818
asection *splt = NULL;
3819
asection *sreloc = NULL;
3820
asection *srelgot = NULL;
3821
bfd_boolean is_vxworks_tls;
3822
unsigned isec_segment, got_segment, plt_segment, check_segment[2];
3823
bfd_boolean fdpic_p = FALSE;
3825
BFD_ASSERT (is_sh_elf (input_bfd));
3827
htab = sh_elf_hash_table (info);
3830
dynobj = htab->root.dynobj;
3832
sgotplt = htab->sgotplt;
3834
fdpic_p = htab->fdpic_p;
3836
symtab_hdr = &elf_symtab_hdr (input_bfd);
3837
sym_hashes = elf_sym_hashes (input_bfd);
3838
local_got_offsets = elf_local_got_offsets (input_bfd);
3840
isec_segment = sh_elf_osec_to_segment (output_bfd,
3841
input_section->output_section);
3842
if (fdpic_p && sgot)
3843
got_segment = sh_elf_osec_to_segment (output_bfd,
3844
sgot->output_section);
3847
if (fdpic_p && splt)
3848
plt_segment = sh_elf_osec_to_segment (output_bfd,
3849
splt->output_section);
3853
/* We have to handle relocations in vxworks .tls_vars sections
3854
specially, because the dynamic loader is 'weird'. */
3855
is_vxworks_tls = (htab && htab->vxworks_p && info->shared
3856
&& !strcmp (input_section->output_section->name,
3860
relend = relocs + input_section->reloc_count;
3861
for (; rel < relend; rel++)
3864
reloc_howto_type *howto;
3865
unsigned long r_symndx;
3866
Elf_Internal_Sym *sym;
3868
struct elf_link_hash_entry *h;
3870
bfd_vma addend = (bfd_vma) 0;
3871
bfd_reloc_status_type r;
3872
int seen_stt_datalabel = 0;
3874
enum got_type got_type;
3875
const char *symname = NULL;
3877
r_symndx = ELF32_R_SYM (rel->r_info);
3879
r_type = ELF32_R_TYPE (rel->r_info);
3881
/* Many of the relocs are only used for relaxing, and are
3882
handled entirely by the relaxation code. */
3883
if (r_type >= (int) R_SH_GNU_VTINHERIT
3884
&& r_type <= (int) R_SH_LABEL)
3886
if (r_type == (int) R_SH_NONE)
3890
|| r_type >= R_SH_max
3891
|| (r_type >= (int) R_SH_FIRST_INVALID_RELOC
3892
&& r_type <= (int) R_SH_LAST_INVALID_RELOC)
3893
|| (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
3894
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_2)
3895
|| ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
3896
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
3897
|| ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
3898
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
3899
|| ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
3900
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
3901
|| ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_6
3902
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_6))
3904
bfd_set_error (bfd_error_bad_value);
3908
howto = get_howto_table (output_bfd) + r_type;
3910
/* For relocs that aren't partial_inplace, we get the addend from
3912
if (! howto->partial_inplace)
3913
addend = rel->r_addend;
3918
check_segment[0] = -1;
3919
check_segment[1] = -1;
3920
if (r_symndx < symtab_hdr->sh_info)
3922
sym = local_syms + r_symndx;
3923
sec = local_sections[r_symndx];
3925
symname = bfd_elf_string_from_elf_section
3926
(input_bfd, symtab_hdr->sh_link, sym->st_name);
3927
if (symname == NULL || *symname == '\0')
3928
symname = bfd_section_name (input_bfd, sec);
3930
relocation = (sec->output_section->vma
3931
+ sec->output_offset
3933
/* A local symbol never has STO_SH5_ISA32, so we don't need
3934
datalabel processing here. Make sure this does not change
3936
if ((sym->st_other & STO_SH5_ISA32) != 0)
3937
((*info->callbacks->reloc_dangerous)
3939
_("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
3940
input_bfd, input_section, rel->r_offset));
3942
if (sec != NULL && discarded_section (sec))
3943
/* Handled below. */
3945
else if (info->relocatable)
3947
/* This is a relocatable link. We don't have to change
3948
anything, unless the reloc is against a section symbol,
3949
in which case we have to adjust according to where the
3950
section symbol winds up in the output section. */
3951
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3953
if (! howto->partial_inplace)
3955
/* For relocations with the addend in the
3956
relocation, we need just to update the addend.
3957
All real relocs are of type partial_inplace; this
3958
code is mostly for completeness. */
3959
rel->r_addend += sec->output_offset;
3964
/* Relocs of type partial_inplace need to pick up the
3965
contents in the contents and add the offset resulting
3966
from the changed location of the section symbol.
3967
Using _bfd_final_link_relocate (e.g. goto
3968
final_link_relocate) here would be wrong, because
3969
relocations marked pc_relative would get the current
3970
location subtracted, and we must only do that at the
3972
r = _bfd_relocate_contents (howto, input_bfd,
3975
contents + rel->r_offset);
3976
goto relocation_done;
3981
else if (! howto->partial_inplace)
3983
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3984
addend = rel->r_addend;
3986
else if ((sec->flags & SEC_MERGE)
3987
&& ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3991
if (howto->rightshift || howto->src_mask != 0xffffffff)
3993
(*_bfd_error_handler)
3994
(_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3995
input_bfd, input_section,
3996
(long) rel->r_offset, howto->name);
4000
addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4003
_bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4005
addend += msec->output_section->vma + msec->output_offset;
4006
bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4012
/* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4015
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4016
symname = h->root.root.string;
4017
while (h->root.type == bfd_link_hash_indirect
4018
|| h->root.type == bfd_link_hash_warning)
4020
#ifdef INCLUDE_SHMEDIA
4021
/* If the reference passes a symbol marked with
4022
STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4024
seen_stt_datalabel |= h->type == STT_DATALABEL;
4026
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4028
if (h->root.type == bfd_link_hash_defined
4029
|| h->root.type == bfd_link_hash_defweak)
4033
dyn = htab ? htab->root.dynamic_sections_created : FALSE;
4034
sec = h->root.u.def.section;
4035
/* In these cases, we don't need the relocation value.
4036
We check specially because in some obscure cases
4037
sec->output_section will be NULL. */
4038
if (r_type == R_SH_GOTPC
4039
|| r_type == R_SH_GOTPC_LOW16
4040
|| r_type == R_SH_GOTPC_MEDLOW16
4041
|| r_type == R_SH_GOTPC_MEDHI16
4042
|| r_type == R_SH_GOTPC_HI16
4043
|| ((r_type == R_SH_PLT32
4044
|| r_type == R_SH_PLT_LOW16
4045
|| r_type == R_SH_PLT_MEDLOW16
4046
|| r_type == R_SH_PLT_MEDHI16
4047
|| r_type == R_SH_PLT_HI16)
4048
&& h->plt.offset != (bfd_vma) -1)
4049
|| ((r_type == R_SH_GOT32
4050
|| r_type == R_SH_GOT20
4051
|| r_type == R_SH_GOTFUNCDESC
4052
|| r_type == R_SH_GOTFUNCDESC20
4053
|| r_type == R_SH_GOTOFFFUNCDESC
4054
|| r_type == R_SH_GOTOFFFUNCDESC20
4055
|| r_type == R_SH_FUNCDESC
4056
|| r_type == R_SH_GOT_LOW16
4057
|| r_type == R_SH_GOT_MEDLOW16
4058
|| r_type == R_SH_GOT_MEDHI16
4059
|| r_type == R_SH_GOT_HI16)
4060
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4062
|| (! info->symbolic && h->dynindx != -1)
4063
|| !h->def_regular))
4064
/* The cases above are those in which relocation is
4065
overwritten in the switch block below. The cases
4066
below are those in which we must defer relocation
4067
to run-time, because we can't resolve absolute
4068
addresses when creating a shared library. */
4070
&& ((! info->symbolic && h->dynindx != -1)
4072
&& ((r_type == R_SH_DIR32
4073
&& !h->forced_local)
4074
|| (r_type == R_SH_REL32
4075
&& !SYMBOL_CALLS_LOCAL (info, h)))
4076
&& ((input_section->flags & SEC_ALLOC) != 0
4077
/* DWARF will emit R_SH_DIR32 relocations in its
4078
sections against symbols defined externally
4079
in shared libraries. We can't do anything
4081
|| ((input_section->flags & SEC_DEBUGGING) != 0
4082
&& h->def_dynamic)))
4083
/* Dynamic relocs are not propagated for SEC_DEBUGGING
4084
sections because such sections are not SEC_ALLOC and
4085
thus ld.so will not process them. */
4086
|| (sec->output_section == NULL
4087
&& ((input_section->flags & SEC_DEBUGGING) != 0
4089
|| (sec->output_section == NULL
4090
&& (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE
4091
|| sh_elf_hash_entry (h)->got_type == GOT_TLS_GD)))
4093
else if (sec->output_section != NULL)
4094
relocation = ((h->root.u.def.value
4095
+ sec->output_section->vma
4096
+ sec->output_offset)
4097
/* A STO_SH5_ISA32 causes a "bitor 1" to the
4098
symbol value, unless we've seen
4099
STT_DATALABEL on the way to it. */
4100
| ((h->other & STO_SH5_ISA32) != 0
4101
&& ! seen_stt_datalabel));
4102
else if (!info->relocatable
4103
&& (_bfd_elf_section_offset (output_bfd, info,
4108
(*_bfd_error_handler)
4109
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4112
(long) rel->r_offset,
4114
h->root.root.string);
4118
else if (h->root.type == bfd_link_hash_undefweak)
4120
else if (info->unresolved_syms_in_objects == RM_IGNORE
4121
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4123
else if (!info->relocatable)
4125
if (! info->callbacks->undefined_symbol
4126
(info, h->root.root.string, input_bfd,
4127
input_section, rel->r_offset,
4128
(info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4129
|| ELF_ST_VISIBILITY (h->other))))
4134
if (sec != NULL && discarded_section (sec))
4135
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4136
rel, 1, relend, howto, 0, contents);
4138
if (info->relocatable)
4141
/* Check for inter-segment relocations in FDPIC files. Most
4142
relocations connect the relocation site to the location of
4143
the target symbol, but there are some exceptions below. */
4144
check_segment[0] = isec_segment;
4146
check_segment[1] = sh_elf_osec_to_segment (output_bfd,
4147
sec->output_section);
4149
check_segment[1] = -1;
4151
switch ((int) r_type)
4153
final_link_relocate:
4154
/* COFF relocs don't use the addend. The addend is used for
4155
R_SH_DIR32 to be compatible with other compilers. */
4156
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4157
contents, rel->r_offset,
4158
relocation, addend);
4162
goto final_link_relocate;
4167
/* If the reloc is against the start of this section, then
4168
the assembler has already taken care of it and the reloc
4169
is here only to assist in relaxing. If the reloc is not
4170
against the start of this section, then it's against an
4171
external symbol and we must deal with it ourselves. */
4172
if (input_section->output_section->vma + input_section->output_offset
4175
int disp = (relocation
4176
- input_section->output_section->vma
4177
- input_section->output_offset
4183
case R_SH_DIR8WPZ: mask = 1; break;
4184
case R_SH_DIR8WPL: mask = 3; break;
4185
default: mask = 0; break;
4189
((*_bfd_error_handler)
4190
(_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4191
input_section->owner,
4192
(unsigned long) rel->r_offset));
4193
bfd_set_error (bfd_error_bad_value);
4197
goto final_link_relocate;
4203
#ifdef INCLUDE_SHMEDIA
4204
if (shmedia_prepare_reloc (info, input_bfd, input_section,
4205
contents, rel, &relocation))
4206
goto final_link_relocate;
4208
bfd_set_error (bfd_error_bad_value);
4216
goto final_link_relocate;
4222
((*_bfd_error_handler)
4223
(_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4224
input_section->owner,
4225
(unsigned long) rel->r_offset, howto->name,
4226
(unsigned long) relocation));
4227
bfd_set_error (bfd_error_bad_value);
4230
goto final_link_relocate;
4237
((*_bfd_error_handler)
4238
(_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4239
input_section->owner,
4240
(unsigned long) rel->r_offset, howto->name,
4241
(unsigned long) relocation));
4242
bfd_set_error (bfd_error_bad_value);
4245
goto final_link_relocate;
4248
if ((signed int)relocation < -32
4249
|| (signed int)relocation > 32)
4251
((*_bfd_error_handler)
4252
(_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
4253
input_section->owner,
4254
(unsigned long) rel->r_offset,
4255
(unsigned long) relocation));
4256
bfd_set_error (bfd_error_bad_value);
4259
goto final_link_relocate;
4262
if ((signed int)relocation < -16
4263
|| (signed int)relocation > 16)
4265
((*_bfd_error_handler)
4266
(_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
4267
input_section->owner,
4268
(unsigned long) rel->r_offset,
4269
(unsigned long) relocation));
4270
bfd_set_error (bfd_error_bad_value);
4273
goto final_link_relocate;
4277
#ifdef INCLUDE_SHMEDIA
4278
case R_SH_IMM_LOW16_PCREL:
4279
case R_SH_IMM_MEDLOW16_PCREL:
4280
case R_SH_IMM_MEDHI16_PCREL:
4281
case R_SH_IMM_HI16_PCREL:
4285
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4286
|| h->root.type != bfd_link_hash_undefweak)
4287
&& r_symndx != STN_UNDEF
4288
&& (input_section->flags & SEC_ALLOC) != 0
4290
&& (r_type == R_SH_DIR32
4291
|| !SYMBOL_CALLS_LOCAL (info, h)))
4293
Elf_Internal_Rela outrel;
4295
bfd_boolean skip, relocate;
4297
/* When generating a shared object, these relocations
4298
are copied into the output file to be resolved at run
4303
sreloc = _bfd_elf_get_dynamic_reloc_section
4304
(input_bfd, input_section, /*rela?*/ TRUE);
4313
_bfd_elf_section_offset (output_bfd, info, input_section,
4315
if (outrel.r_offset == (bfd_vma) -1)
4317
else if (outrel.r_offset == (bfd_vma) -2)
4318
skip = TRUE, relocate = TRUE;
4319
outrel.r_offset += (input_section->output_section->vma
4320
+ input_section->output_offset);
4323
memset (&outrel, 0, sizeof outrel);
4324
else if (r_type == R_SH_REL32)
4326
BFD_ASSERT (h != NULL && h->dynindx != -1);
4327
outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4329
= (howto->partial_inplace
4330
? bfd_get_32 (input_bfd, contents + rel->r_offset)
4333
#ifdef INCLUDE_SHMEDIA
4334
else if (r_type == R_SH_IMM_LOW16_PCREL
4335
|| r_type == R_SH_IMM_MEDLOW16_PCREL
4336
|| r_type == R_SH_IMM_MEDHI16_PCREL
4337
|| r_type == R_SH_IMM_HI16_PCREL)
4339
BFD_ASSERT (h != NULL && h->dynindx != -1);
4340
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4341
outrel.r_addend = addend;
4346
|| ((info->symbolic || h->dynindx == -1)
4347
&& h->def_regular)))
4351
BFD_ASSERT (sec != NULL);
4352
BFD_ASSERT (sec->output_section != NULL);
4353
dynindx = elf_section_data (sec->output_section)->dynindx;
4354
outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4355
outrel.r_addend = relocation;
4357
+= (howto->partial_inplace
4358
? bfd_get_32 (input_bfd, contents + rel->r_offset)
4360
outrel.r_addend -= sec->output_section->vma;
4364
/* h->dynindx may be -1 if this symbol was marked to
4367
|| ((info->symbolic || h->dynindx == -1)
4370
relocate = howto->partial_inplace;
4371
outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4375
BFD_ASSERT (h->dynindx != -1);
4376
outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4378
outrel.r_addend = relocation;
4380
+= (howto->partial_inplace
4381
? bfd_get_32 (input_bfd, contents + rel->r_offset)
4385
loc = sreloc->contents;
4386
loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4387
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4389
check_segment[0] = check_segment[1] = -1;
4391
/* If this reloc is against an external symbol, we do
4392
not want to fiddle with the addend. Otherwise, we
4393
need to include the symbol value so that it becomes
4394
an addend for the dynamic reloc. */
4398
else if (fdpic_p && !info->shared
4399
&& r_type == R_SH_DIR32
4400
&& (input_section->flags & SEC_ALLOC) != 0)
4406
if (sh_elf_osec_readonly_p (output_bfd,
4407
input_section->output_section))
4409
(*_bfd_error_handler)
4410
(_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4413
(long) rel->r_offset,
4418
offset = _bfd_elf_section_offset (output_bfd, info,
4419
input_section, rel->r_offset);
4420
if (offset != (bfd_vma)-1)
4421
sh_elf_add_rofixup (output_bfd, htab->srofixup,
4422
input_section->output_section->vma
4423
+ input_section->output_offset
4426
check_segment[0] = check_segment[1] = -1;
4428
/* We don't want warnings for non-NULL tests on undefined weak
4430
else if (r_type == R_SH_REL32
4432
&& h->root.type == bfd_link_hash_undefweak)
4433
check_segment[0] = check_segment[1] = -1;
4434
goto final_link_relocate;
4437
#ifdef INCLUDE_SHMEDIA
4438
case R_SH_GOTPLT_LOW16:
4439
case R_SH_GOTPLT_MEDLOW16:
4440
case R_SH_GOTPLT_MEDHI16:
4441
case R_SH_GOTPLT_HI16:
4442
case R_SH_GOTPLT10BY4:
4443
case R_SH_GOTPLT10BY8:
4445
/* Relocation is to the entry for this symbol in the
4446
procedure linkage table. */
4453
|| h->plt.offset == (bfd_vma) -1
4454
|| h->got.offset != (bfd_vma) -1)
4457
/* Relocation is to the entry for this symbol in the global
4458
offset table extension for the procedure linkage table. */
4461
BFD_ASSERT (sgotplt != NULL);
4462
relocation = (sgotplt->output_offset
4463
+ (get_plt_index (htab->plt_info, h->plt.offset)
4467
relocation -= GOT_BIAS;
4470
goto final_link_relocate;
4475
#ifdef INCLUDE_SHMEDIA
4476
case R_SH_GOT_LOW16:
4477
case R_SH_GOT_MEDLOW16:
4478
case R_SH_GOT_MEDHI16:
4483
/* Relocation is to the entry for this symbol in the global
4487
BFD_ASSERT (sgot != NULL);
4488
check_segment[0] = check_segment[1] = -1;
4494
off = h->got.offset;
4495
#ifdef INCLUDE_SHMEDIA
4496
if (seen_stt_datalabel)
4498
struct elf_sh_link_hash_entry *hsh;
4500
hsh = (struct elf_sh_link_hash_entry *)h;
4501
off = hsh->datalabel_got.offset;
4504
BFD_ASSERT (off != (bfd_vma) -1);
4506
dyn = htab->root.dynamic_sections_created;
4507
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4509
&& SYMBOL_REFERENCES_LOCAL (info, h))
4510
|| (ELF_ST_VISIBILITY (h->other)
4511
&& h->root.type == bfd_link_hash_undefweak))
4513
/* This is actually a static link, or it is a
4514
-Bsymbolic link and the symbol is defined
4515
locally, or the symbol was forced to be local
4516
because of a version file. We must initialize
4517
this entry in the global offset table. Since the
4518
offset must always be a multiple of 4, we use the
4519
least significant bit to record whether we have
4520
initialized it already.
4522
When doing a dynamic link, we create a .rela.got
4523
relocation entry to initialize the value. This
4524
is done in the finish_dynamic_symbol routine. */
4529
bfd_put_32 (output_bfd, relocation,
4530
sgot->contents + off);
4531
#ifdef INCLUDE_SHMEDIA
4532
if (seen_stt_datalabel)
4534
struct elf_sh_link_hash_entry *hsh;
4536
hsh = (struct elf_sh_link_hash_entry *)h;
4537
hsh->datalabel_got.offset |= 1;
4543
/* If we initialize the GOT entry here with a valid
4544
symbol address, also add a fixup. */
4545
if (fdpic_p && !info->shared
4546
&& sh_elf_hash_entry (h)->got_type == GOT_NORMAL
4547
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4548
|| h->root.type != bfd_link_hash_undefweak))
4549
sh_elf_add_rofixup (output_bfd, htab->srofixup,
4550
sgot->output_section->vma
4551
+ sgot->output_offset
4556
relocation = sh_elf_got_offset (htab) + off;
4560
#ifdef INCLUDE_SHMEDIA
4563
BFD_ASSERT (local_got_offsets != NULL
4564
&& (local_got_offsets[symtab_hdr->sh_info
4568
off = local_got_offsets[symtab_hdr->sh_info
4574
BFD_ASSERT (local_got_offsets != NULL
4575
&& local_got_offsets[r_symndx] != (bfd_vma) -1);
4577
off = local_got_offsets[r_symndx];
4578
#ifdef INCLUDE_SHMEDIA
4582
/* The offset must always be a multiple of 4. We use
4583
the least significant bit to record whether we have
4584
already generated the necessary reloc. */
4589
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4593
Elf_Internal_Rela outrel;
4596
if (srelgot == NULL)
4598
srelgot = bfd_get_linker_section (dynobj,
4600
BFD_ASSERT (srelgot != NULL);
4603
outrel.r_offset = (sgot->output_section->vma
4604
+ sgot->output_offset
4609
= elf_section_data (sec->output_section)->dynindx;
4610
outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4611
outrel.r_addend = relocation;
4612
outrel.r_addend -= sec->output_section->vma;
4616
outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4617
outrel.r_addend = relocation;
4619
loc = srelgot->contents;
4620
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4621
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4624
&& (sh_elf_local_got_type (input_bfd) [r_symndx]
4626
sh_elf_add_rofixup (output_bfd, htab->srofixup,
4627
sgot->output_section->vma
4628
+ sgot->output_offset
4631
#ifdef INCLUDE_SHMEDIA
4633
local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
4636
local_got_offsets[r_symndx] |= 1;
4639
relocation = sh_elf_got_offset (htab) + off;
4643
relocation -= GOT_BIAS;
4646
if (r_type == R_SH_GOT20)
4648
r = install_movi20_field (output_bfd, relocation + addend,
4649
input_bfd, input_section, contents,
4654
goto final_link_relocate;
4658
#ifdef INCLUDE_SHMEDIA
4659
case R_SH_GOTOFF_LOW16:
4660
case R_SH_GOTOFF_MEDLOW16:
4661
case R_SH_GOTOFF_MEDHI16:
4662
case R_SH_GOTOFF_HI16:
4664
/* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4665
we place at the start of the .got.plt section. This is the same
4666
as the start of the output .got section, unless there are function
4667
descriptors in front of it. */
4669
BFD_ASSERT (sgotplt != NULL);
4670
check_segment[0] = got_segment;
4671
relocation -= sgotplt->output_section->vma + sgotplt->output_offset
4672
+ htab->root.hgot->root.u.def.value;
4675
relocation -= GOT_BIAS;
4678
addend = rel->r_addend;
4680
if (r_type == R_SH_GOTOFF20)
4682
r = install_movi20_field (output_bfd, relocation + addend,
4683
input_bfd, input_section, contents,
4688
goto final_link_relocate;
4691
#ifdef INCLUDE_SHMEDIA
4692
case R_SH_GOTPC_LOW16:
4693
case R_SH_GOTPC_MEDLOW16:
4694
case R_SH_GOTPC_MEDHI16:
4695
case R_SH_GOTPC_HI16:
4697
/* Use global offset table as symbol value. */
4699
BFD_ASSERT (sgotplt != NULL);
4700
relocation = sgotplt->output_section->vma + sgotplt->output_offset;
4703
relocation += GOT_BIAS;
4706
addend = rel->r_addend;
4708
goto final_link_relocate;
4711
#ifdef INCLUDE_SHMEDIA
4712
case R_SH_PLT_LOW16:
4713
case R_SH_PLT_MEDLOW16:
4714
case R_SH_PLT_MEDHI16:
4717
/* Relocation is to the entry for this symbol in the
4718
procedure linkage table. */
4720
/* Resolve a PLT reloc against a local symbol directly,
4721
without using the procedure linkage table. */
4723
goto final_link_relocate;
4725
/* We don't want to warn on calls to undefined weak symbols,
4726
as calls to them must be protected by non-NULL tests
4727
anyway, and unprotected calls would invoke undefined
4729
if (h->root.type == bfd_link_hash_undefweak)
4730
check_segment[0] = check_segment[1] = -1;
4732
if (h->forced_local)
4733
goto final_link_relocate;
4735
if (h->plt.offset == (bfd_vma) -1)
4737
/* We didn't make a PLT entry for this symbol. This
4738
happens when statically linking PIC code, or when
4739
using -Bsymbolic. */
4740
goto final_link_relocate;
4743
BFD_ASSERT (splt != NULL);
4744
check_segment[1] = plt_segment;
4745
relocation = (splt->output_section->vma
4746
+ splt->output_offset
4749
#ifdef INCLUDE_SHMEDIA
4753
addend = rel->r_addend;
4755
goto final_link_relocate;
4757
/* Relocation is to the canonical function descriptor for this
4758
symbol, possibly via the GOT. Initialize the GOT
4759
entry and function descriptor if necessary. */
4760
case R_SH_GOTFUNCDESC:
4761
case R_SH_GOTFUNCDESC20:
4765
asection *reloc_section;
4766
bfd_vma reloc_offset;
4767
int reloc_type = R_SH_FUNCDESC;
4771
check_segment[0] = check_segment[1] = -1;
4773
/* FIXME: See what FRV does for global symbols in the
4774
executable, with --export-dynamic. Do they need ld.so
4775
to allocate official descriptors? See what this code
4781
if (r_type == R_SH_FUNCDESC)
4783
reloc_section = input_section;
4784
reloc_offset = rel->r_offset;
4788
reloc_section = sgot;
4791
reloc_offset = h->got.offset;
4794
BFD_ASSERT (local_got_offsets != NULL);
4795
reloc_offset = local_got_offsets[r_symndx];
4797
BFD_ASSERT (reloc_offset != MINUS_ONE);
4799
if (reloc_offset & 1)
4802
goto funcdesc_done_got;
4806
if (h && h->root.type == bfd_link_hash_undefweak
4807
&& (SYMBOL_CALLS_LOCAL (info, h)
4808
|| !htab->root.dynamic_sections_created))
4809
/* Undefined weak symbol which will not be dynamically
4810
resolved later; leave it at zero. */
4811
goto funcdesc_leave_zero;
4812
else if (SYMBOL_CALLS_LOCAL (info, h)
4813
&& ! SYMBOL_FUNCDESC_LOCAL (info, h))
4815
/* If the symbol needs a non-local function descriptor
4816
but binds locally (i.e., its visibility is
4817
protected), emit a dynamic relocation decayed to
4818
section+offset. This is an optimization; the dynamic
4819
linker would resolve our function descriptor request
4820
to our copy of the function anyway. */
4821
dynindx = elf_section_data (h->root.u.def.section
4822
->output_section)->dynindx;
4823
relocation += h->root.u.def.section->output_offset
4824
+ h->root.u.def.value;
4826
else if (! SYMBOL_FUNCDESC_LOCAL (info, h))
4828
/* If the symbol is dynamic and there will be dynamic
4829
symbol resolution because we are or are linked with a
4830
shared library, emit a FUNCDESC relocation such that
4831
the dynamic linker will allocate the function
4833
BFD_ASSERT (h->dynindx != -1);
4834
dynindx = h->dynindx;
4840
/* Otherwise, we know we have a private function
4841
descriptor, so reference it directly. */
4842
reloc_type = R_SH_DIR32;
4843
dynindx = elf_section_data (htab->sfuncdesc
4844
->output_section)->dynindx;
4848
offset = sh_elf_hash_entry (h)->funcdesc.offset;
4849
BFD_ASSERT (offset != MINUS_ONE);
4850
if ((offset & 1) == 0)
4852
if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
4855
sh_elf_hash_entry (h)->funcdesc.offset |= 1;
4860
union gotref *local_funcdesc;
4862
local_funcdesc = sh_elf_local_funcdesc (input_bfd);
4863
offset = local_funcdesc[r_symndx].offset;
4864
BFD_ASSERT (offset != MINUS_ONE);
4865
if ((offset & 1) == 0)
4867
if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
4871
local_funcdesc[r_symndx].offset |= 1;
4875
relocation = htab->sfuncdesc->output_offset + (offset & ~1);
4878
if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
4882
if (sh_elf_osec_readonly_p (output_bfd,
4883
reloc_section->output_section))
4885
(*_bfd_error_handler)
4886
(_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4889
(long) rel->r_offset,
4894
offset = _bfd_elf_section_offset (output_bfd, info,
4895
reloc_section, reloc_offset);
4897
if (offset != (bfd_vma)-1)
4898
sh_elf_add_rofixup (output_bfd, htab->srofixup,
4900
+ reloc_section->output_section->vma
4901
+ reloc_section->output_offset);
4903
else if ((reloc_section->output_section->flags
4904
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
4908
if (sh_elf_osec_readonly_p (output_bfd,
4909
reloc_section->output_section))
4911
info->callbacks->warning
4913
_("cannot emit dynamic relocations in read-only section"),
4914
symname, input_bfd, reloc_section, reloc_offset);
4918
if (srelgot == NULL)
4920
srelgot = bfd_get_linker_section (dynobj, ".rela.got");
4921
BFD_ASSERT (srelgot != NULL);
4924
offset = _bfd_elf_section_offset (output_bfd, info,
4925
reloc_section, reloc_offset);
4927
if (offset != (bfd_vma)-1)
4928
sh_elf_add_dyn_reloc (output_bfd, srelgot,
4930
+ reloc_section->output_section->vma
4931
+ reloc_section->output_offset,
4932
reloc_type, dynindx, relocation);
4934
if (r_type == R_SH_FUNCDESC)
4942
goto funcdesc_leave_zero;
4946
if (SYMBOL_FUNCDESC_LOCAL (info, h))
4947
relocation += htab->sfuncdesc->output_section->vma;
4948
funcdesc_leave_zero:
4949
if (r_type != R_SH_FUNCDESC)
4951
bfd_put_32 (output_bfd, relocation,
4952
reloc_section->contents + reloc_offset);
4956
local_got_offsets[r_symndx] |= 1;
4960
relocation = sh_elf_got_offset (htab) + reloc_offset;
4962
relocation -= GOT_BIAS;
4965
if (r_type == R_SH_GOTFUNCDESC20)
4967
r = install_movi20_field (output_bfd, relocation + addend,
4968
input_bfd, input_section, contents,
4973
goto final_link_relocate;
4977
case R_SH_GOTOFFFUNCDESC:
4978
case R_SH_GOTOFFFUNCDESC20:
4979
/* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4980
executable and --export-dynamic. If such symbols get
4981
ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4985
check_segment[0] = check_segment[1] = -1;
4987
addend = rel->r_addend;
4989
if (h && (h->root.type == bfd_link_hash_undefweak
4990
|| !SYMBOL_FUNCDESC_LOCAL (info, h)))
4993
(_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
4994
input_bfd, input_section, (long) rel->r_offset, howto->name,
4995
h->root.root.string);
5002
/* Otherwise, we know we have a private function
5003
descriptor, so reference it directly. */
5006
offset = sh_elf_hash_entry (h)->funcdesc.offset;
5007
BFD_ASSERT (offset != MINUS_ONE);
5008
if ((offset & 1) == 0)
5010
if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
5013
sh_elf_hash_entry (h)->funcdesc.offset |= 1;
5018
union gotref *local_funcdesc;
5020
local_funcdesc = sh_elf_local_funcdesc (input_bfd);
5021
offset = local_funcdesc[r_symndx].offset;
5022
BFD_ASSERT (offset != MINUS_ONE);
5023
if ((offset & 1) == 0)
5025
if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
5029
local_funcdesc[r_symndx].offset |= 1;
5033
relocation = htab->sfuncdesc->output_offset + (offset & ~1);
5036
relocation -= (htab->root.hgot->root.u.def.value
5037
+ sgotplt->output_offset);
5039
relocation -= GOT_BIAS;
5042
if (r_type == R_SH_GOTOFFFUNCDESC20)
5044
r = install_movi20_field (output_bfd, relocation + addend,
5045
input_bfd, input_section, contents,
5050
goto final_link_relocate;
5052
case R_SH_LOOP_START:
5054
static bfd_vma start, end;
5056
start = (relocation + rel->r_addend
5057
- (sec->output_section->vma + sec->output_offset));
5058
r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5059
rel->r_offset, sec, start, end);
5063
end = (relocation + rel->r_addend
5064
- (sec->output_section->vma + sec->output_offset));
5065
r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5066
rel->r_offset, sec, start, end);
5070
case R_SH_TLS_GD_32:
5071
case R_SH_TLS_IE_32:
5073
check_segment[0] = check_segment[1] = -1;
5074
r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5075
got_type = GOT_UNKNOWN;
5076
if (h == NULL && local_got_offsets)
5077
got_type = sh_elf_local_got_type (input_bfd) [r_symndx];
5080
got_type = sh_elf_hash_entry (h)->got_type;
5082
&& (h->dynindx == -1
5084
r_type = R_SH_TLS_LE_32;
5087
if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE)
5088
r_type = R_SH_TLS_IE_32;
5090
if (r_type == R_SH_TLS_LE_32)
5093
unsigned short insn;
5095
if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5097
/* GD->LE transition:
5098
mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5099
jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5100
1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5102
mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5104
1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5106
offset = rel->r_offset;
5107
BFD_ASSERT (offset >= 16);
5108
/* Size of GD instructions is 16 or 18. */
5110
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5111
if ((insn & 0xff00) == 0xc700)
5113
BFD_ASSERT (offset >= 2);
5115
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5118
BFD_ASSERT ((insn & 0xff00) == 0xd400);
5119
insn = bfd_get_16 (input_bfd, contents + offset + 2);
5120
BFD_ASSERT ((insn & 0xff00) == 0xc700);
5121
insn = bfd_get_16 (input_bfd, contents + offset + 4);
5122
BFD_ASSERT ((insn & 0xff00) == 0xd100);
5123
insn = bfd_get_16 (input_bfd, contents + offset + 6);
5124
BFD_ASSERT (insn == 0x310c);
5125
insn = bfd_get_16 (input_bfd, contents + offset + 8);
5126
BFD_ASSERT (insn == 0x410b);
5127
insn = bfd_get_16 (input_bfd, contents + offset + 10);
5128
BFD_ASSERT (insn == 0x34cc);
5130
bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5131
bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5132
bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5133
bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5134
bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5140
/* IE->LE transition:
5141
mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5142
bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5144
mov.l .Ln,rM; stc gbr,rN; nop; ...;
5147
offset = rel->r_offset;
5148
BFD_ASSERT (offset >= 16);
5149
/* Size of IE instructions is 10 or 12. */
5151
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5152
if ((insn & 0xf0ff) == 0x0012)
5154
BFD_ASSERT (offset >= 2);
5156
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5159
BFD_ASSERT ((insn & 0xff00) == 0xd000);
5160
target = insn & 0x00ff;
5161
insn = bfd_get_16 (input_bfd, contents + offset + 2);
5162
BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5163
insn = bfd_get_16 (input_bfd, contents + offset + 4);
5164
BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5165
insn = 0xd000 | (insn & 0x0f00) | target;
5166
bfd_put_16 (output_bfd, insn, contents + offset + 0);
5167
bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5170
bfd_put_32 (output_bfd, tpoff (info, relocation),
5171
contents + rel->r_offset);
5175
if (sgot == NULL || sgotplt == NULL)
5179
off = h->got.offset;
5182
if (local_got_offsets == NULL)
5185
off = local_got_offsets[r_symndx];
5188
/* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5189
if (r_type == R_SH_TLS_IE_32
5190
&& ! htab->root.dynamic_sections_created)
5193
bfd_put_32 (output_bfd, tpoff (info, relocation),
5194
sgot->contents + off);
5195
bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5196
contents + rel->r_offset);
5204
Elf_Internal_Rela outrel;
5208
if (srelgot == NULL)
5210
srelgot = bfd_get_linker_section (dynobj, ".rela.got");
5211
BFD_ASSERT (srelgot != NULL);
5214
outrel.r_offset = (sgot->output_section->vma
5215
+ sgot->output_offset + off);
5217
if (h == NULL || h->dynindx == -1)
5222
dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5224
if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5225
outrel.r_addend = relocation - dtpoff_base (info);
5227
outrel.r_addend = 0;
5228
outrel.r_info = ELF32_R_INFO (indx, dr_type);
5229
loc = srelgot->contents;
5230
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5231
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5233
if (r_type == R_SH_TLS_GD_32)
5237
bfd_put_32 (output_bfd,
5238
relocation - dtpoff_base (info),
5239
sgot->contents + off + 4);
5243
outrel.r_info = ELF32_R_INFO (indx,
5245
outrel.r_offset += 4;
5246
outrel.r_addend = 0;
5247
srelgot->reloc_count++;
5248
loc += sizeof (Elf32_External_Rela);
5249
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5256
local_got_offsets[r_symndx] |= 1;
5259
if (off >= (bfd_vma) -2)
5262
if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5263
relocation = sh_elf_got_offset (htab) + off;
5267
unsigned short insn;
5269
/* GD->IE transition:
5270
mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5271
jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5272
1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5274
mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5275
nop; nop; bra 3f; nop; .align 2;
5276
1: .long x@TPOFF; 2:...; 3:. */
5278
offset = rel->r_offset;
5279
BFD_ASSERT (offset >= 16);
5280
/* Size of GD instructions is 16 or 18. */
5282
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5283
if ((insn & 0xff00) == 0xc700)
5285
BFD_ASSERT (offset >= 2);
5287
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5290
BFD_ASSERT ((insn & 0xff00) == 0xd400);
5292
/* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5293
bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5295
insn = bfd_get_16 (input_bfd, contents + offset + 2);
5296
BFD_ASSERT ((insn & 0xff00) == 0xc700);
5297
insn = bfd_get_16 (input_bfd, contents + offset + 4);
5298
BFD_ASSERT ((insn & 0xff00) == 0xd100);
5299
insn = bfd_get_16 (input_bfd, contents + offset + 6);
5300
BFD_ASSERT (insn == 0x310c);
5301
insn = bfd_get_16 (input_bfd, contents + offset + 8);
5302
BFD_ASSERT (insn == 0x410b);
5303
insn = bfd_get_16 (input_bfd, contents + offset + 10);
5304
BFD_ASSERT (insn == 0x34cc);
5306
bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5307
bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5308
bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5309
bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5310
bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5312
bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5313
contents + rel->r_offset);
5318
addend = rel->r_addend;
5320
goto final_link_relocate;
5322
case R_SH_TLS_LD_32:
5324
check_segment[0] = check_segment[1] = -1;
5328
unsigned short insn;
5330
/* LD->LE transition:
5331
mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5332
jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5333
1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5335
stc gbr,r0; nop; nop; nop;
5336
nop; nop; bra 3f; ...; 3:. */
5338
offset = rel->r_offset;
5339
BFD_ASSERT (offset >= 16);
5340
/* Size of LD instructions is 16 or 18. */
5342
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5343
if ((insn & 0xff00) == 0xc700)
5345
BFD_ASSERT (offset >= 2);
5347
insn = bfd_get_16 (input_bfd, contents + offset + 0);
5350
BFD_ASSERT ((insn & 0xff00) == 0xd400);
5351
insn = bfd_get_16 (input_bfd, contents + offset + 2);
5352
BFD_ASSERT ((insn & 0xff00) == 0xc700);
5353
insn = bfd_get_16 (input_bfd, contents + offset + 4);
5354
BFD_ASSERT ((insn & 0xff00) == 0xd100);
5355
insn = bfd_get_16 (input_bfd, contents + offset + 6);
5356
BFD_ASSERT (insn == 0x310c);
5357
insn = bfd_get_16 (input_bfd, contents + offset + 8);
5358
BFD_ASSERT (insn == 0x410b);
5359
insn = bfd_get_16 (input_bfd, contents + offset + 10);
5360
BFD_ASSERT (insn == 0x34cc);
5362
bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5363
bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5364
bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5365
bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5366
bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5367
bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5372
if (sgot == NULL || sgotplt == NULL)
5375
off = htab->tls_ldm_got.offset;
5380
Elf_Internal_Rela outrel;
5383
srelgot = htab->srelgot;
5384
if (srelgot == NULL)
5387
outrel.r_offset = (sgot->output_section->vma
5388
+ sgot->output_offset + off);
5389
outrel.r_addend = 0;
5390
outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5391
loc = srelgot->contents;
5392
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5393
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5394
htab->tls_ldm_got.offset |= 1;
5397
relocation = sh_elf_got_offset (htab) + off;
5398
addend = rel->r_addend;
5400
goto final_link_relocate;
5402
case R_SH_TLS_LDO_32:
5403
check_segment[0] = check_segment[1] = -1;
5405
relocation = tpoff (info, relocation);
5407
relocation -= dtpoff_base (info);
5409
addend = rel->r_addend;
5410
goto final_link_relocate;
5412
case R_SH_TLS_LE_32:
5415
Elf_Internal_Rela outrel;
5418
check_segment[0] = check_segment[1] = -1;
5420
if (! info->shared || info->pie)
5422
relocation = tpoff (info, relocation);
5423
addend = rel->r_addend;
5424
goto final_link_relocate;
5429
sreloc = _bfd_elf_get_dynamic_reloc_section
5430
(input_bfd, input_section, /*rela?*/ TRUE);
5435
if (h == NULL || h->dynindx == -1)
5440
outrel.r_offset = (input_section->output_section->vma
5441
+ input_section->output_offset
5443
outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5445
outrel.r_addend = relocation - dtpoff_base (info);
5447
outrel.r_addend = 0;
5449
loc = sreloc->contents;
5450
loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5451
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5457
if (fdpic_p && check_segment[0] != (unsigned) -1
5458
&& check_segment[0] != check_segment[1])
5460
/* We don't want duplicate errors for undefined symbols. */
5461
if (!h || h->root.type != bfd_link_hash_undefined)
5465
info->callbacks->einfo
5466
(_("%X%C: relocation to \"%s\" references a different segment\n"),
5467
input_bfd, input_section, rel->r_offset, symname);
5471
info->callbacks->einfo
5472
(_("%C: warning: relocation to \"%s\" references a different segment\n"),
5473
input_bfd, input_section, rel->r_offset, symname);
5476
elf_elfheader (output_bfd)->e_flags &= ~EF_SH_PIC;
5479
if (r != bfd_reloc_ok)
5484
case bfd_reloc_outofrange:
5486
case bfd_reloc_overflow:
5494
name = (bfd_elf_string_from_elf_section
5495
(input_bfd, symtab_hdr->sh_link, sym->st_name));
5499
name = bfd_section_name (input_bfd, sec);
5501
if (! ((*info->callbacks->reloc_overflow)
5502
(info, (h ? &h->root : NULL), name, howto->name,
5503
(bfd_vma) 0, input_bfd, input_section,
5515
/* This is a version of bfd_generic_get_relocated_section_contents
5516
which uses sh_elf_relocate_section. */
5519
sh_elf_get_relocated_section_contents (bfd *output_bfd,
5520
struct bfd_link_info *link_info,
5521
struct bfd_link_order *link_order,
5523
bfd_boolean relocatable,
5526
Elf_Internal_Shdr *symtab_hdr;
5527
asection *input_section = link_order->u.indirect.section;
5528
bfd *input_bfd = input_section->owner;
5529
asection **sections = NULL;
5530
Elf_Internal_Rela *internal_relocs = NULL;
5531
Elf_Internal_Sym *isymbuf = NULL;
5533
/* We only need to handle the case of relaxing, or of having a
5534
particular set of section contents, specially. */
5536
|| elf_section_data (input_section)->this_hdr.contents == NULL)
5537
return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5542
symtab_hdr = &elf_symtab_hdr (input_bfd);
5544
memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5545
(size_t) input_section->size);
5547
if ((input_section->flags & SEC_RELOC) != 0
5548
&& input_section->reloc_count > 0)
5551
Elf_Internal_Sym *isym, *isymend;
5554
internal_relocs = (_bfd_elf_link_read_relocs
5555
(input_bfd, input_section, NULL,
5556
(Elf_Internal_Rela *) NULL, FALSE));
5557
if (internal_relocs == NULL)
5560
if (symtab_hdr->sh_info != 0)
5562
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5563
if (isymbuf == NULL)
5564
isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5565
symtab_hdr->sh_info, 0,
5567
if (isymbuf == NULL)
5571
amt = symtab_hdr->sh_info;
5572
amt *= sizeof (asection *);
5573
sections = (asection **) bfd_malloc (amt);
5574
if (sections == NULL && amt != 0)
5577
isymend = isymbuf + symtab_hdr->sh_info;
5578
for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5582
if (isym->st_shndx == SHN_UNDEF)
5583
isec = bfd_und_section_ptr;
5584
else if (isym->st_shndx == SHN_ABS)
5585
isec = bfd_abs_section_ptr;
5586
else if (isym->st_shndx == SHN_COMMON)
5587
isec = bfd_com_section_ptr;
5589
isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5594
if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5595
input_section, data, internal_relocs,
5599
if (sections != NULL)
5602
&& symtab_hdr->contents != (unsigned char *) isymbuf)
5604
if (elf_section_data (input_section)->relocs != internal_relocs)
5605
free (internal_relocs);
5611
if (sections != NULL)
5614
&& symtab_hdr->contents != (unsigned char *) isymbuf)
5616
if (internal_relocs != NULL
5617
&& elf_section_data (input_section)->relocs != internal_relocs)
5618
free (internal_relocs);
5622
/* Return the base VMA address which should be subtracted from real addresses
5623
when resolving @dtpoff relocation.
5624
This is PT_TLS segment p_vaddr. */
5627
dtpoff_base (struct bfd_link_info *info)
5629
/* If tls_sec is NULL, we should have signalled an error already. */
5630
if (elf_hash_table (info)->tls_sec == NULL)
5632
return elf_hash_table (info)->tls_sec->vma;
5635
/* Return the relocation value for R_SH_TLS_TPOFF32.. */
5638
tpoff (struct bfd_link_info *info, bfd_vma address)
5640
/* If tls_sec is NULL, we should have signalled an error already. */
5641
if (elf_hash_table (info)->tls_sec == NULL)
5643
/* SH TLS ABI is variant I and static TLS block start just after tcbhead
5644
structure which has 2 pointer fields. */
5645
return (address - elf_hash_table (info)->tls_sec->vma
5646
+ align_power ((bfd_vma) 8,
5647
elf_hash_table (info)->tls_sec->alignment_power));
5651
sh_elf_gc_mark_hook (asection *sec,
5652
struct bfd_link_info *info,
5653
Elf_Internal_Rela *rel,
5654
struct elf_link_hash_entry *h,
5655
Elf_Internal_Sym *sym)
5658
switch (ELF32_R_TYPE (rel->r_info))
5660
case R_SH_GNU_VTINHERIT:
5661
case R_SH_GNU_VTENTRY:
5665
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5668
/* Update the got entry reference counts for the section being removed. */
5671
sh_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5672
asection *sec, const Elf_Internal_Rela *relocs)
5674
Elf_Internal_Shdr *symtab_hdr;
5675
struct elf_link_hash_entry **sym_hashes;
5676
bfd_signed_vma *local_got_refcounts;
5677
union gotref *local_funcdesc;
5678
const Elf_Internal_Rela *rel, *relend;
5680
if (info->relocatable)
5683
elf_section_data (sec)->local_dynrel = NULL;
5685
symtab_hdr = &elf_symtab_hdr (abfd);
5686
sym_hashes = elf_sym_hashes (abfd);
5687
local_got_refcounts = elf_local_got_refcounts (abfd);
5688
local_funcdesc = sh_elf_local_funcdesc (abfd);
5690
relend = relocs + sec->reloc_count;
5691
for (rel = relocs; rel < relend; rel++)
5693
unsigned long r_symndx;
5694
unsigned int r_type;
5695
struct elf_link_hash_entry *h = NULL;
5696
#ifdef INCLUDE_SHMEDIA
5697
int seen_stt_datalabel = 0;
5700
r_symndx = ELF32_R_SYM (rel->r_info);
5701
if (r_symndx >= symtab_hdr->sh_info)
5703
struct elf_sh_link_hash_entry *eh;
5704
struct elf_sh_dyn_relocs **pp;
5705
struct elf_sh_dyn_relocs *p;
5707
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5708
while (h->root.type == bfd_link_hash_indirect
5709
|| h->root.type == bfd_link_hash_warning)
5711
#ifdef INCLUDE_SHMEDIA
5712
seen_stt_datalabel |= h->type == STT_DATALABEL;
5714
h = (struct elf_link_hash_entry *) h->root.u.i.link;
5716
eh = (struct elf_sh_link_hash_entry *) h;
5717
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5720
/* Everything must go for SEC. */
5726
r_type = ELF32_R_TYPE (rel->r_info);
5727
switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
5729
case R_SH_TLS_LD_32:
5730
if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5731
sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5739
#ifdef INCLUDE_SHMEDIA
5740
case R_SH_GOT_LOW16:
5741
case R_SH_GOT_MEDLOW16:
5742
case R_SH_GOT_MEDHI16:
5746
case R_SH_GOTOFF_LOW16:
5747
case R_SH_GOTOFF_MEDLOW16:
5748
case R_SH_GOTOFF_MEDHI16:
5749
case R_SH_GOTOFF_HI16:
5750
case R_SH_GOTPC_LOW16:
5751
case R_SH_GOTPC_MEDLOW16:
5752
case R_SH_GOTPC_MEDHI16:
5753
case R_SH_GOTPC_HI16:
5755
case R_SH_TLS_GD_32:
5756
case R_SH_TLS_IE_32:
5757
case R_SH_GOTFUNCDESC:
5758
case R_SH_GOTFUNCDESC20:
5761
#ifdef INCLUDE_SHMEDIA
5762
if (seen_stt_datalabel)
5764
struct elf_sh_link_hash_entry *eh;
5765
eh = (struct elf_sh_link_hash_entry *) h;
5766
if (eh->datalabel_got.refcount > 0)
5767
eh->datalabel_got.refcount -= 1;
5771
if (h->got.refcount > 0)
5772
h->got.refcount -= 1;
5774
else if (local_got_refcounts != NULL)
5776
#ifdef INCLUDE_SHMEDIA
5777
if (rel->r_addend & 1)
5779
if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5780
local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5784
if (local_got_refcounts[r_symndx] > 0)
5785
local_got_refcounts[r_symndx] -= 1;
5791
sh_elf_hash_entry (h)->abs_funcdesc_refcount -= 1;
5792
else if (sh_elf_hash_table (info)->fdpic_p && !info->shared)
5793
sh_elf_hash_table (info)->srofixup->size -= 4;
5797
case R_SH_GOTOFFFUNCDESC:
5798
case R_SH_GOTOFFFUNCDESC20:
5800
sh_elf_hash_entry (h)->funcdesc.refcount -= 1;
5802
local_funcdesc[r_symndx].refcount -= 1;
5806
if (sh_elf_hash_table (info)->fdpic_p && !info->shared
5807
&& (sec->flags & SEC_ALLOC) != 0)
5808
sh_elf_hash_table (info)->srofixup->size -= 4;
5817
#ifdef INCLUDE_SHMEDIA
5818
case R_SH_PLT_LOW16:
5819
case R_SH_PLT_MEDLOW16:
5820
case R_SH_PLT_MEDHI16:
5825
if (h->plt.refcount > 0)
5826
h->plt.refcount -= 1;
5831
#ifdef INCLUDE_SHMEDIA
5832
case R_SH_GOTPLT_LOW16:
5833
case R_SH_GOTPLT_MEDLOW16:
5834
case R_SH_GOTPLT_MEDHI16:
5835
case R_SH_GOTPLT_HI16:
5836
case R_SH_GOTPLT10BY4:
5837
case R_SH_GOTPLT10BY8:
5841
struct elf_sh_link_hash_entry *eh;
5842
eh = (struct elf_sh_link_hash_entry *) h;
5843
if (eh->gotplt_refcount > 0)
5845
eh->gotplt_refcount -= 1;
5846
if (h->plt.refcount > 0)
5847
h->plt.refcount -= 1;
5849
#ifdef INCLUDE_SHMEDIA
5850
else if (seen_stt_datalabel)
5852
if (eh->datalabel_got.refcount > 0)
5853
eh->datalabel_got.refcount -= 1;
5856
else if (h->got.refcount > 0)
5857
h->got.refcount -= 1;
5859
else if (local_got_refcounts != NULL)
5861
#ifdef INCLUDE_SHMEDIA
5862
if (rel->r_addend & 1)
5864
if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5865
local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5869
if (local_got_refcounts[r_symndx] > 0)
5870
local_got_refcounts[r_symndx] -= 1;
5882
/* Copy the extra info we tack onto an elf_link_hash_entry. */
5885
sh_elf_copy_indirect_symbol (struct bfd_link_info *info,
5886
struct elf_link_hash_entry *dir,
5887
struct elf_link_hash_entry *ind)
5889
struct elf_sh_link_hash_entry *edir, *eind;
5891
edir = (struct elf_sh_link_hash_entry *) dir;
5892
eind = (struct elf_sh_link_hash_entry *) ind;
5894
if (eind->dyn_relocs != NULL)
5896
if (edir->dyn_relocs != NULL)
5898
struct elf_sh_dyn_relocs **pp;
5899
struct elf_sh_dyn_relocs *p;
5901
/* Add reloc counts against the indirect sym to the direct sym
5902
list. Merge any entries against the same section. */
5903
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5905
struct elf_sh_dyn_relocs *q;
5907
for (q = edir->dyn_relocs; q != NULL; q = q->next)
5908
if (q->sec == p->sec)
5910
q->pc_count += p->pc_count;
5911
q->count += p->count;
5918
*pp = edir->dyn_relocs;
5921
edir->dyn_relocs = eind->dyn_relocs;
5922
eind->dyn_relocs = NULL;
5924
edir->gotplt_refcount = eind->gotplt_refcount;
5925
eind->gotplt_refcount = 0;
5926
#ifdef INCLUDE_SHMEDIA
5927
edir->datalabel_got.refcount += eind->datalabel_got.refcount;
5928
eind->datalabel_got.refcount = 0;
5930
edir->funcdesc.refcount += eind->funcdesc.refcount;
5931
eind->funcdesc.refcount = 0;
5932
edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
5933
eind->abs_funcdesc_refcount = 0;
5935
if (ind->root.type == bfd_link_hash_indirect
5936
&& dir->got.refcount <= 0)
5938
edir->got_type = eind->got_type;
5939
eind->got_type = GOT_UNKNOWN;
5942
if (ind->root.type != bfd_link_hash_indirect
5943
&& dir->dynamic_adjusted)
5945
/* If called to transfer flags for a weakdef during processing
5946
of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5947
We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5948
dir->ref_dynamic |= ind->ref_dynamic;
5949
dir->ref_regular |= ind->ref_regular;
5950
dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
5951
dir->needs_plt |= ind->needs_plt;
5954
_bfd_elf_link_hash_copy_indirect (info, dir, ind);
5958
sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
5966
case R_SH_TLS_GD_32:
5967
case R_SH_TLS_IE_32:
5969
return R_SH_TLS_LE_32;
5970
return R_SH_TLS_IE_32;
5971
case R_SH_TLS_LD_32:
5972
return R_SH_TLS_LE_32;
5978
/* Look through the relocs for a section during the first phase.
5979
Since we don't do .gots or .plts, we just need to consider the
5980
virtual table relocs for gc. */
5983
sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
5984
const Elf_Internal_Rela *relocs)
5986
Elf_Internal_Shdr *symtab_hdr;
5987
struct elf_link_hash_entry **sym_hashes;
5988
struct elf_sh_link_hash_table *htab;
5989
const Elf_Internal_Rela *rel;
5990
const Elf_Internal_Rela *rel_end;
5992
unsigned int r_type;
5993
enum got_type got_type, old_got_type;
5997
if (info->relocatable)
6000
BFD_ASSERT (is_sh_elf (abfd));
6002
symtab_hdr = &elf_symtab_hdr (abfd);
6003
sym_hashes = elf_sym_hashes (abfd);
6005
htab = sh_elf_hash_table (info);
6009
rel_end = relocs + sec->reloc_count;
6010
for (rel = relocs; rel < rel_end; rel++)
6012
struct elf_link_hash_entry *h;
6013
unsigned long r_symndx;
6014
#ifdef INCLUDE_SHMEDIA
6015
int seen_stt_datalabel = 0;
6018
r_symndx = ELF32_R_SYM (rel->r_info);
6019
r_type = ELF32_R_TYPE (rel->r_info);
6021
if (r_symndx < symtab_hdr->sh_info)
6025
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6026
while (h->root.type == bfd_link_hash_indirect
6027
|| h->root.type == bfd_link_hash_warning)
6029
#ifdef INCLUDE_SHMEDIA
6030
seen_stt_datalabel |= h->type == STT_DATALABEL;
6032
h = (struct elf_link_hash_entry *) h->root.u.i.link;
6035
/* PR15323, ref flags aren't set for references in the same
6037
h->root.non_ir_ref = 1;
6040
r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6042
&& r_type == R_SH_TLS_IE_32
6044
&& h->root.type != bfd_link_hash_undefined
6045
&& h->root.type != bfd_link_hash_undefweak
6046
&& (h->dynindx == -1
6048
r_type = R_SH_TLS_LE_32;
6053
case R_SH_GOTOFFFUNCDESC:
6054
case R_SH_GOTOFFFUNCDESC20:
6056
case R_SH_GOTFUNCDESC:
6057
case R_SH_GOTFUNCDESC20:
6060
if (h->dynindx == -1)
6061
switch (ELF_ST_VISIBILITY (h->other))
6067
bfd_elf_link_record_dynamic_symbol (info, h);
6074
/* Some relocs require a global offset table. */
6075
if (htab->sgot == NULL)
6080
/* This may require an rofixup. */
6089
case R_SH_GOTFUNCDESC:
6090
case R_SH_GOTFUNCDESC20:
6091
case R_SH_GOTOFFFUNCDESC:
6092
case R_SH_GOTOFFFUNCDESC20:
6094
#ifdef INCLUDE_SHMEDIA
6095
case R_SH_GOTPLT_LOW16:
6096
case R_SH_GOTPLT_MEDLOW16:
6097
case R_SH_GOTPLT_MEDHI16:
6098
case R_SH_GOTPLT_HI16:
6099
case R_SH_GOTPLT10BY4:
6100
case R_SH_GOTPLT10BY8:
6101
case R_SH_GOT_LOW16:
6102
case R_SH_GOT_MEDLOW16:
6103
case R_SH_GOT_MEDHI16:
6107
case R_SH_GOTOFF_LOW16:
6108
case R_SH_GOTOFF_MEDLOW16:
6109
case R_SH_GOTOFF_MEDHI16:
6110
case R_SH_GOTOFF_HI16:
6111
case R_SH_GOTPC_LOW16:
6112
case R_SH_GOTPC_MEDLOW16:
6113
case R_SH_GOTPC_MEDHI16:
6114
case R_SH_GOTPC_HI16:
6116
case R_SH_TLS_GD_32:
6117
case R_SH_TLS_LD_32:
6118
case R_SH_TLS_IE_32:
6119
if (htab->root.dynobj == NULL)
6120
htab->root.dynobj = abfd;
6121
if (!create_got_section (htab->root.dynobj, info))
6132
/* This relocation describes the C++ object vtable hierarchy.
6133
Reconstruct it for later use during GC. */
6134
case R_SH_GNU_VTINHERIT:
6135
if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6139
/* This relocation describes which C++ vtable entries are actually
6140
used. Record for later use during GC. */
6141
case R_SH_GNU_VTENTRY:
6142
BFD_ASSERT (h != NULL);
6144
&& !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6148
case R_SH_TLS_IE_32:
6150
info->flags |= DF_STATIC_TLS;
6154
case R_SH_TLS_GD_32:
6157
#ifdef INCLUDE_SHMEDIA
6158
case R_SH_GOT_LOW16:
6159
case R_SH_GOT_MEDLOW16:
6160
case R_SH_GOT_MEDHI16:
6165
case R_SH_GOTFUNCDESC:
6166
case R_SH_GOTFUNCDESC20:
6170
got_type = GOT_NORMAL;
6172
case R_SH_TLS_GD_32:
6173
got_type = GOT_TLS_GD;
6175
case R_SH_TLS_IE_32:
6176
got_type = GOT_TLS_IE;
6178
case R_SH_GOTFUNCDESC:
6179
case R_SH_GOTFUNCDESC20:
6180
got_type = GOT_FUNCDESC;
6186
#ifdef INCLUDE_SHMEDIA
6187
if (seen_stt_datalabel)
6189
struct elf_sh_link_hash_entry *eh
6190
= (struct elf_sh_link_hash_entry *) h;
6192
eh->datalabel_got.refcount += 1;
6196
h->got.refcount += 1;
6197
old_got_type = sh_elf_hash_entry (h)->got_type;
6201
bfd_signed_vma *local_got_refcounts;
6203
/* This is a global offset table entry for a local
6205
local_got_refcounts = elf_local_got_refcounts (abfd);
6206
if (local_got_refcounts == NULL)
6210
size = symtab_hdr->sh_info;
6211
size *= sizeof (bfd_signed_vma);
6212
#ifdef INCLUDE_SHMEDIA
6213
/* Reserve space for both the datalabel and
6214
codelabel local GOT offsets. */
6217
size += symtab_hdr->sh_info;
6218
local_got_refcounts = ((bfd_signed_vma *)
6219
bfd_zalloc (abfd, size));
6220
if (local_got_refcounts == NULL)
6222
elf_local_got_refcounts (abfd) = local_got_refcounts;
6223
#ifdef INCLUDE_SHMEDIA
6224
/* Take care of both the datalabel and codelabel local
6226
sh_elf_local_got_type (abfd)
6227
= (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6229
sh_elf_local_got_type (abfd)
6230
= (char *) (local_got_refcounts + symtab_hdr->sh_info);
6233
#ifdef INCLUDE_SHMEDIA
6234
if (rel->r_addend & 1)
6235
local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6238
local_got_refcounts[r_symndx] += 1;
6239
old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
6242
/* If a TLS symbol is accessed using IE at least once,
6243
there is no point to use dynamic model for it. */
6244
if (old_got_type != got_type && old_got_type != GOT_UNKNOWN
6245
&& (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE))
6247
if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD)
6248
got_type = GOT_TLS_IE;
6251
if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
6252
&& (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
6253
(*_bfd_error_handler)
6254
(_("%B: `%s' accessed both as normal and FDPIC symbol"),
6255
abfd, h->root.root.string);
6256
else if (old_got_type == GOT_FUNCDESC
6257
|| got_type == GOT_FUNCDESC)
6258
(*_bfd_error_handler)
6259
(_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6260
abfd, h->root.root.string);
6262
(*_bfd_error_handler)
6263
(_("%B: `%s' accessed both as normal and thread local symbol"),
6264
abfd, h->root.root.string);
6269
if (old_got_type != got_type)
6272
sh_elf_hash_entry (h)->got_type = got_type;
6274
sh_elf_local_got_type (abfd) [r_symndx] = got_type;
6279
case R_SH_TLS_LD_32:
6280
sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6284
case R_SH_GOTOFFFUNCDESC:
6285
case R_SH_GOTOFFFUNCDESC20:
6288
(*_bfd_error_handler)
6289
(_("%B: Function descriptor relocation with non-zero addend"),
6296
union gotref *local_funcdesc;
6298
/* We need a function descriptor for a local symbol. */
6299
local_funcdesc = sh_elf_local_funcdesc (abfd);
6300
if (local_funcdesc == NULL)
6304
size = symtab_hdr->sh_info * sizeof (union gotref);
6305
#ifdef INCLUDE_SHMEDIA
6306
/* Count datalabel local GOT. */
6309
local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
6310
if (local_funcdesc == NULL)
6312
sh_elf_local_funcdesc (abfd) = local_funcdesc;
6314
local_funcdesc[r_symndx].refcount += 1;
6316
if (r_type == R_SH_FUNCDESC)
6319
htab->srofixup->size += 4;
6321
htab->srelgot->size += sizeof (Elf32_External_Rela);
6326
sh_elf_hash_entry (h)->funcdesc.refcount++;
6327
if (r_type == R_SH_FUNCDESC)
6328
sh_elf_hash_entry (h)->abs_funcdesc_refcount++;
6330
/* If there is a function descriptor reference, then
6331
there should not be any non-FDPIC references. */
6332
old_got_type = sh_elf_hash_entry (h)->got_type;
6333
if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
6335
if (old_got_type == GOT_NORMAL)
6336
(*_bfd_error_handler)
6337
(_("%B: `%s' accessed both as normal and FDPIC symbol"),
6338
abfd, h->root.root.string);
6340
(*_bfd_error_handler)
6341
(_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6342
abfd, h->root.root.string);
6348
#ifdef INCLUDE_SHMEDIA
6349
case R_SH_GOTPLT_LOW16:
6350
case R_SH_GOTPLT_MEDLOW16:
6351
case R_SH_GOTPLT_MEDHI16:
6352
case R_SH_GOTPLT_HI16:
6353
case R_SH_GOTPLT10BY4:
6354
case R_SH_GOTPLT10BY8:
6356
/* If this is a local symbol, we resolve it directly without
6357
creating a procedure linkage table entry. */
6363
|| h->dynindx == -1)
6367
h->plt.refcount += 1;
6368
((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6373
#ifdef INCLUDE_SHMEDIA
6374
case R_SH_PLT_LOW16:
6375
case R_SH_PLT_MEDLOW16:
6376
case R_SH_PLT_MEDHI16:
6379
/* This symbol requires a procedure linkage table entry. We
6380
actually build the entry in adjust_dynamic_symbol,
6381
because this might be a case of linking PIC code which is
6382
never referenced by a dynamic object, in which case we
6383
don't need to generate a procedure linkage table entry
6386
/* If this is a local symbol, we resolve it directly without
6387
creating a procedure linkage table entry. */
6391
if (h->forced_local)
6395
h->plt.refcount += 1;
6400
#ifdef INCLUDE_SHMEDIA
6401
case R_SH_IMM_LOW16_PCREL:
6402
case R_SH_IMM_MEDLOW16_PCREL:
6403
case R_SH_IMM_MEDHI16_PCREL:
6404
case R_SH_IMM_HI16_PCREL:
6406
if (h != NULL && ! info->shared)
6409
h->plt.refcount += 1;
6412
/* If we are creating a shared library, and this is a reloc
6413
against a global symbol, or a non PC relative reloc
6414
against a local symbol, then we need to copy the reloc
6415
into the shared library. However, if we are linking with
6416
-Bsymbolic, we do not need to copy a reloc against a
6417
global symbol which is defined in an object we are
6418
including in the link (i.e., DEF_REGULAR is set). At
6419
this point we have not seen all the input files, so it is
6420
possible that DEF_REGULAR is not set now but will be set
6421
later (it is never cleared). We account for that
6422
possibility below by storing information in the
6423
dyn_relocs field of the hash table entry. A similar
6424
situation occurs when creating shared libraries and symbol
6425
visibility changes render the symbol local.
6427
If on the other hand, we are creating an executable, we
6428
may need to keep relocations for symbols satisfied by a
6429
dynamic library if we manage to avoid copy relocs for the
6432
&& (sec->flags & SEC_ALLOC) != 0
6433
&& (r_type != R_SH_REL32
6435
&& (! info->symbolic
6436
|| h->root.type == bfd_link_hash_defweak
6437
|| !h->def_regular))))
6439
&& (sec->flags & SEC_ALLOC) != 0
6441
&& (h->root.type == bfd_link_hash_defweak
6442
|| !h->def_regular)))
6444
struct elf_sh_dyn_relocs *p;
6445
struct elf_sh_dyn_relocs **head;
6447
if (htab->root.dynobj == NULL)
6448
htab->root.dynobj = abfd;
6450
/* When creating a shared object, we must copy these
6451
reloc types into the output file. We create a reloc
6452
section in dynobj and make room for this reloc. */
6455
sreloc = _bfd_elf_make_dynamic_reloc_section
6456
(sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
6462
/* If this is a global symbol, we count the number of
6463
relocations we need for this symbol. */
6465
head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6468
/* Track dynamic relocs needed for local syms too. */
6471
Elf_Internal_Sym *isym;
6473
isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6478
s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6482
vpp = &elf_section_data (s)->local_dynrel;
6483
head = (struct elf_sh_dyn_relocs **) vpp;
6487
if (p == NULL || p->sec != sec)
6489
bfd_size_type amt = sizeof (*p);
6490
p = bfd_alloc (htab->root.dynobj, amt);
6501
if (r_type == R_SH_REL32
6502
#ifdef INCLUDE_SHMEDIA
6503
|| r_type == R_SH_IMM_LOW16_PCREL
6504
|| r_type == R_SH_IMM_MEDLOW16_PCREL
6505
|| r_type == R_SH_IMM_MEDHI16_PCREL
6506
|| r_type == R_SH_IMM_HI16_PCREL
6512
/* Allocate the fixup regardless of whether we need a relocation.
6513
If we end up generating the relocation, we'll unallocate the
6515
if (htab->fdpic_p && !info->shared
6516
&& r_type == R_SH_DIR32
6517
&& (sec->flags & SEC_ALLOC) != 0)
6518
htab->srofixup->size += 4;
6521
case R_SH_TLS_LE_32:
6522
if (info->shared && !info->pie)
6524
(*_bfd_error_handler)
6525
(_("%B: TLS local exec code cannot be linked into shared objects"),
6532
case R_SH_TLS_LDO_32:
6533
/* Nothing to do. */
6544
#ifndef sh_elf_set_mach_from_flags
6545
static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
6548
sh_elf_set_mach_from_flags (bfd *abfd)
6550
flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
6552
if (flags >= sizeof(sh_ef_bfd_table))
6555
if (sh_ef_bfd_table[flags] == 0)
6558
bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
6564
/* Reverse table lookup for sh_ef_bfd_table[].
6565
Given a bfd MACH value from archures.c
6566
return the equivalent ELF flags from the table.
6567
Return -1 if no match is found. */
6570
sh_elf_get_flags_from_mach (unsigned long mach)
6572
int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
6575
if (sh_ef_bfd_table[i] == mach)
6578
/* shouldn't get here */
6583
#endif /* not sh_elf_set_mach_from_flags */
6585
#ifndef sh_elf_set_private_flags
6586
/* Function to keep SH specific file flags. */
6589
sh_elf_set_private_flags (bfd *abfd, flagword flags)
6591
BFD_ASSERT (! elf_flags_init (abfd)
6592
|| elf_elfheader (abfd)->e_flags == flags);
6594
elf_elfheader (abfd)->e_flags = flags;
6595
elf_flags_init (abfd) = TRUE;
6596
return sh_elf_set_mach_from_flags (abfd);
6598
#endif /* not sh_elf_set_private_flags */
6600
#ifndef sh_elf_copy_private_data
6601
/* Copy backend specific data from one object module to another */
6604
sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
6606
/* Copy object attributes. */
6607
_bfd_elf_copy_obj_attributes (ibfd, obfd);
6609
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6612
return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6614
#endif /* not sh_elf_copy_private_data */
6616
#ifndef sh_elf_merge_private_data
6618
/* This function returns the ELF architecture number that
6619
corresponds to the given arch_sh* flags. */
6622
sh_find_elf_flags (unsigned int arch_set)
6624
extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
6625
unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set);
6627
return sh_elf_get_flags_from_mach (bfd_mach);
6630
/* This routine initialises the elf flags when required and
6631
calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6634
sh_elf_merge_private_data (bfd *ibfd, bfd *obfd)
6636
extern bfd_boolean sh_merge_bfd_arch (bfd *, bfd *);
6638
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6641
if (! elf_flags_init (obfd))
6643
/* This happens when ld starts out with a 'blank' output file. */
6644
elf_flags_init (obfd) = TRUE;
6645
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6646
sh_elf_set_mach_from_flags (obfd);
6647
if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
6648
elf_elfheader (obfd)->e_flags |= EF_SH_PIC;
6651
if (! sh_merge_bfd_arch (ibfd, obfd))
6653
_bfd_error_handler ("%B: uses instructions which are incompatible "
6654
"with instructions used in previous modules",
6656
bfd_set_error (bfd_error_bad_value);
6660
elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
6661
elf_elfheader (obfd)->e_flags |=
6662
sh_elf_get_flags_from_mach (bfd_get_mach (obfd));
6664
if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
6666
_bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects",
6668
bfd_set_error (bfd_error_bad_value);
6674
#endif /* not sh_elf_merge_private_data */
6676
/* Override the generic function because we need to store sh_elf_obj_tdata
6677
as the specific tdata. We set also the machine architecture from flags
6681
sh_elf_object_p (bfd *abfd)
6683
if (! sh_elf_set_mach_from_flags (abfd))
6686
return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
6687
== fdpic_object_p (abfd));
6690
/* Finish up dynamic symbol handling. We set the contents of various
6691
dynamic sections here. */
6694
sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6695
struct elf_link_hash_entry *h,
6696
Elf_Internal_Sym *sym)
6698
struct elf_sh_link_hash_table *htab;
6700
htab = sh_elf_hash_table (info);
6704
if (h->plt.offset != (bfd_vma) -1)
6712
Elf_Internal_Rela rel;
6714
const struct elf_sh_plt_info *plt_info;
6716
/* This symbol has an entry in the procedure linkage table. Set
6719
BFD_ASSERT (h->dynindx != -1);
6722
sgotplt = htab->sgotplt;
6723
srelplt = htab->srelplt;
6724
BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
6726
/* Get the index in the procedure linkage table which
6727
corresponds to this symbol. This is the index of this symbol
6728
in all the symbols for which we are making plt entries. The
6729
first entry in the procedure linkage table is reserved. */
6730
plt_index = get_plt_index (htab->plt_info, h->plt.offset);
6732
plt_info = htab->plt_info;
6733
if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT)
6734
plt_info = plt_info->short_plt;
6736
/* Get the offset into the .got table of the entry that
6737
corresponds to this function. */
6739
/* The offset must be relative to the GOT symbol, twelve bytes
6740
before the end of .got.plt. Each descriptor is eight
6742
got_offset = plt_index * 8 + 12 - sgotplt->size;
6744
/* Each .got entry is 4 bytes. The first three are
6746
got_offset = (plt_index + 3) * 4;
6750
got_offset -= GOT_BIAS;
6753
/* Fill in the entry in the procedure linkage table. */
6754
memcpy (splt->contents + h->plt.offset,
6755
plt_info->symbol_entry,
6756
plt_info->symbol_entry_size);
6758
if (info->shared || htab->fdpic_p)
6760
if (plt_info->symbol_fields.got20)
6762
bfd_reloc_status_type r;
6763
r = install_movi20_field (output_bfd, got_offset,
6764
splt->owner, splt, splt->contents,
6766
+ plt_info->symbol_fields.got_entry);
6767
BFD_ASSERT (r == bfd_reloc_ok);
6770
install_plt_field (output_bfd, FALSE, got_offset,
6773
+ plt_info->symbol_fields.got_entry));
6777
BFD_ASSERT (!plt_info->symbol_fields.got20);
6779
install_plt_field (output_bfd, FALSE,
6780
(sgotplt->output_section->vma
6781
+ sgotplt->output_offset
6785
+ plt_info->symbol_fields.got_entry));
6786
if (htab->vxworks_p)
6788
unsigned int reachable_plts, plts_per_4k;
6791
/* Divide the PLT into groups. The first group contains
6792
REACHABLE_PLTS entries and the other groups contain
6793
PLTS_PER_4K entries. Entries in the first group can
6794
branch directly to .plt; those in later groups branch
6795
to the last element of the previous group. */
6796
/* ??? It would be better to create multiple copies of
6797
the common resolver stub. */
6798
reachable_plts = ((4096
6799
- plt_info->plt0_entry_size
6800
- (plt_info->symbol_fields.plt + 4))
6801
/ plt_info->symbol_entry_size) + 1;
6802
plts_per_4k = (4096 / plt_info->symbol_entry_size);
6803
if (plt_index < reachable_plts)
6804
distance = -(h->plt.offset
6805
+ plt_info->symbol_fields.plt);
6807
distance = -(((plt_index - reachable_plts) % plts_per_4k + 1)
6808
* plt_info->symbol_entry_size);
6810
/* Install the 'bra' with this offset. */
6811
bfd_put_16 (output_bfd,
6812
0xa000 | (0x0fff & ((distance - 4) / 2)),
6815
+ plt_info->symbol_fields.plt));
6818
install_plt_field (output_bfd, TRUE,
6819
splt->output_section->vma + splt->output_offset,
6822
+ plt_info->symbol_fields.plt));
6825
/* Make got_offset relative to the start of .got.plt. */
6828
got_offset += GOT_BIAS;
6831
got_offset = plt_index * 8;
6833
if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
6834
install_plt_field (output_bfd, FALSE,
6835
plt_index * sizeof (Elf32_External_Rela),
6838
+ plt_info->symbol_fields.reloc_offset));
6840
/* Fill in the entry in the global offset table. */
6841
bfd_put_32 (output_bfd,
6842
(splt->output_section->vma
6843
+ splt->output_offset
6845
+ plt_info->symbol_resolve_offset),
6846
sgotplt->contents + got_offset);
6848
bfd_put_32 (output_bfd,
6849
sh_elf_osec_to_segment (output_bfd,
6850
htab->splt->output_section),
6851
sgotplt->contents + got_offset + 4);
6853
/* Fill in the entry in the .rela.plt section. */
6854
rel.r_offset = (sgotplt->output_section->vma
6855
+ sgotplt->output_offset
6858
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE);
6860
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6863
rel.r_addend = GOT_BIAS;
6865
loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
6866
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6868
if (htab->vxworks_p && !info->shared)
6870
/* Create the .rela.plt.unloaded relocations for this PLT entry.
6871
Begin by pointing LOC to the first such relocation. */
6872
loc = (htab->srelplt2->contents
6873
+ (plt_index * 2 + 1) * sizeof (Elf32_External_Rela));
6875
/* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6876
for the PLT entry's pointer to the .got.plt entry. */
6877
rel.r_offset = (htab->splt->output_section->vma
6878
+ htab->splt->output_offset
6880
+ plt_info->symbol_fields.got_entry);
6881
rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6882
rel.r_addend = got_offset;
6883
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6884
loc += sizeof (Elf32_External_Rela);
6886
/* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6887
the .got.plt entry, which initially points to .plt. */
6888
rel.r_offset = (sgotplt->output_section->vma
6889
+ sgotplt->output_offset
6891
rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32);
6893
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6896
if (!h->def_regular)
6898
/* Mark the symbol as undefined, rather than as defined in
6899
the .plt section. Leave the value alone. */
6900
sym->st_shndx = SHN_UNDEF;
6904
if (h->got.offset != (bfd_vma) -1
6905
&& sh_elf_hash_entry (h)->got_type != GOT_TLS_GD
6906
&& sh_elf_hash_entry (h)->got_type != GOT_TLS_IE
6907
&& sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
6911
Elf_Internal_Rela rel;
6914
/* This symbol has an entry in the global offset table. Set it
6918
srelgot = htab->srelgot;
6919
BFD_ASSERT (sgot != NULL && srelgot != NULL);
6921
rel.r_offset = (sgot->output_section->vma
6922
+ sgot->output_offset
6923
+ (h->got.offset &~ (bfd_vma) 1));
6925
/* If this is a static link, or it is a -Bsymbolic link and the
6926
symbol is defined locally or was forced to be local because
6927
of a version file, we just want to emit a RELATIVE reloc.
6928
The entry in the global offset table will already have been
6929
initialized in the relocate_section function. */
6931
&& SYMBOL_REFERENCES_LOCAL (info, h))
6935
asection *sec = h->root.u.def.section;
6937
= elf_section_data (sec->output_section)->dynindx;
6939
rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
6940
rel.r_addend = (h->root.u.def.value
6941
+ h->root.u.def.section->output_offset);
6945
rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6946
rel.r_addend = (h->root.u.def.value
6947
+ h->root.u.def.section->output_section->vma
6948
+ h->root.u.def.section->output_offset);
6953
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6954
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6958
loc = srelgot->contents;
6959
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
6960
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6963
#ifdef INCLUDE_SHMEDIA
6965
struct elf_sh_link_hash_entry *eh;
6967
eh = (struct elf_sh_link_hash_entry *) h;
6968
if (eh->datalabel_got.offset != (bfd_vma) -1)
6972
Elf_Internal_Rela rel;
6975
/* This symbol has a datalabel entry in the global offset table.
6979
srelgot = htab->srelgot;
6980
BFD_ASSERT (sgot != NULL && srelgot != NULL);
6982
rel.r_offset = (sgot->output_section->vma
6983
+ sgot->output_offset
6984
+ (eh->datalabel_got.offset &~ (bfd_vma) 1));
6986
/* If this is a static link, or it is a -Bsymbolic link and the
6987
symbol is defined locally or was forced to be local because
6988
of a version file, we just want to emit a RELATIVE reloc.
6989
The entry in the global offset table will already have been
6990
initialized in the relocate_section function. */
6992
&& SYMBOL_REFERENCES_LOCAL (info, h))
6996
asection *sec = h->root.u.def.section;
6998
= elf_section_data (sec->output_section)->dynindx;
7000
rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
7001
rel.r_addend = (h->root.u.def.value
7002
+ h->root.u.def.section->output_offset);
7006
rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7007
rel.r_addend = (h->root.u.def.value
7008
+ h->root.u.def.section->output_section->vma
7009
+ h->root.u.def.section->output_offset);
7014
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7015
+ eh->datalabel_got.offset);
7016
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7020
loc = srelgot->contents;
7021
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
7022
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7030
Elf_Internal_Rela rel;
7033
/* This symbol needs a copy reloc. Set it up. */
7035
BFD_ASSERT (h->dynindx != -1
7036
&& (h->root.type == bfd_link_hash_defined
7037
|| h->root.type == bfd_link_hash_defweak));
7039
s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
7040
BFD_ASSERT (s != NULL);
7042
rel.r_offset = (h->root.u.def.value
7043
+ h->root.u.def.section->output_section->vma
7044
+ h->root.u.def.section->output_offset);
7045
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7047
loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7048
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7051
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7052
_GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7054
if (h == htab->root.hdynamic
7055
|| (!htab->vxworks_p && h == htab->root.hgot))
7056
sym->st_shndx = SHN_ABS;
7061
/* Finish up the dynamic sections. */
7064
sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
7066
struct elf_sh_link_hash_table *htab;
7070
htab = sh_elf_hash_table (info);
7074
sgotplt = htab->sgotplt;
7075
sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
7077
if (htab->root.dynamic_sections_created)
7080
Elf32_External_Dyn *dyncon, *dynconend;
7082
BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
7084
dyncon = (Elf32_External_Dyn *) sdyn->contents;
7085
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7086
for (; dyncon < dynconend; dyncon++)
7088
Elf_Internal_Dyn dyn;
7090
#ifdef INCLUDE_SHMEDIA
7094
bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
7100
&& elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7101
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7104
#ifdef INCLUDE_SHMEDIA
7106
name = info->init_function;
7110
name = info->fini_function;
7112
if (dyn.d_un.d_val != 0)
7114
struct elf_link_hash_entry *h;
7116
h = elf_link_hash_lookup (&htab->root, name,
7117
FALSE, FALSE, TRUE);
7118
if (h != NULL && (h->other & STO_SH5_ISA32))
7120
dyn.d_un.d_val |= 1;
7121
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7128
BFD_ASSERT (htab->root.hgot != NULL);
7129
s = htab->root.hgot->root.u.def.section;
7130
dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value
7131
+ s->output_section->vma + s->output_offset;
7132
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7136
s = htab->srelplt->output_section;
7137
BFD_ASSERT (s != NULL);
7138
dyn.d_un.d_ptr = s->vma;
7139
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7143
s = htab->srelplt->output_section;
7144
BFD_ASSERT (s != NULL);
7145
dyn.d_un.d_val = s->size;
7146
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7150
/* My reading of the SVR4 ABI indicates that the
7151
procedure linkage table relocs (DT_JMPREL) should be
7152
included in the overall relocs (DT_RELA). This is
7153
what Solaris does. However, UnixWare can not handle
7154
that case. Therefore, we override the DT_RELASZ entry
7155
here to make it not include the JMPREL relocs. Since
7156
the linker script arranges for .rela.plt to follow all
7157
other relocation sections, we don't have to worry
7158
about changing the DT_RELA entry. */
7159
if (htab->srelplt != NULL)
7161
s = htab->srelplt->output_section;
7162
dyn.d_un.d_val -= s->size;
7164
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7169
/* Fill in the first entry in the procedure linkage table. */
7171
if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
7175
memcpy (splt->contents,
7176
htab->plt_info->plt0_entry,
7177
htab->plt_info->plt0_entry_size);
7178
for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
7179
if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
7180
install_plt_field (output_bfd, FALSE,
7181
(sgotplt->output_section->vma
7182
+ sgotplt->output_offset
7185
+ htab->plt_info->plt0_got_fields[i]));
7187
if (htab->vxworks_p)
7189
/* Finalize the .rela.plt.unloaded contents. */
7190
Elf_Internal_Rela rel;
7193
/* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7194
first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7195
loc = htab->srelplt2->contents;
7196
rel.r_offset = (splt->output_section->vma
7197
+ splt->output_offset
7198
+ htab->plt_info->plt0_got_fields[2]);
7199
rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
7201
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7202
loc += sizeof (Elf32_External_Rela);
7204
/* Fix up the remaining .rela.plt.unloaded relocations.
7205
They may have the wrong symbol index for _G_O_T_ or
7206
_P_L_T_ depending on the order in which symbols were
7208
while (loc < htab->srelplt2->contents + htab->srelplt2->size)
7210
/* The PLT entry's pointer to the .got.plt slot. */
7211
bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7212
rel.r_info = ELF32_R_INFO (htab->root.hgot->indx,
7214
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7215
loc += sizeof (Elf32_External_Rela);
7217
/* The .got.plt slot's pointer to .plt. */
7218
bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7219
rel.r_info = ELF32_R_INFO (htab->root.hplt->indx,
7221
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7222
loc += sizeof (Elf32_External_Rela);
7226
/* UnixWare sets the entsize of .plt to 4, although that doesn't
7227
really seem like the right value. */
7228
elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7232
/* Fill in the first three entries in the global offset table. */
7233
if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p)
7236
bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
7238
bfd_put_32 (output_bfd,
7239
sdyn->output_section->vma + sdyn->output_offset,
7241
bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
7242
bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
7245
if (sgotplt && sgotplt->size > 0)
7246
elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
7248
/* At the very end of the .rofixup section is a pointer to the GOT. */
7249
if (htab->fdpic_p && htab->srofixup != NULL)
7251
struct elf_link_hash_entry *hgot = htab->root.hgot;
7252
bfd_vma got_value = hgot->root.u.def.value
7253
+ hgot->root.u.def.section->output_section->vma
7254
+ hgot->root.u.def.section->output_offset;
7256
sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
7258
/* Make sure we allocated and generated the same number of fixups. */
7259
BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
7262
if (htab->srelfuncdesc)
7263
BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
7264
== htab->srelfuncdesc->size);
7267
BFD_ASSERT (htab->srelgot->reloc_count * sizeof (Elf32_External_Rela)
7268
== htab->srelgot->size);
7273
static enum elf_reloc_type_class
7274
sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
7275
const asection *rel_sec ATTRIBUTE_UNUSED,
7276
const Elf_Internal_Rela *rela)
7278
switch ((int) ELF32_R_TYPE (rela->r_info))
7281
return reloc_class_relative;
7283
return reloc_class_plt;
7285
return reloc_class_copy;
7287
return reloc_class_normal;
7291
#if !defined SH_TARGET_ALREADY_DEFINED
7292
/* Support for Linux core dump NOTE sections. */
7295
elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7300
switch (note->descsz)
7305
case 168: /* Linux/SH */
7307
elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
7310
elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
7319
/* Make a ".reg/999" section. */
7320
return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7321
size, note->descpos + offset);
7325
elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7327
switch (note->descsz)
7332
case 124: /* Linux/SH elf_prpsinfo */
7333
elf_tdata (abfd)->core->program
7334
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7335
elf_tdata (abfd)->core->command
7336
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7339
/* Note that for some reason, a spurious space is tacked
7340
onto the end of the args in some (at least one anyway)
7341
implementations, so strip it off if it exists. */
7344
char *command = elf_tdata (abfd)->core->command;
7345
int n = strlen (command);
7347
if (0 < n && command[n - 1] == ' ')
7348
command[n - 1] = '\0';
7353
#endif /* not SH_TARGET_ALREADY_DEFINED */
7356
/* Return address for Ith PLT stub in section PLT, for relocation REL
7357
or (bfd_vma) -1 if it should not be included. */
7360
sh_elf_plt_sym_val (bfd_vma i, const asection *plt,
7361
const arelent *rel ATTRIBUTE_UNUSED)
7363
const struct elf_sh_plt_info *plt_info;
7365
plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0);
7366
return plt->vma + get_plt_offset (plt_info, i);
7369
/* Decide whether to attempt to turn absptr or lsda encodings in
7370
shared libraries into pcrel within the given input section. */
7373
sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
7374
struct bfd_link_info *info,
7375
asection *eh_frame_section ATTRIBUTE_UNUSED)
7377
struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7379
/* We can't use PC-relative encodings in FDPIC binaries, in general. */
7386
/* Adjust the contents of an eh_frame_hdr section before they're output. */
7389
sh_elf_encode_eh_address (bfd *abfd,
7390
struct bfd_link_info *info,
7391
asection *osec, bfd_vma offset,
7392
asection *loc_sec, bfd_vma loc_offset,
7395
struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7396
struct elf_link_hash_entry *h;
7399
return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec,
7400
loc_offset, encoded);
7402
h = htab->root.hgot;
7403
BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
7405
if (! h || (sh_elf_osec_to_segment (abfd, osec)
7406
== sh_elf_osec_to_segment (abfd, loc_sec->output_section)))
7407
return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
7408
loc_sec, loc_offset, encoded);
7410
BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec)
7411
== (sh_elf_osec_to_segment
7412
(abfd, h->root.u.def.section->output_section)));
7414
*encoded = osec->vma + offset
7415
- (h->root.u.def.value
7416
+ h->root.u.def.section->output_section->vma
7417
+ h->root.u.def.section->output_offset);
7419
return DW_EH_PE_datarel | DW_EH_PE_sdata4;
7422
#if !defined SH_TARGET_ALREADY_DEFINED
7423
#define TARGET_BIG_SYM bfd_elf32_sh_vec
7424
#define TARGET_BIG_NAME "elf32-sh"
7425
#define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7426
#define TARGET_LITTLE_NAME "elf32-shl"
7429
#define ELF_ARCH bfd_arch_sh
7430
#define ELF_TARGET_ID SH_ELF_DATA
7431
#define ELF_MACHINE_CODE EM_SH
7432
#ifdef __QNXTARGET__
7433
#define ELF_MAXPAGESIZE 0x1000
7435
#define ELF_MAXPAGESIZE 0x80
7438
#define elf_symbol_leading_char '_'
7440
#define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7441
#define bfd_elf32_bfd_reloc_name_lookup \
7442
sh_elf_reloc_name_lookup
7443
#define elf_info_to_howto sh_elf_info_to_howto
7444
#define bfd_elf32_bfd_relax_section sh_elf_relax_section
7445
#define elf_backend_relocate_section sh_elf_relocate_section
7446
#define bfd_elf32_bfd_get_relocated_section_contents \
7447
sh_elf_get_relocated_section_contents
7448
#define bfd_elf32_mkobject sh_elf_mkobject
7449
#define elf_backend_object_p sh_elf_object_p
7450
#define bfd_elf32_bfd_set_private_bfd_flags \
7451
sh_elf_set_private_flags
7452
#define bfd_elf32_bfd_copy_private_bfd_data \
7453
sh_elf_copy_private_data
7454
#define bfd_elf32_bfd_merge_private_bfd_data \
7455
sh_elf_merge_private_data
7457
#define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7458
#define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7459
#define elf_backend_check_relocs sh_elf_check_relocs
7460
#define elf_backend_copy_indirect_symbol \
7461
sh_elf_copy_indirect_symbol
7462
#define elf_backend_create_dynamic_sections \
7463
sh_elf_create_dynamic_sections
7464
#define bfd_elf32_bfd_link_hash_table_create \
7465
sh_elf_link_hash_table_create
7466
#define elf_backend_adjust_dynamic_symbol \
7467
sh_elf_adjust_dynamic_symbol
7468
#define elf_backend_always_size_sections \
7469
sh_elf_always_size_sections
7470
#define elf_backend_size_dynamic_sections \
7471
sh_elf_size_dynamic_sections
7472
#define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7473
#define elf_backend_finish_dynamic_symbol \
7474
sh_elf_finish_dynamic_symbol
7475
#define elf_backend_finish_dynamic_sections \
7476
sh_elf_finish_dynamic_sections
7477
#define elf_backend_reloc_type_class sh_elf_reloc_type_class
7478
#define elf_backend_plt_sym_val sh_elf_plt_sym_val
7479
#define elf_backend_can_make_relative_eh_frame \
7480
sh_elf_use_relative_eh_frame
7481
#define elf_backend_can_make_lsda_relative_eh_frame \
7482
sh_elf_use_relative_eh_frame
7483
#define elf_backend_encode_eh_address \
7484
sh_elf_encode_eh_address
7486
#define elf_backend_stack_align 8
7487
#define elf_backend_can_gc_sections 1
7488
#define elf_backend_can_refcount 1
7489
#define elf_backend_want_got_plt 1
7490
#define elf_backend_plt_readonly 1
7491
#define elf_backend_want_plt_sym 0
7492
#define elf_backend_got_header_size 12
7494
#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7496
#include "elf32-target.h"
7498
/* NetBSD support. */
7499
#undef TARGET_BIG_SYM
7500
#define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7501
#undef TARGET_BIG_NAME
7502
#define TARGET_BIG_NAME "elf32-sh-nbsd"
7503
#undef TARGET_LITTLE_SYM
7504
#define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7505
#undef TARGET_LITTLE_NAME
7506
#define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7507
#undef ELF_MAXPAGESIZE
7508
#define ELF_MAXPAGESIZE 0x10000
7509
#undef ELF_COMMONPAGESIZE
7510
#undef elf_symbol_leading_char
7511
#define elf_symbol_leading_char 0
7513
#define elf32_bed elf32_sh_nbsd_bed
7515
#include "elf32-target.h"
7518
/* Linux support. */
7519
#undef TARGET_BIG_SYM
7520
#define TARGET_BIG_SYM bfd_elf32_shblin_vec
7521
#undef TARGET_BIG_NAME
7522
#define TARGET_BIG_NAME "elf32-shbig-linux"
7523
#undef TARGET_LITTLE_SYM
7524
#define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7525
#undef TARGET_LITTLE_NAME
7526
#define TARGET_LITTLE_NAME "elf32-sh-linux"
7527
#undef ELF_COMMONPAGESIZE
7528
#define ELF_COMMONPAGESIZE 0x1000
7530
#undef elf_backend_grok_prstatus
7531
#define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7532
#undef elf_backend_grok_psinfo
7533
#define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7535
#define elf32_bed elf32_sh_lin_bed
7537
#include "elf32-target.h"
7540
/* FDPIC support. */
7541
#undef TARGET_BIG_SYM
7542
#define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7543
#undef TARGET_BIG_NAME
7544
#define TARGET_BIG_NAME "elf32-shbig-fdpic"
7545
#undef TARGET_LITTLE_SYM
7546
#define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7547
#undef TARGET_LITTLE_NAME
7548
#define TARGET_LITTLE_NAME "elf32-sh-fdpic"
7551
#define elf32_bed elf32_sh_fd_bed
7553
#include "elf32-target.h"
7555
#undef elf_backend_modify_program_headers
7557
/* VxWorks support. */
7558
#undef TARGET_BIG_SYM
7559
#define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7560
#undef TARGET_BIG_NAME
7561
#define TARGET_BIG_NAME "elf32-sh-vxworks"
7562
#undef TARGET_LITTLE_SYM
7563
#define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7564
#undef TARGET_LITTLE_NAME
7565
#define TARGET_LITTLE_NAME "elf32-shl-vxworks"
7567
#define elf32_bed elf32_sh_vxworks_bed
7569
#undef elf_backend_want_plt_sym
7570
#define elf_backend_want_plt_sym 1
7571
#undef elf_symbol_leading_char
7572
#define elf_symbol_leading_char '_'
7573
#define elf_backend_want_got_underscore 1
7574
#undef elf_backend_grok_prstatus
7575
#undef elf_backend_grok_psinfo
7576
#undef elf_backend_add_symbol_hook
7577
#define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7578
#undef elf_backend_link_output_symbol_hook
7579
#define elf_backend_link_output_symbol_hook \
7580
elf_vxworks_link_output_symbol_hook
7581
#undef elf_backend_emit_relocs
7582
#define elf_backend_emit_relocs elf_vxworks_emit_relocs
7583
#undef elf_backend_final_write_processing
7584
#define elf_backend_final_write_processing \
7585
elf_vxworks_final_write_processing
7586
#undef ELF_MAXPAGESIZE
7587
#define ELF_MAXPAGESIZE 0x1000
7588
#undef ELF_COMMONPAGESIZE
7590
#include "elf32-target.h"
7592
#endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */
added
removed
binutils-2.23.52.20130611/bfd/elf32-sh.c
