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