1
/* CRIS-specific support for 32-bit ELF.
2
Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
3
Contributed by Axis Communications AB.
4
Written by Hans-Peter Nilsson, based on elf32-fr30.c
5
PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c.
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29
/* Forward declarations. */
30
static reloc_howto_type * cris_reloc_type_lookup
31
PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
33
static void cris_info_to_howto_rela
34
PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
36
static boolean cris_elf_grok_prstatus
37
PARAMS ((bfd *abfd, Elf_Internal_Note *note));
39
static boolean cris_elf_grok_psinfo
40
PARAMS ((bfd *abfd, Elf_Internal_Note *note));
42
static boolean cris_elf_relocate_section
43
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
44
Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
46
static bfd_reloc_status_type cris_final_link_relocate
47
PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
48
Elf_Internal_Rela *, bfd_vma));
50
static boolean cris_elf_gc_sweep_hook
51
PARAMS ((bfd *, struct bfd_link_info *, asection *,
52
const Elf_Internal_Rela *));
54
static asection * cris_elf_gc_mark_hook
55
PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
56
struct elf_link_hash_entry *, Elf_Internal_Sym *));
58
static boolean cris_elf_object_p PARAMS ((bfd *));
60
static void cris_elf_final_write_processing PARAMS ((bfd *, boolean));
62
static boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
64
static boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
66
struct elf_cris_link_hash_entry;
67
static boolean elf_cris_discard_excess_dso_dynamics
68
PARAMS ((struct elf_cris_link_hash_entry *, PTR));
69
static boolean elf_cris_discard_excess_program_dynamics
70
PARAMS ((struct elf_cris_link_hash_entry *, PTR));
71
static boolean elf_cris_adjust_gotplt_to_got
72
PARAMS ((struct elf_cris_link_hash_entry *, PTR));
73
static boolean elf_cris_try_fold_plt_to_got
74
PARAMS ((struct elf_cris_link_hash_entry *, PTR));
75
static struct bfd_hash_entry *elf_cris_link_hash_newfunc
76
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
77
static struct bfd_link_hash_table *elf_cris_link_hash_table_create
79
static boolean elf_cris_adjust_dynamic_symbol
80
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
81
static boolean cris_elf_check_relocs
82
PARAMS ((bfd *, struct bfd_link_info *, asection *,
83
const Elf_Internal_Rela *));
85
static boolean elf_cris_size_dynamic_sections
86
PARAMS ((bfd *, struct bfd_link_info *));
87
static boolean elf_cris_finish_dynamic_symbol
88
PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
90
static boolean elf_cris_finish_dynamic_sections
91
PARAMS ((bfd *, struct bfd_link_info *));
92
static void elf_cris_hide_symbol
93
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
94
static enum elf_reloc_type_class elf_cris_reloc_type_class
95
PARAMS ((const Elf_Internal_Rela *));
97
static reloc_howto_type cris_elf_howto_table [] =
99
/* This reloc does nothing. */
100
HOWTO (R_CRIS_NONE, /* type */
102
2, /* size (0 = byte, 1 = short, 2 = long) */
104
false, /* pc_relative */
106
complain_overflow_bitfield, /* complain_on_overflow */
107
bfd_elf_generic_reloc, /* special_function */
108
"R_CRIS_NONE", /* name */
109
false, /* partial_inplace */
112
false), /* pcrel_offset */
114
/* An 8 bit absolute relocation. */
115
HOWTO (R_CRIS_8, /* type */
117
0, /* size (0 = byte, 1 = short, 2 = long) */
119
false, /* pc_relative */
121
complain_overflow_bitfield, /* complain_on_overflow */
122
bfd_elf_generic_reloc, /* special_function */
123
"R_CRIS_8", /* name */
124
false, /* partial_inplace */
125
0x0000, /* src_mask */
126
0x00ff, /* dst_mask */
127
false), /* pcrel_offset */
129
/* A 16 bit absolute relocation. */
130
HOWTO (R_CRIS_16, /* type */
132
1, /* size (0 = byte, 1 = short, 2 = long) */
134
false, /* pc_relative */
136
complain_overflow_bitfield, /* complain_on_overflow */
137
bfd_elf_generic_reloc, /* special_function */
138
"R_CRIS_16", /* name */
139
false, /* partial_inplace */
140
0x00000000, /* src_mask */
141
0x0000ffff, /* dst_mask */
142
false), /* pcrel_offset */
144
/* A 32 bit absolute relocation. */
145
HOWTO (R_CRIS_32, /* type */
147
2, /* size (0 = byte, 1 = short, 2 = long) */
149
false, /* pc_relative */
151
complain_overflow_bitfield, /* complain_on_overflow */
152
bfd_elf_generic_reloc, /* special_function */
153
"R_CRIS_32", /* name */
154
false, /* partial_inplace */
155
0x00000000, /* src_mask */
156
0xffffffff, /* dst_mask */
157
false), /* pcrel_offset */
159
/* An 8 bit PC-relative relocation. */
160
HOWTO (R_CRIS_8_PCREL, /* type */
162
0, /* size (0 = byte, 1 = short, 2 = long) */
164
true, /* pc_relative */
166
complain_overflow_bitfield, /* complain_on_overflow */
167
bfd_elf_generic_reloc, /* special_function */
168
"R_CRIS_8_PCREL", /* name */
169
false, /* partial_inplace */
170
0x0000, /* src_mask */
171
0x00ff, /* dst_mask */
172
true), /* pcrel_offset */
174
/* A 16 bit PC-relative relocation. */
175
HOWTO (R_CRIS_16_PCREL, /* type */
177
1, /* size (0 = byte, 1 = short, 2 = long) */
179
true, /* pc_relative */
181
complain_overflow_bitfield, /* complain_on_overflow */
182
bfd_elf_generic_reloc, /* special_function */
183
"R_CRIS_16_PCREL", /* name */
184
false, /* partial_inplace */
185
0x00000000, /* src_mask */
186
0x0000ffff, /* dst_mask */
187
true), /* pcrel_offset */
189
/* A 32 bit PC-relative relocation. */
190
HOWTO (R_CRIS_32_PCREL, /* type */
192
2, /* size (0 = byte, 1 = short, 2 = long) */
194
true, /* pc_relative */
196
complain_overflow_bitfield, /* complain_on_overflow */
197
bfd_elf_generic_reloc, /* special_function */
198
"R_CRIS_32_PCREL", /* name */
199
false, /* partial_inplace */
200
0x00000000, /* src_mask */
201
0xffffffff, /* dst_mask */
202
true), /* pcrel_offset */
204
/* GNU extension to record C++ vtable hierarchy. */
205
HOWTO (R_CRIS_GNU_VTINHERIT, /* type */
207
2, /* size (0 = byte, 1 = short, 2 = long) */
209
false, /* pc_relative */
211
complain_overflow_dont, /* complain_on_overflow */
212
NULL, /* special_function */
213
"R_CRIS_GNU_VTINHERIT", /* name */
214
false, /* partial_inplace */
217
false), /* pcrel_offset */
219
/* GNU extension to record C++ vtable member usage. */
220
HOWTO (R_CRIS_GNU_VTENTRY, /* type */
222
2, /* size (0 = byte, 1 = short, 2 = long) */
224
false, /* pc_relative */
226
complain_overflow_dont, /* complain_on_overflow */
227
_bfd_elf_rel_vtable_reloc_fn, /* special_function */
228
"R_CRIS_GNU_VTENTRY", /* name */
229
false, /* partial_inplace */
232
false), /* pcrel_offset */
234
/* This is used only by the dynamic linker. The symbol should exist
235
both in the object being run and in some shared library. The
236
dynamic linker copies the data addressed by the symbol from the
237
shared library into the object, because the object being
238
run has to have the data at some particular address. */
239
HOWTO (R_CRIS_COPY, /* type */
241
2, /* size (0 = byte, 1 = short, 2 = long) */
243
false, /* pc_relative */
245
complain_overflow_bitfield, /* complain_on_overflow */
246
bfd_elf_generic_reloc, /* special_function */
247
"R_CRIS_COPY", /* name */
248
false, /* partial_inplace */
251
false), /* pcrel_offset */
253
/* Like R_CRIS_32, but used when setting global offset table entries. */
254
HOWTO (R_CRIS_GLOB_DAT, /* type */
256
2, /* size (0 = byte, 1 = short, 2 = long) */
258
false, /* pc_relative */
260
complain_overflow_bitfield, /* complain_on_overflow */
261
bfd_elf_generic_reloc, /* special_function */
262
"R_CRIS_GLOB_DAT", /* name */
263
false, /* partial_inplace */
265
0xffffffff, /* dst_mask */
266
false), /* pcrel_offset */
268
/* Marks a procedure linkage table entry for a symbol. */
269
HOWTO (R_CRIS_JUMP_SLOT, /* type */
271
2, /* size (0 = byte, 1 = short, 2 = long) */
273
false, /* pc_relative */
275
complain_overflow_bitfield, /* complain_on_overflow */
276
bfd_elf_generic_reloc, /* special_function */
277
"R_CRIS_JUMP_SLOT", /* name */
278
false, /* partial_inplace */
281
false), /* pcrel_offset */
283
/* Used only by the dynamic linker. When the object is run, this
284
longword is set to the load address of the object, plus the
286
HOWTO (R_CRIS_RELATIVE, /* type */
288
2, /* size (0 = byte, 1 = short, 2 = long) */
290
false, /* pc_relative */
292
complain_overflow_bitfield, /* complain_on_overflow */
293
bfd_elf_generic_reloc, /* special_function */
294
"R_CRIS_RELATIVE", /* name */
295
false, /* partial_inplace */
297
0xffffffff, /* dst_mask */
298
false), /* pcrel_offset */
300
/* Like R_CRIS_32, but referring to the GOT table entry for the symbol. */
301
HOWTO (R_CRIS_16_GOT, /* type */
303
1, /* size (0 = byte, 1 = short, 2 = long) */
305
false, /* pc_relative */
307
complain_overflow_bitfield, /* complain_on_overflow */
308
bfd_elf_generic_reloc, /* special_function */
309
"R_CRIS_16_GOT", /* name */
310
false, /* partial_inplace */
312
0xffff, /* dst_mask */
313
false), /* pcrel_offset */
315
HOWTO (R_CRIS_32_GOT, /* type */
317
2, /* size (0 = byte, 1 = short, 2 = long) */
319
false, /* pc_relative */
321
complain_overflow_bitfield, /* complain_on_overflow */
322
bfd_elf_generic_reloc, /* special_function */
323
"R_CRIS_32_GOT", /* name */
324
false, /* partial_inplace */
326
0xffffffff, /* dst_mask */
327
false), /* pcrel_offset */
329
/* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
330
the GOT table for the symbol. */
331
HOWTO (R_CRIS_16_GOTPLT, /* type */
333
1, /* size (0 = byte, 1 = short, 2 = long) */
335
false, /* pc_relative */
337
complain_overflow_bitfield, /* complain_on_overflow */
338
bfd_elf_generic_reloc, /* special_function */
339
"R_CRIS_16_GOTPLT", /* name */
340
false, /* partial_inplace */
342
0xffff, /* dst_mask */
343
false), /* pcrel_offset */
345
HOWTO (R_CRIS_32_GOTPLT, /* type */
347
2, /* size (0 = byte, 1 = short, 2 = long) */
349
false, /* pc_relative */
351
complain_overflow_bitfield, /* complain_on_overflow */
352
bfd_elf_generic_reloc, /* special_function */
353
"R_CRIS_32_GOTPLT", /* name */
354
false, /* partial_inplace */
356
0xffffffff, /* dst_mask */
357
false), /* pcrel_offset */
359
/* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
361
HOWTO (R_CRIS_32_GOTREL, /* type */
363
2, /* size (0 = byte, 1 = short, 2 = long) */
365
false, /* pc_relative */
367
complain_overflow_bitfield, /* complain_on_overflow */
368
bfd_elf_generic_reloc, /* special_function */
369
"R_CRIS_32_GOTREL", /* name */
370
false, /* partial_inplace */
372
0xffffffff, /* dst_mask */
373
false), /* pcrel_offset */
375
/* A 32-bit offset from GOT to entry for this symbol in PLT and request
376
to create PLT entry for symbol. */
377
HOWTO (R_CRIS_32_PLT_GOTREL, /* type */
379
2, /* size (0 = byte, 1 = short, 2 = long) */
381
false, /* pc_relative */
383
complain_overflow_bitfield, /* complain_on_overflow */
384
bfd_elf_generic_reloc, /* special_function */
385
"R_CRIS_32_PLT_GOTREL", /* name */
386
false, /* partial_inplace */
388
0xffffffff, /* dst_mask */
389
false), /* pcrel_offset */
391
/* A 32-bit offset from PC (location after the relocation) + addend to
392
entry for this symbol in PLT and request to create PLT entry for
394
HOWTO (R_CRIS_32_PLT_PCREL, /* type */
396
2, /* size (0 = byte, 1 = short, 2 = long) */
398
true, /* pc_relative */
400
complain_overflow_bitfield, /* complain_on_overflow */
401
bfd_elf_generic_reloc, /* special_function */
402
"R_CRIS_32_PLT_PCREL", /* name */
403
false, /* partial_inplace */
405
0xffffffff, /* dst_mask */
406
true) /* pcrel_offset */
409
/* Map BFD reloc types to CRIS ELF reloc types. */
411
struct cris_reloc_map
413
bfd_reloc_code_real_type bfd_reloc_val;
414
unsigned int cris_reloc_val;
417
static const struct cris_reloc_map cris_reloc_map [] =
419
{ BFD_RELOC_NONE, R_CRIS_NONE },
420
{ BFD_RELOC_8, R_CRIS_8 },
421
{ BFD_RELOC_16, R_CRIS_16 },
422
{ BFD_RELOC_32, R_CRIS_32 },
423
{ BFD_RELOC_8_PCREL, R_CRIS_8_PCREL },
424
{ BFD_RELOC_16_PCREL, R_CRIS_16_PCREL },
425
{ BFD_RELOC_32_PCREL, R_CRIS_32_PCREL },
426
{ BFD_RELOC_VTABLE_INHERIT, R_CRIS_GNU_VTINHERIT },
427
{ BFD_RELOC_VTABLE_ENTRY, R_CRIS_GNU_VTENTRY },
428
{ BFD_RELOC_CRIS_COPY, R_CRIS_COPY },
429
{ BFD_RELOC_CRIS_GLOB_DAT, R_CRIS_GLOB_DAT },
430
{ BFD_RELOC_CRIS_JUMP_SLOT, R_CRIS_JUMP_SLOT },
431
{ BFD_RELOC_CRIS_RELATIVE, R_CRIS_RELATIVE },
432
{ BFD_RELOC_CRIS_16_GOT, R_CRIS_16_GOT },
433
{ BFD_RELOC_CRIS_32_GOT, R_CRIS_32_GOT },
434
{ BFD_RELOC_CRIS_16_GOTPLT, R_CRIS_16_GOTPLT },
435
{ BFD_RELOC_CRIS_32_GOTPLT, R_CRIS_32_GOTPLT },
436
{ BFD_RELOC_CRIS_32_GOTREL, R_CRIS_32_GOTREL },
437
{ BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL },
438
{ BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL }
441
static reloc_howto_type *
442
cris_reloc_type_lookup (abfd, code)
443
bfd * abfd ATTRIBUTE_UNUSED;
444
bfd_reloc_code_real_type code;
448
for (i = 0; i < sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]); i++)
449
if (cris_reloc_map [i].bfd_reloc_val == code)
450
return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val];
455
/* Set the howto pointer for an CRIS ELF reloc. */
458
cris_info_to_howto_rela (abfd, cache_ptr, dst)
459
bfd * abfd ATTRIBUTE_UNUSED;
461
Elf32_Internal_Rela * dst;
465
r_type = ELF32_R_TYPE (dst->r_info);
466
BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
467
cache_ptr->howto = & cris_elf_howto_table [r_type];
470
/* Support for core dump NOTE sections. */
473
cris_elf_grok_prstatus (abfd, note)
475
Elf_Internal_Note *note;
480
switch (note->descsz)
485
case 214: /* Linux/CRIS */
487
elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
490
elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
499
/* Make a ".reg/999" section. */
500
return _bfd_elfcore_make_pseudosection (abfd, ".reg",
501
raw_size, note->descpos + offset);
505
cris_elf_grok_psinfo (abfd, note)
507
Elf_Internal_Note *note;
509
switch (note->descsz)
514
case 124: /* Linux/CRIS elf_prpsinfo */
515
elf_tdata (abfd)->core_program
516
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
517
elf_tdata (abfd)->core_command
518
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
521
/* Note that for some reason, a spurious space is tacked
522
onto the end of the args in some (at least one anyway)
523
implementations, so strip it off if it exists. */
526
char *command = elf_tdata (abfd)->core_command;
527
int n = strlen (command);
529
if (0 < n && command[n - 1] == ' ')
530
command[n - 1] = '\0';
536
/* The name of the dynamic interpreter. This is put in the .interp
539
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
541
/* The size in bytes of an entry in the procedure linkage table. */
543
#define PLT_ENTRY_SIZE 20
545
/* The first entry in an absolute procedure linkage table looks like this. */
547
static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] =
550
0x7e, 0x7e, /* push mof. */
551
0x7f, 0x0d, /* (dip [pc+]) */
552
0, 0, 0, 0, /* Replaced with address of .got + 4. */
553
0x30, 0x7a, /* move [...],mof */
554
0x7f, 0x0d, /* (dip [pc+]) */
555
0, 0, 0, 0, /* Replaced with address of .got + 8. */
556
0x30, 0x09, /* jump [...] */
559
/* Subsequent entries in an absolute procedure linkage table look like
562
static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] =
564
0x7f, 0x0d, /* (dip [pc+]) */
565
0, 0, 0, 0, /* Replaced with address of this symbol in .got. */
566
0x30, 0x09, /* jump [...] */
567
0x3f, 0x7e, /* move [pc+],mof */
568
0, 0, 0, 0, /* Replaced with offset into relocation table. */
569
0x2f, 0xfe, /* add.d [pc+],pc */
571
0xff, 0xff /* Replaced with offset to start of .plt. */
574
/* The first entry in a PIC procedure linkage table looks like this. */
576
static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] =
578
0xfc, 0xe1, 0x7e, 0x7e, /* push mof */
579
0x04, 0x01, 0x30, 0x7a, /* move [r0+4],mof */
580
0x08, 0x01, 0x30, 0x09, /* jump [r0+8] */
581
0, 0, 0, 0, 0, 0, 0, 0, /* Pad out to 20 bytes. */
584
/* Subsequent entries in a PIC procedure linkage table look like this. */
586
static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] =
588
0x6f, 0x0d, /* (bdap [pc+].d,r0) */
589
0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */
590
0x30, 0x09, /* jump [...] */
591
0x3f, 0x7e, /* move [pc+],mof */
592
0, 0, 0, 0, /* Replaced with offset into relocation table. */
593
0x2f, 0xfe, /* add.d [pc+],pc */
594
0xec, 0xff, /* Replaced with offset to start of .plt. */
598
/* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits
599
(and most other PIC/shlib stuff). Check that we don't drift away
602
The CRIS linker, like the m68k and i386 linkers (and probably the rest
603
too) needs to keep track of the number of relocs that it decides to
604
copy in check_relocs for each symbol. This is so that it can discard
605
PC relative relocs if it doesn't need them when linking with
606
-Bsymbolic. We store the information in a field extending the regular
607
ELF linker hash table. */
609
/* This structure keeps track of the number of PC relative relocs we have
610
copied for a given symbol. */
612
struct elf_cris_pcrel_relocs_copied
615
struct elf_cris_pcrel_relocs_copied *next;
616
/* A section in dynobj. */
618
/* Number of relocs copied in this section. */
622
/* CRIS ELF linker hash entry. */
624
struct elf_cris_link_hash_entry
626
struct elf_link_hash_entry root;
628
/* Number of PC relative relocs copied for this symbol. */
629
struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied;
631
/* The GOTPLT references are CRIS-specific; the goal is to avoid having
632
both a general GOT and a PLT-specific GOT entry for the same symbol,
633
when it is referenced both as a function and as a function pointer.
635
Number of GOTPLT references for a function. */
636
bfd_signed_vma gotplt_refcount;
638
/* Actual GOTPLT index for this symbol, if applicable, or zero if not
639
(zero is never used as an index). FIXME: We should be able to fold
640
this with gotplt_refcount in a union, like the got and plt unions in
641
elf_link_hash_entry. */
642
bfd_size_type gotplt_offset;
645
/* CRIS ELF linker hash table. */
647
struct elf_cris_link_hash_table
649
struct elf_link_hash_table root;
651
/* We can't use the PLT offset and calculate to get the GOTPLT offset,
652
since we try and avoid creating GOTPLT:s when there's already a GOT.
653
Instead, we keep and update the next available index here. */
654
bfd_size_type next_gotplt_entry;
657
/* Traverse a CRIS ELF linker hash table. */
659
#define elf_cris_link_hash_traverse(table, func, info) \
660
(elf_link_hash_traverse \
662
(boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
665
/* Get the CRIS ELF linker hash table from a link_info structure. */
667
#define elf_cris_hash_table(p) \
668
((struct elf_cris_link_hash_table *) (p)->hash)
670
/* Create an entry in a CRIS ELF linker hash table. */
672
static struct bfd_hash_entry *
673
elf_cris_link_hash_newfunc (entry, table, string)
674
struct bfd_hash_entry *entry;
675
struct bfd_hash_table *table;
678
struct elf_cris_link_hash_entry *ret =
679
(struct elf_cris_link_hash_entry *) entry;
681
/* Allocate the structure if it has not already been allocated by a
683
if (ret == (struct elf_cris_link_hash_entry *) NULL)
684
ret = ((struct elf_cris_link_hash_entry *)
685
bfd_hash_allocate (table,
686
sizeof (struct elf_cris_link_hash_entry)));
687
if (ret == (struct elf_cris_link_hash_entry *) NULL)
688
return (struct bfd_hash_entry *) ret;
690
/* Call the allocation method of the superclass. */
691
ret = ((struct elf_cris_link_hash_entry *)
692
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
694
if (ret != (struct elf_cris_link_hash_entry *) NULL)
696
ret->pcrel_relocs_copied = NULL;
697
ret->gotplt_refcount = 0;
698
ret->gotplt_offset = 0;
701
return (struct bfd_hash_entry *) ret;
704
/* Create a CRIS ELF linker hash table. */
706
static struct bfd_link_hash_table *
707
elf_cris_link_hash_table_create (abfd)
710
struct elf_cris_link_hash_table *ret;
711
bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
713
ret = ((struct elf_cris_link_hash_table *) bfd_malloc (amt));
714
if (ret == (struct elf_cris_link_hash_table *) NULL)
717
if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
718
elf_cris_link_hash_newfunc))
724
/* Initialize to skip over the first three entries in the gotplt; they
725
are used for run-time symbol evaluation. */
726
ret->next_gotplt_entry = 12;
728
return &ret->root.root;
731
/* Perform a single relocation. By default we use the standard BFD
732
routines, with a few tweaks. */
734
static bfd_reloc_status_type
735
cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
737
reloc_howto_type * howto;
739
asection * input_section;
741
Elf_Internal_Rela * rel;
744
bfd_reloc_status_type r;
746
/* PC-relative relocations are relative to the position *after*
747
the reloc. Note that for R_CRIS_8_PCREL the adjustment is
748
not a single byte, since PC must be 16-bit-aligned. */
749
switch (ELF32_R_TYPE (rel->r_info))
751
/* Check that the 16-bit GOT relocs are positive. */
752
case R_CRIS_16_GOTPLT:
754
if ((bfd_signed_vma) relocation < 0)
755
return bfd_reloc_overflow;
758
case R_CRIS_32_PLT_PCREL:
759
case R_CRIS_32_PCREL:
763
case R_CRIS_16_PCREL:
771
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
772
contents, rel->r_offset,
773
relocation, rel->r_addend);
777
/* Relocate an CRIS ELF section. See elf32-fr30.c, from where this was
778
copied, for further comments. */
781
cris_elf_relocate_section (output_bfd, info, input_bfd, input_section,
782
contents, relocs, local_syms, local_sections)
783
bfd * output_bfd ATTRIBUTE_UNUSED;
784
struct bfd_link_info * info;
786
asection * input_section;
788
Elf_Internal_Rela * relocs;
789
Elf_Internal_Sym * local_syms;
790
asection ** local_sections;
793
Elf_Internal_Shdr * symtab_hdr;
794
struct elf_link_hash_entry ** sym_hashes;
795
bfd_vma *local_got_offsets;
799
Elf_Internal_Rela * rel;
800
Elf_Internal_Rela * relend;
802
dynobj = elf_hash_table (info)->dynobj;
803
local_got_offsets = elf_local_got_offsets (input_bfd);
804
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
805
sym_hashes = elf_sym_hashes (input_bfd);
806
relend = relocs + input_section->reloc_count;
814
splt = bfd_get_section_by_name (dynobj, ".plt");
815
sgot = bfd_get_section_by_name (dynobj, ".got");
818
for (rel = relocs; rel < relend; rel ++)
820
reloc_howto_type * howto;
821
unsigned long r_symndx;
822
Elf_Internal_Sym * sym;
824
struct elf_link_hash_entry * h;
826
bfd_reloc_status_type r;
827
const char * symname = NULL;
830
r_type = ELF32_R_TYPE (rel->r_info);
832
if ( r_type == R_CRIS_GNU_VTINHERIT
833
|| r_type == R_CRIS_GNU_VTENTRY)
836
r_symndx = ELF32_R_SYM (rel->r_info);
838
if (info->relocateable)
840
/* This is a relocateable link. We don't have to change
841
anything, unless the reloc is against a section symbol,
842
in which case we have to adjust according to where the
843
section symbol winds up in the output section. */
844
if (r_symndx < symtab_hdr->sh_info)
846
sym = local_syms + r_symndx;
848
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
850
sec = local_sections [r_symndx];
851
rel->r_addend += sec->output_offset + sym->st_value;
858
/* This is a final link. */
859
howto = cris_elf_howto_table + r_type;
864
if (r_symndx < symtab_hdr->sh_info)
866
sym = local_syms + r_symndx;
867
sec = local_sections [r_symndx];
868
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
870
symname = (bfd_elf_string_from_elf_section
871
(input_bfd, symtab_hdr->sh_link, sym->st_name));
873
symname = bfd_section_name (input_bfd, sec);
877
/* It seems this can happen with erroneous or unsupported input
878
(mixing a.out and elf in an archive, for example.) */
879
if (sym_hashes == NULL)
882
h = sym_hashes [r_symndx - symtab_hdr->sh_info];
884
while (h->root.type == bfd_link_hash_indirect
885
|| h->root.type == bfd_link_hash_warning)
886
h = (struct elf_link_hash_entry *) h->root.u.i.link;
888
symname = h->root.root.string;
890
if (h->root.type == bfd_link_hash_defined
891
|| h->root.type == bfd_link_hash_defweak)
893
sec = h->root.u.def.section;
895
/* Perhaps we should detect the cases that
896
sec->output_section is expected to be NULL like i386 and
897
m68k, but apparently (and according to elfxx-ia64.c) all
898
valid cases are where the symbol is defined in a shared
899
object which we link dynamically against. This includes
900
PLT relocs for which we've created a PLT entry and other
901
relocs for which we're prepared to create dynamic
904
For now, new situations cause us to just err when
905
sec->output_offset is NULL but the object with the symbol
906
is *not* dynamically linked against. Thus this will
907
automatically remind us so we can see if there are other
908
valid cases we need to revisit. */
909
if ((sec->output_section == NULL
910
&& (sec->owner->flags & DYNAMIC) != 0)
912
/* Here follow the cases where the relocation value must
913
be zero (or when further handling is simplified when
914
zero). I can't claim to understand the various
915
conditions and they weren't described in the files
916
where I copied them from (elf32-m68k.c and
917
elf32-i386.c), but let's mention examples of where
918
they happen. FIXME: Perhaps define and use a
919
dynamic_symbol_p function like ia64.
921
- When creating a shared library, we can have an
922
ordinary relocation for a symbol defined in a shared
923
library (perhaps the one we create). We then make
924
the relocation value zero, as the value seen now will
925
be added into the relocation addend in this shared
926
library, but must be handled only at dynamic-link
927
time. FIXME: Not sure this example covers the
928
h->elf_link_hash_flags test, though it's there in
931
&& ((! info->symbolic && h->dynindx != -1)
932
|| (h->elf_link_hash_flags
933
& ELF_LINK_HASH_DEF_REGULAR) == 0)
934
&& (input_section->flags & SEC_ALLOC) != 0
935
&& (r_type == R_CRIS_8
936
|| r_type == R_CRIS_16
937
|| r_type == R_CRIS_32
938
|| r_type == R_CRIS_8_PCREL
939
|| r_type == R_CRIS_16_PCREL
940
|| r_type == R_CRIS_32_PCREL)))
942
else if (sec->output_section != NULL)
943
relocation = (h->root.u.def.value
944
+ sec->output_section->vma
945
+ sec->output_offset);
948
(*_bfd_error_handler)
949
(_("%s: unresolvable relocation %s against symbol `%s' from %s section"),
950
bfd_archive_filename (input_bfd),
951
cris_elf_howto_table[r_type].name,
953
bfd_get_section_name (input_bfd, input_section));
954
bfd_set_error (bfd_error_bad_value);
958
else if (h->root.type == bfd_link_hash_undefweak)
960
else if (info->shared
961
&& (!info->symbolic || info->allow_shlib_undefined)
962
&& !info->no_undefined
963
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
967
if (!(info->callbacks->undefined_symbol
968
(info, symname, input_bfd,
969
input_section, rel->r_offset,
970
(!info->shared || info->no_undefined
971
|| ELF_ST_VISIBILITY (h->other)))))
979
case R_CRIS_16_GOTPLT:
980
case R_CRIS_32_GOTPLT:
981
/* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
982
but we require a PLT, and the PLT handling will take care of
983
filling in the PLT-specific GOT entry. For the GOT offset,
984
calculate it as we do when filling it in for the .got.plt
985
section. If we don't have a PLT, punt to GOT handling. */
987
&& ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
990
= bfd_get_section_by_name (dynobj, ".got.plt");
993
BFD_ASSERT (h->dynindx != -1);
994
BFD_ASSERT (sgotplt != NULL);
997
= ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
999
relocation = got_offset;
1003
/* We didn't make a PLT entry for this symbol. Maybe everything is
1004
folded into the GOT. Other than folding, this happens when
1005
statically linking PIC code, or when using -Bsymbolic. Check
1006
that we instead have a GOT entry as done for us by
1007
elf_cris_adjust_dynamic_symbol, and drop through into the
1008
ordinary GOT cases. */
1009
if (h != NULL && h->got.offset == (bfd_vma) -1)
1011
(*_bfd_error_handler)
1012
(_("%s: No PLT nor GOT for relocation %s against symbol `%s' from %s section"),
1013
bfd_archive_filename (input_bfd),
1014
cris_elf_howto_table[r_type].name,
1015
symname[0] != '\0' ? symname : _("[whose name is lost]"),
1016
bfd_get_section_name (input_bfd, input_section));
1018
/* FIXME: Perhaps blaming input is not the right thing to
1019
do; this is probably an internal error. But it is true
1020
that we didn't like that particular input. */
1021
bfd_set_error (bfd_error_bad_value);
1026
/* The size of the actual relocation is not used here; we only
1027
fill in the GOT table here. */
1033
/* Note that despite using RELA relocations, the .got contents
1034
is always filled in with the link-relative relocation
1035
value; the addend. */
1039
off = h->got.offset;
1040
BFD_ASSERT (off != (bfd_vma) -1);
1042
if (!elf_hash_table (info)->dynamic_sections_created
1043
|| (! info->shared && h->dynindx == -1)
1045
&& (info->symbolic || h->dynindx == -1)
1046
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1048
/* This wasn't checked above for ! info->shared, but
1049
must hold there if we get here; the symbol must be
1050
defined in the regular program, or be undefweak. */
1051
BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1053
|| (h->elf_link_hash_flags
1054
& ELF_LINK_HASH_DEF_REGULAR) != 0
1055
|| h->root.type == bfd_link_hash_undefweak);
1057
/* This is actually a static link, or it is a
1058
-Bsymbolic link and the symbol is defined locally,
1059
or is undefweak, or the symbol was forced to be
1060
local because of a version file, or we're not
1061
creating a dynamic object. We must initialize this
1062
entry in the global offset table. Since the offset
1063
must always be a multiple of 4, we use the least
1064
significant bit to record whether we have
1065
initialized it already.
1067
If this GOT entry should be runtime-initialized, we
1068
will create a .rela.got relocation entry to
1069
initialize the value. This is done in the
1070
finish_dynamic_symbol routine. */
1075
bfd_put_32 (output_bfd, relocation,
1076
sgot->contents + off);
1083
BFD_ASSERT (local_got_offsets != NULL
1084
&& local_got_offsets[r_symndx] != (bfd_vma) -1);
1086
off = local_got_offsets[r_symndx];
1088
/* The offset must always be a multiple of 4. We use
1089
the least significant bit to record whether we have
1090
already generated the necessary reloc. */
1095
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1100
Elf_Internal_Rela outrel;
1102
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1103
BFD_ASSERT (srelgot != NULL);
1105
outrel.r_offset = (sgot->output_section->vma
1106
+ sgot->output_offset
1108
outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1109
outrel.r_addend = relocation;
1110
bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1111
(((Elf32_External_Rela *)
1113
+ srelgot->reloc_count));
1114
++srelgot->reloc_count;
1117
local_got_offsets[r_symndx] |= 1;
1121
relocation = sgot->output_offset + off;
1122
if (rel->r_addend != 0)
1124
/* We can't do anything for a relocation which is against
1125
a symbol *plus offset*. GOT holds relocations for
1126
symbols. Make this an error; the compiler isn't
1127
allowed to pass us these kinds of things. */
1129
(*_bfd_error_handler)
1130
(_("%s: relocation %s with non-zero addend %d against local symbol from %s section"),
1131
bfd_archive_filename (input_bfd),
1132
cris_elf_howto_table[r_type].name,
1134
bfd_get_section_name (input_bfd, input_section));
1136
(*_bfd_error_handler)
1137
(_("%s: relocation %s with non-zero addend %d against symbol `%s' from %s section"),
1138
bfd_archive_filename (input_bfd),
1139
cris_elf_howto_table[r_type].name,
1141
symname[0] != '\0' ? symname : _("[whose name is lost]"),
1142
bfd_get_section_name (input_bfd, input_section));
1144
bfd_set_error (bfd_error_bad_value);
1150
case R_CRIS_32_GOTREL:
1151
/* This relocation must only be performed against local symbols. */
1152
if (h != NULL && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1154
(*_bfd_error_handler)
1155
(_("%s: relocation %s is not allowed for global symbol: `%s' from %s section"),
1156
bfd_archive_filename (input_bfd),
1157
cris_elf_howto_table[r_type].name,
1159
bfd_get_section_name (input_bfd, input_section));
1160
bfd_set_error (bfd_error_bad_value);
1164
/* This can happen if we get a link error with the input ELF
1165
variant mismatching the output variant. Emit an error so
1166
it's noticed if it happens elsewhere. */
1169
(*_bfd_error_handler)
1170
(_("%s: relocation %s in section %s with no GOT created"),
1171
bfd_archive_filename (input_bfd),
1172
cris_elf_howto_table[r_type].name,
1173
bfd_get_section_name (input_bfd, input_section));
1174
bfd_set_error (bfd_error_bad_value);
1178
/* This relocation is like a PC-relative one, except the
1179
reference point is the location of GOT. Note that
1180
sgot->output_offset is not involved in this calculation. We
1181
always want the start of entire .got section, not the
1182
position after the reserved header. */
1183
relocation -= sgot->output_section->vma;
1186
case R_CRIS_32_PLT_PCREL:
1187
/* Relocation is to the entry for this symbol in the
1188
procedure linkage table. */
1190
/* Resolve a PLT_PCREL reloc against a local symbol directly,
1191
without using the procedure linkage table. */
1192
if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1195
if (h->plt.offset == (bfd_vma) -1
1198
/* We didn't make a PLT entry for this symbol. This
1199
happens when statically linking PIC code, or when
1200
using -Bsymbolic. */
1204
relocation = (splt->output_section->vma
1205
+ splt->output_offset
1209
case R_CRIS_32_PLT_GOTREL:
1210
/* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1211
start of the .got section. See also comment at
1213
relocation -= sgot->output_section->vma;
1215
/* Resolve a PLT_GOTREL reloc against a local symbol directly,
1216
without using the procedure linkage table. */
1217
if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1220
if (h->plt.offset == (bfd_vma) -1
1223
/* We didn't make a PLT entry for this symbol. This
1224
happens when statically linking PIC code, or when
1225
using -Bsymbolic. */
1229
relocation = (splt->output_section->vma
1230
+ splt->output_offset
1232
- sgot->output_section->vma);
1235
case R_CRIS_8_PCREL:
1236
case R_CRIS_16_PCREL:
1237
case R_CRIS_32_PCREL:
1238
/* If the symbol was local, we need no shlib-specific handling. */
1239
if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1248
&& (input_section->flags & SEC_ALLOC) != 0
1249
&& ((r_type != R_CRIS_8_PCREL
1250
&& r_type != R_CRIS_16_PCREL
1251
&& r_type != R_CRIS_32_PCREL)
1253
|| (h->elf_link_hash_flags
1254
& ELF_LINK_HASH_DEF_REGULAR) == 0)))
1256
Elf_Internal_Rela outrel;
1257
boolean skip, relocate;
1259
/* When generating a shared object, these relocations
1260
are copied into the output file to be resolved at run
1267
name = (bfd_elf_string_from_elf_section
1269
elf_elfheader (input_bfd)->e_shstrndx,
1270
elf_section_data (input_section)->rel_hdr.sh_name));
1274
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1275
&& strcmp (bfd_get_section_name (input_bfd,
1279
sreloc = bfd_get_section_by_name (dynobj, name);
1281
/* That section should have been created in
1282
cris_elf_check_relocs, but that function will not be
1283
called for objects which fail in
1284
cris_elf_merge_private_bfd_data. */
1287
(*_bfd_error_handler)
1288
(_("%s: Internal inconsistency; no relocation section %s"),
1289
bfd_archive_filename (input_bfd),
1292
bfd_set_error (bfd_error_bad_value);
1301
_bfd_elf_section_offset (output_bfd, info, input_section,
1303
if (outrel.r_offset == (bfd_vma) -1)
1305
else if (outrel.r_offset == (bfd_vma) -2)
1306
skip = true, relocate = true;
1307
outrel.r_offset += (input_section->output_section->vma
1308
+ input_section->output_offset);
1311
memset (&outrel, 0, sizeof outrel);
1312
/* h->dynindx may be -1 if the symbol was marked to
1315
&& ((! info->symbolic && h->dynindx != -1)
1316
|| (h->elf_link_hash_flags
1317
& ELF_LINK_HASH_DEF_REGULAR) == 0))
1319
BFD_ASSERT (h->dynindx != -1);
1320
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1321
outrel.r_addend = relocation + rel->r_addend;
1325
if (r_type == R_CRIS_32)
1328
outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1329
outrel.r_addend = relocation + rel->r_addend;
1336
sec = local_sections[r_symndx];
1339
BFD_ASSERT (h->root.type == bfd_link_hash_defined
1341
== bfd_link_hash_defweak));
1342
sec = h->root.u.def.section;
1344
if (sec != NULL && bfd_is_abs_section (sec))
1346
else if (sec == NULL || sec->owner == NULL)
1348
bfd_set_error (bfd_error_bad_value);
1355
osec = sec->output_section;
1356
indx = elf_section_data (osec)->dynindx;
1357
BFD_ASSERT (indx > 0);
1360
outrel.r_info = ELF32_R_INFO (indx, r_type);
1361
outrel.r_addend = relocation + rel->r_addend;
1365
bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1366
(((Elf32_External_Rela *)
1368
+ sreloc->reloc_count));
1369
++sreloc->reloc_count;
1371
/* This reloc will be computed at runtime, so there's no
1372
need to do anything now, except for R_CRIS_32 relocations
1373
that have been turned into R_CRIS_RELATIVE. */
1381
r = cris_final_link_relocate (howto, input_bfd, input_section,
1382
contents, rel, relocation);
1384
if (r != bfd_reloc_ok)
1386
const char * msg = (const char *) NULL;
1390
case bfd_reloc_overflow:
1391
r = info->callbacks->reloc_overflow
1392
(info, symname, howto->name, (bfd_vma) 0,
1393
input_bfd, input_section, rel->r_offset);
1396
case bfd_reloc_undefined:
1397
r = info->callbacks->undefined_symbol
1398
(info, symname, input_bfd, input_section, rel->r_offset,
1402
case bfd_reloc_outofrange:
1403
msg = _("internal error: out of range error");
1406
case bfd_reloc_notsupported:
1407
msg = _("internal error: unsupported relocation error");
1410
case bfd_reloc_dangerous:
1411
msg = _("internal error: dangerous relocation");
1415
msg = _("internal error: unknown error");
1420
r = info->callbacks->warning
1421
(info, msg, symname, input_bfd, input_section, rel->r_offset);
1431
/* Finish up dynamic symbol handling. We set the contents of various
1432
dynamic sections here. */
1435
elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
1437
struct bfd_link_info *info;
1438
struct elf_link_hash_entry *h;
1439
Elf_Internal_Sym *sym;
1442
int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
1444
dynobj = elf_hash_table (info)->dynobj;
1446
if (h->plt.offset != (bfd_vma) -1)
1454
bfd_vma gotplt_offset
1455
= ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1456
Elf_Internal_Rela rela;
1457
boolean has_gotplt = gotplt_offset != 0;
1459
/* Get the index in the procedure linkage table which
1460
corresponds to this symbol. This is the index of this symbol
1461
in all the symbols for which we are making plt entries. The
1462
first entry in the procedure linkage table is reserved. */
1463
/* We have to count backwards here, and the result is only valid as
1464
an index into .got.plt and its relocations. FIXME: Constants... */
1465
bfd_vma gotplt_index = gotplt_offset/4 - 3;
1467
/* Get the offset into the .got table of the entry that corresponds
1468
to this function. Note that we embed knowledge that "incoming"
1469
.got goes after .got.plt in the output without padding (pointer
1470
aligned). However, that knowledge is present in several other
1471
places too, here and in elflink.h at least. */
1475
: h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
1477
/* This symbol has an entry in the procedure linkage table. Set it
1480
BFD_ASSERT (h->dynindx != -1);
1482
splt = bfd_get_section_by_name (dynobj, ".plt");
1483
sgot = bfd_get_section_by_name (dynobj, ".got");
1484
sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1485
srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1486
BFD_ASSERT (splt != NULL && sgotplt != NULL
1487
&& (! has_gotplt || srela != NULL));
1489
got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1491
/* Fill in the entry in the procedure linkage table. */
1494
memcpy (splt->contents + h->plt.offset, elf_cris_plt_entry,
1497
/* We need to enter the absolute address of the GOT entry here. */
1498
bfd_put_32 (output_bfd, got_base + got_offset,
1499
splt->contents + h->plt.offset + plt_off1);
1503
memcpy (splt->contents + h->plt.offset, elf_cris_pic_plt_entry,
1505
bfd_put_32 (output_bfd, got_offset,
1506
splt->contents + h->plt.offset + plt_off1);
1509
/* Fill in the plt entry and make a relocation, if this is a "real"
1513
/* Fill in the offset into the reloc table. */
1514
bfd_put_32 (output_bfd,
1515
gotplt_index * sizeof (Elf32_External_Rela),
1516
splt->contents + h->plt.offset + plt_off2);
1518
/* Fill in the offset to the first PLT entry, where to "jump". */
1519
bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3 + 4),
1520
splt->contents + h->plt.offset + plt_off3);
1522
/* Fill in the entry in the global offset table with the address of
1523
the relocating stub. */
1524
bfd_put_32 (output_bfd,
1525
(splt->output_section->vma
1526
+ splt->output_offset
1529
sgotplt->contents + got_offset);
1531
/* Fill in the entry in the .rela.plt section. */
1532
rela.r_offset = (sgotplt->output_section->vma
1533
+ sgotplt->output_offset
1535
rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
1537
bfd_elf32_swap_reloca_out (output_bfd, &rela,
1538
((Elf32_External_Rela *) srela->contents
1542
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1544
/* Mark the symbol as undefined, rather than as defined in
1545
the .plt section. Leave the value alone. */
1546
sym->st_shndx = SHN_UNDEF;
1548
/* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1549
know whether resetting the value is significant; if it really
1550
is, rather than a quirk or bug in the sparc port, then I
1551
believe we'd see this elsewhere. */
1552
/* If the symbol is weak, we do need to clear the value.
1553
Otherwise, the PLT entry would provide a definition for
1554
the symbol even if the symbol wasn't defined anywhere,
1555
and so the symbol would never be NULL. */
1556
if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1562
/* We don't emit .got relocs for symbols that aren't in the
1563
dynamic-symbols table for an ordinary program and are either defined
1564
by the program or are undefined weak symbols. */
1565
if (h->got.offset != (bfd_vma) -1
1567
|| (h->dynindx != -1
1568
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1569
&& h->root.type != bfd_link_hash_undefweak)))
1573
Elf_Internal_Rela rela;
1576
/* This symbol has an entry in the global offset table. Set it up. */
1578
sgot = bfd_get_section_by_name (dynobj, ".got");
1579
srela = bfd_get_section_by_name (dynobj, ".rela.got");
1580
BFD_ASSERT (sgot != NULL && srela != NULL);
1582
rela.r_offset = (sgot->output_section->vma
1583
+ sgot->output_offset
1584
+ (h->got.offset &~ (bfd_vma) 1));
1586
/* If this is a static link, or it is a -Bsymbolic link and the
1587
symbol is defined locally or was forced to be local because
1588
of a version file, we just want to emit a RELATIVE reloc.
1589
The entry in the global offset table will already have been
1590
initialized in the relocate_section function. */
1591
where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
1592
if (! elf_hash_table (info)->dynamic_sections_created
1594
&& (info->symbolic || h->dynindx == -1)
1595
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1597
rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1598
rela.r_addend = bfd_get_signed_32 (output_bfd, where);
1602
bfd_put_32 (output_bfd, (bfd_vma) 0, where);
1603
rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
1607
bfd_elf32_swap_reloca_out (output_bfd, &rela,
1608
((Elf32_External_Rela *) srela->contents
1609
+ srela->reloc_count));
1610
++srela->reloc_count;
1613
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1616
Elf_Internal_Rela rela;
1618
/* This symbol needs a copy reloc. Set it up. */
1620
BFD_ASSERT (h->dynindx != -1
1621
&& (h->root.type == bfd_link_hash_defined
1622
|| h->root.type == bfd_link_hash_defweak));
1624
s = bfd_get_section_by_name (h->root.u.def.section->owner,
1626
BFD_ASSERT (s != NULL);
1628
rela.r_offset = (h->root.u.def.value
1629
+ h->root.u.def.section->output_section->vma
1630
+ h->root.u.def.section->output_offset);
1631
rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
1633
bfd_elf32_swap_reloca_out (output_bfd, &rela,
1634
((Elf32_External_Rela *) s->contents
1639
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1640
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1641
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1642
sym->st_shndx = SHN_ABS;
1647
/* Finish up the dynamic sections. */
1650
elf_cris_finish_dynamic_sections (output_bfd, info)
1652
struct bfd_link_info *info;
1658
dynobj = elf_hash_table (info)->dynobj;
1660
sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1661
BFD_ASSERT (sgot != NULL);
1662
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1664
if (elf_hash_table (info)->dynamic_sections_created)
1667
Elf32_External_Dyn *dyncon, *dynconend;
1669
splt = bfd_get_section_by_name (dynobj, ".plt");
1670
BFD_ASSERT (splt != NULL && sdyn != NULL);
1672
dyncon = (Elf32_External_Dyn *) sdyn->contents;
1673
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1674
for (; dyncon < dynconend; dyncon++)
1676
Elf_Internal_Dyn dyn;
1679
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1687
s = bfd_get_section_by_name (output_bfd, ".got");
1688
BFD_ASSERT (s != NULL);
1689
dyn.d_un.d_ptr = s->vma;
1690
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1694
/* Yes, we *can* have a .plt and no .plt.rela, for instance
1695
if all symbols are found in the .got (not .got.plt). */
1696
s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1697
dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
1698
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1702
s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1705
else if (s->_cooked_size != 0)
1706
dyn.d_un.d_val = s->_cooked_size;
1708
dyn.d_un.d_val = s->_raw_size;
1709
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1713
/* The procedure linkage table relocs (DT_JMPREL) should
1714
not be included in the overall relocs (DT_RELA).
1715
Therefore, we override the DT_RELASZ entry here to
1716
make it not include the JMPREL relocs. Since the
1717
linker script arranges for .rela.plt to follow all
1718
other relocation sections, we don't have to worry
1719
about changing the DT_RELA entry. */
1720
s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1723
if (s->_cooked_size != 0)
1724
dyn.d_un.d_val -= s->_cooked_size;
1726
dyn.d_un.d_val -= s->_raw_size;
1728
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1733
/* Fill in the first entry in the procedure linkage table. */
1734
if (splt->_raw_size > 0)
1737
memcpy (splt->contents, elf_cris_pic_plt0_entry, PLT_ENTRY_SIZE);
1740
memcpy (splt->contents, elf_cris_plt0_entry, PLT_ENTRY_SIZE);
1741
bfd_put_32 (output_bfd,
1742
sgot->output_section->vma + sgot->output_offset + 4,
1743
splt->contents + 6);
1744
bfd_put_32 (output_bfd,
1745
sgot->output_section->vma + sgot->output_offset + 8,
1746
splt->contents + 14);
1748
elf_section_data (splt->output_section)->this_hdr.sh_entsize
1754
/* Fill in the first three entries in the global offset table. */
1755
if (sgot->_raw_size > 0)
1758
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1760
bfd_put_32 (output_bfd,
1761
sdyn->output_section->vma + sdyn->output_offset,
1763
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1764
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1767
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1772
/* Return the section that should be marked against GC for a given
1776
cris_elf_gc_mark_hook (sec, info, rel, h, sym)
1778
struct bfd_link_info * info ATTRIBUTE_UNUSED;
1779
Elf_Internal_Rela * rel;
1780
struct elf_link_hash_entry * h;
1781
Elf_Internal_Sym * sym;
1785
switch (ELF32_R_TYPE (rel->r_info))
1787
case R_CRIS_GNU_VTINHERIT:
1788
case R_CRIS_GNU_VTENTRY:
1792
switch (h->root.type)
1794
case bfd_link_hash_defined:
1795
case bfd_link_hash_defweak:
1796
return h->root.u.def.section;
1798
case bfd_link_hash_common:
1799
return h->root.u.c.p->section;
1807
return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1812
/* Update the got entry reference counts for the section being removed. */
1815
cris_elf_gc_sweep_hook (abfd, info, sec, relocs)
1816
bfd * abfd ATTRIBUTE_UNUSED;
1817
struct bfd_link_info * info ATTRIBUTE_UNUSED;
1818
asection * sec ATTRIBUTE_UNUSED;
1819
const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
1821
Elf_Internal_Shdr *symtab_hdr;
1822
struct elf_link_hash_entry **sym_hashes;
1823
bfd_signed_vma *local_got_refcounts;
1824
const Elf_Internal_Rela *rel, *relend;
1825
unsigned long r_symndx;
1826
struct elf_link_hash_entry *h;
1831
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1832
sym_hashes = elf_sym_hashes (abfd);
1833
local_got_refcounts = elf_local_got_refcounts (abfd);
1835
dynobj = elf_hash_table (info)->dynobj;
1839
sgot = bfd_get_section_by_name (dynobj, ".got");
1840
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1842
relend = relocs + sec->reloc_count;
1843
for (rel = relocs; rel < relend; rel++)
1845
switch (ELF32_R_TYPE (rel->r_info))
1849
r_symndx = ELF32_R_SYM (rel->r_info);
1850
if (r_symndx >= symtab_hdr->sh_info)
1852
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1853
if (h->got.refcount > 0)
1856
if (h->got.refcount == 0)
1858
/* We don't need the .got entry any more. */
1859
sgot->_raw_size -= 4;
1860
srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1867
if (local_got_refcounts != NULL)
1869
if (local_got_refcounts[r_symndx] > 0)
1871
--local_got_refcounts[r_symndx];
1872
if (local_got_refcounts[r_symndx] == 0)
1874
/* We don't need the .got entry any more. */
1875
sgot->_raw_size -= 4;
1877
srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1883
case R_CRIS_16_GOTPLT:
1884
case R_CRIS_32_GOTPLT:
1885
/* For local symbols, treat these like GOT relocs. */
1886
r_symndx = ELF32_R_SYM (rel->r_info);
1887
if (r_symndx < symtab_hdr->sh_info)
1888
goto local_got_reloc;
1890
case R_CRIS_32_PLT_GOTREL:
1891
/* FIXME: We don't garbage-collect away the .got section. */
1892
if (local_got_refcounts != NULL)
1893
local_got_refcounts[-1]--;
1896
case R_CRIS_8_PCREL:
1897
case R_CRIS_16_PCREL:
1898
case R_CRIS_32_PCREL:
1899
case R_CRIS_32_PLT_PCREL:
1900
r_symndx = ELF32_R_SYM (rel->r_info);
1901
if (r_symndx >= symtab_hdr->sh_info)
1903
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1904
if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1905
&& h->plt.refcount > 0)
1918
/* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1919
entry but we found we will not create any. Called when we find we will
1920
not have any PLT for this symbol, by for example
1921
elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
1922
or elf_cris_size_dynamic_sections if no dynamic sections will be
1923
created (we're only linking static objects). */
1926
elf_cris_adjust_gotplt_to_got (h, p)
1927
struct elf_cris_link_hash_entry *h;
1930
struct bfd_link_info *info = (struct bfd_link_info *) p;
1931
bfd *dynobj = elf_hash_table (info)->dynobj;
1933
BFD_ASSERT (dynobj != NULL);
1935
if (h->root.root.type == bfd_link_hash_warning)
1936
h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
1938
/* If nobody wanted a GOTPLT with this symbol, we're done. */
1939
if (h->gotplt_refcount <= 0)
1942
if (h->root.got.refcount > 0)
1944
/* There's a GOT entry for this symbol. Just adjust the refcount.
1945
Probably not necessary at this stage, but keeping it accurate
1946
helps avoiding surprises later. */
1947
h->root.got.refcount += h->gotplt_refcount;
1948
h->gotplt_refcount = -1;
1952
/* No GOT entry for this symbol. We need to create one. */
1953
asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1955
= bfd_get_section_by_name (dynobj, ".rela.got");
1957
/* Put an accurate refcount there. */
1958
h->root.got.refcount = h->gotplt_refcount;
1960
h->gotplt_refcount = -1;
1962
/* We always have a .got and a .rela.got section if there were
1963
GOTPLT relocs in input. */
1964
BFD_ASSERT (sgot != NULL && srelgot != NULL);
1966
/* Allocate space in the .got section. */
1967
sgot->_raw_size += 4;
1969
/* Allocate relocation space. */
1970
srelgot->_raw_size += sizeof (Elf32_External_Rela);
1976
/* Try to fold PLT entries with GOT entries. There are two cases when we
1979
- When all PLT references are GOTPLT references, and there are GOT
1980
references. We don't have to generate a PLT at all.
1982
- When there are both (ordinary) PLT references and GOT references.
1983
We want to make the PLT reference use the ordinary GOT entry rather
1984
than a run-time dynamically resolved GOTPLT entry (since the GOT
1985
entry will have to be resolved at startup anyway).
1987
Though the latter case is handled when room for the PLT is allocated,
1990
Note that this function is called before symbols are forced local by
1991
version scripts. The differing cases are handled by
1992
elf_cris_hide_symbol. */
1995
elf_cris_try_fold_plt_to_got (h, p)
1996
struct elf_cris_link_hash_entry *h;
1999
struct bfd_link_info *info = (struct bfd_link_info *) p;
2001
/* If there are no GOT references for this symbol, we can't fold any
2002
other reference so there's nothing to do. Likewise if there are no
2003
PLT references; GOTPLT references included. */
2004
if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
2007
/* GOTPLT relocs are supposed to be included into the PLT refcount. */
2008
BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
2010
if (h->gotplt_refcount == h->root.plt.refcount)
2012
/* The only PLT references are GOTPLT references, and there are GOT
2013
references. Convert PLT to GOT references. */
2014
if (! elf_cris_adjust_gotplt_to_got (h, info))
2017
/* Clear the PLT references, so no PLT will be created. */
2018
h->root.plt.offset = (bfd_vma) -1;
2024
/* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2025
to use a GOT entry (and create one) rather than requiring a GOTPLT
2029
elf_cris_hide_symbol (info, h, force_local)
2030
struct bfd_link_info *info;
2031
struct elf_link_hash_entry *h;
2032
boolean force_local;
2034
elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2036
_bfd_elf_link_hash_hide_symbol (info, h, force_local);
2039
/* Adjust a symbol defined by a dynamic object and referenced by a
2040
regular object. The current definition is in some section of the
2041
dynamic object, but we're not including those sections. We have to
2042
change the definition to something the rest of the link can
2046
elf_cris_adjust_dynamic_symbol (info, h)
2047
struct bfd_link_info *info;
2048
struct elf_link_hash_entry *h;
2052
unsigned int power_of_two;
2054
dynobj = elf_hash_table (info)->dynobj;
2056
/* Make sure we know what is going on here. */
2057
BFD_ASSERT (dynobj != NULL
2058
&& ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2059
|| h->weakdef != NULL
2060
|| ((h->elf_link_hash_flags
2061
& ELF_LINK_HASH_DEF_DYNAMIC) != 0
2062
&& (h->elf_link_hash_flags
2063
& ELF_LINK_HASH_REF_REGULAR) != 0
2064
&& (h->elf_link_hash_flags
2065
& ELF_LINK_HASH_DEF_REGULAR) == 0)));
2067
/* If this is a function, put it in the procedure linkage table. We
2068
will fill in the contents of the procedure linkage table later,
2069
when we know the address of the .got section. */
2070
if (h->type == STT_FUNC
2071
|| (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2073
/* If we link a program (not a DSO), we'll get rid of unnecessary
2074
PLT entries; we point to the actual symbols -- even for pic
2075
relocs, because a program built with -fpic should have the same
2076
result as one built without -fpic, specifically considering weak
2078
FIXME: m68k and i386 differ here, for unclear reasons. */
2080
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
2082
/* This case can occur if we saw a PLT reloc in an input file,
2083
but the symbol was not defined by a dynamic object. In such
2084
a case, we don't actually need to build a procedure linkage
2085
table, and we can just do an absolute or PC reloc instead, or
2086
change a .got.plt index to a .got index for GOTPLT relocs. */
2087
BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2088
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2089
h->plt.offset = (bfd_vma) -1;
2091
elf_cris_adjust_gotplt_to_got ((struct
2092
elf_cris_link_hash_entry *) h,
2096
/* If there are only GOT references and GOTPLT references to this
2097
PLT entry, get rid of the PLT. */
2098
if (! elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry *)
2102
/* GC or folding may have rendered this entry unused. */
2103
if (h->plt.refcount <= 0)
2105
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2106
h->plt.offset = (bfd_vma) -1;
2110
/* Make sure this symbol is output as a dynamic symbol. */
2111
if (h->dynindx == -1)
2113
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2117
s = bfd_get_section_by_name (dynobj, ".plt");
2118
BFD_ASSERT (s != NULL);
2120
/* If this is the first .plt entry, make room for the special
2122
if (s->_raw_size == 0)
2123
s->_raw_size += PLT_ENTRY_SIZE;
2125
/* If this symbol is not defined in a regular file, and we are
2126
not generating a shared library, then set the symbol to this
2127
location in the .plt. */
2129
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2131
h->root.u.def.section = s;
2132
h->root.u.def.value = s->_raw_size;
2135
/* If there's already a GOT entry, use that, not a .got.plt. A
2136
GOT field still has a reference count when we get here; it's
2137
not yet changed to an offset. */
2138
if (h->got.refcount > 0)
2140
h->got.refcount += h->plt.refcount;
2142
/* Mark the PLT offset to use the GOT entry by setting the low
2143
bit in the plt offset; it is always a multiple of
2145
BFD_ASSERT ((s->_raw_size & 3) == 0);
2147
/* Change the PLT refcount to an offset. */
2148
h->plt.offset = s->_raw_size;
2150
/* By not setting gotplt_offset (i.e. it remains at 0), we signal
2151
that the got entry should be used instead. */
2152
BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2153
h)->gotplt_offset == 0);
2155
/* Make room for this entry. */
2156
s->_raw_size += PLT_ENTRY_SIZE;
2161
/* No GOT reference for this symbol; prepare for an ordinary PLT. */
2162
h->plt.offset = s->_raw_size;
2164
/* Make room for this entry. */
2165
s->_raw_size += PLT_ENTRY_SIZE;
2167
/* We also need to make an entry in the .got.plt section, which
2168
will be placed in the .got section by the linker script. */
2169
((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2170
= elf_cris_hash_table (info)->next_gotplt_entry;
2171
elf_cris_hash_table (info)->next_gotplt_entry += 4;
2173
s = bfd_get_section_by_name (dynobj, ".got.plt");
2174
BFD_ASSERT (s != NULL);
2177
/* We also need to make an entry in the .rela.plt section. */
2179
s = bfd_get_section_by_name (dynobj, ".rela.plt");
2180
BFD_ASSERT (s != NULL);
2181
s->_raw_size += sizeof (Elf32_External_Rela);
2186
/* Reinitialize the plt offset now that it is not used as a reference
2188
h->plt.offset = (bfd_vma) -1;
2190
/* If this is a weak symbol, and there is a real definition, the
2191
processor independent code will have arranged for us to see the
2192
real definition first, and we can just use the same value. */
2193
if (h->weakdef != NULL)
2195
BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2196
|| h->weakdef->root.type == bfd_link_hash_defweak);
2197
h->root.u.def.section = h->weakdef->root.u.def.section;
2198
h->root.u.def.value = h->weakdef->root.u.def.value;
2202
/* This is a reference to a symbol defined by a dynamic object which
2203
is not a function. */
2205
/* If we are creating a shared library, we must presume that the
2206
only references to the symbol are via the global offset table.
2207
For such cases we need not do anything here; the relocations will
2208
be handled correctly by relocate_section. */
2212
/* If there are no references to this symbol that do not use the
2213
GOT, we don't need to generate a copy reloc. */
2214
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2217
/* We must allocate the symbol in our .dynbss section, which will
2218
become part of the .bss section of the executable. There will be
2219
an entry for this symbol in the .dynsym section. The dynamic
2220
object will contain position independent code, so all references
2221
from the dynamic object to this symbol will go through the global
2222
offset table. The dynamic linker will use the .dynsym entry to
2223
determine the address it must put in the global offset table, so
2224
both the dynamic object and the regular object will refer to the
2225
same memory location for the variable. */
2227
s = bfd_get_section_by_name (dynobj, ".dynbss");
2228
BFD_ASSERT (s != NULL);
2230
/* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2231
copy the initial value out of the dynamic object and into the
2232
runtime process image. We need to remember the offset into the
2233
.rela.bss section we are going to use. */
2234
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2238
srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2239
BFD_ASSERT (srel != NULL);
2240
srel->_raw_size += sizeof (Elf32_External_Rela);
2241
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2244
/* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2245
thing to copy; so do we. */
2247
/* We need to figure out the alignment required for this symbol. I
2248
have no idea how ELF linkers handle this. */
2249
power_of_two = bfd_log2 (h->size);
2250
if (power_of_two > 3)
2253
/* Apply the required alignment. */
2254
s->_raw_size = BFD_ALIGN (s->_raw_size,
2255
(bfd_size_type) (1 << power_of_two));
2256
if (power_of_two > bfd_get_section_alignment (dynobj, s))
2258
if (!bfd_set_section_alignment (dynobj, s, power_of_two))
2262
/* Define the symbol as being at this point in the section. */
2263
h->root.u.def.section = s;
2264
h->root.u.def.value = s->_raw_size;
2266
/* Increment the section size to make room for the symbol. */
2267
s->_raw_size += h->size;
2272
/* Look through the relocs for a section during the first phase. */
2275
cris_elf_check_relocs (abfd, info, sec, relocs)
2277
struct bfd_link_info *info;
2279
const Elf_Internal_Rela *relocs;
2282
Elf_Internal_Shdr *symtab_hdr;
2283
struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2284
bfd_signed_vma *local_got_refcounts;
2285
const Elf_Internal_Rela *rel;
2286
const Elf_Internal_Rela *rel_end;
2291
if (info->relocateable)
2294
dynobj = elf_hash_table (info)->dynobj;
2295
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2296
sym_hashes = elf_sym_hashes (abfd);
2297
sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2298
local_got_refcounts = elf_local_got_refcounts (abfd);
2304
if (!elf_bad_symtab (abfd))
2305
sym_hashes_end -= symtab_hdr->sh_info;
2307
rel_end = relocs + sec->reloc_count;
2308
for (rel = relocs; rel < rel_end; rel++)
2310
struct elf_link_hash_entry *h;
2311
unsigned long r_symndx;
2312
enum elf_cris_reloc_type r_type;
2314
r_symndx = ELF32_R_SYM (rel->r_info);
2315
if (r_symndx < symtab_hdr->sh_info)
2318
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2320
r_type = ELF32_R_TYPE (rel->r_info);
2322
/* Some relocs require linker-created sections; we need to hang them
2323
on the first input bfd we found that contained dynamic relocs. */
2328
case R_CRIS_32_GOTREL:
2329
case R_CRIS_32_PLT_GOTREL:
2330
case R_CRIS_32_PLT_PCREL:
2331
case R_CRIS_16_GOTPLT:
2332
case R_CRIS_32_GOTPLT:
2335
elf_hash_table (info)->dynobj = dynobj = abfd;
2337
/* Create the .got section, so we can assume it's always
2338
present whenever there's a dynobj. */
2339
if (!_bfd_elf_create_got_section (dynobj, info))
2348
/* Some relocs require a global offset table (but perhaps not a
2349
specific GOT entry). */
2352
/* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
2353
entry only for local symbols. Unfortunately, we don't know
2354
until later on if there's a version script that forces the
2355
symbol local. We must have the .rela.got section in place
2356
before we know if the symbol looks global now, so we need
2357
to treat the reloc just like for R_CRIS_16_GOT and
2359
case R_CRIS_16_GOTPLT:
2360
case R_CRIS_32_GOTPLT:
2364
&& (h != NULL || info->shared))
2366
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2367
if (srelgot == NULL)
2369
srelgot = bfd_make_section (dynobj, ".rela.got");
2371
|| !bfd_set_section_flags (dynobj, srelgot,
2376
| SEC_LINKER_CREATED
2378
|| !bfd_set_section_alignment (dynobj, srelgot, 2))
2384
case R_CRIS_32_GOTREL:
2385
case R_CRIS_32_PLT_GOTREL:
2387
sgot = bfd_get_section_by_name (dynobj, ".got");
2389
if (local_got_refcounts == NULL)
2393
/* We use index local_got_refcounts[-1] to count all
2394
GOT-relative relocations that do not have explicit
2396
amt = symtab_hdr->sh_info + 1;
2397
amt *= sizeof (bfd_signed_vma);
2398
local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
2399
if (local_got_refcounts == NULL)
2402
local_got_refcounts++;
2403
elf_local_got_refcounts (abfd) = local_got_refcounts;
2413
case R_CRIS_16_GOTPLT:
2414
case R_CRIS_32_GOTPLT:
2415
/* Mark that we need a GOT entry if the PLT entry (and its GOT
2416
entry) is eliminated. We can only do this for a non-local
2420
((struct elf_cris_link_hash_entry *) h)->gotplt_refcount++;
2421
goto handle_gotplt_reloc;
2423
/* If h is NULL then this is a local symbol, and we must make a
2424
GOT entry for it, so handle it like a GOT reloc. */
2429
/* This symbol requires a global offset table entry. */
2432
if (h->got.refcount == 0)
2434
/* Make sure this symbol is output as a dynamic symbol. */
2435
if (h->dynindx == -1)
2437
if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2441
/* Allocate space in the .got section. */
2442
sgot->_raw_size += 4;
2443
/* Allocate relocation space. */
2444
srelgot->_raw_size += sizeof (Elf32_External_Rela);
2450
/* This is a global offset table entry for a local symbol. */
2451
if (local_got_refcounts[r_symndx] == 0)
2453
sgot->_raw_size += 4;
2456
/* If we are generating a shared object, we need to
2457
output a R_CRIS_RELATIVE reloc so that the dynamic
2458
linker can adjust this GOT entry. */
2459
srelgot->_raw_size += sizeof (Elf32_External_Rela);
2462
local_got_refcounts[r_symndx]++;
2466
case R_CRIS_32_GOTREL:
2467
/* This reference requires a global offset table.
2468
FIXME: The actual refcount isn't used currently; the .got
2469
section can't be removed if there were any references in the
2471
local_got_refcounts[-1]++;
2474
handle_gotplt_reloc:
2476
case R_CRIS_32_PLT_GOTREL:
2477
/* This reference requires a global offset table. */
2478
local_got_refcounts[-1]++;
2481
case R_CRIS_32_PLT_PCREL:
2482
/* This symbol requires a procedure linkage table entry. We
2483
actually build the entry in adjust_dynamic_symbol,
2484
because this might be a case of linking PIC code which is
2485
never referenced by a dynamic object, in which case we
2486
don't need to generate a procedure linkage table entry
2489
/* If this is a local symbol, we resolve it directly without
2490
creating a procedure linkage table entry. */
2491
if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2494
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2501
/* Let's help debug shared library creation. Any of these
2502
relocs can be used in shared libs, but pages containing them
2503
cannot be shared. Don't warn for sections we don't care
2504
about, such as debug sections or non-constant sections. We
2505
can't help tables of (global) function pointers, for example,
2506
though they must be emitted in a data section to avoid having
2507
impure text sections. */
2509
&& (sec->flags & SEC_ALLOC) != 0
2510
&& (sec->flags & SEC_READONLY) != 0)
2512
/* FIXME: How do we make this optionally a warning only? */
2513
(*_bfd_error_handler)
2514
(_("%s, section %s:\n relocation %s should not be used in a shared object; recompile with -fPIC"),
2515
bfd_archive_filename (abfd),
2517
cris_elf_howto_table[r_type].name);
2521
case R_CRIS_8_PCREL:
2522
case R_CRIS_16_PCREL:
2523
case R_CRIS_32_PCREL:
2526
h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2528
/* Make sure a plt entry is created for this symbol if it
2529
turns out to be a function defined by a dynamic object. */
2530
if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2534
/* If we are creating a shared library and this is not a local
2535
symbol, we need to copy the reloc into the shared library.
2536
However when linking with -Bsymbolic and this is a global
2537
symbol which is defined in an object we are including in the
2538
link (i.e., DEF_REGULAR is set), then we can resolve the
2539
reloc directly. At this point we have not seen all the input
2540
files, so it is possible that DEF_REGULAR is not set now but
2541
will be set later (it is never cleared). In case of a weak
2542
definition, DEF_REGULAR may be cleared later by a strong
2543
definition in a shared library. We account for that
2544
possibility below by storing information in the relocs_copied
2545
field of the hash table entry. A similar situation occurs
2546
when creating shared libraries and symbol visibility changes
2547
render the symbol local. */
2549
/* No need to do anything if we're not creating a shared object. */
2553
/* We don't need to handle relocs into sections not going into
2554
the "real" output. */
2555
if ((sec->flags & SEC_ALLOC) == 0)
2558
/* We can only eliminate PC-relative relocs. */
2559
if (r_type == R_CRIS_8_PCREL
2560
|| r_type == R_CRIS_16_PCREL
2561
|| r_type == R_CRIS_32_PCREL)
2563
/* If the symbol is local, then we can eliminate the reloc. */
2564
if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2567
/* If this is with -Bsymbolic and the symbol isn't weak, and
2568
is defined by an ordinary object (the ones we include in
2569
this shared library) then we can also eliminate the
2570
reloc. See comment above for more eliminable cases which
2571
we can't identify at this time. */
2573
&& h->root.type != bfd_link_hash_defweak
2574
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2578
/* We create a reloc section in dynobj and make room for this
2584
name = (bfd_elf_string_from_elf_section
2586
elf_elfheader (abfd)->e_shstrndx,
2587
elf_section_data (sec)->rel_hdr.sh_name));
2591
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2592
&& strcmp (bfd_get_section_name (abfd, sec),
2595
sreloc = bfd_get_section_by_name (dynobj, name);
2598
sreloc = bfd_make_section (dynobj, name);
2600
|| !bfd_set_section_flags (dynobj, sreloc,
2605
| SEC_LINKER_CREATED
2607
|| !bfd_set_section_alignment (dynobj, sreloc, 2))
2610
if (sec->flags & SEC_READONLY)
2611
info->flags |= DF_TEXTREL;
2614
sreloc->_raw_size += sizeof (Elf32_External_Rela);
2616
/* If we are linking with -Bsymbolic, we count the number of PC
2617
relative relocations we have entered for this symbol, so that
2618
we can discard them again if the symbol is later defined by a
2619
regular object. We know that h is really a pointer to an
2620
elf_cris_link_hash_entry. */
2621
if ((r_type == R_CRIS_8_PCREL
2622
|| r_type == R_CRIS_16_PCREL
2623
|| r_type == R_CRIS_32_PCREL)
2626
struct elf_cris_link_hash_entry *eh;
2627
struct elf_cris_pcrel_relocs_copied *p;
2629
eh = (struct elf_cris_link_hash_entry *) h;
2631
for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2632
if (p->section == sreloc)
2637
p = ((struct elf_cris_pcrel_relocs_copied *)
2638
bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2641
p->next = eh->pcrel_relocs_copied;
2642
eh->pcrel_relocs_copied = p;
2643
p->section = sreloc;
2651
/* This relocation describes the C++ object vtable hierarchy.
2652
Reconstruct it for later use during GC. */
2653
case R_CRIS_GNU_VTINHERIT:
2654
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2658
/* This relocation describes which C++ vtable entries are actually
2659
used. Record for later use during GC. */
2660
case R_CRIS_GNU_VTENTRY:
2661
if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2666
/* Other relocs do not appear here. */
2667
bfd_set_error (bfd_error_bad_value);
2675
/* Set the sizes of the dynamic sections. */
2678
elf_cris_size_dynamic_sections (output_bfd, info)
2679
bfd *output_bfd ATTRIBUTE_UNUSED;
2680
struct bfd_link_info *info;
2687
dynobj = elf_hash_table (info)->dynobj;
2688
BFD_ASSERT (dynobj != NULL);
2690
if (elf_hash_table (info)->dynamic_sections_created)
2692
/* Set the contents of the .interp section to the interpreter. */
2695
s = bfd_get_section_by_name (dynobj, ".interp");
2696
BFD_ASSERT (s != NULL);
2697
s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2698
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2703
/* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2704
elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2705
elf_cris_adjust_gotplt_to_got,
2708
/* We may have created entries in the .rela.got section.
2709
However, if we are not creating the dynamic sections, we will
2710
not actually use these entries. Reset the size of .rela.got,
2711
which will cause it to get stripped from the output file
2713
s = bfd_get_section_by_name (dynobj, ".rela.got");
2718
/* If this is a -Bsymbolic shared link, then we need to discard all PC
2719
relative relocs against symbols defined in a regular object. We
2720
allocated space for them in the check_relocs routine, but we will not
2721
fill them in in the relocate_section routine. We also discard space
2722
for relocs that have become for local symbols due to symbol
2723
visibility changes. For programs, we discard space for relocs for
2724
symbols not referenced by any dynamic object. */
2726
elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2727
elf_cris_discard_excess_dso_dynamics,
2730
elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2731
elf_cris_discard_excess_program_dynamics,
2734
/* The check_relocs and adjust_dynamic_symbol entry points have
2735
determined the sizes of the various dynamic sections. Allocate
2739
for (s = dynobj->sections; s != NULL; s = s->next)
2744
if ((s->flags & SEC_LINKER_CREATED) == 0)
2747
/* It's OK to base decisions on the section name, because none
2748
of the dynobj section names depend upon the input files. */
2749
name = bfd_get_section_name (dynobj, s);
2753
if (strcmp (name, ".plt") == 0)
2755
if (s->_raw_size == 0)
2757
/* Strip this section if we don't need it; see the
2763
/* Remember whether there is a PLT. */
2767
else if (strncmp (name, ".rela", 5) == 0)
2769
if (s->_raw_size == 0)
2771
/* If we don't need this section, strip it from the
2772
output file. This is mostly to handle .rela.bss and
2773
.rela.plt. We must create both sections in
2774
create_dynamic_sections, because they must be created
2775
before the linker maps input sections to output
2776
sections. The linker does that before
2777
adjust_dynamic_symbol is called, and it is that
2778
function which decides whether anything needs to go
2779
into these sections. */
2784
/* Remember whether there are any reloc sections other
2786
if (strcmp (name, ".rela.plt") != 0)
2789
/* We use the reloc_count field as a counter if we need
2790
to copy relocs into the output file. */
2794
else if (strncmp (name, ".got", 4) != 0)
2796
/* It's not one of our sections, so don't allocate space. */
2802
_bfd_strip_section_from_output (info, s);
2806
/* Allocate memory for the section contents. We use bfd_zalloc here
2807
in case unused entries are not reclaimed before the section's
2808
contents are written out. This should not happen, but this way
2809
if it does, we will not write out garbage. For reloc sections,
2810
this will make entries have the type R_CRIS_NONE. */
2811
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2812
if (s->contents == NULL && s->_raw_size != 0)
2816
if (elf_hash_table (info)->dynamic_sections_created)
2818
/* Add some entries to the .dynamic section. We fill in the
2819
values later, in elf_cris_finish_dynamic_sections, but we
2820
must add the entries now so that we get the correct size for
2821
the .dynamic section. The DT_DEBUG entry is filled in by the
2822
dynamic linker and used by the debugger. */
2823
#define add_dynamic_entry(TAG, VAL) \
2824
bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2828
if (!add_dynamic_entry (DT_DEBUG, 0))
2834
if (!add_dynamic_entry (DT_PLTGOT, 0)
2835
|| !add_dynamic_entry (DT_PLTRELSZ, 0)
2836
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
2837
|| !add_dynamic_entry (DT_JMPREL, 0))
2843
if (!add_dynamic_entry (DT_RELA, 0)
2844
|| !add_dynamic_entry (DT_RELASZ, 0)
2845
|| !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2849
if ((info->flags & DF_TEXTREL) != 0)
2851
if (!add_dynamic_entry (DT_TEXTREL, 0))
2853
info->flags |= DF_TEXTREL;
2856
#undef add_dynamic_entry
2861
/* This function is called via elf_cris_link_hash_traverse if we are
2862
creating a shared object. In the -Bsymbolic case, it discards the
2863
space allocated to copy PC relative relocs against symbols which
2864
are defined in regular objects. For the normal non-symbolic case,
2865
we also discard space for relocs that have become local due to
2866
symbol visibility changes. We allocated space for them in the
2867
check_relocs routine, but we won't fill them in in the
2868
relocate_section routine. */
2871
elf_cris_discard_excess_dso_dynamics (h, inf)
2872
struct elf_cris_link_hash_entry *h;
2875
struct elf_cris_pcrel_relocs_copied *s;
2876
struct bfd_link_info *info = (struct bfd_link_info *) inf;
2878
if (h->root.root.type == bfd_link_hash_warning)
2879
h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2881
/* If a symbol has been forced local or we have found a regular
2882
definition for the symbolic link case, then we won't be needing
2884
if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2885
&& ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2888
for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2889
s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2895
/* This function is called via elf_cris_link_hash_traverse if we are *not*
2896
creating a shared object. We discard space for relocs for symbols put
2897
in the .got, but which we found we do not have to resolve at run-time. */
2900
elf_cris_discard_excess_program_dynamics (h, inf)
2901
struct elf_cris_link_hash_entry *h;
2904
struct bfd_link_info *info = (struct bfd_link_info *) inf;
2906
if (h->root.root.type == bfd_link_hash_warning)
2907
h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2909
/* If we're not creating a shared library and have a symbol which is
2910
referred to by .got references, but the symbol is defined locally,
2911
(or rather, not not defined by a DSO) then lose the reloc for the
2912
.got (don't allocate room for it). */
2913
if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
2915
if (h->root.got.refcount > 0
2916
/* The size of this section is only valid and in sync with the
2917
various reference counts if we do dynamic; don't decrement it
2919
&& elf_hash_table (info)->dynamic_sections_created)
2921
bfd *dynobj = elf_hash_table (info)->dynobj;
2924
BFD_ASSERT (dynobj != NULL);
2926
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2928
BFD_ASSERT (srelgot != NULL);
2930
srelgot->_raw_size -= sizeof (Elf32_External_Rela);
2933
/* If the locally-defined symbol isn't used by a DSO, then we don't
2934
have to export it as a dynamic symbol. This was already done for
2935
functions; doing this for all symbols would presumably not
2936
introduce new problems. Of course we don't do this if we're
2937
exporting all dynamic symbols. */
2938
if (! info->export_dynamic)
2940
h->root.dynindx = -1;
2941
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2942
h->root.dynstr_index);
2949
/* Reject a file depending on presence and expectation of prefixed
2950
underscores on symbols. */
2953
cris_elf_object_p (abfd)
2956
if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
2957
return (bfd_get_symbol_leading_char (abfd) == '_');
2959
return (bfd_get_symbol_leading_char (abfd) == 0);
2962
/* Mark presence or absence of leading underscore. */
2965
cris_elf_final_write_processing (abfd, linker)
2967
boolean linker ATTRIBUTE_UNUSED;
2969
if (bfd_get_symbol_leading_char (abfd) == '_')
2970
elf_elfheader (abfd)->e_flags |= EF_CRIS_UNDERSCORE;
2972
elf_elfheader (abfd)->e_flags &= ~EF_CRIS_UNDERSCORE;
2975
/* Display the flags field. */
2978
cris_elf_print_private_bfd_data (abfd, ptr)
2982
FILE *file = (FILE *) ptr;
2984
BFD_ASSERT (abfd != NULL && ptr != NULL)
2986
_bfd_elf_print_private_bfd_data (abfd, ptr);
2988
fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2990
if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
2991
fprintf (file, _(" [symbols have a _ prefix]"));
2997
/* Don't mix files with and without a leading underscore. */
3000
cris_elf_merge_private_bfd_data (ibfd, obfd)
3004
flagword old_flags, new_flags;
3006
if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3009
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3010
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3013
if (! elf_flags_init (obfd))
3015
/* This happens when ld starts out with a 'blank' output file. */
3016
elf_flags_init (obfd) = true;
3018
/* Set flags according to current bfd_target. */
3019
cris_elf_final_write_processing (obfd, false);
3022
old_flags = elf_elfheader (obfd)->e_flags;
3023
new_flags = elf_elfheader (ibfd)->e_flags;
3025
/* Is this good or bad? We'll follow with other excluding flags. */
3026
if ((old_flags & EF_CRIS_UNDERSCORE) != (new_flags & EF_CRIS_UNDERSCORE))
3028
(*_bfd_error_handler)
3029
((new_flags & EF_CRIS_UNDERSCORE)
3030
? _("%s: uses _-prefixed symbols, but writing file with non-prefixed symbols")
3031
: _("%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
3032
bfd_archive_filename (ibfd));
3033
bfd_set_error (bfd_error_bad_value);
3041
static enum elf_reloc_type_class
3042
elf_cris_reloc_type_class (rela)
3043
const Elf_Internal_Rela *rela;
3045
switch ((int) ELF32_R_TYPE (rela->r_info))
3047
case R_CRIS_RELATIVE:
3048
return reloc_class_relative;
3049
case R_CRIS_JUMP_SLOT:
3050
return reloc_class_plt;
3052
return reloc_class_copy;
3054
return reloc_class_normal;
3058
#define ELF_ARCH bfd_arch_cris
3059
#define ELF_MACHINE_CODE EM_CRIS
3060
#define ELF_MAXPAGESIZE 0x2000
3062
#define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3063
#define TARGET_LITTLE_NAME "elf32-cris"
3064
#define elf_symbol_leading_char 0
3066
#define elf_info_to_howto_rel NULL
3067
#define elf_info_to_howto cris_info_to_howto_rela
3068
#define elf_backend_relocate_section cris_elf_relocate_section
3069
#define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3070
#define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3071
#define elf_backend_check_relocs cris_elf_check_relocs
3072
#define elf_backend_grok_prstatus cris_elf_grok_prstatus
3073
#define elf_backend_grok_psinfo cris_elf_grok_psinfo
3075
#define elf_backend_can_gc_sections 1
3076
#define elf_backend_can_refcount 1
3078
#define elf_backend_object_p cris_elf_object_p
3079
#define elf_backend_final_write_processing \
3080
cris_elf_final_write_processing
3081
#define bfd_elf32_bfd_print_private_bfd_data \
3082
cris_elf_print_private_bfd_data
3083
#define bfd_elf32_bfd_merge_private_bfd_data \
3084
cris_elf_merge_private_bfd_data
3086
#define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3088
#define bfd_elf32_bfd_link_hash_table_create \
3089
elf_cris_link_hash_table_create
3090
#define elf_backend_adjust_dynamic_symbol \
3091
elf_cris_adjust_dynamic_symbol
3092
#define elf_backend_size_dynamic_sections \
3093
elf_cris_size_dynamic_sections
3094
#define elf_backend_finish_dynamic_symbol \
3095
elf_cris_finish_dynamic_symbol
3096
#define elf_backend_finish_dynamic_sections \
3097
elf_cris_finish_dynamic_sections
3098
#define elf_backend_create_dynamic_sections \
3099
_bfd_elf_create_dynamic_sections
3100
#define bfd_elf32_bfd_final_link \
3101
_bfd_elf32_gc_common_final_link
3102
#define elf_backend_hide_symbol elf_cris_hide_symbol
3103
#define elf_backend_reloc_type_class elf_cris_reloc_type_class
3105
#define elf_backend_want_got_plt 1
3106
#define elf_backend_plt_readonly 1
3107
#define elf_backend_want_plt_sym 0
3108
#define elf_backend_got_header_size 12
3109
#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3111
/* Later, we my want to optimize RELA entries into REL entries for dynamic
3112
linking and libraries (if it's a win of any significance). Until then,
3113
take the easy route. */
3114
#define elf_backend_may_use_rel_p 0
3115
#define elf_backend_may_use_rela_p 1
3117
#include "elf32-target.h"
3119
#define INCLUDED_TARGET_FILE
3121
#undef TARGET_LITTLE_SYM
3122
#undef TARGET_LITTLE_NAME
3123
#undef elf_symbol_leading_char
3125
#define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3126
#define TARGET_LITTLE_NAME "elf32-us-cris"
3127
#define elf_symbol_leading_char '_'
3129
#include "elf32-target.h"
added
removed
binutils/bfd/elf32-cris.c
