bfd/elf32-m32r.c

   1 /* M32R-specific support for 32-bit ELF.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007, 2008, 2009, 2010  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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/m32r.h"
  27
  28 #define NOP_INSN                0x7000
  29 #define MAKE_PARALLEL(insn)     ((insn) | 0x8000)
  30
  31 /* Use REL instead of RELA to save space.
  32    This only saves space in libraries and object files, but perhaps
  33    relocs will be put in ROM?  All in all though, REL relocs are a pain
  34    to work with.  */
  35 /* #define USE_REL      1
  36
  37 #ifndef USE_REL
  38 #define USE_REL 0
  39 #endif */
  40 /* Use RELA. But use REL to link old objects for backwords compatibility.  */
  41
  42 /* Functions for the M32R ELF linker.  */
  43
  44 /* The name of the dynamic interpreter.  This is put in the .interp
  45    section.  */
  46
  47 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  48
  49 /* The nop opcode we use.  */
  50
  51 #define M32R_NOP 0x7000f000
  52
  53 #define PLT_EMPTY   0x10101010  /* RIE  -> RIE */
  54
  55 /* The size in bytes of an entry in the procedure linkage table.  */
  56
  57 #define PLT_ENTRY_SIZE 20
  58 #define PLT_HEADER_SIZE 20
  59
  60 /* The first one entries in a procedure linkage table are reserved,
  61    and the initial contents are unimportant (we zero them out).
  62    Subsequent entries look like this. */
  63
  64 #define PLT0_ENTRY_WORD0  0xd6c00000    /* seth r6, #high(.got+4)          */
  65 #define PLT0_ENTRY_WORD1  0x86e60000    /* or3  r6, r6, #low(.got)+4)      */
  66 #define PLT0_ENTRY_WORD2  0x24e626c6    /* ld   r4, @r6+    -> ld r6, @r6  */
  67 #define PLT0_ENTRY_WORD3  0x1fc6f000    /* jmp  r6          || pnop        */
  68 #define PLT0_ENTRY_WORD4  PLT_EMPTY     /* RIE             -> RIE          */
  69
  70 #define PLT0_PIC_ENTRY_WORD0  0xa4cc0004 /* ld   r4, @(4,r12)              */
  71 #define PLT0_PIC_ENTRY_WORD1  0xa6cc0008 /* ld   r6, @(8,r12)              */
  72 #define PLT0_PIC_ENTRY_WORD2  0x1fc6f000 /* jmp  r6         || nop         */
  73 #define PLT0_PIC_ENTRY_WORD3  PLT_EMPTY  /* RIE             -> RIE         */
  74 #define PLT0_PIC_ENTRY_WORD4  PLT_EMPTY  /* RIE             -> RIE         */
  75
  76 #define PLT_ENTRY_WORD0  0xe6000000 /* ld24 r6, .name_in_GOT                */
  77 #define PLT_ENTRY_WORD1  0x06acf000 /* add  r6, r12          || nop         */
  78 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT)         */
  79 #define PLT_ENTRY_WORD1b 0x86e60000 /* or3  r6, r6, #low(.name_in_GOT)      */
  80 #define PLT_ENTRY_WORD2  0x26c61fc6 /* ld  r6, @r6           -> jmp r6      */
  81 #define PLT_ENTRY_WORD3  0xe5000000 /* ld24 r5, $offset                     */
  82 #define PLT_ENTRY_WORD4  0xff000000 /* bra  .plt0.                          */
  83
  84
  85 /* Utility to actually perform an R_M32R_10_PCREL reloc.  */
  86
  87 static bfd_reloc_status_type
  88 m32r_elf_do_10_pcrel_reloc (bfd *abfd,
  89                             reloc_howto_type *howto,
  90                             asection *input_section,
  91                             bfd_byte *data,
  92                             bfd_vma offset,
  93                             asection *symbol_section ATTRIBUTE_UNUSED,
  94                             bfd_vma symbol_value,
  95                             bfd_vma addend)
  96 {
  97   bfd_signed_vma relocation;
  98   unsigned long x;
  99   bfd_reloc_status_type status;
 100
 101   /* Sanity check the address (offset in section).  */
 102   if (offset > bfd_get_section_limit (abfd, input_section))
 103     return bfd_reloc_outofrange;
 104
 105   relocation = symbol_value + addend;
 106   /* Make it pc relative.  */
 107   relocation -= (input_section->output_section->vma
 108                  + input_section->output_offset);
 109   /* These jumps mask off the lower two bits of the current address
 110      before doing pcrel calculations.  */
 111   relocation -= (offset & -(bfd_vma) 4);
 112
 113   if (relocation < -0x200 || relocation > 0x1ff)
 114     status = bfd_reloc_overflow;
 115   else
 116     status = bfd_reloc_ok;
 117
 118   x = bfd_get_16 (abfd, data + offset);
 119   relocation >>= howto->rightshift;
 120   relocation <<= howto->bitpos;
 121   x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
 122   bfd_put_16 (abfd, (bfd_vma) x, data + offset);
 123
 124   return status;
 125 }
 126
 127 /* Handle the R_M32R_10_PCREL reloc.  */
 128
 129 static bfd_reloc_status_type
 130 m32r_elf_10_pcrel_reloc (bfd * abfd,
 131                          arelent * reloc_entry,
 132                          asymbol * symbol,
 133                          void * data,
 134                          asection * input_section,
 135                          bfd * output_bfd,
 136                          char ** error_message ATTRIBUTE_UNUSED)
 137 {
 138   /* This part is from bfd_elf_generic_reloc.  */
 139   if (output_bfd != NULL
 140       && (symbol->flags & BSF_SECTION_SYM) == 0
 141       && (! reloc_entry->howto->partial_inplace
 142           || reloc_entry->addend == 0))
 143     {
 144       reloc_entry->address += input_section->output_offset;
 145       return bfd_reloc_ok;
 146     }
 147
 148   if (output_bfd != NULL)
 149     /* FIXME: See bfd_perform_relocation.  Is this right?  */
 150     return bfd_reloc_continue;
 151
 152   return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
 153                                      input_section,
 154                                      data, reloc_entry->address,
 155                                      symbol->section,
 156                                      (symbol->value
 157                                       + symbol->section->output_section->vma
 158                                       + symbol->section->output_offset),
 159                                      reloc_entry->addend);
 160 }
 161
 162 /* Do generic partial_inplace relocation.
 163    This is a local replacement for bfd_elf_generic_reloc.  */
 164
 165 static bfd_reloc_status_type
 166 m32r_elf_generic_reloc (bfd *input_bfd,
 167                         arelent *reloc_entry,
 168                         asymbol *symbol,
 169                         void * data,
 170                         asection *input_section,
 171                         bfd *output_bfd,
 172                         char **error_message ATTRIBUTE_UNUSED)
 173 {
 174   bfd_reloc_status_type ret;
 175   bfd_vma relocation;
 176   bfd_byte *inplace_address;
 177
 178   /* This part is from bfd_elf_generic_reloc.
 179      If we're relocating, and this an external symbol, we don't want
 180      to change anything.  */
 181   if (output_bfd != NULL
 182       && (symbol->flags & BSF_SECTION_SYM) == 0
 183       && reloc_entry->addend == 0)
 184     {
 185       reloc_entry->address += input_section->output_offset;
 186       return bfd_reloc_ok;
 187     }
 188
 189   /* Now do the reloc in the usual way.
 190      ??? It would be nice to call bfd_elf_generic_reloc here,
 191      but we have partial_inplace set.  bfd_elf_generic_reloc will
 192      pass the handling back to bfd_install_relocation which will install
 193      a section relative addend which is wrong.  */
 194
 195   /* Sanity check the address (offset in section).  */
 196   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
 197     return bfd_reloc_outofrange;
 198
 199   ret = bfd_reloc_ok;
 200   if (bfd_is_und_section (symbol->section)
 201       && output_bfd == NULL)
 202     ret = bfd_reloc_undefined;
 203
 204   if (bfd_is_com_section (symbol->section)
 205       || output_bfd != NULL)
 206     relocation = 0;
 207   else
 208     relocation = symbol->value;
 209
 210   /* Only do this for a final link.  */
 211   if (output_bfd == NULL)
 212     {
 213       relocation += symbol->section->output_section->vma;
 214       relocation += symbol->section->output_offset;
 215     }
 216
 217   relocation += reloc_entry->addend;
 218   inplace_address = (bfd_byte *) data + reloc_entry->address;
 219
 220 #define DOIT(x)                                         \
 221   x = ( (x & ~reloc_entry->howto->dst_mask) |           \
 222   (((x & reloc_entry->howto->src_mask) +  relocation) & \
 223   reloc_entry->howto->dst_mask))
 224
 225   switch (reloc_entry->howto->size)
 226     {
 227     case 1:
 228       {
 229         short x = bfd_get_16 (input_bfd, inplace_address);
 230         DOIT (x);
 231         bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
 232       }
 233       break;
 234     case 2:
 235       {
 236         unsigned long x = bfd_get_32 (input_bfd, inplace_address);
 237         DOIT (x);
 238         bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
 239       }
 240       break;
 241     default:
 242       BFD_ASSERT (0);
 243     }
 244
 245   if (output_bfd != NULL)
 246     reloc_entry->address += input_section->output_offset;
 247
 248   return ret;
 249 }
 250
 251 /* Handle the R_M32R_SDA16 reloc.
 252    This reloc is used to compute the address of objects in the small data area
 253    and to perform loads and stores from that area.
 254    The lower 16 bits are sign extended and added to the register specified
 255    in the instruction, which is assumed to point to _SDA_BASE_.  */
 256
 257 static bfd_reloc_status_type
 258 m32r_elf_sda16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 259                       arelent *reloc_entry,
 260                       asymbol *symbol,
 261                       void * data ATTRIBUTE_UNUSED,
 262                       asection *input_section,
 263                       bfd *output_bfd,
 264                       char **error_message ATTRIBUTE_UNUSED)
 265 {
 266   /* This part is from bfd_elf_generic_reloc.  */
 267   if (output_bfd != NULL
 268       && (symbol->flags & BSF_SECTION_SYM) == 0
 269       && (! reloc_entry->howto->partial_inplace
 270           || reloc_entry->addend == 0))
 271     {
 272       reloc_entry->address += input_section->output_offset;
 273       return bfd_reloc_ok;
 274     }
 275
 276   if (output_bfd != NULL)
 277     /* FIXME: See bfd_perform_relocation.  Is this right?  */
 278     return bfd_reloc_continue;
 279
 280   /* FIXME: not sure what to do here yet.  But then again, the linker
 281      may never call us.  */
 282   abort ();
 283 }
 284
 285 \f
 286 /* Handle the R_M32R_HI16_[SU]LO relocs.
 287    HI16_SLO is for the add3 and load/store with displacement instructions.
 288    HI16_ULO is for the or3 instruction.
 289    For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
 290    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
 291    we must add one to the high 16 bytes (which will get subtracted off when
 292    the low 16 bits are added).
 293    These relocs have to be done in combination with an R_M32R_LO16 reloc
 294    because there is a carry from the LO16 to the HI16.  Here we just save
 295    the information we need; we do the actual relocation when we see the LO16.
 296    This code is copied from the elf32-mips.c.  We also support an arbitrary
 297    number of HI16 relocs to be associated with a single LO16 reloc.  The
 298    assembler sorts the relocs to ensure each HI16 immediately precedes its
 299    LO16.  However if there are multiple copies, the assembler may not find
 300    the real LO16 so it picks the first one it finds.  */
 301
 302 struct m32r_hi16
 303 {
 304   struct m32r_hi16 *next;
 305   bfd_byte *addr;
 306   bfd_vma addend;
 307 };
 308
 309 /* FIXME: This should not be a static variable.  */
 310
 311 static struct m32r_hi16 *m32r_hi16_list;
 312
 313 static bfd_reloc_status_type
 314 m32r_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 315                      arelent *reloc_entry,
 316                      asymbol *symbol,
 317                      void * data,
 318                      asection *input_section,
 319                      bfd *output_bfd,
 320                      char **error_message ATTRIBUTE_UNUSED)
 321 {
 322   bfd_reloc_status_type ret;
 323   bfd_vma relocation;
 324   struct m32r_hi16 *n;
 325
 326   /* This part is from bfd_elf_generic_reloc.
 327      If we're relocating, and this an external symbol, we don't want
 328      to change anything.  */
 329   if (output_bfd != NULL
 330       && (symbol->flags & BSF_SECTION_SYM) == 0
 331       && reloc_entry->addend == 0)
 332     {
 333       reloc_entry->address += input_section->output_offset;
 334       return bfd_reloc_ok;
 335     }
 336
 337   /* Sanity check the address (offset in section).  */
 338   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 339     return bfd_reloc_outofrange;
 340
 341   ret = bfd_reloc_ok;
 342   if (bfd_is_und_section (symbol->section)
 343       && output_bfd == NULL)
 344     ret = bfd_reloc_undefined;
 345
 346   if (bfd_is_com_section (symbol->section))
 347     relocation = 0;
 348   else
 349     relocation = symbol->value;
 350
 351   relocation += symbol->section->output_section->vma;
 352   relocation += symbol->section->output_offset;
 353   relocation += reloc_entry->addend;
 354
 355   /* Save the information, and let LO16 do the actual relocation.  */
 356   n = bfd_malloc ((bfd_size_type) sizeof *n);
 357   if (n == NULL)
 358     return bfd_reloc_outofrange;
 359   n->addr = (bfd_byte *) data + reloc_entry->address;
 360   n->addend = relocation;
 361   n->next = m32r_hi16_list;
 362   m32r_hi16_list = n;
 363
 364   if (output_bfd != NULL)
 365     reloc_entry->address += input_section->output_offset;
 366
 367   return ret;
 368 }
 369
 370 /* Handle an M32R ELF HI16 reloc.  */
 371
 372 static void
 373 m32r_elf_relocate_hi16 (bfd *input_bfd,
 374                         int type,
 375                         Elf_Internal_Rela *relhi,
 376                         Elf_Internal_Rela *rello,
 377                         bfd_byte *contents,
 378                         bfd_vma addend)
 379 {
 380   unsigned long insn;
 381   bfd_vma addlo;
 382
 383   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
 384
 385   addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
 386   if (type == R_M32R_HI16_SLO)
 387     addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
 388   else
 389     addlo &= 0xffff;
 390
 391   addend += ((insn & 0xffff) << 16) + addlo;
 392
 393   /* Reaccount for sign extension of low part.  */
 394   if (type == R_M32R_HI16_SLO
 395       && (addend & 0x8000) != 0)
 396     addend += 0x10000;
 397
 398   bfd_put_32 (input_bfd,
 399               (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
 400               contents + relhi->r_offset);
 401 }
 402
 403 /* Do an R_M32R_LO16 relocation.  This is a straightforward 16 bit
 404    inplace relocation; this function exists in order to do the
 405    R_M32R_HI16_[SU]LO relocation described above.  */
 406
 407 static bfd_reloc_status_type
 408 m32r_elf_lo16_reloc (bfd *input_bfd,
 409                      arelent *reloc_entry,
 410                      asymbol *symbol,
 411                      void * data,
 412                      asection *input_section,
 413                      bfd *output_bfd,
 414                      char **error_message)
 415 {
 416   /* This part is from bfd_elf_generic_reloc.
 417      If we're relocating, and this an external symbol, we don't want
 418      to change anything.  */
 419   if (output_bfd != NULL
 420       && (symbol->flags & BSF_SECTION_SYM) == 0
 421       && reloc_entry->addend == 0)
 422     {
 423       reloc_entry->address += input_section->output_offset;
 424       return bfd_reloc_ok;
 425     }
 426
 427   if (m32r_hi16_list != NULL)
 428     {
 429       struct m32r_hi16 *l;
 430
 431       l = m32r_hi16_list;
 432       while (l != NULL)
 433         {
 434           unsigned long insn;
 435           unsigned long val;
 436           unsigned long vallo;
 437           struct m32r_hi16 *next;
 438
 439           /* Do the HI16 relocation.  Note that we actually don't need
 440              to know anything about the LO16 itself, except where to
 441              find the low 16 bits of the addend needed by the LO16.  */
 442           insn = bfd_get_32 (input_bfd, l->addr);
 443           vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
 444                    & 0xffff) ^ 0x8000) - 0x8000;
 445           val = ((insn & 0xffff) << 16) + vallo;
 446           val += l->addend;
 447
 448           /* Reaccount for sign extension of low part.  */
 449           if ((val & 0x8000) != 0)
 450             val += 0x10000;
 451
 452           insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
 453           bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
 454
 455           next = l->next;
 456           free (l);
 457           l = next;
 458         }
 459
 460       m32r_hi16_list = NULL;
 461     }
 462
 463   /* Now do the LO16 reloc in the usual way.
 464      ??? It would be nice to call bfd_elf_generic_reloc here,
 465      but we have partial_inplace set.  bfd_elf_generic_reloc will
 466      pass the handling back to bfd_install_relocation which will install
 467      a section relative addend which is wrong.  */
 468   return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
 469                                 input_section, output_bfd, error_message);
 470 }
 471
 472 \f
 473 static reloc_howto_type m32r_elf_howto_table[] =
 474 {
 475   /* This reloc does nothing.  */
 476   HOWTO (R_M32R_NONE,           /* type */
 477          0,                     /* rightshift */
 478          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          32,                    /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_bitfield, /* complain_on_overflow */
 483          bfd_elf_generic_reloc, /* special_function */
 484          "R_M32R_NONE",         /* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0,                     /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* A 16 bit absolute relocation.  */
 491   HOWTO (R_M32R_16,             /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_bitfield, /* complain_on_overflow */
 498          m32r_elf_generic_reloc,/* special_function */
 499          "R_M32R_16",           /* name */
 500          TRUE,                  /* partial_inplace */
 501          0xffff,                /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* A 32 bit absolute relocation.  */
 506   HOWTO (R_M32R_32,             /* type */
 507          0,                     /* rightshift */
 508          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 509          32,                    /* bitsize */
 510          FALSE,                 /* pc_relative */
 511          0,                     /* bitpos */
 512          complain_overflow_bitfield, /* complain_on_overflow */
 513          m32r_elf_generic_reloc,/* special_function */
 514          "R_M32R_32",           /* name */
 515          TRUE,                  /* partial_inplace */
 516          0xffffffff,            /* src_mask */
 517          0xffffffff,            /* dst_mask */
 518          FALSE),                /* pcrel_offset */
 519
 520   /* A 24 bit address.  */
 521   HOWTO (R_M32R_24,             /* type */
 522          0,                     /* rightshift */
 523          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 524          24,                    /* bitsize */
 525          FALSE,                 /* pc_relative */
 526          0,                     /* bitpos */
 527          complain_overflow_unsigned, /* complain_on_overflow */
 528          m32r_elf_generic_reloc,/* special_function */
 529          "R_M32R_24",           /* name */
 530          TRUE,                  /* partial_inplace */
 531          0xffffff,              /* src_mask */
 532          0xffffff,              /* dst_mask */
 533          FALSE),                /* pcrel_offset */
 534
 535   /* An PC Relative 10-bit relocation, shifted by 2.
 536      This reloc is complicated because relocations are relative to pc & -4.
 537      i.e. branches in the right insn slot use the address of the left insn
 538      slot for pc.  */
 539   /* ??? It's not clear whether this should have partial_inplace set or not.
 540      Branch relaxing in the assembler can store the addend in the insn,
 541      and if bfd_install_relocation gets called the addend may get added
 542      again.  */
 543   HOWTO (R_M32R_10_PCREL,       /* type */
 544          2,                     /* rightshift */
 545          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          10,                    /* bitsize */
 547          TRUE,                  /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_signed, /* complain_on_overflow */
 550          m32r_elf_10_pcrel_reloc, /* special_function */
 551          "R_M32R_10_PCREL",     /* name */
 552          FALSE,                 /* partial_inplace */
 553          0xff,                  /* src_mask */
 554          0xff,                  /* dst_mask */
 555          TRUE),                 /* pcrel_offset */
 556
 557   /* A relative 18 bit relocation, right shifted by 2.  */
 558   HOWTO (R_M32R_18_PCREL,       /* type */
 559          2,                     /* rightshift */
 560          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 561          16,                    /* bitsize */
 562          TRUE,                  /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_signed, /* complain_on_overflow */
 565          bfd_elf_generic_reloc, /* special_function */
 566          "R_M32R_18_PCREL",     /* name */
 567          FALSE,                 /* partial_inplace */
 568          0xffff,                /* src_mask */
 569          0xffff,                /* dst_mask */
 570          TRUE),                 /* pcrel_offset */
 571
 572   /* A relative 26 bit relocation, right shifted by 2.  */
 573   /* ??? It's not clear whether this should have partial_inplace set or not.
 574      Branch relaxing in the assembler can store the addend in the insn,
 575      and if bfd_install_relocation gets called the addend may get added
 576      again.  */
 577   HOWTO (R_M32R_26_PCREL,       /* type */
 578          2,                     /* rightshift */
 579          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 580          26,                    /* bitsize */
 581          TRUE,                  /* pc_relative */
 582          0,                     /* bitpos */
 583          complain_overflow_signed, /* complain_on_overflow */
 584          bfd_elf_generic_reloc, /* special_function */
 585          "R_M32R_26_PCREL",     /* name */
 586          FALSE,                 /* partial_inplace */
 587          0xffffff,              /* src_mask */
 588          0xffffff,              /* dst_mask */
 589          TRUE),                 /* pcrel_offset */
 590
 591   /* High 16 bits of address when lower 16 is or'd in.  */
 592   HOWTO (R_M32R_HI16_ULO,       /* type */
 593          16,                    /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          16,                    /* bitsize */
 596          FALSE,                 /* pc_relative */
 597          0,                     /* bitpos */
 598          complain_overflow_dont, /* complain_on_overflow */
 599          m32r_elf_hi16_reloc,   /* special_function */
 600          "R_M32R_HI16_ULO",     /* name */
 601          TRUE,                  /* partial_inplace */
 602          0x0000ffff,            /* src_mask */
 603          0x0000ffff,            /* dst_mask */
 604          FALSE),                /* pcrel_offset */
 605
 606   /* High 16 bits of address when lower 16 is added in.  */
 607   HOWTO (R_M32R_HI16_SLO,       /* type */
 608          16,                    /* rightshift */
 609          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 610          16,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          m32r_elf_hi16_reloc,   /* special_function */
 615          "R_M32R_HI16_SLO",     /* name */
 616          TRUE,                  /* partial_inplace */
 617          0x0000ffff,            /* src_mask */
 618          0x0000ffff,            /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Lower 16 bits of address.  */
 622   HOWTO (R_M32R_LO16,           /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          16,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_dont, /* complain_on_overflow */
 629          m32r_elf_lo16_reloc,   /* special_function */
 630          "R_M32R_LO16",         /* name */
 631          TRUE,                  /* partial_inplace */
 632          0x0000ffff,            /* src_mask */
 633          0x0000ffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Small data area 16 bits offset.  */
 637   HOWTO (R_M32R_SDA16,          /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_signed, /* complain_on_overflow */
 644          m32r_elf_sda16_reloc,  /* special_function */
 645          "R_M32R_SDA16",        /* name */
 646          TRUE,                  /* partial_inplace */  /* FIXME: correct? */
 647          0x0000ffff,            /* src_mask */
 648          0x0000ffff,            /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* GNU extension to record C++ vtable hierarchy.  */
 652   HOWTO (R_M32R_GNU_VTINHERIT, /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          0,                     /* bitsize */
 656          FALSE,                 /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_dont, /* complain_on_overflow */
 659          NULL,                  /* special_function */
 660          "R_M32R_GNU_VTINHERIT", /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0,                     /* dst_mask */
 664          FALSE),                /* pcrel_offset */
 665
 666   /* GNU extension to record C++ vtable member usage.  */
 667   HOWTO (R_M32R_GNU_VTENTRY,     /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          0,                     /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_dont, /* complain_on_overflow */
 674          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 675          "R_M32R_GNU_VTENTRY",   /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0,                     /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   EMPTY_HOWTO (13),
 682   EMPTY_HOWTO (14),
 683   EMPTY_HOWTO (15),
 684   EMPTY_HOWTO (16),
 685   EMPTY_HOWTO (17),
 686   EMPTY_HOWTO (18),
 687   EMPTY_HOWTO (19),
 688   EMPTY_HOWTO (20),
 689   EMPTY_HOWTO (21),
 690   EMPTY_HOWTO (22),
 691   EMPTY_HOWTO (23),
 692   EMPTY_HOWTO (24),
 693   EMPTY_HOWTO (25),
 694   EMPTY_HOWTO (26),
 695   EMPTY_HOWTO (27),
 696   EMPTY_HOWTO (28),
 697   EMPTY_HOWTO (29),
 698   EMPTY_HOWTO (30),
 699   EMPTY_HOWTO (31),
 700   EMPTY_HOWTO (32),
 701
 702   /* A 16 bit absolute relocation.  */
 703   HOWTO (R_M32R_16_RELA,        /* type */
 704          0,                     /* rightshift */
 705          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 706          16,                    /* bitsize */
 707          FALSE,                 /* pc_relative */
 708          0,                     /* bitpos */
 709          complain_overflow_bitfield, /* complain_on_overflow */
 710          bfd_elf_generic_reloc, /* special_function */
 711          "R_M32R_16_RELA",      /* name */
 712          FALSE,                 /* partial_inplace */
 713          0xffff,                /* src_mask */
 714          0xffff,                /* dst_mask */
 715          FALSE),                /* pcrel_offset */
 716
 717   /* A 32 bit absolute relocation.  */
 718   HOWTO (R_M32R_32_RELA,        /* type */
 719          0,                     /* rightshift */
 720          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 721          32,                    /* bitsize */
 722          FALSE,                 /* pc_relative */
 723          0,                     /* bitpos */
 724          complain_overflow_bitfield, /* complain_on_overflow */
 725          bfd_elf_generic_reloc,/* special_function */
 726          "R_M32R_32_RELA",              /* name */
 727          FALSE,                 /* partial_inplace */
 728          0xffffffff,            /* src_mask */
 729          0xffffffff,            /* dst_mask */
 730          FALSE),                /* pcrel_offset */
 731
 732   /* A 24 bit address.  */
 733   HOWTO (R_M32R_24_RELA,        /* type */
 734          0,                     /* rightshift */
 735          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 736          24,                    /* bitsize */
 737          FALSE,                 /* pc_relative */
 738          0,                     /* bitpos */
 739          complain_overflow_unsigned, /* complain_on_overflow */
 740          bfd_elf_generic_reloc,/* special_function */
 741          "R_M32R_24_RELA",      /* name */
 742          FALSE,                 /* partial_inplace */
 743          0xffffff,              /* src_mask */
 744          0xffffff,              /* dst_mask */
 745          FALSE),                /* pcrel_offset */
 746
 747   HOWTO (R_M32R_10_PCREL_RELA,  /* type */
 748          2,                     /* rightshift */
 749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 750          10,                    /* bitsize */
 751          TRUE,                  /* pc_relative */
 752          0,                     /* bitpos */
 753          complain_overflow_signed, /* complain_on_overflow */
 754          m32r_elf_10_pcrel_reloc, /* special_function */
 755          "R_M32R_10_PCREL_RELA",/* name */
 756          FALSE,                 /* partial_inplace */
 757          0xff,                  /* src_mask */
 758          0xff,                  /* dst_mask */
 759          TRUE),                 /* pcrel_offset */
 760
 761   /* A relative 18 bit relocation, right shifted by 2.  */
 762   HOWTO (R_M32R_18_PCREL_RELA,  /* type */
 763          2,                     /* rightshift */
 764          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 765          16,                    /* bitsize */
 766          TRUE,                  /* pc_relative */
 767          0,                     /* bitpos */
 768          complain_overflow_signed, /* complain_on_overflow */
 769          bfd_elf_generic_reloc, /* special_function */
 770          "R_M32R_18_PCREL_RELA",/* name */
 771          FALSE,                 /* partial_inplace */
 772          0xffff,                /* src_mask */
 773          0xffff,                /* dst_mask */
 774          TRUE),                 /* pcrel_offset */
 775
 776   /* A relative 26 bit relocation, right shifted by 2.  */
 777   HOWTO (R_M32R_26_PCREL_RELA,  /* type */
 778          2,                     /* rightshift */
 779          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          26,                    /* bitsize */
 781          TRUE,                  /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_signed, /* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_M32R_26_PCREL_RELA",/* name */
 786          FALSE,                 /* partial_inplace */
 787          0xffffff,              /* src_mask */
 788          0xffffff,              /* dst_mask */
 789          TRUE),                 /* pcrel_offset */
 790
 791   /* High 16 bits of address when lower 16 is or'd in.  */
 792   HOWTO (R_M32R_HI16_ULO_RELA,  /* type */
 793          16,                    /* rightshift */
 794          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          FALSE,                 /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_dont, /* complain_on_overflow */
 799          bfd_elf_generic_reloc, /* special_function */
 800          "R_M32R_HI16_ULO_RELA",/* name */
 801          FALSE,                 /* partial_inplace */
 802          0x0000ffff,            /* src_mask */
 803          0x0000ffff,            /* dst_mask */
 804          FALSE),                /* pcrel_offset */
 805
 806   /* High 16 bits of address when lower 16 is added in.  */
 807   HOWTO (R_M32R_HI16_SLO_RELA,  /* type */
 808          16,                    /* rightshift */
 809          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 810          16,                    /* bitsize */
 811          FALSE,                 /* pc_relative */
 812          0,                     /* bitpos */
 813          complain_overflow_dont, /* complain_on_overflow */
 814          bfd_elf_generic_reloc, /* special_function */
 815          "R_M32R_HI16_SLO_RELA",/* name */
 816          FALSE,                 /* partial_inplace */
 817          0x0000ffff,            /* src_mask */
 818          0x0000ffff,            /* dst_mask */
 819          FALSE),                /* pcrel_offset */
 820
 821   /* Lower 16 bits of address.  */
 822   HOWTO (R_M32R_LO16_RELA,      /* type */
 823          0,                     /* rightshift */
 824          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 825          16,                    /* bitsize */
 826          FALSE,                 /* pc_relative */
 827          0,                     /* bitpos */
 828          complain_overflow_dont, /* complain_on_overflow */
 829          bfd_elf_generic_reloc, /* special_function */
 830          "R_M32R_LO16_RELA",    /* name */
 831          FALSE,                 /* partial_inplace */
 832          0x0000ffff,            /* src_mask */
 833          0x0000ffff,            /* dst_mask */
 834          FALSE),                /* pcrel_offset */
 835
 836   /* Small data area 16 bits offset.  */
 837   HOWTO (R_M32R_SDA16_RELA,     /* type */
 838          0,                     /* rightshift */
 839          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 840          16,                    /* bitsize */
 841          FALSE,                 /* pc_relative */
 842          0,                     /* bitpos */
 843          complain_overflow_signed, /* complain_on_overflow */
 844          bfd_elf_generic_reloc, /* special_function */
 845          "R_M32R_SDA16_RELA",   /* name */
 846          TRUE,                  /* partial_inplace */  /* FIXME: correct? */
 847          0x0000ffff,            /* src_mask */
 848          0x0000ffff,            /* dst_mask */
 849          FALSE),                /* pcrel_offset */
 850
 851   /* GNU extension to record C++ vtable hierarchy.  */
 852   HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */
 853          0,                     /* rightshift */
 854          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 855          0,                     /* bitsize */
 856          FALSE,                 /* pc_relative */
 857          0,                     /* bitpos */
 858          complain_overflow_dont, /* complain_on_overflow */
 859          NULL,                  /* special_function */
 860          "R_M32R_RELA_GNU_VTINHERIT", /* name */
 861          FALSE,                 /* partial_inplace */
 862          0,                     /* src_mask */
 863          0,                     /* dst_mask */
 864          FALSE),                /* pcrel_offset */
 865
 866   /* GNU extension to record C++ vtable member usage.  */
 867   HOWTO (R_M32R_RELA_GNU_VTENTRY,     /* type */
 868          0,                     /* rightshift */
 869          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 870          0,                     /* bitsize */
 871          FALSE,                 /* pc_relative */
 872          0,                     /* bitpos */
 873          complain_overflow_dont, /* complain_on_overflow */
 874          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 875          "R_M32R_RELA_GNU_VTENTRY",   /* name */
 876          FALSE,                 /* partial_inplace */
 877          0,                     /* src_mask */
 878          0,                     /* dst_mask */
 879          FALSE),                /* pcrel_offset */
 880
 881   /* A 32 bit PC relative relocation.  */
 882   HOWTO (R_M32R_REL32,          /* type */
 883          0,                     /* rightshift */
 884          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 885          32,                    /* bitsize */
 886          TRUE,                  /* pc_relative */
 887          0,                     /* bitpos */
 888          complain_overflow_bitfield, /* complain_on_overflow */
 889          bfd_elf_generic_reloc,/* special_function */
 890          "R_M32R_REL32",                /* name */
 891          FALSE,                 /* partial_inplace */
 892          0xffffffff,            /* src_mask */
 893          0xffffffff,            /* dst_mask */
 894          TRUE),                 /* pcrel_offset */
 895
 896   EMPTY_HOWTO (46),
 897   EMPTY_HOWTO (47),
 898
 899   /* Like R_M32R_24, but referring to the GOT table entry for
 900      the symbol.  */
 901   HOWTO (R_M32R_GOT24,          /* type */
 902          0,                     /* rightshift */
 903          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 904          24,                    /* bitsize */
 905          FALSE,                 /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_unsigned, /* complain_on_overflow */
 908          bfd_elf_generic_reloc, /* special_function */
 909          "R_M32R_GOT24",        /* name */
 910          FALSE,                 /* partial_inplace */
 911          0xffffff,              /* src_mask */
 912          0xffffff,              /* dst_mask */
 913          FALSE),                /* pcrel_offset */
 914
 915   /* Like R_M32R_PCREL, but referring to the procedure linkage table
 916      entry for the symbol.  */
 917   HOWTO (R_M32R_26_PLTREL,      /* type */
 918          2,                     /* rightshift */
 919          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 920          24,                    /* bitsize */
 921          TRUE,                  /* pc_relative */
 922          0,                     /* bitpos */
 923          complain_overflow_signed, /* complain_on_overflow */
 924          bfd_elf_generic_reloc, /* special_function */
 925          "R_M32R_26_PLTREL",    /* name */
 926          FALSE,                 /* partial_inplace */
 927          0xffffff,              /* src_mask */
 928          0xffffff,              /* dst_mask */
 929          TRUE),                 /* pcrel_offset */
 930
 931   /* This is used only by the dynamic linker.  The symbol should exist
 932      both in the object being run and in some shared library.  The
 933      dynamic linker copies the data addressed by the symbol from the
 934      shared library into the object, because the object being
 935      run has to have the data at some particular address.  */
 936   HOWTO (R_M32R_COPY,           /* type */
 937          0,                     /* rightshift */
 938          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 939          32,                    /* bitsize */
 940          FALSE,                 /* pc_relative */
 941          0,                     /* bitpos */
 942          complain_overflow_bitfield, /* complain_on_overflow */
 943          bfd_elf_generic_reloc, /* special_function */
 944          "R_M32R_COPY",         /* name */
 945          FALSE,                 /* partial_inplace */
 946          0xffffffff,            /* src_mask */
 947          0xffffffff,            /* dst_mask */
 948          FALSE),                /* pcrel_offset */
 949
 950   /* Like R_M32R_24, but used when setting global offset table
 951      entries.  */
 952   HOWTO (R_M32R_GLOB_DAT,       /* type */
 953          0,                     /* rightshift */
 954          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 955          32,                    /* bitsize */
 956          FALSE,                 /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_bitfield, /* complain_on_overflow */
 959          bfd_elf_generic_reloc, /* special_function */
 960          "R_M32R_GLOB_DAT",     /* name */
 961          FALSE,                 /* partial_inplace */
 962          0xffffffff,            /* src_mask */
 963          0xffffffff,            /* dst_mask */
 964          FALSE),                /* pcrel_offset */
 965
 966   /* Marks a procedure linkage table entry for a symbol.  */
 967   HOWTO (R_M32R_JMP_SLOT,       /* type */
 968          0,                     /* rightshift */
 969          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 970          32,                    /* bitsize */
 971          FALSE,                 /* pc_relative */
 972          0,                     /* bitpos */
 973          complain_overflow_bitfield, /* complain_on_overflow */
 974          bfd_elf_generic_reloc, /* special_function */
 975          "R_M32R_JMP_SLOT",     /* name */
 976          FALSE,                 /* partial_inplace */
 977          0xffffffff,            /* src_mask */
 978          0xffffffff,            /* dst_mask */
 979          FALSE),                /* pcrel_offset */
 980
 981   /* Used only by the dynamic linker.  When the object is run, this
 982      longword is set to the load address of the object, plus the
 983      addend.  */
 984   HOWTO (R_M32R_RELATIVE,       /* type */
 985          0,                     /* rightshift */
 986          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 987          32,                    /* bitsize */
 988          FALSE,                 /* pc_relative */
 989          0,                     /* bitpos */
 990          complain_overflow_bitfield, /* complain_on_overflow */
 991          bfd_elf_generic_reloc, /* special_function */
 992          "R_M32R_RELATIVE",     /* name */
 993          FALSE,                 /* partial_inplace */
 994          0xffffffff,            /* src_mask */
 995          0xffffffff,            /* dst_mask */
 996          FALSE),                /* pcrel_offset */
 997
 998   HOWTO (R_M32R_GOTOFF,         /* type */
 999          0,                     /* rightshift */
1000          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          24,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_bitfield, /* complain_on_overflow */
1005          bfd_elf_generic_reloc, /* special_function */
1006          "R_M32R_GOTOFF",       /* name */
1007          FALSE,                 /* partial_inplace */
1008          0xffffff,              /* src_mask */
1009          0xffffff,              /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* An PC Relative 24-bit relocation used when setting PIC offset
1013      table register. */
1014   HOWTO (R_M32R_GOTPC24,        /* type */
1015          0,                     /* rightshift */
1016          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1017          24,                    /* bitsize */
1018          TRUE,                  /* pc_relative */
1019          0,                     /* bitpos */
1020          complain_overflow_unsigned, /* complain_on_overflow */
1021          bfd_elf_generic_reloc, /* special_function */
1022          "R_M32R_GOTPC24",      /* name */
1023          FALSE,                 /* partial_inplace */
1024          0xffffff,              /* src_mask */
1025          0xffffff,              /* dst_mask */
1026          TRUE),                 /* pcrel_offset */
1027
1028   /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1029      the symbol.  */
1030   HOWTO (R_M32R_GOT16_HI_ULO,   /* type */
1031          16,                    /* rightshift */
1032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1033          16,                    /* bitsize */
1034          FALSE,                 /* pc_relative */
1035          0,                     /* bitpos */
1036          complain_overflow_dont, /* complain_on_overflow */
1037          bfd_elf_generic_reloc, /* special_function */
1038          "R_M32R_GOT16_HI_ULO", /* name */
1039          FALSE,                 /* partial_inplace */
1040          0x0000ffff,            /* src_mask */
1041          0x0000ffff,            /* dst_mask */
1042          FALSE),                /* pcrel_offset */
1043
1044   /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1045      the symbol.  */
1046   HOWTO (R_M32R_GOT16_HI_SLO,   /* type */
1047          16,                    /* rightshift */
1048          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049          16,                    /* bitsize */
1050          FALSE,                 /* pc_relative */
1051          0,                     /* bitpos */
1052          complain_overflow_dont, /* complain_on_overflow */
1053          bfd_elf_generic_reloc, /* special_function */
1054          "R_M32R_GOT16_HI_SLO", /* name */
1055          FALSE,                 /* partial_inplace */
1056          0x0000ffff,            /* src_mask */
1057          0x0000ffff,            /* dst_mask */
1058          FALSE),                /* pcrel_offset */
1059
1060   /* Like R_M32R_LO16, but referring to the GOT table entry for
1061      the symbol.  */
1062   HOWTO (R_M32R_GOT16_LO,       /* type */
1063          0,                     /* rightshift */
1064          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_dont, /* complain_on_overflow */
1069          bfd_elf_generic_reloc, /* special_function */
1070          "R_M32R_GOT16_LO",     /* name */
1071          FALSE,                 /* partial_inplace */
1072          0x0000ffff,            /* src_mask */
1073          0x0000ffff,            /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* An PC Relative relocation used when setting PIC offset table register.
1077      Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1078      the symbol.  */
1079   HOWTO (R_M32R_GOTPC_HI_ULO,   /* type */
1080          16,                    /* rightshift */
1081          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1082          16,                    /* bitsize */
1083          FALSE,                 /* pc_relative */
1084          0,                     /* bitpos */
1085          complain_overflow_dont, /* complain_on_overflow */
1086          bfd_elf_generic_reloc, /* special_function */
1087          "R_M32R_GOTPC_HI_ULO", /* name */
1088          FALSE,                 /* partial_inplace */
1089          0x0000ffff,            /* src_mask */
1090          0x0000ffff,            /* dst_mask */
1091          TRUE),                 /* pcrel_offset */
1092
1093   /* An PC Relative relocation used when setting PIC offset table register.
1094      Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1095      the symbol.  */
1096   HOWTO (R_M32R_GOTPC_HI_SLO,   /* type */
1097          16,                    /* rightshift */
1098          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1099          16,                    /* bitsize */
1100          FALSE,                 /* pc_relative */
1101          0,                     /* bitpos */
1102          complain_overflow_dont, /* complain_on_overflow */
1103          bfd_elf_generic_reloc, /* special_function */
1104          "R_M32R_GOTPC_HI_SLO", /* name */
1105          FALSE,                 /* partial_inplace */
1106          0x0000ffff,            /* src_mask */
1107          0x0000ffff,            /* dst_mask */
1108          TRUE),                 /* pcrel_offset */
1109
1110   /* An PC Relative relocation used when setting PIC offset table register.
1111      Like R_M32R_LO16, but referring to the GOT table entry for
1112      the symbol.  */
1113   HOWTO (R_M32R_GOTPC_LO,       /* type */
1114          0,                     /* rightshift */
1115          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1116          16,                    /* bitsize */
1117          FALSE,                 /* pc_relative */
1118          0,                     /* bitpos */
1119          complain_overflow_dont, /* complain_on_overflow */
1120          bfd_elf_generic_reloc, /* special_function */
1121          "R_M32R_GOTPC_LO",     /* name */
1122          FALSE,                 /* partial_inplace */
1123          0x0000ffff,            /* src_mask */
1124          0x0000ffff,            /* dst_mask */
1125          TRUE),                 /* pcrel_offset */
1126
1127   HOWTO (R_M32R_GOTOFF_HI_ULO,  /* type */
1128          16,                    /* rightshift */
1129          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_dont, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_M32R_GOTOFF_HI_ULO",/* name */
1136          FALSE,                 /* partial_inplace */
1137          0x0000ffff,            /* src_mask */
1138          0x0000ffff,            /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   HOWTO (R_M32R_GOTOFF_HI_SLO,  /* type */
1142          16,                    /* rightshift */
1143          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1144          16,                    /* bitsize */
1145          FALSE,                 /* pc_relative */
1146          0,                     /* bitpos */
1147          complain_overflow_dont, /* complain_on_overflow */
1148          bfd_elf_generic_reloc, /* special_function */
1149          "R_M32R_GOTOFF_HI_SLO",/* name */
1150          FALSE,                 /* partial_inplace */
1151          0x0000ffff,            /* src_mask */
1152          0x0000ffff,            /* dst_mask */
1153          FALSE),                /* pcrel_offset */
1154
1155   HOWTO (R_M32R_GOTOFF_LO,      /* type */
1156          0,                     /* rightshift */
1157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1158          16,                    /* bitsize */
1159          FALSE,                 /* pc_relative */
1160          0,                     /* bitpos */
1161          complain_overflow_dont, /* complain_on_overflow */
1162          bfd_elf_generic_reloc, /* special_function */
1163          "R_M32R_GOTOFF_LO",    /* name */
1164          FALSE,                 /* partial_inplace */
1165          0x0000ffff,            /* src_mask */
1166          0x0000ffff,            /* dst_mask */
1167          FALSE),                /* pcrel_offset */
1168 };
1169
1170 /* Map BFD reloc types to M32R ELF reloc types.  */
1171
1172 struct m32r_reloc_map
1173 {
1174   bfd_reloc_code_real_type bfd_reloc_val;
1175   unsigned char elf_reloc_val;
1176 };
1177
1178 #ifdef USE_M32R_OLD_RELOC
1179 static const struct m32r_reloc_map m32r_reloc_map_old[] =
1180 {
1181   { BFD_RELOC_NONE, R_M32R_NONE },
1182   { BFD_RELOC_16, R_M32R_16 },
1183   { BFD_RELOC_32, R_M32R_32 },
1184   { BFD_RELOC_M32R_24, R_M32R_24 },
1185   { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
1186   { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
1187   { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
1188   { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
1189   { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
1190   { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
1191   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
1192   { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
1193   { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
1194 };
1195 #else
1196 static const struct m32r_reloc_map m32r_reloc_map[] =
1197 {
1198   { BFD_RELOC_NONE, R_M32R_NONE },
1199   { BFD_RELOC_16, R_M32R_16_RELA },
1200   { BFD_RELOC_32, R_M32R_32_RELA },
1201   { BFD_RELOC_M32R_24, R_M32R_24_RELA },
1202   { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA },
1203   { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA },
1204   { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA },
1205   { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA },
1206   { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA },
1207   { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA },
1208   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
1209   { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
1210   { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
1211   { BFD_RELOC_32_PCREL, R_M32R_REL32 },
1212
1213   { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
1214   { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
1215   { BFD_RELOC_M32R_COPY, R_M32R_COPY },
1216   { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT },
1217   { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT },
1218   { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE },
1219   { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF },
1220   { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 },
1221   { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO },
1222   { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO },
1223   { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO },
1224   { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO },
1225   { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO },
1226   { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO },
1227   { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO },
1228   { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO },
1229   { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO },
1230 };
1231 #endif
1232
1233 static reloc_howto_type *
1234 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1235                                  bfd_reloc_code_real_type code)
1236 {
1237   unsigned int i;
1238
1239 #ifdef USE_M32R_OLD_RELOC
1240   for (i = 0;
1241        i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map);
1242        i++)
1243     if (m32r_reloc_map_old[i].bfd_reloc_val == code)
1244       return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val];
1245
1246 #else /* ! USE_M32R_OLD_RELOC */
1247
1248   for (i = 0;
1249        i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
1250        i++)
1251     if (m32r_reloc_map[i].bfd_reloc_val == code)
1252       return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
1253 #endif
1254
1255   return NULL;
1256 }
1257
1258 static reloc_howto_type *
1259 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1260                                  const char *r_name)
1261 {
1262   unsigned int i;
1263
1264   for (i = 0;
1265        i < sizeof (m32r_elf_howto_table) / sizeof (m32r_elf_howto_table[0]);
1266        i++)
1267     if (m32r_elf_howto_table[i].name != NULL
1268         && strcasecmp (m32r_elf_howto_table[i].name, r_name) == 0)
1269       return &m32r_elf_howto_table[i];
1270
1271   return NULL;
1272 }
1273
1274 /* Set the howto pointer for an M32R ELF reloc.  */
1275
1276 static void
1277 m32r_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1278                         arelent *cache_ptr,
1279                         Elf_Internal_Rela *dst)
1280 {
1281   unsigned int r_type;
1282
1283   r_type = ELF32_R_TYPE (dst->r_info);
1284   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) <= (unsigned int) R_M32R_GNU_VTENTRY);
1285   cache_ptr->howto = &m32r_elf_howto_table[r_type];
1286 }
1287
1288 static void
1289 m32r_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1290                     arelent *cache_ptr,
1291                     Elf_Internal_Rela *dst)
1292 {
1293   BFD_ASSERT ((ELF32_R_TYPE(dst->r_info) == (unsigned int) R_M32R_NONE)
1294               || ((ELF32_R_TYPE(dst->r_info) > (unsigned int) R_M32R_GNU_VTENTRY)
1295                   && (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_M32R_max)));
1296   cache_ptr->howto = &m32r_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
1297 }
1298
1299 \f
1300 /* Given a BFD section, try to locate the corresponding ELF section
1301    index.  */
1302
1303 static bfd_boolean
1304 _bfd_m32r_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
1305                                         asection *sec,
1306                                         int *retval)
1307 {
1308   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1309     {
1310       *retval = SHN_M32R_SCOMMON;
1311       return TRUE;
1312     }
1313   return FALSE;
1314 }
1315
1316 /* M32R ELF uses two common sections.  One is the usual one, and the other
1317    is for small objects.  All the small objects are kept together, and then
1318    referenced via one register, which yields faster assembler code.  It is
1319    up to the compiler to emit an instruction to load the register with
1320    _SDA_BASE.  This is what we use for the small common section.  This
1321    approach is copied from elf32-mips.c.  */
1322 static asection m32r_elf_scom_section;
1323 static asymbol m32r_elf_scom_symbol;
1324 static asymbol *m32r_elf_scom_symbol_ptr;
1325
1326 /* Handle the special M32R section numbers that a symbol may use.  */
1327
1328 static void
1329 _bfd_m32r_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
1330 {
1331   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
1332
1333   switch (elfsym->internal_elf_sym.st_shndx)
1334     {
1335     case SHN_M32R_SCOMMON:
1336       if (m32r_elf_scom_section.name == NULL)
1337         {
1338           /* Initialize the small common section.  */
1339           m32r_elf_scom_section.name = ".scommon";
1340           m32r_elf_scom_section.flags = SEC_IS_COMMON;
1341           m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
1342           m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
1343           m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
1344           m32r_elf_scom_symbol.name = ".scommon";
1345           m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
1346           m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
1347           m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
1348         }
1349       asym->section = &m32r_elf_scom_section;
1350       asym->value = elfsym->internal_elf_sym.st_size;
1351       break;
1352     }
1353 }
1354
1355 /* Hook called by the linker routine which adds symbols from an object
1356    file.  We must handle the special M32R section numbers here.
1357    We also keep watching for whether we need to create the sdata special
1358    linker sections.  */
1359
1360 static bfd_boolean
1361 m32r_elf_add_symbol_hook (bfd *abfd,
1362                           struct bfd_link_info *info,
1363                           Elf_Internal_Sym *sym,
1364                           const char **namep,
1365                           flagword *flagsp ATTRIBUTE_UNUSED,
1366                           asection **secp,
1367                           bfd_vma *valp)
1368 {
1369   if (! info->relocatable
1370       && (*namep)[0] == '_' && (*namep)[1] == 'S'
1371       && strcmp (*namep, "_SDA_BASE_") == 0
1372       && is_elf_hash_table (info->hash))
1373     {
1374       /* This is simpler than using _bfd_elf_create_linker_section
1375          (our needs are simpler than ppc's needs).  Also
1376          _bfd_elf_create_linker_section currently has a bug where if a .sdata
1377          section already exists a new one is created that follows it which
1378          screws of _SDA_BASE_ address calcs because output_offset != 0.  */
1379       struct elf_link_hash_entry *h;
1380       struct bfd_link_hash_entry *bh;
1381       asection *s = bfd_get_section_by_name (abfd, ".sdata");
1382
1383       /* The following code was cobbled from elf32-ppc.c and elflink.c.  */
1384       if (s == NULL)
1385         {
1386           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1387                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1388
1389           s = bfd_make_section_anyway_with_flags (abfd, ".sdata",
1390                                                   flags);
1391           if (s == NULL)
1392             return FALSE;
1393           bfd_set_section_alignment (abfd, s, 2);
1394         }
1395
1396       bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
1397                                  FALSE, FALSE, FALSE);
1398
1399       if ((bh == NULL || bh->type == bfd_link_hash_undefined)
1400           && !(_bfd_generic_link_add_one_symbol (info,
1401                                                  abfd,
1402                                                  "_SDA_BASE_",
1403                                                  BSF_GLOBAL,
1404                                                  s,
1405                                                  (bfd_vma) 32768,
1406                                                  NULL,
1407                                                  FALSE,
1408                                                  get_elf_backend_data (abfd)->collect,
1409                                                  &bh)))
1410         return FALSE;
1411       h = (struct elf_link_hash_entry *) bh;
1412       h->type = STT_OBJECT;
1413     }
1414
1415   switch (sym->st_shndx)
1416     {
1417     case SHN_M32R_SCOMMON:
1418       *secp = bfd_make_section_old_way (abfd, ".scommon");
1419       (*secp)->flags |= SEC_IS_COMMON;
1420       *valp = sym->st_size;
1421       break;
1422     }
1423
1424   return TRUE;
1425 }
1426
1427 /* We have to figure out the SDA_BASE value, so that we can adjust the
1428    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
1429    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1430    target data.  We don't need to adjust the symbol value for an
1431    external symbol if we are producing relocatable output.  */
1432
1433 static bfd_reloc_status_type
1434 m32r_elf_final_sda_base (bfd *output_bfd,
1435                          struct bfd_link_info *info,
1436                          const char **error_message,
1437                          bfd_vma *psb)
1438 {
1439   if (elf_gp (output_bfd) == 0)
1440     {
1441       struct bfd_link_hash_entry *h;
1442
1443       h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
1444       if (h != NULL && h->type == bfd_link_hash_defined)
1445         elf_gp (output_bfd) = (h->u.def.value
1446                                + h->u.def.section->output_section->vma
1447                                + h->u.def.section->output_offset);
1448       else
1449         {
1450           /* Only get the error once.  */
1451           *psb = elf_gp (output_bfd) = 4;
1452           *error_message =
1453             (const char *) _("SDA relocation when _SDA_BASE_ not defined");
1454           return bfd_reloc_dangerous;
1455         }
1456     }
1457   *psb = elf_gp (output_bfd);
1458   return bfd_reloc_ok;
1459 }
1460 \f
1461 /* Return size of a PLT entry.  */
1462 #define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE
1463
1464 /* The m32r linker needs to keep track of the number of relocs that it
1465    decides to copy in check_relocs for each symbol.  This is so that
1466    it can discard PC relative relocs if it doesn't need them when
1467    linking with -Bsymbolic.  We store the information in a field
1468    extending the regular ELF linker hash table.  */
1469
1470 /* This structure keeps track of the number of PC relative relocs we
1471    have copied for a given symbol.  */
1472
1473 struct elf_m32r_pcrel_relocs_copied
1474 {
1475   /* Next section.  */
1476   struct elf_m32r_pcrel_relocs_copied *next;
1477   /* A section in dynobj.  */
1478   asection *section;
1479   /* Number of relocs copied in this section.  */
1480   bfd_size_type count;
1481 };
1482
1483 /* The sh linker needs to keep track of the number of relocs that it
1484    decides to copy as dynamic relocs in check_relocs for each symbol.
1485    This is so that it can later discard them if they are found to be
1486    unnecessary.  We store the information in a field extending the
1487    regular ELF linker hash table.  */
1488
1489 struct elf_m32r_dyn_relocs
1490 {
1491   struct elf_m32r_dyn_relocs *next;
1492
1493   /* The input section of the reloc.  */
1494   asection *sec;
1495
1496   /* Total number of relocs copied for the input section.  */
1497   bfd_size_type count;
1498
1499   /* Number of pc-relative relocs copied for the input section.  */
1500   bfd_size_type pc_count;
1501 };
1502
1503
1504 /* m32r ELF linker hash entry.  */
1505
1506 struct elf_m32r_link_hash_entry
1507 {
1508   struct elf_link_hash_entry root;
1509
1510   /* Track dynamic relocs copied for this symbol.  */
1511   struct elf_m32r_dyn_relocs *dyn_relocs;
1512 };
1513
1514 /* m32r ELF linker hash table.  */
1515
1516 struct elf_m32r_link_hash_table
1517 {
1518   struct elf_link_hash_table root;
1519
1520   /* Short-cuts to get to dynamic linker sections.  */
1521   asection *sgot;
1522   asection *sgotplt;
1523   asection *srelgot;
1524   asection *splt;
1525   asection *srelplt;
1526   asection *sdynbss;
1527   asection *srelbss;
1528
1529   /* Small local sym cache.  */
1530   struct sym_cache sym_cache;
1531 };
1532
1533 /* Traverse an m32r ELF linker hash table.  */
1534
1535 #define m32r_elf_link_hash_traverse(table, func, info)                  \
1536   (elf_link_hash_traverse                                               \
1537    (&(table)->root,                                                     \
1538     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1539     (info)))
1540
1541 /* Get the m32r ELF linker hash table from a link_info structure.  */
1542
1543 #define m32r_elf_hash_table(p) \
1544   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1545   == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL)
1546
1547 /* Create an entry in an m32r ELF linker hash table.  */
1548
1549 static struct bfd_hash_entry *
1550 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551                             struct bfd_hash_table *table,
1552                             const char *string)
1553 {
1554   struct elf_m32r_link_hash_entry *ret =
1555     (struct elf_m32r_link_hash_entry *) entry;
1556
1557   /* Allocate the structure if it has not already been allocated by a
1558      subclass.  */
1559   if (ret == NULL)
1560     ret = bfd_hash_allocate (table,
1561                              sizeof (struct elf_m32r_link_hash_entry));
1562   if (ret == NULL)
1563     return NULL;
1564
1565   /* Call the allocation method of the superclass.  */
1566   ret = ((struct elf_m32r_link_hash_entry *)
1567          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568                                      table, string));
1569   if (ret != NULL)
1570     {
1571       struct elf_m32r_link_hash_entry *eh;
1572
1573       eh = (struct elf_m32r_link_hash_entry *) ret;
1574       eh->dyn_relocs = NULL;
1575     }
1576
1577   return (struct bfd_hash_entry *) ret;
1578 }
1579
1580 /* Create an m32r ELF linker hash table.  */
1581
1582 static struct bfd_link_hash_table *
1583 m32r_elf_link_hash_table_create (bfd *abfd)
1584 {
1585   struct elf_m32r_link_hash_table *ret;
1586   bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587
1588   ret = bfd_malloc (amt);
1589   if (ret == NULL)
1590     return NULL;
1591
1592   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1593                                       m32r_elf_link_hash_newfunc,
1594                                       sizeof (struct elf_m32r_link_hash_entry),
1595                                       M32R_ELF_DATA))
1596     {
1597       free (ret);
1598       return NULL;
1599     }
1600
1601   ret->sgot = NULL;
1602   ret->sgotplt = NULL;
1603   ret->srelgot = NULL;
1604   ret->splt = NULL;
1605   ret->srelplt = NULL;
1606   ret->sdynbss = NULL;
1607   ret->srelbss = NULL;
1608   ret->sym_cache.abfd = NULL;
1609
1610   return &ret->root.root;
1611 }
1612
1613 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1614    shortcuts to them in our hash table.  */
1615
1616 static bfd_boolean
1617 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1618 {
1619   struct elf_m32r_link_hash_table *htab;
1620
1621   if (! _bfd_elf_create_got_section (dynobj, info))
1622     return FALSE;
1623
1624   htab = m32r_elf_hash_table (info);
1625   if (htab == NULL)
1626     return FALSE;
1627
1628   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1629   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1630   htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1631   if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1632     abort ();
1633
1634   return TRUE;
1635 }
1636
1637 /* Create dynamic sections when linking against a dynamic object.  */
1638
1639 static bfd_boolean
1640 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1641 {
1642   struct elf_m32r_link_hash_table *htab;
1643   flagword flags, pltflags;
1644   asection *s;
1645   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1646   int ptralign = 2; /* 32bit */
1647
1648   htab = m32r_elf_hash_table (info);
1649   if (htab == NULL)
1650     return FALSE;
1651
1652   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1653      .rel[a].bss sections.  */
1654   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1655            | SEC_LINKER_CREATED);
1656
1657   pltflags = flags;
1658   pltflags |= SEC_CODE;
1659   if (bed->plt_not_loaded)
1660     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1661   if (bed->plt_readonly)
1662     pltflags |= SEC_READONLY;
1663
1664   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1665   htab->splt = s;
1666   if (s == NULL
1667       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1668     return FALSE;
1669
1670   if (bed->want_plt_sym)
1671     {
1672       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1673          .plt section.  */
1674       struct bfd_link_hash_entry *bh = NULL;
1675       struct elf_link_hash_entry *h;
1676
1677       if (! (_bfd_generic_link_add_one_symbol
1678              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1679               (bfd_vma) 0, NULL, FALSE,
1680               get_elf_backend_data (abfd)->collect, &bh)))
1681         return FALSE;
1682       h = (struct elf_link_hash_entry *) bh;
1683       h->def_regular = 1;
1684       h->type = STT_OBJECT;
1685       htab->root.hplt = h;
1686
1687       if (info->shared
1688           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1689         return FALSE;
1690     }
1691
1692   s = bfd_make_section_with_flags (abfd,
1693                                    bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1694                                    flags | SEC_READONLY);
1695   htab->srelplt = s;
1696   if (s == NULL
1697       || ! bfd_set_section_alignment (abfd, s, ptralign))
1698     return FALSE;
1699
1700   if (htab->sgot == NULL
1701       && ! create_got_section (abfd, info))
1702     return FALSE;
1703
1704   {
1705     const char *secname;
1706     char *relname;
1707     flagword secflags;
1708     asection *sec;
1709
1710     for (sec = abfd->sections; sec; sec = sec->next)
1711       {
1712         secflags = bfd_get_section_flags (abfd, sec);
1713         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1714             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1715           continue;
1716         secname = bfd_get_section_name (abfd, sec);
1717         relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1718         strcpy (relname, ".rela");
1719         strcat (relname, secname);
1720         if (bfd_get_section_by_name (abfd, secname))
1721           continue;
1722         s = bfd_make_section_with_flags (abfd, relname,
1723                                          flags | SEC_READONLY);
1724         if (s == NULL
1725             || ! bfd_set_section_alignment (abfd, s, ptralign))
1726           return FALSE;
1727       }
1728   }
1729
1730   if (bed->want_dynbss)
1731     {
1732       /* The .dynbss section is a place to put symbols which are defined
1733          by dynamic objects, are referenced by regular objects, and are
1734          not functions.  We must allocate space for them in the process
1735          image and use a R_*_COPY reloc to tell the dynamic linker to
1736          initialize them at run time.  The linker script puts the .dynbss
1737          section into the .bss section of the final image.  */
1738       s = bfd_make_section_with_flags (abfd, ".dynbss",
1739                                        SEC_ALLOC | SEC_LINKER_CREATED);
1740       htab->sdynbss = s;
1741       if (s == NULL)
1742         return FALSE;
1743       /* The .rel[a].bss section holds copy relocs.  This section is not
1744          normally needed.  We need to create it here, though, so that the
1745          linker will map it to an output section.  We can't just create it
1746          only if we need it, because we will not know whether we need it
1747          until we have seen all the input files, and the first time the
1748          main linker code calls BFD after examining all the input files
1749          (size_dynamic_sections) the input sections have already been
1750          mapped to the output sections.  If the section turns out not to
1751          be needed, we can discard it later.  We will never need this
1752          section when generating a shared object, since they do not use
1753          copy relocs.  */
1754       if (! info->shared)
1755         {
1756           s = bfd_make_section_with_flags (abfd,
1757                                            (bed->default_use_rela_p
1758                                             ? ".rela.bss" : ".rel.bss"),
1759                                            flags | SEC_READONLY);
1760           htab->srelbss = s;
1761           if (s == NULL
1762               || ! bfd_set_section_alignment (abfd, s, ptralign))
1763             return FALSE;
1764         }
1765     }
1766
1767   return TRUE;
1768 }
1769
1770 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1771
1772 static void
1773 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1774                                struct elf_link_hash_entry *dir,
1775                                struct elf_link_hash_entry *ind)
1776 {
1777   struct elf_m32r_link_hash_entry * edir;
1778   struct elf_m32r_link_hash_entry * eind;
1779
1780   edir = (struct elf_m32r_link_hash_entry *) dir;
1781   eind = (struct elf_m32r_link_hash_entry *) ind;
1782
1783   if (eind->dyn_relocs != NULL)
1784     {
1785       if (edir->dyn_relocs != NULL)
1786         {
1787           struct elf_m32r_dyn_relocs **pp;
1788           struct elf_m32r_dyn_relocs *p;
1789
1790           /* Add reloc counts against the indirect sym to the direct sym
1791              list.  Merge any entries against the same section.  */
1792           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1793             {
1794               struct elf_m32r_dyn_relocs *q;
1795
1796               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1797                 if (q->sec == p->sec)
1798                   {
1799                     q->pc_count += p->pc_count;
1800                     q->count += p->count;
1801                     *pp = p->next;
1802                     break;
1803                   }
1804               if (q == NULL)
1805                 pp = &p->next;
1806             }
1807           *pp = edir->dyn_relocs;
1808         }
1809
1810       edir->dyn_relocs = eind->dyn_relocs;
1811       eind->dyn_relocs = NULL;
1812     }
1813
1814   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1815 }
1816
1817 \f
1818 /* Adjust a symbol defined by a dynamic object and referenced by a
1819    regular object.  The current definition is in some section of the
1820    dynamic object, but we're not including those sections.  We have to
1821    change the definition to something the rest of the link can
1822    understand.  */
1823
1824 static bfd_boolean
1825 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1826                                 struct elf_link_hash_entry *h)
1827 {
1828   struct elf_m32r_link_hash_table *htab;
1829   struct elf_m32r_link_hash_entry *eh;
1830   struct elf_m32r_dyn_relocs *p;
1831   bfd *dynobj;
1832   asection *s;
1833
1834 #ifdef DEBUG_PIC
1835   printf ("m32r_elf_adjust_dynamic_symbol()\n");
1836 #endif
1837
1838   dynobj = elf_hash_table (info)->dynobj;
1839
1840   /* Make sure we know what is going on here.  */
1841   BFD_ASSERT (dynobj != NULL
1842               && (h->needs_plt
1843                   || h->u.weakdef != NULL
1844                   || (h->def_dynamic
1845                       && h->ref_regular
1846                       && !h->def_regular)));
1847
1848   /* If this is a function, put it in the procedure linkage table.  We
1849      will fill in the contents of the procedure linkage table later,
1850      when we know the address of the .got section.  */
1851   if (h->type == STT_FUNC
1852       || h->needs_plt)
1853     {
1854       if (! info->shared
1855           && !h->def_dynamic
1856           && !h->ref_dynamic
1857           && h->root.type != bfd_link_hash_undefweak
1858           && h->root.type != bfd_link_hash_undefined)
1859         {
1860           /* This case can occur if we saw a PLT reloc in an input
1861              file, but the symbol was never referred to by a dynamic
1862              object.  In such a case, we don't actually need to build
1863              a procedure linkage table, and we can just do a PCREL
1864              reloc instead.  */
1865           h->plt.offset = (bfd_vma) -1;
1866           h->needs_plt = 0;
1867         }
1868
1869       return TRUE;
1870     }
1871   else
1872     h->plt.offset = (bfd_vma) -1;
1873
1874   /* If this is a weak symbol, and there is a real definition, the
1875      processor independent code will have arranged for us to see the
1876      real definition first, and we can just use the same value.  */
1877   if (h->u.weakdef != NULL)
1878     {
1879       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1880                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1881       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1882       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1883       return TRUE;
1884     }
1885
1886   /* This is a reference to a symbol defined by a dynamic object which
1887      is not a function.  */
1888
1889   /* If we are creating a shared library, we must presume that the
1890      only references to the symbol are via the global offset table.
1891      For such cases we need not do anything here; the relocations will
1892      be handled correctly by relocate_section.  */
1893   if (info->shared)
1894     return TRUE;
1895
1896   /* If there are no references to this symbol that do not use the
1897      GOT, we don't need to generate a copy reloc.  */
1898   if (!h->non_got_ref)
1899     return TRUE;
1900
1901   /* If -z nocopyreloc was given, we won't generate them either.  */
1902   if (info->nocopyreloc)
1903     {
1904       h->non_got_ref = 0;
1905       return TRUE;
1906     }
1907
1908   eh = (struct elf_m32r_link_hash_entry *) h;
1909   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1910     {
1911       s = p->sec->output_section;
1912       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1913         break;
1914     }
1915
1916   /* If we didn't find any dynamic relocs in sections which needs the
1917      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1918      the copy reloc.  */
1919   if (p == NULL)
1920     {
1921       h->non_got_ref = 0;
1922       return TRUE;
1923     }
1924
1925   if (h->size == 0)
1926     {
1927       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1928                              h->root.root.string);
1929       return TRUE;
1930     }
1931
1932   /* We must allocate the symbol in our .dynbss section, which will
1933      become part of the .bss section of the executable.  There will be
1934      an entry for this symbol in the .dynsym section.  The dynamic
1935      object will contain position independent code, so all references
1936      from the dynamic object to this symbol will go through the global
1937      offset table.  The dynamic linker will use the .dynsym entry to
1938      determine the address it must put in the global offset table, so
1939      both the dynamic object and the regular object will refer to the
1940      same memory location for the variable.  */
1941
1942   htab = m32r_elf_hash_table (info);
1943   if (htab == NULL)
1944     return FALSE;
1945
1946   s = htab->sdynbss;
1947   BFD_ASSERT (s != NULL);
1948
1949   /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1950      to copy the initial value out of the dynamic object and into the
1951      runtime process image.  We need to remember the offset into the
1952      .rela.bss section we are going to use.  */
1953   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1954     {
1955       asection *srel;
1956
1957       srel = htab->srelbss;
1958       BFD_ASSERT (srel != NULL);
1959       srel->size += sizeof (Elf32_External_Rela);
1960       h->needs_copy = 1;
1961     }
1962
1963   return _bfd_elf_adjust_dynamic_copy (h, s);
1964 }
1965
1966 /* Allocate space in .plt, .got and associated reloc sections for
1967    dynamic relocs.  */
1968
1969 static bfd_boolean
1970 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1971 {
1972   struct bfd_link_info *info;
1973   struct elf_m32r_link_hash_table *htab;
1974   struct elf_m32r_link_hash_entry *eh;
1975   struct elf_m32r_dyn_relocs *p;
1976
1977   if (h->root.type == bfd_link_hash_indirect)
1978     return TRUE;
1979
1980   if (h->root.type == bfd_link_hash_warning)
1981     /* When warning symbols are created, they **replace** the "real"
1982        entry in the hash table, thus we never get to see the real
1983        symbol in a hash traversal.  So look at it now.  */
1984     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1985
1986   info = (struct bfd_link_info *) inf;
1987   htab = m32r_elf_hash_table (info);
1988   if (htab == NULL)
1989     return FALSE;
1990
1991   eh = (struct elf_m32r_link_hash_entry *) h;
1992
1993   if (htab->root.dynamic_sections_created
1994       && h->plt.refcount > 0)
1995     {
1996       /* Make sure this symbol is output as a dynamic symbol.
1997          Undefined weak syms won't yet be marked as dynamic.  */
1998       if (h->dynindx == -1
1999           && !h->forced_local)
2000         {
2001           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2002             return FALSE;
2003         }
2004
2005       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2006         {
2007           asection *s = htab->splt;
2008
2009           /* If this is the first .plt entry, make room for the special
2010              first entry.  */
2011           if (s->size == 0)
2012             s->size += PLT_ENTRY_SIZE;
2013
2014           h->plt.offset = s->size;
2015
2016           /* If this symbol is not defined in a regular file, and we are
2017              not generating a shared library, then set the symbol to this
2018              location in the .plt.  This is required to make function
2019              pointers compare as equal between the normal executable and
2020              the shared library.  */
2021           if (! info->shared
2022               && !h->def_regular)
2023             {
2024               h->root.u.def.section = s;
2025               h->root.u.def.value = h->plt.offset;
2026             }
2027
2028           /* Make room for this entry.  */
2029           s->size += PLT_ENTRY_SIZE;
2030
2031           /* We also need to make an entry in the .got.plt section, which
2032              will be placed in the .got section by the linker script.  */
2033           htab->sgotplt->size += 4;
2034
2035           /* We also need to make an entry in the .rel.plt section.  */
2036           htab->srelplt->size += sizeof (Elf32_External_Rela);
2037         }
2038       else
2039         {
2040           h->plt.offset = (bfd_vma) -1;
2041           h->needs_plt = 0;
2042         }
2043     }
2044   else
2045     {
2046       h->plt.offset = (bfd_vma) -1;
2047       h->needs_plt = 0;
2048     }
2049
2050   if (h->got.refcount > 0)
2051     {
2052       asection *s;
2053       bfd_boolean dyn;
2054
2055       /* Make sure this symbol is output as a dynamic symbol.
2056          Undefined weak syms won't yet be marked as dynamic.  */
2057       if (h->dynindx == -1
2058           && !h->forced_local)
2059         {
2060           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2061             return FALSE;
2062         }
2063
2064       s = htab->sgot;
2065
2066       h->got.offset = s->size;
2067       s->size += 4;
2068       dyn = htab->root.dynamic_sections_created;
2069       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2070         htab->srelgot->size += sizeof (Elf32_External_Rela);
2071     }
2072   else
2073     h->got.offset = (bfd_vma) -1;
2074
2075   if (eh->dyn_relocs == NULL)
2076     return TRUE;
2077
2078   /* In the shared -Bsymbolic case, discard space allocated for
2079      dynamic pc-relative relocs against symbols which turn out to be
2080      defined in regular objects.  For the normal shared case, discard
2081      space for pc-relative relocs that have become local due to symbol
2082      visibility changes.  */
2083
2084   if (info->shared)
2085     {
2086       if (h->def_regular
2087           && (h->forced_local
2088               || info->symbolic))
2089         {
2090           struct elf_m32r_dyn_relocs **pp;
2091
2092           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2093             {
2094               p->count -= p->pc_count;
2095               p->pc_count = 0;
2096               if (p->count == 0)
2097                 *pp = p->next;
2098               else
2099                 pp = &p->next;
2100             }
2101         }
2102
2103       /* Also discard relocs on undefined weak syms with non-default
2104          visibility.  */
2105       if (eh->dyn_relocs != NULL
2106           && h->root.type == bfd_link_hash_undefweak)
2107         {
2108           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2109             eh->dyn_relocs = NULL;
2110
2111           /* Make sure undefined weak symbols are output as a dynamic
2112              symbol in PIEs.  */
2113           else if (h->dynindx == -1
2114                    && !h->forced_local)
2115             {
2116               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2117                 return FALSE;
2118             }
2119         }
2120     }
2121   else
2122     {
2123       /* For the non-shared case, discard space for relocs against
2124          symbols which turn out to need copy relocs or are not
2125          dynamic.  */
2126
2127       if (!h->non_got_ref
2128           && ((h->def_dynamic
2129                && !h->def_regular)
2130               || (htab->root.dynamic_sections_created
2131                   && (h->root.type == bfd_link_hash_undefweak
2132                       || h->root.type == bfd_link_hash_undefined))))
2133         {
2134           /* Make sure this symbol is output as a dynamic symbol.
2135              Undefined weak syms won't yet be marked as dynamic.  */
2136           if (h->dynindx == -1
2137               && !h->forced_local)
2138             {
2139               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2140                 return FALSE;
2141             }
2142
2143           /* If that succeeded, we know we'll be keeping all the
2144              relocs.  */
2145           if (h->dynindx != -1)
2146             goto keep;
2147         }
2148
2149       eh->dyn_relocs = NULL;
2150
2151     keep: ;
2152     }
2153
2154   /* Finally, allocate space.  */
2155   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2156     {
2157       asection *sreloc = elf_section_data (p->sec)->sreloc;
2158       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2159     }
2160
2161   return TRUE;
2162 }
2163
2164 /* Find any dynamic relocs that apply to read-only sections.  */
2165
2166 static bfd_boolean
2167 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2168 {
2169   struct elf_m32r_link_hash_entry *eh;
2170   struct elf_m32r_dyn_relocs *p;
2171
2172   if (h->root.type == bfd_link_hash_warning)
2173     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2174
2175   eh = (struct elf_m32r_link_hash_entry *) h;
2176   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2177     {
2178       asection *s = p->sec->output_section;
2179
2180       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2181         {
2182           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2183
2184           info->flags |= DF_TEXTREL;
2185
2186           /* Not an error, just cut short the traversal.  */
2187           return FALSE;
2188         }
2189     }
2190   return TRUE;
2191 }
2192
2193 /* Set the sizes of the dynamic sections.  */
2194
2195 static bfd_boolean
2196 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2197                                 struct bfd_link_info *info)
2198 {
2199   struct elf_m32r_link_hash_table *htab;
2200   bfd *dynobj;
2201   asection *s;
2202   bfd_boolean relocs;
2203   bfd *ibfd;
2204
2205 #ifdef DEBUG_PIC
2206   printf ("m32r_elf_size_dynamic_sections()\n");
2207 #endif
2208
2209   htab = m32r_elf_hash_table (info);
2210   if (htab == NULL)
2211     return FALSE;
2212
2213   dynobj = htab->root.dynobj;
2214   BFD_ASSERT (dynobj != NULL);
2215
2216   if (htab->root.dynamic_sections_created)
2217     {
2218       /* Set the contents of the .interp section to the interpreter.  */
2219       if (info->executable)
2220         {
2221           s = bfd_get_section_by_name (dynobj, ".interp");
2222           BFD_ASSERT (s != NULL);
2223           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2224           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2225         }
2226     }
2227
2228   /* Set up .got offsets for local syms, and space for local dynamic
2229      relocs.  */
2230   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2231     {
2232       bfd_signed_vma *local_got;
2233       bfd_signed_vma *end_local_got;
2234       bfd_size_type locsymcount;
2235       Elf_Internal_Shdr *symtab_hdr;
2236       asection *srel;
2237
2238       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2239         continue;
2240
2241       for (s = ibfd->sections; s != NULL; s = s->next)
2242         {
2243           struct elf_m32r_dyn_relocs *p;
2244
2245           for (p = ((struct elf_m32r_dyn_relocs *)
2246                     elf_section_data (s)->local_dynrel);
2247                p != NULL;
2248                p = p->next)
2249             {
2250               if (! bfd_is_abs_section (p->sec)
2251                   && bfd_is_abs_section (p->sec->output_section))
2252                 {
2253                   /* Input section has been discarded, either because
2254                      it is a copy of a linkonce section or due to
2255                      linker script /DISCARD/, so we'll be discarding
2256                      the relocs too.  */
2257                 }
2258               else if (p->count != 0)
2259                 {
2260                   srel = elf_section_data (p->sec)->sreloc;
2261                   srel->size += p->count * sizeof (Elf32_External_Rela);
2262                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2263                     info->flags |= DF_TEXTREL;
2264                 }
2265             }
2266         }
2267
2268       local_got = elf_local_got_refcounts (ibfd);
2269       if (!local_got)
2270         continue;
2271
2272       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2273       locsymcount = symtab_hdr->sh_info;
2274       end_local_got = local_got + locsymcount;
2275       s = htab->sgot;
2276       srel = htab->srelgot;
2277       for (; local_got < end_local_got; ++local_got)
2278         {
2279           if (*local_got > 0)
2280             {
2281               *local_got = s->size;
2282               s->size += 4;
2283               if (info->shared)
2284                 srel->size += sizeof (Elf32_External_Rela);
2285             }
2286           else
2287             *local_got = (bfd_vma) -1;
2288         }
2289     }
2290
2291   /* Allocate global sym .plt and .got entries, and space for global
2292      sym dynamic relocs.  */
2293   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2294
2295   /* We now have determined the sizes of the various dynamic sections.
2296      Allocate memory for them.  */
2297   relocs = FALSE;
2298   for (s = dynobj->sections; s != NULL; s = s->next)
2299     {
2300       if ((s->flags & SEC_LINKER_CREATED) == 0)
2301         continue;
2302
2303       if (s == htab->splt
2304           || s == htab->sgot
2305           || s == htab->sgotplt
2306           || s == htab->sdynbss)
2307         {
2308           /* Strip this section if we don't need it; see the
2309              comment below.  */
2310         }
2311       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2312         {
2313           if (s->size != 0 && s != htab->srelplt)
2314             relocs = TRUE;
2315
2316           /* We use the reloc_count field as a counter if we need
2317              to copy relocs into the output file.  */
2318           s->reloc_count = 0;
2319         }
2320       else
2321         /* It's not one of our sections, so don't allocate space.  */
2322         continue;
2323
2324       if (s->size == 0)
2325         {
2326           /* If we don't need this section, strip it from the
2327              output file.  This is mostly to handle .rela.bss and
2328              .rela.plt.  We must create both sections in
2329              create_dynamic_sections, because they must be created
2330              before the linker maps input sections to output
2331              sections.  The linker does that before
2332              adjust_dynamic_symbol is called, and it is that
2333              function which decides whether anything needs to go
2334              into these sections.  */
2335           s->flags |= SEC_EXCLUDE;
2336           continue;
2337         }
2338
2339       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2340         continue;
2341
2342       /* Allocate memory for the section contents.  We use bfd_zalloc
2343          here in case unused entries are not reclaimed before the
2344          section's contents are written out.  This should not happen,
2345          but this way if it does, we get a R_M32R_NONE reloc instead
2346          of garbage.  */
2347       s->contents = bfd_zalloc (dynobj, s->size);
2348       if (s->contents == NULL)
2349         return FALSE;
2350     }
2351
2352   if (htab->root.dynamic_sections_created)
2353     {
2354       /* Add some entries to the .dynamic section.  We fill in the
2355          values later, in m32r_elf_finish_dynamic_sections, but we
2356          must add the entries now so that we get the correct size for
2357          the .dynamic section.  The DT_DEBUG entry is filled in by the
2358          dynamic linker and used by the debugger.  */
2359 #define add_dynamic_entry(TAG, VAL) \
2360   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2361
2362      if (info->executable)
2363         {
2364           if (! add_dynamic_entry (DT_DEBUG, 0))
2365             return FALSE;
2366         }
2367
2368       if (htab->splt->size != 0)
2369         {
2370           if (! add_dynamic_entry (DT_PLTGOT, 0)
2371               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2372               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2373               || ! add_dynamic_entry (DT_JMPREL, 0))
2374             return FALSE;
2375         }
2376
2377       if (relocs)
2378         {
2379           if (! add_dynamic_entry (DT_RELA, 0)
2380               || ! add_dynamic_entry (DT_RELASZ, 0)
2381               || ! add_dynamic_entry (DT_RELAENT,
2382                                       sizeof (Elf32_External_Rela)))
2383             return FALSE;
2384
2385           /* If any dynamic relocs apply to a read-only section,
2386              then we need a DT_TEXTREL entry.  */
2387           if ((info->flags & DF_TEXTREL) == 0)
2388             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2389                                     info);
2390
2391           if ((info->flags & DF_TEXTREL) != 0)
2392             {
2393               if (! add_dynamic_entry (DT_TEXTREL, 0))
2394                 return FALSE;
2395             }
2396         }
2397     }
2398 #undef add_dynamic_entry
2399
2400   return TRUE;
2401 }
2402
2403 /* Relocate an M32R/D ELF section.
2404    There is some attempt to make this function usable for many architectures,
2405    both for RELA and REL type relocs, if only to serve as a learning tool.
2406
2407    The RELOCATE_SECTION function is called by the new ELF backend linker
2408    to handle the relocations for a section.
2409
2410    The relocs are always passed as Rela structures; if the section
2411    actually uses Rel structures, the r_addend field will always be
2412    zero.
2413
2414    This function is responsible for adjust the section contents as
2415    necessary, and (if using Rela relocs and generating a
2416    relocatable output file) adjusting the reloc addend as
2417    necessary.
2418
2419    This function does not have to worry about setting the reloc
2420    address or the reloc symbol index.
2421
2422    LOCAL_SYMS is a pointer to the swapped in local symbols.
2423
2424    LOCAL_SECTIONS is an array giving the section in the input file
2425    corresponding to the st_shndx field of each local symbol.
2426
2427    The global hash table entry for the global symbols can be found
2428    via elf_sym_hashes (input_bfd).
2429
2430    When generating relocatable output, this function must handle
2431    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2432    going to be the section symbol corresponding to the output
2433    section, which means that the addend must be adjusted
2434    accordingly.  */
2435
2436 static bfd_boolean
2437 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2438                            struct bfd_link_info *info,
2439                            bfd *input_bfd,
2440                            asection *input_section,
2441                            bfd_byte *contents,
2442                            Elf_Internal_Rela *relocs,
2443                            Elf_Internal_Sym *local_syms,
2444                            asection **local_sections)
2445 {
2446   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2447   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2448   Elf_Internal_Rela *rel, *relend;
2449   /* Assume success.  */
2450   bfd_boolean ret = TRUE;
2451   struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2452   bfd *dynobj;
2453   bfd_vma *local_got_offsets;
2454   asection *sgot, *splt, *sreloc;
2455   bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2456
2457   if (htab == NULL)
2458     return FALSE;
2459
2460   dynobj = htab->root.dynobj;
2461   local_got_offsets = elf_local_got_offsets (input_bfd);
2462
2463   sgot = htab->sgot;
2464   splt = htab->splt;
2465   sreloc = NULL;
2466
2467   rel = relocs;
2468   relend = relocs + input_section->reloc_count;
2469   for (; rel < relend; rel++)
2470     {
2471       int r_type;
2472       reloc_howto_type *howto;
2473       unsigned long r_symndx;
2474       struct elf_link_hash_entry *h;
2475       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2476          ensure it's zero (we use REL relocs, not RELA).  Therefore this
2477          should be assigning zero to `addend', but for clarity we use
2478          `r_addend'.  */
2479       bfd_vma addend = rel->r_addend;
2480       bfd_vma offset = rel->r_offset;
2481       bfd_vma relocation;
2482       Elf_Internal_Sym *sym;
2483       asection *sec;
2484       const char *sym_name;
2485       bfd_reloc_status_type r;
2486       const char *errmsg = NULL;
2487       bfd_boolean use_rel = FALSE;
2488
2489       h = NULL;
2490       r_type = ELF32_R_TYPE (rel->r_info);
2491       if (r_type < 0 || r_type >= (int) R_M32R_max)
2492         {
2493           (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2494                                  input_bfd,
2495                                  (int) r_type);
2496           bfd_set_error (bfd_error_bad_value);
2497           ret = FALSE;
2498           continue;
2499         }
2500
2501       if (   r_type == R_M32R_GNU_VTENTRY
2502           || r_type == R_M32R_GNU_VTINHERIT
2503           || r_type == R_M32R_NONE
2504           || r_type == R_M32R_RELA_GNU_VTENTRY
2505           || r_type == R_M32R_RELA_GNU_VTINHERIT)
2506         continue;
2507
2508       if (r_type <= R_M32R_GNU_VTENTRY)
2509         use_rel = TRUE;
2510
2511       howto = m32r_elf_howto_table + r_type;
2512       r_symndx = ELF32_R_SYM (rel->r_info);
2513
2514       sym = NULL;
2515       sec = NULL;
2516       h = NULL;
2517
2518       if (r_symndx < symtab_hdr->sh_info)
2519         {
2520           /* Local symbol.  */
2521           sym = local_syms + r_symndx;
2522           sec = local_sections[r_symndx];
2523           sym_name = "<local symbol>";
2524
2525           if (!use_rel)
2526             {
2527               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2528               addend = rel->r_addend;
2529             }
2530           else
2531             {
2532               relocation = (sec->output_section->vma
2533                             + sec->output_offset
2534                             + sym->st_value);
2535             }
2536         }
2537       else
2538         {
2539           /* External symbol.  */
2540           relocation = 0;
2541
2542           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2543           while (h->root.type == bfd_link_hash_indirect
2544                  || h->root.type == bfd_link_hash_warning)
2545             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2546           sym_name = h->root.root.string;
2547
2548           if (h->root.type == bfd_link_hash_defined
2549               || h->root.type == bfd_link_hash_defweak)
2550             {
2551               bfd_boolean dyn;
2552               sec = h->root.u.def.section;
2553
2554               dyn = htab->root.dynamic_sections_created;
2555               sec = h->root.u.def.section;
2556               if (r_type == R_M32R_GOTPC24
2557                   || (r_type == R_M32R_GOTPC_HI_ULO
2558                       || r_type == R_M32R_GOTPC_HI_SLO
2559                       || r_type == R_M32R_GOTPC_LO)
2560                   || (r_type == R_M32R_26_PLTREL
2561                       && h->plt.offset != (bfd_vma) -1)
2562                   || ((r_type == R_M32R_GOT24
2563                        || r_type == R_M32R_GOT16_HI_ULO
2564                        || r_type == R_M32R_GOT16_HI_SLO
2565                        || r_type == R_M32R_GOT16_LO)
2566                       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2567                                                           info->shared, h)
2568                       && (! info->shared
2569                           || (! info->symbolic && h->dynindx != -1)
2570                           || !h->def_regular))
2571                   || (info->shared
2572                       && ((! info->symbolic && h->dynindx != -1)
2573                           || !h->def_regular)
2574                       && (((r_type == R_M32R_16_RELA
2575                             || r_type == R_M32R_32_RELA
2576                             || r_type == R_M32R_24_RELA
2577                             || r_type == R_M32R_HI16_ULO_RELA
2578                             || r_type == R_M32R_HI16_SLO_RELA
2579                             || r_type == R_M32R_LO16_RELA)
2580                            && !h->forced_local)
2581                           || r_type == R_M32R_REL32
2582                           || r_type == R_M32R_10_PCREL_RELA
2583                           || r_type == R_M32R_18_PCREL_RELA
2584                           || r_type == R_M32R_26_PCREL_RELA)
2585                       && ((input_section->flags & SEC_ALLOC) != 0
2586                           /* DWARF will emit R_M32R_16(24,32) relocations
2587                              in its sections against symbols defined
2588                              externally in shared libraries.  We can't do
2589                              anything with them here.  */
2590                           || ((input_section->flags & SEC_DEBUGGING) != 0
2591                               && h->def_dynamic))))
2592                 {
2593                   /* In these cases, we don't need the relocation
2594                      value.  We check specially because in some
2595                      obscure cases sec->output_section will be NULL.  */
2596                 }
2597               else if (sec->output_section != NULL)
2598                 relocation = (h->root.u.def.value
2599                               + sec->output_section->vma
2600                               + sec->output_offset);
2601               else if (!info->relocatable)
2602                 {
2603                   (*_bfd_error_handler)
2604                     (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2605                      input_bfd,
2606                      input_section,
2607                      (long) rel->r_offset,
2608                      howto->name,
2609                      h->root.root.string);
2610                 }
2611             }
2612           else if (h->root.type == bfd_link_hash_undefweak)
2613             ;
2614           else if (info->unresolved_syms_in_objects == RM_IGNORE
2615                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2616             ;
2617           else if (!info->relocatable)
2618             {
2619               if (! ((*info->callbacks->undefined_symbol)
2620                      (info, h->root.root.string, input_bfd,
2621                       input_section, offset,
2622                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2623                        || ELF_ST_VISIBILITY (h->other)))))
2624                 return FALSE;
2625             }
2626         }
2627
2628       if (sec != NULL && elf_discarded_section (sec))
2629         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2630                                          rel, relend, howto, contents);
2631
2632       if (info->relocatable && !use_rel)
2633         {
2634           /* This is a relocatable link.  We don't have to change
2635              anything, unless the reloc is against a section symbol,
2636              in which case we have to adjust according to where the
2637              section symbol winds up in the output section.  */
2638           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2639             rel->r_addend += sec->output_offset;
2640           continue;
2641         }
2642
2643       if (info->relocatable && use_rel)
2644         {
2645           /* This is a relocatable link.  We don't have to change
2646              anything, unless the reloc is against a section symbol,
2647              in which case we have to adjust according to where the
2648              section symbol winds up in the output section.  */
2649           if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2650             continue;
2651
2652           addend += sec->output_offset;
2653
2654           /* If partial_inplace, we need to store any additional addend
2655              back in the section.  */
2656           if (! howto->partial_inplace)
2657             continue;
2658           /* ??? Here is a nice place to call a special_function
2659              like handler.  */
2660           if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2661             r = _bfd_relocate_contents (howto, input_bfd,
2662                                         addend, contents + offset);
2663           else
2664             {
2665               Elf_Internal_Rela *lorel;
2666
2667               /* We allow an arbitrary number of HI16 relocs before the
2668                  LO16 reloc.  This permits gcc to emit the HI and LO relocs
2669                  itself.  */
2670               for (lorel = rel + 1;
2671                    (lorel < relend
2672                     && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2673                         || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2674                    lorel++)
2675                 continue;
2676               if (lorel < relend
2677                   && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2678                 {
2679                   m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2680                                           contents, addend);
2681                   r = bfd_reloc_ok;
2682                 }
2683               else
2684                 r = _bfd_relocate_contents (howto, input_bfd,
2685                                             addend, contents + offset);
2686             }
2687         }
2688       else
2689         {
2690           /* Sanity check the address.  */
2691           if (offset > high_address)
2692             {
2693               r = bfd_reloc_outofrange;
2694               goto check_reloc;
2695             }
2696
2697           switch ((int) r_type)
2698             {
2699             case R_M32R_GOTOFF:
2700               /* Relocation is relative to the start of the global offset
2701                  table (for ld24 rx, #uimm24). eg access at label+addend
2702
2703                  ld24 rx. #label@GOTOFF + addend
2704                  sub  rx, r12.  */
2705
2706               BFD_ASSERT (sgot != NULL);
2707
2708               relocation = -(relocation - sgot->output_section->vma);
2709               rel->r_addend = -rel->r_addend;
2710               break;
2711
2712             case R_M32R_GOTOFF_HI_ULO:
2713             case R_M32R_GOTOFF_HI_SLO:
2714             case R_M32R_GOTOFF_LO:
2715               BFD_ASSERT (sgot != NULL);
2716
2717               relocation -= sgot->output_section->vma;
2718
2719               if ((r_type == R_M32R_GOTOFF_HI_SLO)
2720                   && ((relocation + rel->r_addend) & 0x8000))
2721                 rel->r_addend += 0x10000;
2722               break;
2723
2724             case R_M32R_GOTPC24:
2725               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2726                  ld24 rx,#_GLOBAL_OFFSET_TABLE_
2727                */
2728              relocation = sgot->output_section->vma;
2729              break;
2730
2731             case R_M32R_GOTPC_HI_ULO:
2732             case R_M32R_GOTPC_HI_SLO:
2733             case R_M32R_GOTPC_LO:
2734               {
2735                 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2736                    bl .+4
2737                    seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2738                    or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2739                    or
2740                    bl .+4
2741                    seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2742                    add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2743                  */
2744                 relocation = sgot->output_section->vma;
2745                 relocation -= (input_section->output_section->vma
2746                                + input_section->output_offset
2747                                + rel->r_offset);
2748                 if ((r_type == R_M32R_GOTPC_HI_SLO)
2749                      && ((relocation + rel->r_addend) & 0x8000))
2750                   rel->r_addend += 0x10000;
2751
2752                 break;
2753               }
2754             case R_M32R_GOT16_HI_ULO:
2755             case R_M32R_GOT16_HI_SLO:
2756             case R_M32R_GOT16_LO:
2757               /* Fall through.  */
2758             case R_M32R_GOT24:
2759               /* Relocation is to the entry for this symbol in the global
2760                  offset table.  */
2761               BFD_ASSERT (sgot != NULL);
2762
2763               if (h != NULL)
2764                 {
2765                   bfd_boolean dyn;
2766                   bfd_vma off;
2767
2768                   off = h->got.offset;
2769                   BFD_ASSERT (off != (bfd_vma) -1);
2770
2771                   dyn = htab->root.dynamic_sections_created;
2772                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2773                       || (info->shared
2774                           && (info->symbolic
2775                               || h->dynindx == -1
2776                               || h->forced_local)
2777                           && h->def_regular))
2778                     {
2779                       /* This is actually a static link, or it is a
2780                          -Bsymbolic link and the symbol is defined
2781                          locally, or the symbol was forced to be local
2782                          because of a version file.  We must initialize
2783                          this entry in the global offset table.  Since the
2784                          offset must always be a multiple of 4, we use the
2785                          least significant bit to record whether we have
2786                          initialized it already.
2787
2788                          When doing a dynamic link, we create a .rela.got
2789                          relocation entry to initialize the value.  This
2790                          is done in the finish_dynamic_symbol routine.  */
2791                       if ((off & 1) != 0)
2792                         off &= ~1;
2793                       else
2794                         {
2795                           bfd_put_32 (output_bfd, relocation,
2796                                       sgot->contents + off);
2797                           h->got.offset |= 1;
2798                         }
2799                     }
2800
2801                   relocation = sgot->output_offset + off;
2802                 }
2803               else
2804                 {
2805                   bfd_vma off;
2806                   bfd_byte *loc;
2807
2808                   BFD_ASSERT (local_got_offsets != NULL
2809                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
2810
2811                   off = local_got_offsets[r_symndx];
2812
2813                   /* The offset must always be a multiple of 4.  We use
2814                      the least significant bit to record whether we have
2815                      already processed this entry.  */
2816                   if ((off & 1) != 0)
2817                     off &= ~1;
2818                   else
2819                     {
2820                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2821
2822                       if (info->shared)
2823                         {
2824                           asection *srelgot;
2825                           Elf_Internal_Rela outrel;
2826
2827                           /* We need to generate a R_M32R_RELATIVE reloc
2828                              for the dynamic linker.  */
2829                           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2830                           BFD_ASSERT (srelgot != NULL);
2831
2832                           outrel.r_offset = (sgot->output_section->vma
2833                                              + sgot->output_offset
2834                                              + off);
2835                           outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2836                           outrel.r_addend = relocation;
2837                           loc = srelgot->contents;
2838                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2839                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2840                           ++srelgot->reloc_count;
2841                         }
2842
2843                       local_got_offsets[r_symndx] |= 1;
2844                     }
2845
2846                   relocation = sgot->output_offset + off;
2847                 }
2848               if ((r_type == R_M32R_GOT16_HI_SLO)
2849                   && ((relocation + rel->r_addend) & 0x8000))
2850                 rel->r_addend += 0x10000;
2851
2852               break;
2853
2854             case R_M32R_26_PLTREL:
2855               /* Relocation is to the entry for this symbol in the
2856                  procedure linkage table.  */
2857
2858               /* The native assembler will generate a 26_PLTREL reloc
2859                  for a local symbol if you assemble a call from one
2860                  section to another when using -K pic. */
2861               if (h == NULL)
2862                 break;
2863
2864               if (h->forced_local)
2865                 break;
2866
2867               if (h->plt.offset == (bfd_vma) -1)
2868                 /* We didn't make a PLT entry for this symbol.  This
2869                    happens when statically linking PIC code, or when
2870                    using -Bsymbolic.  */
2871                 break;
2872
2873               relocation = (splt->output_section->vma
2874                             + splt->output_offset
2875                             + h->plt.offset);
2876               break;
2877
2878             case R_M32R_HI16_SLO_RELA:
2879               if ((relocation + rel->r_addend) & 0x8000)
2880                 rel->r_addend += 0x10000;
2881               /* Fall through.  */
2882
2883             case R_M32R_16_RELA:
2884             case R_M32R_24_RELA:
2885             case R_M32R_32_RELA:
2886             case R_M32R_REL32:
2887             case R_M32R_10_PCREL_RELA:
2888             case R_M32R_18_PCREL_RELA:
2889             case R_M32R_26_PCREL_RELA:
2890             case R_M32R_HI16_ULO_RELA:
2891             case R_M32R_LO16_RELA:
2892               if (info->shared
2893                   && r_symndx != STN_UNDEF
2894                   && (input_section->flags & SEC_ALLOC) != 0
2895                   && ((   r_type != R_M32R_10_PCREL_RELA
2896                        && r_type != R_M32R_18_PCREL_RELA
2897                        && r_type != R_M32R_26_PCREL_RELA
2898                        && r_type != R_M32R_REL32)
2899                       || (h != NULL
2900                           && h->dynindx != -1
2901                           && (! info->symbolic
2902                               || !h->def_regular))))
2903                 {
2904                   Elf_Internal_Rela outrel;
2905                   bfd_boolean skip, relocate;
2906                   bfd_byte *loc;
2907
2908                   /* When generating a shared object, these relocations
2909                      are copied into the output file to be resolved at run
2910                      time.  */
2911                   if (sreloc == NULL)
2912                     {
2913                       sreloc = _bfd_elf_get_dynamic_reloc_section
2914                         (input_bfd, input_section, /*rela?*/ TRUE);
2915                       if (sreloc == NULL)
2916                         return FALSE;
2917                     }
2918
2919                   skip = FALSE;
2920                   relocate = FALSE;
2921
2922                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2923                                                              info,
2924                                                              input_section,
2925                                                              rel->r_offset);
2926                   if (outrel.r_offset == (bfd_vma) -1)
2927                     skip = TRUE;
2928                   else if (outrel.r_offset == (bfd_vma) -2)
2929                     skip = relocate = TRUE;
2930                   outrel.r_offset += (input_section->output_section->vma
2931                                       + input_section->output_offset);
2932
2933                   if (skip)
2934                     memset (&outrel, 0, sizeof outrel);
2935                   else if (   r_type == R_M32R_10_PCREL_RELA
2936                            || r_type == R_M32R_18_PCREL_RELA
2937                            || r_type == R_M32R_26_PCREL_RELA
2938                            || r_type == R_M32R_REL32)
2939                     {
2940                       BFD_ASSERT (h != NULL && h->dynindx != -1);
2941                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2942                       outrel.r_addend = rel->r_addend;
2943                     }
2944                   else
2945                     {
2946                     /* h->dynindx may be -1 if this symbol was marked to
2947                        become local.  */
2948                     if (h == NULL
2949                         || ((info->symbolic || h->dynindx == -1)
2950                              && h->def_regular))
2951                       {
2952                         relocate = TRUE;
2953                         outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2954                         outrel.r_addend = relocation + rel->r_addend;
2955                       }
2956                     else
2957                       {
2958                         BFD_ASSERT (h->dynindx != -1);
2959                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2960                         outrel.r_addend = relocation + rel->r_addend;
2961                       }
2962                     }
2963
2964                   loc = sreloc->contents;
2965                   loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2966                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2967                   ++sreloc->reloc_count;
2968
2969                   /* If this reloc is against an external symbol, we do
2970                      not want to fiddle with the addend.  Otherwise, we
2971                      need to include the symbol value so that it becomes
2972                      an addend for the dynamic reloc.  */
2973                   if (! relocate)
2974                     continue;
2975                   break;
2976                 }
2977               else if (r_type != R_M32R_10_PCREL_RELA)
2978                 break;
2979               /* Fall through.  */
2980
2981             case (int) R_M32R_10_PCREL :
2982               r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2983                                               contents, offset,
2984                                               sec, relocation, addend);
2985               goto check_reloc;
2986
2987             case (int) R_M32R_HI16_SLO :
2988             case (int) R_M32R_HI16_ULO :
2989               {
2990                 Elf_Internal_Rela *lorel;
2991
2992                 /* We allow an arbitrary number of HI16 relocs before the
2993                    LO16 reloc.  This permits gcc to emit the HI and LO relocs
2994                    itself.  */
2995                 for (lorel = rel + 1;
2996                      (lorel < relend
2997                       && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2998                           || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2999                      lorel++)
3000                   continue;
3001                 if (lorel < relend
3002                     && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
3003                   {
3004                     m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
3005                                             contents, relocation + addend);
3006                     r = bfd_reloc_ok;
3007                   }
3008                 else
3009                   r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3010                                                 contents, offset,
3011                                                 relocation, addend);
3012               }
3013
3014               goto check_reloc;
3015
3016             case (int) R_M32R_SDA16_RELA:
3017             case (int) R_M32R_SDA16 :
3018               {
3019                 const char *name;
3020
3021                 BFD_ASSERT (sec != NULL);
3022                 name = bfd_get_section_name (abfd, sec);
3023
3024                 if (   strcmp (name, ".sdata") == 0
3025                     || strcmp (name, ".sbss") == 0
3026                     || strcmp (name, ".scommon") == 0)
3027                   {
3028                     bfd_vma sda_base;
3029                     bfd *out_bfd = sec->output_section->owner;
3030
3031                     r = m32r_elf_final_sda_base (out_bfd, info,
3032                                                  &errmsg,
3033                                                  &sda_base);
3034                     if (r != bfd_reloc_ok)
3035                       {
3036                         ret = FALSE;
3037                         goto check_reloc;
3038                       }
3039
3040                     /* At this point `relocation' contains the object's
3041                        address.  */
3042                     relocation -= sda_base;
3043                     /* Now it contains the offset from _SDA_BASE_.  */
3044                   }
3045                 else
3046                   {
3047                     (*_bfd_error_handler)
3048                       (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3049                        input_bfd,
3050                        sec,
3051                        sym_name,
3052                        m32r_elf_howto_table[(int) r_type].name);
3053                     /*bfd_set_error (bfd_error_bad_value); ??? why? */
3054                     ret = FALSE;
3055                     continue;
3056                   }
3057               }
3058               /* Fall through.  */
3059
3060             default : /* OLD_M32R_RELOC */
3061
3062               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3063                                             contents, offset,
3064                                             relocation, addend);
3065               goto check_reloc;
3066             }
3067
3068           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3069                                         contents, rel->r_offset,
3070                                         relocation, rel->r_addend);
3071
3072         }
3073
3074     check_reloc:
3075
3076       if (r != bfd_reloc_ok)
3077         {
3078           /* FIXME: This should be generic enough to go in a utility.  */
3079           const char *name;
3080
3081           if (h != NULL)
3082             name = h->root.root.string;
3083           else
3084             {
3085               name = (bfd_elf_string_from_elf_section
3086                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
3087               if (name == NULL || *name == '\0')
3088                 name = bfd_section_name (input_bfd, sec);
3089             }
3090
3091           if (errmsg != NULL)
3092             goto common_error;
3093
3094           switch (r)
3095             {
3096             case bfd_reloc_overflow:
3097               if (! ((*info->callbacks->reloc_overflow)
3098                      (info, (h ? &h->root : NULL), name, howto->name,
3099                       (bfd_vma) 0, input_bfd, input_section, offset)))
3100                 return FALSE;
3101               break;
3102
3103             case bfd_reloc_undefined:
3104               if (! ((*info->callbacks->undefined_symbol)
3105                      (info, name, input_bfd, input_section,
3106                       offset, TRUE)))
3107                 return FALSE;
3108               break;
3109
3110             case bfd_reloc_outofrange:
3111               errmsg = _("internal error: out of range error");
3112               goto common_error;
3113
3114             case bfd_reloc_notsupported:
3115               errmsg = _("internal error: unsupported relocation error");
3116               goto common_error;
3117
3118             case bfd_reloc_dangerous:
3119               errmsg = _("internal error: dangerous error");
3120               goto common_error;
3121
3122             default:
3123               errmsg = _("internal error: unknown error");
3124               /* fall through */
3125
3126             common_error:
3127               if (!((*info->callbacks->warning)
3128                     (info, errmsg, name, input_bfd, input_section,
3129                      offset)))
3130                 return FALSE;
3131               break;
3132             }
3133         }
3134     }
3135
3136   return ret;
3137 }
3138
3139 /* Finish up dynamic symbol handling.  We set the contents of various
3140    dynamic sections here.  */
3141
3142 static bfd_boolean
3143 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3144                                 struct bfd_link_info *info,
3145                                 struct elf_link_hash_entry *h,
3146                                 Elf_Internal_Sym *sym)
3147 {
3148   struct elf_m32r_link_hash_table *htab;
3149   bfd_byte *loc;
3150
3151 #ifdef DEBUG_PIC
3152   printf ("m32r_elf_finish_dynamic_symbol()\n");
3153 #endif
3154
3155   htab = m32r_elf_hash_table (info);
3156   if (htab == NULL)
3157     return FALSE;
3158
3159   if (h->plt.offset != (bfd_vma) -1)
3160     {
3161       asection *splt;
3162       asection *sgot;
3163       asection *srela;
3164
3165       bfd_vma plt_index;
3166       bfd_vma got_offset;
3167       Elf_Internal_Rela rela;
3168
3169       /* This symbol has an entry in the procedure linkage table.  Set
3170          it up.  */
3171
3172       BFD_ASSERT (h->dynindx != -1);
3173
3174       splt = htab->splt;
3175       sgot = htab->sgotplt;
3176       srela = htab->srelplt;
3177       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3178
3179       /* Get the index in the procedure linkage table which
3180          corresponds to this symbol.  This is the index of this symbol
3181          in all the symbols for which we are making plt entries.  The
3182          first entry in the procedure linkage table is reserved.  */
3183       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3184
3185       /* Get the offset into the .got table of the entry that
3186         corresponds to this function.  Each .got entry is 4 bytes.
3187         The first three are reserved.  */
3188       got_offset = (plt_index + 3) * 4;
3189
3190       /* Fill in the entry in the procedure linkage table.  */
3191       if (! info->shared)
3192         {
3193           bfd_put_32 (output_bfd,
3194               (PLT_ENTRY_WORD0b
3195                + (((sgot->output_section->vma
3196                     + sgot->output_offset
3197                     + got_offset) >> 16) & 0xffff)),
3198               splt->contents + h->plt.offset);
3199           bfd_put_32 (output_bfd,
3200               (PLT_ENTRY_WORD1b
3201                + ((sgot->output_section->vma
3202                    + sgot->output_offset
3203                    + got_offset) & 0xffff)),
3204               splt->contents + h->plt.offset + 4);
3205           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3206               splt->contents + h->plt.offset + 8);
3207           bfd_put_32 (output_bfd,
3208               (PLT_ENTRY_WORD3
3209                + plt_index * sizeof (Elf32_External_Rela)),
3210               splt->contents + h->plt.offset + 12);
3211           bfd_put_32 (output_bfd,
3212               (PLT_ENTRY_WORD4
3213                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3214               splt->contents + h->plt.offset + 16);
3215         }
3216       else
3217         {
3218           bfd_put_32 (output_bfd,
3219               PLT_ENTRY_WORD0 + got_offset,
3220               splt->contents + h->plt.offset);
3221           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3222               splt->contents + h->plt.offset + 4);
3223           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3224               splt->contents + h->plt.offset + 8);
3225           bfd_put_32 (output_bfd,
3226               (PLT_ENTRY_WORD3
3227                + plt_index * sizeof (Elf32_External_Rela)),
3228               splt->contents + h->plt.offset + 12);
3229           bfd_put_32 (output_bfd,
3230               (PLT_ENTRY_WORD4
3231                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3232               splt->contents + h->plt.offset + 16);
3233         }
3234
3235       /* Fill in the entry in the global offset table.  */
3236       bfd_put_32 (output_bfd,
3237                   (splt->output_section->vma
3238                    + splt->output_offset
3239                    + h->plt.offset
3240                    + 12), /* same offset */
3241                   sgot->contents + got_offset);
3242
3243       /* Fill in the entry in the .rela.plt section.  */
3244       rela.r_offset = (sgot->output_section->vma
3245                        + sgot->output_offset
3246                        + got_offset);
3247       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3248       rela.r_addend = 0;
3249       loc = srela->contents;
3250       loc += plt_index * sizeof (Elf32_External_Rela);
3251       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3252
3253       if (!h->def_regular)
3254         {
3255           /* Mark the symbol as undefined, rather than as defined in
3256              the .plt section.  Leave the value alone.  */
3257           sym->st_shndx = SHN_UNDEF;
3258         }
3259     }
3260
3261   if (h->got.offset != (bfd_vma) -1)
3262     {
3263       asection *sgot;
3264       asection *srela;
3265       Elf_Internal_Rela rela;
3266
3267       /* This symbol has an entry in the global offset table.  Set it
3268          up.  */
3269
3270       sgot = htab->sgot;
3271       srela = htab->srelgot;
3272       BFD_ASSERT (sgot != NULL && srela != NULL);
3273
3274       rela.r_offset = (sgot->output_section->vma
3275                        + sgot->output_offset
3276                        + (h->got.offset &~ 1));
3277
3278       /* If this is a -Bsymbolic link, and the symbol is defined
3279          locally, we just want to emit a RELATIVE reloc.  Likewise if
3280          the symbol was forced to be local because of a version file.
3281          The entry in the global offset table will already have been
3282          initialized in the relocate_section function.  */
3283       if (info->shared
3284           && (info->symbolic
3285               || h->dynindx == -1
3286               || h->forced_local)
3287           && h->def_regular)
3288         {
3289           rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3290           rela.r_addend = (h->root.u.def.value
3291                            + h->root.u.def.section->output_section->vma
3292                            + h->root.u.def.section->output_offset);
3293         }
3294       else
3295         {
3296           BFD_ASSERT ((h->got.offset & 1) == 0);
3297           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3298           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3299           rela.r_addend = 0;
3300         }
3301
3302       loc = srela->contents;
3303       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3304       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3305       ++srela->reloc_count;
3306     }
3307
3308   if (h->needs_copy)
3309     {
3310       asection *s;
3311       Elf_Internal_Rela rela;
3312
3313       /* This symbols needs a copy reloc.  Set it up.  */
3314
3315       BFD_ASSERT (h->dynindx != -1
3316                   && (h->root.type == bfd_link_hash_defined
3317                       || h->root.type == bfd_link_hash_defweak));
3318
3319       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3320                                    ".rela.bss");
3321       BFD_ASSERT (s != NULL);
3322
3323       rela.r_offset = (h->root.u.def.value
3324                        + h->root.u.def.section->output_section->vma
3325                        + h->root.u.def.section->output_offset);
3326       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3327       rela.r_addend = 0;
3328       loc = s->contents;
3329       loc += s->reloc_count * sizeof (Elf32_External_Rela);
3330       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3331       ++s->reloc_count;
3332     }
3333
3334   /* Mark some specially defined symbols as absolute.  */
3335   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3336       || h == htab->root.hgot)
3337     sym->st_shndx = SHN_ABS;
3338
3339   return TRUE;
3340 }
3341
3342
3343 /* Finish up the dynamic sections.  */
3344
3345 static bfd_boolean
3346 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3347                                   struct bfd_link_info *info)
3348 {
3349   struct elf_m32r_link_hash_table *htab;
3350   bfd *dynobj;
3351   asection *sdyn;
3352   asection *sgot;
3353
3354 #ifdef DEBUG_PIC
3355   printf ("m32r_elf_finish_dynamic_sections()\n");
3356 #endif
3357
3358   htab = m32r_elf_hash_table (info);
3359   if (htab == NULL)
3360     return FALSE;
3361
3362   dynobj = htab->root.dynobj;
3363
3364   sgot = htab->sgotplt;
3365   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3366
3367   if (htab->root.dynamic_sections_created)
3368     {
3369       asection *splt;
3370       Elf32_External_Dyn *dyncon, *dynconend;
3371
3372       BFD_ASSERT (sgot != NULL && sdyn != NULL);
3373
3374       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3375       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3376
3377       for (; dyncon < dynconend; dyncon++)
3378         {
3379           Elf_Internal_Dyn dyn;
3380           asection *s;
3381
3382           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3383
3384           switch (dyn.d_tag)
3385             {
3386             default:
3387               break;
3388
3389             case DT_PLTGOT:
3390               s = htab->sgot->output_section;
3391               goto get_vma;
3392             case DT_JMPREL:
3393               s = htab->srelplt->output_section;
3394             get_vma:
3395               BFD_ASSERT (s != NULL);
3396               dyn.d_un.d_ptr = s->vma;
3397               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3398               break;
3399
3400             case DT_PLTRELSZ:
3401               s = htab->srelplt->output_section;
3402               BFD_ASSERT (s != NULL);
3403               dyn.d_un.d_val = s->size;
3404               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3405               break;
3406
3407             case DT_RELASZ:
3408               /* My reading of the SVR4 ABI indicates that the
3409                  procedure linkage table relocs (DT_JMPREL) should be
3410                  included in the overall relocs (DT_RELA).  This is
3411                  what Solaris does.  However, UnixWare can not handle
3412                  that case.  Therefore, we override the DT_RELASZ entry
3413                  here to make it not include the JMPREL relocs.  Since
3414                  the linker script arranges for .rela.plt to follow all
3415                  other relocation sections, we don't have to worry
3416                  about changing the DT_RELA entry.  */
3417               if (htab->srelplt != NULL)
3418                 {
3419                   s = htab->srelplt->output_section;
3420                   dyn.d_un.d_val -= s->size;
3421                 }
3422               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3423               break;
3424             }
3425         }
3426
3427       /* Fill in the first entry in the procedure linkage table.  */
3428       splt = htab->splt;
3429       if (splt && splt->size > 0)
3430         {
3431           if (info->shared)
3432             {
3433               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3434               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3435               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3436               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3437               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3438             }
3439           else
3440             {
3441               unsigned long addr;
3442               /* addr = .got + 4 */
3443               addr = sgot->output_section->vma + sgot->output_offset + 4;
3444               bfd_put_32 (output_bfd,
3445                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3446                           splt->contents);
3447               bfd_put_32 (output_bfd,
3448                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
3449                           splt->contents + 4);
3450               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3451               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3452               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3453             }
3454
3455           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3456             PLT_ENTRY_SIZE;
3457         }
3458     }
3459
3460   /* Fill in the first three entries in the global offset table.  */
3461   if (sgot && sgot->size > 0)
3462     {
3463       if (sdyn == NULL)
3464         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3465       else
3466         bfd_put_32 (output_bfd,
3467                     sdyn->output_section->vma + sdyn->output_offset,
3468                     sgot->contents);
3469       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3470       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3471
3472       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3473     }
3474
3475   return TRUE;
3476 }
3477
3478 \f
3479 /* Set the right machine number.  */
3480
3481 static bfd_boolean
3482 m32r_elf_object_p (bfd *abfd)
3483 {
3484   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3485     {
3486     default:
3487     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3488     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3489     case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3490     }
3491   return TRUE;
3492 }
3493
3494 /* Store the machine number in the flags field.  */
3495
3496 static void
3497 m32r_elf_final_write_processing (bfd *abfd,
3498                                  bfd_boolean linker ATTRIBUTE_UNUSED)
3499 {
3500   unsigned long val;
3501
3502   switch (bfd_get_mach (abfd))
3503     {
3504     default:
3505     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3506     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3507     case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3508     }
3509
3510   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3511   elf_elfheader (abfd)->e_flags |= val;
3512 }
3513
3514 /* Function to keep M32R specific file flags.  */
3515
3516 static bfd_boolean
3517 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3518 {
3519   BFD_ASSERT (!elf_flags_init (abfd)
3520               || elf_elfheader (abfd)->e_flags == flags);
3521
3522   elf_elfheader (abfd)->e_flags = flags;
3523   elf_flags_init (abfd) = TRUE;
3524   return TRUE;
3525 }
3526
3527 /* Merge backend specific data from an object file to the output
3528    object file when linking.  */
3529
3530 static bfd_boolean
3531 m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3532 {
3533   flagword out_flags;
3534   flagword in_flags;
3535
3536   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3537       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3538     return TRUE;
3539
3540   in_flags  = elf_elfheader (ibfd)->e_flags;
3541   out_flags = elf_elfheader (obfd)->e_flags;
3542
3543   if (! elf_flags_init (obfd))
3544     {
3545       /* If the input is the default architecture then do not
3546          bother setting the flags for the output architecture,
3547          instead allow future merges to do this.  If no future
3548          merges ever set these flags then they will retain their
3549          unitialised values, which surprise surprise, correspond
3550          to the default values.  */
3551       if (bfd_get_arch_info (ibfd)->the_default)
3552         return TRUE;
3553
3554       elf_flags_init (obfd) = TRUE;
3555       elf_elfheader (obfd)->e_flags = in_flags;
3556
3557       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3558           && bfd_get_arch_info (obfd)->the_default)
3559         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3560                                   bfd_get_mach (ibfd));
3561
3562       return TRUE;
3563     }
3564
3565   /* Check flag compatibility.  */
3566   if (in_flags == out_flags)
3567     return TRUE;
3568
3569   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3570     {
3571       if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3572           || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3573           || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3574         {
3575           (*_bfd_error_handler)
3576             (_("%B: Instruction set mismatch with previous modules"), ibfd);
3577
3578           bfd_set_error (bfd_error_bad_value);
3579           return FALSE;
3580         }
3581     }
3582
3583   return TRUE;
3584 }
3585
3586 /* Display the flags field.  */
3587
3588 static bfd_boolean
3589 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3590 {
3591   FILE * file = (FILE *) ptr;
3592
3593   BFD_ASSERT (abfd != NULL && ptr != NULL);
3594
3595   _bfd_elf_print_private_bfd_data (abfd, ptr);
3596
3597   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3598
3599   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3600     {
3601     default:
3602     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3603     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3604     case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3605     }
3606
3607   fputc ('\n', file);
3608
3609   return TRUE;
3610 }
3611
3612 static asection *
3613 m32r_elf_gc_mark_hook (asection *sec,
3614                        struct bfd_link_info *info,
3615                        Elf_Internal_Rela *rel,
3616                        struct elf_link_hash_entry *h,
3617                        Elf_Internal_Sym *sym)
3618 {
3619   if (h != NULL)
3620     switch (ELF32_R_TYPE (rel->r_info))
3621       {
3622       case R_M32R_GNU_VTINHERIT:
3623       case R_M32R_GNU_VTENTRY:
3624       case R_M32R_RELA_GNU_VTINHERIT:
3625       case R_M32R_RELA_GNU_VTENTRY:
3626         return NULL;
3627       }
3628
3629   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3630 }
3631
3632 static bfd_boolean
3633 m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3634                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
3635                         asection *sec ATTRIBUTE_UNUSED,
3636                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3637 {
3638   /* Update the got entry reference counts for the section being removed.  */
3639   Elf_Internal_Shdr *symtab_hdr;
3640   struct elf_link_hash_entry **sym_hashes;
3641   bfd_signed_vma *local_got_refcounts;
3642   const Elf_Internal_Rela *rel, *relend;
3643
3644   if (info->relocatable)
3645     return TRUE;
3646
3647   elf_section_data (sec)->local_dynrel = NULL;
3648
3649   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3650   sym_hashes = elf_sym_hashes (abfd);
3651   local_got_refcounts = elf_local_got_refcounts (abfd);
3652
3653   relend = relocs + sec->reloc_count;
3654   for (rel = relocs; rel < relend; rel++)
3655     {
3656       unsigned long r_symndx;
3657       struct elf_link_hash_entry *h = NULL;
3658
3659       r_symndx = ELF32_R_SYM (rel->r_info);
3660       if (r_symndx >= symtab_hdr->sh_info)
3661         {
3662           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3663           while (h->root.type == bfd_link_hash_indirect
3664                  || h->root.type == bfd_link_hash_warning)
3665             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3666         }
3667
3668       switch (ELF32_R_TYPE (rel->r_info))
3669         {
3670         case R_M32R_GOT16_HI_ULO:
3671         case R_M32R_GOT16_HI_SLO:
3672         case R_M32R_GOT16_LO:
3673         case R_M32R_GOTOFF:
3674         case R_M32R_GOTOFF_HI_ULO:
3675         case R_M32R_GOTOFF_HI_SLO:
3676         case R_M32R_GOTOFF_LO:
3677         case R_M32R_GOT24:
3678         case R_M32R_GOTPC_HI_ULO:
3679         case R_M32R_GOTPC_HI_SLO:
3680         case R_M32R_GOTPC_LO:
3681         case R_M32R_GOTPC24:
3682           if (h != NULL)
3683             {
3684               if (h->got.refcount > 0)
3685                 h->got.refcount--;
3686             }
3687           else
3688             {
3689               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3690                 local_got_refcounts[r_symndx]--;
3691             }
3692           break;
3693
3694         case R_M32R_16_RELA:
3695         case R_M32R_24_RELA:
3696         case R_M32R_32_RELA:
3697         case R_M32R_REL32:
3698         case R_M32R_HI16_ULO_RELA:
3699         case R_M32R_HI16_SLO_RELA:
3700         case R_M32R_LO16_RELA:
3701         case R_M32R_SDA16_RELA:
3702         case R_M32R_10_PCREL_RELA:
3703         case R_M32R_18_PCREL_RELA:
3704         case R_M32R_26_PCREL_RELA:
3705           if (h != NULL)
3706             {
3707               struct elf_m32r_link_hash_entry *eh;
3708               struct elf_m32r_dyn_relocs **pp;
3709               struct elf_m32r_dyn_relocs *p;
3710
3711               if (!info->shared && h->plt.refcount > 0)
3712                 h->plt.refcount -= 1;
3713
3714               eh = (struct elf_m32r_link_hash_entry *) h;
3715
3716               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3717                 if (p->sec == sec)
3718                   {
3719                     if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3720                         || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3721                         || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3722                         || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3723                       p->pc_count -= 1;
3724                     p->count -= 1;
3725                     if (p->count == 0)
3726                       *pp = p->next;
3727                     break;
3728                   }
3729             }
3730           break;
3731
3732         case R_M32R_26_PLTREL:
3733           if (h != NULL)
3734             {
3735               if (h->plt.refcount > 0)
3736                 h->plt.refcount--;
3737             }
3738           break;
3739
3740         default:
3741           break;
3742         }
3743     }
3744
3745   return TRUE;
3746 }
3747
3748 /* Look through the relocs for a section during the first phase.
3749    Since we don't do .gots or .plts, we just need to consider the
3750    virtual table relocs for gc.  */
3751
3752 static bfd_boolean
3753 m32r_elf_check_relocs (bfd *abfd,
3754                        struct bfd_link_info *info,
3755                        asection *sec,
3756                        const Elf_Internal_Rela *relocs)
3757 {
3758   Elf_Internal_Shdr *symtab_hdr;
3759   struct elf_link_hash_entry **sym_hashes;
3760   const Elf_Internal_Rela *rel;
3761   const Elf_Internal_Rela *rel_end;
3762   struct elf_m32r_link_hash_table *htab;
3763   bfd *dynobj;
3764   asection *sreloc;
3765
3766   if (info->relocatable)
3767     return TRUE;
3768
3769   sreloc = NULL;
3770   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3771   sym_hashes = elf_sym_hashes (abfd);
3772
3773   htab = m32r_elf_hash_table (info);
3774   if (htab == NULL)
3775     return FALSE;
3776
3777   dynobj = htab->root.dynobj;
3778
3779   rel_end = relocs + sec->reloc_count;
3780   for (rel = relocs; rel < rel_end; rel++)
3781     {
3782       int r_type;
3783       struct elf_link_hash_entry *h;
3784       unsigned long r_symndx;
3785
3786       r_symndx = ELF32_R_SYM (rel->r_info);
3787       r_type = ELF32_R_TYPE (rel->r_info);
3788       if (r_symndx < symtab_hdr->sh_info)
3789         h = NULL;
3790       else
3791         {
3792           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3793           while (h->root.type == bfd_link_hash_indirect
3794                  || h->root.type == bfd_link_hash_warning)
3795             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3796         }
3797
3798       /* Some relocs require a global offset table.  */
3799       if (htab->sgot == NULL)
3800         {
3801           switch (r_type)
3802             {
3803             case R_M32R_GOT16_HI_ULO:
3804             case R_M32R_GOT16_HI_SLO:
3805             case R_M32R_GOTOFF:
3806             case R_M32R_GOTOFF_HI_ULO:
3807             case R_M32R_GOTOFF_HI_SLO:
3808             case R_M32R_GOTOFF_LO:
3809             case R_M32R_GOT16_LO:
3810             case R_M32R_GOTPC24:
3811             case R_M32R_GOTPC_HI_ULO:
3812             case R_M32R_GOTPC_HI_SLO:
3813             case R_M32R_GOTPC_LO:
3814             case R_M32R_GOT24:
3815               if (dynobj == NULL)
3816                 htab->root.dynobj = dynobj = abfd;
3817               if (! create_got_section (dynobj, info))
3818                 return FALSE;
3819               break;
3820
3821             default:
3822               break;
3823           }
3824         }
3825
3826       switch (r_type)
3827         {
3828         case R_M32R_GOT16_HI_ULO:
3829         case R_M32R_GOT16_HI_SLO:
3830         case R_M32R_GOT16_LO:
3831         case R_M32R_GOT24:
3832
3833           if (h != NULL)
3834             h->got.refcount += 1;
3835           else
3836             {
3837               bfd_signed_vma *local_got_refcounts;
3838
3839               /* This is a global offset table entry for a local
3840                  symbol.  */
3841               local_got_refcounts = elf_local_got_refcounts (abfd);
3842               if (local_got_refcounts == NULL)
3843                 {
3844                   bfd_size_type size;
3845
3846                   size = symtab_hdr->sh_info;
3847                   size *= sizeof (bfd_signed_vma);
3848                   local_got_refcounts = bfd_zalloc (abfd, size);
3849                   if (local_got_refcounts == NULL)
3850                     return FALSE;
3851                   elf_local_got_refcounts (abfd) = local_got_refcounts;
3852                 }
3853               local_got_refcounts[r_symndx] += 1;
3854             }
3855           break;
3856
3857         case R_M32R_26_PLTREL:
3858           /* This symbol requires a procedure linkage table entry.  We
3859              actually build the entry in adjust_dynamic_symbol,
3860              because this might be a case of linking PIC code without
3861              linking in any dynamic objects, in which case we don't
3862              need to generate a procedure linkage table after all.  */
3863
3864           /* If this is a local symbol, we resolve it directly without
3865              creating a procedure linkage table entry.  */
3866           if (h == NULL)
3867             continue;
3868
3869           if (h->forced_local)
3870             break;
3871
3872           h->needs_plt = 1;
3873           h->plt.refcount += 1;
3874           break;
3875
3876         case R_M32R_16_RELA:
3877         case R_M32R_24_RELA:
3878         case R_M32R_32_RELA:
3879         case R_M32R_REL32:
3880         case R_M32R_HI16_ULO_RELA:
3881         case R_M32R_HI16_SLO_RELA:
3882         case R_M32R_LO16_RELA:
3883         case R_M32R_SDA16_RELA:
3884         case R_M32R_10_PCREL_RELA:
3885         case R_M32R_18_PCREL_RELA:
3886         case R_M32R_26_PCREL_RELA:
3887
3888           if (h != NULL && !info->shared)
3889             {
3890               h->non_got_ref = 1;
3891               h->plt.refcount += 1;
3892             }
3893
3894           /* If we are creating a shared library, and this is a reloc
3895              against a global symbol, or a non PC relative reloc
3896              against a local symbol, then we need to copy the reloc
3897              into the shared library.  However, if we are linking with
3898              -Bsymbolic, we do not need to copy a reloc against a
3899              global symbol which is defined in an object we are
3900              including in the link (i.e., DEF_REGULAR is set).  At
3901              this point we have not seen all the input files, so it is
3902              possible that DEF_REGULAR is not set now but will be set
3903              later (it is never cleared).  We account for that
3904              possibility below by storing information in the
3905              dyn_relocs field of the hash table entry. A similar
3906              situation occurs when creating shared libraries and symbol
3907              visibility changes render the symbol local.
3908
3909              If on the other hand, we are creating an executable, we
3910              may need to keep relocations for symbols satisfied by a
3911              dynamic library if we manage to avoid copy relocs for the
3912              symbol.  */
3913           if ((info->shared
3914                && (sec->flags & SEC_ALLOC) != 0
3915                && ((   r_type != R_M32R_26_PCREL_RELA
3916                     && r_type != R_M32R_18_PCREL_RELA
3917                     && r_type != R_M32R_10_PCREL_RELA
3918                     && r_type != R_M32R_REL32)
3919                    || (h != NULL
3920                        && (! info->symbolic
3921                            || h->root.type == bfd_link_hash_defweak
3922                            || !h->def_regular))))
3923               || (!info->shared
3924                   && (sec->flags & SEC_ALLOC) != 0
3925                   && h != NULL
3926                   && (h->root.type == bfd_link_hash_defweak
3927                       || !h->def_regular)))
3928             {
3929               struct elf_m32r_dyn_relocs *p;
3930               struct elf_m32r_dyn_relocs **head;
3931
3932               if (dynobj == NULL)
3933                 htab->root.dynobj = dynobj = abfd;
3934
3935               /* When creating a shared object, we must copy these
3936                  relocs into the output file.  We create a reloc
3937                  section in dynobj and make room for the reloc.  */
3938               if (sreloc == NULL)
3939                 {
3940                   sreloc = _bfd_elf_make_dynamic_reloc_section
3941                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3942
3943                   if (sreloc == NULL)
3944                     return FALSE;
3945                 }
3946
3947               /* If this is a global symbol, we count the number of
3948                  relocations we need for this symbol.  */
3949               if (h != NULL)
3950                 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3951               else
3952                 {
3953                   /* Track dynamic relocs needed for local syms too.  */
3954                   asection *s;
3955                   void *vpp;
3956                   Elf_Internal_Sym *isym;
3957
3958                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3959                                                 abfd, r_symndx);
3960                   if (isym == NULL)
3961                     return FALSE;
3962
3963                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3964                   if (s == NULL)
3965                     s = sec;
3966
3967                   vpp = &elf_section_data (s)->local_dynrel;
3968                   head = (struct elf_m32r_dyn_relocs **) vpp;
3969                 }
3970
3971               p = *head;
3972               if (p == NULL || p->sec != sec)
3973                 {
3974                   bfd_size_type amt = sizeof (*p);
3975
3976                   p = bfd_alloc (dynobj, amt);
3977                   if (p == NULL)
3978                     return FALSE;
3979                   p->next = *head;
3980                   *head = p;
3981                   p->sec = sec;
3982                   p->count = 0;
3983                   p->pc_count = 0;
3984                 }
3985
3986               p->count += 1;
3987               if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3988                   || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3989                   || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3990                   || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3991                 p->pc_count += 1;
3992             }
3993           break;
3994
3995         /* This relocation describes the C++ object vtable hierarchy.
3996            Reconstruct it for later use during GC.  */
3997         case R_M32R_RELA_GNU_VTINHERIT:
3998         case R_M32R_GNU_VTINHERIT:
3999           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4000             return FALSE;
4001           break;
4002
4003         /* This relocation describes which C++ vtable entries are actually
4004            used.  Record for later use during GC.  */
4005         case R_M32R_GNU_VTENTRY:
4006           BFD_ASSERT (h != NULL);
4007           if (h != NULL
4008               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4009             return FALSE;
4010           break;
4011         case R_M32R_RELA_GNU_VTENTRY:
4012           BFD_ASSERT (h != NULL);
4013           if (h != NULL
4014               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4015             return FALSE;
4016           break;
4017         }
4018     }
4019
4020   return TRUE;
4021 }
4022
4023 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
4024 {
4025   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
4026   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4027   { NULL,                     0,  0, 0,            0 }
4028 };
4029
4030 static enum elf_reloc_type_class
4031 m32r_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4032 {
4033   switch ((int) ELF32_R_TYPE (rela->r_info))
4034     {
4035     case R_M32R_RELATIVE:  return reloc_class_relative;
4036     case R_M32R_JMP_SLOT:  return reloc_class_plt;
4037     case R_M32R_COPY:      return reloc_class_copy;
4038     default:               return reloc_class_normal;
4039     }
4040 }
4041 \f
4042 #define ELF_ARCH                bfd_arch_m32r
4043 #define ELF_TARGET_ID           M32R_ELF_DATA
4044 #define ELF_MACHINE_CODE        EM_M32R
4045 #define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
4046 #define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
4047
4048 #define TARGET_BIG_SYM          bfd_elf32_m32r_vec
4049 #define TARGET_BIG_NAME         "elf32-m32r"
4050 #define TARGET_LITTLE_SYM       bfd_elf32_m32rle_vec
4051 #define TARGET_LITTLE_NAME      "elf32-m32rle"
4052
4053 #define elf_info_to_howto                       m32r_info_to_howto
4054 #define elf_info_to_howto_rel                   m32r_info_to_howto_rel
4055 #define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
4056 #define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
4057 #define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
4058 #define elf_backend_relocate_section            m32r_elf_relocate_section
4059 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
4060 #define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
4061 #define elf_backend_check_relocs                m32r_elf_check_relocs
4062
4063 #define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
4064 #define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
4065 #define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
4066 #define elf_backend_omit_section_dynsym \
4067   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4068 #define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
4069 #define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
4070 #define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
4071 #define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
4072 #define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
4073
4074 #define elf_backend_can_gc_sections             1
4075 /*#if !USE_REL
4076 #define elf_backend_rela_normal                 1
4077 #endif*/
4078 #define elf_backend_can_refcount 1
4079 #define elf_backend_want_got_plt 1
4080 #define elf_backend_plt_readonly 1
4081 #define elf_backend_want_plt_sym 0
4082 #define elf_backend_got_header_size 12
4083
4084 #define elf_backend_may_use_rel_p       1
4085 #ifdef USE_M32R_OLD_RELOC
4086 #define elf_backend_default_use_rela_p  0
4087 #define elf_backend_may_use_rela_p      0
4088 #else
4089 #define elf_backend_default_use_rela_p  1
4090 #define elf_backend_may_use_rela_p      1
4091 #endif
4092
4093 #define elf_backend_object_p                    m32r_elf_object_p
4094 #define elf_backend_final_write_processing      m32r_elf_final_write_processing
4095 #define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
4096 #define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
4097 #define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
4098 #define elf_backend_special_sections            m32r_elf_special_sections
4099
4100 #include "elf32-target.h"
4101
4102 #undef  ELF_MAXPAGESIZE
4103 #define ELF_MAXPAGESIZE         0x1000
4104
4105 #undef  TARGET_BIG_SYM
4106 #define TARGET_BIG_SYM          bfd_elf32_m32rlin_vec
4107 #undef  TARGET_BIG_NAME
4108 #define TARGET_BIG_NAME         "elf32-m32r-linux"
4109 #undef  TARGET_LITTLE_SYM
4110 #define TARGET_LITTLE_SYM       bfd_elf32_m32rlelin_vec
4111 #undef  TARGET_LITTLE_NAME
4112 #define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
4113 #undef  elf32_bed
4114 #define elf32_bed               elf32_m32r_lin_bed
4115
4116 #include "elf32-target.h"
4117