bfd/elf32-iq2000.c

   1 /* IQ2000-specific support for 32-bit ELF.
   2    Copyright (C) 2003-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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #include "sysdep.h"
  21 #include "bfd.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/iq2000.h"
  25
  26 /* Forward declarations.  */
  27
  28 static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  29
  30 \f
  31 static reloc_howto_type iq2000_elf_howto_table [] =
  32 {
  33   /* This reloc does nothing.  */
  34
  35   HOWTO (R_IQ2000_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_IQ2000_NONE",            /* name */
  44          FALSE,                      /* partial_inplace */
  45          0,                          /* src_mask */
  46          0,                          /* dst_mask */
  47          FALSE),                     /* pcrel_offset */
  48
  49   /* A 16 bit absolute relocation.  */
  50   HOWTO (R_IQ2000_16,                /* type */
  51          0,                          /* rightshift */
  52          1,                          /* size (0 = byte, 1 = short, 2 = long) */
  53          16,                         /* bitsize */
  54          FALSE,                      /* pc_relative */
  55          0,                          /* bitpos */
  56          complain_overflow_bitfield, /* complain_on_overflow */
  57          bfd_elf_generic_reloc,      /* special_function */
  58          "R_IQ2000_16",              /* name */
  59          FALSE,                      /* partial_inplace */
  60          0x0000,                     /* src_mask */
  61          0xffff,                     /* dst_mask */
  62          FALSE),                     /* pcrel_offset */
  63
  64   /* A 32 bit absolute relocation.  */
  65   HOWTO (R_IQ2000_32,                /* type */
  66          0,                          /* rightshift */
  67          2,                          /* size (0 = byte, 1 = short, 2 = long) */
  68          31,                         /* bitsize */
  69          FALSE,                      /* pc_relative */
  70          0,                          /* bitpos */
  71          complain_overflow_bitfield, /* complain_on_overflow */
  72          bfd_elf_generic_reloc,      /* special_function */
  73          "R_IQ2000_32",              /* name */
  74          FALSE,                      /* partial_inplace */
  75          0x00000000,                 /* src_mask */
  76          0x7fffffff,                 /* dst_mask */
  77          FALSE),                     /* pcrel_offset */
  78
  79   /* 26 bit branch address.  */
  80   HOWTO (R_IQ2000_26,           /* type */
  81          2,                     /* rightshift */
  82          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          26,                    /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_dont, /* complain_on_overflow */
  87                                 /* This needs complex overflow
  88                                    detection, because the upper four
  89                                    bits must match the PC.  */
  90          bfd_elf_generic_reloc, /* special_function */
  91          "R_IQ2000_26",         /* name */
  92          FALSE,                 /* partial_inplace */
  93          0x00000000,            /* src_mask */
  94          0x03ffffff,            /* dst_mask */
  95          FALSE),                /* pcrel_offset */
  96
  97   /* 16 bit PC relative reference.  */
  98   HOWTO (R_IQ2000_PC16,         /* type */
  99          2,                     /* rightshift */
 100          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 101          16,                    /* bitsize */
 102          TRUE,                  /* pc_relative */
 103          0,                     /* bitpos */
 104          complain_overflow_signed, /* complain_on_overflow */
 105          bfd_elf_generic_reloc, /* special_function */
 106          "R_IQ2000_PC16",       /* name */
 107          FALSE,                 /* partial_inplace */
 108          0x0000,                /* src_mask */
 109          0xffff,                /* dst_mask */
 110          TRUE),                 /* pcrel_offset */
 111
 112   /* high 16 bits of symbol value.  */
 113   HOWTO (R_IQ2000_HI16,         /* type */
 114          16,                    /* rightshift */
 115          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 116          15,                    /* bitsize */
 117          FALSE,                 /* pc_relative */
 118          0,                     /* bitpos */
 119          complain_overflow_dont, /* complain_on_overflow */
 120          iq2000_elf_howto_hi16_reloc,   /* special_function */
 121          "R_IQ2000_HI16",       /* name */
 122          FALSE,                 /* partial_inplace */
 123          0x0000,                /* src_mask */
 124          0x7fff,                /* dst_mask */
 125          FALSE),                /* pcrel_offset */
 126
 127   /* Low 16 bits of symbol value.  */
 128   HOWTO (R_IQ2000_LO16,         /* type */
 129          0,                     /* rightshift */
 130          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 131          16,                    /* bitsize */
 132          FALSE,                 /* pc_relative */
 133          0,                     /* bitpos */
 134          complain_overflow_dont, /* complain_on_overflow */
 135          bfd_elf_generic_reloc, /* special_function */
 136          "R_IQ2000_LO16",       /* name */
 137          FALSE,                 /* partial_inplace */
 138          0x0000,                /* src_mask */
 139          0xffff,                /* dst_mask */
 140          FALSE),                /* pcrel_offset */
 141
 142   /* 16-bit jump offset.  */
 143   HOWTO (R_IQ2000_OFFSET_16,    /* type */
 144          2,                     /* rightshift */
 145          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 146          16,                    /* bitsize */
 147          FALSE,                 /* pc_relative */
 148          0,                     /* bitpos */
 149          complain_overflow_dont, /* complain_on_overflow */
 150          bfd_elf_generic_reloc, /* special_function */
 151          "R_IQ2000_OFFSET_16",  /* name */
 152          FALSE,                 /* partial_inplace */
 153          0x0000,                /* src_mask */
 154          0xffff,                /* dst_mask */
 155          FALSE),                /* pcrel_offset */
 156
 157   /* 21-bit jump offset.  */
 158   HOWTO (R_IQ2000_OFFSET_21,    /* type */
 159          2,                     /* rightshift */
 160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 161          21,                    /* bitsize */
 162          FALSE,                 /* pc_relative */
 163          0,                     /* bitpos */
 164          complain_overflow_dont, /* complain_on_overflow */
 165          bfd_elf_generic_reloc, /* special_function */
 166          "R_IQ2000_OFFSET_21",  /* name */
 167          FALSE,                 /* partial_inplace */
 168          0x000000,              /* src_mask */
 169          0x1fffff,              /* dst_mask */
 170          FALSE),                /* pcrel_offset */
 171
 172   /* unsigned high 16 bits of value.  */
 173   HOWTO (R_IQ2000_OFFSET_21,    /* type */
 174          16,                    /* rightshift */
 175          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 176          16,                    /* bitsize */
 177          FALSE,                 /* pc_relative */
 178          0,                     /* bitpos */
 179          complain_overflow_dont, /* complain_on_overflow */
 180          bfd_elf_generic_reloc, /* special_function */
 181          "R_IQ2000_UHI16",      /* name */
 182          FALSE,                 /* partial_inplace */
 183          0x0000,                /* src_mask */
 184          0x7fff,                /* dst_mask */
 185          FALSE),                /* pcrel_offset */
 186
 187   /* A 32 bit absolute debug relocation.  */
 188   HOWTO (R_IQ2000_32_DEBUG,          /* type */
 189          0,                          /* rightshift */
 190          2,                          /* size (0 = byte, 1 = short, 2 = long) */
 191          32,                         /* bitsize */
 192          FALSE,                      /* pc_relative */
 193          0,                          /* bitpos */
 194          complain_overflow_bitfield, /* complain_on_overflow */
 195          bfd_elf_generic_reloc,      /* special_function */
 196          "R_IQ2000_32",              /* name */
 197          FALSE,                      /* partial_inplace */
 198          0x00000000,                 /* src_mask */
 199          0xffffffff,                 /* dst_mask */
 200          FALSE),                     /* pcrel_offset */
 201
 202 };
 203
 204 /* GNU extension to record C++ vtable hierarchy.  */
 205 static reloc_howto_type iq2000_elf_vtinherit_howto =
 206   HOWTO (R_IQ2000_GNU_VTINHERIT,    /* type */
 207          0,                        /* rightshift */
 208          2,                        /* size (0 = byte, 1 = short, 2 = long) */
 209          0,                        /* bitsize */
 210          FALSE,                    /* pc_relative */
 211          0,                        /* bitpos */
 212          complain_overflow_dont,   /* complain_on_overflow */
 213          NULL,                     /* special_function */
 214          "R_IQ2000_GNU_VTINHERIT",  /* name */
 215          FALSE,                    /* partial_inplace */
 216          0,                        /* src_mask */
 217          0,                        /* dst_mask */
 218          FALSE);                   /* pcrel_offset */
 219
 220 /* GNU extension to record C++ vtable member usage.  */
 221 static reloc_howto_type iq2000_elf_vtentry_howto =
 222   HOWTO (R_IQ2000_GNU_VTENTRY,     /* type */
 223          0,                        /* rightshift */
 224          2,                        /* size (0 = byte, 1 = short, 2 = long) */
 225          0,                        /* bitsize */
 226          FALSE,                    /* pc_relative */
 227          0,                        /* bitpos */
 228          complain_overflow_dont,   /* complain_on_overflow */
 229          NULL,                     /* special_function */
 230          "R_IQ2000_GNU_VTENTRY",    /* name */
 231          FALSE,                    /* partial_inplace */
 232          0,                        /* src_mask */
 233          0,                        /* dst_mask */
 234          FALSE);                   /* pcrel_offset */
 235
 236 \f
 237 static bfd_reloc_status_type
 238 iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 239                              arelent *reloc_entry,
 240                              asymbol *symbol,
 241                              void * data,
 242                              asection *input_section,
 243                              bfd *output_bfd,
 244                              char **error_message ATTRIBUTE_UNUSED)
 245 {
 246   bfd_reloc_status_type ret;
 247   bfd_vma relocation;
 248
 249   /* If we're relocating and this an external symbol,
 250      we don't want to change anything.  */
 251   if (output_bfd != (bfd *) NULL
 252       && (symbol->flags & BSF_SECTION_SYM) == 0
 253       && reloc_entry->addend == 0)
 254     {
 255       reloc_entry->address += input_section->output_offset;
 256       return bfd_reloc_ok;
 257     }
 258
 259   if (bfd_is_com_section (symbol->section))
 260     relocation = 0;
 261   else
 262     relocation = symbol->value;
 263
 264   relocation += symbol->section->output_section->vma;
 265   relocation += symbol->section->output_offset;
 266   relocation += reloc_entry->addend;
 267
 268   /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion.  */
 269   if (relocation & 0x8000)
 270     reloc_entry->addend += 0x10000;
 271
 272   /* Now do the reloc in the usual way.  */
 273   ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 274                                 input_section, output_bfd, error_message);
 275
 276   /* Put it back the way it was.  */
 277   if (relocation & 0x8000)
 278     reloc_entry->addend -= 0x10000;
 279
 280   return ret;
 281 }
 282
 283 static bfd_reloc_status_type
 284 iq2000_elf_relocate_hi16 (bfd *input_bfd,
 285                           Elf_Internal_Rela *relhi,
 286                           bfd_byte *contents,
 287                           bfd_vma value)
 288 {
 289   bfd_vma insn;
 290
 291   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
 292
 293   value += relhi->r_addend;
 294   value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit.  */
 295
 296   /* If top-bit of %lo value is on, this means that %lo will
 297      sign-propagate and so we compensate by adding 1 to %hi value.  */
 298   if (value & 0x8000)
 299     value += 0x10000;
 300
 301   value >>= 16;
 302   insn = ((insn & ~0xFFFF) | value);
 303
 304   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
 305   return bfd_reloc_ok;
 306 }
 307
 308 static bfd_reloc_status_type
 309 iq2000_elf_relocate_offset16 (bfd *input_bfd,
 310                               Elf_Internal_Rela *rel,
 311                               bfd_byte *contents,
 312                               bfd_vma value,
 313                               bfd_vma location)
 314 {
 315   bfd_vma insn;
 316   bfd_vma jtarget;
 317
 318   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
 319
 320   value += rel->r_addend;
 321
 322   if (value & 3)
 323     return bfd_reloc_dangerous;
 324
 325   jtarget = (value & 0x3fffc) | (location & 0xf0000000L);
 326
 327   if (jtarget != value)
 328     return bfd_reloc_overflow;
 329
 330   insn = (insn & ~0xFFFF) | ((value >> 2) & 0xFFFF);
 331
 332   bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
 333   return bfd_reloc_ok;
 334 }
 335
 336 /* Map BFD reloc types to IQ2000 ELF reloc types.  */
 337
 338 static reloc_howto_type *
 339 iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 340                           bfd_reloc_code_real_type code)
 341 {
 342   /* Note that the iq2000_elf_howto_table is indxed by the R_
 343      constants.  Thus, the order that the howto records appear in the
 344      table *must* match the order of the relocation types defined in
 345      include/elf/iq2000.h.  */
 346
 347   switch (code)
 348     {
 349     case BFD_RELOC_NONE:
 350       return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE];
 351     case BFD_RELOC_16:
 352       return &iq2000_elf_howto_table[ (int) R_IQ2000_16];
 353     case BFD_RELOC_32:
 354       return &iq2000_elf_howto_table[ (int) R_IQ2000_32];
 355     case BFD_RELOC_MIPS_JMP:
 356       return &iq2000_elf_howto_table[ (int) R_IQ2000_26];
 357     case BFD_RELOC_IQ2000_OFFSET_16:
 358       return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16];
 359     case BFD_RELOC_IQ2000_OFFSET_21:
 360       return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21];
 361     case BFD_RELOC_16_PCREL_S2:
 362       return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16];
 363     case BFD_RELOC_HI16:
 364       return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16];
 365     case BFD_RELOC_IQ2000_UHI16:
 366       return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16];
 367     case BFD_RELOC_LO16:
 368       return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16];
 369     case BFD_RELOC_VTABLE_INHERIT:
 370       return &iq2000_elf_vtinherit_howto;
 371     case BFD_RELOC_VTABLE_ENTRY:
 372       return &iq2000_elf_vtentry_howto;
 373     default:
 374       /* Pacify gcc -Wall.  */
 375       return NULL;
 376     }
 377   return NULL;
 378 }
 379
 380 static reloc_howto_type *
 381 iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 382 {
 383   unsigned int i;
 384
 385   for (i = 0;
 386        i < (sizeof (iq2000_elf_howto_table)
 387             / sizeof (iq2000_elf_howto_table[0]));
 388        i++)
 389     if (iq2000_elf_howto_table[i].name != NULL
 390         && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0)
 391       return &iq2000_elf_howto_table[i];
 392
 393   if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0)
 394     return &iq2000_elf_vtinherit_howto;
 395   if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0)
 396     return &iq2000_elf_vtentry_howto;
 397
 398   return NULL;
 399 }
 400 \f
 401 /* Perform a single relocation.  By default we use the standard BFD
 402    routines.  */
 403
 404 static bfd_reloc_status_type
 405 iq2000_final_link_relocate (reloc_howto_type *  howto,
 406                             bfd *               input_bfd,
 407                             asection *          input_section,
 408                             bfd_byte *          contents,
 409                             Elf_Internal_Rela * rel,
 410                             bfd_vma             relocation)
 411 {
 412   return _bfd_final_link_relocate (howto, input_bfd, input_section,
 413                                    contents, rel->r_offset,
 414                                    relocation, rel->r_addend);
 415 }
 416 \f
 417 /* Set the howto pointer for a IQ2000 ELF reloc.  */
 418
 419 static void
 420 iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 421                            arelent * cache_ptr,
 422                            Elf_Internal_Rela * dst)
 423 {
 424   unsigned int r_type;
 425
 426   r_type = ELF32_R_TYPE (dst->r_info);
 427   switch (r_type)
 428     {
 429     case R_IQ2000_GNU_VTINHERIT:
 430       cache_ptr->howto = & iq2000_elf_vtinherit_howto;
 431       break;
 432
 433     case R_IQ2000_GNU_VTENTRY:
 434       cache_ptr->howto = & iq2000_elf_vtentry_howto;
 435       break;
 436
 437     default:
 438       if (r_type >= (unsigned int) R_IQ2000_max)
 439         {
 440           /* xgettext:c-format */
 441           _bfd_error_handler (_("%B: invalid IQ2000 reloc number: %d"), abfd, r_type);
 442           r_type = 0;
 443         }
 444       cache_ptr->howto = & iq2000_elf_howto_table [r_type];
 445       break;
 446     }
 447 }
 448
 449 /* Look through the relocs for a section during the first phase.
 450    Since we don't do .gots or .plts, we just need to consider the
 451    virtual table relocs for gc.  */
 452
 453 static bfd_boolean
 454 iq2000_elf_check_relocs (bfd *abfd,
 455                          struct bfd_link_info *info,
 456                          asection *sec,
 457                          const Elf_Internal_Rela *relocs)
 458 {
 459   Elf_Internal_Shdr *symtab_hdr;
 460   struct elf_link_hash_entry **sym_hashes;
 461   const Elf_Internal_Rela *rel;
 462   const Elf_Internal_Rela *rel_end;
 463   bfd_boolean changed = FALSE;
 464
 465   if (bfd_link_relocatable (info))
 466     return TRUE;
 467
 468   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 469   sym_hashes = elf_sym_hashes (abfd);
 470
 471   rel_end = relocs + sec->reloc_count;
 472   for (rel = relocs; rel < rel_end; rel++)
 473     {
 474       struct elf_link_hash_entry *h;
 475       unsigned long r_symndx;
 476
 477       r_symndx = ELF32_R_SYM (rel->r_info);
 478       if (r_symndx < symtab_hdr->sh_info)
 479         h = NULL;
 480       else
 481         {
 482           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 483           while (h->root.type == bfd_link_hash_indirect
 484                  || h->root.type == bfd_link_hash_warning)
 485             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 486
 487           /* PR15323, ref flags aren't set for references in the same
 488              object.  */
 489           h->root.non_ir_ref = 1;
 490         }
 491
 492       switch (ELF32_R_TYPE (rel->r_info))
 493         {
 494           /* This relocation describes the C++ object vtable
 495              hierarchy.  Reconstruct it for later use during GC.  */
 496         case R_IQ2000_GNU_VTINHERIT:
 497           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 498             return FALSE;
 499           break;
 500
 501           /* This relocation describes which C++ vtable entries
 502              are actually used.  Record for later use during GC.  */
 503         case R_IQ2000_GNU_VTENTRY:
 504           BFD_ASSERT (h != NULL);
 505           if (h != NULL
 506               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 507             return FALSE;
 508           break;
 509
 510         case R_IQ2000_32:
 511           /* For debug section, change to special harvard-aware relocations.  */
 512           if (CONST_STRNEQ (sec->name, ".debug")
 513               || CONST_STRNEQ (sec->name, ".stab")
 514               || CONST_STRNEQ (sec->name, ".eh_frame"))
 515             {
 516               ((Elf_Internal_Rela *) rel)->r_info
 517                 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
 518               changed = TRUE;
 519             }
 520           break;
 521         }
 522     }
 523
 524   if (changed)
 525     /* Note that we've changed relocs, otherwise if !info->keep_memory
 526        we'll free the relocs and lose our changes.  */
 527     elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
 528
 529   return TRUE;
 530 }
 531
 532 \f
 533 /* Relocate a IQ2000 ELF section.
 534    There is some attempt to make this function usable for many architectures,
 535    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 536    if only to serve as a learning tool.
 537
 538    The RELOCATE_SECTION function is called by the new ELF backend linker
 539    to handle the relocations for a section.
 540
 541    The relocs are always passed as Rela structures; if the section
 542    actually uses Rel structures, the r_addend field will always be
 543    zero.
 544
 545    This function is responsible for adjusting the section contents as
 546    necessary, and (if using Rela relocs and generating a relocatable
 547    output file) adjusting the reloc addend as necessary.
 548
 549    This function does not have to worry about setting the reloc
 550    address or the reloc symbol index.
 551
 552    LOCAL_SYMS is a pointer to the swapped in local symbols.
 553
 554    LOCAL_SECTIONS is an array giving the section in the input file
 555    corresponding to the st_shndx field of each local symbol.
 556
 557    The global hash table entry for the global symbols can be found
 558    via elf_sym_hashes (input_bfd).
 559
 560    When generating relocatable output, this function must handle
 561    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 562    going to be the section symbol corresponding to the output
 563    section, which means that the addend must be adjusted
 564    accordingly.  */
 565
 566 static bfd_boolean
 567 iq2000_elf_relocate_section (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 568                              struct bfd_link_info *  info,
 569                              bfd *                   input_bfd,
 570                              asection *              input_section,
 571                              bfd_byte *              contents,
 572                              Elf_Internal_Rela *     relocs,
 573                              Elf_Internal_Sym *      local_syms,
 574                              asection **             local_sections)
 575 {
 576   Elf_Internal_Shdr *           symtab_hdr;
 577   struct elf_link_hash_entry ** sym_hashes;
 578   Elf_Internal_Rela *           rel;
 579   Elf_Internal_Rela *           relend;
 580
 581   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 582   sym_hashes = elf_sym_hashes (input_bfd);
 583   relend     = relocs + input_section->reloc_count;
 584
 585   for (rel = relocs; rel < relend; rel ++)
 586     {
 587       reloc_howto_type *           howto;
 588       unsigned long                r_symndx;
 589       Elf_Internal_Sym *           sym;
 590       asection *                   sec;
 591       struct elf_link_hash_entry * h;
 592       bfd_vma                      relocation;
 593       bfd_reloc_status_type        r;
 594       const char *                 name = NULL;
 595       int                          r_type;
 596
 597       r_type = ELF32_R_TYPE (rel->r_info);
 598
 599       if (   r_type == R_IQ2000_GNU_VTINHERIT
 600           || r_type == R_IQ2000_GNU_VTENTRY)
 601         continue;
 602
 603       r_symndx = ELF32_R_SYM (rel->r_info);
 604
 605       howto  = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 606       h      = NULL;
 607       sym    = NULL;
 608       sec    = NULL;
 609
 610       if (r_symndx < symtab_hdr->sh_info)
 611         {
 612           asection *osec;
 613
 614           sym = local_syms + r_symndx;
 615           osec = sec = local_sections [r_symndx];
 616           if ((sec->flags & SEC_MERGE)
 617               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 618             /* This relocation is relative to a section symbol that is
 619                going to be merged.  Change it so that it is relative
 620                to the merged section symbol.  */
 621             rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, &sec,
 622                                                     rel->r_addend);
 623
 624           relocation = (sec->output_section->vma
 625                         + sec->output_offset
 626                         + sym->st_value);
 627
 628           name = bfd_elf_string_from_elf_section
 629             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 630           name = (name == NULL) ? bfd_section_name (input_bfd, osec) : name;
 631         }
 632       else
 633         {
 634           bfd_boolean unresolved_reloc;
 635           bfd_boolean warned, ignored;
 636
 637           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 638                                    r_symndx, symtab_hdr, sym_hashes,
 639                                    h, sec, relocation,
 640                                    unresolved_reloc, warned, ignored);
 641
 642           name = h->root.root.string;
 643         }
 644
 645       if (sec != NULL && discarded_section (sec))
 646         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 647                                          rel, 1, relend, howto, 0, contents);
 648
 649       if (bfd_link_relocatable (info))
 650         continue;
 651
 652       switch (r_type)
 653         {
 654         case R_IQ2000_HI16:
 655           r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 656           break;
 657
 658         case R_IQ2000_OFFSET_16:
 659           r = iq2000_elf_relocate_offset16 (input_bfd, rel, contents, relocation,
 660                                             input_section->output_section->vma
 661                                             + input_section->output_offset
 662                                             + rel->r_offset);
 663           break;
 664
 665         case R_IQ2000_PC16:
 666           rel->r_addend -= 4;
 667           /* Fall through.  */
 668
 669         default:
 670           r = iq2000_final_link_relocate (howto, input_bfd, input_section,
 671                                          contents, rel, relocation);
 672           break;
 673         }
 674
 675       if (r != bfd_reloc_ok)
 676         {
 677           const char * msg = (const char *) NULL;
 678
 679           switch (r)
 680             {
 681             case bfd_reloc_overflow:
 682               (*info->callbacks->reloc_overflow)
 683                 (info, (h ? &h->root : NULL), name, howto->name,
 684                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
 685               break;
 686
 687             case bfd_reloc_undefined:
 688               (*info->callbacks->undefined_symbol)
 689                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 690               break;
 691
 692             case bfd_reloc_outofrange:
 693               msg = _("internal error: out of range error");
 694               break;
 695
 696             case bfd_reloc_notsupported:
 697               msg = _("internal error: unsupported relocation error");
 698               break;
 699
 700             case bfd_reloc_dangerous:
 701               msg = _("internal error: dangerous relocation");
 702               break;
 703
 704             default:
 705               msg = _("internal error: unknown error");
 706               break;
 707             }
 708
 709           if (msg)
 710             (*info->callbacks->warning) (info, msg, name, input_bfd,
 711                                          input_section, rel->r_offset);
 712         }
 713     }
 714
 715   return TRUE;
 716 }
 717 \f
 718
 719 /* Return the section that should be marked against GC for a given
 720    relocation.  */
 721
 722 static asection *
 723 iq2000_elf_gc_mark_hook (asection *sec,
 724                          struct bfd_link_info *info,
 725                          Elf_Internal_Rela *rel,
 726                          struct elf_link_hash_entry *h,
 727                          Elf_Internal_Sym *sym)
 728 {
 729   if (h != NULL)
 730     switch (ELF32_R_TYPE (rel->r_info))
 731       {
 732       case R_IQ2000_GNU_VTINHERIT:
 733       case R_IQ2000_GNU_VTENTRY:
 734         return NULL;
 735       }
 736
 737   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 738 }
 739
 740 \f
 741 /* Return the MACH for an e_flags value.  */
 742
 743 static int
 744 elf32_iq2000_machine (bfd *abfd)
 745 {
 746   switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
 747     {
 748     case EF_IQ2000_CPU_IQ10:
 749       return bfd_mach_iq10;
 750
 751     case EF_IQ2000_CPU_IQ2000:
 752     default:
 753       return bfd_mach_iq2000;
 754     }
 755 }
 756
 757 \f
 758 /* Function to set the ELF flag bits.  */
 759
 760 static bfd_boolean
 761 iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
 762 {
 763   elf_elfheader (abfd)->e_flags = flags;
 764   elf_flags_init (abfd) = TRUE;
 765   return TRUE;
 766 }
 767
 768 /* Merge backend specific data from an object
 769    file to the output object file when linking.  */
 770
 771 static bfd_boolean
 772 iq2000_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
 773 {
 774   bfd *obfd = info->output_bfd;
 775   flagword old_flags, old_partial;
 776   flagword new_flags, new_partial;
 777   bfd_boolean error = FALSE;
 778   char new_opt[80];
 779   char old_opt[80];
 780
 781   new_opt[0] = old_opt[0] = '\0';
 782   new_flags = elf_elfheader (ibfd)->e_flags;
 783   old_flags = elf_elfheader (obfd)->e_flags;
 784
 785   if (!elf_flags_init (obfd))
 786     {
 787       /* First call, no flags set.  */
 788       elf_flags_init (obfd) = TRUE;
 789       elf_elfheader (obfd)->e_flags = new_flags;
 790     }
 791
 792   else if (new_flags != old_flags)
 793     {
 794       /* Warn if different cpu is used, but allow a
 795          specific cpu to override the generic cpu.  */
 796       new_partial = (new_flags & EF_IQ2000_CPU_MASK);
 797       old_partial = (old_flags & EF_IQ2000_CPU_MASK);
 798
 799       if (new_partial != old_partial)
 800         {
 801           switch (new_partial)
 802             {
 803             case EF_IQ2000_CPU_IQ10:
 804               strcat (new_opt, " -m10");
 805               break;
 806
 807             default:
 808             case EF_IQ2000_CPU_IQ2000:
 809               strcat (new_opt, " -m2000");
 810               break;
 811             }
 812
 813           switch (old_partial)
 814             {
 815             case EF_IQ2000_CPU_IQ10:
 816               strcat (old_opt, " -m10");
 817               break;
 818
 819             default:
 820             case EF_IQ2000_CPU_IQ2000:
 821               strcat (old_opt, " -m2000");
 822               break;
 823             }
 824         }
 825
 826       /* Print out any mismatches from above.  */
 827       if (new_opt[0])
 828         {
 829           error = TRUE;
 830           _bfd_error_handler
 831             /* xgettext:c-format */
 832             (_("%s: compiled with %s and linked with modules compiled with %s"),
 833              bfd_get_filename (ibfd), new_opt, old_opt);
 834         }
 835
 836       new_flags &= ~ EF_IQ2000_ALL_FLAGS;
 837       old_flags &= ~ EF_IQ2000_ALL_FLAGS;
 838
 839       /* Warn about any other mismatches.  */
 840       if (new_flags != old_flags)
 841         {
 842           error = TRUE;
 843
 844           _bfd_error_handler
 845             /* xgettext:c-format */
 846             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
 847              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 848         }
 849     }
 850
 851   if (error)
 852     bfd_set_error (bfd_error_bad_value);
 853
 854   return !error;
 855 }
 856
 857 \f
 858 static bfd_boolean
 859 iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
 860 {
 861   FILE *file = (FILE *) ptr;
 862   flagword flags;
 863
 864   BFD_ASSERT (abfd != NULL && ptr != NULL);
 865
 866   /* Print normal ELF private data.  */
 867   _bfd_elf_print_private_bfd_data (abfd, ptr);
 868
 869   flags = elf_elfheader (abfd)->e_flags;
 870   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
 871
 872   switch (flags & EF_IQ2000_CPU_MASK)
 873     {
 874     case EF_IQ2000_CPU_IQ10:
 875       fprintf (file, " -m10");
 876       break;
 877     case EF_IQ2000_CPU_IQ2000:
 878       fprintf (file, " -m2000");
 879       break;
 880     default:
 881       break;
 882     }
 883
 884   fputc ('\n', file);
 885   return TRUE;
 886 }
 887
 888 static
 889 bfd_boolean
 890 iq2000_elf_object_p (bfd *abfd)
 891 {
 892   bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
 893                              elf32_iq2000_machine (abfd));
 894   return TRUE;
 895 }
 896
 897 \f
 898 #define ELF_ARCH                bfd_arch_iq2000
 899 #define ELF_MACHINE_CODE        EM_IQ2000
 900 #define ELF_MAXPAGESIZE         0x1000
 901
 902 #define TARGET_BIG_SYM          iq2000_elf32_vec
 903 #define TARGET_BIG_NAME         "elf32-iq2000"
 904
 905 #define elf_info_to_howto_rel                   NULL
 906 #define elf_info_to_howto                       iq2000_info_to_howto_rela
 907 #define elf_backend_relocate_section            iq2000_elf_relocate_section
 908 #define elf_backend_gc_mark_hook                iq2000_elf_gc_mark_hook
 909 #define elf_backend_check_relocs                iq2000_elf_check_relocs
 910 #define elf_backend_object_p                    iq2000_elf_object_p
 911 #define elf_backend_rela_normal                 1
 912
 913 #define elf_backend_can_gc_sections             1
 914
 915 #define bfd_elf32_bfd_reloc_type_lookup         iq2000_reloc_type_lookup
 916 #define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
 917 #define bfd_elf32_bfd_set_private_flags         iq2000_elf_set_private_flags
 918 #define bfd_elf32_bfd_merge_private_bfd_data    iq2000_elf_merge_private_bfd_data
 919 #define bfd_elf32_bfd_print_private_bfd_data    iq2000_elf_print_private_bfd_data
 920
 921 #include "elf32-target.h"