bfd/elf32-mt.c

   1 /* Morpho Technologies MT specific support for 32-bit ELF
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2011
   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 3 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,
  20    MA 02111-1307, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/mt.h"
  27
  28 /* Prototypes.  */
  29 static reloc_howto_type * mt_reloc_type_lookup
  30   (bfd *, bfd_reloc_code_real_type);
  31
  32 static void mt_info_to_howto_rela
  33   (bfd *, arelent *, Elf_Internal_Rela *);
  34
  35 static bfd_reloc_status_type mt_elf_relocate_hi16
  36   (bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
  37
  38 static bfd_reloc_status_type mt_final_link_relocate
  39   (reloc_howto_type *, bfd *, asection *, bfd_byte *,
  40    Elf_Internal_Rela *, bfd_vma);
  41
  42 static bfd_boolean mt_elf_relocate_section
  43   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  44    Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
  45
  46 /* Relocation tables.  */
  47 static reloc_howto_type mt_elf_howto_table [] =
  48 {
  49   /* This reloc does nothing.  */
  50   HOWTO (R_MT_NONE,           /* type */
  51           0,                      /* rightshift */
  52           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  53           32,                     /* bitsize */
  54           FALSE,                  /* pc_relative */
  55           0,                      /* bitpos */
  56           complain_overflow_dont, /* complain_on_overflow */
  57           bfd_elf_generic_reloc,  /* special_function */
  58           "R_MT_NONE",          /* name */
  59           FALSE,                  /* partial_inplace */
  60           0 ,                     /* src_mask */
  61           0,                      /* dst_mask */
  62           FALSE),                 /* pcrel_offset */
  63
  64   /* A 16 bit absolute relocation.  */
  65   HOWTO (R_MT_16,             /* type */
  66           0,                      /* rightshift */
  67           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  68           16,                     /* bitsize */
  69           FALSE,                  /* pc_relative */
  70           0,                      /* bitpos */
  71           complain_overflow_dont, /* complain_on_overflow */
  72           bfd_elf_generic_reloc,  /* special_function */
  73           "R_MT_16",            /* name */
  74           FALSE,                  /* partial_inplace */
  75           0 ,                     /* src_mask */
  76           0xffff,                 /* dst_mask */
  77           FALSE),                 /* pcrel_offset */
  78
  79   /* A 32 bit absolute relocation.  */
  80   HOWTO (R_MT_32,             /* type */
  81           0,                      /* rightshift */
  82           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  83           32,                     /* bitsize */
  84           FALSE,                  /* pc_relative */
  85           0,                      /* bitpos */
  86           complain_overflow_dont, /* complain_on_overflow */
  87           bfd_elf_generic_reloc,  /* special_function */
  88           "R_MT_32",            /* name */
  89           FALSE,                  /* partial_inplace */
  90           0 ,                     /* src_mask */
  91           0xffffffff,             /* dst_mask */
  92           FALSE),                 /* pcrel_offset */
  93
  94   /* A 32 bit pc-relative relocation.  */
  95   HOWTO (R_MT_32_PCREL,       /* type */
  96           0,                      /* rightshift */
  97           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  98           32,                     /* bitsize */
  99           TRUE,                   /* pc_relative */
 100           0,                      /* bitpos */
 101           complain_overflow_dont, /* complain_on_overflow */
 102           bfd_elf_generic_reloc,  /* special_function */
 103           "R_MT_32_PCREL",    /* name */
 104           FALSE,                  /* partial_inplace */
 105           0 ,                     /* src_mask */
 106           0xffffffff,             /* dst_mask */
 107           TRUE),                  /* pcrel_offset */
 108
 109   /* A 16 bit pc-relative relocation.  */
 110   HOWTO (R_MT_PC16,           /* type */
 111           0,                      /* rightshift */
 112           2,                      /* size (0 = byte, 1 = short, 2 = long) */
 113           16,                     /* bitsize */
 114           TRUE,                   /* pc_relative */
 115           0,                      /* bitpos */
 116           complain_overflow_signed, /* complain_on_overflow */
 117           bfd_elf_generic_reloc,  /* special_function */
 118           "R_MT_PC16",          /* name */
 119           FALSE,                  /* partial_inplace */
 120           0,                      /* src_mask */
 121           0xffff,                 /* dst_mask */
 122           TRUE),                  /* pcrel_offset */
 123
 124   /* high 16 bits of symbol value.  */
 125   HOWTO (R_MT_HI16,          /* type */
 126          0,                     /* rightshift */
 127          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 128          16,                    /* bitsize */
 129          FALSE,                 /* pc_relative */
 130          0,                     /* bitpos */
 131          complain_overflow_dont, /* complain_on_overflow */
 132          bfd_elf_generic_reloc, /* special_function */
 133          "R_MT_HI16",        /* name */
 134          FALSE,                  /* partial_inplace */
 135          0xffff0000,            /* src_mask */
 136          0xffff0000,            /* dst_mask */
 137          FALSE),                /* pcrel_offset */
 138
 139   /* Low 16 bits of symbol value.  */
 140   HOWTO (R_MT_LO16,          /* type */
 141          0,                     /* rightshift */
 142          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 143          16,                    /* bitsize */
 144          FALSE,                 /* pc_relative */
 145          0,                     /* bitpos */
 146          complain_overflow_dont, /* complain_on_overflow */
 147          bfd_elf_generic_reloc, /* special_function */
 148          "R_MT_LO16",        /* name */
 149          FALSE,                  /* partial_inplace */
 150          0xffff,                /* src_mask */
 151          0xffff,                /* dst_mask */
 152          FALSE),                /* pcrel_offset */
 153 };
 154
 155 /* Map BFD reloc types to MT ELF reloc types.  */
 156
 157 static reloc_howto_type *
 158 mt_reloc_type_lookup
 159     (bfd *                    abfd ATTRIBUTE_UNUSED,
 160      bfd_reloc_code_real_type code)
 161 {
 162   /* Note that the mt_elf_howto_table is indxed by the R_
 163      constants.  Thus, the order that the howto records appear in the
 164      table *must* match the order of the relocation types defined in
 165      include/elf/mt.h.  */
 166
 167   switch (code)
 168     {
 169     case BFD_RELOC_NONE:
 170       return &mt_elf_howto_table[ (int) R_MT_NONE];
 171     case BFD_RELOC_16:
 172       return &mt_elf_howto_table[ (int) R_MT_16];
 173     case BFD_RELOC_32:
 174       return &mt_elf_howto_table[ (int) R_MT_32];
 175     case BFD_RELOC_32_PCREL:
 176       return &mt_elf_howto_table[ (int) R_MT_32_PCREL];
 177     case BFD_RELOC_16_PCREL:
 178       return &mt_elf_howto_table[ (int) R_MT_PC16];
 179     case BFD_RELOC_HI16:
 180       return &mt_elf_howto_table[ (int) R_MT_HI16];
 181     case BFD_RELOC_LO16:
 182       return &mt_elf_howto_table[ (int) R_MT_LO16];
 183
 184     default:
 185       /* Pacify gcc -Wall.  */
 186       return NULL;
 187     }
 188   return NULL;
 189 }
 190
 191 static reloc_howto_type *
 192 mt_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 193                       const char *r_name)
 194 {
 195   unsigned int i;
 196
 197   for (i = 0;
 198        i < sizeof (mt_elf_howto_table) / sizeof (mt_elf_howto_table[0]);
 199        i++)
 200     if (mt_elf_howto_table[i].name != NULL
 201         && strcasecmp (mt_elf_howto_table[i].name, r_name) == 0)
 202       return &mt_elf_howto_table[i];
 203
 204   return NULL;
 205 }
 206
 207 bfd_reloc_status_type
 208 mt_elf_relocate_hi16
 209     (bfd *               input_bfd,
 210      Elf_Internal_Rela * relhi,
 211      bfd_byte *          contents,
 212      bfd_vma             value)
 213 {
 214   bfd_vma insn;
 215
 216   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
 217
 218   value += relhi->r_addend;
 219   value >>= 16;
 220   insn = ((insn & ~0xFFFF) | value);
 221
 222   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
 223   return bfd_reloc_ok;
 224 }
 225 \f
 226 /* XXX: The following code is the result of a cut&paste.  This unfortunate
 227    practice is very widespread in the various target back-end files.  */
 228
 229 /* Set the howto pointer for a MT ELF reloc.  */
 230
 231 static void
 232 mt_info_to_howto_rela
 233     (bfd *               abfd ATTRIBUTE_UNUSED,
 234      arelent *           cache_ptr,
 235      Elf_Internal_Rela * dst)
 236 {
 237   unsigned int r_type;
 238
 239   r_type = ELF32_R_TYPE (dst->r_info);
 240   cache_ptr->howto = & mt_elf_howto_table [r_type];
 241 }
 242
 243 /* Perform a single relocation.  By default we use the standard BFD
 244    routines.  */
 245
 246 static bfd_reloc_status_type
 247 mt_final_link_relocate
 248     (reloc_howto_type *  howto,
 249      bfd *               input_bfd,
 250      asection *          input_section,
 251      bfd_byte *          contents,
 252      Elf_Internal_Rela * rel,
 253      bfd_vma             relocation)
 254 {
 255   return _bfd_final_link_relocate (howto, input_bfd, input_section,
 256                                    contents, rel->r_offset,
 257                                    relocation, rel->r_addend);
 258 }
 259
 260 /* Relocate a MT ELF section.
 261    There is some attempt to make this function usable for many architectures,
 262    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 263    if only to serve as a learning tool.
 264
 265    The RELOCATE_SECTION function is called by the new ELF backend linker
 266    to handle the relocations for a section.
 267
 268    The relocs are always passed as Rela structures; if the section
 269    actually uses Rel structures, the r_addend field will always be
 270    zero.
 271
 272    This function is responsible for adjusting the section contents as
 273    necessary, and (if using Rela relocs and generating a relocatable
 274    output file) adjusting the reloc addend as necessary.
 275
 276    This function does not have to worry about setting the reloc
 277    address or the reloc symbol index.
 278
 279    LOCAL_SYMS is a pointer to the swapped in local symbols.
 280
 281    LOCAL_SECTIONS is an array giving the section in the input file
 282    corresponding to the st_shndx field of each local symbol.
 283
 284    The global hash table entry for the global symbols can be found
 285    via elf_sym_hashes (input_bfd).
 286
 287    When generating relocatable output, this function must handle
 288    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 289    going to be the section symbol corresponding to the output
 290    section, which means that the addend must be adjusted
 291    accordingly.  */
 292
 293 static bfd_boolean
 294 mt_elf_relocate_section
 295     (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 296      struct bfd_link_info *  info,
 297      bfd *                   input_bfd,
 298      asection *              input_section,
 299      bfd_byte *              contents,
 300      Elf_Internal_Rela *     relocs,
 301      Elf_Internal_Sym *      local_syms,
 302      asection **             local_sections)
 303 {
 304   Elf_Internal_Shdr *           symtab_hdr;
 305   struct elf_link_hash_entry ** sym_hashes;
 306   Elf_Internal_Rela *           rel;
 307   Elf_Internal_Rela *           relend;
 308
 309   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 310   sym_hashes = elf_sym_hashes (input_bfd);
 311   relend     = relocs + input_section->reloc_count;
 312
 313   for (rel = relocs; rel < relend; rel ++)
 314     {
 315       reloc_howto_type *           howto;
 316       unsigned long                r_symndx;
 317       Elf_Internal_Sym *           sym;
 318       asection *                   sec;
 319       struct elf_link_hash_entry * h;
 320       bfd_vma                      relocation;
 321       bfd_reloc_status_type        r;
 322       const char *                 name = NULL;
 323       int                          r_type;
 324
 325       r_type = ELF32_R_TYPE (rel->r_info);
 326
 327       r_symndx = ELF32_R_SYM (rel->r_info);
 328
 329       howto  = mt_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 330       h      = NULL;
 331       sym    = NULL;
 332       sec    = NULL;
 333
 334       if (r_symndx < symtab_hdr->sh_info)
 335         {
 336           sym = local_syms + r_symndx;
 337           sec = local_sections [r_symndx];
 338           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 339
 340           name = bfd_elf_string_from_elf_section
 341             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 342           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 343         }
 344       else
 345         {
 346           bfd_boolean unresolved_reloc;
 347           bfd_boolean warned;
 348
 349           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 350                                    r_symndx, symtab_hdr, sym_hashes,
 351                                    h, sec, relocation,
 352                                    unresolved_reloc, warned);
 353
 354           name = h->root.root.string;
 355         }
 356
 357       if (sec != NULL && elf_discarded_section (sec))
 358         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 359                                          rel, relend, howto, contents);
 360
 361       if (info->relocatable)
 362         continue;
 363
 364       /* Finally, the sole MT-specific part.  */
 365       switch (r_type)
 366         {
 367         case R_MT_HI16:
 368           r = mt_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 369           break;
 370         default:
 371           r = mt_final_link_relocate (howto, input_bfd, input_section,
 372                                           contents, rel, relocation);
 373           break;
 374         }
 375
 376
 377       if (r != bfd_reloc_ok)
 378         {
 379           const char * msg = (const char *) NULL;
 380
 381           switch (r)
 382             {
 383             case bfd_reloc_overflow:
 384               r = info->callbacks->reloc_overflow
 385                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 386                  input_bfd, input_section, rel->r_offset);
 387               break;
 388
 389             case bfd_reloc_undefined:
 390               r = info->callbacks->undefined_symbol
 391                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 392               break;
 393
 394             case bfd_reloc_outofrange:
 395               msg = _("internal error: out of range error");
 396               break;
 397
 398             case bfd_reloc_dangerous:
 399               msg = _("internal error: dangerous relocation");
 400               break;
 401
 402             default:
 403               msg = _("internal error: unknown error");
 404               break;
 405             }
 406
 407           if (msg)
 408             r = info->callbacks->warning
 409               (info, msg, name, input_bfd, input_section, rel->r_offset);
 410
 411           if (! r)
 412             return FALSE;
 413         }
 414     }
 415
 416   return TRUE;
 417 }
 418
 419 /* Look through the relocs for a section during the first phase.
 420    Since we don't do .gots or .plts, we just need to consider the
 421    virtual table relocs for gc.  */
 422
 423 static bfd_boolean
 424 mt_elf_check_relocs
 425     (bfd *                     abfd,
 426      struct bfd_link_info *    info,
 427      asection *                sec,
 428      const Elf_Internal_Rela * relocs)
 429 {
 430   Elf_Internal_Shdr *           symtab_hdr;
 431   struct elf_link_hash_entry ** sym_hashes;
 432   const Elf_Internal_Rela *     rel;
 433   const Elf_Internal_Rela *     rel_end;
 434
 435   if (info->relocatable)
 436     return TRUE;
 437
 438   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 439   sym_hashes = elf_sym_hashes (abfd);
 440
 441   rel_end = relocs + sec->reloc_count;
 442   for (rel = relocs; rel < rel_end; rel++)
 443     {
 444       struct elf_link_hash_entry *h;
 445       unsigned long r_symndx;
 446
 447       r_symndx = ELF32_R_SYM (rel->r_info);
 448       if (r_symndx < symtab_hdr->sh_info)
 449         h = NULL;
 450       else
 451         {
 452           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 453           while (h->root.type == bfd_link_hash_indirect
 454                  || h->root.type == bfd_link_hash_warning)
 455             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 456         }
 457     }
 458
 459   return TRUE;
 460 }
 461
 462 /* Return the MACH for an e_flags value.  */
 463
 464 static int
 465 elf32_mt_machine (bfd *abfd)
 466 {
 467   switch (elf_elfheader (abfd)->e_flags & EF_MT_CPU_MASK)
 468     {
 469     case EF_MT_CPU_MRISC:       return bfd_mach_ms1;
 470     case EF_MT_CPU_MRISC2:      return bfd_mach_mrisc2;
 471     case EF_MT_CPU_MS2:         return bfd_mach_ms2;
 472     }
 473
 474   return bfd_mach_ms1;
 475 }
 476
 477 static bfd_boolean
 478 mt_elf_object_p (bfd * abfd)
 479 {
 480   bfd_default_set_arch_mach (abfd, bfd_arch_mt, elf32_mt_machine (abfd));
 481
 482   return TRUE;
 483 }
 484
 485 /* Function to set the ELF flag bits.  */
 486
 487 static bfd_boolean
 488 mt_elf_set_private_flags (bfd *    abfd,
 489                            flagword flags)
 490 {
 491   elf_elfheader (abfd)->e_flags = flags;
 492   elf_flags_init (abfd) = TRUE;
 493   return TRUE;
 494 }
 495
 496 static bfd_boolean
 497 mt_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd)
 498 {
 499   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 500       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 501     return TRUE;
 502
 503   BFD_ASSERT (!elf_flags_init (obfd)
 504               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 505
 506   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 507   elf_flags_init (obfd) = TRUE;
 508
 509   /* Copy object attributes.  */
 510   _bfd_elf_copy_obj_attributes (ibfd, obfd);
 511
 512   return TRUE;
 513 }
 514
 515 /* Merge backend specific data from an object file to the output
 516    object file when linking.  */
 517
 518 static bfd_boolean
 519 mt_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
 520 {
 521   flagword     old_flags, new_flags;
 522   bfd_boolean  ok = TRUE;
 523
 524   /* Check if we have the same endianness.  */
 525   if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
 526     return FALSE;
 527
 528   /* If they're not both mt, then merging is meaningless, so just
 529      don't do it.  */
 530   if (strcmp (ibfd->arch_info->arch_name, "mt") != 0)
 531     return TRUE;
 532   if (strcmp (obfd->arch_info->arch_name, "mt") != 0)
 533     return TRUE;
 534
 535   new_flags = elf_elfheader (ibfd)->e_flags;
 536   old_flags = elf_elfheader (obfd)->e_flags;
 537
 538 #ifdef DEBUG
 539   _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
 540                       ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
 541 #endif
 542
 543   if (!elf_flags_init (obfd))
 544     {
 545       old_flags = new_flags;
 546       elf_flags_init (obfd) = TRUE;
 547     }
 548   else if ((new_flags & EF_MT_CPU_MASK) != (old_flags & EF_MT_CPU_MASK))
 549     {
 550       /* CPU has changed.  This is invalid, because MRISC, MRISC2 and
 551          MS2 are not subsets of each other.   */
 552       ok = FALSE;
 553     }
 554
 555   if (ok)
 556     {
 557       obfd->arch_info = ibfd->arch_info;
 558       elf_elfheader (obfd)->e_flags = old_flags;
 559     }
 560
 561   return ok;
 562 }
 563
 564 static bfd_boolean
 565 mt_elf_print_private_bfd_data (bfd * abfd, void * ptr)
 566 {
 567   FILE *   file = (FILE *) ptr;
 568   flagword flags;
 569
 570   BFD_ASSERT (abfd != NULL && ptr != NULL);
 571
 572   /* Print normal ELF private data.  */
 573   _bfd_elf_print_private_bfd_data (abfd, ptr);
 574
 575   flags = elf_elfheader (abfd)->e_flags;
 576   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
 577
 578   switch (flags & EF_MT_CPU_MASK)
 579     {
 580     default:
 581     case EF_MT_CPU_MRISC:   fprintf (file, " ms1-16-002");      break;
 582     case EF_MT_CPU_MRISC2:  fprintf (file, " ms1-16-003");      break;
 583     case EF_MT_CPU_MS2:     fprintf (file, " ms2");     break;
 584     }
 585
 586   fputc ('\n', file);
 587
 588   return TRUE;
 589 }
 590
 591 \f
 592 #define TARGET_BIG_SYM   bfd_elf32_mt_vec
 593 #define TARGET_BIG_NAME  "elf32-mt"
 594
 595 #define ELF_ARCH         bfd_arch_mt
 596 #define ELF_MACHINE_CODE EM_MT
 597 #define ELF_MAXPAGESIZE  1 /* No pages on the MT.  */
 598
 599 #define elf_info_to_howto_rel                   NULL
 600 #define elf_info_to_howto                       mt_info_to_howto_rela
 601
 602 #define elf_backend_relocate_section            mt_elf_relocate_section
 603
 604 #define bfd_elf32_bfd_reloc_type_lookup         mt_reloc_type_lookup
 605 #define bfd_elf32_bfd_reloc_name_lookup   mt_reloc_name_lookup
 606
 607 #define elf_backend_check_relocs                mt_elf_check_relocs
 608 #define elf_backend_object_p                    mt_elf_object_p
 609 #define elf_backend_rela_normal                 1
 610
 611 #define elf_backend_can_gc_sections             1
 612
 613 #define bfd_elf32_bfd_set_private_flags         mt_elf_set_private_flags
 614 #define bfd_elf32_bfd_copy_private_bfd_data     mt_elf_copy_private_bfd_data
 615 #define bfd_elf32_bfd_merge_private_bfd_data    mt_elf_merge_private_bfd_data
 616 #define bfd_elf32_bfd_print_private_bfd_data    mt_elf_print_private_bfd_data
 617
 618 #include "elf32-target.h"