?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make .ifdef treat a referenced but not yet defined symbol as if it were
[binutils.git] / bfd / elf32-cris.c
blob063c7dd0ba0a574048bb256b7a289b5ae6359485
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 dynobj = elf_hash_table (info)->dynobj;
803 local_got_offsets = elf_local_got_offsets (input_bfd);
804 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
805 sym_hashes = elf_sym_hashes (input_bfd);
806 relend = relocs + input_section->reloc_count;
807
808 sgot = NULL;
809 splt = NULL;
810 sreloc = NULL;
811
812 if (dynobj != NULL)
813 {
814 splt = bfd_get_section_by_name (dynobj, ".plt");
815 sgot = bfd_get_section_by_name (dynobj, ".got");
816 }
817
818 for (rel = relocs; rel < relend; rel ++)
819 {
820 reloc_howto_type * howto;
821 unsigned long r_symndx;
822 Elf_Internal_Sym * sym;
823 asection * sec;
824 struct elf_link_hash_entry * h;
825 bfd_vma relocation;
826 bfd_reloc_status_type r;
827 const char * symname = NULL;
828 int r_type;
829
830 r_type = ELF32_R_TYPE (rel->r_info);
831
832 if ( r_type == R_CRIS_GNU_VTINHERIT
833 || r_type == R_CRIS_GNU_VTENTRY)
834 continue;
835
836 r_symndx = ELF32_R_SYM (rel->r_info);
837
838 if (info->relocateable)
839 {
840 /* This is a relocateable link. We don't have to change
841 anything, unless the reloc is against a section symbol,
842 in which case we have to adjust according to where the
843 section symbol winds up in the output section. */
844 if (r_symndx < symtab_hdr->sh_info)
845 {
846 sym = local_syms + r_symndx;
847
848 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
849 {
850 sec = local_sections [r_symndx];
851 rel->r_addend += sec->output_offset + sym->st_value;
852 }
853 }
854
855 continue;
856 }
857
858 /* This is a final link. */
859 howto = cris_elf_howto_table + r_type;
860 h = NULL;
861 sym = NULL;
862 sec = NULL;
863
864 if (r_symndx < symtab_hdr->sh_info)
865 {
866 sym = local_syms + r_symndx;
867 sec = local_sections [r_symndx];
868 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
869
870 symname = (bfd_elf_string_from_elf_section
871 (input_bfd, symtab_hdr->sh_link, sym->st_name));
872 if (symname == NULL)
873 symname = bfd_section_name (input_bfd, sec);
874 }
875 else
876 {
877 /* It seems this can happen with erroneous or unsupported input
878 (mixing a.out and elf in an archive, for example.) */
879 if (sym_hashes == NULL)
880 return false;
881
882 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
883
884 while (h->root.type == bfd_link_hash_indirect
885 || h->root.type == bfd_link_hash_warning)
886 h = (struct elf_link_hash_entry *) h->root.u.i.link;
887
888 symname = h->root.root.string;
889
890 if (h->root.type == bfd_link_hash_defined
891 || h->root.type == bfd_link_hash_defweak)
892 {
893 sec = h->root.u.def.section;
894
895 /* Perhaps we should detect the cases that
896 sec->output_section is expected to be NULL like i386 and
897 m68k, but apparently (and according to elfxx-ia64.c) all
898 valid cases are where the symbol is defined in a shared
899 object which we link dynamically against. This includes
900 PLT relocs for which we've created a PLT entry and other
901 relocs for which we're prepared to create dynamic
902 relocations.
903
904 For now, new situations cause us to just err when
905 sec->output_offset is NULL but the object with the symbol
906 is *not* dynamically linked against. Thus this will
907 automatically remind us so we can see if there are other
908 valid cases we need to revisit. */
909 if ((sec->output_section == NULL
910 && (sec->owner->flags & DYNAMIC) != 0)
911
912 /* Here follow the cases where the relocation value must
913 be zero (or when further handling is simplified when
914 zero). I can't claim to understand the various
915 conditions and they weren't described in the files
916 where I copied them from (elf32-m68k.c and
917 elf32-i386.c), but let's mention examples of where
918 they happen. FIXME: Perhaps define and use a
919 dynamic_symbol_p function like ia64.
920
921 - When creating a shared library, we can have an
922 ordinary relocation for a symbol defined in a shared
923 library (perhaps the one we create). We then make
924 the relocation value zero, as the value seen now will
925 be added into the relocation addend in this shared
926 library, but must be handled only at dynamic-link
927 time. FIXME: Not sure this example covers the
928 h->elf_link_hash_flags test, though it's there in
929 other targets. */
930 || (info->shared
931 && ((! info->symbolic && h->dynindx != -1)
932 || (h->elf_link_hash_flags
933 & ELF_LINK_HASH_DEF_REGULAR) == 0)
934 && (input_section->flags & SEC_ALLOC) != 0
935 && (r_type == R_CRIS_8
936 || r_type == R_CRIS_16
937 || r_type == R_CRIS_32
938 || r_type == R_CRIS_8_PCREL
939 || r_type == R_CRIS_16_PCREL
940 || r_type == R_CRIS_32_PCREL)))
941 relocation = 0;
942 else if (sec->output_section != NULL)
943 relocation = (h->root.u.def.value
944 + sec->output_section->vma
945 + sec->output_offset);
946 else
947 {
948 (*_bfd_error_handler)
949 (_("%s: unresolvable relocation %s against symbol `%s' from %s section"),
950 bfd_archive_filename (input_bfd),
951 cris_elf_howto_table[r_type].name,
952 symname,
953 bfd_get_section_name (input_bfd, input_section));
954 bfd_set_error (bfd_error_bad_value);
955 return false;
956 }
957 }
958 else if (h->root.type == bfd_link_hash_undefweak)
959 relocation = 0;
960 else if (info->shared
961 && (!info->symbolic || info->allow_shlib_undefined)
962 && !info->no_undefined
963 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
964 relocation = 0;
965 else
966 {
967 if (!(info->callbacks->undefined_symbol
968 (info, symname, input_bfd,
969 input_section, rel->r_offset,
970 (!info->shared || info->no_undefined
971 || ELF_ST_VISIBILITY (h->other)))))
972 return false;
973 relocation = 0;
974 }
975 }
976
977 switch (r_type)
978 {
979 case R_CRIS_16_GOTPLT:
980 case R_CRIS_32_GOTPLT:
981 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
982 but we require a PLT, and the PLT handling will take care of
983 filling in the PLT-specific GOT entry. For the GOT offset,
984 calculate it as we do when filling it in for the .got.plt
985 section. If we don't have a PLT, punt to GOT handling. */
986 if (h != NULL
987 && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
988 {
989 asection *sgotplt
990 = bfd_get_section_by_name (dynobj, ".got.plt");
991 bfd_vma got_offset;
992
993 BFD_ASSERT (h->dynindx != -1);
994 BFD_ASSERT (sgotplt != NULL);
995
996 got_offset
997 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
998
999 relocation = got_offset;
1000 break;
1001 }
1002
1003 /* We didn't make a PLT entry for this symbol. Maybe everything is
1004 folded into the GOT. Other than folding, this happens when
1005 statically linking PIC code, or when using -Bsymbolic. Check
1006 that we instead have a GOT entry as done for us by
1007 elf_cris_adjust_dynamic_symbol, and drop through into the
1008 ordinary GOT cases. */
1009 if (h != NULL && h->got.offset == (bfd_vma) -1)
1010 {
1011 (*_bfd_error_handler)
1012 (_("%s: No PLT nor GOT for relocation %s against symbol `%s' from %s section"),
1013 bfd_archive_filename (input_bfd),
1014 cris_elf_howto_table[r_type].name,
1015 symname[0] != '\0' ? symname : _("[whose name is lost]"),
1016 bfd_get_section_name (input_bfd, input_section));
1017
1018 /* FIXME: Perhaps blaming input is not the right thing to
1019 do; this is probably an internal error. But it is true
1020 that we didn't like that particular input. */
1021 bfd_set_error (bfd_error_bad_value);
1022 return false;
1023 }
1024 /* Fall through. */
1025
1026 /* The size of the actual relocation is not used here; we only
1027 fill in the GOT table here. */
1028 case R_CRIS_16_GOT:
1029 case R_CRIS_32_GOT:
1030 {
1031 bfd_vma off;
1032
1033 /* Note that despite using RELA relocations, the .got contents
1034 is always filled in with the link-relative relocation
1035 value; the addend. */
1036
1037 if (h != NULL)
1038 {
1039 off = h->got.offset;
1040 BFD_ASSERT (off != (bfd_vma) -1);
1041
1042 if (!elf_hash_table (info)->dynamic_sections_created
1043 || (! info->shared && h->dynindx == -1)
1044 || (info->shared
1045 && (info->symbolic || h->dynindx == -1)
1046 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1047 {
1048 /* This wasn't checked above for ! info->shared, but
1049 must hold there if we get here; the symbol must be
1050 defined in the regular program, or be undefweak. */
1051 BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1052 || info->shared
1053 || (h->elf_link_hash_flags
1054 & ELF_LINK_HASH_DEF_REGULAR) != 0
1055 || h->root.type == bfd_link_hash_undefweak);
1056
1057 /* This is actually a static link, or it is a
1058 -Bsymbolic link and the symbol is defined locally,
1059 or is undefweak, or the symbol was forced to be
1060 local because of a version file, or we're not
1061 creating a dynamic object. We must initialize this
1062 entry in the global offset table. Since the offset
1063 must always be a multiple of 4, we use the least
1064 significant bit to record whether we have
1065 initialized it already.
1066
1067 If this GOT entry should be runtime-initialized, we
1068 will create a .rela.got relocation entry to
1069 initialize the value. This is done in the
1070 finish_dynamic_symbol routine. */
1071 if ((off & 1) != 0)
1072 off &= ~1;
1073 else
1074 {
1075 bfd_put_32 (output_bfd, relocation,
1076 sgot->contents + off);
1077 h->got.offset |= 1;
1078 }
1079 }
1080 }
1081 else
1082 {
1083 BFD_ASSERT (local_got_offsets != NULL
1084 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1085
1086 off = local_got_offsets[r_symndx];
1087
1088 /* The offset must always be a multiple of 4. We use
1089 the least significant bit to record whether we have
1090 already generated the necessary reloc. */
1091 if ((off & 1) != 0)
1092 off &= ~1;
1093 else
1094 {
1095 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1096
1097 if (info->shared)
1098 {
1099 asection *srelgot;
1100 Elf_Internal_Rela outrel;
1101
1102 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1103 BFD_ASSERT (srelgot != NULL);
1104
1105 outrel.r_offset = (sgot->output_section->vma
1106 + sgot->output_offset
1107 + off);
1108 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1109 outrel.r_addend = relocation;
1110 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1111 (((Elf32_External_Rela *)
1112 srelgot->contents)
1113 + srelgot->reloc_count));
1114 ++srelgot->reloc_count;
1115 }
1116
1117 local_got_offsets[r_symndx] |= 1;
1118 }
1119 }
1120
1121 relocation = sgot->output_offset + off;
1122 if (rel->r_addend != 0)
1123 {
1124 /* We can't do anything for a relocation which is against
1125 a symbol *plus offset*. GOT holds relocations for
1126 symbols. Make this an error; the compiler isn't
1127 allowed to pass us these kinds of things. */
1128 if (h == NULL)
1129 (*_bfd_error_handler)
1130 (_("%s: relocation %s with non-zero addend %d against local symbol from %s section"),
1131 bfd_archive_filename (input_bfd),
1132 cris_elf_howto_table[r_type].name,
1133 rel->r_addend,
1134 bfd_get_section_name (input_bfd, input_section));
1135 else
1136 (*_bfd_error_handler)
1137 (_("%s: relocation %s with non-zero addend %d against symbol `%s' from %s section"),
1138 bfd_archive_filename (input_bfd),
1139 cris_elf_howto_table[r_type].name,
1140 rel->r_addend,
1141 symname[0] != '\0' ? symname : _("[whose name is lost]"),
1142 bfd_get_section_name (input_bfd, input_section));
1143
1144 bfd_set_error (bfd_error_bad_value);
1145 return false;
1146 }
1147 }
1148 break;
1149
1150 case R_CRIS_32_GOTREL:
1151 /* This relocation must only be performed against local symbols. */
1152 if (h != NULL && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1153 {
1154 (*_bfd_error_handler)
1155 (_("%s: relocation %s is not allowed for global symbol: `%s' from %s section"),
1156 bfd_archive_filename (input_bfd),
1157 cris_elf_howto_table[r_type].name,
1158 symname,
1159 bfd_get_section_name (input_bfd, input_section));
1160 bfd_set_error (bfd_error_bad_value);
1161 return false;
1162 }
1163
1164 /* This can happen if we get a link error with the input ELF
1165 variant mismatching the output variant. Emit an error so
1166 it's noticed if it happens elsewhere. */
1167 if (sgot == NULL)
1168 {
1169 (*_bfd_error_handler)
1170 (_("%s: relocation %s in section %s with no GOT created"),
1171 bfd_archive_filename (input_bfd),
1172 cris_elf_howto_table[r_type].name,
1173 bfd_get_section_name (input_bfd, input_section));
1174 bfd_set_error (bfd_error_bad_value);
1175 return false;
1176 }
1177
1178 /* This relocation is like a PC-relative one, except the
1179 reference point is the location of GOT. Note that
1180 sgot->output_offset is not involved in this calculation. We
1181 always want the start of entire .got section, not the
1182 position after the reserved header. */
1183 relocation -= sgot->output_section->vma;
1184 break;
1185
1186 case R_CRIS_32_PLT_PCREL:
1187 /* Relocation is to the entry for this symbol in the
1188 procedure linkage table. */
1189
1190 /* Resolve a PLT_PCREL reloc against a local symbol directly,
1191 without using the procedure linkage table. */
1192 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1193 break;
1194
1195 if (h->plt.offset == (bfd_vma) -1
1196 || splt == NULL)
1197 {
1198 /* We didn't make a PLT entry for this symbol. This
1199 happens when statically linking PIC code, or when
1200 using -Bsymbolic. */
1201 break;
1202 }
1203
1204 relocation = (splt->output_section->vma
1205 + splt->output_offset
1206 + h->plt.offset);
1207 break;
1208
1209 case R_CRIS_32_PLT_GOTREL:
1210 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1211 start of the .got section. See also comment at
1212 R_CRIS_32_GOT. */
1213 relocation -= sgot->output_section->vma;
1214
1215 /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1216 without using the procedure linkage table. */
1217 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1218 break;
1219
1220 if (h->plt.offset == (bfd_vma) -1
1221 || splt == NULL)
1222 {
1223 /* We didn't make a PLT entry for this symbol. This
1224 happens when statically linking PIC code, or when
1225 using -Bsymbolic. */
1226 break;
1227 }
1228
1229 relocation = (splt->output_section->vma
1230 + splt->output_offset
1231 + h->plt.offset
1232 - sgot->output_section->vma);
1233 break;
1234
1235 case R_CRIS_8_PCREL:
1236 case R_CRIS_16_PCREL:
1237 case R_CRIS_32_PCREL:
1238 /* If the symbol was local, we need no shlib-specific handling. */
1239 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1240 break;
1241
1242 /* Fall through. */
1243 case R_CRIS_8:
1244 case R_CRIS_16:
1245 case R_CRIS_32:
1246 if (info->shared
1247 && r_symndx != 0
1248 && (input_section->flags & SEC_ALLOC) != 0
1249 && ((r_type != R_CRIS_8_PCREL
1250 && r_type != R_CRIS_16_PCREL
1251 && r_type != R_CRIS_32_PCREL)
1252 || (!info->symbolic
1253 || (h->elf_link_hash_flags
1254 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1255 {
1256 Elf_Internal_Rela outrel;
1257 boolean skip, relocate;
1258
1259 /* When generating a shared object, these relocations
1260 are copied into the output file to be resolved at run
1261 time. */
1262
1263 if (sreloc == NULL)
1264 {
1265 const char *name;
1266
1267 name = (bfd_elf_string_from_elf_section
1268 (input_bfd,
1269 elf_elfheader (input_bfd)->e_shstrndx,
1270 elf_section_data (input_section)->rel_hdr.sh_name));
1271 if (name == NULL)
1272 return false;
1273
1274 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1275 && strcmp (bfd_get_section_name (input_bfd,
1276 input_section),
1277 name + 5) == 0);
1278
1279 sreloc = bfd_get_section_by_name (dynobj, name);
1280
1281 /* That section should have been created in
1282 cris_elf_check_relocs, but that function will not be
1283 called for objects which fail in
1284 cris_elf_merge_private_bfd_data. */
1285 if (sreloc == NULL)
1286 {
1287 (*_bfd_error_handler)
1288 (_("%s: Internal inconsistency; no relocation section %s"),
1289 bfd_archive_filename (input_bfd),
1290 name);
1291
1292 bfd_set_error (bfd_error_bad_value);
1293 return false;
1294 }
1295 }
1296
1297 skip = false;
1298 relocate = false;
1299
1300 outrel.r_offset =
1301 _bfd_elf_section_offset (output_bfd, info, input_section,
1302 rel->r_offset);
1303 if (outrel.r_offset == (bfd_vma) -1)
1304 skip = true;
1305 else if (outrel.r_offset == (bfd_vma) -2)
1306 skip = true, relocate = true;
1307 outrel.r_offset += (input_section->output_section->vma
1308 + input_section->output_offset);
1309
1310 if (skip)
1311 memset (&outrel, 0, sizeof outrel);
1312 /* h->dynindx may be -1 if the symbol was marked to
1313 become local. */
1314 else if (h != NULL
1315 && ((! info->symbolic && h->dynindx != -1)
1316 || (h->elf_link_hash_flags
1317 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1318 {
1319 BFD_ASSERT (h->dynindx != -1);
1320 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1321 outrel.r_addend = relocation + rel->r_addend;
1322 }
1323 else
1324 {
1325 if (r_type == R_CRIS_32)
1326 {
1327 relocate = true;
1328 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1329 outrel.r_addend = relocation + rel->r_addend;
1330 }
1331 else
1332 {
1333 long indx;
1334
1335 if (h == NULL)
1336 sec = local_sections[r_symndx];
1337 else
1338 {
1339 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1340 || (h->root.type
1341 == bfd_link_hash_defweak));
1342 sec = h->root.u.def.section;
1343 }
1344 if (sec != NULL && bfd_is_abs_section (sec))
1345 indx = 0;
1346 else if (sec == NULL || sec->owner == NULL)
1347 {
1348 bfd_set_error (bfd_error_bad_value);
1349 return false;
1350 }
1351 else
1352 {
1353 asection *osec;
1354
1355 osec = sec->output_section;
1356 indx = elf_section_data (osec)->dynindx;
1357 BFD_ASSERT (indx > 0);
1358 }
1359
1360 outrel.r_info = ELF32_R_INFO (indx, r_type);
1361 outrel.r_addend = relocation + rel->r_addend;
1362 }
1363 }
1364
1365 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1366 (((Elf32_External_Rela *)
1367 sreloc->contents)
1368 + sreloc->reloc_count));
1369 ++sreloc->reloc_count;
1370
1371 /* This reloc will be computed at runtime, so there's no
1372 need to do anything now, except for R_CRIS_32 relocations
1373 that have been turned into R_CRIS_RELATIVE. */
1374 if (!relocate)
1375 continue;
1376 }
1377
1378 break;
1379 }
1380
1381 r = cris_final_link_relocate (howto, input_bfd, input_section,
1382 contents, rel, relocation);
1383
1384 if (r != bfd_reloc_ok)
1385 {
1386 const char * msg = (const char *) NULL;
1387
1388 switch (r)
1389 {
1390 case bfd_reloc_overflow:
1391 r = info->callbacks->reloc_overflow
1392 (info, symname, howto->name, (bfd_vma) 0,
1393 input_bfd, input_section, rel->r_offset);
1394 break;
1395
1396 case bfd_reloc_undefined:
1397 r = info->callbacks->undefined_symbol
1398 (info, symname, input_bfd, input_section, rel->r_offset,
1399 true);
1400 break;
1401
1402 case bfd_reloc_outofrange:
1403 msg = _("internal error: out of range error");
1404 break;
1405
1406 case bfd_reloc_notsupported:
1407 msg = _("internal error: unsupported relocation error");
1408 break;
1409
1410 case bfd_reloc_dangerous:
1411 msg = _("internal error: dangerous relocation");
1412 break;
1413
1414 default:
1415 msg = _("internal error: unknown error");
1416 break;
1417 }
1418
1419 if (msg)
1420 r = info->callbacks->warning
1421 (info, msg, symname, input_bfd, input_section, rel->r_offset);
1422
1423 if (! r)
1424 return false;
1425 }
1426 }
1427
1428 return true;
1429 }
1430 \f
1431 /* Finish up dynamic symbol handling. We set the contents of various
1432 dynamic sections here. */
1433
1434 static boolean
1435 elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
1436 bfd *output_bfd;
1437 struct bfd_link_info *info;
1438 struct elf_link_hash_entry *h;
1439 Elf_Internal_Sym *sym;
1440 {
1441 bfd *dynobj;
1442 int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
1443
1444 dynobj = elf_hash_table (info)->dynobj;
1445
1446 if (h->plt.offset != (bfd_vma) -1)
1447 {
1448 asection *splt;
1449 asection *sgotplt;
1450 asection *sgot;
1451 asection *srela;
1452 bfd_vma got_base;
1453
1454 bfd_vma gotplt_offset
1455 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1456 Elf_Internal_Rela rela;
1457 boolean has_gotplt = gotplt_offset != 0;
1458
1459 /* Get the index in the procedure linkage table which
1460 corresponds to this symbol. This is the index of this symbol
1461 in all the symbols for which we are making plt entries. The
1462 first entry in the procedure linkage table is reserved. */
1463 /* We have to count backwards here, and the result is only valid as
1464 an index into .got.plt and its relocations. FIXME: Constants... */
1465 bfd_vma gotplt_index = gotplt_offset/4 - 3;
1466
1467 /* Get the offset into the .got table of the entry that corresponds
1468 to this function. Note that we embed knowledge that "incoming"
1469 .got goes after .got.plt in the output without padding (pointer
1470 aligned). However, that knowledge is present in several other
1471 places too, here and in elflink.h at least. */
1472 bfd_vma got_offset
1473 = (has_gotplt
1474 ? gotplt_offset
1475 : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
1476
1477 /* This symbol has an entry in the procedure linkage table. Set it
1478 up. */
1479
1480 BFD_ASSERT (h->dynindx != -1);
1481
1482 splt = bfd_get_section_by_name (dynobj, ".plt");
1483 sgot = bfd_get_section_by_name (dynobj, ".got");
1484 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1485 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1486 BFD_ASSERT (splt != NULL && sgotplt != NULL
1487 && (! has_gotplt || srela != NULL));
1488
1489 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1490
1491 /* Fill in the entry in the procedure linkage table. */
1492 if (! info->shared)
1493 {
1494 memcpy (splt->contents + h->plt.offset, elf_cris_plt_entry,
1495 PLT_ENTRY_SIZE);
1496
1497 /* We need to enter the absolute address of the GOT entry here. */
1498 bfd_put_32 (output_bfd, got_base + got_offset,
1499 splt->contents + h->plt.offset + plt_off1);
1500 }
1501 else
1502 {
1503 memcpy (splt->contents + h->plt.offset, elf_cris_pic_plt_entry,
1504 PLT_ENTRY_SIZE);
1505 bfd_put_32 (output_bfd, got_offset,
1506 splt->contents + h->plt.offset + plt_off1);
1507 }
1508
1509 /* Fill in the plt entry and make a relocation, if this is a "real"
1510 PLT entry. */
1511 if (has_gotplt)
1512 {
1513 /* Fill in the offset into the reloc table. */
1514 bfd_put_32 (output_bfd,
1515 gotplt_index * sizeof (Elf32_External_Rela),
1516 splt->contents + h->plt.offset + plt_off2);
1517
1518 /* Fill in the offset to the first PLT entry, where to "jump". */
1519 bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3 + 4),
1520 splt->contents + h->plt.offset + plt_off3);
1521
1522 /* Fill in the entry in the global offset table with the address of
1523 the relocating stub. */
1524 bfd_put_32 (output_bfd,
1525 (splt->output_section->vma
1526 + splt->output_offset
1527 + h->plt.offset
1528 + 8),
1529 sgotplt->contents + got_offset);
1530
1531 /* Fill in the entry in the .rela.plt section. */
1532 rela.r_offset = (sgotplt->output_section->vma
1533 + sgotplt->output_offset
1534 + got_offset);
1535 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
1536 rela.r_addend = 0;
1537 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1538 ((Elf32_External_Rela *) srela->contents
1539 + gotplt_index));
1540 }
1541
1542 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1543 {
1544 /* Mark the symbol as undefined, rather than as defined in
1545 the .plt section. Leave the value alone. */
1546 sym->st_shndx = SHN_UNDEF;
1547
1548 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1549 know whether resetting the value is significant; if it really
1550 is, rather than a quirk or bug in the sparc port, then I
1551 believe we'd see this elsewhere. */
1552 /* If the symbol is weak, we do need to clear the value.
1553 Otherwise, the PLT entry would provide a definition for
1554 the symbol even if the symbol wasn't defined anywhere,
1555 and so the symbol would never be NULL. */
1556 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1557 == 0)
1558 sym->st_value = 0;
1559 }
1560 }
1561
1562 /* We don't emit .got relocs for symbols that aren't in the
1563 dynamic-symbols table for an ordinary program and are either defined
1564 by the program or are undefined weak symbols. */
1565 if (h->got.offset != (bfd_vma) -1
1566 && (info->shared
1567 || (h->dynindx != -1
1568 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1569 && h->root.type != bfd_link_hash_undefweak)))
1570 {
1571 asection *sgot;
1572 asection *srela;
1573 Elf_Internal_Rela rela;
1574 bfd_byte *where;
1575
1576 /* This symbol has an entry in the global offset table. Set it up. */
1577
1578 sgot = bfd_get_section_by_name (dynobj, ".got");
1579 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1580 BFD_ASSERT (sgot != NULL && srela != NULL);
1581
1582 rela.r_offset = (sgot->output_section->vma
1583 + sgot->output_offset
1584 + (h->got.offset &~ (bfd_vma) 1));
1585
1586 /* If this is a static link, or it is a -Bsymbolic link and the
1587 symbol is defined locally or was forced to be local because
1588 of a version file, we just want to emit a RELATIVE reloc.
1589 The entry in the global offset table will already have been
1590 initialized in the relocate_section function. */
1591 where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
1592 if (! elf_hash_table (info)->dynamic_sections_created
1593 || (info->shared
1594 && (info->symbolic || h->dynindx == -1)
1595 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1596 {
1597 rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1598 rela.r_addend = bfd_get_signed_32 (output_bfd, where);
1599 }
1600 else
1601 {
1602 bfd_put_32 (output_bfd, (bfd_vma) 0, where);
1603 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
1604 rela.r_addend = 0;
1605 }
1606
1607 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1608 ((Elf32_External_Rela *) srela->contents
1609 + srela->reloc_count));
1610 ++srela->reloc_count;
1611 }
1612
1613 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1614 {
1615 asection *s;
1616 Elf_Internal_Rela rela;
1617
1618 /* This symbol needs a copy reloc. Set it up. */
1619
1620 BFD_ASSERT (h->dynindx != -1
1621 && (h->root.type == bfd_link_hash_defined
1622 || h->root.type == bfd_link_hash_defweak));
1623
1624 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1625 ".rela.bss");
1626 BFD_ASSERT (s != NULL);
1627
1628 rela.r_offset = (h->root.u.def.value
1629 + h->root.u.def.section->output_section->vma
1630 + h->root.u.def.section->output_offset);
1631 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
1632 rela.r_addend = 0;
1633 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1634 ((Elf32_External_Rela *) s->contents
1635 + s->reloc_count));
1636 ++s->reloc_count;
1637 }
1638
1639 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1640 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1641 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1642 sym->st_shndx = SHN_ABS;
1643
1644 return true;
1645 }
1646 \f
1647 /* Finish up the dynamic sections. */
1648
1649 static boolean
1650 elf_cris_finish_dynamic_sections (output_bfd, info)
1651 bfd *output_bfd;
1652 struct bfd_link_info *info;
1653 {
1654 bfd *dynobj;
1655 asection *sgot;
1656 asection *sdyn;
1657
1658 dynobj = elf_hash_table (info)->dynobj;
1659
1660 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1661 BFD_ASSERT (sgot != NULL);
1662 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1663
1664 if (elf_hash_table (info)->dynamic_sections_created)
1665 {
1666 asection *splt;
1667 Elf32_External_Dyn *dyncon, *dynconend;
1668
1669 splt = bfd_get_section_by_name (dynobj, ".plt");
1670 BFD_ASSERT (splt != NULL && sdyn != NULL);
1671
1672 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1673 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1674 for (; dyncon < dynconend; dyncon++)
1675 {
1676 Elf_Internal_Dyn dyn;
1677 asection *s;
1678
1679 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1680
1681 switch (dyn.d_tag)
1682 {
1683 default:
1684 break;
1685
1686 case DT_PLTGOT:
1687 s = bfd_get_section_by_name (output_bfd, ".got");
1688 BFD_ASSERT (s != NULL);
1689 dyn.d_un.d_ptr = s->vma;
1690 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1691 break;
1692
1693 case DT_JMPREL:
1694 /* Yes, we *can* have a .plt and no .plt.rela, for instance
1695 if all symbols are found in the .got (not .got.plt). */
1696 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1697 dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
1698 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1699 break;
1700
1701 case DT_PLTRELSZ:
1702 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1703 if (s == NULL)
1704 dyn.d_un.d_val = 0;
1705 else if (s->_cooked_size != 0)
1706 dyn.d_un.d_val = s->_cooked_size;
1707 else
1708 dyn.d_un.d_val = s->_raw_size;
1709 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1710 break;
1711
1712 case DT_RELASZ:
1713 /* The procedure linkage table relocs (DT_JMPREL) should
1714 not be included in the overall relocs (DT_RELA).
1715 Therefore, we override the DT_RELASZ entry here to
1716 make it not include the JMPREL relocs. Since the
1717 linker script arranges for .rela.plt to follow all
1718 other relocation sections, we don't have to worry
1719 about changing the DT_RELA entry. */
1720 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1721 if (s != NULL)
1722 {
1723 if (s->_cooked_size != 0)
1724 dyn.d_un.d_val -= s->_cooked_size;
1725 else
1726 dyn.d_un.d_val -= s->_raw_size;
1727 }
1728 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1729 break;
1730 }
1731 }
1732
1733 /* Fill in the first entry in the procedure linkage table. */
1734 if (splt->_raw_size > 0)
1735 {
1736 if (info->shared)
1737 memcpy (splt->contents, elf_cris_pic_plt0_entry, PLT_ENTRY_SIZE);
1738 else
1739 {
1740 memcpy (splt->contents, elf_cris_plt0_entry, PLT_ENTRY_SIZE);
1741 bfd_put_32 (output_bfd,
1742 sgot->output_section->vma + sgot->output_offset + 4,
1743 splt->contents + 6);
1744 bfd_put_32 (output_bfd,
1745 sgot->output_section->vma + sgot->output_offset + 8,
1746 splt->contents + 14);
1747
1748 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1749 = PLT_ENTRY_SIZE;
1750 }
1751 }
1752 }
1753
1754 /* Fill in the first three entries in the global offset table. */
1755 if (sgot->_raw_size > 0)
1756 {
1757 if (sdyn == NULL)
1758 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1759 else
1760 bfd_put_32 (output_bfd,
1761 sdyn->output_section->vma + sdyn->output_offset,
1762 sgot->contents);
1763 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1764 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1765 }
1766
1767 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1768
1769 return true;
1770 }
1771 \f
1772 /* Return the section that should be marked against GC for a given
1773 relocation. */
1774
1775 static asection *
1776 cris_elf_gc_mark_hook (sec, info, rel, h, sym)
1777 asection * sec;
1778 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1779 Elf_Internal_Rela * rel;
1780 struct elf_link_hash_entry * h;
1781 Elf_Internal_Sym * sym;
1782 {
1783 if (h != NULL)
1784 {
1785 switch (ELF32_R_TYPE (rel->r_info))
1786 {
1787 case R_CRIS_GNU_VTINHERIT:
1788 case R_CRIS_GNU_VTENTRY:
1789 break;
1790
1791 default:
1792 switch (h->root.type)
1793 {
1794 case bfd_link_hash_defined:
1795 case bfd_link_hash_defweak:
1796 return h->root.u.def.section;
1797
1798 case bfd_link_hash_common:
1799 return h->root.u.c.p->section;
1800
1801 default:
1802 break;
1803 }
1804 }
1805 }
1806 else
1807 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1808
1809 return NULL;
1810 }
1811
1812 /* Update the got entry reference counts for the section being removed. */
1813
1814 static boolean
1815 cris_elf_gc_sweep_hook (abfd, info, sec, relocs)
1816 bfd * abfd ATTRIBUTE_UNUSED;
1817 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1818 asection * sec ATTRIBUTE_UNUSED;
1819 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
1820 {
1821 Elf_Internal_Shdr *symtab_hdr;
1822 struct elf_link_hash_entry **sym_hashes;
1823 bfd_signed_vma *local_got_refcounts;
1824 const Elf_Internal_Rela *rel, *relend;
1825 unsigned long r_symndx;
1826 struct elf_link_hash_entry *h;
1827 bfd *dynobj;
1828 asection *sgot;
1829 asection *srelgot;
1830
1831 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1832 sym_hashes = elf_sym_hashes (abfd);
1833 local_got_refcounts = elf_local_got_refcounts (abfd);
1834
1835 dynobj = elf_hash_table (info)->dynobj;
1836 if (dynobj == NULL)
1837 return true;
1838
1839 sgot = bfd_get_section_by_name (dynobj, ".got");
1840 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1841
1842 relend = relocs + sec->reloc_count;
1843 for (rel = relocs; rel < relend; rel++)
1844 {
1845 switch (ELF32_R_TYPE (rel->r_info))
1846 {
1847 case R_CRIS_16_GOT:
1848 case R_CRIS_32_GOT:
1849 r_symndx = ELF32_R_SYM (rel->r_info);
1850 if (r_symndx >= symtab_hdr->sh_info)
1851 {
1852 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1853 if (h->got.refcount > 0)
1854 {
1855 --h->got.refcount;
1856 if (h->got.refcount == 0)
1857 {
1858 /* We don't need the .got entry any more. */
1859 sgot->_raw_size -= 4;
1860 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1861 }
1862 }
1863 break;
1864 }
1865
1866 local_got_reloc:
1867 if (local_got_refcounts != NULL)
1868 {
1869 if (local_got_refcounts[r_symndx] > 0)
1870 {
1871 --local_got_refcounts[r_symndx];
1872 if (local_got_refcounts[r_symndx] == 0)
1873 {
1874 /* We don't need the .got entry any more. */
1875 sgot->_raw_size -= 4;
1876 if (info->shared)
1877 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1878 }
1879 }
1880 }
1881 break;
1882
1883 case R_CRIS_16_GOTPLT:
1884 case R_CRIS_32_GOTPLT:
1885 /* For local symbols, treat these like GOT relocs. */
1886 r_symndx = ELF32_R_SYM (rel->r_info);
1887 if (r_symndx < symtab_hdr->sh_info)
1888 goto local_got_reloc;
1889
1890 case R_CRIS_32_PLT_GOTREL:
1891 /* FIXME: We don't garbage-collect away the .got section. */
1892 if (local_got_refcounts != NULL)
1893 local_got_refcounts[-1]--;
1894 /* Fall through. */
1895
1896 case R_CRIS_8_PCREL:
1897 case R_CRIS_16_PCREL:
1898 case R_CRIS_32_PCREL:
1899 case R_CRIS_32_PLT_PCREL:
1900 r_symndx = ELF32_R_SYM (rel->r_info);
1901 if (r_symndx >= symtab_hdr->sh_info)
1902 {
1903 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1904 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1905 && h->plt.refcount > 0)
1906 --h->plt.refcount;
1907 }
1908 break;
1909
1910 default:
1911 break;
1912 }
1913 }
1914
1915 return true;
1916 }
1917
1918 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1919 entry but we found we will not create any. Called when we find we will
1920 not have any PLT for this symbol, by for example
1921 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
1922 or elf_cris_size_dynamic_sections if no dynamic sections will be
1923 created (we're only linking static objects). */
1924
1925 static boolean
1926 elf_cris_adjust_gotplt_to_got (h, p)
1927 struct elf_cris_link_hash_entry *h;
1928 PTR p;
1929 {
1930 struct bfd_link_info *info = (struct bfd_link_info *) p;
1931 bfd *dynobj = elf_hash_table (info)->dynobj;
1932
1933 BFD_ASSERT (dynobj != NULL);
1934
1935 if (h->root.root.type == bfd_link_hash_warning)
1936 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
1937
1938 /* If nobody wanted a GOTPLT with this symbol, we're done. */
1939 if (h->gotplt_refcount <= 0)
1940 return true;
1941
1942 if (h->root.got.refcount > 0)
1943 {
1944 /* There's a GOT entry for this symbol. Just adjust the refcount.
1945 Probably not necessary at this stage, but keeping it accurate
1946 helps avoiding surprises later. */
1947 h->root.got.refcount += h->gotplt_refcount;
1948 h->gotplt_refcount = -1;
1949 }
1950 else
1951 {
1952 /* No GOT entry for this symbol. We need to create one. */
1953 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1954 asection *srelgot
1955 = bfd_get_section_by_name (dynobj, ".rela.got");
1956
1957 /* Put an accurate refcount there. */
1958 h->root.got.refcount = h->gotplt_refcount;
1959
1960 h->gotplt_refcount = -1;
1961
1962 /* We always have a .got and a .rela.got section if there were
1963 GOTPLT relocs in input. */
1964 BFD_ASSERT (sgot != NULL && srelgot != NULL);
1965
1966 /* Allocate space in the .got section. */
1967 sgot->_raw_size += 4;
1968
1969 /* Allocate relocation space. */
1970 srelgot->_raw_size += sizeof (Elf32_External_Rela);
1971 }
1972
1973 return true;
1974 }
1975
1976 /* Try to fold PLT entries with GOT entries. There are two cases when we
1977 want to do this:
1978
1979 - When all PLT references are GOTPLT references, and there are GOT
1980 references. We don't have to generate a PLT at all.
1981
1982 - When there are both (ordinary) PLT references and GOT references.
1983 We want to make the PLT reference use the ordinary GOT entry rather
1984 than a run-time dynamically resolved GOTPLT entry (since the GOT
1985 entry will have to be resolved at startup anyway).
1986
1987 Though the latter case is handled when room for the PLT is allocated,
1988 not here.
1989
1990 Note that this function is called before symbols are forced local by
1991 version scripts. The differing cases are handled by
1992 elf_cris_hide_symbol. */
1993
1994 static boolean
1995 elf_cris_try_fold_plt_to_got (h, p)
1996 struct elf_cris_link_hash_entry *h;
1997 PTR p;
1998 {
1999 struct bfd_link_info *info = (struct bfd_link_info *) p;
2000
2001 /* If there are no GOT references for this symbol, we can't fold any
2002 other reference so there's nothing to do. Likewise if there are no
2003 PLT references; GOTPLT references included. */
2004 if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
2005 return true;
2006
2007 /* GOTPLT relocs are supposed to be included into the PLT refcount. */
2008 BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
2009
2010 if (h->gotplt_refcount == h->root.plt.refcount)
2011 {
2012 /* The only PLT references are GOTPLT references, and there are GOT
2013 references. Convert PLT to GOT references. */
2014 if (! elf_cris_adjust_gotplt_to_got (h, info))
2015 return false;
2016
2017 /* Clear the PLT references, so no PLT will be created. */
2018 h->root.plt.offset = (bfd_vma) -1;
2019 }
2020
2021 return true;
2022 }
2023
2024 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2025 to use a GOT entry (and create one) rather than requiring a GOTPLT
2026 entry. */
2027
2028 static void
2029 elf_cris_hide_symbol (info, h, force_local)
2030 struct bfd_link_info *info;
2031 struct elf_link_hash_entry *h;
2032 boolean force_local;
2033 {
2034 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2035
2036 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2037 }
2038
2039 /* Adjust a symbol defined by a dynamic object and referenced by a
2040 regular object. The current definition is in some section of the
2041 dynamic object, but we're not including those sections. We have to
2042 change the definition to something the rest of the link can
2043 understand. */
2044
2045 static boolean
2046 elf_cris_adjust_dynamic_symbol (info, h)
2047 struct bfd_link_info *info;
2048 struct elf_link_hash_entry *h;
2049 {
2050 bfd *dynobj;
2051 asection *s;
2052 unsigned int power_of_two;
2053
2054 dynobj = elf_hash_table (info)->dynobj;
2055
2056 /* Make sure we know what is going on here. */
2057 BFD_ASSERT (dynobj != NULL
2058 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2059 || h->weakdef != NULL
2060 || ((h->elf_link_hash_flags
2061 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2062 && (h->elf_link_hash_flags
2063 & ELF_LINK_HASH_REF_REGULAR) != 0
2064 && (h->elf_link_hash_flags
2065 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2066
2067 /* If this is a function, put it in the procedure linkage table. We
2068 will fill in the contents of the procedure linkage table later,
2069 when we know the address of the .got section. */
2070 if (h->type == STT_FUNC
2071 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2072 {
2073 /* If we link a program (not a DSO), we'll get rid of unnecessary
2074 PLT entries; we point to the actual symbols -- even for pic
2075 relocs, because a program built with -fpic should have the same
2076 result as one built without -fpic, specifically considering weak
2077 symbols.
2078 FIXME: m68k and i386 differ here, for unclear reasons. */
2079 if (! info->shared
2080 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
2081 {
2082 /* This case can occur if we saw a PLT reloc in an input file,
2083 but the symbol was not defined by a dynamic object. In such
2084 a case, we don't actually need to build a procedure linkage
2085 table, and we can just do an absolute or PC reloc instead, or
2086 change a .got.plt index to a .got index for GOTPLT relocs. */
2087 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2088 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2089 h->plt.offset = (bfd_vma) -1;
2090 return
2091 elf_cris_adjust_gotplt_to_got ((struct
2092 elf_cris_link_hash_entry *) h,
2093 info);
2094 }
2095
2096 /* If there are only GOT references and GOTPLT references to this
2097 PLT entry, get rid of the PLT. */
2098 if (! elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry *)
2099 h, info))
2100 return false;
2101
2102 /* GC or folding may have rendered this entry unused. */
2103 if (h->plt.refcount <= 0)
2104 {
2105 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2106 h->plt.offset = (bfd_vma) -1;
2107 return true;
2108 }
2109
2110 /* Make sure this symbol is output as a dynamic symbol. */
2111 if (h->dynindx == -1)
2112 {
2113 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2114 return false;
2115 }
2116
2117 s = bfd_get_section_by_name (dynobj, ".plt");
2118 BFD_ASSERT (s != NULL);
2119
2120 /* If this is the first .plt entry, make room for the special
2121 first entry. */
2122 if (s->_raw_size == 0)
2123 s->_raw_size += PLT_ENTRY_SIZE;
2124
2125 /* If this symbol is not defined in a regular file, and we are
2126 not generating a shared library, then set the symbol to this
2127 location in the .plt. */
2128 if (!info->shared
2129 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2130 {
2131 h->root.u.def.section = s;
2132 h->root.u.def.value = s->_raw_size;
2133 }
2134
2135 /* If there's already a GOT entry, use that, not a .got.plt. A
2136 GOT field still has a reference count when we get here; it's
2137 not yet changed to an offset. */
2138 if (h->got.refcount > 0)
2139 {
2140 h->got.refcount += h->plt.refcount;
2141
2142 /* Mark the PLT offset to use the GOT entry by setting the low
2143 bit in the plt offset; it is always a multiple of
2144 pointer-size. */
2145 BFD_ASSERT ((s->_raw_size & 3) == 0);
2146
2147 /* Change the PLT refcount to an offset. */
2148 h->plt.offset = s->_raw_size;
2149
2150 /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2151 that the got entry should be used instead. */
2152 BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2153 h)->gotplt_offset == 0);
2154
2155 /* Make room for this entry. */
2156 s->_raw_size += PLT_ENTRY_SIZE;
2157
2158 return true;
2159 }
2160
2161 /* No GOT reference for this symbol; prepare for an ordinary PLT. */
2162 h->plt.offset = s->_raw_size;
2163
2164 /* Make room for this entry. */
2165 s->_raw_size += PLT_ENTRY_SIZE;
2166
2167 /* We also need to make an entry in the .got.plt section, which
2168 will be placed in the .got section by the linker script. */
2169 ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2170 = elf_cris_hash_table (info)->next_gotplt_entry;
2171 elf_cris_hash_table (info)->next_gotplt_entry += 4;
2172
2173 s = bfd_get_section_by_name (dynobj, ".got.plt");
2174 BFD_ASSERT (s != NULL);
2175 s->_raw_size += 4;
2176
2177 /* We also need to make an entry in the .rela.plt section. */
2178
2179 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2180 BFD_ASSERT (s != NULL);
2181 s->_raw_size += sizeof (Elf32_External_Rela);
2182
2183 return true;
2184 }
2185
2186 /* Reinitialize the plt offset now that it is not used as a reference
2187 count any more. */
2188 h->plt.offset = (bfd_vma) -1;
2189
2190 /* If this is a weak symbol, and there is a real definition, the
2191 processor independent code will have arranged for us to see the
2192 real definition first, and we can just use the same value. */
2193 if (h->weakdef != NULL)
2194 {
2195 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2196 || h->weakdef->root.type == bfd_link_hash_defweak);
2197 h->root.u.def.section = h->weakdef->root.u.def.section;
2198 h->root.u.def.value = h->weakdef->root.u.def.value;
2199 return true;
2200 }
2201
2202 /* This is a reference to a symbol defined by a dynamic object which
2203 is not a function. */
2204
2205 /* If we are creating a shared library, we must presume that the
2206 only references to the symbol are via the global offset table.
2207 For such cases we need not do anything here; the relocations will
2208 be handled correctly by relocate_section. */
2209 if (info->shared)
2210 return true;
2211
2212 /* If there are no references to this symbol that do not use the
2213 GOT, we don't need to generate a copy reloc. */
2214 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2215 return true;
2216
2217 /* We must allocate the symbol in our .dynbss section, which will
2218 become part of the .bss section of the executable. There will be
2219 an entry for this symbol in the .dynsym section. The dynamic
2220 object will contain position independent code, so all references
2221 from the dynamic object to this symbol will go through the global
2222 offset table. The dynamic linker will use the .dynsym entry to
2223 determine the address it must put in the global offset table, so
2224 both the dynamic object and the regular object will refer to the
2225 same memory location for the variable. */
2226
2227 s = bfd_get_section_by_name (dynobj, ".dynbss");
2228 BFD_ASSERT (s != NULL);
2229
2230 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2231 copy the initial value out of the dynamic object and into the
2232 runtime process image. We need to remember the offset into the
2233 .rela.bss section we are going to use. */
2234 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2235 {
2236 asection *srel;
2237
2238 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2239 BFD_ASSERT (srel != NULL);
2240 srel->_raw_size += sizeof (Elf32_External_Rela);
2241 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2242 }
2243
2244 /* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2245 thing to copy; so do we. */
2246
2247 /* We need to figure out the alignment required for this symbol. I
2248 have no idea how ELF linkers handle this. */
2249 power_of_two = bfd_log2 (h->size);
2250 if (power_of_two > 3)
2251 power_of_two = 3;
2252
2253 /* Apply the required alignment. */
2254 s->_raw_size = BFD_ALIGN (s->_raw_size,
2255 (bfd_size_type) (1 << power_of_two));
2256 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2257 {
2258 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
2259 return false;
2260 }
2261
2262 /* Define the symbol as being at this point in the section. */
2263 h->root.u.def.section = s;
2264 h->root.u.def.value = s->_raw_size;
2265
2266 /* Increment the section size to make room for the symbol. */
2267 s->_raw_size += h->size;
2268
2269 return true;
2270 }
2271
2272 /* Look through the relocs for a section during the first phase. */
2273
2274 static boolean
2275 cris_elf_check_relocs (abfd, info, sec, relocs)
2276 bfd *abfd;
2277 struct bfd_link_info *info;
2278 asection *sec;
2279 const Elf_Internal_Rela *relocs;
2280 {
2281 bfd *dynobj;
2282 Elf_Internal_Shdr *symtab_hdr;
2283 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2284 bfd_signed_vma *local_got_refcounts;
2285 const Elf_Internal_Rela *rel;
2286 const Elf_Internal_Rela *rel_end;
2287 asection *sgot;
2288 asection *srelgot;
2289 asection *sreloc;
2290
2291 if (info->relocateable)
2292 return true;
2293
2294 dynobj = elf_hash_table (info)->dynobj;
2295 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2296 sym_hashes = elf_sym_hashes (abfd);
2297 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2298 local_got_refcounts = elf_local_got_refcounts (abfd);
2299
2300 sgot = NULL;
2301 srelgot = NULL;
2302 sreloc = NULL;
2303
2304 if (!elf_bad_symtab (abfd))
2305 sym_hashes_end -= symtab_hdr->sh_info;
2306
2307 rel_end = relocs + sec->reloc_count;
2308 for (rel = relocs; rel < rel_end; rel++)
2309 {
2310 struct elf_link_hash_entry *h;
2311 unsigned long r_symndx;
2312 enum elf_cris_reloc_type r_type;
2313
2314 r_symndx = ELF32_R_SYM (rel->r_info);
2315 if (r_symndx < symtab_hdr->sh_info)
2316 h = NULL;
2317 else
2318 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2319
2320 r_type = ELF32_R_TYPE (rel->r_info);
2321
2322 /* Some relocs require linker-created sections; we need to hang them
2323 on the first input bfd we found that contained dynamic relocs. */
2324 switch (r_type)
2325 {
2326 case R_CRIS_16_GOT:
2327 case R_CRIS_32_GOT:
2328 case R_CRIS_32_GOTREL:
2329 case R_CRIS_32_PLT_GOTREL:
2330 case R_CRIS_32_PLT_PCREL:
2331 case R_CRIS_16_GOTPLT:
2332 case R_CRIS_32_GOTPLT:
2333 if (dynobj == NULL)
2334 {
2335 elf_hash_table (info)->dynobj = dynobj = abfd;
2336
2337 /* Create the .got section, so we can assume it's always
2338 present whenever there's a dynobj. */
2339 if (!_bfd_elf_create_got_section (dynobj, info))
2340 return false;
2341 }
2342 break;
2343
2344 default:
2345 break;
2346 }
2347
2348 /* Some relocs require a global offset table (but perhaps not a
2349 specific GOT entry). */
2350 switch (r_type)
2351 {
2352 /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
2353 entry only for local symbols. Unfortunately, we don't know
2354 until later on if there's a version script that forces the
2355 symbol local. We must have the .rela.got section in place
2356 before we know if the symbol looks global now, so we need
2357 to treat the reloc just like for R_CRIS_16_GOT and
2358 R_CRIS_32_GOT. */
2359 case R_CRIS_16_GOTPLT:
2360 case R_CRIS_32_GOTPLT:
2361 case R_CRIS_16_GOT:
2362 case R_CRIS_32_GOT:
2363 if (srelgot == NULL
2364 && (h != NULL || info->shared))
2365 {
2366 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2367 if (srelgot == NULL)
2368 {
2369 srelgot = bfd_make_section (dynobj, ".rela.got");
2370 if (srelgot == NULL
2371 || !bfd_set_section_flags (dynobj, srelgot,
2372 (SEC_ALLOC
2373 | SEC_LOAD
2374 | SEC_HAS_CONTENTS
2375 | SEC_IN_MEMORY
2376 | SEC_LINKER_CREATED
2377 | SEC_READONLY))
2378 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2379 return false;
2380 }
2381 }
2382 /* Fall through. */
2383
2384 case R_CRIS_32_GOTREL:
2385 case R_CRIS_32_PLT_GOTREL:
2386 if (sgot == NULL)
2387 sgot = bfd_get_section_by_name (dynobj, ".got");
2388
2389 if (local_got_refcounts == NULL)
2390 {
2391 bfd_size_type amt;
2392
2393 /* We use index local_got_refcounts[-1] to count all
2394 GOT-relative relocations that do not have explicit
2395 GOT entries. */
2396 amt = symtab_hdr->sh_info + 1;
2397 amt *= sizeof (bfd_signed_vma);
2398 local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
2399 if (local_got_refcounts == NULL)
2400 return false;
2401
2402 local_got_refcounts++;
2403 elf_local_got_refcounts (abfd) = local_got_refcounts;
2404 }
2405 break;
2406
2407 default:
2408 break;
2409 }
2410
2411 switch (r_type)
2412 {
2413 case R_CRIS_16_GOTPLT:
2414 case R_CRIS_32_GOTPLT:
2415 /* Mark that we need a GOT entry if the PLT entry (and its GOT
2416 entry) is eliminated. We can only do this for a non-local
2417 symbol. */
2418 if (h != NULL)
2419 {
2420 ((struct elf_cris_link_hash_entry *) h)->gotplt_refcount++;
2421 goto handle_gotplt_reloc;
2422 }
2423 /* If h is NULL then this is a local symbol, and we must make a
2424 GOT entry for it, so handle it like a GOT reloc. */
2425 /* Fall through. */
2426
2427 case R_CRIS_16_GOT:
2428 case R_CRIS_32_GOT:
2429 /* This symbol requires a global offset table entry. */
2430 if (h != NULL)
2431 {
2432 if (h->got.refcount == 0)
2433 {
2434 /* Make sure this symbol is output as a dynamic symbol. */
2435 if (h->dynindx == -1)
2436 {
2437 if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2438 return false;
2439 }
2440
2441 /* Allocate space in the .got section. */
2442 sgot->_raw_size += 4;
2443 /* Allocate relocation space. */
2444 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2445 }
2446 h->got.refcount++;
2447 }
2448 else
2449 {
2450 /* This is a global offset table entry for a local symbol. */
2451 if (local_got_refcounts[r_symndx] == 0)
2452 {
2453 sgot->_raw_size += 4;
2454 if (info->shared)
2455 {
2456 /* If we are generating a shared object, we need to
2457 output a R_CRIS_RELATIVE reloc so that the dynamic
2458 linker can adjust this GOT entry. */
2459 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2460 }
2461 }
2462 local_got_refcounts[r_symndx]++;
2463 }
2464 break;
2465
2466 case R_CRIS_32_GOTREL:
2467 /* This reference requires a global offset table.
2468 FIXME: The actual refcount isn't used currently; the .got
2469 section can't be removed if there were any references in the
2470 input. */
2471 local_got_refcounts[-1]++;
2472 break;
2473
2474 handle_gotplt_reloc:
2475
2476 case R_CRIS_32_PLT_GOTREL:
2477 /* This reference requires a global offset table. */
2478 local_got_refcounts[-1]++;
2479 /* Fall through. */
2480
2481 case R_CRIS_32_PLT_PCREL:
2482 /* This symbol requires a procedure linkage table entry. We
2483 actually build the entry in adjust_dynamic_symbol,
2484 because this might be a case of linking PIC code which is
2485 never referenced by a dynamic object, in which case we
2486 don't need to generate a procedure linkage table entry
2487 after all. */
2488
2489 /* If this is a local symbol, we resolve it directly without
2490 creating a procedure linkage table entry. */
2491 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2492 continue;
2493
2494 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2495 h->plt.refcount++;
2496 break;
2497
2498 case R_CRIS_8:
2499 case R_CRIS_16:
2500 case R_CRIS_32:
2501 /* Let's help debug shared library creation. Any of these
2502 relocs can be used in shared libs, but pages containing them
2503 cannot be shared. Don't warn for sections we don't care
2504 about, such as debug sections or non-constant sections. We
2505 can't help tables of (global) function pointers, for example,
2506 though they must be emitted in a data section to avoid having
2507 impure text sections. */
2508 if (info->shared
2509 && (sec->flags & SEC_ALLOC) != 0
2510 && (sec->flags & SEC_READONLY) != 0)
2511 {
2512 /* FIXME: How do we make this optionally a warning only? */
2513 (*_bfd_error_handler)
2514 (_("%s, section %s:\n relocation %s should not be used in a shared object; recompile with -fPIC"),
2515 bfd_archive_filename (abfd),
2516 sec->name,
2517 cris_elf_howto_table[r_type].name);
2518 }
2519 /* Fall through. */
2520
2521 case R_CRIS_8_PCREL:
2522 case R_CRIS_16_PCREL:
2523 case R_CRIS_32_PCREL:
2524 if (h != NULL)
2525 {
2526 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2527
2528 /* Make sure a plt entry is created for this symbol if it
2529 turns out to be a function defined by a dynamic object. */
2530 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2531 h->plt.refcount++;
2532 }
2533
2534 /* If we are creating a shared library and this is not a local
2535 symbol, we need to copy the reloc into the shared library.
2536 However when linking with -Bsymbolic and this is a global
2537 symbol which is defined in an object we are including in the
2538 link (i.e., DEF_REGULAR is set), then we can resolve the
2539 reloc directly. At this point we have not seen all the input
2540 files, so it is possible that DEF_REGULAR is not set now but
2541 will be set later (it is never cleared). In case of a weak
2542 definition, DEF_REGULAR may be cleared later by a strong
2543 definition in a shared library. We account for that
2544 possibility below by storing information in the relocs_copied
2545 field of the hash table entry. A similar situation occurs
2546 when creating shared libraries and symbol visibility changes
2547 render the symbol local. */
2548
2549 /* No need to do anything if we're not creating a shared object. */
2550 if (! info->shared)
2551 break;
2552
2553 /* We don't need to handle relocs into sections not going into
2554 the "real" output. */
2555 if ((sec->flags & SEC_ALLOC) == 0)
2556 break;
2557
2558 /* We can only eliminate PC-relative relocs. */
2559 if (r_type == R_CRIS_8_PCREL
2560 || r_type == R_CRIS_16_PCREL
2561 || r_type == R_CRIS_32_PCREL)
2562 {
2563 /* If the symbol is local, then we can eliminate the reloc. */
2564 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2565 break;
2566
2567 /* If this is with -Bsymbolic and the symbol isn't weak, and
2568 is defined by an ordinary object (the ones we include in
2569 this shared library) then we can also eliminate the
2570 reloc. See comment above for more eliminable cases which
2571 we can't identify at this time. */
2572 if (info->symbolic
2573 && h->root.type != bfd_link_hash_defweak
2574 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2575 break;
2576 }
2577
2578 /* We create a reloc section in dynobj and make room for this
2579 reloc. */
2580 if (sreloc == NULL)
2581 {
2582 const char *name;
2583
2584 name = (bfd_elf_string_from_elf_section
2585 (abfd,
2586 elf_elfheader (abfd)->e_shstrndx,
2587 elf_section_data (sec)->rel_hdr.sh_name));
2588 if (name == NULL)
2589 return false;
2590
2591 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2592 && strcmp (bfd_get_section_name (abfd, sec),
2593 name + 5) == 0);
2594
2595 sreloc = bfd_get_section_by_name (dynobj, name);
2596 if (sreloc == NULL)
2597 {
2598 sreloc = bfd_make_section (dynobj, name);
2599 if (sreloc == NULL
2600 || !bfd_set_section_flags (dynobj, sreloc,
2601 (SEC_ALLOC
2602 | SEC_LOAD
2603 | SEC_HAS_CONTENTS
2604 | SEC_IN_MEMORY
2605 | SEC_LINKER_CREATED
2606 | SEC_READONLY))
2607 || !bfd_set_section_alignment (dynobj, sreloc, 2))
2608 return false;
2609 }
2610 if (sec->flags & SEC_READONLY)
2611 info->flags |= DF_TEXTREL;
2612 }
2613
2614 sreloc->_raw_size += sizeof (Elf32_External_Rela);
2615
2616 /* If we are linking with -Bsymbolic, we count the number of PC
2617 relative relocations we have entered for this symbol, so that
2618 we can discard them again if the symbol is later defined by a
2619 regular object. We know that h is really a pointer to an
2620 elf_cris_link_hash_entry. */
2621 if ((r_type == R_CRIS_8_PCREL
2622 || r_type == R_CRIS_16_PCREL
2623 || r_type == R_CRIS_32_PCREL)
2624 && info->symbolic)
2625 {
2626 struct elf_cris_link_hash_entry *eh;
2627 struct elf_cris_pcrel_relocs_copied *p;
2628
2629 eh = (struct elf_cris_link_hash_entry *) h;
2630
2631 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2632 if (p->section == sreloc)
2633 break;
2634
2635 if (p == NULL)
2636 {
2637 p = ((struct elf_cris_pcrel_relocs_copied *)
2638 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2639 if (p == NULL)
2640 return false;
2641 p->next = eh->pcrel_relocs_copied;
2642 eh->pcrel_relocs_copied = p;
2643 p->section = sreloc;
2644 p->count = 0;
2645 }
2646
2647 ++p->count;
2648 }
2649 break;
2650
2651 /* This relocation describes the C++ object vtable hierarchy.
2652 Reconstruct it for later use during GC. */
2653 case R_CRIS_GNU_VTINHERIT:
2654 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2655 return false;
2656 break;
2657
2658 /* This relocation describes which C++ vtable entries are actually
2659 used. Record for later use during GC. */
2660 case R_CRIS_GNU_VTENTRY:
2661 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2662 return false;
2663 break;
2664
2665 default:
2666 /* Other relocs do not appear here. */
2667 bfd_set_error (bfd_error_bad_value);
2668 return false;
2669 }
2670 }
2671
2672 return true;
2673 }
2674
2675 /* Set the sizes of the dynamic sections. */
2676
2677 static boolean
2678 elf_cris_size_dynamic_sections (output_bfd, info)
2679 bfd *output_bfd ATTRIBUTE_UNUSED;
2680 struct bfd_link_info *info;
2681 {
2682 bfd *dynobj;
2683 asection *s;
2684 boolean plt;
2685 boolean relocs;
2686
2687 dynobj = elf_hash_table (info)->dynobj;
2688 BFD_ASSERT (dynobj != NULL);
2689
2690 if (elf_hash_table (info)->dynamic_sections_created)
2691 {
2692 /* Set the contents of the .interp section to the interpreter. */
2693 if (!info->shared)
2694 {
2695 s = bfd_get_section_by_name (dynobj, ".interp");
2696 BFD_ASSERT (s != NULL);
2697 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2698 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2699 }
2700 }
2701 else
2702 {
2703 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2704 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2705 elf_cris_adjust_gotplt_to_got,
2706 (PTR) info);
2707
2708 /* We may have created entries in the .rela.got section.
2709 However, if we are not creating the dynamic sections, we will
2710 not actually use these entries. Reset the size of .rela.got,
2711 which will cause it to get stripped from the output file
2712 below. */
2713 s = bfd_get_section_by_name (dynobj, ".rela.got");
2714 if (s != NULL)
2715 s->_raw_size = 0;
2716 }
2717
2718 /* If this is a -Bsymbolic shared link, then we need to discard all PC
2719 relative relocs against symbols defined in a regular object. We
2720 allocated space for them in the check_relocs routine, but we will not
2721 fill them in in the relocate_section routine. We also discard space
2722 for relocs that have become for local symbols due to symbol
2723 visibility changes. For programs, we discard space for relocs for
2724 symbols not referenced by any dynamic object. */
2725 if (info->shared)
2726 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2727 elf_cris_discard_excess_dso_dynamics,
2728 (PTR) info);
2729 else
2730 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2731 elf_cris_discard_excess_program_dynamics,
2732 (PTR) info);
2733
2734 /* The check_relocs and adjust_dynamic_symbol entry points have
2735 determined the sizes of the various dynamic sections. Allocate
2736 memory for them. */
2737 plt = false;
2738 relocs = false;
2739 for (s = dynobj->sections; s != NULL; s = s->next)
2740 {
2741 const char *name;
2742 boolean strip;
2743
2744 if ((s->flags & SEC_LINKER_CREATED) == 0)
2745 continue;
2746
2747 /* It's OK to base decisions on the section name, because none
2748 of the dynobj section names depend upon the input files. */
2749 name = bfd_get_section_name (dynobj, s);
2750
2751 strip = false;
2752
2753 if (strcmp (name, ".plt") == 0)
2754 {
2755 if (s->_raw_size == 0)
2756 {
2757 /* Strip this section if we don't need it; see the
2758 comment below. */
2759 strip = true;
2760 }
2761 else
2762 {
2763 /* Remember whether there is a PLT. */
2764 plt = true;
2765 }
2766 }
2767 else if (strncmp (name, ".rela", 5) == 0)
2768 {
2769 if (s->_raw_size == 0)
2770 {
2771 /* If we don't need this section, strip it from the
2772 output file. This is mostly to handle .rela.bss and
2773 .rela.plt. We must create both sections in
2774 create_dynamic_sections, because they must be created
2775 before the linker maps input sections to output
2776 sections. The linker does that before
2777 adjust_dynamic_symbol is called, and it is that
2778 function which decides whether anything needs to go
2779 into these sections. */
2780 strip = true;
2781 }
2782 else
2783 {
2784 /* Remember whether there are any reloc sections other
2785 than .rela.plt. */
2786 if (strcmp (name, ".rela.plt") != 0)
2787 relocs = true;
2788
2789 /* We use the reloc_count field as a counter if we need
2790 to copy relocs into the output file. */
2791 s->reloc_count = 0;
2792 }
2793 }
2794 else if (strncmp (name, ".got", 4) != 0)
2795 {
2796 /* It's not one of our sections, so don't allocate space. */
2797 continue;
2798 }
2799
2800 if (strip)
2801 {
2802 _bfd_strip_section_from_output (info, s);
2803 continue;
2804 }
2805
2806 /* Allocate memory for the section contents. We use bfd_zalloc here
2807 in case unused entries are not reclaimed before the section's
2808 contents are written out. This should not happen, but this way
2809 if it does, we will not write out garbage. For reloc sections,
2810 this will make entries have the type R_CRIS_NONE. */
2811 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2812 if (s->contents == NULL && s->_raw_size != 0)
2813 return false;
2814 }
2815
2816 if (elf_hash_table (info)->dynamic_sections_created)
2817 {
2818 /* Add some entries to the .dynamic section. We fill in the
2819 values later, in elf_cris_finish_dynamic_sections, but we
2820 must add the entries now so that we get the correct size for
2821 the .dynamic section. The DT_DEBUG entry is filled in by the
2822 dynamic linker and used by the debugger. */
2823 #define add_dynamic_entry(TAG, VAL) \
2824 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2825
2826 if (!info->shared)
2827 {
2828 if (!add_dynamic_entry (DT_DEBUG, 0))
2829 return false;
2830 }
2831
2832 if (plt)
2833 {
2834 if (!add_dynamic_entry (DT_PLTGOT, 0)
2835 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2836 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2837 || !add_dynamic_entry (DT_JMPREL, 0))
2838 return false;
2839 }
2840
2841 if (relocs)
2842 {
2843 if (!add_dynamic_entry (DT_RELA, 0)
2844 || !add_dynamic_entry (DT_RELASZ, 0)
2845 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2846 return false;
2847 }
2848
2849 if ((info->flags & DF_TEXTREL) != 0)
2850 {
2851 if (!add_dynamic_entry (DT_TEXTREL, 0))
2852 return false;
2853 info->flags |= DF_TEXTREL;
2854 }
2855 }
2856 #undef add_dynamic_entry
2857
2858 return true;
2859 }
2860
2861 /* This function is called via elf_cris_link_hash_traverse if we are
2862 creating a shared object. In the -Bsymbolic case, it discards the
2863 space allocated to copy PC relative relocs against symbols which
2864 are defined in regular objects. For the normal non-symbolic case,
2865 we also discard space for relocs that have become local due to
2866 symbol visibility changes. We allocated space for them in the
2867 check_relocs routine, but we won't fill them in in the
2868 relocate_section routine. */
2869
2870 static boolean
2871 elf_cris_discard_excess_dso_dynamics (h, inf)
2872 struct elf_cris_link_hash_entry *h;
2873 PTR inf;
2874 {
2875 struct elf_cris_pcrel_relocs_copied *s;
2876 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2877
2878 if (h->root.root.type == bfd_link_hash_warning)
2879 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2880
2881 /* If a symbol has been forced local or we have found a regular
2882 definition for the symbolic link case, then we won't be needing
2883 any relocs. */
2884 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2885 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2886 || info->symbolic))
2887 {
2888 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2889 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2890 }
2891
2892 return true;
2893 }
2894
2895 /* This function is called via elf_cris_link_hash_traverse if we are *not*
2896 creating a shared object. We discard space for relocs for symbols put
2897 in the .got, but which we found we do not have to resolve at run-time. */
2898
2899 static boolean
2900 elf_cris_discard_excess_program_dynamics (h, inf)
2901 struct elf_cris_link_hash_entry *h;
2902 PTR inf;
2903 {
2904 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2905
2906 if (h->root.root.type == bfd_link_hash_warning)
2907 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2908
2909 /* If we're not creating a shared library and have a symbol which is
2910 referred to by .got references, but the symbol is defined locally,
2911 (or rather, not not defined by a DSO) then lose the reloc for the
2912 .got (don't allocate room for it). */
2913 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
2914 {
2915 if (h->root.got.refcount > 0
2916 /* The size of this section is only valid and in sync with the
2917 various reference counts if we do dynamic; don't decrement it
2918 otherwise. */
2919 && elf_hash_table (info)->dynamic_sections_created)
2920 {
2921 bfd *dynobj = elf_hash_table (info)->dynobj;
2922 asection *srelgot;
2923
2924 BFD_ASSERT (dynobj != NULL);
2925
2926 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2927
2928 BFD_ASSERT (srelgot != NULL);
2929
2930 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
2931 }
2932
2933 /* If the locally-defined symbol isn't used by a DSO, then we don't
2934 have to export it as a dynamic symbol. This was already done for
2935 functions; doing this for all symbols would presumably not
2936 introduce new problems. Of course we don't do this if we're
2937 exporting all dynamic symbols. */
2938 if (! info->export_dynamic)
2939 {
2940 h->root.dynindx = -1;
2941 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2942 h->root.dynstr_index);
2943 }
2944 }
2945
2946 return true;
2947 }
2948
2949 /* Reject a file depending on presence and expectation of prefixed
2950 underscores on symbols. */
2951
2952 static boolean
2953 cris_elf_object_p (abfd)
2954 bfd *abfd;
2955 {
2956 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
2957 return (bfd_get_symbol_leading_char (abfd) == '_');
2958 else
2959 return (bfd_get_symbol_leading_char (abfd) == 0);
2960 }
2961
2962 /* Mark presence or absence of leading underscore. */
2963
2964 static void
2965 cris_elf_final_write_processing (abfd, linker)
2966 bfd *abfd;
2967 boolean linker ATTRIBUTE_UNUSED;
2968 {
2969 if (bfd_get_symbol_leading_char (abfd) == '_')
2970 elf_elfheader (abfd)->e_flags |= EF_CRIS_UNDERSCORE;
2971 else
2972 elf_elfheader (abfd)->e_flags &= ~EF_CRIS_UNDERSCORE;
2973 }
2974
2975 /* Display the flags field. */
2976
2977 static boolean
2978 cris_elf_print_private_bfd_data (abfd, ptr)
2979 bfd *abfd;
2980 PTR ptr;
2981 {
2982 FILE *file = (FILE *) ptr;
2983
2984 BFD_ASSERT (abfd != NULL && ptr != NULL)
2985
2986 _bfd_elf_print_private_bfd_data (abfd, ptr);
2987
2988 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2989
2990 if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
2991 fprintf (file, _(" [symbols have a _ prefix]"));
2992
2993 fputc ('\n', file);
2994 return true;
2995 }
2996
2997 /* Don't mix files with and without a leading underscore. */
2998
2999 static boolean
3000 cris_elf_merge_private_bfd_data (ibfd, obfd)
3001 bfd *ibfd;
3002 bfd *obfd;
3003 {
3004 flagword old_flags, new_flags;
3005
3006 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3007 return false;
3008
3009 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3010 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3011 return true;
3012
3013 if (! elf_flags_init (obfd))
3014 {
3015 /* This happens when ld starts out with a 'blank' output file. */
3016 elf_flags_init (obfd) = true;
3017
3018 /* Set flags according to current bfd_target. */
3019 cris_elf_final_write_processing (obfd, false);
3020 }
3021
3022 old_flags = elf_elfheader (obfd)->e_flags;
3023 new_flags = elf_elfheader (ibfd)->e_flags;
3024
3025 /* Is this good or bad? We'll follow with other excluding flags. */
3026 if ((old_flags & EF_CRIS_UNDERSCORE) != (new_flags & EF_CRIS_UNDERSCORE))
3027 {
3028 (*_bfd_error_handler)
3029 ((new_flags & EF_CRIS_UNDERSCORE)
3030 ? _("%s: uses _-prefixed symbols, but writing file with non-prefixed symbols")
3031 : _("%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
3032 bfd_archive_filename (ibfd));
3033 bfd_set_error (bfd_error_bad_value);
3034 return false;
3035 }
3036
3037 return true;
3038 }
3039
3040
3041 static enum elf_reloc_type_class
3042 elf_cris_reloc_type_class (rela)
3043 const Elf_Internal_Rela *rela;
3044 {
3045 switch ((int) ELF32_R_TYPE (rela->r_info))
3046 {
3047 case R_CRIS_RELATIVE:
3048 return reloc_class_relative;
3049 case R_CRIS_JUMP_SLOT:
3050 return reloc_class_plt;
3051 case R_CRIS_COPY:
3052 return reloc_class_copy;
3053 default:
3054 return reloc_class_normal;
3055 }
3056 }
3057 \f
3058 #define ELF_ARCH bfd_arch_cris
3059 #define ELF_MACHINE_CODE EM_CRIS
3060 #define ELF_MAXPAGESIZE 0x2000
3061
3062 #define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3063 #define TARGET_LITTLE_NAME "elf32-cris"
3064 #define elf_symbol_leading_char 0
3065
3066 #define elf_info_to_howto_rel NULL
3067 #define elf_info_to_howto cris_info_to_howto_rela
3068 #define elf_backend_relocate_section cris_elf_relocate_section
3069 #define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3070 #define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3071 #define elf_backend_check_relocs cris_elf_check_relocs
3072 #define elf_backend_grok_prstatus cris_elf_grok_prstatus
3073 #define elf_backend_grok_psinfo cris_elf_grok_psinfo
3074
3075 #define elf_backend_can_gc_sections 1
3076 #define elf_backend_can_refcount 1
3077
3078 #define elf_backend_object_p cris_elf_object_p
3079 #define elf_backend_final_write_processing \
3080 cris_elf_final_write_processing
3081 #define bfd_elf32_bfd_print_private_bfd_data \
3082 cris_elf_print_private_bfd_data
3083 #define bfd_elf32_bfd_merge_private_bfd_data \
3084 cris_elf_merge_private_bfd_data
3085
3086 #define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3087
3088 #define bfd_elf32_bfd_link_hash_table_create \
3089 elf_cris_link_hash_table_create
3090 #define elf_backend_adjust_dynamic_symbol \
3091 elf_cris_adjust_dynamic_symbol
3092 #define elf_backend_size_dynamic_sections \
3093 elf_cris_size_dynamic_sections
3094 #define elf_backend_finish_dynamic_symbol \
3095 elf_cris_finish_dynamic_symbol
3096 #define elf_backend_finish_dynamic_sections \
3097 elf_cris_finish_dynamic_sections
3098 #define elf_backend_create_dynamic_sections \
3099 _bfd_elf_create_dynamic_sections
3100 #define bfd_elf32_bfd_final_link \
3101 _bfd_elf32_gc_common_final_link
3102 #define elf_backend_hide_symbol elf_cris_hide_symbol
3103 #define elf_backend_reloc_type_class elf_cris_reloc_type_class
3104
3105 #define elf_backend_want_got_plt 1
3106 #define elf_backend_plt_readonly 1
3107 #define elf_backend_want_plt_sym 0
3108 #define elf_backend_got_header_size 12
3109 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3110
3111 /* Later, we my want to optimize RELA entries into REL entries for dynamic
3112 linking and libraries (if it's a win of any significance). Until then,
3113 take the easy route. */
3114 #define elf_backend_may_use_rel_p 0
3115 #define elf_backend_may_use_rela_p 1
3116
3117 #include "elf32-target.h"
3118
3119 #define INCLUDED_TARGET_FILE
3120
3121 #undef TARGET_LITTLE_SYM
3122 #undef TARGET_LITTLE_NAME
3123 #undef elf_symbol_leading_char
3124
3125 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3126 #define TARGET_LITTLE_NAME "elf32-us-cris"
3127 #define elf_symbol_leading_char '_'
3128
3129 #include "elf32-target.h"
git-cvsimport of binutils cvsroot