bfd/elf32-m32r.c

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