bfd/elf32-iq2000.c

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