]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-cris.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf-bfd.h (elf_backend_reloc_type_class): Pass in the entire
[thirdparty/binutils-gdb.git] / bfd / elf32-cris.c
1 /* CRIS-specific support for 32-bit ELF.
2 Copyright 2000, 2001 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.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
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.
13
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.
18
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. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/cris.h"
28
29 /* Forward declarations. */
30 static reloc_howto_type * cris_reloc_type_lookup
31 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
32
33 static void cris_info_to_howto_rela
34 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
35
36 static boolean cris_elf_relocate_section
37 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
38 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
39
40 static bfd_reloc_status_type cris_final_link_relocate
41 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
42 Elf_Internal_Rela *, bfd_vma));
43
44 static boolean cris_elf_gc_sweep_hook
45 PARAMS ((bfd *, struct bfd_link_info *, asection *,
46 const Elf_Internal_Rela *));
47
48 static asection * cris_elf_gc_mark_hook
49 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
50 struct elf_link_hash_entry *, Elf_Internal_Sym *));
51
52 static boolean cris_elf_object_p PARAMS ((bfd *));
53
54 static void cris_elf_final_write_processing PARAMS ((bfd *, boolean));
55
56 static boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
57
58 static boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
59
60 struct elf_cris_link_hash_entry;
61 static boolean elf_cris_discard_excess_dso_dynamics
62 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
63 static boolean elf_cris_discard_excess_program_dynamics
64 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
65 static boolean elf_cris_adjust_gotplt_to_got
66 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
67 static boolean elf_cris_try_fold_plt_to_got
68 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
69 static struct bfd_hash_entry *elf_cris_link_hash_newfunc
70 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
71 static struct bfd_link_hash_table *elf_cris_link_hash_table_create
72 PARAMS ((bfd *));
73 static boolean elf_cris_adjust_dynamic_symbol
74 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
75 static boolean cris_elf_check_relocs
76 PARAMS ((bfd *, struct bfd_link_info *, asection *,
77 const Elf_Internal_Rela *));
78
79 static boolean elf_cris_size_dynamic_sections
80 PARAMS ((bfd *, struct bfd_link_info *));
81 static boolean elf_cris_finish_dynamic_symbol
82 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
83 Elf_Internal_Sym *));
84 static boolean elf_cris_finish_dynamic_sections
85 PARAMS ((bfd *, struct bfd_link_info *));
86 static void elf_cris_hide_symbol
87 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
88 static enum elf_reloc_type_class elf_cris_reloc_type_class
89 PARAMS ((const Elf_Internal_Rela *));
90
91 static reloc_howto_type cris_elf_howto_table [] =
92 {
93 /* This reloc does nothing. */
94 HOWTO (R_CRIS_NONE, /* type */
95 0, /* rightshift */
96 2, /* size (0 = byte, 1 = short, 2 = long) */
97 32, /* bitsize */
98 false, /* pc_relative */
99 0, /* bitpos */
100 complain_overflow_bitfield, /* complain_on_overflow */
101 bfd_elf_generic_reloc, /* special_function */
102 "R_CRIS_NONE", /* name */
103 false, /* partial_inplace */
104 0, /* src_mask */
105 0, /* dst_mask */
106 false), /* pcrel_offset */
107
108 /* An 8 bit absolute relocation. */
109 HOWTO (R_CRIS_8, /* type */
110 0, /* rightshift */
111 0, /* size (0 = byte, 1 = short, 2 = long) */
112 8, /* bitsize */
113 false, /* pc_relative */
114 0, /* bitpos */
115 complain_overflow_bitfield, /* complain_on_overflow */
116 bfd_elf_generic_reloc, /* special_function */
117 "R_CRIS_8", /* name */
118 false, /* partial_inplace */
119 0x0000, /* src_mask */
120 0x00ff, /* dst_mask */
121 false), /* pcrel_offset */
122
123 /* A 16 bit absolute relocation. */
124 HOWTO (R_CRIS_16, /* type */
125 0, /* rightshift */
126 1, /* size (0 = byte, 1 = short, 2 = long) */
127 16, /* bitsize */
128 false, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_bitfield, /* complain_on_overflow */
131 bfd_elf_generic_reloc, /* special_function */
132 "R_CRIS_16", /* name */
133 false, /* partial_inplace */
134 0x00000000, /* src_mask */
135 0x0000ffff, /* dst_mask */
136 false), /* pcrel_offset */
137
138 /* A 32 bit absolute relocation. */
139 HOWTO (R_CRIS_32, /* type */
140 0, /* rightshift */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
142 32, /* bitsize */
143 false, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_CRIS_32", /* name */
148 false, /* partial_inplace */
149 0x00000000, /* src_mask */
150 0xffffffff, /* dst_mask */
151 false), /* pcrel_offset */
152
153 /* An 8 bit PC-relative relocation. */
154 HOWTO (R_CRIS_8_PCREL, /* type */
155 0, /* rightshift */
156 0, /* size (0 = byte, 1 = short, 2 = long) */
157 8, /* bitsize */
158 true, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 bfd_elf_generic_reloc, /* special_function */
162 "R_CRIS_8_PCREL", /* name */
163 false, /* partial_inplace */
164 0x0000, /* src_mask */
165 0x00ff, /* dst_mask */
166 true), /* pcrel_offset */
167
168 /* A 16 bit PC-relative relocation. */
169 HOWTO (R_CRIS_16_PCREL, /* type */
170 0, /* rightshift */
171 1, /* size (0 = byte, 1 = short, 2 = long) */
172 16, /* bitsize */
173 true, /* pc_relative */
174 0, /* bitpos */
175 complain_overflow_bitfield, /* complain_on_overflow */
176 bfd_elf_generic_reloc, /* special_function */
177 "R_CRIS_16", /* name */
178 false, /* partial_inplace */
179 0x00000000, /* src_mask */
180 0x0000ffff, /* dst_mask */
181 true), /* pcrel_offset */
182
183 /* A 32 bit PC-relative relocation. */
184 HOWTO (R_CRIS_32_PCREL, /* type */
185 0, /* rightshift */
186 2, /* size (0 = byte, 1 = short, 2 = long) */
187 32, /* bitsize */
188 true, /* pc_relative */
189 0, /* bitpos */
190 complain_overflow_bitfield, /* complain_on_overflow */
191 bfd_elf_generic_reloc, /* special_function */
192 "R_CRIS_32", /* name */
193 false, /* partial_inplace */
194 0x00000000, /* src_mask */
195 0xffffffff, /* dst_mask */
196 true), /* pcrel_offset */
197
198 /* GNU extension to record C++ vtable hierarchy. */
199 HOWTO (R_CRIS_GNU_VTINHERIT, /* type */
200 0, /* rightshift */
201 2, /* size (0 = byte, 1 = short, 2 = long) */
202 0, /* bitsize */
203 false, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_dont, /* complain_on_overflow */
206 NULL, /* special_function */
207 "R_CRIS_GNU_VTINHERIT", /* name */
208 false, /* partial_inplace */
209 0, /* src_mask */
210 0, /* dst_mask */
211 false), /* pcrel_offset */
212
213 /* GNU extension to record C++ vtable member usage. */
214 HOWTO (R_CRIS_GNU_VTENTRY, /* type */
215 0, /* rightshift */
216 2, /* size (0 = byte, 1 = short, 2 = long) */
217 0, /* bitsize */
218 false, /* pc_relative */
219 0, /* bitpos */
220 complain_overflow_dont, /* complain_on_overflow */
221 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
222 "R_CRIS_GNU_VTENTRY", /* name */
223 false, /* partial_inplace */
224 0, /* src_mask */
225 0, /* dst_mask */
226 false), /* pcrel_offset */
227
228 /* This is used only by the dynamic linker. The symbol should exist
229 both in the object being run and in some shared library. The
230 dynamic linker copies the data addressed by the symbol from the
231 shared library into the object, because the object being
232 run has to have the data at some particular address. */
233 HOWTO (R_CRIS_COPY, /* type */
234 0, /* rightshift */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
236 32, /* bitsize */
237 false, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_bitfield, /* complain_on_overflow */
240 bfd_elf_generic_reloc, /* special_function */
241 "R_CRIS_COPY", /* name */
242 false, /* partial_inplace */
243 0, /* src_mask */
244 0, /* dst_mask */
245 false), /* pcrel_offset */
246
247 /* Like R_CRIS_32, but used when setting global offset table entries. */
248 HOWTO (R_CRIS_GLOB_DAT, /* type */
249 0, /* rightshift */
250 2, /* size (0 = byte, 1 = short, 2 = long) */
251 32, /* bitsize */
252 false, /* pc_relative */
253 0, /* bitpos */
254 complain_overflow_bitfield, /* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_CRIS_GLOB_DAT", /* name */
257 false, /* partial_inplace */
258 0, /* src_mask */
259 0xffffffff, /* dst_mask */
260 false), /* pcrel_offset */
261
262 /* Marks a procedure linkage table entry for a symbol. */
263 HOWTO (R_CRIS_JUMP_SLOT, /* type */
264 0, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 32, /* bitsize */
267 false, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_CRIS_JUMP_SLOT", /* name */
272 false, /* partial_inplace */
273 0, /* src_mask */
274 0, /* dst_mask */
275 false), /* pcrel_offset */
276
277 /* Used only by the dynamic linker. When the object is run, this
278 longword is set to the load address of the object, plus the
279 addend. */
280 HOWTO (R_CRIS_RELATIVE, /* type */
281 0, /* rightshift */
282 2, /* size (0 = byte, 1 = short, 2 = long) */
283 32, /* bitsize */
284 false, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_bitfield, /* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_CRIS_RELATIVE", /* name */
289 false, /* partial_inplace */
290 0, /* src_mask */
291 0xffffffff, /* dst_mask */
292 false), /* pcrel_offset */
293
294 /* Like R_CRIS_32, but referring to the GOT table entry for the symbol. */
295 HOWTO (R_CRIS_16_GOT, /* type */
296 0, /* rightshift */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
299 false, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_bitfield, /* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_CRIS_16_GOT", /* name */
304 false, /* partial_inplace */
305 0, /* src_mask */
306 0xffff, /* dst_mask */
307 false), /* pcrel_offset */
308
309 HOWTO (R_CRIS_32_GOT, /* type */
310 0, /* rightshift */
311 2, /* size (0 = byte, 1 = short, 2 = long) */
312 32, /* bitsize */
313 false, /* pc_relative */
314 0, /* bitpos */
315 complain_overflow_bitfield, /* complain_on_overflow */
316 bfd_elf_generic_reloc, /* special_function */
317 "R_CRIS_32_GOT", /* name */
318 false, /* partial_inplace */
319 0, /* src_mask */
320 0xffffffff, /* dst_mask */
321 false), /* pcrel_offset */
322
323 /* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
324 the GOT table for the symbol. */
325 HOWTO (R_CRIS_16_GOTPLT, /* type */
326 0, /* rightshift */
327 1, /* size (0 = byte, 1 = short, 2 = long) */
328 16, /* bitsize */
329 false, /* pc_relative */
330 0, /* bitpos */
331 complain_overflow_bitfield, /* complain_on_overflow */
332 bfd_elf_generic_reloc, /* special_function */
333 "R_CRIS_16_GOTPLT", /* name */
334 false, /* partial_inplace */
335 0, /* src_mask */
336 0xffff, /* dst_mask */
337 false), /* pcrel_offset */
338
339 HOWTO (R_CRIS_32_GOTPLT, /* type */
340 0, /* rightshift */
341 2, /* size (0 = byte, 1 = short, 2 = long) */
342 32, /* bitsize */
343 false, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_bitfield, /* complain_on_overflow */
346 bfd_elf_generic_reloc, /* special_function */
347 "R_CRIS_32_GOTPLT", /* name */
348 false, /* partial_inplace */
349 0, /* src_mask */
350 0xffffffff, /* dst_mask */
351 false), /* pcrel_offset */
352
353 /* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
354 be necessary. */
355 HOWTO (R_CRIS_32_GOTREL, /* type */
356 0, /* rightshift */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
358 32, /* bitsize */
359 false, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_bitfield, /* complain_on_overflow */
362 bfd_elf_generic_reloc, /* special_function */
363 "R_CRIS_32_GOTREL", /* name */
364 false, /* partial_inplace */
365 0, /* src_mask */
366 0xffffffff, /* dst_mask */
367 false), /* pcrel_offset */
368
369 /* A 32-bit offset from GOT to entry for this symbol in PLT and request
370 to create PLT entry for symbol. */
371 HOWTO (R_CRIS_32_PLT_GOTREL, /* type */
372 0, /* rightshift */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
374 32, /* bitsize */
375 false, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_bitfield, /* complain_on_overflow */
378 bfd_elf_generic_reloc, /* special_function */
379 "R_CRIS_32_PLT_GOTREL", /* name */
380 false, /* partial_inplace */
381 0, /* src_mask */
382 0xffffffff, /* dst_mask */
383 false), /* pcrel_offset */
384
385 /* A 32-bit offset from PC (location after the relocation) + addend to
386 entry for this symbol in PLT and request to create PLT entry for
387 symbol. */
388 HOWTO (R_CRIS_32_PLT_PCREL, /* type */
389 0, /* rightshift */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
391 32, /* bitsize */
392 true, /* pc_relative */
393 0, /* bitpos */
394 complain_overflow_bitfield, /* complain_on_overflow */
395 bfd_elf_generic_reloc, /* special_function */
396 "R_CRIS_32_PLT_PCREL", /* name */
397 false, /* partial_inplace */
398 0, /* src_mask */
399 0xffffffff, /* dst_mask */
400 true) /* pcrel_offset */
401 };
402 \f
403 /* Map BFD reloc types to CRIS ELF reloc types. */
404
405 struct cris_reloc_map
406 {
407 bfd_reloc_code_real_type bfd_reloc_val;
408 unsigned int cris_reloc_val;
409 };
410
411 static const struct cris_reloc_map cris_reloc_map [] =
412 {
413 { BFD_RELOC_NONE, R_CRIS_NONE },
414 { BFD_RELOC_8, R_CRIS_8 },
415 { BFD_RELOC_16, R_CRIS_16 },
416 { BFD_RELOC_32, R_CRIS_32 },
417 { BFD_RELOC_8_PCREL, R_CRIS_8_PCREL },
418 { BFD_RELOC_16_PCREL, R_CRIS_16_PCREL },
419 { BFD_RELOC_32_PCREL, R_CRIS_32_PCREL },
420 { BFD_RELOC_VTABLE_INHERIT, R_CRIS_GNU_VTINHERIT },
421 { BFD_RELOC_VTABLE_ENTRY, R_CRIS_GNU_VTENTRY },
422 { BFD_RELOC_CRIS_COPY, R_CRIS_COPY },
423 { BFD_RELOC_CRIS_GLOB_DAT, R_CRIS_GLOB_DAT },
424 { BFD_RELOC_CRIS_JUMP_SLOT, R_CRIS_JUMP_SLOT },
425 { BFD_RELOC_CRIS_RELATIVE, R_CRIS_RELATIVE },
426 { BFD_RELOC_CRIS_16_GOT, R_CRIS_16_GOT },
427 { BFD_RELOC_CRIS_32_GOT, R_CRIS_32_GOT },
428 { BFD_RELOC_CRIS_16_GOTPLT, R_CRIS_16_GOTPLT },
429 { BFD_RELOC_CRIS_32_GOTPLT, R_CRIS_32_GOTPLT },
430 { BFD_RELOC_CRIS_32_GOTREL, R_CRIS_32_GOTREL },
431 { BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL },
432 { BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL }
433 };
434
435 static reloc_howto_type *
436 cris_reloc_type_lookup (abfd, code)
437 bfd * abfd ATTRIBUTE_UNUSED;
438 bfd_reloc_code_real_type code;
439 {
440 unsigned int i;
441
442 for (i = sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]);
443 --i;)
444 if (cris_reloc_map [i].bfd_reloc_val == code)
445 return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val];
446
447 return NULL;
448 }
449
450 /* Set the howto pointer for an CRIS ELF reloc. */
451
452 static void
453 cris_info_to_howto_rela (abfd, cache_ptr, dst)
454 bfd * abfd ATTRIBUTE_UNUSED;
455 arelent * cache_ptr;
456 Elf32_Internal_Rela * dst;
457 {
458 unsigned int r_type;
459
460 r_type = ELF32_R_TYPE (dst->r_info);
461 BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
462 cache_ptr->howto = & cris_elf_howto_table [r_type];
463 }
464 \f
465 /* The name of the dynamic interpreter. This is put in the .interp
466 section. */
467
468 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
469
470 /* The size in bytes of an entry in the procedure linkage table. */
471
472 #define PLT_ENTRY_SIZE 20
473
474 /* The first entry in an absolute procedure linkage table looks like this. */
475
476 static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] =
477 {
478 0xfc, 0xe1,
479 0x7e, 0x7e, /* push mof. */
480 0x7f, 0x0d, /* (dip [pc+]) */
481 0, 0, 0, 0, /* Replaced with address of .got + 4. */
482 0x30, 0x7a, /* move [...],mof */
483 0x7f, 0x0d, /* (dip [pc+]) */
484 0, 0, 0, 0, /* Replaced with address of .got + 8. */
485 0x30, 0x09, /* jump [...] */
486 };
487
488 /* Subsequent entries in an absolute procedure linkage table look like
489 this. */
490
491 static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] =
492 {
493 0x7f, 0x0d, /* (dip [pc+]) */
494 0, 0, 0, 0, /* Replaced with address of this symbol in .got. */
495 0x30, 0x09, /* jump [...] */
496 0x3f, 0x7e, /* move [pc+],mof */
497 0, 0, 0, 0, /* Replaced with offset into relocation table. */
498 0x2f, 0xfe, /* add.d [pc+],pc */
499 0xec, 0xff,
500 0xff, 0xff /* Replaced with offset to start of .plt. */
501 };
502
503 /* The first entry in a PIC procedure linkage table looks like this. */
504
505 static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] =
506 {
507 0xfc, 0xe1, 0x7e, 0x7e, /* push mof */
508 0x04, 0x01, 0x30, 0x7a, /* move [r0+4],mof */
509 0x08, 0x01, 0x30, 0x09, /* jump [r0+8] */
510 0, 0, 0, 0, 0, 0, 0, 0, /* Pad out to 20 bytes. */
511 };
512
513 /* Subsequent entries in a PIC procedure linkage table look like this. */
514
515 static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] =
516 {
517 0x6f, 0x0d, /* (bdap [pc+].d,r0) */
518 0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */
519 0x30, 0x09, /* jump [...] */
520 0x3f, 0x7e, /* move [pc+],mof */
521 0, 0, 0, 0, /* Replaced with offset into relocation table. */
522 0x2f, 0xfe, /* add.d [pc+],pc */
523 0xec, 0xff, /* Replaced with offset to start of .plt. */
524 0xff, 0xff
525 };
526 \f
527 /* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits
528 (and most other PIC/shlib stuff). Check that we don't drift away
529 without reason.
530
531 The CRIS linker, like the m68k and i386 linkers (and probably the rest
532 too) needs to keep track of the number of relocs that it decides to
533 copy in check_relocs for each symbol. This is so that it can discard
534 PC relative relocs if it doesn't need them when linking with
535 -Bsymbolic. We store the information in a field extending the regular
536 ELF linker hash table. */
537
538 /* This structure keeps track of the number of PC relative relocs we have
539 copied for a given symbol. */
540
541 struct elf_cris_pcrel_relocs_copied
542 {
543 /* Next section. */
544 struct elf_cris_pcrel_relocs_copied *next;
545 /* A section in dynobj. */
546 asection *section;
547 /* Number of relocs copied in this section. */
548 bfd_size_type count;
549 };
550
551 /* CRIS ELF linker hash entry. */
552
553 struct elf_cris_link_hash_entry
554 {
555 struct elf_link_hash_entry root;
556
557 /* Number of PC relative relocs copied for this symbol. */
558 struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied;
559
560 /* The GOTPLT references are CRIS-specific; the goal is to avoid having
561 both a general GOT and a PLT-specific GOT entry for the same symbol,
562 when it is referenced both as a function and as a function pointer.
563
564 Number of GOTPLT references for a function. */
565 bfd_signed_vma gotplt_refcount;
566
567 /* Actual GOTPLT index for this symbol, if applicable, or zero if not
568 (zero is never used as an index). FIXME: We should be able to fold
569 this with gotplt_refcount in a union, like the got and plt unions in
570 elf_link_hash_entry. */
571 bfd_size_type gotplt_offset;
572 };
573
574 /* CRIS ELF linker hash table. */
575
576 struct elf_cris_link_hash_table
577 {
578 struct elf_link_hash_table root;
579
580 /* We can't use the PLT offset and calculate to get the GOTPLT offset,
581 since we try and avoid creating GOTPLT:s when there's already a GOT.
582 Instead, we keep and update the next available index here. */
583 bfd_size_type next_gotplt_entry;
584 };
585
586 /* Traverse a CRIS ELF linker hash table. */
587
588 #define elf_cris_link_hash_traverse(table, func, info) \
589 (elf_link_hash_traverse \
590 (&(table)->root, \
591 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
592 (info)))
593
594 /* Get the CRIS ELF linker hash table from a link_info structure. */
595
596 #define elf_cris_hash_table(p) \
597 ((struct elf_cris_link_hash_table *) (p)->hash)
598
599 /* Create an entry in a CRIS ELF linker hash table. */
600
601 static struct bfd_hash_entry *
602 elf_cris_link_hash_newfunc (entry, table, string)
603 struct bfd_hash_entry *entry;
604 struct bfd_hash_table *table;
605 const char *string;
606 {
607 struct elf_cris_link_hash_entry *ret =
608 (struct elf_cris_link_hash_entry *) entry;
609
610 /* Allocate the structure if it has not already been allocated by a
611 subclass. */
612 if (ret == (struct elf_cris_link_hash_entry *) NULL)
613 ret = ((struct elf_cris_link_hash_entry *)
614 bfd_hash_allocate (table,
615 sizeof (struct elf_cris_link_hash_entry)));
616 if (ret == (struct elf_cris_link_hash_entry *) NULL)
617 return (struct bfd_hash_entry *) ret;
618
619 /* Call the allocation method of the superclass. */
620 ret = ((struct elf_cris_link_hash_entry *)
621 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
622 table, string));
623 if (ret != (struct elf_cris_link_hash_entry *) NULL)
624 {
625 ret->pcrel_relocs_copied = NULL;
626 ret->gotplt_refcount = 0;
627 ret->gotplt_offset = 0;
628 }
629
630 return (struct bfd_hash_entry *) ret;
631 }
632
633 /* Create a CRIS ELF linker hash table. */
634
635 static struct bfd_link_hash_table *
636 elf_cris_link_hash_table_create (abfd)
637 bfd *abfd;
638 {
639 struct elf_cris_link_hash_table *ret;
640 bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
641
642 ret = ((struct elf_cris_link_hash_table *) bfd_alloc (abfd, amt));
643 if (ret == (struct elf_cris_link_hash_table *) NULL)
644 return NULL;
645
646 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
647 elf_cris_link_hash_newfunc))
648 {
649 bfd_release (abfd, ret);
650 return NULL;
651 }
652
653 /* Initialize to skip over the first three entries in the gotplt; they
654 are used for run-time symbol evaluation. */
655 ret->next_gotplt_entry = 12;
656
657 return &ret->root.root;
658 }
659 \f
660 /* Perform a single relocation. By default we use the standard BFD
661 routines, with a few tweaks. */
662
663 static bfd_reloc_status_type
664 cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
665 relocation)
666 reloc_howto_type * howto;
667 bfd * input_bfd;
668 asection * input_section;
669 bfd_byte * contents;
670 Elf_Internal_Rela * rel;
671 bfd_vma relocation;
672 {
673 bfd_reloc_status_type r;
674
675 /* PC-relative relocations are relative to the position *after*
676 the reloc. Note that for R_CRIS_8_PCREL the adjustment is
677 not a single byte, since PC must be 16-bit-aligned. */
678 switch (ELF32_R_TYPE (rel->r_info))
679 {
680 /* Check that the 16-bit GOT relocs are positive. */
681 case R_CRIS_16_GOTPLT:
682 case R_CRIS_16_GOT:
683 if ((bfd_signed_vma) relocation < 0)
684 return bfd_reloc_overflow;
685 break;
686
687 case R_CRIS_32_PLT_PCREL:
688 case R_CRIS_32_PCREL:
689 relocation -= 2;
690 /* Fall through. */
691 case R_CRIS_8_PCREL:
692 case R_CRIS_16_PCREL:
693 relocation -= 2;
694 break;
695
696 default:
697 break;
698 }
699
700 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
701 contents, rel->r_offset,
702 relocation, rel->r_addend);
703 return r;
704 }
705 \f
706 /* Relocate an CRIS ELF section. See elf32-fr30.c, from where this was
707 copied, for further comments. */
708
709 static boolean
710 cris_elf_relocate_section (output_bfd, info, input_bfd, input_section,
711 contents, relocs, local_syms, local_sections)
712 bfd * output_bfd ATTRIBUTE_UNUSED;
713 struct bfd_link_info * info;
714 bfd * input_bfd;
715 asection * input_section;
716 bfd_byte * contents;
717 Elf_Internal_Rela * relocs;
718 Elf_Internal_Sym * local_syms;
719 asection ** local_sections;
720 {
721 bfd *dynobj;
722 Elf_Internal_Shdr * symtab_hdr;
723 struct elf_link_hash_entry ** sym_hashes;
724 bfd_vma *local_got_offsets;
725 asection *sgot;
726 asection *splt;
727 asection *sreloc;
728 Elf_Internal_Rela * rel;
729 Elf_Internal_Rela * relend;
730
731 dynobj = elf_hash_table (info)->dynobj;
732 local_got_offsets = elf_local_got_offsets (input_bfd);
733 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
734 sym_hashes = elf_sym_hashes (input_bfd);
735 relend = relocs + input_section->reloc_count;
736
737 /* It seems this can happen with erroneous or unsupported input (mixing
738 a.out and elf in an archive, for example.) */
739 if (sym_hashes == NULL)
740 return false;
741
742 sgot = NULL;
743 splt = NULL;
744 sreloc = NULL;
745
746 if (dynobj != NULL)
747 {
748 splt = bfd_get_section_by_name (dynobj, ".plt");
749 sgot = bfd_get_section_by_name (dynobj, ".got");
750 }
751
752 for (rel = relocs; rel < relend; rel ++)
753 {
754 reloc_howto_type * howto;
755 unsigned long r_symndx;
756 Elf_Internal_Sym * sym;
757 asection * sec;
758 struct elf_link_hash_entry * h;
759 bfd_vma relocation;
760 bfd_reloc_status_type r;
761 const char * symname = NULL;
762 int r_type;
763
764 r_type = ELF32_R_TYPE (rel->r_info);
765
766 if ( r_type == R_CRIS_GNU_VTINHERIT
767 || r_type == R_CRIS_GNU_VTENTRY)
768 continue;
769
770 r_symndx = ELF32_R_SYM (rel->r_info);
771
772 if (info->relocateable)
773 {
774 /* This is a relocateable link. We don't have to change
775 anything, unless the reloc is against a section symbol,
776 in which case we have to adjust according to where the
777 section symbol winds up in the output section. */
778 if (r_symndx < symtab_hdr->sh_info)
779 {
780 sym = local_syms + r_symndx;
781
782 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
783 {
784 sec = local_sections [r_symndx];
785 rel->r_addend += sec->output_offset + sym->st_value;
786 }
787 }
788
789 continue;
790 }
791
792 /* This is a final link. */
793 howto = cris_elf_howto_table + r_type;
794 h = NULL;
795 sym = NULL;
796 sec = NULL;
797
798 if (r_symndx < symtab_hdr->sh_info)
799 {
800 sym = local_syms + r_symndx;
801 sec = local_sections [r_symndx];
802 relocation = (sec->output_section->vma
803 + sec->output_offset
804 + sym->st_value);
805
806 symname = (bfd_elf_string_from_elf_section
807 (input_bfd, symtab_hdr->sh_link, sym->st_name));
808 if (symname == NULL)
809 symname = bfd_section_name (input_bfd, sec);
810 }
811 else
812 {
813 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
814
815 while (h->root.type == bfd_link_hash_indirect
816 || h->root.type == bfd_link_hash_warning)
817 h = (struct elf_link_hash_entry *) h->root.u.i.link;
818
819 symname = h->root.root.string;
820
821 if (h->root.type == bfd_link_hash_defined
822 || h->root.type == bfd_link_hash_defweak)
823 {
824 sec = h->root.u.def.section;
825
826 /* Perhaps we should detect the cases that
827 sec->output_section is expected to be NULL like i386 and
828 m68k, but apparently (and according to elfxx-ia64.c) all
829 valid cases are where the symbol is defined in a shared
830 object which we link dynamically against. This includes
831 PLT relocs for which we've created a PLT entry and other
832 relocs for which we're prepared to create dynamic
833 relocations.
834
835 For now, new situations cause us to just err when
836 sec->output_offset is NULL but the object with the symbol
837 is *not* dynamically linked against. Thus this will
838 automatically remind us so we can see if there are other
839 valid cases we need to revisit. */
840 if ((sec->output_section == NULL
841 && (sec->owner->flags & DYNAMIC) != 0)
842
843 /* Here follow the cases where the relocation value must
844 be zero (or when further handling is simplified when
845 zero). I can't claim to understand the various
846 conditions and they weren't described in the files
847 where I copied them from (elf32-m68k.c and
848 elf32-i386.c), but let's mention examples of where
849 they happen. FIXME: Perhaps define and use a
850 dynamic_symbol_p function like ia64.
851
852 - When creating a shared library, we can have an
853 ordinary relocation for a symbol defined in a shared
854 library (perhaps the one we create). We then make
855 the relocation value zero, as the value seen now will
856 be added into the relocation addend in this shared
857 library, but must be handled only at dynamic-link
858 time. FIXME: Not sure this example covers the
859 h->elf_link_hash_flags test, though it's there in
860 other targets. */
861 || (info->shared
862 && ((! info->symbolic && h->dynindx != -1)
863 || (h->elf_link_hash_flags
864 & ELF_LINK_HASH_DEF_REGULAR) == 0)
865 && (input_section->flags & SEC_ALLOC) != 0
866 && (r_type == R_CRIS_8
867 || r_type == R_CRIS_16
868 || r_type == R_CRIS_32
869 || r_type == R_CRIS_8_PCREL
870 || r_type == R_CRIS_16_PCREL
871 || r_type == R_CRIS_32_PCREL)))
872 relocation = 0;
873 else if (sec->output_section != NULL)
874 relocation = (h->root.u.def.value
875 + sec->output_section->vma
876 + sec->output_offset);
877 else
878 {
879 (*_bfd_error_handler)
880 (_("%s: unresolvable relocation %s against symbol `%s' from %s section"),
881 bfd_archive_filename (input_bfd),
882 cris_elf_howto_table[r_type].name,
883 symname,
884 bfd_get_section_name (input_bfd, input_section));
885 bfd_set_error (bfd_error_bad_value);
886 return false;
887 }
888 }
889 else if (h->root.type == bfd_link_hash_undefweak)
890 relocation = 0;
891 else if (info->shared
892 && (!info->symbolic || info->allow_shlib_undefined)
893 && !info->no_undefined
894 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
895 relocation = 0;
896 else
897 {
898 if (!(info->callbacks->undefined_symbol
899 (info, symname, input_bfd,
900 input_section, rel->r_offset,
901 (!info->shared || info->no_undefined
902 || ELF_ST_VISIBILITY (h->other)))))
903 return false;
904 relocation = 0;
905 }
906 }
907
908 switch (r_type)
909 {
910 case R_CRIS_16_GOTPLT:
911 case R_CRIS_32_GOTPLT:
912 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
913 but we require a PLT, and the PLT handling will take care of
914 filling in the PLT-specific GOT entry. For the GOT offset,
915 calculate it as we do when filling it in for the .got.plt
916 section. If we don't have a PLT, punt to GOT handling. */
917 if (h != NULL
918 && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
919 {
920 asection *sgotplt
921 = bfd_get_section_by_name (dynobj, ".got.plt");
922 bfd_vma got_offset;
923
924 BFD_ASSERT (h->dynindx != -1);
925 BFD_ASSERT (sgotplt != NULL);
926
927 got_offset
928 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
929
930 relocation = got_offset;
931 break;
932 }
933
934 /* We didn't make a PLT entry for this symbol. Maybe everything is
935 folded into the GOT. Other than folding, this happens when
936 statically linking PIC code, or when using -Bsymbolic. Check
937 that we instead have a GOT entry as done for us by
938 elf_cris_adjust_dynamic_symbol, and drop through into the
939 ordinary GOT cases. */
940 if (h != NULL && h->got.offset == (bfd_vma) -1)
941 {
942 (*_bfd_error_handler)
943 (_("%s: No PLT nor GOT for relocation %s against symbol `%s' from %s section"),
944 bfd_archive_filename (input_bfd),
945 cris_elf_howto_table[r_type].name,
946 symname[0] != '\0' ? symname : _("[whose name is lost]"),
947 bfd_get_section_name (input_bfd, input_section));
948
949 /* FIXME: Perhaps blaming input is not the right thing to
950 do; this is probably an internal error. But it is true
951 that we didn't like that particular input. */
952 bfd_set_error (bfd_error_bad_value);
953 return false;
954 }
955 /* Fall through. */
956
957 /* The size of the actual relocation is not used here; we only
958 fill in the GOT table here. */
959 case R_CRIS_16_GOT:
960 case R_CRIS_32_GOT:
961 {
962 bfd_vma off;
963
964 /* Note that despite using RELA relocations, the .got contents
965 is always filled in with the link-relative relocation
966 value; the addend. */
967
968 if (h != NULL)
969 {
970 off = h->got.offset;
971 BFD_ASSERT (off != (bfd_vma) -1);
972
973 if (!elf_hash_table (info)->dynamic_sections_created
974 || (! info->shared && h->dynindx == -1)
975 || (info->shared
976 && (info->symbolic || h->dynindx == -1)
977 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
978 {
979 /* This wasn't checked above for ! info->shared, but
980 must hold there if we get here; the symbol must not
981 be used in, or defined by a DSO. (Note that
982 checking for ELF_LINK_HASH_DEF_REGULAR doesn't
983 catch all cases.) */
984 BFD_ASSERT (info->shared
985 || (h->elf_link_hash_flags
986 & (ELF_LINK_HASH_REF_DYNAMIC
987 | ELF_LINK_HASH_DEF_DYNAMIC)) == 0);
988
989 /* This is actually a static link, or it is a
990 -Bsymbolic link and the symbol is defined
991 locally, or the symbol was forced to be local
992 because of a version file, or we're not creating a
993 dynamic object and the symbol isn't referred to by
994 a dynamic object. We must initialize
995 this entry in the global offset table. Since
996 the offset must always be a multiple of 4, we
997 use the least significant bit to record whether
998 we have initialized it already.
999
1000 When doing a dynamic link, we create a .rela.got
1001 relocation entry to initialize the value. This
1002 is done in the finish_dynamic_symbol routine. */
1003 if ((off & 1) != 0)
1004 off &= ~1;
1005 else
1006 {
1007 bfd_put_32 (output_bfd, relocation,
1008 sgot->contents + off);
1009 h->got.offset |= 1;
1010 }
1011 }
1012 }
1013 else
1014 {
1015 BFD_ASSERT (local_got_offsets != NULL
1016 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1017
1018 off = local_got_offsets[r_symndx];
1019
1020 /* The offset must always be a multiple of 4. We use
1021 the least significant bit to record whether we have
1022 already generated the necessary reloc. */
1023 if ((off & 1) != 0)
1024 off &= ~1;
1025 else
1026 {
1027 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1028
1029 if (info->shared)
1030 {
1031 asection *srelgot;
1032 Elf_Internal_Rela outrel;
1033
1034 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1035 BFD_ASSERT (srelgot != NULL);
1036
1037 outrel.r_offset = (sgot->output_section->vma
1038 + sgot->output_offset
1039 + off);
1040 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1041 outrel.r_addend = relocation;
1042 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1043 (((Elf32_External_Rela *)
1044 srelgot->contents)
1045 + srelgot->reloc_count));
1046 ++srelgot->reloc_count;
1047 }
1048
1049 local_got_offsets[r_symndx] |= 1;
1050 }
1051 }
1052
1053 relocation = sgot->output_offset + off;
1054 if (rel->r_addend != 0)
1055 {
1056 /* We can't do anything for a relocation which is against
1057 a symbol *plus offset*. GOT holds relocations for
1058 symbols. Make this an error; the compiler isn't
1059 allowed to pass us these kinds of things. */
1060 if (h == NULL)
1061 (*_bfd_error_handler)
1062 (_("%s: relocation %s with non-zero addend %d against local symbol from %s section"),
1063 bfd_archive_filename (input_bfd),
1064 cris_elf_howto_table[r_type].name,
1065 rel->r_addend,
1066 bfd_get_section_name (input_bfd, input_section));
1067 else
1068 (*_bfd_error_handler)
1069 (_("%s: relocation %s with non-zero addend %d against symbol `%s' from %s section"),
1070 bfd_archive_filename (input_bfd),
1071 cris_elf_howto_table[r_type].name,
1072 rel->r_addend,
1073 symname[0] != '\0' ? symname : _("[whose name is lost]"),
1074 bfd_get_section_name (input_bfd, input_section));
1075
1076 bfd_set_error (bfd_error_bad_value);
1077 return false;
1078 }
1079 }
1080 break;
1081
1082 case R_CRIS_32_GOTREL:
1083 /* This relocation must only be performed against local symbols. */
1084 if (h != NULL)
1085 {
1086 (*_bfd_error_handler)
1087 (_("%s: relocation %s is not allowed for global symbol: `%s' from %s section"),
1088 bfd_archive_filename (input_bfd),
1089 cris_elf_howto_table[r_type].name,
1090 symname,
1091 bfd_get_section_name (input_bfd, input_section));
1092 bfd_set_error (bfd_error_bad_value);
1093 return false;
1094 }
1095
1096 /* This relocation is like a PC-relative one, except the
1097 reference point is the location of GOT. Note that
1098 sgot->output_offset is not involved in this calculation. We
1099 always want the start of entire .got section, not the
1100 position after the reserved header. */
1101 relocation -= sgot->output_section->vma;
1102 break;
1103
1104 case R_CRIS_32_PLT_PCREL:
1105 /* Relocation is to the entry for this symbol in the
1106 procedure linkage table. */
1107
1108 /* Resolve a PLT_PCREL reloc against a local symbol directly,
1109 without using the procedure linkage table. */
1110 if (h == NULL)
1111 break;
1112
1113 if (h->plt.offset == (bfd_vma) -1
1114 || splt == NULL)
1115 {
1116 /* We didn't make a PLT entry for this symbol. This
1117 happens when statically linking PIC code, or when
1118 using -Bsymbolic. */
1119 break;
1120 }
1121
1122 relocation = (splt->output_section->vma
1123 + splt->output_offset
1124 + h->plt.offset);
1125 break;
1126
1127 case R_CRIS_32_PLT_GOTREL:
1128 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1129 start of the .got section. See also comment at
1130 R_CRIS_32_GOT. */
1131 relocation -= sgot->output_section->vma;
1132
1133 /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1134 without using the procedure linkage table. */
1135 if (h == NULL)
1136 break;
1137
1138 if (h->plt.offset == (bfd_vma) -1
1139 || splt == NULL)
1140 {
1141 /* We didn't make a PLT entry for this symbol. This
1142 happens when statically linking PIC code, or when
1143 using -Bsymbolic. */
1144 break;
1145 }
1146
1147 relocation = (splt->output_section->vma
1148 + splt->output_offset
1149 + h->plt.offset
1150 - sgot->output_section->vma);
1151 break;
1152
1153 case R_CRIS_8_PCREL:
1154 case R_CRIS_16_PCREL:
1155 case R_CRIS_32_PCREL:
1156 /* If the symbol was local, we need no shlib-specific handling. */
1157 if (h == NULL)
1158 break;
1159
1160 /* Fall through. */
1161 case R_CRIS_8:
1162 case R_CRIS_16:
1163 case R_CRIS_32:
1164 if (info->shared
1165 && (input_section->flags & SEC_ALLOC) != 0
1166 && ((r_type != R_CRIS_8_PCREL
1167 && r_type != R_CRIS_16_PCREL
1168 && r_type != R_CRIS_32_PCREL)
1169 || (!info->symbolic
1170 || (h->elf_link_hash_flags
1171 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1172 {
1173 Elf_Internal_Rela outrel;
1174 boolean skip, relocate;
1175
1176 /* When generating a shared object, these relocations
1177 are copied into the output file to be resolved at run
1178 time. */
1179
1180 if (sreloc == NULL)
1181 {
1182 const char *name;
1183
1184 name = (bfd_elf_string_from_elf_section
1185 (input_bfd,
1186 elf_elfheader (input_bfd)->e_shstrndx,
1187 elf_section_data (input_section)->rel_hdr.sh_name));
1188 if (name == NULL)
1189 return false;
1190
1191 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1192 && strcmp (bfd_get_section_name (input_bfd,
1193 input_section),
1194 name + 5) == 0);
1195
1196 sreloc = bfd_get_section_by_name (dynobj, name);
1197
1198 /* That section should have been created in
1199 cris_elf_check_relocs, but that function will not be
1200 called for objects which fail in
1201 cris_elf_merge_private_bfd_data. */
1202 if (sreloc == NULL)
1203 {
1204 (*_bfd_error_handler)
1205 (_("%s: Internal inconsistency; no relocation section %s"),
1206 bfd_archive_filename (input_bfd),
1207 name);
1208
1209 bfd_set_error (bfd_error_bad_value);
1210 return false;
1211 }
1212 }
1213
1214 skip = false;
1215
1216 if (elf_section_data (input_section)->stab_info == NULL)
1217 outrel.r_offset = rel->r_offset;
1218 else
1219 {
1220 bfd_vma off;
1221
1222 off = (_bfd_stab_section_offset
1223 (output_bfd, &elf_hash_table (info)->stab_info,
1224 input_section,
1225 &elf_section_data (input_section)->stab_info,
1226 rel->r_offset));
1227 if (off == (bfd_vma) -1)
1228 skip = true;
1229 outrel.r_offset = off;
1230 }
1231
1232 outrel.r_offset += (input_section->output_section->vma
1233 + input_section->output_offset);
1234
1235 if (skip)
1236 {
1237 memset (&outrel, 0, sizeof outrel);
1238 relocate = false;
1239 }
1240 /* h->dynindx may be -1 if the symbol was marked to
1241 become local. */
1242 else if (h != NULL
1243 && ((! info->symbolic && h->dynindx != -1)
1244 || (h->elf_link_hash_flags
1245 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1246 {
1247 BFD_ASSERT (h->dynindx != -1);
1248 relocate = false;
1249 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1250 outrel.r_addend = relocation + rel->r_addend;
1251 }
1252 else
1253 {
1254 if (r_type == R_CRIS_32)
1255 {
1256 relocate = true;
1257 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1258 outrel.r_addend = relocation + rel->r_addend;
1259 }
1260 else
1261 {
1262 long indx;
1263
1264 if (h == NULL)
1265 sec = local_sections[r_symndx];
1266 else
1267 {
1268 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1269 || (h->root.type
1270 == bfd_link_hash_defweak));
1271 sec = h->root.u.def.section;
1272 }
1273 if (sec != NULL && bfd_is_abs_section (sec))
1274 indx = 0;
1275 else if (sec == NULL || sec->owner == NULL)
1276 {
1277 bfd_set_error (bfd_error_bad_value);
1278 return false;
1279 }
1280 else
1281 {
1282 asection *osec;
1283
1284 osec = sec->output_section;
1285 indx = elf_section_data (osec)->dynindx;
1286 BFD_ASSERT (indx > 0);
1287 }
1288
1289 relocate = false;
1290 outrel.r_info = ELF32_R_INFO (indx, r_type);
1291 outrel.r_addend = relocation + rel->r_addend;
1292 }
1293 }
1294
1295 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1296 (((Elf32_External_Rela *)
1297 sreloc->contents)
1298 + sreloc->reloc_count));
1299 ++sreloc->reloc_count;
1300
1301 /* This reloc will be computed at runtime, so there's no
1302 need to do anything now, except for R_CRIS_32 relocations
1303 that have been turned into R_CRIS_RELATIVE. */
1304 if (!relocate)
1305 continue;
1306 }
1307
1308 break;
1309 }
1310
1311 r = cris_final_link_relocate (howto, input_bfd, input_section,
1312 contents, rel, relocation);
1313
1314 if (r != bfd_reloc_ok)
1315 {
1316 const char * msg = (const char *) NULL;
1317
1318 switch (r)
1319 {
1320 case bfd_reloc_overflow:
1321 r = info->callbacks->reloc_overflow
1322 (info, symname, howto->name, (bfd_vma) 0,
1323 input_bfd, input_section, rel->r_offset);
1324 break;
1325
1326 case bfd_reloc_undefined:
1327 r = info->callbacks->undefined_symbol
1328 (info, symname, input_bfd, input_section, rel->r_offset,
1329 true);
1330 break;
1331
1332 case bfd_reloc_outofrange:
1333 msg = _("internal error: out of range error");
1334 break;
1335
1336 case bfd_reloc_notsupported:
1337 msg = _("internal error: unsupported relocation error");
1338 break;
1339
1340 case bfd_reloc_dangerous:
1341 msg = _("internal error: dangerous relocation");
1342 break;
1343
1344 default:
1345 msg = _("internal error: unknown error");
1346 break;
1347 }
1348
1349 if (msg)
1350 r = info->callbacks->warning
1351 (info, msg, symname, input_bfd, input_section, rel->r_offset);
1352
1353 if (! r)
1354 return false;
1355 }
1356 }
1357
1358 return true;
1359 }
1360 \f
1361 /* Finish up dynamic symbol handling. We set the contents of various
1362 dynamic sections here. */
1363
1364 static boolean
1365 elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
1366 bfd *output_bfd;
1367 struct bfd_link_info *info;
1368 struct elf_link_hash_entry *h;
1369 Elf_Internal_Sym *sym;
1370 {
1371 bfd *dynobj;
1372 int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
1373
1374 dynobj = elf_hash_table (info)->dynobj;
1375
1376 if (h->plt.offset != (bfd_vma) -1)
1377 {
1378 asection *splt;
1379 asection *sgotplt;
1380 asection *sgot;
1381 asection *srela;
1382 bfd_vma got_base;
1383
1384 bfd_vma gotplt_offset
1385 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1386 Elf_Internal_Rela rela;
1387 boolean has_gotplt = gotplt_offset != 0;
1388
1389 /* Get the index in the procedure linkage table which
1390 corresponds to this symbol. This is the index of this symbol
1391 in all the symbols for which we are making plt entries. The
1392 first entry in the procedure linkage table is reserved. */
1393 /* We have to count backwards here, and the result is only valid as
1394 an index into .got.plt and its relocations. FIXME: Constants... */
1395 bfd_vma gotplt_index = gotplt_offset/4 - 3;
1396
1397 /* Get the offset into the .got table of the entry that corresponds
1398 to this function. Note that we embed knowledge that "incoming"
1399 .got goes after .got.plt in the output without padding (pointer
1400 aligned). However, that knowledge is present in several other
1401 places too, here and in elflink.h at least. */
1402 bfd_vma got_offset
1403 = (has_gotplt
1404 ? gotplt_offset
1405 : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
1406
1407 /* This symbol has an entry in the procedure linkage table. Set it
1408 up. */
1409
1410 BFD_ASSERT (h->dynindx != -1);
1411
1412 splt = bfd_get_section_by_name (dynobj, ".plt");
1413 sgot = bfd_get_section_by_name (dynobj, ".got");
1414 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1415 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1416 BFD_ASSERT (splt != NULL && sgotplt != NULL
1417 && (! has_gotplt || srela != NULL));
1418
1419 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1420
1421 /* Fill in the entry in the procedure linkage table. */
1422 if (! info->shared)
1423 {
1424 memcpy (splt->contents + h->plt.offset, elf_cris_plt_entry,
1425 PLT_ENTRY_SIZE);
1426
1427 /* We need to enter the absolute address of the GOT entry here. */
1428 bfd_put_32 (output_bfd, got_base + got_offset,
1429 splt->contents + h->plt.offset + plt_off1);
1430 }
1431 else
1432 {
1433 memcpy (splt->contents + h->plt.offset, elf_cris_pic_plt_entry,
1434 PLT_ENTRY_SIZE);
1435 bfd_put_32 (output_bfd, got_offset,
1436 splt->contents + h->plt.offset + plt_off1);
1437 }
1438
1439 /* Fill in the plt entry and make a relocation, if this is a "real"
1440 PLT entry. */
1441 if (has_gotplt)
1442 {
1443 /* Fill in the offset into the reloc table. */
1444 bfd_put_32 (output_bfd,
1445 gotplt_index * sizeof (Elf32_External_Rela),
1446 splt->contents + h->plt.offset + plt_off2);
1447
1448 /* Fill in the offset to the first PLT entry, where to "jump". */
1449 bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3 + 4),
1450 splt->contents + h->plt.offset + plt_off3);
1451
1452 /* Fill in the entry in the global offset table with the address of
1453 the relocating stub. */
1454 bfd_put_32 (output_bfd,
1455 (splt->output_section->vma
1456 + splt->output_offset
1457 + h->plt.offset
1458 + 8),
1459 sgotplt->contents + got_offset);
1460
1461 /* Fill in the entry in the .rela.plt section. */
1462 rela.r_offset = (sgotplt->output_section->vma
1463 + sgotplt->output_offset
1464 + got_offset);
1465 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
1466 rela.r_addend = 0;
1467 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1468 ((Elf32_External_Rela *) srela->contents
1469 + gotplt_index));
1470 }
1471
1472 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1473 {
1474 /* Mark the symbol as undefined, rather than as defined in
1475 the .plt section. Leave the value alone. */
1476 sym->st_shndx = SHN_UNDEF;
1477
1478 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1479 know whether resetting the value is significant; if it really
1480 is, rather than a quirk or bug in the sparc port, then I
1481 believe we'd see this elsewhere. */
1482 /* If the symbol is weak, we do need to clear the value.
1483 Otherwise, the PLT entry would provide a definition for
1484 the symbol even if the symbol wasn't defined anywhere,
1485 and so the symbol would never be NULL. */
1486 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1487 == 0)
1488 sym->st_value = 0;
1489 }
1490 }
1491
1492 /* We don't emit .got relocs for symbols that aren't in the
1493 dynamic-symbols table for an ordinary program. */
1494 if (h->got.offset != (bfd_vma) -1
1495 && (info->shared || h->dynindx != -1))
1496 {
1497 asection *sgot;
1498 asection *srela;
1499 Elf_Internal_Rela rela;
1500 bfd_byte *where;
1501
1502 /* This symbol has an entry in the global offset table. Set it up. */
1503
1504 sgot = bfd_get_section_by_name (dynobj, ".got");
1505 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1506 BFD_ASSERT (sgot != NULL && srela != NULL);
1507
1508 rela.r_offset = (sgot->output_section->vma
1509 + sgot->output_offset
1510 + (h->got.offset &~ (bfd_vma) 1));
1511
1512 /* If this is a static link, or it is a -Bsymbolic link and the
1513 symbol is defined locally or was forced to be local because
1514 of a version file, we just want to emit a RELATIVE reloc.
1515 The entry in the global offset table will already have been
1516 initialized in the relocate_section function. */
1517 where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
1518 if (! elf_hash_table (info)->dynamic_sections_created
1519 || (info->shared
1520 && (info->symbolic || h->dynindx == -1)
1521 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1522 {
1523 rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1524 rela.r_addend = bfd_get_signed_32 (output_bfd, where);
1525 }
1526 else
1527 {
1528 bfd_put_32 (output_bfd, (bfd_vma) 0, where);
1529 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
1530 rela.r_addend = 0;
1531 }
1532
1533 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1534 ((Elf32_External_Rela *) srela->contents
1535 + srela->reloc_count));
1536 ++srela->reloc_count;
1537 }
1538
1539 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1540 {
1541 asection *s;
1542 Elf_Internal_Rela rela;
1543
1544 /* This symbol needs a copy reloc. Set it up. */
1545
1546 BFD_ASSERT (h->dynindx != -1
1547 && (h->root.type == bfd_link_hash_defined
1548 || h->root.type == bfd_link_hash_defweak));
1549
1550 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1551 ".rela.bss");
1552 BFD_ASSERT (s != NULL);
1553
1554 rela.r_offset = (h->root.u.def.value
1555 + h->root.u.def.section->output_section->vma
1556 + h->root.u.def.section->output_offset);
1557 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
1558 rela.r_addend = 0;
1559 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1560 ((Elf32_External_Rela *) s->contents
1561 + s->reloc_count));
1562 ++s->reloc_count;
1563 }
1564
1565 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1566 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1567 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1568 sym->st_shndx = SHN_ABS;
1569
1570 return true;
1571 }
1572 \f
1573 /* Finish up the dynamic sections. */
1574
1575 static boolean
1576 elf_cris_finish_dynamic_sections (output_bfd, info)
1577 bfd *output_bfd;
1578 struct bfd_link_info *info;
1579 {
1580 bfd *dynobj;
1581 asection *sgot;
1582 asection *sdyn;
1583
1584 dynobj = elf_hash_table (info)->dynobj;
1585
1586 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1587 BFD_ASSERT (sgot != NULL);
1588 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1589
1590 if (elf_hash_table (info)->dynamic_sections_created)
1591 {
1592 asection *splt;
1593 Elf32_External_Dyn *dyncon, *dynconend;
1594
1595 splt = bfd_get_section_by_name (dynobj, ".plt");
1596 BFD_ASSERT (splt != NULL && sdyn != NULL);
1597
1598 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1599 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1600 for (; dyncon < dynconend; dyncon++)
1601 {
1602 Elf_Internal_Dyn dyn;
1603 asection *s;
1604
1605 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1606
1607 switch (dyn.d_tag)
1608 {
1609 default:
1610 break;
1611
1612 case DT_PLTGOT:
1613 s = bfd_get_section_by_name (output_bfd, ".got");
1614 BFD_ASSERT (s != NULL);
1615 dyn.d_un.d_ptr = s->vma;
1616 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1617 break;
1618
1619 case DT_JMPREL:
1620 /* Yes, we *can* have a .plt and no .plt.rela, for instance
1621 if all symbols are found in the .got (not .got.plt). */
1622 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1623 dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
1624 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1625 break;
1626
1627 case DT_PLTRELSZ:
1628 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1629 if (s == NULL)
1630 dyn.d_un.d_val = 0;
1631 else if (s->_cooked_size != 0)
1632 dyn.d_un.d_val = s->_cooked_size;
1633 else
1634 dyn.d_un.d_val = s->_raw_size;
1635 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1636 break;
1637
1638 case DT_RELASZ:
1639 /* The procedure linkage table relocs (DT_JMPREL) should
1640 not be included in the overall relocs (DT_RELA).
1641 Therefore, we override the DT_RELASZ entry here to
1642 make it not include the JMPREL relocs. Since the
1643 linker script arranges for .rela.plt to follow all
1644 other relocation sections, we don't have to worry
1645 about changing the DT_RELA entry. */
1646 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1647 if (s != NULL)
1648 {
1649 if (s->_cooked_size != 0)
1650 dyn.d_un.d_val -= s->_cooked_size;
1651 else
1652 dyn.d_un.d_val -= s->_raw_size;
1653 }
1654 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1655 break;
1656 }
1657 }
1658
1659 /* Fill in the first entry in the procedure linkage table. */
1660 if (splt->_raw_size > 0)
1661 {
1662 if (info->shared)
1663 memcpy (splt->contents, elf_cris_pic_plt0_entry, PLT_ENTRY_SIZE);
1664 else
1665 {
1666 memcpy (splt->contents, elf_cris_plt0_entry, PLT_ENTRY_SIZE);
1667 bfd_put_32 (output_bfd,
1668 sgot->output_section->vma + sgot->output_offset + 4,
1669 splt->contents + 6);
1670 bfd_put_32 (output_bfd,
1671 sgot->output_section->vma + sgot->output_offset + 8,
1672 splt->contents + 14);
1673
1674 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1675 = PLT_ENTRY_SIZE;
1676 }
1677 }
1678 }
1679
1680 /* Fill in the first three entries in the global offset table. */
1681 if (sgot->_raw_size > 0)
1682 {
1683 if (sdyn == NULL)
1684 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1685 else
1686 bfd_put_32 (output_bfd,
1687 sdyn->output_section->vma + sdyn->output_offset,
1688 sgot->contents);
1689 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1690 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1691 }
1692
1693 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1694
1695 return true;
1696 }
1697 \f
1698 /* Return the section that should be marked against GC for a given
1699 relocation. */
1700
1701 static asection *
1702 cris_elf_gc_mark_hook (abfd, info, rel, h, sym)
1703 bfd * abfd;
1704 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1705 Elf_Internal_Rela * rel;
1706 struct elf_link_hash_entry * h;
1707 Elf_Internal_Sym * sym;
1708 {
1709 if (h != NULL)
1710 {
1711 switch (ELF32_R_TYPE (rel->r_info))
1712 {
1713 case R_CRIS_GNU_VTINHERIT:
1714 case R_CRIS_GNU_VTENTRY:
1715 break;
1716
1717 default:
1718 switch (h->root.type)
1719 {
1720 case bfd_link_hash_defined:
1721 case bfd_link_hash_defweak:
1722 return h->root.u.def.section;
1723
1724 case bfd_link_hash_common:
1725 return h->root.u.c.p->section;
1726
1727 default:
1728 break;
1729 }
1730 }
1731 }
1732 else
1733 {
1734 if (!(elf_bad_symtab (abfd)
1735 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1736 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1737 && sym->st_shndx != SHN_COMMON))
1738 {
1739 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1740 }
1741 }
1742
1743 return NULL;
1744 }
1745
1746 /* Update the got entry reference counts for the section being removed. */
1747
1748 static boolean
1749 cris_elf_gc_sweep_hook (abfd, info, sec, relocs)
1750 bfd * abfd ATTRIBUTE_UNUSED;
1751 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1752 asection * sec ATTRIBUTE_UNUSED;
1753 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
1754 {
1755 Elf_Internal_Shdr *symtab_hdr;
1756 struct elf_link_hash_entry **sym_hashes;
1757 bfd_signed_vma *local_got_refcounts;
1758 const Elf_Internal_Rela *rel, *relend;
1759 unsigned long r_symndx;
1760 struct elf_link_hash_entry *h;
1761 bfd *dynobj;
1762 asection *sgot;
1763 asection *srelgot;
1764
1765 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1766 sym_hashes = elf_sym_hashes (abfd);
1767 local_got_refcounts = elf_local_got_refcounts (abfd);
1768
1769 dynobj = elf_hash_table (info)->dynobj;
1770 if (dynobj == NULL)
1771 return true;
1772
1773 sgot = bfd_get_section_by_name (dynobj, ".got");
1774 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1775
1776 relend = relocs + sec->reloc_count;
1777 for (rel = relocs; rel < relend; rel++)
1778 {
1779 switch (ELF32_R_TYPE (rel->r_info))
1780 {
1781 case R_CRIS_16_GOT:
1782 case R_CRIS_32_GOT:
1783 r_symndx = ELF32_R_SYM (rel->r_info);
1784 if (r_symndx >= symtab_hdr->sh_info)
1785 {
1786 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1787 if (h->got.refcount > 0)
1788 {
1789 --h->got.refcount;
1790 if (h->got.refcount == 0)
1791 {
1792 /* We don't need the .got entry any more. */
1793 sgot->_raw_size -= 4;
1794 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1795 }
1796 }
1797 break;
1798 }
1799
1800 local_got_reloc:
1801 if (local_got_refcounts != NULL)
1802 {
1803 if (local_got_refcounts[r_symndx] > 0)
1804 {
1805 --local_got_refcounts[r_symndx];
1806 if (local_got_refcounts[r_symndx] == 0)
1807 {
1808 /* We don't need the .got entry any more. */
1809 sgot->_raw_size -= 4;
1810 if (info->shared)
1811 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1812 }
1813 }
1814 }
1815 break;
1816
1817 case R_CRIS_16_GOTPLT:
1818 case R_CRIS_32_GOTPLT:
1819 /* For local symbols, treat these like GOT relocs. */
1820 r_symndx = ELF32_R_SYM (rel->r_info);
1821 if (r_symndx < symtab_hdr->sh_info)
1822 goto local_got_reloc;
1823
1824 case R_CRIS_32_PLT_GOTREL:
1825 /* FIXME: We don't garbage-collect away the .got section. */
1826 if (local_got_refcounts != NULL)
1827 local_got_refcounts[-1]--;
1828 /* Fall through. */
1829
1830 case R_CRIS_8_PCREL:
1831 case R_CRIS_16_PCREL:
1832 case R_CRIS_32_PCREL:
1833 case R_CRIS_32_PLT_PCREL:
1834 r_symndx = ELF32_R_SYM (rel->r_info);
1835 if (r_symndx >= symtab_hdr->sh_info)
1836 {
1837 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1838 if (h->plt.refcount > 0)
1839 --h->plt.refcount;
1840 }
1841 break;
1842
1843 default:
1844 break;
1845 }
1846 }
1847
1848 return true;
1849 }
1850
1851 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1852 entry but we found we will not create any. Called when we find we will
1853 not have any PLT for this symbol, by for example
1854 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
1855 or elf_cris_size_dynamic_sections if no dynamic sections will be
1856 created (we're only linking static objects). */
1857
1858 static boolean
1859 elf_cris_adjust_gotplt_to_got (h, p)
1860 struct elf_cris_link_hash_entry *h;
1861 PTR p;
1862 {
1863 struct bfd_link_info *info = (struct bfd_link_info *) p;
1864 bfd *dynobj = elf_hash_table (info)->dynobj;
1865
1866 BFD_ASSERT (dynobj != NULL);
1867
1868 /* If nobody wanted a GOTPLT with this symbol, we're done. */
1869 if (h->gotplt_refcount <= 0)
1870 return true;
1871
1872 if (h->root.got.refcount > 0)
1873 {
1874 /* There's a GOT entry for this symbol. Just adjust the refcount.
1875 Probably not necessary at this stage, but keeping it accurate
1876 helps avoiding surprises later. */
1877 h->root.got.refcount += h->gotplt_refcount;
1878 h->gotplt_refcount = -1;
1879 }
1880 else
1881 {
1882 /* No GOT entry for this symbol. We need to create one. */
1883 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1884 asection *srelgot
1885 = bfd_get_section_by_name (dynobj, ".rela.got");
1886
1887 /* Put an accurate refcount there. */
1888 h->root.got.refcount = h->gotplt_refcount;
1889
1890 h->gotplt_refcount = -1;
1891
1892 /* We always have a .got section when there are dynamic
1893 relocs. */
1894 BFD_ASSERT (sgot != NULL /* Surely have .got section. */);
1895
1896 /* We might have had a PLT but with no GOT entry and
1897 further no GOT reloc section at all needed before.
1898 Add it. */
1899 if (srelgot == NULL)
1900 {
1901 srelgot = bfd_make_section (dynobj, ".rela.got");
1902
1903 if (srelgot == NULL
1904 || !bfd_set_section_flags (dynobj, srelgot,
1905 (SEC_ALLOC
1906 | SEC_LOAD
1907 | SEC_HAS_CONTENTS
1908 | SEC_IN_MEMORY
1909 | SEC_LINKER_CREATED
1910 | SEC_READONLY))
1911 || !bfd_set_section_alignment (dynobj, srelgot, 2))
1912 return false;
1913 }
1914
1915 /* Allocate space in the .got section. */
1916 sgot->_raw_size += 4;
1917
1918 /* Allocate relocation space. */
1919 srelgot->_raw_size += sizeof (Elf32_External_Rela);
1920 }
1921
1922 return true;
1923 }
1924
1925 /* Try to fold PLT entries with GOT entries. There are two cases when we
1926 want to do this:
1927
1928 - When all PLT references are GOTPLT references, and there are GOT
1929 references. We don't have to generate a PLT at all.
1930
1931 - When there are both (ordinary) PLT references and GOT references.
1932 We want to make the PLT reference use the ordinary GOT entry rather
1933 than a run-time dynamically resolved GOTPLT entry (since the GOT
1934 entry will have to be resolved at startup anyway).
1935
1936 Though the latter case is handled when room for the PLT is allocated,
1937 not here.
1938
1939 Note that this function is called before symbols are forced local by
1940 version scripts. The differing cases are handled by
1941 elf_cris_hide_symbol. */
1942
1943 static boolean
1944 elf_cris_try_fold_plt_to_got (h, p)
1945 struct elf_cris_link_hash_entry *h;
1946 PTR p;
1947 {
1948 struct bfd_link_info *info = (struct bfd_link_info *) p;
1949
1950 /* If there are no GOT references for this symbol, we can't fold any
1951 other reference so there's nothing to do. Likewise if there are no
1952 PLT references; GOTPLT references included. */
1953 if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
1954 return true;
1955
1956 /* GOTPLT relocs are supposed to be included into the PLT refcount. */
1957 BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
1958
1959 if (h->gotplt_refcount == h->root.plt.refcount)
1960 {
1961 /* The only PLT references are GOTPLT references, and there are GOT
1962 references. Convert PLT to GOT references. */
1963 if (! elf_cris_adjust_gotplt_to_got (h, info))
1964 return false;
1965
1966 /* Clear the PLT references, so no PLT will be created. */
1967 h->root.plt.offset = (bfd_vma) -1;
1968 }
1969
1970 return true;
1971 }
1972
1973 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
1974 to use a GOT entry (and create one) rather than requiring a GOTPLT
1975 entry. */
1976
1977 static void
1978 elf_cris_hide_symbol (info, h)
1979 struct bfd_link_info *info;
1980 struct elf_link_hash_entry *h;
1981 {
1982 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
1983
1984 _bfd_elf_link_hash_hide_symbol (info, h);
1985 }
1986
1987 /* Adjust a symbol defined by a dynamic object and referenced by a
1988 regular object. The current definition is in some section of the
1989 dynamic object, but we're not including those sections. We have to
1990 change the definition to something the rest of the link can
1991 understand. */
1992
1993 static boolean
1994 elf_cris_adjust_dynamic_symbol (info, h)
1995 struct bfd_link_info *info;
1996 struct elf_link_hash_entry *h;
1997 {
1998 bfd *dynobj;
1999 asection *s;
2000 unsigned int power_of_two;
2001
2002 dynobj = elf_hash_table (info)->dynobj;
2003
2004 /* Make sure we know what is going on here. */
2005 BFD_ASSERT (dynobj != NULL
2006 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2007 || h->weakdef != NULL
2008 || ((h->elf_link_hash_flags
2009 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2010 && (h->elf_link_hash_flags
2011 & ELF_LINK_HASH_REF_REGULAR) != 0
2012 && (h->elf_link_hash_flags
2013 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2014
2015 /* If this is a function, put it in the procedure linkage table. We
2016 will fill in the contents of the procedure linkage table later,
2017 when we know the address of the .got section. */
2018 if (h->type == STT_FUNC
2019 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2020 {
2021 if (! info->shared
2022 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2023 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
2024 /* We must always create the plt entry if it was referenced by a
2025 PLT relocation. In this case we already recorded it as a
2026 dynamic symbol. */
2027 /* FIXME: m68k and i386 differ here, for unclear reasons. */
2028 && h->dynindx == -1)
2029 {
2030 /* This case can occur if we saw a PLT reloc in an input file,
2031 but the symbol was never referred to by a dynamic object. In
2032 such a case, we don't actually need to build a procedure
2033 linkage table, and we can just do a PC reloc instead, or
2034 change a .got.plt index to a .got index for GOTPLT relocs. */
2035 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2036 h->plt.offset = (bfd_vma) -1;
2037
2038 return
2039 elf_cris_adjust_gotplt_to_got ((struct
2040 elf_cris_link_hash_entry *) h,
2041 info);
2042 }
2043
2044 /* If there are only GOT references and GOTPLT references to this
2045 PLT entry, get rid of the PLT. */
2046 if (! elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry *)
2047 h, info))
2048 return false;
2049
2050 /* GC or folding may have rendered this entry unused. */
2051 if (h->plt.refcount <= 0)
2052 {
2053 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2054 h->plt.offset = (bfd_vma) -1;
2055 return true;
2056 }
2057
2058 /* Make sure this symbol is output as a dynamic symbol. */
2059 if (h->dynindx == -1)
2060 {
2061 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2062 return false;
2063 }
2064
2065 s = bfd_get_section_by_name (dynobj, ".plt");
2066 BFD_ASSERT (s != NULL);
2067
2068 /* If this is the first .plt entry, make room for the special
2069 first entry. */
2070 if (s->_raw_size == 0)
2071 s->_raw_size += PLT_ENTRY_SIZE;
2072
2073 /* If this symbol is not defined in a regular file, and we are
2074 not generating a shared library, then set the symbol to this
2075 location in the .plt. This is required to make function
2076 pointers compare as equal between the normal executable and
2077 the shared library. */
2078 if (!info->shared
2079 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2080 {
2081 h->root.u.def.section = s;
2082 h->root.u.def.value = s->_raw_size;
2083 }
2084
2085 /* If there's already a GOT entry, use that, not a .got.plt. A
2086 GOT field still has a reference count when we get here; it's
2087 not yet changed to an offset. */
2088 if (h->got.refcount > 0)
2089 {
2090 h->got.refcount += h->plt.refcount;
2091
2092 /* Mark the PLT offset to use the GOT entry by setting the low
2093 bit in the plt offset; it is always a multiple of
2094 pointer-size. */
2095 BFD_ASSERT ((s->_raw_size & 3) == 0);
2096
2097 /* Change the PLT refcount to an offset. */
2098 h->plt.offset = s->_raw_size;
2099
2100 /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2101 that the got entry should be used instead. */
2102 BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2103 h)->gotplt_offset == 0);
2104
2105 /* Make room for this entry. */
2106 s->_raw_size += PLT_ENTRY_SIZE;
2107
2108 return true;
2109 }
2110
2111 /* No GOT reference for this symbol; prepare for an ordinary PLT. */
2112 h->plt.offset = s->_raw_size;
2113
2114 /* Make room for this entry. */
2115 s->_raw_size += PLT_ENTRY_SIZE;
2116
2117 /* We also need to make an entry in the .got.plt section, which
2118 will be placed in the .got section by the linker script. */
2119 ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2120 = elf_cris_hash_table (info)->next_gotplt_entry;
2121 elf_cris_hash_table (info)->next_gotplt_entry += 4;
2122
2123 s = bfd_get_section_by_name (dynobj, ".got.plt");
2124 BFD_ASSERT (s != NULL);
2125 s->_raw_size += 4;
2126
2127 /* We also need to make an entry in the .rela.plt section. */
2128
2129 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2130 BFD_ASSERT (s != NULL);
2131 s->_raw_size += sizeof (Elf32_External_Rela);
2132
2133 return true;
2134 }
2135
2136 /* Reinitialize the plt offset now that it is not used as a reference
2137 count any more. */
2138 h->plt.offset = (bfd_vma) -1;
2139
2140 /* If this is a weak symbol, and there is a real definition, the
2141 processor independent code will have arranged for us to see the
2142 real definition first, and we can just use the same value. */
2143 if (h->weakdef != NULL)
2144 {
2145 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2146 || h->weakdef->root.type == bfd_link_hash_defweak);
2147 h->root.u.def.section = h->weakdef->root.u.def.section;
2148 h->root.u.def.value = h->weakdef->root.u.def.value;
2149 return true;
2150 }
2151
2152 /* This is a reference to a symbol defined by a dynamic object which
2153 is not a function. */
2154
2155 /* If we are creating a shared library, we must presume that the
2156 only references to the symbol are via the global offset table.
2157 For such cases we need not do anything here; the relocations will
2158 be handled correctly by relocate_section. */
2159 if (info->shared)
2160 return true;
2161
2162 /* If there are no references to this symbol that do not use the
2163 GOT, we don't need to generate a copy reloc. */
2164 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2165 return true;
2166
2167 /* We must allocate the symbol in our .dynbss section, which will
2168 become part of the .bss section of the executable. There will be
2169 an entry for this symbol in the .dynsym section. The dynamic
2170 object will contain position independent code, so all references
2171 from the dynamic object to this symbol will go through the global
2172 offset table. The dynamic linker will use the .dynsym entry to
2173 determine the address it must put in the global offset table, so
2174 both the dynamic object and the regular object will refer to the
2175 same memory location for the variable. */
2176
2177 s = bfd_get_section_by_name (dynobj, ".dynbss");
2178 BFD_ASSERT (s != NULL);
2179
2180 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2181 copy the initial value out of the dynamic object and into the
2182 runtime process image. We need to remember the offset into the
2183 .rela.bss section we are going to use. */
2184 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2185 {
2186 asection *srel;
2187
2188 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2189 BFD_ASSERT (srel != NULL);
2190 srel->_raw_size += sizeof (Elf32_External_Rela);
2191 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2192 }
2193
2194 /* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2195 thing to copy; so do we. */
2196
2197 /* We need to figure out the alignment required for this symbol. I
2198 have no idea how ELF linkers handle this. */
2199 power_of_two = bfd_log2 (h->size);
2200 if (power_of_two > 3)
2201 power_of_two = 3;
2202
2203 /* Apply the required alignment. */
2204 s->_raw_size = BFD_ALIGN (s->_raw_size,
2205 (bfd_size_type) (1 << power_of_two));
2206 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2207 {
2208 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
2209 return false;
2210 }
2211
2212 /* Define the symbol as being at this point in the section. */
2213 h->root.u.def.section = s;
2214 h->root.u.def.value = s->_raw_size;
2215
2216 /* Increment the section size to make room for the symbol. */
2217 s->_raw_size += h->size;
2218
2219 return true;
2220 }
2221
2222 /* Look through the relocs for a section during the first phase. */
2223
2224 static boolean
2225 cris_elf_check_relocs (abfd, info, sec, relocs)
2226 bfd *abfd;
2227 struct bfd_link_info *info;
2228 asection *sec;
2229 const Elf_Internal_Rela *relocs;
2230 {
2231 bfd *dynobj;
2232 Elf_Internal_Shdr *symtab_hdr;
2233 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2234 bfd_signed_vma *local_got_refcounts;
2235 const Elf_Internal_Rela *rel;
2236 const Elf_Internal_Rela *rel_end;
2237 asection *sgot;
2238 asection *srelgot;
2239 asection *sreloc;
2240
2241 if (info->relocateable)
2242 return true;
2243
2244 dynobj = elf_hash_table (info)->dynobj;
2245 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2246 sym_hashes = elf_sym_hashes (abfd);
2247 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2248 local_got_refcounts = elf_local_got_refcounts (abfd);
2249
2250 sgot = NULL;
2251 srelgot = NULL;
2252 sreloc = NULL;
2253
2254 if (!elf_bad_symtab (abfd))
2255 sym_hashes_end -= symtab_hdr->sh_info;
2256
2257 rel_end = relocs + sec->reloc_count;
2258 for (rel = relocs; rel < rel_end; rel++)
2259 {
2260 struct elf_link_hash_entry *h;
2261 unsigned long r_symndx;
2262 enum elf_cris_reloc_type r_type;
2263
2264 r_symndx = ELF32_R_SYM (rel->r_info);
2265 if (r_symndx < symtab_hdr->sh_info)
2266 h = NULL;
2267 else
2268 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2269
2270 r_type = ELF32_R_TYPE (rel->r_info);
2271
2272 /* Some relocs require linker-created sections; we need to hang them
2273 on the first input bfd we found that contained dynamic relocs. */
2274 switch (r_type)
2275 {
2276 case R_CRIS_16_GOT:
2277 case R_CRIS_32_GOT:
2278 case R_CRIS_32_GOTREL:
2279 case R_CRIS_32_PLT_GOTREL:
2280 case R_CRIS_32_PLT_PCREL:
2281 case R_CRIS_16_GOTPLT:
2282 case R_CRIS_32_GOTPLT:
2283 if (dynobj == NULL)
2284 {
2285 elf_hash_table (info)->dynobj = dynobj = abfd;
2286
2287 /* Create the .got section, so we can assume it's always
2288 present whenever there's a dynobj. */
2289 if (!_bfd_elf_create_got_section (dynobj, info))
2290 return false;
2291 }
2292 break;
2293
2294 default:
2295 break;
2296 }
2297
2298 /* Some relocs require a global offset table (but perhaps not a
2299 specific GOT entry). */
2300 switch (r_type)
2301 {
2302 case R_CRIS_16_GOT:
2303 case R_CRIS_32_GOT:
2304 case R_CRIS_32_GOTREL:
2305 case R_CRIS_32_PLT_GOTREL:
2306 if (sgot == NULL)
2307 sgot = bfd_get_section_by_name (dynobj, ".got");
2308
2309 if (local_got_refcounts == NULL)
2310 {
2311 bfd_size_type amt;
2312
2313 /* We use index local_got_refcounts[-1] to count all
2314 GOT-relative relocations that do not have explicit
2315 GOT entries. */
2316 amt = symtab_hdr->sh_info + 1;
2317 amt *= sizeof (bfd_signed_vma);
2318 local_got_refcounts = ((bfd_signed_vma *) bfd_alloc (abfd, amt));
2319 if (local_got_refcounts == NULL)
2320 return false;
2321 memset (local_got_refcounts, -1, (size_t) amt);
2322
2323 local_got_refcounts++;
2324 elf_local_got_refcounts (abfd) = local_got_refcounts;
2325 }
2326 break;
2327
2328 default:
2329 break;
2330 }
2331
2332 switch (r_type)
2333 {
2334 case R_CRIS_16_GOTPLT:
2335 case R_CRIS_32_GOTPLT:
2336 /* Mark that we need a GOT entry if the PLT entry (and its GOT
2337 entry) is eliminated. We can only do this for a non-local
2338 symbol. */
2339 if (h != NULL)
2340 {
2341 ((struct elf_cris_link_hash_entry *) h)->gotplt_refcount++;
2342 goto handle_gotplt_reloc;
2343 }
2344 /* If h is NULL then this is a local symbol, and we must make a
2345 GOT entry for it, so handle it like a GOT reloc. */
2346 /* Fall through. */
2347
2348 case R_CRIS_16_GOT:
2349 case R_CRIS_32_GOT:
2350 /* This symbol requires a global offset table entry. */
2351
2352 if (srelgot == NULL
2353 && (h != NULL || info->shared))
2354 {
2355 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2356 if (srelgot == NULL)
2357 {
2358 srelgot = bfd_make_section (dynobj, ".rela.got");
2359 if (srelgot == NULL
2360 || !bfd_set_section_flags (dynobj, srelgot,
2361 (SEC_ALLOC
2362 | SEC_LOAD
2363 | SEC_HAS_CONTENTS
2364 | SEC_IN_MEMORY
2365 | SEC_LINKER_CREATED
2366 | SEC_READONLY))
2367 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2368 return false;
2369 }
2370 }
2371
2372 if (h != NULL)
2373 {
2374 if (h->got.refcount == -1)
2375 {
2376 h->got.refcount = 1;
2377
2378 /* Make sure this symbol is output as a dynamic symbol. */
2379 if (h->dynindx == -1)
2380 {
2381 if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2382 return false;
2383 }
2384
2385 /* Allocate space in the .got section. */
2386 sgot->_raw_size += 4;
2387 /* Allocate relocation space. */
2388 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2389 }
2390 else
2391 h->got.refcount++;
2392 }
2393 else
2394 {
2395 /* This is a global offset table entry for a local symbol. */
2396 if (local_got_refcounts[r_symndx] == -1)
2397 {
2398 local_got_refcounts[r_symndx] = 1;
2399
2400 sgot->_raw_size += 4;
2401 if (info->shared)
2402 {
2403 /* If we are generating a shared object, we need to
2404 output a R_CRIS_RELATIVE reloc so that the dynamic
2405 linker can adjust this GOT entry. */
2406 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2407 }
2408 }
2409 else
2410 local_got_refcounts[r_symndx]++;
2411 }
2412 break;
2413
2414 case R_CRIS_32_GOTREL:
2415 /* This reference requires a global offset table.
2416 FIXME: The actual refcount isn't used currently; the .got
2417 section can't be removed if there were any references in the
2418 input. */
2419 local_got_refcounts[-1]++;
2420 break;
2421
2422 handle_gotplt_reloc:
2423
2424 case R_CRIS_32_PLT_GOTREL:
2425 /* This reference requires a global offset table. */
2426 local_got_refcounts[-1]++;
2427 /* Fall through. */
2428
2429 case R_CRIS_32_PLT_PCREL:
2430 /* This symbol requires a procedure linkage table entry. We
2431 actually build the entry in adjust_dynamic_symbol,
2432 because this might be a case of linking PIC code which is
2433 never referenced by a dynamic object, in which case we
2434 don't need to generate a procedure linkage table entry
2435 after all. */
2436
2437 /* If this is a local symbol, we resolve it directly without
2438 creating a procedure linkage table entry. */
2439 if (h == NULL)
2440 continue;
2441
2442 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2443 if (h->plt.refcount == -1)
2444 h->plt.refcount = 1;
2445 else
2446 h->plt.refcount++;
2447 break;
2448
2449 case R_CRIS_8:
2450 case R_CRIS_16:
2451 case R_CRIS_32:
2452 /* Let's help debug shared library creation. Any of these
2453 relocs can be used in shared libs, but pages containing them
2454 cannot be shared. Don't warn for sections we don't care
2455 about, such as debug sections or non-constant sections. We
2456 can't help tables of (global) function pointers, for example,
2457 though they must be emitted in a data section to avoid having
2458 impure text sections. */
2459 if (info->shared
2460 && (sec->flags & SEC_ALLOC) != 0
2461 && (sec->flags & SEC_READONLY) != 0)
2462 {
2463 /* FIXME: How do we make this optionally a warning only? */
2464 (*_bfd_error_handler)
2465 (_("%s, section %s:\n relocation %s should not be used in a shared object; recompile with -fPIC"),
2466 bfd_archive_filename (abfd),
2467 sec->name,
2468 cris_elf_howto_table[r_type].name);
2469 }
2470 /* Fall through. */
2471
2472 case R_CRIS_8_PCREL:
2473 case R_CRIS_16_PCREL:
2474 case R_CRIS_32_PCREL:
2475 if (h != NULL)
2476 {
2477 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2478
2479 /* Make sure a plt entry is created for this symbol if it
2480 turns out to be a function defined by a dynamic object. */
2481 if (h->plt.refcount == -1)
2482 h->plt.refcount = 1;
2483 else
2484 h->plt.refcount++;
2485 }
2486
2487 /* If we are creating a shared library and this is not a local
2488 symbol, we need to copy the reloc into the shared library.
2489 However when linking with -Bsymbolic and this is a global
2490 symbol which is defined in an object we are including in the
2491 link (i.e., DEF_REGULAR is set), then we can resolve the
2492 reloc directly. At this point we have not seen all the input
2493 files, so it is possible that DEF_REGULAR is not set now but
2494 will be set later (it is never cleared). In case of a weak
2495 definition, DEF_REGULAR may be cleared later by a strong
2496 definition in a shared library. We account for that
2497 possibility below by storing information in the relocs_copied
2498 field of the hash table entry. A similar situation occurs
2499 when creating shared libraries and symbol visibility changes
2500 render the symbol local. */
2501
2502 /* No need to do anything if we're not creating a shared object. */
2503 if (! info->shared)
2504 break;
2505
2506 /* We don't need to handle relocs into sections not going into
2507 the "real" output. */
2508 if ((sec->flags & SEC_ALLOC) == 0)
2509 break;
2510
2511 /* We can only eliminate PC-relative relocs. */
2512 if (r_type == R_CRIS_8_PCREL
2513 || r_type == R_CRIS_16_PCREL
2514 || r_type == R_CRIS_32_PCREL)
2515 {
2516 /* If the symbol is local, then we can eliminate the reloc. */
2517 if (h == NULL)
2518 break;
2519
2520 /* If this is with -Bsymbolic and the symbol isn't weak, and
2521 is defined by an ordinary object (the ones we include in
2522 this shared library) then we can also eliminate the
2523 reloc. See comment above for more eliminable cases which
2524 we can't identify at this time. */
2525 if (info->symbolic
2526 && h->root.type != bfd_link_hash_defweak
2527 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2528 break;
2529 }
2530
2531 /* We create a reloc section in dynobj and make room for this
2532 reloc. */
2533 if (sreloc == NULL)
2534 {
2535 const char *name;
2536
2537 name = (bfd_elf_string_from_elf_section
2538 (abfd,
2539 elf_elfheader (abfd)->e_shstrndx,
2540 elf_section_data (sec)->rel_hdr.sh_name));
2541 if (name == NULL)
2542 return false;
2543
2544 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2545 && strcmp (bfd_get_section_name (abfd, sec),
2546 name + 5) == 0);
2547
2548 sreloc = bfd_get_section_by_name (dynobj, name);
2549 if (sreloc == NULL)
2550 {
2551 sreloc = bfd_make_section (dynobj, name);
2552 if (sreloc == NULL
2553 || !bfd_set_section_flags (dynobj, sreloc,
2554 (SEC_ALLOC
2555 | SEC_LOAD
2556 | SEC_HAS_CONTENTS
2557 | SEC_IN_MEMORY
2558 | SEC_LINKER_CREATED
2559 | SEC_READONLY))
2560 || !bfd_set_section_alignment (dynobj, sreloc, 2))
2561 return false;
2562 }
2563 if (sec->flags & SEC_READONLY)
2564 info->flags |= DF_TEXTREL;
2565 }
2566
2567 sreloc->_raw_size += sizeof (Elf32_External_Rela);
2568
2569 /* If we are linking with -Bsymbolic, we count the number of PC
2570 relative relocations we have entered for this symbol, so that
2571 we can discard them again if the symbol is later defined by a
2572 regular object. We know that h is really a pointer to an
2573 elf_cris_link_hash_entry. */
2574 if ((r_type == R_CRIS_8_PCREL
2575 || r_type == R_CRIS_16_PCREL
2576 || r_type == R_CRIS_32_PCREL)
2577 && info->symbolic)
2578 {
2579 struct elf_cris_link_hash_entry *eh;
2580 struct elf_cris_pcrel_relocs_copied *p;
2581
2582 eh = (struct elf_cris_link_hash_entry *) h;
2583
2584 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2585 if (p->section == sreloc)
2586 break;
2587
2588 if (p == NULL)
2589 {
2590 p = ((struct elf_cris_pcrel_relocs_copied *)
2591 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2592 if (p == NULL)
2593 return false;
2594 p->next = eh->pcrel_relocs_copied;
2595 eh->pcrel_relocs_copied = p;
2596 p->section = sreloc;
2597 p->count = 0;
2598 }
2599
2600 ++p->count;
2601 }
2602 break;
2603
2604 /* This relocation describes the C++ object vtable hierarchy.
2605 Reconstruct it for later use during GC. */
2606 case R_CRIS_GNU_VTINHERIT:
2607 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2608 return false;
2609 break;
2610
2611 /* This relocation describes which C++ vtable entries are actually
2612 used. Record for later use during GC. */
2613 case R_CRIS_GNU_VTENTRY:
2614 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2615 return false;
2616 break;
2617
2618 default:
2619 /* Other relocs do not appear here. */
2620 bfd_set_error (bfd_error_bad_value);
2621 return false;
2622 }
2623 }
2624
2625 return true;
2626 }
2627
2628 /* Set the sizes of the dynamic sections. */
2629
2630 static boolean
2631 elf_cris_size_dynamic_sections (output_bfd, info)
2632 bfd *output_bfd ATTRIBUTE_UNUSED;
2633 struct bfd_link_info *info;
2634 {
2635 bfd *dynobj;
2636 asection *s;
2637 boolean plt;
2638 boolean relocs;
2639
2640 dynobj = elf_hash_table (info)->dynobj;
2641 BFD_ASSERT (dynobj != NULL);
2642
2643 if (elf_hash_table (info)->dynamic_sections_created)
2644 {
2645 /* Set the contents of the .interp section to the interpreter. */
2646 if (!info->shared)
2647 {
2648 s = bfd_get_section_by_name (dynobj, ".interp");
2649 BFD_ASSERT (s != NULL);
2650 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2651 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2652 }
2653 }
2654 else
2655 {
2656 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2657 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2658 elf_cris_adjust_gotplt_to_got,
2659 (PTR) info);
2660
2661 /* We may have created entries in the .rela.got section.
2662 However, if we are not creating the dynamic sections, we will
2663 not actually use these entries. Reset the size of .rela.got,
2664 which will cause it to get stripped from the output file
2665 below. */
2666 s = bfd_get_section_by_name (dynobj, ".rela.got");
2667 if (s != NULL)
2668 s->_raw_size = 0;
2669 }
2670
2671 /* If this is a -Bsymbolic shared link, then we need to discard all PC
2672 relative relocs against symbols defined in a regular object. We
2673 allocated space for them in the check_relocs routine, but we will not
2674 fill them in in the relocate_section routine. We also discard space
2675 for relocs that have become for local symbols due to symbol
2676 visibility changes. For programs, we discard space for relocs for
2677 symbols not referenced by any dynamic object. */
2678 if (info->shared)
2679 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2680 elf_cris_discard_excess_dso_dynamics,
2681 (PTR) info);
2682 else
2683 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2684 elf_cris_discard_excess_program_dynamics,
2685 (PTR) info);
2686
2687 /* The check_relocs and adjust_dynamic_symbol entry points have
2688 determined the sizes of the various dynamic sections. Allocate
2689 memory for them. */
2690 plt = false;
2691 relocs = false;
2692 for (s = dynobj->sections; s != NULL; s = s->next)
2693 {
2694 const char *name;
2695 boolean strip;
2696
2697 if ((s->flags & SEC_LINKER_CREATED) == 0)
2698 continue;
2699
2700 /* It's OK to base decisions on the section name, because none
2701 of the dynobj section names depend upon the input files. */
2702 name = bfd_get_section_name (dynobj, s);
2703
2704 strip = false;
2705
2706 if (strcmp (name, ".plt") == 0)
2707 {
2708 if (s->_raw_size == 0)
2709 {
2710 /* Strip this section if we don't need it; see the
2711 comment below. */
2712 strip = true;
2713 }
2714 else
2715 {
2716 /* Remember whether there is a PLT. */
2717 plt = true;
2718 }
2719 }
2720 else if (strncmp (name, ".rela", 5) == 0)
2721 {
2722 if (s->_raw_size == 0)
2723 {
2724 /* If we don't need this section, strip it from the
2725 output file. This is mostly to handle .rela.bss and
2726 .rela.plt. We must create both sections in
2727 create_dynamic_sections, because they must be created
2728 before the linker maps input sections to output
2729 sections. The linker does that before
2730 adjust_dynamic_symbol is called, and it is that
2731 function which decides whether anything needs to go
2732 into these sections. */
2733 strip = true;
2734 }
2735 else
2736 {
2737 /* Remember whether there are any reloc sections other
2738 than .rela.plt. */
2739 if (strcmp (name, ".rela.plt") != 0)
2740 relocs = true;
2741
2742 /* We use the reloc_count field as a counter if we need
2743 to copy relocs into the output file. */
2744 s->reloc_count = 0;
2745 }
2746 }
2747 else if (strncmp (name, ".got", 4) != 0)
2748 {
2749 /* It's not one of our sections, so don't allocate space. */
2750 continue;
2751 }
2752
2753 if (strip)
2754 {
2755 _bfd_strip_section_from_output (info, s);
2756 continue;
2757 }
2758
2759 /* Allocate memory for the section contents. We use bfd_zalloc here
2760 in case unused entries are not reclaimed before the section's
2761 contents are written out. This should not happen, but this way
2762 if it does, we will not write out garbage. For reloc sections,
2763 this will make entries have the type R_CRIS_NONE. */
2764 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2765 if (s->contents == NULL && s->_raw_size != 0)
2766 return false;
2767 }
2768
2769 if (elf_hash_table (info)->dynamic_sections_created)
2770 {
2771 /* Add some entries to the .dynamic section. We fill in the
2772 values later, in elf_cris_finish_dynamic_sections, but we
2773 must add the entries now so that we get the correct size for
2774 the .dynamic section. The DT_DEBUG entry is filled in by the
2775 dynamic linker and used by the debugger. */
2776 #define add_dynamic_entry(TAG, VAL) \
2777 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2778
2779 if (!info->shared)
2780 {
2781 if (!add_dynamic_entry (DT_DEBUG, 0))
2782 return false;
2783 }
2784
2785 if (plt)
2786 {
2787 if (!add_dynamic_entry (DT_PLTGOT, 0)
2788 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2789 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2790 || !add_dynamic_entry (DT_JMPREL, 0))
2791 return false;
2792 }
2793
2794 if (relocs)
2795 {
2796 if (!add_dynamic_entry (DT_RELA, 0)
2797 || !add_dynamic_entry (DT_RELASZ, 0)
2798 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2799 return false;
2800 }
2801
2802 if ((info->flags & DF_TEXTREL) != 0)
2803 {
2804 if (!add_dynamic_entry (DT_TEXTREL, 0))
2805 return false;
2806 info->flags |= DF_TEXTREL;
2807 }
2808 }
2809 #undef add_dynamic_entry
2810
2811 return true;
2812 }
2813
2814 /* This function is called via elf_cris_link_hash_traverse if we are
2815 creating a shared object. In the -Bsymbolic case, it discards the
2816 space allocated to copy PC relative relocs against symbols which
2817 are defined in regular objects. For the normal non-symbolic case,
2818 we also discard space for relocs that have become local due to
2819 symbol visibility changes. We allocated space for them in the
2820 check_relocs routine, but we won't fill them in in the
2821 relocate_section routine. */
2822
2823 static boolean
2824 elf_cris_discard_excess_dso_dynamics (h, inf)
2825 struct elf_cris_link_hash_entry *h;
2826 PTR inf;
2827 {
2828 struct elf_cris_pcrel_relocs_copied *s;
2829 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2830
2831 /* If a symbol has been forced local or we have found a regular
2832 definition for the symbolic link case, then we won't be needing
2833 any relocs. */
2834 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2835 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2836 || info->symbolic))
2837 {
2838 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2839 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2840 }
2841
2842 return true;
2843 }
2844
2845 /* This function is called via elf_cris_link_hash_traverse if we are *not*
2846 creating a shared object. We discard space for relocs for symbols put
2847 in the .got, but which we found we do not have to resolve at run-time. */
2848
2849 static boolean
2850 elf_cris_discard_excess_program_dynamics (h, inf)
2851 struct elf_cris_link_hash_entry *h;
2852 PTR inf;
2853 {
2854 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2855
2856 /* If we're not creating a shared library and have a symbol which is
2857 referred to by .got references, but the symbol is defined locally,
2858 (or rather, not referred to by a DSO and not defined by a DSO) then
2859 lose the reloc for the .got (don't allocate room for it). */
2860 if ((h->root.elf_link_hash_flags
2861 & (ELF_LINK_HASH_REF_DYNAMIC | ELF_LINK_HASH_DEF_DYNAMIC)) == 0)
2862 {
2863 if (h->root.got.refcount > 0
2864 /* The size of this section is only valid and in sync with the
2865 various reference counts if we do dynamic; don't decrement it
2866 otherwise. */
2867 && elf_hash_table (info)->dynamic_sections_created)
2868 {
2869 bfd *dynobj = elf_hash_table (info)->dynobj;
2870 asection *srelgot;
2871
2872 BFD_ASSERT (dynobj != NULL);
2873
2874 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2875
2876 BFD_ASSERT (srelgot != NULL);
2877
2878 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
2879 }
2880
2881 /* If the locally-defined symbol isn't used by a DSO, then we don't
2882 have to export it as a dynamic symbol. This was already done for
2883 functions; doing this for all symbols would presumably not
2884 introduce new problems. */
2885 h->root.dynindx = -1;
2886 }
2887
2888 return true;
2889 }
2890
2891 /* Reject a file depending on presence and expectation of prefixed
2892 underscores on symbols. */
2893
2894 static boolean
2895 cris_elf_object_p (abfd)
2896 bfd *abfd;
2897 {
2898 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
2899 return (bfd_get_symbol_leading_char (abfd) == '_');
2900 else
2901 return (bfd_get_symbol_leading_char (abfd) == 0);
2902 }
2903
2904 /* Mark presence or absence of leading underscore. */
2905
2906 static void
2907 cris_elf_final_write_processing (abfd, linker)
2908 bfd *abfd;
2909 boolean linker ATTRIBUTE_UNUSED;
2910 {
2911 if (bfd_get_symbol_leading_char (abfd) == '_')
2912 elf_elfheader (abfd)->e_flags |= EF_CRIS_UNDERSCORE;
2913 else
2914 elf_elfheader (abfd)->e_flags &= ~EF_CRIS_UNDERSCORE;
2915 }
2916
2917 /* Display the flags field. */
2918
2919 static boolean
2920 cris_elf_print_private_bfd_data (abfd, ptr)
2921 bfd *abfd;
2922 PTR ptr;
2923 {
2924 FILE *file = (FILE *) ptr;
2925
2926 BFD_ASSERT (abfd != NULL && ptr != NULL)
2927
2928 _bfd_elf_print_private_bfd_data (abfd, ptr);
2929
2930 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2931
2932 if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
2933 fprintf (file, _(" [symbols have a _ prefix]"));
2934
2935 fputc ('\n', file);
2936 return true;
2937 }
2938
2939 /* Don't mix files with and without a leading underscore. */
2940
2941 static boolean
2942 cris_elf_merge_private_bfd_data (ibfd, obfd)
2943 bfd *ibfd;
2944 bfd *obfd;
2945 {
2946 flagword old_flags, new_flags;
2947
2948 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2949 return false;
2950
2951 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2952 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2953 return true;
2954
2955 if (! elf_flags_init (obfd))
2956 {
2957 /* This happens when ld starts out with a 'blank' output file. */
2958 elf_flags_init (obfd) = true;
2959
2960 /* Set flags according to current bfd_target. */
2961 cris_elf_final_write_processing (obfd, false);
2962 }
2963
2964 old_flags = elf_elfheader (obfd)->e_flags;
2965 new_flags = elf_elfheader (ibfd)->e_flags;
2966
2967 /* Is this good or bad? We'll follow with other excluding flags. */
2968 if ((old_flags & EF_CRIS_UNDERSCORE) != (new_flags & EF_CRIS_UNDERSCORE))
2969 {
2970 (*_bfd_error_handler)
2971 ((new_flags & EF_CRIS_UNDERSCORE)
2972 ? _("%s: uses _-prefixed symbols, but writing file with non-prefixed symbols")
2973 : _("%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
2974 bfd_archive_filename (ibfd));
2975 bfd_set_error (bfd_error_bad_value);
2976 return false;
2977 }
2978
2979 return true;
2980 }
2981
2982
2983 static enum elf_reloc_type_class
2984 elf_cris_reloc_type_class (rela)
2985 const Elf_Internal_Rela *rela;
2986 {
2987 switch ((int) ELF32_R_TYPE (rela->r_info))
2988 {
2989 case R_CRIS_RELATIVE:
2990 return reloc_class_relative;
2991 case R_CRIS_JUMP_SLOT:
2992 return reloc_class_plt;
2993 case R_CRIS_COPY:
2994 return reloc_class_copy;
2995 default:
2996 return reloc_class_normal;
2997 }
2998 }
2999 \f
3000 #define ELF_ARCH bfd_arch_cris
3001 #define ELF_MACHINE_CODE EM_CRIS
3002 #define ELF_MAXPAGESIZE 0x2000
3003
3004 #define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3005 #define TARGET_LITTLE_NAME "elf32-cris"
3006 #define elf_symbol_leading_char 0
3007
3008 #define elf_info_to_howto_rel NULL
3009 #define elf_info_to_howto cris_info_to_howto_rela
3010 #define elf_backend_relocate_section cris_elf_relocate_section
3011 #define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3012 #define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3013 #define elf_backend_check_relocs cris_elf_check_relocs
3014
3015 #define elf_backend_can_gc_sections 1
3016
3017 #define elf_backend_object_p cris_elf_object_p
3018 #define elf_backend_final_write_processing \
3019 cris_elf_final_write_processing
3020 #define bfd_elf32_bfd_print_private_bfd_data \
3021 cris_elf_print_private_bfd_data
3022 #define bfd_elf32_bfd_merge_private_bfd_data \
3023 cris_elf_merge_private_bfd_data
3024
3025 #define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3026
3027 #define bfd_elf32_bfd_link_hash_table_create \
3028 elf_cris_link_hash_table_create
3029 #define elf_backend_adjust_dynamic_symbol \
3030 elf_cris_adjust_dynamic_symbol
3031 #define elf_backend_size_dynamic_sections \
3032 elf_cris_size_dynamic_sections
3033 #define elf_backend_finish_dynamic_symbol \
3034 elf_cris_finish_dynamic_symbol
3035 #define elf_backend_finish_dynamic_sections \
3036 elf_cris_finish_dynamic_sections
3037 #define elf_backend_create_dynamic_sections \
3038 _bfd_elf_create_dynamic_sections
3039 #define bfd_elf32_bfd_final_link \
3040 _bfd_elf32_gc_common_final_link
3041 #define elf_backend_hide_symbol elf_cris_hide_symbol
3042 #define elf_backend_reloc_type_class elf_cris_reloc_type_class
3043
3044 #define elf_backend_want_got_plt 1
3045 #define elf_backend_plt_readonly 1
3046 #define elf_backend_want_plt_sym 0
3047 #define elf_backend_got_header_size 12
3048 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3049
3050 /* Later, we my want to optimize RELA entries into REL entries for dynamic
3051 linking and libraries (if it's a win of any significance). Until then,
3052 take the easy route. */
3053 #define elf_backend_may_use_rel_p 0
3054 #define elf_backend_may_use_rela_p 1
3055
3056 #include "elf32-target.h"
3057
3058 #define INCLUDED_TARGET_FILE
3059
3060 #undef TARGET_LITTLE_SYM
3061 #undef TARGET_LITTLE_NAME
3062 #undef elf_symbol_leading_char
3063
3064 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3065 #define TARGET_LITTLE_NAME "elf32-us-cris"
3066 #define elf_symbol_leading_char '_'
3067
3068 #include "elf32-target.h"
A mirror of the official binutils-gdb repository