bfd/elf32-or32.c

   1 /* OR32-specific support for 32-bit ELF
   2    Copyright 2002 Free Software Foundation, Inc.
   3    Contributed by Ivan Guzvinec  <ivang@opencores.org>
   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 2 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, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/or32.h"
  26 #include "libiberty.h"
  27
  28 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  29   PARAMS ((bfd *, bfd_reloc_code_real_type));
  30 static void or32_info_to_howto_rel
  31   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  32 static bfd_boolean or32_elf_object_p
  33   PARAMS ((bfd *));
  34 static void or32_elf_final_write_processing
  35   PARAMS ((bfd *, bfd_boolean));
  36 static bfd_reloc_status_type or32_elf_32_reloc
  37   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  38 static bfd_reloc_status_type or32_elf_16_reloc
  39   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  40 static bfd_reloc_status_type or32_elf_8_reloc
  41   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  42 static bfd_reloc_status_type or32_elf_const_reloc
  43   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  44 static bfd_reloc_status_type or32_elf_consth_reloc
  45   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  46 static bfd_reloc_status_type or32_elf_jumptarg_reloc
  47   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  48
  49 /* Try to minimize the amount of space occupied by relocation tables
  50    on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
  51 #define USE_REL 1
  52
  53 static reloc_howto_type elf_or32_howto_table[] =
  54 {
  55   /* This reloc does nothing.  */
  56   HOWTO (R_OR32_NONE,           /* type */
  57          0,                     /* rightshift */
  58          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  59          32,                    /* bitsize */
  60          FALSE,                 /* pc_relative */
  61          0,                     /* bitpos */
  62          complain_overflow_bitfield, /* complain_on_overflow */
  63          bfd_elf_generic_reloc, /* special_function */
  64          "R_OR32_NONE",         /* name */
  65          FALSE,                 /* partial_inplace */
  66          0,                     /* src_mask */
  67          0,                     /* dst_mask */
  68          FALSE),                /* pcrel_offset */
  69
  70   /* A standard 32 bit relocation.  */
  71   HOWTO (R_OR32_32,             /* type */
  72          0,                     /* rightshift */
  73          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  74          32,                    /* bitsize */
  75          FALSE,                 /* pc_relative */
  76          0,                     /* bitpos */
  77          complain_overflow_bitfield, /* complain_on_overflow */
  78          or32_elf_32_reloc,     /* special_function */
  79          "R_OR32_32",           /* name */
  80          FALSE,                 /* partial_inplace */
  81          0xffffffff,            /* src_mask */
  82          0xffffffff,            /* dst_mask */
  83          FALSE),                /* pcrel_offset */
  84
  85   /* A standard 16 bit relocation.  */
  86   HOWTO (R_OR32_16,             /* type */
  87          0,                     /* rightshift */
  88          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  89          16,                    /* bitsize */
  90          FALSE,                 /* pc_relative */
  91          0,                     /* bitpos */
  92          complain_overflow_bitfield, /* complain_on_overflow */
  93          or32_elf_16_reloc,     /* special_function */
  94          "R_OR32_16",           /* name */
  95          FALSE,                 /* partial_inplace */
  96          0x0000ffff,            /* src_mask */
  97          0x0000ffff,            /* dst_mask */
  98          FALSE),                /* pcrel_offset */
  99
 100   /* A standard 8 bit relocation.  */
 101   HOWTO (R_OR32_8,              /* type */
 102          0,                     /* rightshift */
 103          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 104          8,                     /* bitsize */
 105          FALSE,                 /* pc_relative */
 106          0,                     /* bitpos */
 107          complain_overflow_bitfield, /* complain_on_overflow */
 108          or32_elf_8_reloc,      /* special_function */
 109          "R_OR32_8",            /* name */
 110          FALSE,                 /* partial_inplace */
 111          0x000000ff,            /* src_mask */
 112          0x000000ff,            /* dst_mask */
 113          FALSE),                /* pcrel_offset */
 114
 115   /* A standard low 16 bit relocation.  */
 116   HOWTO (R_OR32_CONST,          /* type */
 117          0,                     /* rightshift */
 118          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 119          16,                    /* bitsize */
 120          FALSE,                 /* pc_relative */
 121          0,                     /* bitpos */
 122          complain_overflow_dont, /* complain_on_overflow */
 123          or32_elf_const_reloc,  /* special_function */
 124          "R_OR32_CONST",        /* name */
 125          FALSE,                 /* partial_inplace */
 126          0x0000ffff,            /* src_mask */
 127          0x0000ffff,            /* dst_mask */
 128          FALSE),                /* pcrel_offset */
 129
 130   /* A standard high 16 bit relocation.  */
 131   HOWTO (R_OR32_CONSTH,         /* type */
 132          16,                    /* rightshift */
 133          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 134          16,                    /* bitsize */
 135          TRUE,                  /* pc_relative */
 136          0,                     /* bitpos */
 137          complain_overflow_dont, /* complain_on_overflow */
 138          or32_elf_consth_reloc, /* special_function */
 139          "R_OR32_CONSTH",       /* name */
 140          FALSE,                 /* partial_inplace */
 141          0xffff0000,            /* src_mask */
 142          0x0000ffff,            /* dst_mask */
 143          FALSE),                /* pcrel_offset */
 144
 145   /* A standard branch relocation.  */
 146   HOWTO (R_OR32_JUMPTARG,       /* type */
 147          2,                     /* rightshift */
 148          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          28,                    /* bitsize */
 150          TRUE,                  /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_signed, /* complain_on_overflow */
 153          or32_elf_jumptarg_reloc,/* special_function */
 154          "R_OR32_JUMPTARG",     /* name */
 155          FALSE,                 /* partial_inplace */
 156          0,                     /* src_mask */
 157          0x03ffffff,            /* dst_mask */
 158          TRUE),                 /* pcrel_offset */
 159
 160   /* GNU extension to record C++ vtable hierarchy.  */
 161   HOWTO (R_OR32_GNU_VTINHERIT, /* type */
 162          0,                     /* rightshift */
 163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          0,                     /* bitsize */
 165          FALSE,                 /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_dont, /* complain_on_overflow */
 168          NULL,                  /* special_function */
 169          "R_OR32_GNU_VTINHERIT", /* name */
 170          FALSE,                 /* partial_inplace */
 171          0,                     /* src_mask */
 172          0,                     /* dst_mask */
 173          FALSE),                /* pcrel_offset */
 174
 175   /* GNU extension to record C++ vtable member usage.  */
 176   HOWTO (R_OR32_GNU_VTENTRY,     /* type */
 177          0,                     /* rightshift */
 178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          0,                     /* bitsize */
 180          FALSE,                 /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_dont, /* complain_on_overflow */
 183          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 184          "R_OR32_GNU_VTENTRY",   /* name */
 185          FALSE,                 /* partial_inplace */
 186          0,                     /* src_mask */
 187          0,                     /* dst_mask */
 188          FALSE),                /* pcrel_offset */
 189 };
 190
 191 /* Map BFD reloc types to OR32 ELF reloc types.  */
 192
 193 struct or32_reloc_map
 194 {
 195   bfd_reloc_code_real_type  bfd_reloc_val;
 196   unsigned char             elf_reloc_val;
 197 };
 198
 199 static const struct or32_reloc_map or32_reloc_map[] =
 200 {
 201   { BFD_RELOC_NONE, R_OR32_NONE },
 202   { BFD_RELOC_32, R_OR32_32 },
 203   { BFD_RELOC_16, R_OR32_16 },
 204   { BFD_RELOC_8, R_OR32_8 },
 205   { BFD_RELOC_LO16, R_OR32_CONST },
 206   { BFD_RELOC_HI16, R_OR32_CONSTH },
 207   { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
 208   { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
 209   { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
 210 };
 211
 212 static reloc_howto_type *
 213 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 214      bfd *abfd ATTRIBUTE_UNUSED;
 215      bfd_reloc_code_real_type code;
 216 {
 217   unsigned int i;
 218
 219   for (i = ARRAY_SIZE (or32_reloc_map); i--;)
 220     {
 221       if (or32_reloc_map[i].bfd_reloc_val == code)
 222         return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];
 223     }
 224
 225   return NULL;
 226 }
 227
 228 /* Set the howto pointer for an OR32 ELF reloc.  */
 229
 230 static void
 231 or32_info_to_howto_rel (abfd, cache_ptr, dst)
 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   BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
 240   cache_ptr->howto = &elf_or32_howto_table[r_type];
 241 }
 242
 243 /* Set the right machine number for an OR32 ELF file.  */
 244
 245 static bfd_boolean
 246 or32_elf_object_p (abfd)
 247      bfd *abfd;
 248 {
 249   (void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);
 250   return TRUE;
 251 }
 252
 253 /* The final processing done just before writing out an OR32 ELF object file.
 254    This gets the OR32 architecture right based on the machine number.  */
 255
 256 static void
 257 or32_elf_final_write_processing (abfd, linker)
 258      bfd *abfd;
 259      bfd_boolean linker ATTRIBUTE_UNUSED;
 260 {
 261   int mach;
 262   unsigned long val;
 263
 264   switch (mach = bfd_get_mach (abfd))
 265     {
 266     /*
 267     case bfd_mach_arc_base:
 268       val = E_OR32_MACH_BASE;
 269       break;
 270     */
 271     default:
 272       val = 0;
 273       return;
 274     }
 275
 276   elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
 277   elf_elfheader (abfd)->e_flags |= val;
 278 }
 279
 280 bfd_reloc_status_type
 281 or32_elf_32_reloc (abfd, reloc_entry, symbol, data, input_section,
 282                    output_bfd, error_message)
 283      bfd *abfd;
 284      arelent *reloc_entry;
 285      asymbol *symbol;
 286      PTR data;
 287      asection *input_section;
 288      bfd *output_bfd;
 289      char **error_message ATTRIBUTE_UNUSED;
 290 {
 291   if (output_bfd != (bfd *) NULL)
 292     {
 293       unsigned long insn;
 294       bfd_size_type addr = reloc_entry->address;
 295
 296       reloc_entry->address += input_section->output_offset;
 297
 298       insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 299       insn += symbol->section->output_section->vma;
 300       insn += symbol->section->output_offset;
 301       insn += symbol->value;
 302       bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 303
 304       return bfd_reloc_ok;
 305     }
 306
 307   return bfd_reloc_continue;
 308 }
 309
 310 bfd_reloc_status_type
 311 or32_elf_16_reloc (abfd, reloc_entry, symbol, data, input_section,
 312                    output_bfd, error_message)
 313      bfd *abfd;
 314      arelent *reloc_entry;
 315      asymbol *symbol;
 316      PTR data;
 317      asection *input_section;
 318      bfd *output_bfd;
 319      char **error_message ATTRIBUTE_UNUSED;
 320 {
 321   if (output_bfd != (bfd *) NULL)
 322     {
 323       unsigned short insn;
 324       bfd_size_type addr = reloc_entry->address;
 325
 326       reloc_entry->address += input_section->output_offset;
 327
 328       insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 329       insn += symbol->section->output_section->vma;
 330       insn += symbol->section->output_offset;
 331       insn += symbol->value;
 332       bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);
 333
 334       return bfd_reloc_ok;
 335     }
 336
 337   return bfd_reloc_continue;
 338 }
 339
 340 bfd_reloc_status_type
 341 or32_elf_8_reloc (abfd, reloc_entry, symbol, data, input_section,
 342                   output_bfd, error_message)
 343      bfd *abfd ATTRIBUTE_UNUSED;
 344      arelent *reloc_entry;
 345      asymbol *symbol;
 346      PTR data;
 347      asection *input_section;
 348      bfd *output_bfd;
 349      char **error_message ATTRIBUTE_UNUSED;
 350 {
 351   if (output_bfd != (bfd *) NULL)
 352     {
 353       unsigned char insn;
 354       bfd_size_type addr = reloc_entry->address;
 355
 356       reloc_entry->address += input_section->output_offset;
 357
 358       insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);
 359       insn += symbol->section->output_section->vma;
 360       insn += symbol->section->output_offset;
 361       insn += symbol->value;
 362       bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);
 363
 364       return bfd_reloc_ok;
 365     }
 366
 367   return bfd_reloc_continue;
 368 }
 369
 370 /* Do a R_OR32_CONSTH relocation.  This has to be done in combination
 371    with a R_OR32_CONST reloc, because there is a carry from the LO16 to
 372    the HI16.  Here we just save the information we need; we do the
 373    actual relocation when we see the LO16.  OR32 ELF requires that the
 374    LO16 immediately follow the HI16.  As a GNU extension, we permit an
 375    arbitrary number of HI16 relocs to be associated with a single LO16
 376    reloc.  This extension permits gcc to output the HI and LO relocs
 377    itself. This code is copied from the elf32-mips.c.  */
 378
 379 struct or32_consth
 380 {
 381   struct or32_consth *next;
 382   bfd_byte *addr;
 383   bfd_vma addend;
 384 };
 385
 386 /* FIXME: This should not be a static variable.  */
 387
 388 static struct or32_consth *or32_consth_list;
 389
 390 bfd_reloc_status_type
 391 or32_elf_consth_reloc (abfd, reloc_entry, symbol, data, input_section,
 392                        output_bfd, error_message)
 393      bfd *abfd ATTRIBUTE_UNUSED;
 394      arelent *reloc_entry;
 395      asymbol *symbol;
 396      PTR data;
 397      asection *input_section;
 398      bfd *output_bfd;
 399      char **error_message ATTRIBUTE_UNUSED;
 400 {
 401   bfd_reloc_status_type ret;
 402   bfd_vma relocation;
 403   struct or32_consth *n;
 404
 405   ret = bfd_reloc_ok;
 406
 407   if (bfd_is_und_section (symbol->section)
 408       && output_bfd == (bfd *) NULL)
 409     ret = bfd_reloc_undefined;
 410
 411   if (bfd_is_com_section (symbol->section))
 412     relocation = 0;
 413   else
 414     relocation = symbol->value;
 415
 416   relocation += symbol->section->output_section->vma;
 417   relocation += symbol->section->output_offset;
 418   relocation += reloc_entry->addend;
 419
 420   if (reloc_entry->address > input_section->_cooked_size)
 421     return bfd_reloc_outofrange;
 422
 423   /* Save the information, and let LO16 do the actual relocation.  */
 424   n = (struct or32_consth *) bfd_malloc (sizeof *n);
 425   if (n == NULL)
 426     return bfd_reloc_outofrange;
 427   n->addr = (bfd_byte *) data + reloc_entry->address;
 428   n->addend = relocation;
 429   n->next = or32_consth_list;
 430   or32_consth_list = n;
 431
 432   if (output_bfd != (bfd *) NULL)
 433     reloc_entry->address += input_section->output_offset;
 434
 435   return ret;
 436 }
 437
 438 /* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit
 439    inplace relocation; this function exists in order to do the
 440    R_OR32_CONSTH relocation described above.  */
 441
 442 bfd_reloc_status_type
 443 or32_elf_const_reloc (abfd, reloc_entry, symbol, data, input_section,
 444                       output_bfd, error_message)
 445      bfd *abfd;
 446      arelent *reloc_entry;
 447      asymbol *symbol;
 448      PTR data;
 449      asection *input_section;
 450      bfd *output_bfd;
 451      char **error_message;
 452 {
 453   if (or32_consth_list != NULL)
 454     {
 455       struct or32_consth *l;
 456
 457       l = or32_consth_list;
 458       while (l != NULL)
 459         {
 460           unsigned long insn;
 461           unsigned long val;
 462           unsigned long vallo;
 463           struct or32_consth *next;
 464
 465           /* Do the HI16 relocation.  Note that we actually don't need
 466              to know anything about the LO16 itself, except where to
 467              find the low 16 bits of the addend needed by the LO16.  */
 468           insn = bfd_get_32 (abfd, l->addr);
 469           vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
 470                    & 0xffff);
 471           val = ((insn & 0xffff) << 16) + vallo;
 472           val += l->addend;
 473
 474           insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
 475           bfd_put_32 (abfd, insn, l->addr);
 476
 477           next = l->next;
 478           free (l);
 479           l = next;
 480         }
 481
 482       or32_consth_list = NULL;
 483     }
 484
 485   if (output_bfd != (bfd *) NULL)
 486     {
 487       unsigned long insn, tmp;
 488       bfd_size_type addr = reloc_entry->address;
 489
 490       reloc_entry->address += input_section->output_offset;
 491
 492       insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 493       tmp = insn & 0x0000ffff;
 494       tmp += symbol->section->output_section->vma;
 495       tmp += symbol->section->output_offset;
 496       tmp += symbol->value;
 497       insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);
 498       bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 499
 500       return bfd_reloc_ok;
 501     }
 502
 503   /* Now do the LO16 reloc in the usual way.  */
 504   return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 505                                 input_section, output_bfd, error_message);
 506 }
 507
 508 bfd_reloc_status_type
 509 or32_elf_jumptarg_reloc (abfd, reloc_entry, symbol, data, input_section,
 510                          output_bfd, error_message)
 511      bfd *abfd;
 512      arelent *reloc_entry;
 513      asymbol *symbol ATTRIBUTE_UNUSED;
 514      PTR data;
 515      asection *input_section;
 516      bfd *output_bfd;
 517      char **error_message ATTRIBUTE_UNUSED;
 518 {
 519   if (output_bfd != (bfd *) NULL)
 520     {
 521       unsigned long insn, tmp;
 522       bfd_size_type addr = reloc_entry->address;
 523
 524       reloc_entry->address += input_section->output_offset;
 525
 526       insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 527       tmp = insn | 0xfc000000;
 528       tmp -= (input_section->output_offset >> 2);
 529       insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
 530       bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 531
 532       return bfd_reloc_ok;
 533     }
 534
 535   return bfd_reloc_continue;
 536 }
 537
 538 #define TARGET_LITTLE_SYM       bfd_elf32_or32_little_vec
 539 #define TARGET_LITTLE_NAME      "elf32-littleor32"
 540 #define TARGET_BIG_SYM          bfd_elf32_or32_big_vec
 541 #define TARGET_BIG_NAME         "elf32-or32"
 542 #define ELF_ARCH                bfd_arch_or32
 543 #define ELF_MACHINE_CODE        EM_OR32
 544 #define ELF_MAXPAGESIZE         0x1000
 545
 546 #define elf_info_to_howto       0
 547 #define elf_info_to_howto_rel   or32_info_to_howto_rel
 548 #define elf_backend_object_p    or32_elf_object_p
 549 #define elf_backend_final_write_processing \
 550                                 or32_elf_final_write_processing
 551
 552 #include "elf32-target.h"