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 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.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 \f
 354 /* Perform a single relocation.  By default we use the standard BFD
 355    routines.  */
 356
 357 static bfd_reloc_status_type
 358 iq2000_final_link_relocate (reloc_howto_type *  howto,
 359                             bfd *               input_bfd,
 360                             asection *          input_section,
 361                             bfd_byte *          contents,
 362                             Elf_Internal_Rela * rel,
 363                             bfd_vma             relocation)
 364 {
 365   return _bfd_final_link_relocate (howto, input_bfd, input_section,
 366                                    contents, rel->r_offset,
 367                                    relocation, rel->r_addend);
 368 }
 369 \f
 370 /* Set the howto pointer for a IQ2000 ELF reloc.  */
 371
 372 static void
 373 iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 374                            arelent * cache_ptr,
 375                            Elf_Internal_Rela * dst)
 376 {
 377   unsigned int r_type;
 378
 379   r_type = ELF32_R_TYPE (dst->r_info);
 380   switch (r_type)
 381     {
 382     case R_IQ2000_GNU_VTINHERIT:
 383       cache_ptr->howto = & iq2000_elf_vtinherit_howto;
 384       break;
 385
 386     case R_IQ2000_GNU_VTENTRY:
 387       cache_ptr->howto = & iq2000_elf_vtentry_howto;
 388       break;
 389
 390     default:
 391       cache_ptr->howto = & iq2000_elf_howto_table [r_type];
 392       break;
 393     }
 394 }
 395
 396 /* Look through the relocs for a section during the first phase.
 397    Since we don't do .gots or .plts, we just need to consider the
 398    virtual table relocs for gc.  */
 399
 400 static bfd_boolean
 401 iq2000_elf_check_relocs (bfd *abfd,
 402                          struct bfd_link_info *info,
 403                          asection *sec,
 404                          const Elf_Internal_Rela *relocs)
 405 {
 406   Elf_Internal_Shdr *symtab_hdr;
 407   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 408   const Elf_Internal_Rela *rel;
 409   const Elf_Internal_Rela *rel_end;
 410   bfd_boolean changed = FALSE;
 411
 412   if (info->relocatable)
 413     return TRUE;
 414
 415   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 416   sym_hashes = elf_sym_hashes (abfd);
 417   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 418   if (!elf_bad_symtab (abfd))
 419     sym_hashes_end -= symtab_hdr->sh_info;
 420
 421   rel_end = relocs + sec->reloc_count;
 422   for (rel = relocs; rel < rel_end; rel++)
 423     {
 424       struct elf_link_hash_entry *h;
 425       unsigned long r_symndx;
 426
 427       r_symndx = ELF32_R_SYM (rel->r_info);
 428       if (r_symndx < symtab_hdr->sh_info)
 429         h = NULL;
 430       else
 431         {
 432           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 433           while (h->root.type == bfd_link_hash_indirect
 434                  || h->root.type == bfd_link_hash_warning)
 435             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 436         }
 437
 438       switch (ELF32_R_TYPE (rel->r_info))
 439         {
 440           /* This relocation describes the C++ object vtable
 441              hierarchy.  Reconstruct it for later use during GC.  */
 442         case R_IQ2000_GNU_VTINHERIT:
 443           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 444             return FALSE;
 445           break;
 446
 447           /* This relocation describes which C++ vtable entries
 448              are actually used.  Record for later use during GC.  */
 449         case R_IQ2000_GNU_VTENTRY:
 450           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 451             return FALSE;
 452           break;
 453
 454         case R_IQ2000_32:
 455           /* For debug section, change to special harvard-aware relocations.  */
 456           if (CONST_STRNEQ (sec->name, ".debug")
 457               || CONST_STRNEQ (sec->name, ".stab")
 458               || CONST_STRNEQ (sec->name, ".eh_frame"))
 459             {
 460               ((Elf_Internal_Rela *) rel)->r_info
 461                 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
 462               changed = TRUE;
 463             }
 464           break;
 465         }
 466     }
 467
 468   if (changed)
 469     /* Note that we've changed relocs, otherwise if !info->keep_memory
 470        we'll free the relocs and lose our changes.  */
 471     elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
 472
 473   return TRUE;
 474 }
 475
 476 \f
 477 /* Relocate a IQ2000 ELF section.
 478    There is some attempt to make this function usable for many architectures,
 479    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 480    if only to serve as a learning tool.
 481
 482    The RELOCATE_SECTION function is called by the new ELF backend linker
 483    to handle the relocations for a section.
 484
 485    The relocs are always passed as Rela structures; if the section
 486    actually uses Rel structures, the r_addend field will always be
 487    zero.
 488
 489    This function is responsible for adjusting the section contents as
 490    necessary, and (if using Rela relocs and generating a relocatable
 491    output file) adjusting the reloc addend as necessary.
 492
 493    This function does not have to worry about setting the reloc
 494    address or the reloc symbol index.
 495
 496    LOCAL_SYMS is a pointer to the swapped in local symbols.
 497
 498    LOCAL_SECTIONS is an array giving the section in the input file
 499    corresponding to the st_shndx field of each local symbol.
 500
 501    The global hash table entry for the global symbols can be found
 502    via elf_sym_hashes (input_bfd).
 503
 504    When generating relocatable output, this function must handle
 505    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 506    going to be the section symbol corresponding to the output
 507    section, which means that the addend must be adjusted
 508    accordingly.  */
 509
 510 static bfd_boolean
 511 iq2000_elf_relocate_section (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 512                              struct bfd_link_info *  info,
 513                              bfd *                   input_bfd,
 514                              asection *              input_section,
 515                              bfd_byte *              contents,
 516                              Elf_Internal_Rela *     relocs,
 517                              Elf_Internal_Sym *      local_syms,
 518                              asection **             local_sections)
 519 {
 520   Elf_Internal_Shdr *           symtab_hdr;
 521   struct elf_link_hash_entry ** sym_hashes;
 522   Elf_Internal_Rela *           rel;
 523   Elf_Internal_Rela *           relend;
 524
 525   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 526   sym_hashes = elf_sym_hashes (input_bfd);
 527   relend     = relocs + input_section->reloc_count;
 528
 529   for (rel = relocs; rel < relend; rel ++)
 530     {
 531       reloc_howto_type *           howto;
 532       unsigned long                r_symndx;
 533       Elf_Internal_Sym *           sym;
 534       asection *                   sec;
 535       struct elf_link_hash_entry * h;
 536       bfd_vma                      relocation;
 537       bfd_reloc_status_type        r;
 538       const char *                 name = NULL;
 539       int                          r_type;
 540
 541       r_type = ELF32_R_TYPE (rel->r_info);
 542
 543       if (   r_type == R_IQ2000_GNU_VTINHERIT
 544           || r_type == R_IQ2000_GNU_VTENTRY)
 545         continue;
 546
 547       r_symndx = ELF32_R_SYM (rel->r_info);
 548
 549       howto  = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 550       h      = NULL;
 551       sym    = NULL;
 552       sec    = NULL;
 553
 554       if (r_symndx < symtab_hdr->sh_info)
 555         {
 556           sym = local_syms + r_symndx;
 557           sec = local_sections [r_symndx];
 558           relocation = (sec->output_section->vma
 559                         + sec->output_offset
 560                         + sym->st_value);
 561
 562           name = bfd_elf_string_from_elf_section
 563             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 564           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 565         }
 566       else
 567         {
 568           bfd_boolean unresolved_reloc;
 569           bfd_boolean warned;
 570
 571           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 572                                    r_symndx, symtab_hdr, sym_hashes,
 573                                    h, sec, relocation,
 574                                    unresolved_reloc, warned);
 575
 576           name = h->root.root.string;
 577         }
 578
 579       if (sec != NULL && elf_discarded_section (sec))
 580         {
 581           /* For relocs against symbols from removed linkonce sections,
 582              or sections discarded by a linker script, we just want the
 583              section contents zeroed.  Avoid any special processing.  */
 584           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 585           rel->r_info = 0;
 586           rel->r_addend = 0;
 587           continue;
 588         }
 589
 590       if (info->relocatable)
 591         continue;
 592
 593       switch (r_type)
 594         {
 595         case R_IQ2000_HI16:
 596           r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 597           break;
 598
 599         case R_IQ2000_PC16:
 600           rel->r_addend -= 4;
 601           /* Fall through.  */
 602
 603         default:
 604           r = iq2000_final_link_relocate (howto, input_bfd, input_section,
 605                                          contents, rel, relocation);
 606           break;
 607         }
 608
 609       if (r != bfd_reloc_ok)
 610         {
 611           const char * msg = (const char *) NULL;
 612
 613           switch (r)
 614             {
 615             case bfd_reloc_overflow:
 616               r = info->callbacks->reloc_overflow
 617                 (info, (h ? &h->root : NULL), name, howto->name,
 618                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
 619               break;
 620
 621             case bfd_reloc_undefined:
 622               r = info->callbacks->undefined_symbol
 623                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 624               break;
 625
 626             case bfd_reloc_outofrange:
 627               msg = _("internal error: out of range error");
 628               break;
 629
 630             case bfd_reloc_notsupported:
 631               msg = _("internal error: unsupported relocation error");
 632               break;
 633
 634             case bfd_reloc_dangerous:
 635               msg = _("internal error: dangerous relocation");
 636               break;
 637
 638             default:
 639               msg = _("internal error: unknown error");
 640               break;
 641             }
 642
 643           if (msg)
 644             r = info->callbacks->warning
 645               (info, msg, name, input_bfd, input_section, rel->r_offset);
 646
 647           if (! r)
 648             return FALSE;
 649         }
 650     }
 651
 652   return TRUE;
 653 }
 654 \f
 655
 656 /* Return the section that should be marked against GC for a given
 657    relocation.  */
 658
 659 static asection *
 660 iq2000_elf_gc_mark_hook (asection *sec,
 661                          struct bfd_link_info *info,
 662                          Elf_Internal_Rela *rel,
 663                          struct elf_link_hash_entry *h,
 664                          Elf_Internal_Sym *sym)
 665 {
 666   if (h != NULL)
 667     switch (ELF32_R_TYPE (rel->r_info))
 668       {
 669       case R_IQ2000_GNU_VTINHERIT:
 670       case R_IQ2000_GNU_VTENTRY:
 671         return NULL;
 672       }
 673
 674   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 675 }
 676
 677 \f
 678 /* Return the MACH for an e_flags value.  */
 679
 680 static int
 681 elf32_iq2000_machine (bfd *abfd)
 682 {
 683   switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
 684     {
 685     case EF_IQ2000_CPU_IQ10:
 686       return bfd_mach_iq10;
 687
 688     case EF_IQ2000_CPU_IQ2000:
 689     default:
 690       return bfd_mach_iq2000;
 691     }
 692 }
 693
 694 \f
 695 /* Function to set the ELF flag bits.  */
 696
 697 static bfd_boolean
 698 iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
 699 {
 700   elf_elfheader (abfd)->e_flags = flags;
 701   elf_flags_init (abfd) = TRUE;
 702   return TRUE;
 703 }
 704
 705 /* Copy backend specific data from one object module to another.  */
 706
 707 static bfd_boolean
 708 iq2000_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 709 {
 710   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 711       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 712     return TRUE;
 713
 714   BFD_ASSERT (!elf_flags_init (obfd)
 715               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 716
 717   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 718   elf_flags_init (obfd) = TRUE;
 719   return TRUE;
 720 }
 721
 722 /* Merge backend specific data from an object
 723    file to the output object file when linking.  */
 724
 725 static bfd_boolean
 726 iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 727 {
 728   flagword old_flags, old_partial;
 729   flagword new_flags, new_partial;
 730   bfd_boolean error = FALSE;
 731   char new_opt[80];
 732   char old_opt[80];
 733
 734   new_opt[0] = old_opt[0] = '\0';
 735   new_flags = elf_elfheader (ibfd)->e_flags;
 736   old_flags = elf_elfheader (obfd)->e_flags;
 737
 738   if (!elf_flags_init (obfd))
 739     {
 740       /* First call, no flags set.  */
 741       elf_flags_init (obfd) = TRUE;
 742       elf_elfheader (obfd)->e_flags = new_flags;
 743     }
 744
 745   else if (new_flags != old_flags)
 746     {
 747       /* Warn if different cpu is used, but allow a
 748          specific cpu to override the generic cpu.  */
 749       new_partial = (new_flags & EF_IQ2000_CPU_MASK);
 750       old_partial = (old_flags & EF_IQ2000_CPU_MASK);
 751
 752       if (new_partial != old_partial)
 753         {
 754           switch (new_partial)
 755             {
 756             case EF_IQ2000_CPU_IQ10:
 757               strcat (new_opt, " -m10");
 758               break;
 759
 760             default:
 761             case EF_IQ2000_CPU_IQ2000:
 762               strcat (new_opt, " -m2000");
 763               break;
 764             }
 765
 766           switch (old_partial)
 767             {
 768             case EF_IQ2000_CPU_IQ10:
 769               strcat (old_opt, " -m10");
 770               break;
 771
 772             default:
 773             case EF_IQ2000_CPU_IQ2000:
 774               strcat (old_opt, " -m2000");
 775               break;
 776             }
 777         }
 778
 779       /* Print out any mismatches from above.  */
 780       if (new_opt[0])
 781         {
 782           error = TRUE;
 783           _bfd_error_handler
 784             (_("%s: compiled with %s and linked with modules compiled with %s"),
 785              bfd_get_filename (ibfd), new_opt, old_opt);
 786         }
 787
 788       new_flags &= ~ EF_IQ2000_ALL_FLAGS;
 789       old_flags &= ~ EF_IQ2000_ALL_FLAGS;
 790
 791       /* Warn about any other mismatches.  */
 792       if (new_flags != old_flags)
 793         {
 794           error = TRUE;
 795
 796           _bfd_error_handler
 797             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
 798              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 799         }
 800     }
 801
 802   if (error)
 803     bfd_set_error (bfd_error_bad_value);
 804
 805   return !error;
 806 }
 807
 808 \f
 809 static bfd_boolean
 810 iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
 811 {
 812   FILE *file = (FILE *) ptr;
 813   flagword flags;
 814
 815   BFD_ASSERT (abfd != NULL && ptr != NULL);
 816
 817   /* Print normal ELF private data.  */
 818   _bfd_elf_print_private_bfd_data (abfd, ptr);
 819
 820   flags = elf_elfheader (abfd)->e_flags;
 821   fprintf (file, _("private flags = 0x%lx:"), (long)flags);
 822
 823   switch (flags & EF_IQ2000_CPU_MASK)
 824     {
 825     case EF_IQ2000_CPU_IQ10:
 826       fprintf (file, " -m10");
 827       break;
 828     case EF_IQ2000_CPU_IQ2000:
 829       fprintf (file, " -m2000");
 830       break;
 831     default:
 832       break;
 833     }
 834
 835   fputc ('\n', file);
 836   return TRUE;
 837 }
 838
 839 static
 840 bfd_boolean
 841 iq2000_elf_object_p (bfd *abfd)
 842 {
 843   bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
 844                              elf32_iq2000_machine (abfd));
 845   return TRUE;
 846 }
 847
 848 \f
 849 #define ELF_ARCH                bfd_arch_iq2000
 850 #define ELF_MACHINE_CODE        EM_IQ2000
 851 #define ELF_MAXPAGESIZE         0x1000
 852
 853 #define TARGET_BIG_SYM          bfd_elf32_iq2000_vec
 854 #define TARGET_BIG_NAME         "elf32-iq2000"
 855
 856 #define elf_info_to_howto_rel                   NULL
 857 #define elf_info_to_howto                       iq2000_info_to_howto_rela
 858 #define elf_backend_relocate_section            iq2000_elf_relocate_section
 859 #define elf_backend_gc_mark_hook                iq2000_elf_gc_mark_hook
 860 #define elf_backend_check_relocs                iq2000_elf_check_relocs
 861 #define elf_backend_object_p                    iq2000_elf_object_p
 862 #define elf_backend_rela_normal                 1
 863
 864 #define elf_backend_can_gc_sections             1
 865
 866 #define bfd_elf32_bfd_reloc_type_lookup         iq2000_reloc_type_lookup
 867 #define bfd_elf32_bfd_set_private_flags         iq2000_elf_set_private_flags
 868 #define bfd_elf32_bfd_copy_private_bfd_data     iq2000_elf_copy_private_bfd_data
 869 #define bfd_elf32_bfd_merge_private_bfd_data    iq2000_elf_merge_private_bfd_data
 870 #define bfd_elf32_bfd_print_private_bfd_data    iq2000_elf_print_private_bfd_data
 871
 872 #include "elf32-target.h"