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