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