bfd/elf32-m32r.c

   1 /* M32R-specific support for 32-bit ELF.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/m32r.h"
  26
  27 static bfd_reloc_status_type m32r_elf_10_pcrel_reloc
  28   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  29 static bfd_reloc_status_type m32r_elf_do_10_pcrel_reloc
  30   PARAMS ((bfd *, reloc_howto_type *, asection *,
  31            bfd_byte *, bfd_vma, asection *, bfd_vma, bfd_vma));
  32 static bfd_reloc_status_type m32r_elf_hi16_reloc
  33   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  34 static void m32r_elf_relocate_hi16
  35   PARAMS ((bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *,
  36            bfd_byte *, bfd_vma));
  37 bfd_reloc_status_type m32r_elf_lo16_reloc
  38   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  39 bfd_reloc_status_type m32r_elf_generic_reloc
  40   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  41 static bfd_reloc_status_type m32r_elf_sda16_reloc
  42   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  43 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  44   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  45 static void m32r_info_to_howto_rel
  46   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
  47 boolean _bfd_m32r_elf_section_from_bfd_section
  48   PARAMS ((bfd *, asection *, int *));
  49 void _bfd_m32r_elf_symbol_processing
  50   PARAMS ((bfd *, asymbol *));
  51 static boolean m32r_elf_add_symbol_hook
  52   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
  53            const char **, flagword *, asection **, bfd_vma *));
  54 static boolean m32r_elf_relocate_section
  55   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  56            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  57 #if 0 /* not yet */
  58 static boolean m32r_elf_relax_delete_bytes
  59   PARAMS ((bfd *, asection *, bfd_vma, int));
  60 #endif
  61 static bfd_reloc_status_type m32r_elf_final_sda_base
  62   PARAMS ((bfd *, struct bfd_link_info *, const char **, bfd_vma *));
  63 static boolean m32r_elf_object_p
  64   PARAMS ((bfd *));
  65 static void m32r_elf_final_write_processing
  66   PARAMS ((bfd *, boolean));
  67 static boolean m32r_elf_set_private_flags
  68   PARAMS ((bfd *, flagword));
  69 static boolean m32r_elf_merge_private_bfd_data
  70   PARAMS ((bfd *, bfd *));
  71 static boolean m32r_elf_print_private_bfd_data
  72   PARAMS ((bfd *, PTR));
  73 static boolean m32r_elf_gc_sweep_hook
  74   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  75            const Elf_Internal_Rela *));
  76 static boolean m32r_elf_check_relocs
  77   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  78            const Elf_Internal_Rela *));
  79
  80 asection * m32r_elf_gc_mark_hook
  81   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  82            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  83
  84 #define NOP_INSN                0x7000
  85 #define MAKE_PARALLEL(insn)     ((insn) | 0x8000)
  86
  87 /* Use REL instead of RELA to save space.
  88    This only saves space in libraries and object files, but perhaps
  89    relocs will be put in ROM?  All in all though, REL relocs are a pain
  90    to work with.  */
  91 #define USE_REL
  92
  93 static reloc_howto_type m32r_elf_howto_table[] =
  94 {
  95   /* This reloc does nothing.  */
  96   HOWTO (R_M32R_NONE,           /* type */
  97          0,                     /* rightshift */
  98          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  99          32,                    /* bitsize */
 100          false,                 /* pc_relative */
 101          0,                     /* bitpos */
 102          complain_overflow_bitfield, /* complain_on_overflow */
 103          bfd_elf_generic_reloc, /* special_function */
 104          "R_M32R_NONE",         /* name */
 105          false,                 /* partial_inplace */
 106          0,                     /* src_mask */
 107          0,                     /* dst_mask */
 108          false),                /* pcrel_offset */
 109
 110   /* A 16 bit absolute relocation.  */
 111   HOWTO (R_M32R_16,             /* type */
 112          0,                     /* rightshift */
 113          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 114          16,                    /* bitsize */
 115          false,                 /* pc_relative */
 116          0,                     /* bitpos */
 117          complain_overflow_bitfield, /* complain_on_overflow */
 118          m32r_elf_generic_reloc,/* special_function */
 119          "R_M32R_16",           /* name */
 120          true,                  /* partial_inplace */
 121          0xffff,                /* src_mask */
 122          0xffff,                /* dst_mask */
 123          false),                /* pcrel_offset */
 124
 125   /* A 32 bit absolute relocation.  */
 126   HOWTO (R_M32R_32,             /* type */
 127          0,                     /* rightshift */
 128          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 129          32,                    /* bitsize */
 130          false,                 /* pc_relative */
 131          0,                     /* bitpos */
 132          complain_overflow_bitfield, /* complain_on_overflow */
 133          m32r_elf_generic_reloc,/* special_function */
 134          "R_M32R_32",           /* name */
 135          true,                  /* partial_inplace */
 136          0xffffffff,            /* src_mask */
 137          0xffffffff,            /* dst_mask */
 138          false),                /* pcrel_offset */
 139
 140   /* A 24 bit address.  */
 141   HOWTO (R_M32R_24,             /* type */
 142          0,                     /* rightshift */
 143          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 144          24,                    /* bitsize */
 145          false,                 /* pc_relative */
 146          0,                     /* bitpos */
 147          complain_overflow_unsigned, /* complain_on_overflow */
 148          m32r_elf_generic_reloc,/* special_function */
 149          "R_M32R_24",           /* name */
 150          true,                  /* partial_inplace */
 151          0xffffff,              /* src_mask */
 152          0xffffff,              /* dst_mask */
 153          false),                /* pcrel_offset */
 154
 155   /* An PC Relative 10-bit relocation, shifted by 2.
 156      This reloc is complicated because relocations are relative to pc & -4.
 157      i.e. branches in the right insn slot use the address of the left insn
 158      slot for pc.  */
 159   /* ??? It's not clear whether this should have partial_inplace set or not.
 160      Branch relaxing in the assembler can store the addend in the insn,
 161      and if bfd_install_relocation gets called the addend may get added
 162      again.  */
 163   HOWTO (R_M32R_10_PCREL,       /* type */
 164          2,                     /* rightshift */
 165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 166          10,                    /* bitsize */
 167          true,                  /* pc_relative */
 168          0,                     /* bitpos */
 169          complain_overflow_signed, /* complain_on_overflow */
 170          m32r_elf_10_pcrel_reloc, /* special_function */
 171          "R_M32R_10_PCREL",     /* name */
 172          false,                 /* partial_inplace */
 173          0xff,                  /* src_mask */
 174          0xff,                  /* dst_mask */
 175          true),                 /* pcrel_offset */
 176
 177   /* A relative 18 bit relocation, right shifted by 2.  */
 178   HOWTO (R_M32R_18_PCREL,       /* type */
 179          2,                     /* rightshift */
 180          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 181          16,                    /* bitsize */
 182          true,                  /* pc_relative */
 183          0,                     /* bitpos */
 184          complain_overflow_signed, /* complain_on_overflow */
 185          bfd_elf_generic_reloc, /* special_function */
 186          "R_M32R_18_PCREL",     /* name */
 187          false,                 /* partial_inplace */
 188          0xffff,                /* src_mask */
 189          0xffff,                /* dst_mask */
 190          true),                 /* pcrel_offset */
 191
 192   /* A relative 26 bit relocation, right shifted by 2.  */
 193   /* ??? It's not clear whether this should have partial_inplace set or not.
 194      Branch relaxing in the assembler can store the addend in the insn,
 195      and if bfd_install_relocation gets called the addend may get added
 196      again.  */
 197   HOWTO (R_M32R_26_PCREL,       /* type */
 198          2,                     /* rightshift */
 199          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          26,                    /* bitsize */
 201          true,                  /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_signed, /* complain_on_overflow */
 204          bfd_elf_generic_reloc, /* special_function */
 205          "R_M32R_26_PCREL",     /* name */
 206          false,                 /* partial_inplace */
 207          0xffffff,              /* src_mask */
 208          0xffffff,              /* dst_mask */
 209          true),                 /* pcrel_offset */
 210
 211   /* High 16 bits of address when lower 16 is or'd in.  */
 212   HOWTO (R_M32R_HI16_ULO,       /* type */
 213          16,                    /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          16,                    /* bitsize */
 216          false,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_dont, /* complain_on_overflow */
 219          m32r_elf_hi16_reloc,   /* special_function */
 220          "R_M32R_HI16_ULO",     /* name */
 221          true,                  /* partial_inplace */
 222          0x0000ffff,            /* src_mask */
 223          0x0000ffff,            /* dst_mask */
 224          false),                /* pcrel_offset */
 225
 226   /* High 16 bits of address when lower 16 is added in.  */
 227   HOWTO (R_M32R_HI16_SLO,       /* type */
 228          16,                    /* rightshift */
 229          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          16,                    /* bitsize */
 231          false,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_dont, /* complain_on_overflow */
 234          m32r_elf_hi16_reloc,   /* special_function */
 235          "R_M32R_HI16_SLO",     /* name */
 236          true,                  /* partial_inplace */
 237          0x0000ffff,            /* src_mask */
 238          0x0000ffff,            /* dst_mask */
 239          false),                /* pcrel_offset */
 240
 241   /* Lower 16 bits of address.  */
 242   HOWTO (R_M32R_LO16,           /* type */
 243          0,                     /* rightshift */
 244          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 245          16,                    /* bitsize */
 246          false,                 /* pc_relative */
 247          0,                     /* bitpos */
 248          complain_overflow_dont, /* complain_on_overflow */
 249          m32r_elf_lo16_reloc,   /* special_function */
 250          "R_M32R_LO16",         /* name */
 251          true,                  /* partial_inplace */
 252          0x0000ffff,            /* src_mask */
 253          0x0000ffff,            /* dst_mask */
 254          false),                /* pcrel_offset */
 255
 256   /* Small data area 16 bits offset.  */
 257   HOWTO (R_M32R_SDA16,          /* type */
 258          0,                     /* rightshift */
 259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 260          16,                    /* bitsize */
 261          false,                 /* pc_relative */
 262          0,                     /* bitpos */
 263          complain_overflow_signed, /* complain_on_overflow */
 264          m32r_elf_sda16_reloc,  /* special_function */
 265          "R_M32R_SDA16",        /* name */
 266          true,                  /* partial_inplace */  /* FIXME: correct? */
 267          0x0000ffff,            /* src_mask */
 268          0x0000ffff,            /* dst_mask */
 269          false),                /* pcrel_offset */
 270
 271   /* GNU extension to record C++ vtable hierarchy */
 272   HOWTO (R_M32R_GNU_VTINHERIT, /* type */
 273          0,                     /* rightshift */
 274          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          0,                     /* bitsize */
 276          false,                 /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_dont, /* complain_on_overflow */
 279          NULL,                  /* special_function */
 280          "R_M32R_GNU_VTINHERIT", /* name */
 281          false,                 /* partial_inplace */
 282          0,                     /* src_mask */
 283          0,                     /* dst_mask */
 284          false),                /* pcrel_offset */
 285
 286   /* GNU extension to record C++ vtable member usage */
 287   HOWTO (R_M32R_GNU_VTENTRY,     /* type */
 288          0,                     /* rightshift */
 289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          0,                     /* bitsize */
 291          false,                 /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_dont, /* complain_on_overflow */
 294          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 295          "R_M32R_GNU_VTENTRY",   /* name */
 296          false,                 /* partial_inplace */
 297          0,                     /* src_mask */
 298          0,                     /* dst_mask */
 299          false),                /* pcrel_offset */
 300
 301 };
 302 \f
 303 /* Handle the R_M32R_10_PCREL reloc.  */
 304
 305 static bfd_reloc_status_type
 306 m32r_elf_10_pcrel_reloc (abfd, reloc_entry, symbol, data,
 307                          input_section, output_bfd, error_message)
 308      bfd * abfd;
 309      arelent * reloc_entry;
 310      asymbol * symbol;
 311      PTR data;
 312      asection * input_section;
 313      bfd * output_bfd;
 314      char ** error_message ATTRIBUTE_UNUSED;
 315 {
 316   /* This part is from bfd_elf_generic_reloc.  */
 317   if (output_bfd != (bfd *) NULL
 318       && (symbol->flags & BSF_SECTION_SYM) == 0
 319       && (! reloc_entry->howto->partial_inplace
 320           || reloc_entry->addend == 0))
 321     {
 322       reloc_entry->address += input_section->output_offset;
 323       return bfd_reloc_ok;
 324     }
 325
 326   if (output_bfd != NULL)
 327     {
 328       /* FIXME: See bfd_perform_relocation.  Is this right?  */
 329       return bfd_reloc_continue;
 330     }
 331
 332   return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
 333                                      input_section,
 334                                      data, reloc_entry->address,
 335                                      symbol->section,
 336                                      (symbol->value
 337                                       + symbol->section->output_section->vma
 338                                       + symbol->section->output_offset),
 339                                      reloc_entry->addend);
 340 }
 341
 342 /* Utility to actually perform an R_M32R_10_PCREL reloc.  */
 343
 344 static bfd_reloc_status_type
 345 m32r_elf_do_10_pcrel_reloc (abfd, howto, input_section, data, offset,
 346                             symbol_section, symbol_value, addend)
 347      bfd *abfd;
 348      reloc_howto_type *howto;
 349      asection *input_section;
 350      bfd_byte *data;
 351      bfd_vma offset;
 352      asection *symbol_section ATTRIBUTE_UNUSED;
 353      bfd_vma symbol_value;
 354      bfd_vma addend;
 355 {
 356   bfd_signed_vma relocation;
 357   unsigned long x;
 358   bfd_reloc_status_type status;
 359
 360   /* Sanity check the address (offset in section).  */
 361   if (offset > input_section->_cooked_size)
 362     return bfd_reloc_outofrange;
 363
 364   relocation = symbol_value + addend;
 365   /* Make it pc relative.  */
 366   relocation -= (input_section->output_section->vma
 367                  + input_section->output_offset);
 368   /* These jumps mask off the lower two bits of the current address
 369      before doing pcrel calculations.  */
 370   relocation -= (offset & -(bfd_vma) 4);
 371
 372   if (relocation < -0x200 || relocation > 0x1ff)
 373     status = bfd_reloc_overflow;
 374   else
 375     status = bfd_reloc_ok;
 376
 377   x = bfd_get_16 (abfd, data + offset);
 378   relocation >>= howto->rightshift;
 379   relocation <<= howto->bitpos;
 380   x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
 381   bfd_put_16 (abfd, (bfd_vma) x, data + offset);
 382
 383   return status;
 384 }
 385
 386 /* Handle the R_M32R_HI16_[SU]LO relocs.
 387    HI16_SLO is for the add3 and load/store with displacement instructions.
 388    HI16_ULO is for the or3 instruction.
 389    For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
 390    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
 391    we must add one to the high 16 bytes (which will get subtracted off when
 392    the low 16 bits are added).
 393    These relocs have to be done in combination with an R_M32R_LO16 reloc
 394    because there is a carry from the LO16 to the HI16.  Here we just save
 395    the information we need; we do the actual relocation when we see the LO16.
 396    This code is copied from the elf32-mips.c.  We also support an arbitrary
 397    number of HI16 relocs to be associated with a single LO16 reloc.  The
 398    assembler sorts the relocs to ensure each HI16 immediately precedes its
 399    LO16.  However if there are multiple copies, the assembler may not find
 400    the real LO16 so it picks the first one it finds.  */
 401
 402 struct m32r_hi16
 403 {
 404   struct m32r_hi16 *next;
 405   bfd_byte *addr;
 406   bfd_vma addend;
 407 };
 408
 409 /* FIXME: This should not be a static variable.  */
 410
 411 static struct m32r_hi16 *m32r_hi16_list;
 412
 413 static bfd_reloc_status_type
 414 m32r_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
 415                      input_section, output_bfd, error_message)
 416      bfd *abfd ATTRIBUTE_UNUSED;
 417      arelent *reloc_entry;
 418      asymbol *symbol;
 419      PTR data;
 420      asection *input_section;
 421      bfd *output_bfd;
 422      char **error_message ATTRIBUTE_UNUSED;
 423 {
 424   bfd_reloc_status_type ret;
 425   bfd_vma relocation;
 426   struct m32r_hi16 *n;
 427
 428   /* This part is from bfd_elf_generic_reloc.
 429      If we're relocating, and this an external symbol, we don't want
 430      to change anything.  */
 431   if (output_bfd != (bfd *) NULL
 432       && (symbol->flags & BSF_SECTION_SYM) == 0
 433       && reloc_entry->addend == 0)
 434     {
 435       reloc_entry->address += input_section->output_offset;
 436       return bfd_reloc_ok;
 437     }
 438
 439   /* Sanity check the address (offset in section).  */
 440   if (reloc_entry->address > input_section->_cooked_size)
 441     return bfd_reloc_outofrange;
 442
 443   ret = bfd_reloc_ok;
 444   if (bfd_is_und_section (symbol->section)
 445       && output_bfd == (bfd *) NULL)
 446     ret = bfd_reloc_undefined;
 447
 448   if (bfd_is_com_section (symbol->section))
 449     relocation = 0;
 450   else
 451     relocation = symbol->value;
 452
 453   relocation += symbol->section->output_section->vma;
 454   relocation += symbol->section->output_offset;
 455   relocation += reloc_entry->addend;
 456
 457   /* Save the information, and let LO16 do the actual relocation.  */
 458   n = (struct m32r_hi16 *) bfd_malloc ((bfd_size_type) sizeof *n);
 459   if (n == NULL)
 460     return bfd_reloc_outofrange;
 461   n->addr = (bfd_byte *) data + reloc_entry->address;
 462   n->addend = relocation;
 463   n->next = m32r_hi16_list;
 464   m32r_hi16_list = n;
 465
 466   if (output_bfd != (bfd *) NULL)
 467     reloc_entry->address += input_section->output_offset;
 468
 469   return ret;
 470 }
 471
 472 /* Handle an M32R ELF HI16 reloc.  */
 473
 474 static void
 475 m32r_elf_relocate_hi16 (input_bfd, type, relhi, rello, contents, addend)
 476      bfd *input_bfd;
 477      int type;
 478      Elf_Internal_Rela *relhi;
 479      Elf_Internal_Rela *rello;
 480      bfd_byte *contents;
 481      bfd_vma addend;
 482 {
 483   unsigned long insn;
 484   bfd_vma addlo;
 485
 486   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
 487
 488   addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
 489   if (type == R_M32R_HI16_SLO)
 490     addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
 491   else
 492     addlo &= 0xffff;
 493
 494   addend += ((insn & 0xffff) << 16) + addlo;
 495
 496   /* Reaccount for sign extension of low part.  */
 497   if (type == R_M32R_HI16_SLO
 498       && (addend & 0x8000) != 0)
 499     addend += 0x10000;
 500
 501   bfd_put_32 (input_bfd,
 502               (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
 503               contents + relhi->r_offset);
 504 }
 505
 506 /* Do an R_M32R_LO16 relocation.  This is a straightforward 16 bit
 507    inplace relocation; this function exists in order to do the
 508    R_M32R_HI16_[SU]LO relocation described above.  */
 509
 510 bfd_reloc_status_type
 511 m32r_elf_lo16_reloc (input_bfd, reloc_entry, symbol, data,
 512                      input_section, output_bfd, error_message)
 513      bfd *input_bfd;
 514      arelent *reloc_entry;
 515      asymbol *symbol;
 516      PTR data;
 517      asection *input_section;
 518      bfd *output_bfd;
 519      char **error_message;
 520 {
 521   /* This part is from bfd_elf_generic_reloc.
 522      If we're relocating, and this an external symbol, we don't want
 523      to change anything.  */
 524   if (output_bfd != (bfd *) NULL
 525       && (symbol->flags & BSF_SECTION_SYM) == 0
 526       && reloc_entry->addend == 0)
 527     {
 528       reloc_entry->address += input_section->output_offset;
 529       return bfd_reloc_ok;
 530     }
 531
 532   if (m32r_hi16_list != NULL)
 533     {
 534       struct m32r_hi16 *l;
 535
 536       l = m32r_hi16_list;
 537       while (l != NULL)
 538         {
 539           unsigned long insn;
 540           unsigned long val;
 541           unsigned long vallo;
 542           struct m32r_hi16 *next;
 543
 544           /* Do the HI16 relocation.  Note that we actually don't need
 545              to know anything about the LO16 itself, except where to
 546              find the low 16 bits of the addend needed by the LO16.  */
 547           insn = bfd_get_32 (input_bfd, l->addr);
 548           vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
 549                    & 0xffff) ^ 0x8000) - 0x8000;
 550           val = ((insn & 0xffff) << 16) + vallo;
 551           val += l->addend;
 552
 553           /* Reaccount for sign extension of low part.  */
 554           if ((val & 0x8000) != 0)
 555             val += 0x10000;
 556
 557           insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
 558           bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
 559
 560           next = l->next;
 561           free (l);
 562           l = next;
 563         }
 564
 565       m32r_hi16_list = NULL;
 566     }
 567
 568   /* Now do the LO16 reloc in the usual way.
 569      ??? It would be nice to call bfd_elf_generic_reloc here,
 570      but we have partial_inplace == TRUE.  bfd_elf_generic_reloc will
 571      pass the handling back to bfd_install_relocation which will install
 572      a section relative addend which is wrong.  */
 573   return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
 574                                 input_section, output_bfd, error_message);
 575 }
 576
 577 /* Do generic partial_inplace relocation.
 578    This is a local replacement for bfd_elf_generic_reloc.  */
 579
 580 bfd_reloc_status_type
 581 m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
 582                      input_section, output_bfd, error_message)
 583      bfd *input_bfd;
 584      arelent *reloc_entry;
 585      asymbol *symbol;
 586      PTR data;
 587      asection *input_section;
 588      bfd *output_bfd;
 589      char **error_message ATTRIBUTE_UNUSED;
 590 {
 591   bfd_reloc_status_type ret;
 592   bfd_vma relocation;
 593   bfd_byte *inplace_address;
 594
 595   /* This part is from bfd_elf_generic_reloc.
 596      If we're relocating, and this an external symbol, we don't want
 597      to change anything.  */
 598   if (output_bfd != (bfd *) NULL
 599       && (symbol->flags & BSF_SECTION_SYM) == 0
 600       && reloc_entry->addend == 0)
 601     {
 602       reloc_entry->address += input_section->output_offset;
 603       return bfd_reloc_ok;
 604     }
 605
 606   /* Now do the reloc in the usual way.
 607      ??? It would be nice to call bfd_elf_generic_reloc here,
 608      but we have partial_inplace == TRUE.  bfd_elf_generic_reloc will
 609      pass the handling back to bfd_install_relocation which will install
 610      a section relative addend which is wrong.  */
 611
 612   /* Sanity check the address (offset in section).  */
 613   if (reloc_entry->address > input_section->_cooked_size)
 614     return bfd_reloc_outofrange;
 615
 616   ret = bfd_reloc_ok;
 617   if (bfd_is_und_section (symbol->section)
 618       && output_bfd == (bfd *) NULL)
 619     ret = bfd_reloc_undefined;
 620
 621   if (bfd_is_com_section (symbol->section)
 622       || output_bfd != (bfd *) NULL)
 623     relocation = 0;
 624   else
 625     relocation = symbol->value;
 626
 627   /* Only do this for a final link.  */
 628   if (output_bfd == (bfd *) NULL)
 629     {
 630       relocation += symbol->section->output_section->vma;
 631       relocation += symbol->section->output_offset;
 632     }
 633
 634   relocation += reloc_entry->addend;
 635   inplace_address = (bfd_byte *) data + reloc_entry->address;
 636
 637 #define DOIT(x)                                         \
 638   x = ( (x & ~reloc_entry->howto->dst_mask) |           \
 639   (((x & reloc_entry->howto->src_mask) +  relocation) & \
 640   reloc_entry->howto->dst_mask))
 641
 642   switch (reloc_entry->howto->size)
 643     {
 644     case 1:
 645       {
 646         short x = bfd_get_16 (input_bfd, inplace_address);
 647         DOIT (x);
 648         bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
 649       }
 650       break;
 651     case 2:
 652       {
 653         unsigned long x = bfd_get_32 (input_bfd, inplace_address);
 654         DOIT (x);
 655         bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
 656       }
 657       break;
 658     default:
 659       BFD_ASSERT (0);
 660     }
 661
 662   if (output_bfd != (bfd *) NULL)
 663     reloc_entry->address += input_section->output_offset;
 664
 665   return ret;
 666 }
 667
 668 /* Handle the R_M32R_SDA16 reloc.
 669    This reloc is used to compute the address of objects in the small data area
 670    and to perform loads and stores from that area.
 671    The lower 16 bits are sign extended and added to the register specified
 672    in the instruction, which is assumed to point to _SDA_BASE_.  */
 673
 674 static bfd_reloc_status_type
 675 m32r_elf_sda16_reloc (abfd, reloc_entry, symbol, data,
 676                       input_section, output_bfd, error_message)
 677      bfd *abfd ATTRIBUTE_UNUSED;
 678      arelent *reloc_entry;
 679      asymbol *symbol;
 680      PTR data ATTRIBUTE_UNUSED;
 681      asection *input_section;
 682      bfd *output_bfd;
 683      char **error_message ATTRIBUTE_UNUSED;
 684 {
 685   /* This part is from bfd_elf_generic_reloc.  */
 686   if (output_bfd != (bfd *) NULL
 687       && (symbol->flags & BSF_SECTION_SYM) == 0
 688       && (! reloc_entry->howto->partial_inplace
 689           || reloc_entry->addend == 0))
 690     {
 691       reloc_entry->address += input_section->output_offset;
 692       return bfd_reloc_ok;
 693     }
 694
 695   if (output_bfd != NULL)
 696     {
 697       /* FIXME: See bfd_perform_relocation.  Is this right?  */
 698       return bfd_reloc_continue;
 699     }
 700
 701   /* FIXME: not sure what to do here yet.  But then again, the linker
 702      may never call us.  */
 703   abort ();
 704 }
 705 \f
 706 /* Map BFD reloc types to M32R ELF reloc types.  */
 707
 708 struct m32r_reloc_map
 709 {
 710   bfd_reloc_code_real_type bfd_reloc_val;
 711   unsigned char elf_reloc_val;
 712 };
 713
 714 static const struct m32r_reloc_map m32r_reloc_map[] =
 715 {
 716   { BFD_RELOC_NONE, R_M32R_NONE },
 717   { BFD_RELOC_16, R_M32R_16 },
 718   { BFD_RELOC_32, R_M32R_32 },
 719   { BFD_RELOC_M32R_24, R_M32R_24 },
 720   { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
 721   { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
 722   { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
 723   { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
 724   { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
 725   { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
 726   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
 727   { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
 728   { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
 729 };
 730
 731 static reloc_howto_type *
 732 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 733      bfd *abfd ATTRIBUTE_UNUSED;
 734      bfd_reloc_code_real_type code;
 735 {
 736   unsigned int i;
 737
 738   for (i = 0;
 739        i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
 740        i++)
 741     {
 742       if (m32r_reloc_map[i].bfd_reloc_val == code)
 743         return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
 744     }
 745
 746   return NULL;
 747 }
 748
 749 /* Set the howto pointer for an M32R ELF reloc.  */
 750
 751 static void
 752 m32r_info_to_howto_rel (abfd, cache_ptr, dst)
 753      bfd *abfd ATTRIBUTE_UNUSED;
 754      arelent *cache_ptr;
 755      Elf32_Internal_Rel *dst;
 756 {
 757   unsigned int r_type;
 758
 759   r_type = ELF32_R_TYPE (dst->r_info);
 760   BFD_ASSERT (r_type < (unsigned int) R_M32R_max);
 761   cache_ptr->howto = &m32r_elf_howto_table[r_type];
 762 }
 763 \f
 764 /* Given a BFD section, try to locate the corresponding ELF section
 765    index.  */
 766
 767 boolean
 768 _bfd_m32r_elf_section_from_bfd_section (abfd, sec, retval)
 769      bfd *abfd ATTRIBUTE_UNUSED;
 770      asection *sec;
 771      int *retval;
 772 {
 773   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
 774     {
 775       *retval = SHN_M32R_SCOMMON;
 776       return true;
 777     }
 778   return false;
 779 }
 780
 781 /* M32R ELF uses two common sections.  One is the usual one, and the other
 782    is for small objects.  All the small objects are kept together, and then
 783    referenced via one register, which yields faster assembler code.  It is
 784    up to the compiler to emit an instruction to load the register with
 785    _SDA_BASE.  This is what we use for the small common section.  This
 786    approach is copied from elf32-mips.c.  */
 787 static asection m32r_elf_scom_section;
 788 static asymbol m32r_elf_scom_symbol;
 789 static asymbol *m32r_elf_scom_symbol_ptr;
 790
 791 /* Handle the special M32R section numbers that a symbol may use.  */
 792
 793 void
 794 _bfd_m32r_elf_symbol_processing (abfd, asym)
 795      bfd *abfd ATTRIBUTE_UNUSED;
 796      asymbol *asym;
 797 {
 798   elf_symbol_type *elfsym;
 799
 800   elfsym = (elf_symbol_type *) asym;
 801
 802   switch (elfsym->internal_elf_sym.st_shndx)
 803     {
 804     case SHN_M32R_SCOMMON:
 805       if (m32r_elf_scom_section.name == NULL)
 806         {
 807           /* Initialize the small common section.  */
 808           m32r_elf_scom_section.name = ".scommon";
 809           m32r_elf_scom_section.flags = SEC_IS_COMMON;
 810           m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
 811           m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
 812           m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
 813           m32r_elf_scom_symbol.name = ".scommon";
 814           m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
 815           m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
 816           m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
 817         }
 818       asym->section = &m32r_elf_scom_section;
 819       asym->value = elfsym->internal_elf_sym.st_size;
 820       break;
 821     }
 822 }
 823
 824 /* Hook called by the linker routine which adds symbols from an object
 825    file.  We must handle the special M32R section numbers here.
 826    We also keep watching for whether we need to create the sdata special
 827    linker sections.  */
 828
 829 static boolean
 830 m32r_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
 831      bfd *abfd;
 832      struct bfd_link_info *info;
 833      const Elf_Internal_Sym *sym;
 834      const char **namep;
 835      flagword *flagsp ATTRIBUTE_UNUSED;
 836      asection **secp;
 837      bfd_vma *valp;
 838 {
 839   if (! info->relocateable
 840       && (*namep)[0] == '_' && (*namep)[1] == 'S'
 841       && strcmp (*namep, "_SDA_BASE_") == 0
 842       && info->hash->creator->flavour == bfd_target_elf_flavour)
 843     {
 844       /* This is simpler than using _bfd_elf_create_linker_section
 845          (our needs are simpler than ppc's needs).  Also
 846          _bfd_elf_create_linker_section currently has a bug where if a .sdata
 847          section already exists a new one is created that follows it which
 848          screws of _SDA_BASE_ address calcs because output_offset != 0.  */
 849       struct elf_link_hash_entry *h;
 850       asection *s = bfd_get_section_by_name (abfd, ".sdata");
 851
 852       /* The following code was cobbled from elf32-ppc.c and elflink.c.  */
 853
 854       if (s == NULL)
 855         {
 856           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 857                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 858
 859           s = bfd_make_section_anyway (abfd, ".sdata");
 860           if (s == NULL)
 861             return false;
 862           bfd_set_section_flags (abfd, s, flags);
 863           bfd_set_section_alignment (abfd, s, 2);
 864         }
 865
 866       h = (struct elf_link_hash_entry *)
 867         bfd_link_hash_lookup (info->hash, "_SDA_BASE_", false, false, false);
 868
 869       if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 870           && !(_bfd_generic_link_add_one_symbol (info,
 871                                                  abfd,
 872                                                  "_SDA_BASE_",
 873                                                  BSF_GLOBAL,
 874                                                  s,
 875                                                  (bfd_vma) 32768,
 876                                                  (const char *) NULL,
 877                                                  false,
 878                                                  get_elf_backend_data (abfd)->collect,
 879                                                  (struct bfd_link_hash_entry **) &h)))
 880         return false;
 881       h->type = STT_OBJECT;
 882     }
 883
 884   switch (sym->st_shndx)
 885     {
 886     case SHN_M32R_SCOMMON:
 887       *secp = bfd_make_section_old_way (abfd, ".scommon");
 888       (*secp)->flags |= SEC_IS_COMMON;
 889       *valp = sym->st_size;
 890       break;
 891     }
 892
 893   return true;
 894 }
 895
 896 /* We have to figure out the SDA_BASE value, so that we can adjust the
 897    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
 898    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
 899    target data.  We don't need to adjust the symbol value for an
 900    external symbol if we are producing relocateable output.  */
 901
 902 static bfd_reloc_status_type
 903 m32r_elf_final_sda_base (output_bfd, info, error_message, psb)
 904      bfd *output_bfd;
 905      struct bfd_link_info *info;
 906      const char **error_message;
 907      bfd_vma *psb;
 908 {
 909   if (elf_gp (output_bfd) == 0)
 910     {
 911       struct bfd_link_hash_entry *h;
 912
 913       h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", false, false, true);
 914       if (h != (struct bfd_link_hash_entry *) NULL
 915           && h->type == bfd_link_hash_defined)
 916         elf_gp (output_bfd) = (h->u.def.value
 917                                + h->u.def.section->output_section->vma
 918                                + h->u.def.section->output_offset);
 919       else
 920         {
 921           /* Only get the error once.  */
 922           *psb = elf_gp (output_bfd) = 4;
 923           *error_message =
 924             (const char *) _("SDA relocation when _SDA_BASE_ not defined");
 925           return bfd_reloc_dangerous;
 926         }
 927     }
 928   *psb = elf_gp (output_bfd);
 929   return bfd_reloc_ok;
 930 }
 931 \f
 932 /* Relocate an M32R/D ELF section.
 933    There is some attempt to make this function usable for many architectures,
 934    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 935    if only to serve as a learning tool.
 936
 937    The RELOCATE_SECTION function is called by the new ELF backend linker
 938    to handle the relocations for a section.
 939
 940    The relocs are always passed as Rela structures; if the section
 941    actually uses Rel structures, the r_addend field will always be
 942    zero.
 943
 944    This function is responsible for adjust the section contents as
 945    necessary, and (if using Rela relocs and generating a
 946    relocateable output file) adjusting the reloc addend as
 947    necessary.
 948
 949    This function does not have to worry about setting the reloc
 950    address or the reloc symbol index.
 951
 952    LOCAL_SYMS is a pointer to the swapped in local symbols.
 953
 954    LOCAL_SECTIONS is an array giving the section in the input file
 955    corresponding to the st_shndx field of each local symbol.
 956
 957    The global hash table entry for the global symbols can be found
 958    via elf_sym_hashes (input_bfd).
 959
 960    When generating relocateable output, this function must handle
 961    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 962    going to be the section symbol corresponding to the output
 963    section, which means that the addend must be adjusted
 964    accordingly.  */
 965
 966 static boolean
 967 m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 968                            contents, relocs, local_syms, local_sections)
 969      bfd *output_bfd ATTRIBUTE_UNUSED;
 970      struct bfd_link_info *info;
 971      bfd *input_bfd;
 972      asection *input_section;
 973      bfd_byte *contents;
 974      Elf_Internal_Rela *relocs;
 975      Elf_Internal_Sym *local_syms;
 976      asection **local_sections;
 977 {
 978   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 979   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 980   Elf_Internal_Rela *rel, *relend;
 981   /* Assume success.  */
 982   boolean ret = true;
 983
 984   rel = relocs;
 985   relend = relocs + input_section->reloc_count;
 986   for (; rel < relend; rel++)
 987     {
 988       int r_type;
 989       reloc_howto_type *howto;
 990       unsigned long r_symndx;
 991       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
 992          ensure it's zero (we use REL relocs, not RELA).  Therefore this
 993          should be assigning zero to `addend', but for clarity we use
 994          `r_addend'.  */
 995       bfd_vma addend = rel->r_addend;
 996       bfd_vma offset = rel->r_offset;
 997       struct elf_link_hash_entry *h;
 998       Elf_Internal_Sym *sym;
 999       asection *sec;
1000       const char *sym_name;
1001       bfd_reloc_status_type r;
1002       const char *errmsg = NULL;
1003
1004       h = NULL;
1005       r_type = ELF32_R_TYPE (rel->r_info);
1006       if (r_type < 0 || r_type >= (int) R_M32R_max)
1007         {
1008           (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
1009                                  bfd_archive_filename (input_bfd),
1010                                  (int) r_type);
1011           bfd_set_error (bfd_error_bad_value);
1012           ret = false;
1013           continue;
1014         }
1015
1016       if (r_type == R_M32R_GNU_VTENTRY
1017           || r_type == R_M32R_GNU_VTINHERIT)
1018         continue;
1019
1020       howto = m32r_elf_howto_table + r_type;
1021       r_symndx = ELF32_R_SYM (rel->r_info);
1022
1023       if (info->relocateable)
1024         {
1025           /* This is a relocateable link.  We don't have to change
1026              anything, unless the reloc is against a section symbol,
1027              in which case we have to adjust according to where the
1028              section symbol winds up in the output section.  */
1029           sec = NULL;
1030           if (r_symndx >= symtab_hdr->sh_info)
1031             {
1032               /* External symbol.  */
1033               continue;
1034             }
1035
1036           /* Local symbol.  */
1037           sym = local_syms + r_symndx;
1038           sym_name = "<local symbol>";
1039           /* STT_SECTION: symbol is associated with a section.  */
1040           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
1041             {
1042               /* Symbol isn't associated with a section.  Nothing to do.  */
1043               continue;
1044             }
1045
1046           sec = local_sections[r_symndx];
1047           addend += sec->output_offset + sym->st_value;
1048 #ifndef USE_REL
1049           /* This can't be done for USE_REL because it doesn't mean anything
1050              and elf_link_input_bfd asserts this stays zero.  */
1051           rel->r_addend = addend;
1052 #endif
1053
1054 #ifndef USE_REL
1055           /* Addends are stored with relocs.  We're done.  */
1056           continue;
1057 #else /* USE_REL */
1058           /* If partial_inplace, we need to store any additional addend
1059              back in the section.  */
1060           if (! howto->partial_inplace)
1061             continue;
1062           /* ??? Here is a nice place to call a special_function
1063              like handler.  */
1064           if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
1065             r = _bfd_relocate_contents (howto, input_bfd,
1066                                         addend, contents + offset);
1067           else
1068             {
1069               Elf_Internal_Rela *lorel;
1070
1071               /* We allow an arbitrary number of HI16 relocs before the
1072                  LO16 reloc.  This permits gcc to emit the HI and LO relocs
1073                  itself.  */
1074               for (lorel = rel + 1;
1075                    (lorel < relend
1076                     && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
1077                         || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
1078                    lorel++)
1079                 continue;
1080               if (lorel < relend
1081                   && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
1082                 {
1083                   m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
1084                                           contents, addend);
1085                   r = bfd_reloc_ok;
1086                 }
1087               else
1088                 r = _bfd_relocate_contents (howto, input_bfd,
1089                                             addend, contents + offset);
1090             }
1091 #endif /* USE_REL */
1092         }
1093       else
1094         {
1095           bfd_vma relocation;
1096
1097           /* This is a final link.  */
1098           sym = NULL;
1099           sec = NULL;
1100
1101           if (r_symndx < symtab_hdr->sh_info)
1102             {
1103               /* Local symbol.  */
1104               sym = local_syms + r_symndx;
1105               sec = local_sections[r_symndx];
1106               sym_name = "<local symbol>";
1107 #ifndef USE_REL
1108               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1109               addend = rel->r_addend;
1110 #else
1111               /* FIXME: This won't handle local relocations against SEC_MERGE
1112                  symbols.  See elf32-i386.c for how to do this.  */
1113               relocation = (sec->output_section->vma
1114                             + sec->output_offset
1115                             + sym->st_value);
1116 #endif
1117             }
1118           else
1119             {
1120               /* External symbol.  */
1121               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1122               while (h->root.type == bfd_link_hash_indirect
1123                      || h->root.type == bfd_link_hash_warning)
1124                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1125               sym_name = h->root.root.string;
1126
1127               if (h->root.type == bfd_link_hash_defined
1128                   || h->root.type == bfd_link_hash_defweak)
1129                 {
1130                   sec = h->root.u.def.section;
1131                   if (sec->output_section == NULL)
1132                     relocation = 0;
1133                   else
1134                     relocation = (h->root.u.def.value
1135                                   + sec->output_section->vma
1136                                   + sec->output_offset);
1137                 }
1138               else if (h->root.type == bfd_link_hash_undefweak)
1139                 relocation = 0;
1140               else
1141                 {
1142                   if (! ((*info->callbacks->undefined_symbol)
1143                          (info, h->root.root.string, input_bfd,
1144                           input_section, offset, true)))
1145                     return false;
1146                   relocation = 0;
1147                 }
1148             }
1149
1150           /* Sanity check the address.  */
1151           if (offset > input_section->_raw_size)
1152             {
1153               r = bfd_reloc_outofrange;
1154               goto check_reloc;
1155             }
1156
1157           switch ((int) r_type)
1158             {
1159             case (int) R_M32R_10_PCREL :
1160               r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
1161                                               contents, offset,
1162                                               sec, relocation, addend);
1163               break;
1164
1165             case (int) R_M32R_HI16_SLO :
1166             case (int) R_M32R_HI16_ULO :
1167               {
1168                 Elf_Internal_Rela *lorel;
1169
1170                 /* We allow an arbitrary number of HI16 relocs before the
1171                    LO16 reloc.  This permits gcc to emit the HI and LO relocs
1172                    itself.  */
1173                 for (lorel = rel + 1;
1174                      (lorel < relend
1175                       && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
1176                           || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
1177                      lorel++)
1178                   continue;
1179                 if (lorel < relend
1180                     && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
1181                   {
1182                     m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
1183                                             contents, relocation + addend);
1184                     r = bfd_reloc_ok;
1185                   }
1186                 else
1187                   r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1188                                                 contents, offset,
1189                                                 relocation, addend);
1190               }
1191               break;
1192
1193             case (int) R_M32R_SDA16 :
1194               {
1195                 const char *name;
1196
1197                 BFD_ASSERT (sec != NULL);
1198                 name = bfd_get_section_name (abfd, sec);
1199
1200                 if (strcmp (name, ".sdata") == 0
1201                     || strcmp (name, ".sbss") == 0
1202                     || strcmp (name, ".scommon") == 0)
1203                   {
1204                     bfd_vma sda_base;
1205                     bfd *out_bfd = sec->output_section->owner;
1206
1207                     r = m32r_elf_final_sda_base (out_bfd, info,
1208                                                  &errmsg,
1209                                                  &sda_base);
1210                     if (r != bfd_reloc_ok)
1211                       {
1212                         ret = false;
1213                         goto check_reloc;
1214                       }
1215
1216                     /* At this point `relocation' contains the object's
1217                        address.  */
1218                     relocation -= sda_base;
1219                     /* Now it contains the offset from _SDA_BASE_.  */
1220                   }
1221                 else
1222                   {
1223                     (*_bfd_error_handler)
1224                       (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
1225                        bfd_archive_filename (input_bfd),
1226                        sym_name,
1227                        m32r_elf_howto_table[(int) r_type].name,
1228                        bfd_get_section_name (abfd, sec));
1229                     /*bfd_set_error (bfd_error_bad_value); ??? why? */
1230                     ret = false;
1231                     continue;
1232                   }
1233               }
1234               /* fall through */
1235
1236             default :
1237               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1238                                             contents, offset,
1239                                             relocation, addend);
1240               break;
1241             }
1242         }
1243
1244     check_reloc:
1245
1246       if (r != bfd_reloc_ok)
1247         {
1248           /* FIXME: This should be generic enough to go in a utility.  */
1249           const char *name;
1250
1251           if (h != NULL)
1252             name = h->root.root.string;
1253           else
1254             {
1255               name = (bfd_elf_string_from_elf_section
1256                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1257               if (name == NULL || *name == '\0')
1258                 name = bfd_section_name (input_bfd, sec);
1259             }
1260
1261           if (errmsg != NULL)
1262             goto common_error;
1263
1264           switch (r)
1265             {
1266             case bfd_reloc_overflow:
1267               if (! ((*info->callbacks->reloc_overflow)
1268                      (info, name, howto->name, (bfd_vma) 0,
1269                       input_bfd, input_section, offset)))
1270                 return false;
1271               break;
1272
1273             case bfd_reloc_undefined:
1274               if (! ((*info->callbacks->undefined_symbol)
1275                      (info, name, input_bfd, input_section,
1276                       offset, true)))
1277                 return false;
1278               break;
1279
1280             case bfd_reloc_outofrange:
1281               errmsg = _("internal error: out of range error");
1282               goto common_error;
1283
1284             case bfd_reloc_notsupported:
1285               errmsg = _("internal error: unsupported relocation error");
1286               goto common_error;
1287
1288             case bfd_reloc_dangerous:
1289               errmsg = _("internal error: dangerous error");
1290               goto common_error;
1291
1292             default:
1293               errmsg = _("internal error: unknown error");
1294               /* fall through */
1295
1296             common_error:
1297               if (!((*info->callbacks->warning)
1298                     (info, errmsg, name, input_bfd, input_section,
1299                      offset)))
1300                 return false;
1301               break;
1302             }
1303         }
1304     }
1305
1306   return ret;
1307 }
1308 \f
1309 #if 0 /* relaxing not supported yet */
1310
1311 /* This function handles relaxing for the m32r.
1312    Relaxing on the m32r is tricky because of instruction alignment
1313    requirements (4 byte instructions must be aligned on 4 byte boundaries).
1314
1315    The following relaxing opportunities are handled:
1316
1317    seth/add3/jl -> bl24 or bl8
1318    seth/add3 -> ld24
1319
1320    It would be nice to handle bl24 -> bl8 but given:
1321
1322    - 4 byte insns must be on 4 byte boundaries
1323    - branch instructions only branch to insns on 4 byte boundaries
1324
1325    this isn't much of a win because the insn in the 2 "deleted" bytes
1326    must become a nop.  With some complexity some real relaxation could be
1327    done but the frequency just wouldn't make it worth it; it's better to
1328    try to do all the code compaction one can elsewhere.
1329    When the chip supports parallel 16 bit insns, things may change.
1330 */
1331
1332 static boolean
1333 m32r_elf_relax_section (abfd, sec, link_info, again)
1334      bfd *abfd;
1335      asection *sec;
1336      struct bfd_link_info *link_info;
1337      boolean *again;
1338 {
1339   Elf_Internal_Shdr *symtab_hdr;
1340   /* The Rela structures are used here because that's what
1341      _bfd_elf32_link_read_relocs uses [for convenience - it sets the addend
1342      field to 0].  */
1343   Elf_Internal_Rela *internal_relocs;
1344   Elf_Internal_Rela *free_relocs = NULL;
1345   Elf_Internal_Rela *irel, *irelend;
1346   bfd_byte *contents = NULL;
1347   bfd_byte *free_contents = NULL;
1348   Elf32_External_Sym *extsyms = NULL;
1349   Elf32_External_Sym *free_extsyms = NULL;
1350
1351   /* Assume nothing changes.  */
1352   *again = false;
1353
1354   /* We don't have to do anything for a relocateable link, if
1355      this section does not have relocs, or if this is not a
1356      code section.  */
1357   if (link_info->relocateable
1358       || (sec->flags & SEC_RELOC) == 0
1359       || sec->reloc_count == 0
1360       || (sec->flags & SEC_CODE) == 0
1361       || 0 /* FIXME: check SHF_M32R_CAN_RELAX */)
1362     return true;
1363
1364   /* If this is the first time we have been called for this section,
1365      initialize the cooked size.  */
1366   if (sec->_cooked_size == 0)
1367     sec->_cooked_size = sec->_raw_size;
1368
1369   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1370
1371   /* Get a copy of the native relocations.  */
1372   internal_relocs = (_bfd_elf32_link_read_relocs
1373                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1374                       link_info->keep_memory));
1375   if (internal_relocs == NULL)
1376     goto error_return;
1377   if (! link_info->keep_memory)
1378     free_relocs = internal_relocs;
1379
1380   /* Walk through them looking for relaxing opportunities.  */
1381   irelend = internal_relocs + sec->reloc_count;
1382   for (irel = internal_relocs; irel < irelend; irel++)
1383     {
1384       bfd_vma symval;
1385
1386       /* If this isn't something that can be relaxed, then ignore
1387          this reloc.  */
1388       if (ELF32_R_TYPE (irel->r_info) != (int) R_M32R_HI16_SLO)
1389         continue;
1390
1391       /* Get the section contents if we haven't done so already.  */
1392       if (contents == NULL)
1393         {
1394           /* Get cached copy if it exists.  */
1395           if (elf_section_data (sec)->this_hdr.contents != NULL)
1396             contents = elf_section_data (sec)->this_hdr.contents;
1397           else
1398             {
1399               /* Go get them off disk.  */
1400               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1401               if (contents == NULL)
1402                 goto error_return;
1403               free_contents = contents;
1404
1405               if (! bfd_get_section_contents (abfd, sec, contents,
1406                                               (file_ptr) 0, sec->_raw_size))
1407                 goto error_return;
1408             }
1409         }
1410
1411       /* Read this BFD's symbols if we haven't done so already.  */
1412       if (extsyms == NULL)
1413         {
1414           /* Get cached copy if it exists.  */
1415           if (symtab_hdr->contents != NULL)
1416             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1417           else
1418             {
1419               bfd_size_type amt = symtab_hdr->sh_size;
1420               /* Go get them off disk.  */
1421               extsyms = (Elf32_External_Sym *) bfd_malloc (amt);
1422               if (extsyms == NULL)
1423                 goto error_return;
1424               free_extsyms = extsyms;
1425               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1426                   || bfd_bread (extsyms, amt, abfd) != amt)
1427                 goto error_return;
1428             }
1429         }
1430
1431       /* Get the value of the symbol referred to by the reloc.  */
1432       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1433         {
1434           Elf_Internal_Sym isym;
1435           asection *sym_sec;
1436
1437           /* A local symbol.  */
1438           bfd_elf32_swap_symbol_in (abfd,
1439                                     extsyms + ELF32_R_SYM (irel->r_info),
1440                                     &isym);
1441
1442           sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1443           symval = (isym.st_value
1444                     + sym_sec->output_section->vma
1445                     + sym_sec->output_offset);
1446         }
1447       else
1448         {
1449           unsigned long indx;
1450           struct elf_link_hash_entry *h;
1451
1452           /* An external symbol.  */
1453           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1454           h = elf_sym_hashes (abfd)[indx];
1455           BFD_ASSERT (h != NULL);
1456           if (h->root.type != bfd_link_hash_defined
1457               && h->root.type != bfd_link_hash_defweak)
1458             {
1459               /* This appears to be a reference to an undefined
1460                  symbol.  Just ignore it--it will be caught by the
1461                  regular reloc processing.  */
1462               continue;
1463             }
1464
1465           symval = (h->root.u.def.value
1466                     + h->root.u.def.section->output_section->vma
1467                     + h->root.u.def.section->output_offset);
1468         }
1469
1470       /* For simplicity of coding, we are going to modify the section
1471          contents, the section relocs, and the BFD symbol table.  We
1472          must tell the rest of the code not to free up this
1473          information.  It would be possible to instead create a table
1474          of changes which have to be made, as is done in coff-mips.c;
1475          that would be more work, but would require less memory when
1476          the linker is run.  */
1477
1478       /* Try to change a seth/add3/jl subroutine call to bl24 or bl8.
1479          This sequence is generated by the compiler when compiling in
1480          32 bit mode.  Also look for seth/add3 -> ld24.  */
1481
1482       if (ELF32_R_TYPE (irel->r_info) == (int) R_M32R_HI16_SLO)
1483         {
1484           Elf_Internal_Rela *nrel;
1485           bfd_vma pc = (sec->output_section->vma + sec->output_offset
1486                         + irel->r_offset);
1487           bfd_signed_vma pcrel_value = symval - pc;
1488           unsigned int code,reg;
1489           int addend,nop_p,bl8_p,to_delete;
1490
1491           /* The tests are ordered so that we get out as quickly as possible
1492              if this isn't something we can relax, taking into account that
1493              we are looking for two separate possibilities (jl/ld24).  */
1494
1495           /* Do nothing if no room in the section for this to be what we're
1496              looking for.  */
1497           if (irel->r_offset > sec->_cooked_size - 8)
1498             continue;
1499
1500           /* Make sure the next relocation applies to the next
1501              instruction and that it's the add3's reloc.  */
1502           nrel = irel + 1;
1503           if (nrel == irelend
1504               || irel->r_offset + 4 != nrel->r_offset
1505               || ELF32_R_TYPE (nrel->r_info) != (int) R_M32R_LO16)
1506             continue;
1507
1508           /* See if the instructions are seth/add3.  */
1509           /* FIXME: This is where macros from cgen can come in.  */
1510           code = bfd_get_16 (abfd, contents + irel->r_offset + 0);
1511           if ((code & 0xf0ff) != 0xd0c0)
1512             continue; /* not seth rN,foo */
1513           reg = (code & 0x0f00) >> 8;
1514           code = bfd_get_16 (abfd, contents + irel->r_offset + 4);
1515           if (code != (0x80a0 | reg | (reg << 8)))
1516             continue; /* not add3 rN,rN,foo */
1517
1518           /* At this point we've confirmed we have seth/add3.  Now check
1519              whether the next insn is a jl, in which case try to change this
1520              to bl24 or bl8.  */
1521
1522           /* Ensure the branch target is in range.
1523              The bl24 instruction has a 24 bit operand which is the target
1524              address right shifted by 2, giving a signed range of 26 bits.
1525              Note that 4 bytes are added to the high value because the target
1526              will be at least 4 bytes closer if we can relax.  It'll actually
1527              be 4 or 8 bytes closer, but we don't know which just yet and
1528              the difference isn't significant enough to worry about.  */
1529 #ifndef USE_REL /* put in for learning purposes */
1530           pcrel_value += irel->r_addend;
1531 #else
1532           addend = bfd_get_signed_16 (abfd, contents + irel->r_offset + 2);
1533           pcrel_value += addend;
1534 #endif
1535
1536           if (pcrel_value >= -(1 << 25) && pcrel_value < (1 << 25) + 4
1537               /* Do nothing if no room in the section for this to be what we're
1538                  looking for.  */
1539               && (irel->r_offset <= sec->_cooked_size - 12)
1540               /* Ensure the next insn is "jl rN".  */
1541               && ((code = bfd_get_16 (abfd, contents + irel->r_offset + 8)),
1542                   code != (0x1ec0 | reg)))
1543             {
1544               /* We can relax to bl24/bl8.  */
1545
1546               /* See if there's a nop following the jl.
1547                  Also see if we can use a bl8 insn.  */
1548               code = bfd_get_16 (abfd, contents + irel->r_offset + 10);
1549               nop_p = (code & 0x7fff) == NOP_INSN;
1550               bl8_p = pcrel_value >= -0x200 && pcrel_value < 0x200;
1551
1552               if (bl8_p)
1553                 {
1554                   /* Change "seth rN,foo" to "bl8 foo || nop".
1555                      We OR in CODE just in case it's not a nop (technically,
1556                      CODE currently must be a nop, but for cleanness we
1557                      allow it to be anything).  */
1558 #ifndef USE_REL /* put in for learning purposes */
1559                   code = 0x7e000000 | MAKE_PARALLEL (code);
1560 #else
1561                   code = (0x7e000000 + (((addend >> 2) & 0xff) << 16)) | MAKE_PARALLEL (code);
1562 #endif
1563                   to_delete = 8;
1564                 }
1565               else
1566                 {
1567                   /* Change the seth rN,foo to a bl24 foo.  */
1568 #ifndef USE_REL /* put in for learning purposes */
1569                   code = 0xfe000000;
1570 #else
1571                   code = 0xfe000000 + ((addend >> 2) & 0xffffff);
1572 #endif
1573                   to_delete = nop_p ? 8 : 4;
1574                 }
1575
1576               bfd_put_32 (abfd, code, contents + irel->r_offset);
1577
1578               /* Set the new reloc type.  */
1579               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1580                                            bl8_p ? R_M32R_10_PCREL : R_M32R_26_PCREL);
1581
1582               /* Delete the add3 reloc by making it a null reloc.  */
1583               nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1584                                            R_M32R_NONE);
1585             }
1586           else if (addend >= 0
1587                    && symval + addend <= 0xffffff)
1588             {
1589               /* We can relax to ld24.  */
1590
1591               code = 0xe0000000 | (reg << 24) | (addend & 0xffffff);
1592               bfd_put_32 (abfd, code, contents + irel->r_offset);
1593               to_delete = 4;
1594               /* Tell the following code a nop filler isn't needed.  */
1595               nop_p = 1;
1596             }
1597           else
1598             {
1599               /* Can't do anything here.  */
1600               continue;
1601             }
1602
1603           /* Note that we've changed the relocs, section contents, etc.  */
1604           elf_section_data (sec)->relocs = internal_relocs;
1605           free_relocs = NULL;
1606
1607           elf_section_data (sec)->this_hdr.contents = contents;
1608           free_contents = NULL;
1609
1610           symtab_hdr->contents = (bfd_byte *) extsyms;
1611           free_extsyms = NULL;
1612
1613           /* Delete TO_DELETE bytes of data.  */
1614           if (!m32r_elf_relax_delete_bytes (abfd, sec,
1615                                             irel->r_offset + 4, to_delete))
1616             goto error_return;
1617
1618           /* Now that the following bytes have been moved into place, see if
1619              we need to replace the jl with a nop.  This happens when we had
1620              to use a bl24 insn and the insn following the jl isn't a nop.
1621              Technically, this situation can't happen (since the insn can
1622              never be executed) but to be clean we do this.  When the chip
1623              supports parallel 16 bit insns things may change.
1624              We don't need to do this in the case of relaxing to ld24,
1625              and the above code sets nop_p so this isn't done.  */
1626           if (! nop_p && to_delete == 4)
1627             bfd_put_16 (abfd, NOP_INSN, contents + irel->r_offset + 4);
1628
1629           /* That will change things, so we should relax again.
1630              Note that this is not required, and it may be slow.  */
1631           *again = true;
1632
1633           continue;
1634         }
1635
1636       /* loop to try the next reloc */
1637     }
1638
1639   if (free_relocs != NULL)
1640     {
1641       free (free_relocs);
1642       free_relocs = NULL;
1643     }
1644
1645   if (free_contents != NULL)
1646     {
1647       if (! link_info->keep_memory)
1648         free (free_contents);
1649       else
1650         {
1651           /* Cache the section contents for elf_link_input_bfd.  */
1652           elf_section_data (sec)->this_hdr.contents = contents;
1653         }
1654       free_contents = NULL;
1655     }
1656
1657   if (free_extsyms != NULL)
1658     {
1659       if (! link_info->keep_memory)
1660         free (free_extsyms);
1661       else
1662         {
1663           /* Cache the symbols for elf_link_input_bfd.  */
1664           symtab_hdr->contents = extsyms;
1665         }
1666       free_extsyms = NULL;
1667     }
1668
1669   return true;
1670
1671  error_return:
1672   if (free_relocs != NULL)
1673     free (free_relocs);
1674   if (free_contents != NULL)
1675     free (free_contents);
1676   if (free_extsyms != NULL)
1677     free (free_extsyms);
1678   return false;
1679 }
1680
1681 /* Delete some bytes from a section while relaxing.  */
1682
1683 static boolean
1684 m32r_elf_relax_delete_bytes (abfd, sec, addr, count)
1685      bfd *abfd;
1686      asection *sec;
1687      bfd_vma addr;
1688      int count;
1689 {
1690   Elf_Internal_Shdr *symtab_hdr;
1691   Elf32_External_Sym *extsyms;
1692   int shndx, index;
1693   bfd_byte *contents;
1694   Elf_Internal_Rela *irel, *irelend;
1695   Elf_Internal_Rela *irelalign;
1696   bfd_vma toaddr;
1697   Elf32_External_Sym *esym, *esymend;
1698   struct elf_link_hash_entry *sym_hash;
1699
1700   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1701   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1702
1703   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1704
1705   contents = elf_section_data (sec)->this_hdr.contents;
1706
1707   /* The deletion must stop at the next ALIGN reloc for an aligment
1708      power larger than the number of bytes we are deleting.  */
1709
1710   irelalign = NULL;
1711   toaddr = sec->_cooked_size;
1712
1713   irel = elf_section_data (sec)->relocs;
1714   irelend = irel + sec->reloc_count;
1715
1716   /* Actually delete the bytes.  */
1717   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1718   sec->_cooked_size -= count;
1719
1720   /* Adjust all the relocs.  */
1721   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1722     {
1723       /* Get the new reloc address.  */
1724       if ((irel->r_offset > addr
1725            && irel->r_offset < toaddr))
1726         irel->r_offset -= count;
1727     }
1728
1729   /* Adjust the local symbols defined in this section.  */
1730   esym = extsyms;
1731   esymend = esym + symtab_hdr->sh_info;
1732   for (; esym < esymend; esym++)
1733     {
1734       Elf_Internal_Sym isym;
1735
1736       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1737
1738       if (isym.st_shndx == shndx
1739           && isym.st_value > addr
1740           && isym.st_value < toaddr)
1741         {
1742           isym.st_value -= count;
1743           bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1744         }
1745     }
1746
1747   /* Now adjust the global symbols defined in this section.  */
1748   esym = extsyms + symtab_hdr->sh_info;
1749   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1750   for (index = 0; esym < esymend; esym++, index++)
1751     {
1752       Elf_Internal_Sym isym;
1753
1754       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1755       sym_hash = elf_sym_hashes (abfd)[index];
1756       if (isym.st_shndx == shndx
1757           && ((sym_hash)->root.type == bfd_link_hash_defined
1758               || (sym_hash)->root.type == bfd_link_hash_defweak)
1759           && (sym_hash)->root.u.def.section == sec
1760           && (sym_hash)->root.u.def.value > addr
1761           && (sym_hash)->root.u.def.value < toaddr)
1762         {
1763           (sym_hash)->root.u.def.value -= count;
1764         }
1765     }
1766
1767   return true;
1768 }
1769
1770 /* This is a version of bfd_generic_get_relocated_section_contents
1771    which uses m32r_elf_relocate_section.  */
1772
1773 static bfd_byte *
1774 m32r_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1775                                          data, relocateable, symbols)
1776      bfd *output_bfd;
1777      struct bfd_link_info *link_info;
1778      struct bfd_link_order *link_order;
1779      bfd_byte *data;
1780      boolean relocateable;
1781      asymbol **symbols;
1782 {
1783   Elf_Internal_Shdr *symtab_hdr;
1784   asection *input_section = link_order->u.indirect.section;
1785   bfd *input_bfd = input_section->owner;
1786   asection **sections = NULL;
1787   Elf_Internal_Rela *internal_relocs = NULL;
1788   Elf32_External_Sym *external_syms = NULL;
1789   Elf_Internal_Sym *internal_syms = NULL;
1790   bfd_size_type amt;
1791
1792   /* We only need to handle the case of relaxing, or of having a
1793      particular set of section contents, specially.  */
1794   if (relocateable
1795       || elf_section_data (input_section)->this_hdr.contents == NULL)
1796     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1797                                                        link_order, data,
1798                                                        relocateable,
1799                                                        symbols);
1800
1801   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1802
1803   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1804           input_section->_raw_size);
1805
1806   if ((input_section->flags & SEC_RELOC) != 0
1807       && input_section->reloc_count > 0)
1808     {
1809       Elf_Internal_Sym *isymp;
1810       asection **secpp;
1811       Elf32_External_Sym *esym, *esymend;
1812
1813       if (symtab_hdr->contents != NULL)
1814         external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1815       else
1816         {
1817           amt = symtab_hdr->sh_info;
1818           amt *= sizeof (Elf32_External_Sym);
1819           external_syms = (Elf32_External_Sym *) bfd_malloc (amt);
1820           if (external_syms == NULL && symtab_hdr->sh_info > 0)
1821             goto error_return;
1822           if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1823               || bfd_bread (external_syms, amt, input_bfd) != amt)
1824             goto error_return;
1825         }
1826
1827       internal_relocs = (_bfd_elf32_link_read_relocs
1828                          (input_bfd, input_section, (PTR) NULL,
1829                           (Elf_Internal_Rela *) NULL, false));
1830       if (internal_relocs == NULL)
1831         goto error_return;
1832
1833       amt = symtab_hdr->sh_info;
1834       amt *= sizeof (Elf_Internal_Sym);
1835       internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
1836       if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1837         goto error_return;
1838
1839       amt = symtab_hdr->sh_info;
1840       amt *= sizeof (asection *);
1841       sections = (asection **) bfd_malloc (amt);
1842       if (sections == NULL && symtab_hdr->sh_info > 0)
1843         goto error_return;
1844
1845       isymp = internal_syms;
1846       secpp = sections;
1847       esym = external_syms;
1848       esymend = esym + symtab_hdr->sh_info;
1849       for (; esym < esymend; ++esym, ++isymp, ++secpp)
1850         {
1851           asection *isec;
1852
1853           bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1854
1855           if (isymp->st_shndx == SHN_UNDEF)
1856             isec = bfd_und_section_ptr;
1857           else if (isymp->st_shndx == SHN_ABS)
1858             isec = bfd_abs_section_ptr;
1859           else if (isymp->st_shndx == SHN_COMMON)
1860             isec = bfd_com_section_ptr;
1861           else if (isymp->st_shndx == SHN_M32R_SCOMMON)
1862             isec = &m32r_elf_scom_section;
1863           else
1864             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1865
1866           *secpp = isec;
1867         }
1868
1869       if (! m32r_elf_relocate_section (output_bfd, link_info, input_bfd,
1870                                        input_section, data, internal_relocs,
1871                                        internal_syms, sections))
1872         goto error_return;
1873
1874       if (sections != NULL)
1875         free (sections);
1876       sections = NULL;
1877       if (internal_syms != NULL)
1878         free (internal_syms);
1879       internal_syms = NULL;
1880       if (external_syms != NULL && symtab_hdr->contents == NULL)
1881         free (external_syms);
1882       external_syms = NULL;
1883       if (internal_relocs != elf_section_data (input_section)->relocs)
1884         free (internal_relocs);
1885       internal_relocs = NULL;
1886     }
1887
1888   return data;
1889
1890  error_return:
1891   if (internal_relocs != NULL
1892       && internal_relocs != elf_section_data (input_section)->relocs)
1893     free (internal_relocs);
1894   if (external_syms != NULL && symtab_hdr->contents == NULL)
1895     free (external_syms);
1896   if (internal_syms != NULL)
1897     free (internal_syms);
1898   if (sections != NULL)
1899     free (sections);
1900   return NULL;
1901 }
1902
1903 #endif /* #if 0 */
1904 \f
1905 /* Set the right machine number.  */
1906 static boolean
1907 m32r_elf_object_p (abfd)
1908      bfd *abfd;
1909 {
1910   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
1911     {
1912     default:
1913     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
1914     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
1915     }
1916   return true;
1917 }
1918
1919 /* Store the machine number in the flags field.  */
1920 static void
1921 m32r_elf_final_write_processing (abfd, linker)
1922      bfd *   abfd;
1923      boolean linker ATTRIBUTE_UNUSED;
1924 {
1925   unsigned long val;
1926
1927   switch (bfd_get_mach (abfd))
1928     {
1929     default:
1930     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
1931     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
1932     }
1933
1934   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
1935   elf_elfheader (abfd)->e_flags |= val;
1936 }
1937
1938 /* Function to keep M32R specific file flags.  */
1939 static boolean
1940 m32r_elf_set_private_flags (abfd, flags)
1941      bfd *    abfd;
1942      flagword flags;
1943 {
1944   BFD_ASSERT (!elf_flags_init (abfd)
1945               || elf_elfheader (abfd)->e_flags == flags);
1946
1947   elf_elfheader (abfd)->e_flags = flags;
1948   elf_flags_init (abfd) = true;
1949   return true;
1950 }
1951
1952 /* Merge backend specific data from an object file to the output
1953    object file when linking.  */
1954 static boolean
1955 m32r_elf_merge_private_bfd_data (ibfd, obfd)
1956      bfd * ibfd;
1957      bfd * obfd;
1958 {
1959   flagword out_flags;
1960   flagword in_flags;
1961
1962   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1963       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1964     return true;
1965
1966   in_flags  = elf_elfheader (ibfd)->e_flags;
1967   out_flags = elf_elfheader (obfd)->e_flags;
1968
1969   if (! elf_flags_init (obfd))
1970     {
1971       /* If the input is the default architecture then do not
1972          bother setting the flags for the output architecture,
1973          instead allow future merges to do this.  If no future
1974          merges ever set these flags then they will retain their
1975          unitialised values, which surprise surprise, correspond
1976          to the default values.  */
1977       if (bfd_get_arch_info (ibfd)->the_default)
1978         return true;
1979
1980       elf_flags_init (obfd) = true;
1981       elf_elfheader (obfd)->e_flags = in_flags;
1982
1983       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1984           && bfd_get_arch_info (obfd)->the_default)
1985         {
1986           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1987         }
1988
1989       return true;
1990     }
1991
1992   /* Check flag compatibility.  */
1993   if (in_flags == out_flags)
1994     return true;
1995
1996   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
1997     {
1998       if ((in_flags & EF_M32R_ARCH) != E_M32R_ARCH)
1999         {
2000           (*_bfd_error_handler)
2001             (_("%s: Instruction set mismatch with previous modules"),
2002              bfd_archive_filename (ibfd));
2003
2004           bfd_set_error (bfd_error_bad_value);
2005           return false;
2006         }
2007     }
2008
2009   return true;
2010 }
2011
2012 /* Display the flags field */
2013 static boolean
2014 m32r_elf_print_private_bfd_data (abfd, ptr)
2015      bfd *   abfd;
2016      PTR     ptr;
2017 {
2018   FILE * file = (FILE *) ptr;
2019
2020   BFD_ASSERT (abfd != NULL && ptr != NULL)
2021
2022   _bfd_elf_print_private_bfd_data (abfd, ptr);
2023
2024   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
2025
2026   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
2027     {
2028     default:
2029     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
2030     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
2031     }
2032
2033   fputc ('\n', file);
2034
2035   return true;
2036 }
2037
2038 asection *
2039 m32r_elf_gc_mark_hook (abfd, info, rel, h, sym)
2040        bfd *abfd;
2041        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2042        Elf_Internal_Rela *rel;
2043        struct elf_link_hash_entry *h;
2044        Elf_Internal_Sym *sym;
2045 {
2046   if (h != NULL)
2047     {
2048       switch (ELF32_R_TYPE (rel->r_info))
2049       {
2050       case R_M32R_GNU_VTINHERIT:
2051       case R_M32R_GNU_VTENTRY:
2052         break;
2053
2054       default:
2055         switch (h->root.type)
2056           {
2057           case bfd_link_hash_defined:
2058           case bfd_link_hash_defweak:
2059             return h->root.u.def.section;
2060
2061           case bfd_link_hash_common:
2062             return h->root.u.c.p->section;
2063
2064           default:
2065             break;
2066           }
2067        }
2068      }
2069    else
2070      {
2071        return bfd_section_from_elf_index (abfd, sym->st_shndx);
2072      }
2073   return NULL;
2074 }
2075
2076 static boolean
2077 m32r_elf_gc_sweep_hook (abfd, info, sec, relocs)
2078      bfd *abfd ATTRIBUTE_UNUSED;
2079      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2080      asection *sec ATTRIBUTE_UNUSED;
2081      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2082 {
2083   /* we don't use got and plt entries for m32r */
2084   return true;
2085 }
2086
2087 /* Look through the relocs for a section during the first phase.
2088    Since we don't do .gots or .plts, we just need to consider the
2089    virtual table relocs for gc.  */
2090
2091 static boolean
2092 m32r_elf_check_relocs (abfd, info, sec, relocs)
2093      bfd *abfd;
2094      struct bfd_link_info *info;
2095      asection *sec;
2096      const Elf_Internal_Rela *relocs;
2097 {
2098   Elf_Internal_Shdr *symtab_hdr;
2099   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2100   const Elf_Internal_Rela *rel;
2101   const Elf_Internal_Rela *rel_end;
2102
2103   if (info->relocateable)
2104     return true;
2105
2106   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2107   sym_hashes = elf_sym_hashes (abfd);
2108   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2109   if (!elf_bad_symtab (abfd))
2110     sym_hashes_end -= symtab_hdr->sh_info;
2111
2112   rel_end = relocs + sec->reloc_count;
2113   for (rel = relocs; rel < rel_end; rel++)
2114     {
2115       struct elf_link_hash_entry *h;
2116       unsigned long r_symndx;
2117
2118       r_symndx = ELF32_R_SYM (rel->r_info);
2119       if (r_symndx < symtab_hdr->sh_info)
2120         h = NULL;
2121       else
2122         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2123
2124       switch (ELF32_R_TYPE (rel->r_info))
2125         {
2126         /* This relocation describes the C++ object vtable hierarchy.
2127            Reconstruct it for later use during GC.  */
2128         case R_M32R_GNU_VTINHERIT:
2129           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2130             return false;
2131           break;
2132
2133         /* This relocation describes which C++ vtable entries are actually
2134            used.  Record for later use during GC.  */
2135         case R_M32R_GNU_VTENTRY:
2136           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2137             return false;
2138           break;
2139         }
2140     }
2141
2142   return true;
2143 }
2144 \f
2145 #define ELF_ARCH                bfd_arch_m32r
2146 #define ELF_MACHINE_CODE        EM_M32R
2147 #define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
2148 #define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
2149
2150 #define TARGET_BIG_SYM          bfd_elf32_m32r_vec
2151 #define TARGET_BIG_NAME         "elf32-m32r"
2152
2153 #define elf_info_to_howto                       0
2154 #define elf_info_to_howto_rel                   m32r_info_to_howto_rel
2155 #define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
2156 #define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
2157 #define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
2158 #define elf_backend_relocate_section            m32r_elf_relocate_section
2159 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
2160 #define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
2161 #define elf_backend_check_relocs                m32r_elf_check_relocs
2162
2163 #define elf_backend_can_gc_sections             1
2164 #if 0 /* not yet */
2165 /* relax support */
2166 #define bfd_elf32_bfd_relax_section             m32r_elf_relax_section
2167 #define bfd_elf32_bfd_get_relocated_section_contents \
2168                                         m32r_elf_get_relocated_section_contents
2169 #endif
2170
2171 #define elf_backend_object_p                    m32r_elf_object_p
2172 #define elf_backend_final_write_processing      m32r_elf_final_write_processing
2173 #define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
2174 #define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
2175 #define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
2176
2177 #include "elf32-target.h"