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