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           bfd_boolean unresolved_reloc;
 622           bfd_boolean warned;
 623
 624           RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx,
 625                                    symtab_hdr, relocation,
 626                                    sec, unresolved_reloc, info, warned);
 627
 628           name = h->root.root.string;
 629         }
 630
 631       switch (r_type)
 632         {
 633         case R_IQ2000_HI16:
 634           r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 635           break;
 636
 637         case R_IQ2000_PC16:
 638           rel->r_addend -= 4;
 639           /* Fall through.  */
 640
 641         default:
 642           r = iq2000_final_link_relocate (howto, input_bfd, input_section,
 643                                          contents, rel, relocation);
 644           break;
 645         }
 646
 647       if (r != bfd_reloc_ok)
 648         {
 649           const char * msg = (const char *) NULL;
 650
 651           switch (r)
 652             {
 653             case bfd_reloc_overflow:
 654               r = info->callbacks->reloc_overflow
 655                 (info, name, howto->name, (bfd_vma) 0,
 656                  input_bfd, input_section, rel->r_offset);
 657               break;
 658
 659             case bfd_reloc_undefined:
 660               r = info->callbacks->undefined_symbol
 661                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 662               break;
 663
 664             case bfd_reloc_outofrange:
 665               msg = _("internal error: out of range error");
 666               break;
 667
 668             case bfd_reloc_notsupported:
 669               msg = _("internal error: unsupported relocation error");
 670               break;
 671
 672             case bfd_reloc_dangerous:
 673               msg = _("internal error: dangerous relocation");
 674               break;
 675
 676             default:
 677               msg = _("internal error: unknown error");
 678               break;
 679             }
 680
 681           if (msg)
 682             r = info->callbacks->warning
 683               (info, msg, name, input_bfd, input_section, rel->r_offset);
 684
 685           if (! r)
 686             return FALSE;
 687         }
 688     }
 689
 690   return TRUE;
 691 }
 692 \f
 693
 694 /* Update the got entry reference counts for the section being
 695    removed.  */
 696
 697 static bfd_boolean
 698 iq2000_elf_gc_sweep_hook (abfd, info, sec, relocs)
 699      bfd *                     abfd ATTRIBUTE_UNUSED;
 700      struct bfd_link_info *    info ATTRIBUTE_UNUSED;
 701      asection *                sec ATTRIBUTE_UNUSED;
 702      const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
 703 {
 704   return TRUE;
 705 }
 706
 707 /* Return the section that should be marked against GC for a given
 708    relocation.  */
 709
 710 static asection *
 711 iq2000_elf_gc_mark_hook (sec, info, rel, h, sym)
 712      asection *                   sec;
 713      struct bfd_link_info *       info ATTRIBUTE_UNUSED;
 714      Elf_Internal_Rela *          rel;
 715      struct elf_link_hash_entry * h;
 716      Elf_Internal_Sym *           sym;
 717 {
 718   if (h != NULL)
 719     {
 720       switch (ELF32_R_TYPE (rel->r_info))
 721         {
 722         case R_IQ2000_GNU_VTINHERIT:
 723         case R_IQ2000_GNU_VTENTRY:
 724           break;
 725
 726         default:
 727           switch (h->root.type)
 728             {
 729             case bfd_link_hash_defined:
 730             case bfd_link_hash_defweak:
 731               return h->root.u.def.section;
 732
 733             case bfd_link_hash_common:
 734               return h->root.u.c.p->section;
 735
 736             default:
 737               break;
 738             }
 739         }
 740     }
 741   else
 742     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 743
 744   return NULL;
 745 }
 746
 747 \f
 748 /* Return the MACH for an e_flags value.  */
 749
 750 static int
 751 elf32_iq2000_machine (abfd)
 752      bfd *abfd;
 753 {
 754   switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
 755     {
 756     case EF_IQ2000_CPU_IQ2000:  return bfd_mach_iq2000;
 757     case EF_IQ2000_CPU_IQ10:  return bfd_mach_iq10;
 758     }
 759
 760   return bfd_mach_iq2000;
 761 }
 762
 763 \f
 764 /* Function to set the ELF flag bits.  */
 765
 766 static bfd_boolean
 767 iq2000_elf_set_private_flags (abfd, flags)
 768      bfd *abfd;
 769      flagword flags;
 770 {
 771   elf_elfheader (abfd)->e_flags = flags;
 772   elf_flags_init (abfd) = TRUE;
 773   return TRUE;
 774 }
 775
 776 /* Copy backend specific data from one object module to another.  */
 777
 778 static bfd_boolean
 779 iq2000_elf_copy_private_bfd_data (ibfd, obfd)
 780      bfd *ibfd;
 781      bfd *obfd;
 782 {
 783   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 784       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 785     return TRUE;
 786
 787   BFD_ASSERT (!elf_flags_init (obfd)
 788               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 789
 790   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 791   elf_flags_init (obfd) = TRUE;
 792   return TRUE;
 793 }
 794
 795 /* Merge backend specific data from an object file to the output
 796    object file when linking.  */
 797
 798 static bfd_boolean
 799 iq2000_elf_merge_private_bfd_data (ibfd, obfd)
 800      bfd *ibfd;
 801      bfd *obfd;
 802 {
 803   flagword old_flags, old_partial;
 804   flagword new_flags, new_partial;
 805   bfd_boolean error = FALSE;
 806   char new_opt[80];
 807   char old_opt[80];
 808
 809   new_opt[0] = old_opt[0] = '\0';
 810   new_flags = elf_elfheader (ibfd)->e_flags;
 811   old_flags = elf_elfheader (obfd)->e_flags;
 812
 813 #ifdef DEBUG
 814   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
 815                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
 816                          bfd_get_filename (ibfd));
 817 #endif
 818
 819   if (!elf_flags_init (obfd))
 820     {
 821       /* First call, no flags set.  */
 822       elf_flags_init (obfd) = TRUE;
 823       elf_elfheader (obfd)->e_flags = new_flags;
 824     }
 825
 826   else if (new_flags == old_flags)
 827     /* Compatible flags are ok.  */
 828     ;
 829
 830   else          /* Possibly incompatible flags.  */
 831     {
 832       /* Warn if different cpu is used (allow a specific cpu to override
 833          the generic cpu).  */
 834       new_partial = (new_flags & EF_IQ2000_CPU_MASK);
 835       old_partial = (old_flags & EF_IQ2000_CPU_MASK);
 836       if (new_partial == old_partial)
 837         ;
 838
 839       else
 840         {
 841           switch (new_partial)
 842             {
 843             default:              strcat (new_opt, " -m2000");  break;
 844             case EF_IQ2000_CPU_IQ2000:  strcat (new_opt, " -m2000");  break;
 845             case EF_IQ2000_CPU_IQ10:  strcat (new_opt, " -m10");  break;
 846             }
 847
 848           switch (old_partial)
 849             {
 850             default:              strcat (old_opt, " -m2000");  break;
 851             case EF_IQ2000_CPU_IQ2000:  strcat (old_opt, " -m2000");  break;
 852             case EF_IQ2000_CPU_IQ10:  strcat (old_opt, " -m10");  break;
 853             }
 854         }
 855
 856       /* Print out any mismatches from above.  */
 857       if (new_opt[0])
 858         {
 859           error = TRUE;
 860           (*_bfd_error_handler)
 861             (_("%s: compiled with %s and linked with modules compiled with %s"),
 862              bfd_get_filename (ibfd), new_opt, old_opt);
 863         }
 864
 865       new_flags &= ~ EF_IQ2000_ALL_FLAGS;
 866       old_flags &= ~ EF_IQ2000_ALL_FLAGS;
 867
 868       /* Warn about any other mismatches.  */
 869       if (new_flags != old_flags)
 870         {
 871           error = TRUE;
 872           (*_bfd_error_handler)
 873             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
 874              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 875         }
 876     }
 877
 878   if (error)
 879     bfd_set_error (bfd_error_bad_value);
 880
 881   return !error;
 882 }
 883
 884 \f
 885 static bfd_boolean
 886 iq2000_elf_print_private_bfd_data (abfd, ptr)
 887      bfd *abfd;
 888      PTR ptr;
 889 {
 890   FILE *file = (FILE *) ptr;
 891   flagword flags;
 892
 893   BFD_ASSERT (abfd != NULL && ptr != NULL);
 894
 895   /* Print normal ELF private data.  */
 896   _bfd_elf_print_private_bfd_data (abfd, ptr);
 897
 898   flags = elf_elfheader (abfd)->e_flags;
 899   fprintf (file, _("private flags = 0x%lx:"), (long)flags);
 900
 901   switch (flags & EF_IQ2000_CPU_MASK)
 902     {
 903     default:                                                    break;
 904     case EF_IQ2000_CPU_IQ2000:  fprintf (file, " -m2000");      break;
 905     case EF_IQ2000_CPU_IQ10:  fprintf (file, " -m10");  break;
 906     }
 907
 908   fputc ('\n', file);
 909   return TRUE;
 910 }
 911
 912 static
 913 bfd_boolean
 914 iq2000_elf_object_p (abfd)
 915      bfd *abfd;
 916 {
 917   /* Irix 5 and 6 is broken.  Object file symbol tables are not always
 918      sorted correctly such that local symbols precede global symbols,
 919      and the sh_info field in the symbol table is not always right.  */
 920   elf_bad_symtab (abfd) = TRUE;
 921
 922   bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
 923                              elf32_iq2000_machine (abfd));
 924   return TRUE;
 925 }
 926
 927 \f
 928 #define ELF_ARCH                bfd_arch_iq2000
 929 #define ELF_MACHINE_CODE        EM_IQ2000
 930 #define ELF_MAXPAGESIZE         0x1000
 931
 932 #define TARGET_BIG_SYM          bfd_elf32_iq2000_vec
 933 #define TARGET_BIG_NAME         "elf32-iq2000"
 934
 935 #define elf_info_to_howto_rel                   NULL
 936 #define elf_info_to_howto                       iq2000_info_to_howto_rela
 937 #define elf_backend_relocate_section            iq2000_elf_relocate_section
 938 #define elf_backend_gc_mark_hook                iq2000_elf_gc_mark_hook
 939 #define elf_backend_gc_sweep_hook               iq2000_elf_gc_sweep_hook
 940 #define elf_backend_check_relocs                iq2000_elf_check_relocs
 941 #define elf_backend_object_p                    iq2000_elf_object_p
 942 #define elf_backend_rela_normal                 1
 943
 944 #define elf_backend_can_gc_sections             1
 945
 946 #define bfd_elf32_bfd_reloc_type_lookup         iq2000_reloc_type_lookup
 947 #define bfd_elf32_bfd_set_private_flags         iq2000_elf_set_private_flags
 948 #define bfd_elf32_bfd_copy_private_bfd_data     iq2000_elf_copy_private_bfd_data
 949 #define bfd_elf32_bfd_merge_private_bfd_data    iq2000_elf_merge_private_bfd_data
 950 #define bfd_elf32_bfd_print_private_bfd_data    iq2000_elf_print_private_bfd_data
 951
 952 #include "elf32-target.h"