bfd/elf32-moxie.c

   1 /* moxie-specific support for 32-bit ELF.
   2    Copyright (C) 2009-2018 Free Software Foundation, Inc.
   3
   4    Copied from elf32-fr30.c which is..
   5    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28 #include "elf/moxie.h"
  29
  30 /* Forward declarations.  */
  31
  32 static reloc_howto_type moxie_elf_howto_table [] =
  33 {
  34   /* This reloc does nothing.  */
  35   HOWTO (R_MOXIE_NONE,          /* type */
  36          0,                     /* rightshift */
  37          3,                     /* size (0 = byte, 1 = short, 2 = long) */
  38          0,                     /* bitsize */
  39          FALSE,                 /* pc_relative */
  40          0,                     /* bitpos */
  41          complain_overflow_dont, /* complain_on_overflow */
  42          bfd_elf_generic_reloc, /* special_function */
  43          "R_MOXIE_NONE",                /* name */
  44          FALSE,                 /* partial_inplace */
  45          0,                     /* src_mask */
  46          0,                     /* dst_mask */
  47          FALSE),                /* pcrel_offset */
  48
  49   /* A 32 bit absolute relocation.  */
  50   HOWTO (R_MOXIE_32,            /* 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_bitfield, /* complain_on_overflow */
  57          bfd_elf_generic_reloc, /* special_function */
  58          "R_MOXIE_32",          /* name */
  59          FALSE,                 /* partial_inplace */
  60          0x00000000,            /* src_mask */
  61          0xffffffff,            /* dst_mask */
  62          FALSE),                /* pcrel_offset */
  63
  64   /* A 10 bit PC-relative relocation.  */
  65   HOWTO (R_MOXIE_PCREL10,       /* type.  */
  66          1,                     /* rightshift.  */
  67          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
  68          10,                    /* bitsize.  */
  69          TRUE,                  /* pc_relative.  */
  70          0,                     /* bitpos.  */
  71          complain_overflow_signed, /* complain_on_overflow.  */
  72          bfd_elf_generic_reloc, /* special_function.  */
  73          "R_MOXIE_PCREL10",             /* name.  */
  74          FALSE,                 /* partial_inplace.  */
  75          0,                     /* src_mask.  */
  76          0x000003FF,            /* dst_mask.  */
  77          TRUE),                 /* pcrel_offset.  */
  78 };
  79 \f
  80 /* Map BFD reloc types to MOXIE ELF reloc types.  */
  81
  82 struct moxie_reloc_map
  83 {
  84   bfd_reloc_code_real_type bfd_reloc_val;
  85   unsigned int moxie_reloc_val;
  86 };
  87
  88 static const struct moxie_reloc_map moxie_reloc_map [] =
  89 {
  90   { BFD_RELOC_NONE,            R_MOXIE_NONE },
  91   { BFD_RELOC_32,              R_MOXIE_32 },
  92   { BFD_RELOC_MOXIE_10_PCREL,  R_MOXIE_PCREL10 },
  93 };
  94
  95 static reloc_howto_type *
  96 moxie_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
  97                          bfd_reloc_code_real_type code)
  98 {
  99   unsigned int i;
 100
 101   for (i = sizeof (moxie_reloc_map) / sizeof (moxie_reloc_map[0]);
 102        i--;)
 103     if (moxie_reloc_map [i].bfd_reloc_val == code)
 104       return & moxie_elf_howto_table [moxie_reloc_map[i].moxie_reloc_val];
 105
 106   return NULL;
 107 }
 108
 109 static reloc_howto_type *
 110 moxie_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 111 {
 112   unsigned int i;
 113
 114   for (i = 0;
 115        i < sizeof (moxie_elf_howto_table) / sizeof (moxie_elf_howto_table[0]);
 116        i++)
 117     if (moxie_elf_howto_table[i].name != NULL
 118         && strcasecmp (moxie_elf_howto_table[i].name, r_name) == 0)
 119       return &moxie_elf_howto_table[i];
 120
 121   return NULL;
 122 }
 123
 124 /* Set the howto pointer for an MOXIE ELF reloc.  */
 125
 126 static void
 127 moxie_info_to_howto_rela (bfd *abfd,
 128                           arelent *cache_ptr,
 129                           Elf_Internal_Rela *dst)
 130 {
 131   unsigned int r_type;
 132
 133   r_type = ELF32_R_TYPE (dst->r_info);
 134   if (r_type >= (unsigned int) R_MOXIE_max)
 135     {
 136       /* xgettext:c-format */
 137       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 138                           abfd, r_type);
 139       r_type = 0;
 140     }
 141   cache_ptr->howto = & moxie_elf_howto_table [r_type];
 142 }
 143 \f
 144 /* Perform a single relocation.  By default we use the standard BFD
 145    routines, but a few relocs, we have to do them ourselves.  */
 146
 147 static bfd_reloc_status_type
 148 moxie_final_link_relocate (reloc_howto_type *howto,
 149                            bfd *input_bfd,
 150                            asection *input_section,
 151                            bfd_byte *contents,
 152                            Elf_Internal_Rela *rel,
 153                            bfd_vma relocation)
 154 {
 155   bfd_reloc_status_type r = bfd_reloc_ok;
 156
 157   switch (howto->type)
 158     {
 159     default:
 160       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 161                                     contents, rel->r_offset,
 162                                     relocation, rel->r_addend);
 163     }
 164
 165   return r;
 166 }
 167 \f
 168 /* Relocate an MOXIE ELF section.
 169
 170    The RELOCATE_SECTION function is called by the new ELF backend linker
 171    to handle the relocations for a section.
 172
 173    The relocs are always passed as Rela structures; if the section
 174    actually uses Rel structures, the r_addend field will always be
 175    zero.
 176
 177    This function is responsible for adjusting the section contents as
 178    necessary, and (if using Rela relocs and generating a relocatable
 179    output file) adjusting the reloc addend as necessary.
 180
 181    This function does not have to worry about setting the reloc
 182    address or the reloc symbol index.
 183
 184    LOCAL_SYMS is a pointer to the swapped in local symbols.
 185
 186    LOCAL_SECTIONS is an array giving the section in the input file
 187    corresponding to the st_shndx field of each local symbol.
 188
 189    The global hash table entry for the global symbols can be found
 190    via elf_sym_hashes (input_bfd).
 191
 192    When generating relocatable output, this function must handle
 193    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 194    going to be the section symbol corresponding to the output
 195    section, which means that the addend must be adjusted
 196    accordingly.  */
 197
 198 static bfd_boolean
 199 moxie_elf_relocate_section (bfd *output_bfd,
 200                             struct bfd_link_info *info,
 201                             bfd *input_bfd,
 202                             asection *input_section,
 203                             bfd_byte *contents,
 204                             Elf_Internal_Rela *relocs,
 205                             Elf_Internal_Sym *local_syms,
 206                             asection **local_sections)
 207 {
 208   Elf_Internal_Shdr *symtab_hdr;
 209   struct elf_link_hash_entry **sym_hashes;
 210   Elf_Internal_Rela *rel;
 211   Elf_Internal_Rela *relend;
 212
 213   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 214   sym_hashes = elf_sym_hashes (input_bfd);
 215   relend     = relocs + input_section->reloc_count;
 216
 217   for (rel = relocs; rel < relend; rel ++)
 218     {
 219       reloc_howto_type *howto;
 220       unsigned long r_symndx;
 221       Elf_Internal_Sym *sym;
 222       asection *sec;
 223       struct elf_link_hash_entry *h;
 224       bfd_vma relocation;
 225       bfd_reloc_status_type r;
 226       const char *name;
 227       int r_type;
 228
 229       r_type = ELF32_R_TYPE (rel->r_info);
 230       r_symndx = ELF32_R_SYM (rel->r_info);
 231       howto  = moxie_elf_howto_table + r_type;
 232       h      = NULL;
 233       sym    = NULL;
 234       sec    = NULL;
 235
 236       if (r_symndx < symtab_hdr->sh_info)
 237         {
 238           sym = local_syms + r_symndx;
 239           sec = local_sections [r_symndx];
 240           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 241
 242           name = bfd_elf_string_from_elf_section
 243             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 244           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 245         }
 246       else
 247         {
 248           bfd_boolean unresolved_reloc, warned, ignored;
 249
 250           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 251                                    r_symndx, symtab_hdr, sym_hashes,
 252                                    h, sec, relocation,
 253                                    unresolved_reloc, warned, ignored);
 254
 255           name = h->root.root.string;
 256         }
 257
 258       if (sec != NULL && discarded_section (sec))
 259         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 260                                          rel, 1, relend, howto, 0, contents);
 261
 262       if (bfd_link_relocatable (info))
 263         continue;
 264
 265       r = moxie_final_link_relocate (howto, input_bfd, input_section,
 266                                      contents, rel, relocation);
 267
 268       if (r != bfd_reloc_ok)
 269         {
 270           const char * msg = NULL;
 271
 272           switch (r)
 273             {
 274             case bfd_reloc_overflow:
 275               (*info->callbacks->reloc_overflow)
 276                 (info, (h ? &h->root : NULL), name, howto->name,
 277                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
 278               break;
 279
 280             case bfd_reloc_undefined:
 281               (*info->callbacks->undefined_symbol)
 282                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 283               break;
 284
 285             case bfd_reloc_outofrange:
 286               msg = _("internal error: out of range error");
 287               break;
 288
 289             case bfd_reloc_notsupported:
 290               msg = _("internal error: unsupported relocation error");
 291               break;
 292
 293             case bfd_reloc_dangerous:
 294               msg = _("internal error: dangerous relocation");
 295               break;
 296
 297             default:
 298               msg = _("internal error: unknown error");
 299               break;
 300             }
 301
 302           if (msg)
 303             (*info->callbacks->warning) (info, msg, name, input_bfd,
 304                                          input_section, rel->r_offset);
 305         }
 306     }
 307
 308   return TRUE;
 309 }
 310 \f
 311 /* Return the section that should be marked against GC for a given
 312    relocation.  */
 313
 314 static asection *
 315 moxie_elf_gc_mark_hook (asection *sec,
 316                         struct bfd_link_info *info,
 317                         Elf_Internal_Rela *rel,
 318                         struct elf_link_hash_entry *h,
 319                         Elf_Internal_Sym *sym)
 320 {
 321   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 322 }
 323
 324 /* Look through the relocs for a section during the first phase.
 325    Since we don't do .gots or .plts, we just need to consider the
 326    virtual table relocs for gc.  */
 327
 328 static bfd_boolean
 329 moxie_elf_check_relocs (bfd *abfd,
 330                         struct bfd_link_info *info,
 331                         asection *sec,
 332                         const Elf_Internal_Rela *relocs)
 333 {
 334   Elf_Internal_Shdr *symtab_hdr;
 335   struct elf_link_hash_entry **sym_hashes;
 336   const Elf_Internal_Rela *rel;
 337   const Elf_Internal_Rela *rel_end;
 338
 339   if (bfd_link_relocatable (info))
 340     return TRUE;
 341
 342   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 343   sym_hashes = elf_sym_hashes (abfd);
 344
 345   rel_end = relocs + sec->reloc_count;
 346   for (rel = relocs; rel < rel_end; rel++)
 347     {
 348       struct elf_link_hash_entry *h;
 349       unsigned long r_symndx;
 350
 351       r_symndx = ELF32_R_SYM (rel->r_info);
 352       if (r_symndx < symtab_hdr->sh_info)
 353         h = NULL;
 354       else
 355         {
 356           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 357           while (h->root.type == bfd_link_hash_indirect
 358                  || h->root.type == bfd_link_hash_warning)
 359             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 360         }
 361     }
 362
 363   return TRUE;
 364 }
 365 \f
 366 #define ELF_ARCH                bfd_arch_moxie
 367 #define ELF_MACHINE_CODE        EM_MOXIE
 368 #define ELF_MACHINE_ALT1        EM_MOXIE_OLD
 369 #define ELF_MAXPAGESIZE         0x1
 370
 371 #define TARGET_BIG_SYM          moxie_elf32_be_vec
 372 #define TARGET_BIG_NAME         "elf32-bigmoxie"
 373 #define TARGET_LITTLE_SYM       moxie_elf32_le_vec
 374 #define TARGET_LITTLE_NAME      "elf32-littlemoxie"
 375
 376 #define elf_info_to_howto_rel                   NULL
 377 #define elf_info_to_howto                       moxie_info_to_howto_rela
 378 #define elf_backend_relocate_section            moxie_elf_relocate_section
 379 #define elf_backend_gc_mark_hook                moxie_elf_gc_mark_hook
 380 #define elf_backend_check_relocs                moxie_elf_check_relocs
 381
 382 #define elf_backend_can_gc_sections             1
 383 #define elf_backend_rela_normal                 1
 384
 385 #define bfd_elf32_bfd_reloc_type_lookup         moxie_reloc_type_lookup
 386 #define bfd_elf32_bfd_reloc_name_lookup         moxie_reloc_name_lookup
 387
 388 #include "elf32-target.h"