bfd/elf32-openrisc.c

   1 /* OpenRISC-specific support for 32-bit ELF.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4    Contributed by Johan Rydberg, jrydberg@opencores.org
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
  21    USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/openrisc.h"
  28 #include "libiberty.h"
  29
  30 static reloc_howto_type openrisc_elf_howto_table[] =
  31 {
  32   /* This reloc does nothing.  */
  33   HOWTO (R_OPENRISC_NONE,       /* type */
  34          0,                     /* rightshift */
  35          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  36          32,                    /* bitsize */
  37          FALSE,                 /* pc_relative */
  38          0,                     /* bitpos */
  39          complain_overflow_bitfield, /* complain_on_overflow */
  40          bfd_elf_generic_reloc, /* special_function */
  41          "R_OPENRISC_NONE",     /* name */
  42          FALSE,                 /* partial_inplace */
  43          0,                     /* src_mask */
  44          0,                     /* dst_mask */
  45          FALSE),                /* pcrel_offset */
  46
  47   /* A PC relative 26 bit relocation, right shifted by 2.  */
  48   HOWTO (R_OPENRISC_INSN_REL_26, /* type */
  49          2,                     /* rightshift */
  50          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  51          26,                    /* bitsize */
  52          TRUE,                  /* pc_relative */
  53          0,                     /* bitpos */
  54          complain_overflow_signed, /* complain_on_overflow */
  55          bfd_elf_generic_reloc, /* special_function */
  56          "R_OPENRISC_INSN_REL_26", /* name */
  57          FALSE,                 /* partial_inplace */
  58          0x00000000,            /* src_mask */
  59          0x03ffffff,            /* dst_mask */
  60          FALSE),                /* pcrel_offset */
  61
  62   /* A absolute 26 bit relocation, right shifted by 2.  */
  63   HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
  64          2,                     /* rightshift */
  65          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  66          26,                    /* bitsize */
  67          FALSE,                 /* pc_relative */
  68          0,                     /* bitpos */
  69          complain_overflow_signed, /* complain_on_overflow */
  70          bfd_elf_generic_reloc, /* special_function */
  71          "R_OPENRISC_INSN_ABS_26", /* name */
  72          FALSE,                 /* partial_inplace */
  73          0x00000000,            /* src_mask */
  74          0x03ffffff,            /* dst_mask */
  75          FALSE),                /* pcrel_offset */
  76
  77   HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
  78          0,                     /* rightshift */
  79          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  80          16,                    /* bitsize */
  81          FALSE,                 /* pc_relative */
  82          0,                     /* bitpos */
  83          complain_overflow_dont, /* complain_on_overflow */
  84          bfd_elf_generic_reloc, /* special_function */
  85          "R_OPENRISC_LO_16_IN_INSN", /* name */
  86          FALSE,                 /* partial_inplace */
  87          0,                     /* src_mask */
  88          0x0000ffff,            /* dst_mask */
  89          FALSE),                /* pcrel_offset */
  90
  91   HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
  92          16,                    /* rightshift */
  93          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  94          16,                    /* bitsize */
  95          FALSE,                 /* pc_relative */
  96          0,                     /* bitpos */
  97          complain_overflow_dont,        /* complain_on_overflow */
  98          bfd_elf_generic_reloc, /* special_function */
  99          "R_OPENRISC_HI_16_IN_INSN",    /* name */
 100          FALSE,                 /* partial_inplace */
 101          0,                     /* src_mask */
 102          0x0000ffff,            /* dst_mask */
 103          FALSE),                /* pcrel_offset */
 104
 105   /* An 8 bit absolute relocation.  */
 106   HOWTO (R_OPENRISC_8,          /* type */
 107          0,                     /* rightshift */
 108          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 109          8,                     /* bitsize */
 110          FALSE,                 /* pc_relative */
 111          0,                     /* bitpos */
 112          complain_overflow_bitfield, /* complain_on_overflow */
 113          bfd_elf_generic_reloc, /* special_function */
 114          "R_OPENRISC_8",        /* name */
 115          TRUE,                  /* partial_inplace */
 116          0x0000,                /* src_mask */
 117          0x00ff,                /* dst_mask */
 118          FALSE),                /* pcrel_offset */
 119
 120   /* A 16 bit absolute relocation.  */
 121   HOWTO (R_OPENRISC_16,         /* type */
 122          0,                     /* rightshift */
 123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 124          16,                    /* bitsize */
 125          FALSE,                 /* pc_relative */
 126          0,                     /* bitpos */
 127          complain_overflow_bitfield, /* complain_on_overflow */
 128          bfd_elf_generic_reloc, /* special_function */
 129          "R_OPENRISC_16",       /* name */
 130          TRUE,                  /* partial_inplace */
 131          0x00000000,            /* src_mask */
 132          0x0000ffff,            /* dst_mask */
 133          FALSE),                /* pcrel_offset */
 134
 135   /* A 32 bit absolute relocation.  */
 136   HOWTO (R_OPENRISC_32,         /* type */
 137          0,                     /* rightshift */
 138          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 139          32,                    /* bitsize */
 140          FALSE,                 /* pc_relative */
 141          0,                     /* bitpos */
 142          complain_overflow_bitfield, /* complain_on_overflow */
 143          bfd_elf_generic_reloc, /* special_function */
 144          "R_OPENRISC_32",       /* name */
 145          TRUE,                  /* partial_inplace */
 146          0x00000000,            /* src_mask */
 147          0xffffffff,            /* dst_mask */
 148          FALSE),                /* pcrel_offset */
 149
 150   /* GNU extension to record C++ vtable hierarchy.  */
 151   HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
 152          0,                     /* rightshift */
 153          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 154          0,                     /* bitsize */
 155          FALSE,                 /* pc_relative */
 156          0,                     /* bitpos */
 157          complain_overflow_dont, /* complain_on_overflow */
 158          NULL,                  /* special_function */
 159          "R_OPENRISC_GNU_VTINHERIT", /* name */
 160          FALSE,                 /* partial_inplace */
 161          0,                     /* src_mask */
 162          0,                     /* dst_mask */
 163          FALSE),                /* pcrel_offset */
 164
 165   /* GNU extension to record C++ vtable member usage.  */
 166   HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
 167          0,                     /* rightshift */
 168          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 169          0,                     /* bitsize */
 170          FALSE,                 /* pc_relative */
 171          0,                     /* bitpos */
 172          complain_overflow_dont, /* complain_on_overflow */
 173          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 174          "R_OPENRISC_GNU_VTENTRY", /* name */
 175          FALSE,                 /* partial_inplace */
 176          0,                     /* src_mask */
 177          0,                     /* dst_mask */
 178          FALSE),                /* pcrel_offset */
 179 };
 180
 181 /* Map BFD reloc types to OpenRISC ELF reloc types.  */
 182
 183 struct openrisc_reloc_map
 184 {
 185   bfd_reloc_code_real_type bfd_reloc_val;
 186   unsigned int openrisc_reloc_val;
 187 };
 188
 189 static const struct openrisc_reloc_map openrisc_reloc_map[] =
 190 {
 191   { BFD_RELOC_NONE,             R_OPENRISC_NONE },
 192   { BFD_RELOC_32,               R_OPENRISC_32 },
 193   { BFD_RELOC_16,               R_OPENRISC_16 },
 194   { BFD_RELOC_8,                R_OPENRISC_8 },
 195   { BFD_RELOC_OPENRISC_REL_26,R_OPENRISC_INSN_REL_26 },
 196   { BFD_RELOC_OPENRISC_ABS_26,R_OPENRISC_INSN_ABS_26 },
 197     { BFD_RELOC_HI16,           R_OPENRISC_HI_16_IN_INSN },
 198   { BFD_RELOC_LO16,             R_OPENRISC_LO_16_IN_INSN },
 199   { BFD_RELOC_VTABLE_INHERIT,   R_OPENRISC_GNU_VTINHERIT },
 200   { BFD_RELOC_VTABLE_ENTRY,     R_OPENRISC_GNU_VTENTRY }
 201 };
 202
 203 static reloc_howto_type *
 204 openrisc_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 205                             bfd_reloc_code_real_type code)
 206 {
 207   unsigned int i;
 208
 209   for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
 210     if (openrisc_reloc_map[i].bfd_reloc_val == code)
 211       return & openrisc_elf_howto_table[openrisc_reloc_map[i].
 212                                        openrisc_reloc_val];
 213
 214   return NULL;
 215 }
 216
 217 /* Set the howto pointer for an OpenRISC ELF reloc.  */
 218
 219 static void
 220 openrisc_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 221                              arelent * cache_ptr,
 222                              Elf_Internal_Rela * dst)
 223 {
 224   unsigned int r_type;
 225
 226   r_type = ELF32_R_TYPE (dst->r_info);
 227   BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
 228   cache_ptr->howto = & openrisc_elf_howto_table[r_type];
 229 }
 230
 231 /* Perform a single relocation.  By default we use the standard BFD
 232    routines, but a few relocs, we have to do them ourselves.  */
 233
 234 static bfd_reloc_status_type
 235 openrisc_final_link_relocate (reloc_howto_type *howto,
 236                               bfd *input_bfd,
 237                               asection *input_section,
 238                               bfd_byte *contents,
 239                               Elf_Internal_Rela *rel,
 240                               bfd_vma relocation)
 241 {
 242   bfd_reloc_status_type r = bfd_reloc_ok;
 243
 244   switch (howto->type)
 245     {
 246     case R_OPENRISC_LO_16_IN_INSN:
 247       relocation &= 0xffff;
 248       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 249                                     contents, rel->r_offset,
 250                                     relocation, rel->r_addend);
 251       break;
 252
 253     default:
 254       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 255                                     contents, rel->r_offset,
 256                                     relocation, rel->r_addend);
 257     }
 258
 259   return r;
 260 }
 261
 262 /* Relocate an OpenRISC ELF section.
 263
 264    The RELOCATE_SECTION function is called by the new ELF backend linker
 265    to handle the relocations for a section.
 266
 267    The relocs are always passed as Rela structures; if the section
 268    actually uses Rel structures, the r_addend field will always be
 269    zero.
 270
 271    This function is responsible for adjusting the section contents as
 272    necessary, and (if using Rela relocs and generating a relocatable
 273    output file) adjusting the reloc addend as necessary.
 274
 275    This function does not have to worry about setting the reloc
 276    address or the reloc symbol index.
 277
 278    LOCAL_SYMS is a pointer to the swapped in local symbols.
 279
 280    LOCAL_SECTIONS is an array giving the section in the input file
 281    corresponding to the st_shndx field of each local symbol.
 282
 283    The global hash table entry for the global symbols can be found
 284    via elf_sym_hashes (input_bfd).
 285
 286    When generating relocatable output, this function must handle
 287    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 288    going to be the section symbol corresponding to the output
 289    section, which means that the addend must be adjusted
 290    accordingly.  */
 291
 292 static bfd_boolean
 293 openrisc_elf_relocate_section (bfd *output_bfd,
 294                                struct bfd_link_info *info,
 295                                bfd *input_bfd,
 296                                asection *input_section,
 297                                bfd_byte *contents,
 298                                Elf_Internal_Rela *relocs,
 299                                Elf_Internal_Sym *local_syms,
 300                                asection **local_sections)
 301 {
 302   Elf_Internal_Shdr *symtab_hdr;
 303   struct elf_link_hash_entry **sym_hashes;
 304   Elf_Internal_Rela *rel;
 305   Elf_Internal_Rela *relend;
 306
 307   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 308   sym_hashes = elf_sym_hashes (input_bfd);
 309   relend = relocs + input_section->reloc_count;
 310
 311   for (rel = relocs; rel < relend; rel++)
 312     {
 313       reloc_howto_type *howto;
 314       unsigned long r_symndx;
 315       Elf_Internal_Sym *sym;
 316       asection *sec;
 317       struct elf_link_hash_entry *h;
 318       bfd_vma relocation;
 319       bfd_reloc_status_type r;
 320       const char *name = NULL;
 321       int r_type;
 322
 323       r_type = ELF32_R_TYPE (rel->r_info);
 324       r_symndx = ELF32_R_SYM (rel->r_info);
 325
 326       if (r_type == R_OPENRISC_GNU_VTINHERIT
 327           || r_type == R_OPENRISC_GNU_VTENTRY)
 328         continue;
 329
 330       if ((unsigned int) r_type >
 331           (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
 332         abort ();
 333
 334       howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 335       h = NULL;
 336       sym = NULL;
 337       sec = NULL;
 338
 339       if (r_symndx < symtab_hdr->sh_info)
 340         {
 341           sym = local_syms + r_symndx;
 342           sec = local_sections[r_symndx];
 343           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 344
 345           name = bfd_elf_string_from_elf_section
 346             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 347           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 348         }
 349       else
 350         {
 351           bfd_boolean unresolved_reloc, warned;
 352
 353           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 354                                    r_symndx, symtab_hdr, sym_hashes,
 355                                    h, sec, relocation,
 356                                    unresolved_reloc, warned);
 357         }
 358
 359       if (sec != NULL && elf_discarded_section (sec))
 360         {
 361           /* For relocs against symbols from removed linkonce sections,
 362              or sections discarded by a linker script, we just want the
 363              section contents zeroed.  Avoid any special processing.  */
 364           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 365           rel->r_info = 0;
 366           rel->r_addend = 0;
 367           continue;
 368         }
 369
 370       if (info->relocatable)
 371         continue;
 372
 373       r = openrisc_final_link_relocate (howto, input_bfd, input_section,
 374                                         contents, rel, relocation);
 375
 376       if (r != bfd_reloc_ok)
 377         {
 378           const char *msg = NULL;
 379
 380           switch (r)
 381             {
 382             case bfd_reloc_overflow:
 383               r = info->callbacks->reloc_overflow
 384                 (info, (h ? &h->root : NULL), name, howto->name,
 385                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
 386               break;
 387
 388             case bfd_reloc_undefined:
 389               r = info->callbacks->undefined_symbol
 390                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 391               break;
 392
 393             case bfd_reloc_outofrange:
 394               msg = _("internal error: out of range error");
 395               break;
 396
 397             case bfd_reloc_notsupported:
 398               msg = _("internal error: unsupported relocation error");
 399               break;
 400
 401             case bfd_reloc_dangerous:
 402               msg = _("internal error: dangerous relocation");
 403               break;
 404
 405             default:
 406               msg = _("internal error: unknown error");
 407               break;
 408             }
 409
 410           if (msg)
 411             r = info->callbacks->warning
 412               (info, msg, name, input_bfd, input_section, rel->r_offset);
 413
 414           if (!r)
 415             return FALSE;
 416         }
 417     }
 418
 419   return TRUE;
 420 }
 421
 422 /* Return the section that should be marked against GC for a given
 423    relocation.  */
 424
 425 static asection *
 426 openrisc_elf_gc_mark_hook (asection *sec,
 427                            struct bfd_link_info *info,
 428                            Elf_Internal_Rela *rel,
 429                            struct elf_link_hash_entry *h,
 430                            Elf_Internal_Sym *sym)
 431 {
 432   if (h != NULL)
 433     switch (ELF32_R_TYPE (rel->r_info))
 434       {
 435       case R_OPENRISC_GNU_VTINHERIT:
 436       case R_OPENRISC_GNU_VTENTRY:
 437         return NULL;
 438       }
 439
 440   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 441 }
 442
 443 /* Look through the relocs for a section during the first phase.
 444    Since we don't do .gots or .plts, we just need to consider the
 445    virtual table relocs for gc.  */
 446
 447 static bfd_boolean
 448 openrisc_elf_check_relocs (bfd *abfd,
 449                            struct bfd_link_info *info,
 450                            asection *sec,
 451                            const Elf_Internal_Rela *relocs)
 452 {
 453   Elf_Internal_Shdr *symtab_hdr;
 454   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 455   const Elf_Internal_Rela *rel;
 456   const Elf_Internal_Rela *rel_end;
 457
 458   if (info->relocatable)
 459     return TRUE;
 460
 461   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 462   sym_hashes = elf_sym_hashes (abfd);
 463   sym_hashes_end =
 464     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 465   if (!elf_bad_symtab (abfd))
 466     sym_hashes_end -= symtab_hdr->sh_info;
 467
 468   rel_end = relocs + sec->reloc_count;
 469   for (rel = relocs; rel < rel_end; rel++)
 470     {
 471       struct elf_link_hash_entry *h;
 472       unsigned long r_symndx;
 473
 474       r_symndx = ELF32_R_SYM (rel->r_info);
 475       if (r_symndx < symtab_hdr->sh_info)
 476         h = NULL;
 477       else
 478         {
 479           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 480           while (h->root.type == bfd_link_hash_indirect
 481                  || h->root.type == bfd_link_hash_warning)
 482             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 483         }
 484
 485       switch (ELF32_R_TYPE (rel->r_info))
 486         {
 487           /* This relocation describes the C++ object vtable hierarchy.
 488              Reconstruct it for later use during GC.  */
 489         case R_OPENRISC_GNU_VTINHERIT:
 490           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 491             return FALSE;
 492           break;
 493
 494           /* This relocation describes which C++ vtable entries are actually
 495              used.  Record for later use during GC.  */
 496         case R_OPENRISC_GNU_VTENTRY:
 497           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 498             return FALSE;
 499           break;
 500         }
 501     }
 502
 503   return TRUE;
 504 }
 505
 506 /* Set the right machine number.  */
 507
 508 static bfd_boolean
 509 openrisc_elf_object_p (bfd *abfd)
 510 {
 511   bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
 512   return TRUE;
 513 }
 514
 515 /* Store the machine number in the flags field.  */
 516
 517 static void
 518 openrisc_elf_final_write_processing (bfd *abfd,
 519                                      bfd_boolean linker ATTRIBUTE_UNUSED)
 520 {
 521   unsigned long val;
 522
 523   switch (bfd_get_mach (abfd))
 524     {
 525     default:
 526       val = 0;
 527       break;
 528     }
 529
 530   elf_elfheader (abfd)->e_flags &= ~0xf;
 531   elf_elfheader (abfd)->e_flags |= val;
 532 }
 533
 534
 535 #define ELF_ARCH                        bfd_arch_openrisc
 536 #define ELF_MACHINE_CODE                EM_OPENRISC
 537 #define ELF_MACHINE_ALT1                EM_OPENRISC_OLD
 538 #define ELF_MAXPAGESIZE                 0x1000
 539
 540 #define TARGET_BIG_SYM                  bfd_elf32_openrisc_vec
 541 #define TARGET_BIG_NAME                 "elf32-openrisc"
 542
 543 #define elf_info_to_howto_rel           NULL
 544 #define elf_info_to_howto               openrisc_info_to_howto_rela
 545 #define elf_backend_relocate_section    openrisc_elf_relocate_section
 546 #define elf_backend_gc_mark_hook        openrisc_elf_gc_mark_hook
 547 #define elf_backend_check_relocs        openrisc_elf_check_relocs
 548
 549 #define elf_backend_can_gc_sections     1
 550 #define elf_backend_rela_normal         1
 551
 552 #define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
 553
 554 #define elf_backend_object_p                openrisc_elf_object_p
 555 #define elf_backend_final_write_processing  openrisc_elf_final_write_processing
 556
 557 #include "elf32-target.h"