bfd/elf32-iq2000.c

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