1 /* CRIS-specific support for 32-bit ELF.
2 Copyright 2000, 2001, 2002, 2003 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
*, Elf_Internal_Rela
*));
36 static bfd_boolean cris_elf_grok_prstatus
37 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
39 static bfd_boolean cris_elf_grok_psinfo
40 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
42 static bfd_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 bfd_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 bfd_boolean cris_elf_object_p
PARAMS ((bfd
*));
60 static void cris_elf_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
62 static bfd_boolean cris_elf_print_private_bfd_data
PARAMS ((bfd
*, PTR
));
64 static bfd_boolean cris_elf_merge_private_bfd_data
PARAMS ((bfd
*, bfd
*));
66 struct elf_cris_link_hash_entry
;
67 static bfd_boolean elf_cris_discard_excess_dso_dynamics
68 PARAMS ((struct elf_cris_link_hash_entry
*, PTR
));
69 static bfd_boolean elf_cris_discard_excess_program_dynamics
70 PARAMS ((struct elf_cris_link_hash_entry
*, PTR
));
71 static bfd_boolean elf_cris_adjust_gotplt_to_got
72 PARAMS ((struct elf_cris_link_hash_entry
*, PTR
));
73 static bfd_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 bfd_boolean elf_cris_adjust_dynamic_symbol
80 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
81 static bfd_boolean cris_elf_check_relocs
82 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
83 const Elf_Internal_Rela
*));
85 static bfd_boolean elf_cris_size_dynamic_sections
86 PARAMS ((bfd
*, struct bfd_link_info
*));
87 static bfd_boolean elf_cris_finish_dynamic_symbol
88 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
90 static bfd_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
*, bfd_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 Elf_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 (bfd_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 if (info
->relocatable
)
805 dynobj
= elf_hash_table (info
)->dynobj
;
806 local_got_offsets
= elf_local_got_offsets (input_bfd
);
807 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
808 sym_hashes
= elf_sym_hashes (input_bfd
);
809 relend
= relocs
+ input_section
->reloc_count
;
817 splt
= bfd_get_section_by_name (dynobj
, ".plt");
818 sgot
= bfd_get_section_by_name (dynobj
, ".got");
821 for (rel
= relocs
; rel
< relend
; rel
++)
823 reloc_howto_type
*howto
;
824 unsigned long r_symndx
;
825 Elf_Internal_Sym
*sym
;
827 struct elf_link_hash_entry
*h
;
829 bfd_reloc_status_type r
;
830 const char *symname
= NULL
;
833 r_type
= ELF32_R_TYPE (rel
->r_info
);
835 if ( r_type
== R_CRIS_GNU_VTINHERIT
836 || r_type
== R_CRIS_GNU_VTENTRY
)
839 /* This is a final link. */
840 r_symndx
= ELF32_R_SYM (rel
->r_info
);
841 howto
= cris_elf_howto_table
+ r_type
;
846 if (r_symndx
< symtab_hdr
->sh_info
)
848 sym
= local_syms
+ r_symndx
;
849 sec
= local_sections
[r_symndx
];
850 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
852 symname
= (bfd_elf_string_from_elf_section
853 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
855 symname
= bfd_section_name (input_bfd
, sec
);
859 /* It seems this can happen with erroneous or unsupported input
860 (mixing a.out and elf in an archive, for example.) */
861 if (sym_hashes
== NULL
)
864 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
866 while (h
->root
.type
== bfd_link_hash_indirect
867 || h
->root
.type
== bfd_link_hash_warning
)
868 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
870 symname
= h
->root
.root
.string
;
872 if (h
->root
.type
== bfd_link_hash_defined
873 || h
->root
.type
== bfd_link_hash_defweak
)
875 sec
= h
->root
.u
.def
.section
;
877 /* Perhaps we should detect the cases that
878 sec->output_section is expected to be NULL like i386 and
879 m68k, but apparently (and according to elfxx-ia64.c) all
880 valid cases are where the symbol is defined in a shared
881 object which we link dynamically against. This includes
882 PLT relocs for which we've created a PLT entry and other
883 relocs for which we're prepared to create dynamic
886 For now, new situations cause us to just err when
887 sec->output_offset is NULL but the object with the symbol
888 is *not* dynamically linked against. Thus this will
889 automatically remind us so we can see if there are other
890 valid cases we need to revisit. */
891 if ((sec
->output_section
== NULL
892 && (sec
->owner
->flags
& DYNAMIC
) != 0)
894 /* Here follow the cases where the relocation value must
895 be zero (or when further handling is simplified when
896 zero). I can't claim to understand the various
897 conditions and they weren't described in the files
898 where I copied them from (elf32-m68k.c and
899 elf32-i386.c), but let's mention examples of where
900 they happen. FIXME: Perhaps define and use a
901 dynamic_symbol_p function like ia64.
903 - When creating a shared library, we can have an
904 ordinary relocation for a symbol defined in a shared
905 library (perhaps the one we create). We then make
906 the relocation value zero, as the value seen now will
907 be added into the relocation addend in this shared
908 library, but must be handled only at dynamic-link
909 time. FIXME: Not sure this example covers the
910 h->elf_link_hash_flags test, though it's there in
913 && ((! info
->symbolic
&& h
->dynindx
!= -1)
914 || (h
->elf_link_hash_flags
915 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
916 && (input_section
->flags
& SEC_ALLOC
) != 0
917 && (r_type
== R_CRIS_8
918 || r_type
== R_CRIS_16
919 || r_type
== R_CRIS_32
920 || r_type
== R_CRIS_8_PCREL
921 || r_type
== R_CRIS_16_PCREL
922 || r_type
== R_CRIS_32_PCREL
)))
924 else if (sec
->output_section
!= NULL
)
925 relocation
= (h
->root
.u
.def
.value
926 + sec
->output_section
->vma
927 + sec
->output_offset
);
930 (*_bfd_error_handler
)
931 (_("%s: unresolvable relocation %s against symbol `%s' from %s section"),
932 bfd_archive_filename (input_bfd
),
933 cris_elf_howto_table
[r_type
].name
,
935 bfd_get_section_name (input_bfd
, input_section
));
936 bfd_set_error (bfd_error_bad_value
);
940 else if (h
->root
.type
== bfd_link_hash_undefweak
)
942 else if (info
->shared
943 && !info
->no_undefined
944 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
948 if (!(info
->callbacks
->undefined_symbol
949 (info
, symname
, input_bfd
,
950 input_section
, rel
->r_offset
,
951 (!info
->shared
|| info
->no_undefined
952 || ELF_ST_VISIBILITY (h
->other
)))))
960 case R_CRIS_16_GOTPLT
:
961 case R_CRIS_32_GOTPLT
:
962 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
963 but we require a PLT, and the PLT handling will take care of
964 filling in the PLT-specific GOT entry. For the GOT offset,
965 calculate it as we do when filling it in for the .got.plt
966 section. If we don't have a PLT, punt to GOT handling. */
968 && ((struct elf_cris_link_hash_entry
*) h
)->gotplt_offset
!= 0)
971 = bfd_get_section_by_name (dynobj
, ".got.plt");
974 BFD_ASSERT (h
->dynindx
!= -1);
975 BFD_ASSERT (sgotplt
!= NULL
);
978 = ((struct elf_cris_link_hash_entry
*) h
)->gotplt_offset
;
980 relocation
= got_offset
;
984 /* We didn't make a PLT entry for this symbol. Maybe everything is
985 folded into the GOT. Other than folding, this happens when
986 statically linking PIC code, or when using -Bsymbolic. Check
987 that we instead have a GOT entry as done for us by
988 elf_cris_adjust_dynamic_symbol, and drop through into the
989 ordinary GOT cases. */
990 if (h
!= NULL
&& h
->got
.offset
== (bfd_vma
) -1)
992 (*_bfd_error_handler
)
993 (_("%s: No PLT nor GOT for relocation %s against symbol `%s' from %s section"),
994 bfd_archive_filename (input_bfd
),
995 cris_elf_howto_table
[r_type
].name
,
996 symname
[0] != '\0' ? symname
: _("[whose name is lost]"),
997 bfd_get_section_name (input_bfd
, input_section
));
999 /* FIXME: Perhaps blaming input is not the right thing to
1000 do; this is probably an internal error. But it is true
1001 that we didn't like that particular input. */
1002 bfd_set_error (bfd_error_bad_value
);
1007 /* The size of the actual relocation is not used here; we only
1008 fill in the GOT table here. */
1014 /* Note that despite using RELA relocations, the .got contents
1015 is always filled in with the link-relative relocation
1016 value; the addend. */
1020 off
= h
->got
.offset
;
1021 BFD_ASSERT (off
!= (bfd_vma
) -1);
1023 if (!elf_hash_table (info
)->dynamic_sections_created
1025 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1027 && (info
->symbolic
|| h
->dynindx
== -1)
1028 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1030 /* This wasn't checked above for ! info->shared, but
1031 must hold there if we get here; the symbol must be
1032 defined in the regular program, or be undefweak. */
1033 BFD_ASSERT (!elf_hash_table (info
)->dynamic_sections_created
1035 || (h
->elf_link_hash_flags
1036 & ELF_LINK_HASH_DEF_REGULAR
) != 0
1037 || h
->root
.type
== bfd_link_hash_undefweak
);
1039 /* This is actually a static link, or it is a
1040 -Bsymbolic link and the symbol is defined locally,
1041 or is undefweak, or the symbol was forced to be
1042 local because of a version file, or we're not
1043 creating a dynamic object. We must initialize this
1044 entry in the global offset table. Since the offset
1045 must always be a multiple of 4, we use the least
1046 significant bit to record whether we have
1047 initialized it already.
1049 If this GOT entry should be runtime-initialized, we
1050 will create a .rela.got relocation entry to
1051 initialize the value. This is done in the
1052 finish_dynamic_symbol routine. */
1057 bfd_put_32 (output_bfd
, relocation
,
1058 sgot
->contents
+ off
);
1065 BFD_ASSERT (local_got_offsets
!= NULL
1066 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1068 off
= local_got_offsets
[r_symndx
];
1070 /* The offset must always be a multiple of 4. We use
1071 the least significant bit to record whether we have
1072 already generated the necessary reloc. */
1077 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1082 Elf_Internal_Rela outrel
;
1085 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1086 BFD_ASSERT (s
!= NULL
);
1088 outrel
.r_offset
= (sgot
->output_section
->vma
1089 + sgot
->output_offset
1091 outrel
.r_info
= ELF32_R_INFO (0, R_CRIS_RELATIVE
);
1092 outrel
.r_addend
= relocation
;
1094 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1095 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1098 local_got_offsets
[r_symndx
] |= 1;
1102 relocation
= sgot
->output_offset
+ off
;
1103 if (rel
->r_addend
!= 0)
1105 /* We can't do anything for a relocation which is against
1106 a symbol *plus offset*. GOT holds relocations for
1107 symbols. Make this an error; the compiler isn't
1108 allowed to pass us these kinds of things. */
1110 (*_bfd_error_handler
)
1111 (_("%s: relocation %s with non-zero addend %d against local symbol from %s section"),
1112 bfd_archive_filename (input_bfd
),
1113 cris_elf_howto_table
[r_type
].name
,
1115 bfd_get_section_name (input_bfd
, input_section
));
1117 (*_bfd_error_handler
)
1118 (_("%s: relocation %s with non-zero addend %d against symbol `%s' from %s section"),
1119 bfd_archive_filename (input_bfd
),
1120 cris_elf_howto_table
[r_type
].name
,
1122 symname
[0] != '\0' ? symname
: _("[whose name is lost]"),
1123 bfd_get_section_name (input_bfd
, input_section
));
1125 bfd_set_error (bfd_error_bad_value
);
1131 case R_CRIS_32_GOTREL
:
1132 /* This relocation must only be performed against local symbols.
1133 It's also ok when we link a program and the symbol is either
1134 defined in an ordinary (non-DSO) object or is undefined weak. */
1136 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1138 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1139 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1140 && h
->root
.type
== bfd_link_hash_undefweak
))))
1142 (*_bfd_error_handler
)
1143 (_("%s: relocation %s is not allowed for global symbol: `%s' from %s section"),
1144 bfd_archive_filename (input_bfd
),
1145 cris_elf_howto_table
[r_type
].name
,
1147 bfd_get_section_name (input_bfd
, input_section
));
1148 bfd_set_error (bfd_error_bad_value
);
1152 /* This can happen if we get a link error with the input ELF
1153 variant mismatching the output variant. Emit an error so
1154 it's noticed if it happens elsewhere. */
1157 (*_bfd_error_handler
)
1158 (_("%s: relocation %s in section %s with no GOT created"),
1159 bfd_archive_filename (input_bfd
),
1160 cris_elf_howto_table
[r_type
].name
,
1161 bfd_get_section_name (input_bfd
, input_section
));
1162 bfd_set_error (bfd_error_bad_value
);
1166 /* This relocation is like a PC-relative one, except the
1167 reference point is the location of GOT. Note that
1168 sgot->output_offset is not involved in this calculation. We
1169 always want the start of entire .got section, not the
1170 position after the reserved header. */
1171 relocation
-= sgot
->output_section
->vma
;
1174 case R_CRIS_32_PLT_PCREL
:
1175 /* Relocation is to the entry for this symbol in the
1176 procedure linkage table. */
1178 /* Resolve a PLT_PCREL reloc against a local symbol directly,
1179 without using the procedure linkage table. */
1180 if (h
== NULL
|| ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1183 if (h
->plt
.offset
== (bfd_vma
) -1
1186 /* We didn't make a PLT entry for this symbol. This
1187 happens when statically linking PIC code, or when
1188 using -Bsymbolic. */
1192 relocation
= (splt
->output_section
->vma
1193 + splt
->output_offset
1197 case R_CRIS_32_PLT_GOTREL
:
1198 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1199 start of the .got section. See also comment at
1201 relocation
-= sgot
->output_section
->vma
;
1203 /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1204 without using the procedure linkage table. */
1205 if (h
== NULL
|| ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1208 if (h
->plt
.offset
== (bfd_vma
) -1
1211 /* We didn't make a PLT entry for this symbol. This
1212 happens when statically linking PIC code, or when
1213 using -Bsymbolic. */
1217 relocation
= (splt
->output_section
->vma
1218 + splt
->output_offset
1220 - sgot
->output_section
->vma
);
1223 case R_CRIS_8_PCREL
:
1224 case R_CRIS_16_PCREL
:
1225 case R_CRIS_32_PCREL
:
1226 /* If the symbol was local, we need no shlib-specific handling. */
1227 if (h
== NULL
|| ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1236 && (input_section
->flags
& SEC_ALLOC
) != 0
1237 && ((r_type
!= R_CRIS_8_PCREL
1238 && r_type
!= R_CRIS_16_PCREL
1239 && r_type
!= R_CRIS_32_PCREL
)
1241 || (h
->elf_link_hash_flags
1242 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1244 Elf_Internal_Rela outrel
;
1246 bfd_boolean skip
, relocate
;
1248 /* When generating a shared object, these relocations
1249 are copied into the output file to be resolved at run
1256 name
= (bfd_elf_string_from_elf_section
1258 elf_elfheader (input_bfd
)->e_shstrndx
,
1259 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1263 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1264 && strcmp (bfd_get_section_name (input_bfd
,
1268 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1270 /* That section should have been created in
1271 cris_elf_check_relocs, but that function will not be
1272 called for objects which fail in
1273 cris_elf_merge_private_bfd_data. */
1276 (*_bfd_error_handler
)
1277 (_("%s: Internal inconsistency; no relocation section %s"),
1278 bfd_archive_filename (input_bfd
),
1281 bfd_set_error (bfd_error_bad_value
);
1290 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1292 if (outrel
.r_offset
== (bfd_vma
) -1)
1294 else if (outrel
.r_offset
== (bfd_vma
) -2)
1295 skip
= TRUE
, relocate
= TRUE
;
1296 outrel
.r_offset
+= (input_section
->output_section
->vma
1297 + input_section
->output_offset
);
1300 memset (&outrel
, 0, sizeof outrel
);
1301 /* h->dynindx may be -1 if the symbol was marked to
1304 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1305 || (h
->elf_link_hash_flags
1306 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1308 BFD_ASSERT (h
->dynindx
!= -1);
1309 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1310 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1314 if (r_type
== R_CRIS_32
)
1317 outrel
.r_info
= ELF32_R_INFO (0, R_CRIS_RELATIVE
);
1318 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1325 sec
= local_sections
[r_symndx
];
1328 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1330 == bfd_link_hash_defweak
));
1331 sec
= h
->root
.u
.def
.section
;
1333 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
1335 else if (sec
== NULL
|| sec
->owner
== NULL
)
1337 bfd_set_error (bfd_error_bad_value
);
1344 osec
= sec
->output_section
;
1345 indx
= elf_section_data (osec
)->dynindx
;
1346 BFD_ASSERT (indx
> 0);
1349 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1350 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1354 loc
= sreloc
->contents
;
1355 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1356 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1358 /* This reloc will be computed at runtime, so there's no
1359 need to do anything now, except for R_CRIS_32 relocations
1360 that have been turned into R_CRIS_RELATIVE. */
1368 r
= cris_final_link_relocate (howto
, input_bfd
, input_section
,
1369 contents
, rel
, relocation
);
1371 if (r
!= bfd_reloc_ok
)
1373 const char * msg
= (const char *) NULL
;
1377 case bfd_reloc_overflow
:
1378 r
= info
->callbacks
->reloc_overflow
1379 (info
, symname
, howto
->name
, (bfd_vma
) 0,
1380 input_bfd
, input_section
, rel
->r_offset
);
1383 case bfd_reloc_undefined
:
1384 r
= info
->callbacks
->undefined_symbol
1385 (info
, symname
, input_bfd
, input_section
, rel
->r_offset
,
1389 case bfd_reloc_outofrange
:
1390 msg
= _("internal error: out of range error");
1393 case bfd_reloc_notsupported
:
1394 msg
= _("internal error: unsupported relocation error");
1397 case bfd_reloc_dangerous
:
1398 msg
= _("internal error: dangerous relocation");
1402 msg
= _("internal error: unknown error");
1407 r
= info
->callbacks
->warning
1408 (info
, msg
, symname
, input_bfd
, input_section
, rel
->r_offset
);
1418 /* Finish up dynamic symbol handling. We set the contents of various
1419 dynamic sections here. */
1422 elf_cris_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1424 struct bfd_link_info
*info
;
1425 struct elf_link_hash_entry
*h
;
1426 Elf_Internal_Sym
*sym
;
1429 int plt_off1
= 2, plt_off2
= 10, plt_off3
= 16;
1431 dynobj
= elf_hash_table (info
)->dynobj
;
1433 if (h
->plt
.offset
!= (bfd_vma
) -1)
1441 bfd_vma gotplt_offset
1442 = ((struct elf_cris_link_hash_entry
*) h
)->gotplt_offset
;
1443 Elf_Internal_Rela rela
;
1445 bfd_boolean has_gotplt
= gotplt_offset
!= 0;
1447 /* Get the index in the procedure linkage table which
1448 corresponds to this symbol. This is the index of this symbol
1449 in all the symbols for which we are making plt entries. The
1450 first entry in the procedure linkage table is reserved. */
1451 /* We have to count backwards here, and the result is only valid as
1452 an index into .got.plt and its relocations. FIXME: Constants... */
1453 bfd_vma gotplt_index
= gotplt_offset
/4 - 3;
1455 /* Get the offset into the .got table of the entry that corresponds
1456 to this function. Note that we embed knowledge that "incoming"
1457 .got goes after .got.plt in the output without padding (pointer
1458 aligned). However, that knowledge is present in several other
1459 places too, here and in elflink.h at least. */
1463 : h
->got
.offset
+ elf_cris_hash_table(info
)->next_gotplt_entry
);
1465 /* This symbol has an entry in the procedure linkage table. Set it
1468 BFD_ASSERT (h
->dynindx
!= -1);
1470 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1471 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1472 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
1473 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1474 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
1475 && (! has_gotplt
|| srela
!= NULL
));
1477 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
1479 /* Fill in the entry in the procedure linkage table. */
1482 memcpy (splt
->contents
+ h
->plt
.offset
, elf_cris_plt_entry
,
1485 /* We need to enter the absolute address of the GOT entry here. */
1486 bfd_put_32 (output_bfd
, got_base
+ got_offset
,
1487 splt
->contents
+ h
->plt
.offset
+ plt_off1
);
1491 memcpy (splt
->contents
+ h
->plt
.offset
, elf_cris_pic_plt_entry
,
1493 bfd_put_32 (output_bfd
, got_offset
,
1494 splt
->contents
+ h
->plt
.offset
+ plt_off1
);
1497 /* Fill in the plt entry and make a relocation, if this is a "real"
1501 /* Fill in the offset into the reloc table. */
1502 bfd_put_32 (output_bfd
,
1503 gotplt_index
* sizeof (Elf32_External_Rela
),
1504 splt
->contents
+ h
->plt
.offset
+ plt_off2
);
1506 /* Fill in the offset to the first PLT entry, where to "jump". */
1507 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ plt_off3
+ 4),
1508 splt
->contents
+ h
->plt
.offset
+ plt_off3
);
1510 /* Fill in the entry in the global offset table with the address of
1511 the relocating stub. */
1512 bfd_put_32 (output_bfd
,
1513 (splt
->output_section
->vma
1514 + splt
->output_offset
1517 sgotplt
->contents
+ got_offset
);
1519 /* Fill in the entry in the .rela.plt section. */
1520 rela
.r_offset
= (sgotplt
->output_section
->vma
1521 + sgotplt
->output_offset
1523 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CRIS_JUMP_SLOT
);
1525 loc
= srela
->contents
+ gotplt_index
* sizeof (Elf32_External_Rela
);
1526 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1529 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1531 /* Mark the symbol as undefined, rather than as defined in
1532 the .plt section. Leave the value alone. */
1533 sym
->st_shndx
= SHN_UNDEF
;
1535 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1536 know whether resetting the value is significant; if it really
1537 is, rather than a quirk or bug in the sparc port, then I
1538 believe we'd see this elsewhere. */
1539 /* If the symbol is weak, we do need to clear the value.
1540 Otherwise, the PLT entry would provide a definition for
1541 the symbol even if the symbol wasn't defined anywhere,
1542 and so the symbol would never be NULL. */
1543 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
1549 /* We don't emit .got relocs for symbols that aren't in the
1550 dynamic-symbols table for an ordinary program and are either defined
1551 by the program or are undefined weak symbols. */
1552 if (h
->got
.offset
!= (bfd_vma
) -1
1554 || (h
->dynindx
!= -1
1555 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1556 && h
->root
.type
!= bfd_link_hash_undefweak
)))
1560 Elf_Internal_Rela rela
;
1564 /* This symbol has an entry in the global offset table. Set it up. */
1566 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1567 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
1568 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1570 rela
.r_offset
= (sgot
->output_section
->vma
1571 + sgot
->output_offset
1572 + (h
->got
.offset
&~ (bfd_vma
) 1));
1574 /* If this is a static link, or it is a -Bsymbolic link and the
1575 symbol is defined locally or was forced to be local because
1576 of a version file, we just want to emit a RELATIVE reloc.
1577 The entry in the global offset table will already have been
1578 initialized in the relocate_section function. */
1579 where
= sgot
->contents
+ (h
->got
.offset
&~ (bfd_vma
) 1);
1580 if (! elf_hash_table (info
)->dynamic_sections_created
1582 && (info
->symbolic
|| h
->dynindx
== -1)
1583 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1585 rela
.r_info
= ELF32_R_INFO (0, R_CRIS_RELATIVE
);
1586 rela
.r_addend
= bfd_get_signed_32 (output_bfd
, where
);
1590 bfd_put_32 (output_bfd
, (bfd_vma
) 0, where
);
1591 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CRIS_GLOB_DAT
);
1595 loc
= srela
->contents
;
1596 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1597 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1600 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1603 Elf_Internal_Rela rela
;
1606 /* This symbol needs a copy reloc. Set it up. */
1608 BFD_ASSERT (h
->dynindx
!= -1
1609 && (h
->root
.type
== bfd_link_hash_defined
1610 || h
->root
.type
== bfd_link_hash_defweak
));
1612 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1614 BFD_ASSERT (s
!= NULL
);
1616 rela
.r_offset
= (h
->root
.u
.def
.value
1617 + h
->root
.u
.def
.section
->output_section
->vma
1618 + h
->root
.u
.def
.section
->output_offset
);
1619 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CRIS_COPY
);
1621 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1622 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1625 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1626 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1627 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1628 sym
->st_shndx
= SHN_ABS
;
1633 /* Finish up the dynamic sections. */
1636 elf_cris_finish_dynamic_sections (output_bfd
, info
)
1638 struct bfd_link_info
*info
;
1644 dynobj
= elf_hash_table (info
)->dynobj
;
1646 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1647 BFD_ASSERT (sgot
!= NULL
);
1648 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1650 if (elf_hash_table (info
)->dynamic_sections_created
)
1653 Elf32_External_Dyn
*dyncon
, *dynconend
;
1655 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1656 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1658 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1659 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1660 for (; dyncon
< dynconend
; dyncon
++)
1662 Elf_Internal_Dyn dyn
;
1665 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1673 s
= bfd_get_section_by_name (output_bfd
, ".got");
1674 BFD_ASSERT (s
!= NULL
);
1675 dyn
.d_un
.d_ptr
= s
->vma
;
1676 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1680 /* Yes, we *can* have a .plt and no .plt.rela, for instance
1681 if all symbols are found in the .got (not .got.plt). */
1682 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
1683 dyn
.d_un
.d_ptr
= s
!= NULL
? s
->vma
: 0;
1684 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1688 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
1691 else if (s
->_cooked_size
!= 0)
1692 dyn
.d_un
.d_val
= s
->_cooked_size
;
1694 dyn
.d_un
.d_val
= s
->_raw_size
;
1695 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1699 /* The procedure linkage table relocs (DT_JMPREL) should
1700 not be included in the overall relocs (DT_RELA).
1701 Therefore, we override the DT_RELASZ entry here to
1702 make it not include the JMPREL relocs. Since the
1703 linker script arranges for .rela.plt to follow all
1704 other relocation sections, we don't have to worry
1705 about changing the DT_RELA entry. */
1706 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
1709 if (s
->_cooked_size
!= 0)
1710 dyn
.d_un
.d_val
-= s
->_cooked_size
;
1712 dyn
.d_un
.d_val
-= s
->_raw_size
;
1714 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1719 /* Fill in the first entry in the procedure linkage table. */
1720 if (splt
->_raw_size
> 0)
1723 memcpy (splt
->contents
, elf_cris_pic_plt0_entry
, PLT_ENTRY_SIZE
);
1726 memcpy (splt
->contents
, elf_cris_plt0_entry
, PLT_ENTRY_SIZE
);
1727 bfd_put_32 (output_bfd
,
1728 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
1729 splt
->contents
+ 6);
1730 bfd_put_32 (output_bfd
,
1731 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
1732 splt
->contents
+ 14);
1734 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
1740 /* Fill in the first three entries in the global offset table. */
1741 if (sgot
->_raw_size
> 0)
1744 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1746 bfd_put_32 (output_bfd
,
1747 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1749 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1750 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1753 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1758 /* Return the section that should be marked against GC for a given
1762 cris_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
)
1764 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1765 Elf_Internal_Rela
*rel
;
1766 struct elf_link_hash_entry
*h
;
1767 Elf_Internal_Sym
*sym
;
1771 switch (ELF32_R_TYPE (rel
->r_info
))
1773 case R_CRIS_GNU_VTINHERIT
:
1774 case R_CRIS_GNU_VTENTRY
:
1778 switch (h
->root
.type
)
1780 case bfd_link_hash_defined
:
1781 case bfd_link_hash_defweak
:
1782 return h
->root
.u
.def
.section
;
1784 case bfd_link_hash_common
:
1785 return h
->root
.u
.c
.p
->section
;
1793 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1798 /* Update the got entry reference counts for the section being removed. */
1801 cris_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1802 bfd
*abfd ATTRIBUTE_UNUSED
;
1803 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1804 asection
*sec ATTRIBUTE_UNUSED
;
1805 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
1807 Elf_Internal_Shdr
*symtab_hdr
;
1808 struct elf_link_hash_entry
**sym_hashes
;
1809 bfd_signed_vma
*local_got_refcounts
;
1810 const Elf_Internal_Rela
*rel
, *relend
;
1811 unsigned long r_symndx
;
1812 struct elf_link_hash_entry
*h
;
1817 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1818 sym_hashes
= elf_sym_hashes (abfd
);
1819 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1821 dynobj
= elf_hash_table (info
)->dynobj
;
1825 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1826 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1828 relend
= relocs
+ sec
->reloc_count
;
1829 for (rel
= relocs
; rel
< relend
; rel
++)
1831 switch (ELF32_R_TYPE (rel
->r_info
))
1835 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1836 if (r_symndx
>= symtab_hdr
->sh_info
)
1838 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1839 if (h
->got
.refcount
> 0)
1842 if (h
->got
.refcount
== 0)
1844 /* We don't need the .got entry any more. */
1845 sgot
->_raw_size
-= 4;
1846 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
1853 if (local_got_refcounts
!= NULL
)
1855 if (local_got_refcounts
[r_symndx
] > 0)
1857 --local_got_refcounts
[r_symndx
];
1858 if (local_got_refcounts
[r_symndx
] == 0)
1860 /* We don't need the .got entry any more. */
1861 sgot
->_raw_size
-= 4;
1863 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
1869 case R_CRIS_16_GOTPLT
:
1870 case R_CRIS_32_GOTPLT
:
1871 /* For local symbols, treat these like GOT relocs. */
1872 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1873 if (r_symndx
< symtab_hdr
->sh_info
)
1874 goto local_got_reloc
;
1876 case R_CRIS_32_PLT_GOTREL
:
1877 /* FIXME: We don't garbage-collect away the .got section. */
1878 if (local_got_refcounts
!= NULL
)
1879 local_got_refcounts
[-1]--;
1882 case R_CRIS_8_PCREL
:
1883 case R_CRIS_16_PCREL
:
1884 case R_CRIS_32_PCREL
:
1885 case R_CRIS_32_PLT_PCREL
:
1886 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1887 if (r_symndx
>= symtab_hdr
->sh_info
)
1889 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1890 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1891 && h
->plt
.refcount
> 0)
1904 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1905 entry but we found we will not create any. Called when we find we will
1906 not have any PLT for this symbol, by for example
1907 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
1908 or elf_cris_size_dynamic_sections if no dynamic sections will be
1909 created (we're only linking static objects). */
1912 elf_cris_adjust_gotplt_to_got (h
, p
)
1913 struct elf_cris_link_hash_entry
*h
;
1916 struct bfd_link_info
*info
= (struct bfd_link_info
*) p
;
1917 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1919 BFD_ASSERT (dynobj
!= NULL
);
1921 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1922 h
= (struct elf_cris_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1924 /* If nobody wanted a GOTPLT with this symbol, we're done. */
1925 if (h
->gotplt_refcount
<= 0)
1928 if (h
->root
.got
.refcount
> 0)
1930 /* There's a GOT entry for this symbol. Just adjust the refcount.
1931 Probably not necessary at this stage, but keeping it accurate
1932 helps avoiding surprises later. */
1933 h
->root
.got
.refcount
+= h
->gotplt_refcount
;
1934 h
->gotplt_refcount
= -1;
1938 /* No GOT entry for this symbol. We need to create one. */
1939 asection
*sgot
= bfd_get_section_by_name (dynobj
, ".got");
1941 = bfd_get_section_by_name (dynobj
, ".rela.got");
1943 /* Put an accurate refcount there. */
1944 h
->root
.got
.refcount
= h
->gotplt_refcount
;
1946 h
->gotplt_refcount
= -1;
1948 /* We always have a .got and a .rela.got section if there were
1949 GOTPLT relocs in input. */
1950 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
1952 /* Allocate space in the .got section. */
1953 sgot
->_raw_size
+= 4;
1955 /* Allocate relocation space. */
1956 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
1962 /* Try to fold PLT entries with GOT entries. There are two cases when we
1965 - When all PLT references are GOTPLT references, and there are GOT
1966 references. We don't have to generate a PLT at all.
1968 - When there are both (ordinary) PLT references and GOT references.
1969 We want to make the PLT reference use the ordinary GOT entry rather
1970 than a run-time dynamically resolved GOTPLT entry (since the GOT
1971 entry will have to be resolved at startup anyway).
1973 Though the latter case is handled when room for the PLT is allocated,
1976 Note that this function is called before symbols are forced local by
1977 version scripts. The differing cases are handled by
1978 elf_cris_hide_symbol. */
1981 elf_cris_try_fold_plt_to_got (h
, p
)
1982 struct elf_cris_link_hash_entry
*h
;
1985 struct bfd_link_info
*info
= (struct bfd_link_info
*) p
;
1987 /* If there are no GOT references for this symbol, we can't fold any
1988 other reference so there's nothing to do. Likewise if there are no
1989 PLT references; GOTPLT references included. */
1990 if (h
->root
.got
.refcount
<= 0 || h
->root
.plt
.refcount
<= 0)
1993 /* GOTPLT relocs are supposed to be included into the PLT refcount. */
1994 BFD_ASSERT (h
->gotplt_refcount
<= h
->root
.plt
.refcount
);
1996 if (h
->gotplt_refcount
== h
->root
.plt
.refcount
)
1998 /* The only PLT references are GOTPLT references, and there are GOT
1999 references. Convert PLT to GOT references. */
2000 if (! elf_cris_adjust_gotplt_to_got (h
, info
))
2003 /* Clear the PLT references, so no PLT will be created. */
2004 h
->root
.plt
.offset
= (bfd_vma
) -1;
2010 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2011 to use a GOT entry (and create one) rather than requiring a GOTPLT
2015 elf_cris_hide_symbol (info
, h
, force_local
)
2016 struct bfd_link_info
*info
;
2017 struct elf_link_hash_entry
*h
;
2018 bfd_boolean force_local
;
2020 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry
*) h
, info
);
2022 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
2025 /* Adjust a symbol defined by a dynamic object and referenced by a
2026 regular object. The current definition is in some section of the
2027 dynamic object, but we're not including those sections. We have to
2028 change the definition to something the rest of the link can
2032 elf_cris_adjust_dynamic_symbol (info
, h
)
2033 struct bfd_link_info
*info
;
2034 struct elf_link_hash_entry
*h
;
2038 unsigned int power_of_two
;
2040 dynobj
= elf_hash_table (info
)->dynobj
;
2042 /* Make sure we know what is going on here. */
2043 BFD_ASSERT (dynobj
!= NULL
2044 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2045 || h
->weakdef
!= NULL
2046 || ((h
->elf_link_hash_flags
2047 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2048 && (h
->elf_link_hash_flags
2049 & ELF_LINK_HASH_REF_REGULAR
) != 0
2050 && (h
->elf_link_hash_flags
2051 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2053 /* If this is a function, put it in the procedure linkage table. We
2054 will fill in the contents of the procedure linkage table later,
2055 when we know the address of the .got section. */
2056 if (h
->type
== STT_FUNC
2057 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2059 /* If we link a program (not a DSO), we'll get rid of unnecessary
2060 PLT entries; we point to the actual symbols -- even for pic
2061 relocs, because a program built with -fpic should have the same
2062 result as one built without -fpic, specifically considering weak
2064 FIXME: m68k and i386 differ here, for unclear reasons. */
2066 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
2068 /* This case can occur if we saw a PLT reloc in an input file,
2069 but the symbol was not defined by a dynamic object. In such
2070 a case, we don't actually need to build a procedure linkage
2071 table, and we can just do an absolute or PC reloc instead, or
2072 change a .got.plt index to a .got index for GOTPLT relocs. */
2073 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2074 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2075 h
->plt
.offset
= (bfd_vma
) -1;
2077 elf_cris_adjust_gotplt_to_got ((struct
2078 elf_cris_link_hash_entry
*) h
,
2082 /* If there are only GOT references and GOTPLT references to this
2083 PLT entry, get rid of the PLT. */
2084 if (! elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry
*)
2088 /* GC or folding may have rendered this entry unused. */
2089 if (h
->plt
.refcount
<= 0)
2091 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2092 h
->plt
.offset
= (bfd_vma
) -1;
2096 /* Make sure this symbol is output as a dynamic symbol. */
2097 if (h
->dynindx
== -1)
2099 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2103 s
= bfd_get_section_by_name (dynobj
, ".plt");
2104 BFD_ASSERT (s
!= NULL
);
2106 /* If this is the first .plt entry, make room for the special
2108 if (s
->_raw_size
== 0)
2109 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2111 /* If this symbol is not defined in a regular file, and we are
2112 not generating a shared library, then set the symbol to this
2113 location in the .plt. */
2115 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2117 h
->root
.u
.def
.section
= s
;
2118 h
->root
.u
.def
.value
= s
->_raw_size
;
2121 /* If there's already a GOT entry, use that, not a .got.plt. A
2122 GOT field still has a reference count when we get here; it's
2123 not yet changed to an offset. */
2124 if (h
->got
.refcount
> 0)
2126 h
->got
.refcount
+= h
->plt
.refcount
;
2128 /* Mark the PLT offset to use the GOT entry by setting the low
2129 bit in the plt offset; it is always a multiple of
2131 BFD_ASSERT ((s
->_raw_size
& 3) == 0);
2133 /* Change the PLT refcount to an offset. */
2134 h
->plt
.offset
= s
->_raw_size
;
2136 /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2137 that the got entry should be used instead. */
2138 BFD_ASSERT (((struct elf_cris_link_hash_entry
*)
2139 h
)->gotplt_offset
== 0);
2141 /* Make room for this entry. */
2142 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2147 /* No GOT reference for this symbol; prepare for an ordinary PLT. */
2148 h
->plt
.offset
= s
->_raw_size
;
2150 /* Make room for this entry. */
2151 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2153 /* We also need to make an entry in the .got.plt section, which
2154 will be placed in the .got section by the linker script. */
2155 ((struct elf_cris_link_hash_entry
*) h
)->gotplt_offset
2156 = elf_cris_hash_table (info
)->next_gotplt_entry
;
2157 elf_cris_hash_table (info
)->next_gotplt_entry
+= 4;
2159 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2160 BFD_ASSERT (s
!= NULL
);
2163 /* We also need to make an entry in the .rela.plt section. */
2165 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2166 BFD_ASSERT (s
!= NULL
);
2167 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
2172 /* Reinitialize the plt offset now that it is not used as a reference
2174 h
->plt
.offset
= (bfd_vma
) -1;
2176 /* If this is a weak symbol, and there is a real definition, the
2177 processor independent code will have arranged for us to see the
2178 real definition first, and we can just use the same value. */
2179 if (h
->weakdef
!= NULL
)
2181 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2182 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2183 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2184 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2188 /* This is a reference to a symbol defined by a dynamic object which
2189 is not a function. */
2191 /* If we are creating a shared library, we must presume that the
2192 only references to the symbol are via the global offset table.
2193 For such cases we need not do anything here; the relocations will
2194 be handled correctly by relocate_section. */
2198 /* If there are no references to this symbol that do not use the
2199 GOT, we don't need to generate a copy reloc. */
2200 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
2203 /* We must allocate the symbol in our .dynbss section, which will
2204 become part of the .bss section of the executable. There will be
2205 an entry for this symbol in the .dynsym section. The dynamic
2206 object will contain position independent code, so all references
2207 from the dynamic object to this symbol will go through the global
2208 offset table. The dynamic linker will use the .dynsym entry to
2209 determine the address it must put in the global offset table, so
2210 both the dynamic object and the regular object will refer to the
2211 same memory location for the variable. */
2213 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2214 BFD_ASSERT (s
!= NULL
);
2216 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2217 copy the initial value out of the dynamic object and into the
2218 runtime process image. We need to remember the offset into the
2219 .rela.bss section we are going to use. */
2220 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2224 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
2225 BFD_ASSERT (srel
!= NULL
);
2226 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2227 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2230 /* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2231 thing to copy; so do we. */
2233 /* We need to figure out the alignment required for this symbol. I
2234 have no idea how ELF linkers handle this. */
2235 power_of_two
= bfd_log2 (h
->size
);
2236 if (power_of_two
> 3)
2239 /* Apply the required alignment. */
2240 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2241 (bfd_size_type
) (1 << power_of_two
));
2242 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2244 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2248 /* Define the symbol as being at this point in the section. */
2249 h
->root
.u
.def
.section
= s
;
2250 h
->root
.u
.def
.value
= s
->_raw_size
;
2252 /* Increment the section size to make room for the symbol. */
2253 s
->_raw_size
+= h
->size
;
2258 /* Look through the relocs for a section during the first phase. */
2261 cris_elf_check_relocs (abfd
, info
, sec
, relocs
)
2263 struct bfd_link_info
*info
;
2265 const Elf_Internal_Rela
*relocs
;
2268 Elf_Internal_Shdr
*symtab_hdr
;
2269 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
2270 bfd_signed_vma
*local_got_refcounts
;
2271 const Elf_Internal_Rela
*rel
;
2272 const Elf_Internal_Rela
*rel_end
;
2277 if (info
->relocatable
)
2280 dynobj
= elf_hash_table (info
)->dynobj
;
2281 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2282 sym_hashes
= elf_sym_hashes (abfd
);
2283 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
2284 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2290 if (!elf_bad_symtab (abfd
))
2291 sym_hashes_end
-= symtab_hdr
->sh_info
;
2293 rel_end
= relocs
+ sec
->reloc_count
;
2294 for (rel
= relocs
; rel
< rel_end
; rel
++)
2296 struct elf_link_hash_entry
*h
;
2297 unsigned long r_symndx
;
2298 enum elf_cris_reloc_type r_type
;
2300 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2301 if (r_symndx
< symtab_hdr
->sh_info
)
2304 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2306 r_type
= ELF32_R_TYPE (rel
->r_info
);
2308 /* Some relocs require linker-created sections; we need to hang them
2309 on the first input bfd we found that contained dynamic relocs. */
2314 case R_CRIS_32_GOTREL
:
2315 case R_CRIS_32_PLT_GOTREL
:
2316 case R_CRIS_32_PLT_PCREL
:
2317 case R_CRIS_16_GOTPLT
:
2318 case R_CRIS_32_GOTPLT
:
2321 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2323 /* Create the .got section, so we can assume it's always
2324 present whenever there's a dynobj. */
2325 if (!_bfd_elf_create_got_section (dynobj
, info
))
2334 /* Some relocs require a global offset table (but perhaps not a
2335 specific GOT entry). */
2338 /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
2339 entry only for local symbols. Unfortunately, we don't know
2340 until later on if there's a version script that forces the
2341 symbol local. We must have the .rela.got section in place
2342 before we know if the symbol looks global now, so we need
2343 to treat the reloc just like for R_CRIS_16_GOT and
2345 case R_CRIS_16_GOTPLT
:
2346 case R_CRIS_32_GOTPLT
:
2350 && (h
!= NULL
|| info
->shared
))
2352 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
2353 if (srelgot
== NULL
)
2355 srelgot
= bfd_make_section (dynobj
, ".rela.got");
2357 || !bfd_set_section_flags (dynobj
, srelgot
,
2362 | SEC_LINKER_CREATED
2364 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
2370 case R_CRIS_32_GOTREL
:
2371 case R_CRIS_32_PLT_GOTREL
:
2373 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2375 if (local_got_refcounts
== NULL
)
2379 /* We use index local_got_refcounts[-1] to count all
2380 GOT-relative relocations that do not have explicit
2382 amt
= symtab_hdr
->sh_info
+ 1;
2383 amt
*= sizeof (bfd_signed_vma
);
2384 local_got_refcounts
= ((bfd_signed_vma
*) bfd_zalloc (abfd
, amt
));
2385 if (local_got_refcounts
== NULL
)
2388 local_got_refcounts
++;
2389 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2399 case R_CRIS_16_GOTPLT
:
2400 case R_CRIS_32_GOTPLT
:
2401 /* Mark that we need a GOT entry if the PLT entry (and its GOT
2402 entry) is eliminated. We can only do this for a non-local
2406 ((struct elf_cris_link_hash_entry
*) h
)->gotplt_refcount
++;
2407 goto handle_gotplt_reloc
;
2409 /* If h is NULL then this is a local symbol, and we must make a
2410 GOT entry for it, so handle it like a GOT reloc. */
2415 /* This symbol requires a global offset table entry. */
2418 if (h
->got
.refcount
== 0)
2420 /* Make sure this symbol is output as a dynamic symbol. */
2421 if (h
->dynindx
== -1)
2423 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2427 /* Allocate space in the .got section. */
2428 sgot
->_raw_size
+= 4;
2429 /* Allocate relocation space. */
2430 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
2436 /* This is a global offset table entry for a local symbol. */
2437 if (local_got_refcounts
[r_symndx
] == 0)
2439 sgot
->_raw_size
+= 4;
2442 /* If we are generating a shared object, we need to
2443 output a R_CRIS_RELATIVE reloc so that the dynamic
2444 linker can adjust this GOT entry. */
2445 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
2448 local_got_refcounts
[r_symndx
]++;
2452 case R_CRIS_32_GOTREL
:
2453 /* This reference requires a global offset table.
2454 FIXME: The actual refcount isn't used currently; the .got
2455 section can't be removed if there were any references in the
2457 local_got_refcounts
[-1]++;
2460 handle_gotplt_reloc
:
2462 case R_CRIS_32_PLT_GOTREL
:
2463 /* This reference requires a global offset table. */
2464 local_got_refcounts
[-1]++;
2467 case R_CRIS_32_PLT_PCREL
:
2468 /* This symbol requires a procedure linkage table entry. We
2469 actually build the entry in adjust_dynamic_symbol,
2470 because this might be a case of linking PIC code which is
2471 never referenced by a dynamic object, in which case we
2472 don't need to generate a procedure linkage table entry
2475 /* If this is a local symbol, we resolve it directly without
2476 creating a procedure linkage table entry. */
2477 if (h
== NULL
|| ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2480 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2487 /* Let's help debug shared library creation. Any of these
2488 relocs can be used in shared libs, but pages containing them
2489 cannot be shared. Don't warn for sections we don't care
2490 about, such as debug sections or non-constant sections. We
2491 can't help tables of (global) function pointers, for example,
2492 though they must be emitted in a data section to avoid having
2493 impure text sections. */
2495 && (sec
->flags
& SEC_ALLOC
) != 0
2496 && (sec
->flags
& SEC_READONLY
) != 0)
2498 /* FIXME: How do we make this optionally a warning only? */
2499 (*_bfd_error_handler
)
2500 (_("%s, section %s:\n relocation %s should not be used in a shared object; recompile with -fPIC"),
2501 bfd_archive_filename (abfd
),
2503 cris_elf_howto_table
[r_type
].name
);
2507 case R_CRIS_8_PCREL
:
2508 case R_CRIS_16_PCREL
:
2509 case R_CRIS_32_PCREL
:
2512 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
2514 /* Make sure a plt entry is created for this symbol if it
2515 turns out to be a function defined by a dynamic object. */
2516 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2520 /* If we are creating a shared library and this is not a local
2521 symbol, we need to copy the reloc into the shared library.
2522 However when linking with -Bsymbolic and this is a global
2523 symbol which is defined in an object we are including in the
2524 link (i.e., DEF_REGULAR is set), then we can resolve the
2525 reloc directly. At this point we have not seen all the input
2526 files, so it is possible that DEF_REGULAR is not set now but
2527 will be set later (it is never cleared). In case of a weak
2528 definition, DEF_REGULAR may be cleared later by a strong
2529 definition in a shared library. We account for that
2530 possibility below by storing information in the relocs_copied
2531 field of the hash table entry. A similar situation occurs
2532 when creating shared libraries and symbol visibility changes
2533 render the symbol local. */
2535 /* No need to do anything if we're not creating a shared object. */
2539 /* We don't need to handle relocs into sections not going into
2540 the "real" output. */
2541 if ((sec
->flags
& SEC_ALLOC
) == 0)
2544 /* We can only eliminate PC-relative relocs. */
2545 if (r_type
== R_CRIS_8_PCREL
2546 || r_type
== R_CRIS_16_PCREL
2547 || r_type
== R_CRIS_32_PCREL
)
2549 /* If the symbol is local, then we can eliminate the reloc. */
2550 if (h
== NULL
|| ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2553 /* If this is with -Bsymbolic and the symbol isn't weak, and
2554 is defined by an ordinary object (the ones we include in
2555 this shared library) then we can also eliminate the
2556 reloc. See comment above for more eliminable cases which
2557 we can't identify at this time. */
2559 && h
->root
.type
!= bfd_link_hash_defweak
2560 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2564 /* We create a reloc section in dynobj and make room for this
2570 name
= (bfd_elf_string_from_elf_section
2572 elf_elfheader (abfd
)->e_shstrndx
,
2573 elf_section_data (sec
)->rel_hdr
.sh_name
));
2577 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
2578 && strcmp (bfd_get_section_name (abfd
, sec
),
2581 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2584 sreloc
= bfd_make_section (dynobj
, name
);
2586 || !bfd_set_section_flags (dynobj
, sreloc
,
2591 | SEC_LINKER_CREATED
2593 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
2596 if (sec
->flags
& SEC_READONLY
)
2597 info
->flags
|= DF_TEXTREL
;
2600 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
2602 /* If we are linking with -Bsymbolic, we count the number of PC
2603 relative relocations we have entered for this symbol, so that
2604 we can discard them again if the symbol is later defined by a
2605 regular object. We know that h is really a pointer to an
2606 elf_cris_link_hash_entry. */
2607 if ((r_type
== R_CRIS_8_PCREL
2608 || r_type
== R_CRIS_16_PCREL
2609 || r_type
== R_CRIS_32_PCREL
)
2612 struct elf_cris_link_hash_entry
*eh
;
2613 struct elf_cris_pcrel_relocs_copied
*p
;
2615 eh
= (struct elf_cris_link_hash_entry
*) h
;
2617 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2618 if (p
->section
== sreloc
)
2623 p
= ((struct elf_cris_pcrel_relocs_copied
*)
2624 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
2627 p
->next
= eh
->pcrel_relocs_copied
;
2628 eh
->pcrel_relocs_copied
= p
;
2629 p
->section
= sreloc
;
2637 /* This relocation describes the C++ object vtable hierarchy.
2638 Reconstruct it for later use during GC. */
2639 case R_CRIS_GNU_VTINHERIT
:
2640 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2644 /* This relocation describes which C++ vtable entries are actually
2645 used. Record for later use during GC. */
2646 case R_CRIS_GNU_VTENTRY
:
2647 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2652 /* Other relocs do not appear here. */
2653 bfd_set_error (bfd_error_bad_value
);
2661 /* Set the sizes of the dynamic sections. */
2664 elf_cris_size_dynamic_sections (output_bfd
, info
)
2665 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2666 struct bfd_link_info
*info
;
2673 dynobj
= elf_hash_table (info
)->dynobj
;
2674 BFD_ASSERT (dynobj
!= NULL
);
2676 if (elf_hash_table (info
)->dynamic_sections_created
)
2678 /* Set the contents of the .interp section to the interpreter. */
2681 s
= bfd_get_section_by_name (dynobj
, ".interp");
2682 BFD_ASSERT (s
!= NULL
);
2683 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2684 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2689 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2690 elf_cris_link_hash_traverse (elf_cris_hash_table (info
),
2691 elf_cris_adjust_gotplt_to_got
,
2694 /* We may have created entries in the .rela.got section.
2695 However, if we are not creating the dynamic sections, we will
2696 not actually use these entries. Reset the size of .rela.got,
2697 which will cause it to get stripped from the output file
2699 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
2704 /* If this is a -Bsymbolic shared link, then we need to discard all PC
2705 relative relocs against symbols defined in a regular object. We
2706 allocated space for them in the check_relocs routine, but we will not
2707 fill them in in the relocate_section routine. We also discard space
2708 for relocs that have become for local symbols due to symbol
2709 visibility changes. For programs, we discard space for relocs for
2710 symbols not referenced by any dynamic object. */
2712 elf_cris_link_hash_traverse (elf_cris_hash_table (info
),
2713 elf_cris_discard_excess_dso_dynamics
,
2716 elf_cris_link_hash_traverse (elf_cris_hash_table (info
),
2717 elf_cris_discard_excess_program_dynamics
,
2720 /* The check_relocs and adjust_dynamic_symbol entry points have
2721 determined the sizes of the various dynamic sections. Allocate
2725 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2730 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2733 /* It's OK to base decisions on the section name, because none
2734 of the dynobj section names depend upon the input files. */
2735 name
= bfd_get_section_name (dynobj
, s
);
2739 if (strcmp (name
, ".plt") == 0)
2741 if (s
->_raw_size
== 0)
2743 /* Strip this section if we don't need it; see the
2749 /* Remember whether there is a PLT. */
2753 else if (strncmp (name
, ".rela", 5) == 0)
2755 if (s
->_raw_size
== 0)
2757 /* If we don't need this section, strip it from the
2758 output file. This is mostly to handle .rela.bss and
2759 .rela.plt. We must create both sections in
2760 create_dynamic_sections, because they must be created
2761 before the linker maps input sections to output
2762 sections. The linker does that before
2763 adjust_dynamic_symbol is called, and it is that
2764 function which decides whether anything needs to go
2765 into these sections. */
2770 /* Remember whether there are any reloc sections other
2772 if (strcmp (name
, ".rela.plt") != 0)
2775 /* We use the reloc_count field as a counter if we need
2776 to copy relocs into the output file. */
2780 else if (strncmp (name
, ".got", 4) != 0)
2782 /* It's not one of our sections, so don't allocate space. */
2788 _bfd_strip_section_from_output (info
, s
);
2792 /* Allocate memory for the section contents. We use bfd_zalloc here
2793 in case unused entries are not reclaimed before the section's
2794 contents are written out. This should not happen, but this way
2795 if it does, we will not write out garbage. For reloc sections,
2796 this will make entries have the type R_CRIS_NONE. */
2797 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2798 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2802 if (elf_hash_table (info
)->dynamic_sections_created
)
2804 /* Add some entries to the .dynamic section. We fill in the
2805 values later, in elf_cris_finish_dynamic_sections, but we
2806 must add the entries now so that we get the correct size for
2807 the .dynamic section. The DT_DEBUG entry is filled in by the
2808 dynamic linker and used by the debugger. */
2809 #define add_dynamic_entry(TAG, VAL) \
2810 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2814 if (!add_dynamic_entry (DT_DEBUG
, 0))
2820 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2821 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2822 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2823 || !add_dynamic_entry (DT_JMPREL
, 0))
2829 if (!add_dynamic_entry (DT_RELA
, 0)
2830 || !add_dynamic_entry (DT_RELASZ
, 0)
2831 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2835 if ((info
->flags
& DF_TEXTREL
) != 0)
2837 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2839 info
->flags
|= DF_TEXTREL
;
2842 #undef add_dynamic_entry
2847 /* This function is called via elf_cris_link_hash_traverse if we are
2848 creating a shared object. In the -Bsymbolic case, it discards the
2849 space allocated to copy PC relative relocs against symbols which
2850 are defined in regular objects. For the normal non-symbolic case,
2851 we also discard space for relocs that have become local due to
2852 symbol visibility changes. We allocated space for them in the
2853 check_relocs routine, but we won't fill them in in the
2854 relocate_section routine. */
2857 elf_cris_discard_excess_dso_dynamics (h
, inf
)
2858 struct elf_cris_link_hash_entry
*h
;
2861 struct elf_cris_pcrel_relocs_copied
*s
;
2862 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2864 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2865 h
= (struct elf_cris_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2867 /* If a symbol has been forced local or we have found a regular
2868 definition for the symbolic link case, then we won't be needing
2870 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2871 && ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
2874 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
2875 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rela
);
2881 /* This function is called via elf_cris_link_hash_traverse if we are *not*
2882 creating a shared object. We discard space for relocs for symbols put
2883 in the .got, but which we found we do not have to resolve at run-time. */
2886 elf_cris_discard_excess_program_dynamics (h
, inf
)
2887 struct elf_cris_link_hash_entry
*h
;
2890 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2892 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2893 h
= (struct elf_cris_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2895 /* If we're not creating a shared library and have a symbol which is
2896 referred to by .got references, but the symbol is defined locally,
2897 (or rather, not not defined by a DSO) then lose the reloc for the
2898 .got (don't allocate room for it). */
2899 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
2901 if (h
->root
.got
.refcount
> 0
2902 /* The size of this section is only valid and in sync with the
2903 various reference counts if we do dynamic; don't decrement it
2905 && elf_hash_table (info
)->dynamic_sections_created
)
2907 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
2910 BFD_ASSERT (dynobj
!= NULL
);
2912 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
2914 BFD_ASSERT (srelgot
!= NULL
);
2916 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
2919 /* If the locally-defined symbol isn't used by a DSO, then we don't
2920 have to export it as a dynamic symbol. This was already done for
2921 functions; doing this for all symbols would presumably not
2922 introduce new problems. Of course we don't do this if we're
2923 exporting all dynamic symbols. */
2924 if (! info
->export_dynamic
2925 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2927 h
->root
.dynindx
= -1;
2928 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2929 h
->root
.dynstr_index
);
2936 /* Reject a file depending on presence and expectation of prefixed
2937 underscores on symbols. */
2940 cris_elf_object_p (abfd
)
2943 if ((elf_elfheader (abfd
)->e_flags
& EF_CRIS_UNDERSCORE
))
2944 return (bfd_get_symbol_leading_char (abfd
) == '_');
2946 return (bfd_get_symbol_leading_char (abfd
) == 0);
2949 /* Mark presence or absence of leading underscore. */
2952 cris_elf_final_write_processing (abfd
, linker
)
2954 bfd_boolean linker ATTRIBUTE_UNUSED
;
2956 if (bfd_get_symbol_leading_char (abfd
) == '_')
2957 elf_elfheader (abfd
)->e_flags
|= EF_CRIS_UNDERSCORE
;
2959 elf_elfheader (abfd
)->e_flags
&= ~EF_CRIS_UNDERSCORE
;
2962 /* Display the flags field. */
2965 cris_elf_print_private_bfd_data (abfd
, ptr
)
2969 FILE *file
= (FILE *) ptr
;
2971 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
)
2973 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2975 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2977 if (elf_elfheader (abfd
)->e_flags
& EF_CRIS_UNDERSCORE
)
2978 fprintf (file
, _(" [symbols have a _ prefix]"));
2984 /* Don't mix files with and without a leading underscore. */
2987 cris_elf_merge_private_bfd_data (ibfd
, obfd
)
2991 flagword old_flags
, new_flags
;
2993 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2996 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2997 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3000 if (! elf_flags_init (obfd
))
3002 /* This happens when ld starts out with a 'blank' output file. */
3003 elf_flags_init (obfd
) = TRUE
;
3005 /* Set flags according to current bfd_target. */
3006 cris_elf_final_write_processing (obfd
, FALSE
);
3009 old_flags
= elf_elfheader (obfd
)->e_flags
;
3010 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3012 /* Is this good or bad? We'll follow with other excluding flags. */
3013 if ((old_flags
& EF_CRIS_UNDERSCORE
) != (new_flags
& EF_CRIS_UNDERSCORE
))
3015 (*_bfd_error_handler
)
3016 ((new_flags
& EF_CRIS_UNDERSCORE
)
3017 ? _("%s: uses _-prefixed symbols, but writing file with non-prefixed symbols")
3018 : _("%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
3019 bfd_archive_filename (ibfd
));
3020 bfd_set_error (bfd_error_bad_value
);
3028 static enum elf_reloc_type_class
3029 elf_cris_reloc_type_class (rela
)
3030 const Elf_Internal_Rela
*rela
;
3032 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3034 case R_CRIS_RELATIVE
:
3035 return reloc_class_relative
;
3036 case R_CRIS_JUMP_SLOT
:
3037 return reloc_class_plt
;
3039 return reloc_class_copy
;
3041 return reloc_class_normal
;
3045 #define ELF_ARCH bfd_arch_cris
3046 #define ELF_MACHINE_CODE EM_CRIS
3047 #define ELF_MAXPAGESIZE 0x2000
3049 #define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3050 #define TARGET_LITTLE_NAME "elf32-cris"
3051 #define elf_symbol_leading_char 0
3053 #define elf_info_to_howto_rel NULL
3054 #define elf_info_to_howto cris_info_to_howto_rela
3055 #define elf_backend_relocate_section cris_elf_relocate_section
3056 #define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3057 #define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3058 #define elf_backend_check_relocs cris_elf_check_relocs
3059 #define elf_backend_grok_prstatus cris_elf_grok_prstatus
3060 #define elf_backend_grok_psinfo cris_elf_grok_psinfo
3062 #define elf_backend_can_gc_sections 1
3063 #define elf_backend_can_refcount 1
3065 #define elf_backend_object_p cris_elf_object_p
3066 #define elf_backend_final_write_processing \
3067 cris_elf_final_write_processing
3068 #define bfd_elf32_bfd_print_private_bfd_data \
3069 cris_elf_print_private_bfd_data
3070 #define bfd_elf32_bfd_merge_private_bfd_data \
3071 cris_elf_merge_private_bfd_data
3073 #define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3075 #define bfd_elf32_bfd_link_hash_table_create \
3076 elf_cris_link_hash_table_create
3077 #define elf_backend_adjust_dynamic_symbol \
3078 elf_cris_adjust_dynamic_symbol
3079 #define elf_backend_size_dynamic_sections \
3080 elf_cris_size_dynamic_sections
3081 #define elf_backend_finish_dynamic_symbol \
3082 elf_cris_finish_dynamic_symbol
3083 #define elf_backend_finish_dynamic_sections \
3084 elf_cris_finish_dynamic_sections
3085 #define elf_backend_create_dynamic_sections \
3086 _bfd_elf_create_dynamic_sections
3087 #define bfd_elf32_bfd_final_link \
3088 _bfd_elf32_gc_common_final_link
3089 #define elf_backend_hide_symbol elf_cris_hide_symbol
3090 #define elf_backend_reloc_type_class elf_cris_reloc_type_class
3092 #define elf_backend_want_got_plt 1
3093 #define elf_backend_plt_readonly 1
3094 #define elf_backend_want_plt_sym 0
3095 #define elf_backend_got_header_size 12
3096 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3098 /* Later, we my want to optimize RELA entries into REL entries for dynamic
3099 linking and libraries (if it's a win of any significance). Until then,
3100 take the easy route. */
3101 #define elf_backend_may_use_rel_p 0
3102 #define elf_backend_may_use_rela_p 1
3103 #define elf_backend_rela_normal 1
3105 #include "elf32-target.h"
3107 #define INCLUDED_TARGET_FILE
3109 #undef TARGET_LITTLE_SYM
3110 #undef TARGET_LITTLE_NAME
3111 #undef elf_symbol_leading_char
3113 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3114 #define TARGET_LITTLE_NAME "elf32-us-cris"
3115 #define elf_symbol_leading_char '_'
3117 #include "elf32-target.h"