projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elflink.c (_bfd_elf_gc_mark_hook): New function.
[deliverable/binutils-gdb.git] / bfd / elf32-fr30.c
1 /* FR30-specific support for 32-bit ELF.
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/fr30.h"
26
27 /* Forward declarations. */
28 static bfd_reloc_status_type fr30_elf_i20_reloc
29 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
30 static bfd_reloc_status_type fr30_elf_i32_reloc
31 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
32 static reloc_howto_type * fr30_reloc_type_lookup
33 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
34 static void fr30_info_to_howto_rela
35 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
36 static bfd_boolean fr30_elf_relocate_section
37 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
38 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
39 static bfd_reloc_status_type fr30_final_link_relocate
40 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
41 Elf_Internal_Rela *, bfd_vma));
42 static bfd_boolean fr30_elf_check_relocs
43 PARAMS ((bfd *, struct bfd_link_info *, asection *,
44 const Elf_Internal_Rela *));
45
46 static reloc_howto_type fr30_elf_howto_table [] =
47 {
48 /* This reloc does nothing. */
49 HOWTO (R_FR30_NONE, /* type */
50 0, /* rightshift */
51 2, /* size (0 = byte, 1 = short, 2 = long) */
52 32, /* bitsize */
53 FALSE, /* pc_relative */
54 0, /* bitpos */
55 complain_overflow_bitfield, /* complain_on_overflow */
56 bfd_elf_generic_reloc, /* special_function */
57 "R_FR30_NONE", /* name */
58 FALSE, /* partial_inplace */
59 0, /* src_mask */
60 0, /* dst_mask */
61 FALSE), /* pcrel_offset */
62
63 /* An 8 bit absolute relocation. */
64 HOWTO (R_FR30_8, /* type */
65 0, /* rightshift */
66 1, /* size (0 = byte, 1 = short, 2 = long) */
67 8, /* bitsize */
68 FALSE, /* pc_relative */
69 4, /* bitpos */
70 complain_overflow_bitfield, /* complain_on_overflow */
71 bfd_elf_generic_reloc, /* special_function */
72 "R_FR30_8", /* name */
73 TRUE, /* partial_inplace */
74 0x0000, /* src_mask */
75 0x0ff0, /* dst_mask */
76 FALSE), /* pcrel_offset */
77
78 /* A 20 bit absolute relocation. */
79 HOWTO (R_FR30_20, /* type */
80 0, /* rightshift */
81 2, /* size (0 = byte, 1 = short, 2 = long) */
82 20, /* bitsize */
83 FALSE, /* pc_relative */
84 0, /* bitpos */
85 complain_overflow_bitfield, /* complain_on_overflow */
86 fr30_elf_i20_reloc, /* special_function */
87 "R_FR30_20", /* name */
88 TRUE, /* partial_inplace */
89 0x00000000, /* src_mask */
90 0x00f0ffff, /* dst_mask */
91 FALSE), /* pcrel_offset */
92
93 /* A 32 bit absolute relocation. */
94 HOWTO (R_FR30_32, /* type */
95 0, /* rightshift */
96 2, /* size (0 = byte, 1 = short, 2 = long) */
97 32, /* bitsize */
98 FALSE, /* pc_relative */
99 0, /* bitpos */
100 complain_overflow_bitfield, /* complain_on_overflow */
101 bfd_elf_generic_reloc, /* special_function */
102 "R_FR30_32", /* name */
103 TRUE, /* partial_inplace */
104 0x00000000, /* src_mask */
105 0xffffffff, /* dst_mask */
106 FALSE), /* pcrel_offset */
107
108 /* A 32 bit into 48 bits absolute relocation. */
109 HOWTO (R_FR30_48, /* type */
110 0, /* rightshift */
111 2, /* size (0 = byte, 1 = short, 2 = long) */
112 32, /* bitsize */
113 FALSE, /* pc_relative */
114 0, /* bitpos */
115 complain_overflow_bitfield, /* complain_on_overflow */
116 fr30_elf_i32_reloc, /* special_function */
117 "R_FR30_48", /* name */
118 TRUE, /* partial_inplace */
119 0x00000000, /* src_mask */
120 0xffffffff, /* dst_mask */
121 FALSE), /* pcrel_offset */
122
123 /* A 6 bit absolute relocation. */
124 HOWTO (R_FR30_6_IN_4, /* type */
125 2, /* rightshift */
126 1, /* size (0 = byte, 1 = short, 2 = long) */
127 6, /* bitsize */
128 FALSE, /* pc_relative */
129 4, /* bitpos */
130 complain_overflow_unsigned, /* complain_on_overflow */
131 bfd_elf_generic_reloc, /* special_function */
132 "R_FR30_6_IN_4", /* name */
133 TRUE, /* partial_inplace */
134 0x0000, /* src_mask */
135 0x00f0, /* dst_mask */
136 FALSE), /* pcrel_offset */
137
138 /* An 8 bit absolute relocation. */
139 HOWTO (R_FR30_8_IN_8, /* type */
140 0, /* rightshift */
141 1, /* size (0 = byte, 1 = short, 2 = long) */
142 8, /* bitsize */
143 FALSE, /* pc_relative */
144 4, /* bitpos */
145 complain_overflow_signed, /* complain_on_overflow */
146 bfd_elf_generic_reloc,/* special_function */
147 "R_FR30_8_IN_8", /* name */
148 TRUE, /* partial_inplace */
149 0x0000, /* src_mask */
150 0x0ff0, /* dst_mask */
151 FALSE), /* pcrel_offset */
152
153 /* A 9 bit absolute relocation. */
154 HOWTO (R_FR30_9_IN_8, /* type */
155 1, /* rightshift */
156 1, /* size (0 = byte, 1 = short, 2 = long) */
157 9, /* bitsize */
158 FALSE, /* pc_relative */
159 4, /* bitpos */
160 complain_overflow_signed, /* complain_on_overflow */
161 bfd_elf_generic_reloc,/* special_function */
162 "R_FR30_9_IN_8", /* name */
163 TRUE, /* partial_inplace */
164 0x0000, /* src_mask */
165 0x0ff0, /* dst_mask */
166 FALSE), /* pcrel_offset */
167
168 /* A 10 bit absolute relocation. */
169 HOWTO (R_FR30_10_IN_8, /* type */
170 2, /* rightshift */
171 1, /* size (0 = byte, 1 = short, 2 = long) */
172 10, /* bitsize */
173 FALSE, /* pc_relative */
174 4, /* bitpos */
175 complain_overflow_signed, /* complain_on_overflow */
176 bfd_elf_generic_reloc,/* special_function */
177 "R_FR30_10_IN_8", /* name */
178 TRUE, /* partial_inplace */
179 0x0000, /* src_mask */
180 0x0ff0, /* dst_mask */
181 FALSE), /* pcrel_offset */
182
183 /* A PC relative 9 bit relocation, right shifted by 1. */
184 HOWTO (R_FR30_9_PCREL, /* type */
185 1, /* rightshift */
186 1, /* size (0 = byte, 1 = short, 2 = long) */
187 9, /* bitsize */
188 TRUE, /* pc_relative */
189 0, /* bitpos */
190 complain_overflow_signed, /* complain_on_overflow */
191 bfd_elf_generic_reloc, /* special_function */
192 "R_FR30_9_PCREL", /* name */
193 FALSE, /* partial_inplace */
194 0x0000, /* src_mask */
195 0x00ff, /* dst_mask */
196 FALSE), /* pcrel_offset */
197
198 /* A PC relative 12 bit relocation, right shifted by 1. */
199 HOWTO (R_FR30_12_PCREL, /* type */
200 1, /* rightshift */
201 1, /* size (0 = byte, 1 = short, 2 = long) */
202 12, /* bitsize */
203 TRUE, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_signed, /* complain_on_overflow */
206 bfd_elf_generic_reloc, /* special_function */
207 "R_FR30_12_PCREL", /* name */
208 FALSE, /* partial_inplace */
209 0x0000, /* src_mask */
210 0x07ff, /* dst_mask */
211 FALSE), /* pcrel_offset */
212 /* GNU extension to record C++ vtable hierarchy */
213 HOWTO (R_FR30_GNU_VTINHERIT, /* type */
214 0, /* rightshift */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
216 0, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_dont, /* complain_on_overflow */
220 NULL, /* special_function */
221 "R_FR30_GNU_VTINHERIT", /* name */
222 FALSE, /* partial_inplace */
223 0, /* src_mask */
224 0, /* dst_mask */
225 FALSE), /* pcrel_offset */
226
227 /* GNU extension to record C++ vtable member usage */
228 HOWTO (R_FR30_GNU_VTENTRY, /* type */
229 0, /* rightshift */
230 2, /* size (0 = byte, 1 = short, 2 = long) */
231 0, /* bitsize */
232 FALSE, /* pc_relative */
233 0, /* bitpos */
234 complain_overflow_dont, /* complain_on_overflow */
235 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
236 "R_FR30_GNU_VTENTRY", /* name */
237 FALSE, /* partial_inplace */
238 0, /* src_mask */
239 0, /* dst_mask */
240 FALSE), /* pcrel_offset */
241 };
242 \f
243 /* Utility to actually perform an R_FR30_20 reloc. */
244
245 static bfd_reloc_status_type
246 fr30_elf_i20_reloc (abfd, reloc_entry, symbol, data,
247 input_section, output_bfd, error_message)
248 bfd *abfd;
249 arelent *reloc_entry;
250 asymbol *symbol;
251 PTR data;
252 asection *input_section;
253 bfd *output_bfd;
254 char **error_message ATTRIBUTE_UNUSED;
255 {
256 bfd_vma relocation;
257 unsigned long x;
258
259 /* This part is from bfd_elf_generic_reloc. */
260 if (output_bfd != (bfd *) NULL
261 && (symbol->flags & BSF_SECTION_SYM) == 0
262 && (! reloc_entry->howto->partial_inplace
263 || reloc_entry->addend == 0))
264 {
265 reloc_entry->address += input_section->output_offset;
266 return bfd_reloc_ok;
267 }
268
269 if (output_bfd != NULL)
270 /* FIXME: See bfd_perform_relocation. Is this right? */
271 return bfd_reloc_ok;
272
273 relocation =
274 symbol->value
275 + symbol->section->output_section->vma
276 + symbol->section->output_offset
277 + reloc_entry->addend;
278
279 if (relocation > (((bfd_vma) 1 << 20) - 1))
280 return bfd_reloc_overflow;
281
282 x = bfd_get_32 (abfd, (char *) data + reloc_entry->address);
283 x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
284 bfd_put_32 (abfd, (bfd_vma) x, (char *) data + reloc_entry->address);
285
286 return bfd_reloc_ok;
287 }
288 \f
289 /* Utility to actually perform a R_FR30_48 reloc. */
290
291 static bfd_reloc_status_type
292 fr30_elf_i32_reloc (abfd, reloc_entry, symbol, data,
293 input_section, output_bfd, error_message)
294 bfd *abfd;
295 arelent *reloc_entry;
296 asymbol *symbol;
297 PTR data;
298 asection *input_section;
299 bfd *output_bfd;
300 char **error_message ATTRIBUTE_UNUSED;
301 {
302 bfd_vma relocation;
303
304 /* This part is from bfd_elf_generic_reloc. */
305 if (output_bfd != (bfd *) NULL
306 && (symbol->flags & BSF_SECTION_SYM) == 0
307 && (! reloc_entry->howto->partial_inplace
308 || reloc_entry->addend == 0))
309 {
310 reloc_entry->address += input_section->output_offset;
311 return bfd_reloc_ok;
312 }
313
314 if (output_bfd != NULL)
315 /* FIXME: See bfd_perform_relocation. Is this right? */
316 return bfd_reloc_ok;
317
318 relocation =
319 symbol->value
320 + symbol->section->output_section->vma
321 + symbol->section->output_offset
322 + reloc_entry->addend;
323
324 bfd_put_32 (abfd, relocation, (char *) data + reloc_entry->address + 2);
325
326 return bfd_reloc_ok;
327 }
328 \f
329 /* Map BFD reloc types to FR30 ELF reloc types. */
330
331 struct fr30_reloc_map
332 {
333 bfd_reloc_code_real_type bfd_reloc_val;
334 unsigned int fr30_reloc_val;
335 };
336
337 static const struct fr30_reloc_map fr30_reloc_map [] =
338 {
339 { BFD_RELOC_NONE, R_FR30_NONE },
340 { BFD_RELOC_8, R_FR30_8 },
341 { BFD_RELOC_FR30_20, R_FR30_20 },
342 { BFD_RELOC_32, R_FR30_32 },
343 { BFD_RELOC_FR30_48, R_FR30_48 },
344 { BFD_RELOC_FR30_6_IN_4, R_FR30_6_IN_4 },
345 { BFD_RELOC_FR30_8_IN_8, R_FR30_8_IN_8 },
346 { BFD_RELOC_FR30_9_IN_8, R_FR30_9_IN_8 },
347 { BFD_RELOC_FR30_10_IN_8, R_FR30_10_IN_8 },
348 { BFD_RELOC_FR30_9_PCREL, R_FR30_9_PCREL },
349 { BFD_RELOC_FR30_12_PCREL, R_FR30_12_PCREL },
350 { BFD_RELOC_VTABLE_INHERIT, R_FR30_GNU_VTINHERIT },
351 { BFD_RELOC_VTABLE_ENTRY, R_FR30_GNU_VTENTRY },
352 };
353
354 static reloc_howto_type *
355 fr30_reloc_type_lookup (abfd, code)
356 bfd *abfd ATTRIBUTE_UNUSED;
357 bfd_reloc_code_real_type code;
358 {
359 unsigned int i;
360
361 for (i = sizeof (fr30_reloc_map) / sizeof (fr30_reloc_map[0]);
362 --i;)
363 if (fr30_reloc_map [i].bfd_reloc_val == code)
364 return & fr30_elf_howto_table [fr30_reloc_map[i].fr30_reloc_val];
365
366 return NULL;
367 }
368
369 /* Set the howto pointer for an FR30 ELF reloc. */
370
371 static void
372 fr30_info_to_howto_rela (abfd, cache_ptr, dst)
373 bfd *abfd ATTRIBUTE_UNUSED;
374 arelent *cache_ptr;
375 Elf_Internal_Rela *dst;
376 {
377 unsigned int r_type;
378
379 r_type = ELF32_R_TYPE (dst->r_info);
380 BFD_ASSERT (r_type < (unsigned int) R_FR30_max);
381 cache_ptr->howto = & fr30_elf_howto_table [r_type];
382 }
383 \f
384 /* Perform a single relocation. By default we use the standard BFD
385 routines, but a few relocs, we have to do them ourselves. */
386
387 static bfd_reloc_status_type
388 fr30_final_link_relocate (howto, input_bfd, input_section, contents, rel,
389 relocation)
390 reloc_howto_type *howto;
391 bfd *input_bfd;
392 asection *input_section;
393 bfd_byte *contents;
394 Elf_Internal_Rela *rel;
395 bfd_vma relocation;
396 {
397 bfd_reloc_status_type r = bfd_reloc_ok;
398 bfd_vma x;
399 bfd_signed_vma srel;
400
401 switch (howto->type)
402 {
403 case R_FR30_20:
404 contents += rel->r_offset;
405 relocation += rel->r_addend;
406
407 if (relocation > ((1 << 20) - 1))
408 return bfd_reloc_overflow;
409
410 x = bfd_get_32 (input_bfd, contents);
411 x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
412 bfd_put_32 (input_bfd, x, contents);
413 break;
414
415 case R_FR30_48:
416 contents += rel->r_offset + 2;
417 relocation += rel->r_addend;
418 bfd_put_32 (input_bfd, relocation, contents);
419 break;
420
421 case R_FR30_9_PCREL:
422 contents += rel->r_offset + 1;
423 srel = (bfd_signed_vma) relocation;
424 srel += rel->r_addend;
425 srel -= rel->r_offset;
426 srel -= 2; /* Branch instructions add 2 to the PC... */
427 srel -= (input_section->output_section->vma +
428 input_section->output_offset);
429
430 if (srel & 1)
431 return bfd_reloc_outofrange;
432 if (srel > ((1 << 8) - 1) || (srel < - (1 << 8)))
433 return bfd_reloc_overflow;
434
435 bfd_put_8 (input_bfd, srel >> 1, contents);
436 break;
437
438 case R_FR30_12_PCREL:
439 contents += rel->r_offset;
440 srel = (bfd_signed_vma) relocation;
441 srel += rel->r_addend;
442 srel -= rel->r_offset;
443 srel -= 2; /* Branch instructions add 2 to the PC... */
444 srel -= (input_section->output_section->vma +
445 input_section->output_offset);
446
447 if (srel & 1)
448 return bfd_reloc_outofrange;
449 if (srel > ((1 << 11) - 1) || (srel < - (1 << 11)))
450 return bfd_reloc_overflow;
451
452 x = bfd_get_16 (input_bfd, contents);
453 x = (x & 0xf800) | ((srel >> 1) & 0x7ff);
454 bfd_put_16 (input_bfd, x, contents);
455 break;
456
457 default:
458 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
459 contents, rel->r_offset,
460 relocation, rel->r_addend);
461 }
462
463 return r;
464 }
465 \f
466 /* Relocate an FR30 ELF section.
467
468 The RELOCATE_SECTION function is called by the new ELF backend linker
469 to handle the relocations for a section.
470
471 The relocs are always passed as Rela structures; if the section
472 actually uses Rel structures, the r_addend field will always be
473 zero.
474
475 This function is responsible for adjusting the section contents as
476 necessary, and (if using Rela relocs and generating a relocatable
477 output file) adjusting the reloc addend as necessary.
478
479 This function does not have to worry about setting the reloc
480 address or the reloc symbol index.
481
482 LOCAL_SYMS is a pointer to the swapped in local symbols.
483
484 LOCAL_SECTIONS is an array giving the section in the input file
485 corresponding to the st_shndx field of each local symbol.
486
487 The global hash table entry for the global symbols can be found
488 via elf_sym_hashes (input_bfd).
489
490 When generating relocatable output, this function must handle
491 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
492 going to be the section symbol corresponding to the output
493 section, which means that the addend must be adjusted
494 accordingly. */
495
496 static bfd_boolean
497 fr30_elf_relocate_section (output_bfd, info, input_bfd, input_section,
498 contents, relocs, local_syms, local_sections)
499 bfd *output_bfd;
500 struct bfd_link_info *info;
501 bfd *input_bfd;
502 asection *input_section;
503 bfd_byte *contents;
504 Elf_Internal_Rela *relocs;
505 Elf_Internal_Sym *local_syms;
506 asection **local_sections;
507 {
508 Elf_Internal_Shdr *symtab_hdr;
509 struct elf_link_hash_entry **sym_hashes;
510 Elf_Internal_Rela *rel;
511 Elf_Internal_Rela *relend;
512
513 if (info->relocatable)
514 return TRUE;
515
516 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
517 sym_hashes = elf_sym_hashes (input_bfd);
518 relend = relocs + input_section->reloc_count;
519
520 for (rel = relocs; rel < relend; rel ++)
521 {
522 reloc_howto_type *howto;
523 unsigned long r_symndx;
524 Elf_Internal_Sym *sym;
525 asection *sec;
526 struct elf_link_hash_entry *h;
527 bfd_vma relocation;
528 bfd_reloc_status_type r;
529 const char *name;
530 int r_type;
531
532 r_type = ELF32_R_TYPE (rel->r_info);
533
534 if ( r_type == R_FR30_GNU_VTINHERIT
535 || r_type == R_FR30_GNU_VTENTRY)
536 continue;
537
538 r_symndx = ELF32_R_SYM (rel->r_info);
539
540 howto = fr30_elf_howto_table + ELF32_R_TYPE (rel->r_info);
541 h = NULL;
542 sym = NULL;
543 sec = NULL;
544
545 if (r_symndx < symtab_hdr->sh_info)
546 {
547 sym = local_syms + r_symndx;
548 sec = local_sections [r_symndx];
549 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
550
551 name = bfd_elf_string_from_elf_section
552 (input_bfd, symtab_hdr->sh_link, sym->st_name);
553 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
554 }
555 else
556 {
557 bfd_boolean unresolved_reloc, warned;
558
559 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
560 r_symndx, symtab_hdr, sym_hashes,
561 h, sec, relocation,
562 unresolved_reloc, warned);
563
564 name = h->root.root.string;
565 }
566
567 r = fr30_final_link_relocate (howto, input_bfd, input_section,
568 contents, rel, relocation);
569
570 if (r != bfd_reloc_ok)
571 {
572 const char * msg = (const char *) NULL;
573
574 switch (r)
575 {
576 case bfd_reloc_overflow:
577 r = info->callbacks->reloc_overflow
578 (info, (h ? &h->root : NULL), name, howto->name,
579 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
580 break;
581
582 case bfd_reloc_undefined:
583 r = info->callbacks->undefined_symbol
584 (info, name, input_bfd, input_section, rel->r_offset,
585 TRUE);
586 break;
587
588 case bfd_reloc_outofrange:
589 msg = _("internal error: out of range error");
590 break;
591
592 case bfd_reloc_notsupported:
593 msg = _("internal error: unsupported relocation error");
594 break;
595
596 case bfd_reloc_dangerous:
597 msg = _("internal error: dangerous relocation");
598 break;
599
600 default:
601 msg = _("internal error: unknown error");
602 break;
603 }
604
605 if (msg)
606 r = info->callbacks->warning
607 (info, msg, name, input_bfd, input_section, rel->r_offset);
608
609 if (! r)
610 return FALSE;
611 }
612 }
613
614 return TRUE;
615 }
616 \f
617 /* Return the section that should be marked against GC for a given
618 relocation. */
619
620 static asection *
621 fr30_elf_gc_mark_hook (asection *sec,
622 struct bfd_link_info *info,
623 Elf_Internal_Rela *rel,
624 struct elf_link_hash_entry *h,
625 Elf_Internal_Sym *sym)
626 {
627 if (h != NULL)
628 switch (ELF32_R_TYPE (rel->r_info))
629 {
630 case R_FR30_GNU_VTINHERIT:
631 case R_FR30_GNU_VTENTRY:
632 return NULL;
633 }
634
635 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
636 }
637
638 /* Look through the relocs for a section during the first phase.
639 Since we don't do .gots or .plts, we just need to consider the
640 virtual table relocs for gc. */
641
642 static bfd_boolean
643 fr30_elf_check_relocs (abfd, info, sec, relocs)
644 bfd *abfd;
645 struct bfd_link_info *info;
646 asection *sec;
647 const Elf_Internal_Rela *relocs;
648 {
649 Elf_Internal_Shdr *symtab_hdr;
650 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
651 const Elf_Internal_Rela *rel;
652 const Elf_Internal_Rela *rel_end;
653
654 if (info->relocatable)
655 return TRUE;
656
657 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
658 sym_hashes = elf_sym_hashes (abfd);
659 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
660 if (!elf_bad_symtab (abfd))
661 sym_hashes_end -= symtab_hdr->sh_info;
662
663 rel_end = relocs + sec->reloc_count;
664 for (rel = relocs; rel < rel_end; rel++)
665 {
666 struct elf_link_hash_entry *h;
667 unsigned long r_symndx;
668
669 r_symndx = ELF32_R_SYM (rel->r_info);
670 if (r_symndx < symtab_hdr->sh_info)
671 h = NULL;
672 else
673 {
674 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
675 while (h->root.type == bfd_link_hash_indirect
676 || h->root.type == bfd_link_hash_warning)
677 h = (struct elf_link_hash_entry *) h->root.u.i.link;
678 }
679
680 switch (ELF32_R_TYPE (rel->r_info))
681 {
682 /* This relocation describes the C++ object vtable hierarchy.
683 Reconstruct it for later use during GC. */
684 case R_FR30_GNU_VTINHERIT:
685 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
686 return FALSE;
687 break;
688
689 /* This relocation describes which C++ vtable entries are actually
690 used. Record for later use during GC. */
691 case R_FR30_GNU_VTENTRY:
692 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
693 return FALSE;
694 break;
695 }
696 }
697
698 return TRUE;
699 }
700 \f
701 #define ELF_ARCH bfd_arch_fr30
702 #define ELF_MACHINE_CODE EM_FR30
703 #define ELF_MACHINE_ALT1 EM_CYGNUS_FR30
704 #define ELF_MAXPAGESIZE 0x1000
705
706 #define TARGET_BIG_SYM bfd_elf32_fr30_vec
707 #define TARGET_BIG_NAME "elf32-fr30"
708
709 #define elf_info_to_howto_rel NULL
710 #define elf_info_to_howto fr30_info_to_howto_rela
711 #define elf_backend_relocate_section fr30_elf_relocate_section
712 #define elf_backend_gc_mark_hook fr30_elf_gc_mark_hook
713 #define elf_backend_check_relocs fr30_elf_check_relocs
714
715 #define elf_backend_can_gc_sections 1
716 #define elf_backend_rela_normal 1
717
718 #define bfd_elf32_bfd_reloc_type_lookup fr30_reloc_type_lookup
719
720 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.076787 seconds and 4 git commands to generate.