bfd/elf32-iq2000.c

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