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