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   const Elf_Internal_Rela *rel;
 458   const Elf_Internal_Rela *rel_end;
 459   bfd_boolean changed = FALSE;
 460
 461   if (info->relocatable)
 462     return TRUE;
 463
 464   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 465   sym_hashes = elf_sym_hashes (abfd);
 466   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
 467   if (!elf_bad_symtab (abfd))
 468     sym_hashes_end -= symtab_hdr->sh_info;
 469
 470   rel_end = relocs + sec->reloc_count;
 471   for (rel = relocs; rel < rel_end; rel++)
 472     {
 473       struct elf_link_hash_entry *h;
 474       unsigned long r_symndx;
 475
 476       r_symndx = ELF32_R_SYM (rel->r_info);
 477       if (r_symndx < symtab_hdr->sh_info)
 478         h = NULL;
 479       else
 480         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 481
 482       switch (ELF32_R_TYPE (rel->r_info))
 483         {
 484           /* This relocation describes the C++ object vtable hierarchy.
 485              Reconstruct it for later use during GC.  */
 486         case R_IQ2000_GNU_VTINHERIT:
 487           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 488             return FALSE;
 489           break;
 490
 491           /* This relocation describes which C++ vtable entries are actually
 492              used.  Record for later use during GC.  */
 493         case R_IQ2000_GNU_VTENTRY:
 494           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 495             return FALSE;
 496           break;
 497
 498         case R_IQ2000_32:
 499           /* For debug section, change to special harvard-aware relocations */
 500           if (memcmp (sec->name, ".debug", 6) == 0
 501               || memcmp (sec->name, ".stab", 5) == 0
 502               || memcmp (sec->name, ".eh_frame", 9) == 0)
 503             {
 504               ((Elf_Internal_Rela *) rel)->r_info
 505                 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
 506               changed = TRUE;
 507             }
 508           break;
 509         }
 510     }
 511
 512   if (changed)
 513     /* Note that we've changed relocs, otherwise if !info->keep_memory
 514        we'll free the relocs and lose our changes.  */
 515     (const Elf_Internal_Rela *) (elf_section_data (sec)->relocs) = relocs;
 516
 517   return TRUE;
 518 }
 519
 520 \f
 521 /* Relocate a IQ2000 ELF section.
 522    There is some attempt to make this function usable for many architectures,
 523    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 524    if only to serve as a learning tool.
 525
 526    The RELOCATE_SECTION function is called by the new ELF backend linker
 527    to handle the relocations for a section.
 528
 529    The relocs are always passed as Rela structures; if the section
 530    actually uses Rel structures, the r_addend field will always be
 531    zero.
 532
 533    This function is responsible for adjusting the section contents as
 534    necessary, and (if using Rela relocs and generating a relocatable
 535    output file) adjusting the reloc addend as necessary.
 536
 537    This function does not have to worry about setting the reloc
 538    address or the reloc symbol index.
 539
 540    LOCAL_SYMS is a pointer to the swapped in local symbols.
 541
 542    LOCAL_SECTIONS is an array giving the section in the input file
 543    corresponding to the st_shndx field of each local symbol.
 544
 545    The global hash table entry for the global symbols can be found
 546    via elf_sym_hashes (input_bfd).
 547
 548    When generating relocatable output, this function must handle
 549    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 550    going to be the section symbol corresponding to the output
 551    section, which means that the addend must be adjusted
 552    accordingly.  */
 553
 554 static bfd_boolean
 555 iq2000_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 556                            contents, relocs, local_syms, local_sections)
 557      bfd *                   output_bfd ATTRIBUTE_UNUSED;
 558      struct bfd_link_info *  info;
 559      bfd *                   input_bfd;
 560      asection *              input_section;
 561      bfd_byte *              contents;
 562      Elf_Internal_Rela *     relocs;
 563      Elf_Internal_Sym *      local_syms;
 564      asection **             local_sections;
 565 {
 566   Elf_Internal_Shdr *           symtab_hdr;
 567   struct elf_link_hash_entry ** sym_hashes;
 568   Elf_Internal_Rela *           rel;
 569   Elf_Internal_Rela *           relend;
 570
 571   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 572   sym_hashes = elf_sym_hashes (input_bfd);
 573   relend     = relocs + input_section->reloc_count;
 574
 575   for (rel = relocs; rel < relend; rel ++)
 576     {
 577       reloc_howto_type *           howto;
 578       unsigned long                r_symndx;
 579       Elf_Internal_Sym *           sym;
 580       asection *                   sec;
 581       struct elf_link_hash_entry * h;
 582       bfd_vma                      relocation;
 583       bfd_reloc_status_type        r;
 584       const char *                 name = NULL;
 585       int                          r_type;
 586
 587       r_type = ELF32_R_TYPE (rel->r_info);
 588
 589       if (   r_type == R_IQ2000_GNU_VTINHERIT
 590           || r_type == R_IQ2000_GNU_VTENTRY)
 591         continue;
 592
 593       r_symndx = ELF32_R_SYM (rel->r_info);
 594
 595       /* This is a final link.  */
 596       howto  = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 597       h      = NULL;
 598       sym    = NULL;
 599       sec    = NULL;
 600
 601       if (r_symndx < symtab_hdr->sh_info)
 602         {
 603           sym = local_syms + r_symndx;
 604           sec = local_sections [r_symndx];
 605           relocation = (sec->output_section->vma
 606                         + sec->output_offset
 607                         + sym->st_value);
 608
 609           name = bfd_elf_string_from_elf_section
 610             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 611           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 612 #ifdef DEBUG
 613           fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
 614                    sec->name, name, sym->st_name,
 615                    sec->output_section->vma, sec->output_offset,
 616                    sym->st_value, rel->r_addend);
 617 #endif
 618         }
 619       else
 620         {
 621           h = sym_hashes [r_symndx];
 622
 623           while (h->root.type == bfd_link_hash_indirect
 624                  || h->root.type == bfd_link_hash_warning)
 625             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 626
 627           name = h->root.root.string;
 628
 629           if (h->root.type == bfd_link_hash_defined
 630               || h->root.type == bfd_link_hash_defweak)
 631             {
 632               sec = h->root.u.def.section;
 633               relocation = (h->root.u.def.value
 634                             + sec->output_section->vma
 635                             + sec->output_offset);
 636 #ifdef DEBUG
 637               fprintf (stderr,
 638                        "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
 639                        sec->name, name, h->root.u.def.value,
 640                        sec->output_section->vma, sec->output_offset, relocation);
 641 #endif
 642             }
 643           else if (h->root.type == bfd_link_hash_undefweak)
 644             {
 645 #ifdef DEBUG
 646               fprintf (stderr, "undefined: sec: %s, name: %s\n",
 647                        sec->name, name);
 648 #endif
 649               relocation = 0;
 650             }
 651           else
 652             {
 653               if (! ((*info->callbacks->undefined_symbol)
 654                      (info, h->root.root.string, input_bfd,
 655                       input_section, rel->r_offset,
 656                      (!info->shared || info->no_undefined))))
 657                 return FALSE;
 658 #ifdef DEBUG
 659               fprintf (stderr, "unknown: name: %s\n", name);
 660 #endif
 661               relocation = 0;
 662             }
 663         }
 664
 665       switch (r_type)
 666         {
 667         case R_IQ2000_HI16:
 668           r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 669           break;
 670
 671         case R_IQ2000_PC16:
 672           rel->r_addend -= 4;
 673           /* Fall through.  */
 674
 675         default:
 676           r = iq2000_final_link_relocate (howto, input_bfd, input_section,
 677                                          contents, rel, relocation);
 678           break;
 679         }
 680
 681       if (r != bfd_reloc_ok)
 682         {
 683           const char * msg = (const char *) NULL;
 684
 685           switch (r)
 686             {
 687             case bfd_reloc_overflow:
 688               r = info->callbacks->reloc_overflow
 689                 (info, name, howto->name, (bfd_vma) 0,
 690                  input_bfd, input_section, rel->r_offset);
 691               break;
 692
 693             case bfd_reloc_undefined:
 694               r = info->callbacks->undefined_symbol
 695                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 696               break;
 697
 698             case bfd_reloc_outofrange:
 699               msg = _("internal error: out of range error");
 700               break;
 701
 702             case bfd_reloc_notsupported:
 703               msg = _("internal error: unsupported relocation error");
 704               break;
 705
 706             case bfd_reloc_dangerous:
 707               msg = _("internal error: dangerous relocation");
 708               break;
 709
 710             default:
 711               msg = _("internal error: unknown error");
 712               break;
 713             }
 714
 715           if (msg)
 716             r = info->callbacks->warning
 717               (info, msg, name, input_bfd, input_section, rel->r_offset);
 718
 719           if (! r)
 720             return FALSE;
 721         }
 722     }
 723
 724   return TRUE;
 725 }
 726 \f
 727
 728 /* Update the got entry reference counts for the section being
 729    removed.  */
 730
 731 static bfd_boolean
 732 iq2000_elf_gc_sweep_hook (abfd, info, sec, relocs)
 733      bfd *                     abfd ATTRIBUTE_UNUSED;
 734      struct bfd_link_info *    info ATTRIBUTE_UNUSED;
 735      asection *                sec ATTRIBUTE_UNUSED;
 736      const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
 737 {
 738   return TRUE;
 739 }
 740
 741 /* Return the section that should be marked against GC for a given
 742    relocation.  */
 743
 744 static asection *
 745 iq2000_elf_gc_mark_hook (sec, info, rel, h, sym)
 746      asection *                   sec;
 747      struct bfd_link_info *       info ATTRIBUTE_UNUSED;
 748      Elf_Internal_Rela *          rel;
 749      struct elf_link_hash_entry * h;
 750      Elf_Internal_Sym *           sym;
 751 {
 752   if (h != NULL)
 753     {
 754       switch (ELF32_R_TYPE (rel->r_info))
 755         {
 756         case R_IQ2000_GNU_VTINHERIT:
 757         case R_IQ2000_GNU_VTENTRY:
 758           break;
 759
 760         default:
 761           switch (h->root.type)
 762             {
 763             case bfd_link_hash_defined:
 764             case bfd_link_hash_defweak:
 765               return h->root.u.def.section;
 766
 767             case bfd_link_hash_common:
 768               return h->root.u.c.p->section;
 769
 770             default:
 771               break;
 772             }
 773         }
 774     }
 775   else
 776     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 777
 778   return NULL;
 779 }
 780
 781 \f
 782 /* Return the MACH for an e_flags value.  */
 783
 784 static int
 785 elf32_iq2000_machine (abfd)
 786      bfd *abfd;
 787 {
 788   switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
 789     {
 790     case EF_IQ2000_CPU_IQ2000:  return bfd_mach_iq2000;
 791     case EF_IQ2000_CPU_IQ10:  return bfd_mach_iq10;
 792     }
 793
 794   return bfd_mach_iq2000;
 795 }
 796
 797 \f
 798 /* Function to set the ELF flag bits.  */
 799
 800 static bfd_boolean
 801 iq2000_elf_set_private_flags (abfd, flags)
 802      bfd *abfd;
 803      flagword flags;
 804 {
 805   elf_elfheader (abfd)->e_flags = flags;
 806   elf_flags_init (abfd) = TRUE;
 807   return TRUE;
 808 }
 809
 810 /* Copy backend specific data from one object module to another.  */
 811
 812 static bfd_boolean
 813 iq2000_elf_copy_private_bfd_data (ibfd, obfd)
 814      bfd *ibfd;
 815      bfd *obfd;
 816 {
 817   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 818       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 819     return TRUE;
 820
 821   BFD_ASSERT (!elf_flags_init (obfd)
 822               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 823
 824   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 825   elf_flags_init (obfd) = TRUE;
 826   return TRUE;
 827 }
 828
 829 /* Merge backend specific data from an object file to the output
 830    object file when linking.  */
 831
 832 static bfd_boolean
 833 iq2000_elf_merge_private_bfd_data (ibfd, obfd)
 834      bfd *ibfd;
 835      bfd *obfd;
 836 {
 837   flagword old_flags, old_partial;
 838   flagword new_flags, new_partial;
 839   bfd_boolean error = FALSE;
 840   char new_opt[80];
 841   char old_opt[80];
 842
 843   new_opt[0] = old_opt[0] = '\0';
 844   new_flags = elf_elfheader (ibfd)->e_flags;
 845   old_flags = elf_elfheader (obfd)->e_flags;
 846
 847 #ifdef DEBUG
 848   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
 849                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
 850                          bfd_get_filename (ibfd));
 851 #endif
 852
 853   if (!elf_flags_init (obfd))
 854     {
 855       /* First call, no flags set.  */
 856       elf_flags_init (obfd) = TRUE;
 857       elf_elfheader (obfd)->e_flags = new_flags;
 858     }
 859
 860   else if (new_flags == old_flags)
 861     /* Compatible flags are ok.  */
 862     ;
 863
 864   else          /* Possibly incompatible flags.  */
 865     {
 866       /* Warn if different cpu is used (allow a specific cpu to override
 867          the generic cpu).  */
 868       new_partial = (new_flags & EF_IQ2000_CPU_MASK);
 869       old_partial = (old_flags & EF_IQ2000_CPU_MASK);
 870       if (new_partial == old_partial)
 871         ;
 872
 873       else
 874         {
 875           switch (new_partial)
 876             {
 877             default:              strcat (new_opt, " -m2000");  break;
 878             case EF_IQ2000_CPU_IQ2000:  strcat (new_opt, " -m2000");  break;
 879             case EF_IQ2000_CPU_IQ10:  strcat (new_opt, " -m10");  break;
 880             }
 881
 882           switch (old_partial)
 883             {
 884             default:              strcat (old_opt, " -m2000");  break;
 885             case EF_IQ2000_CPU_IQ2000:  strcat (old_opt, " -m2000");  break;
 886             case EF_IQ2000_CPU_IQ10:  strcat (old_opt, " -m10");  break;
 887             }
 888         }
 889
 890       /* Print out any mismatches from above.  */
 891       if (new_opt[0])
 892         {
 893           error = TRUE;
 894           (*_bfd_error_handler)
 895             (_("%s: compiled with %s and linked with modules compiled with %s"),
 896              bfd_get_filename (ibfd), new_opt, old_opt);
 897         }
 898
 899       new_flags &= ~ EF_IQ2000_ALL_FLAGS;
 900       old_flags &= ~ EF_IQ2000_ALL_FLAGS;
 901
 902       /* Warn about any other mismatches.  */
 903       if (new_flags != old_flags)
 904         {
 905           error = TRUE;
 906           (*_bfd_error_handler)
 907             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
 908              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 909         }
 910     }
 911
 912   if (error)
 913     bfd_set_error (bfd_error_bad_value);
 914
 915   return !error;
 916 }
 917
 918 \f
 919 static bfd_boolean
 920 iq2000_elf_print_private_bfd_data (abfd, ptr)
 921      bfd *abfd;
 922      PTR ptr;
 923 {
 924   FILE *file = (FILE *) ptr;
 925   flagword flags;
 926
 927   BFD_ASSERT (abfd != NULL && ptr != NULL);
 928
 929   /* Print normal ELF private data.  */
 930   _bfd_elf_print_private_bfd_data (abfd, ptr);
 931
 932   flags = elf_elfheader (abfd)->e_flags;
 933   fprintf (file, _("private flags = 0x%lx:"), (long)flags);
 934
 935   switch (flags & EF_IQ2000_CPU_MASK)
 936     {
 937     default:                                                    break;
 938     case EF_IQ2000_CPU_IQ2000:  fprintf (file, " -m2000");      break;
 939     case EF_IQ2000_CPU_IQ10:  fprintf (file, " -m10");  break;
 940     }
 941
 942   fputc ('\n', file);
 943   return TRUE;
 944 }
 945
 946 static
 947 bfd_boolean
 948 iq2000_elf_object_p (abfd)
 949      bfd *abfd;
 950 {
 951   /* Irix 5 and 6 is broken.  Object file symbol tables are not always
 952      sorted correctly such that local symbols precede global symbols,
 953      and the sh_info field in the symbol table is not always right.  */
 954   elf_bad_symtab (abfd) = TRUE;
 955
 956   bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
 957                              elf32_iq2000_machine (abfd));
 958   return TRUE;
 959 }
 960
 961 \f
 962 #define ELF_ARCH                bfd_arch_iq2000
 963 #define ELF_MACHINE_CODE        EM_IQ2000
 964 #define ELF_MAXPAGESIZE         0x1000
 965
 966 #define TARGET_BIG_SYM          bfd_elf32_iq2000_vec
 967 #define TARGET_BIG_NAME         "elf32-iq2000"
 968
 969 #define elf_info_to_howto_rel                   NULL
 970 #define elf_info_to_howto                       iq2000_info_to_howto_rela
 971 #define elf_backend_relocate_section            iq2000_elf_relocate_section
 972 #define elf_backend_gc_mark_hook                iq2000_elf_gc_mark_hook
 973 #define elf_backend_gc_sweep_hook               iq2000_elf_gc_sweep_hook
 974 #define elf_backend_check_relocs                iq2000_elf_check_relocs
 975 #define elf_backend_object_p                    iq2000_elf_object_p
 976 #define elf_backend_rela_normal                 1
 977
 978 #define elf_backend_can_gc_sections             1
 979
 980 #define bfd_elf32_bfd_reloc_type_lookup         iq2000_reloc_type_lookup
 981 #define bfd_elf32_bfd_set_private_flags         iq2000_elf_set_private_flags
 982 #define bfd_elf32_bfd_copy_private_bfd_data     iq2000_elf_copy_private_bfd_data
 983 #define bfd_elf32_bfd_merge_private_bfd_data    iq2000_elf_merge_private_bfd_data
 984 #define bfd_elf32_bfd_print_private_bfd_data    iq2000_elf_print_private_bfd_data
 985
 986 #include "elf32-target.h"