bfd/elf32-mt.c

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