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