source: trunk/src/binutils/bfd/elf32-cris.c@ 610

Last change on this file since 610 was 610, checked in by bird, 22 years ago

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