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 /* The sh linker needs to keep track of the number of relocs that it
1489    decides to copy as dynamic relocs in check_relocs for each symbol.
1490    This is so that it can later discard them if they are found to be
1491    unnecessary.  We store the information in a field extending the
1492    regular ELF linker hash table.  */
1493
1494 struct elf_m32r_dyn_relocs
1495 {
1496   struct elf_m32r_dyn_relocs *next;
1497
1498   /* The input section of the reloc.  */
1499   asection *sec;
1500
1501   /* Total number of relocs copied for the input section.  */
1502   bfd_size_type count;
1503
1504   /* Number of pc-relative relocs copied for the input section.  */
1505   bfd_size_type pc_count;
1506 };
1507
1508
1509 /* m32r ELF linker hash entry.  */
1510
1511 struct elf_m32r_link_hash_entry
1512 {
1513   struct elf_link_hash_entry root;
1514
1515   /* Track dynamic relocs copied for this symbol.  */
1516   struct elf_m32r_dyn_relocs *dyn_relocs;
1517 };
1518
1519 /* m32r ELF linker hash table.  */
1520
1521 struct elf_m32r_link_hash_table
1522 {
1523   struct elf_link_hash_table root;
1524
1525   /* Short-cuts to get to dynamic linker sections.  */
1526   asection *sdynbss;
1527   asection *srelbss;
1528
1529   /* Small local sym cache.  */
1530   struct sym_cache sym_cache;
1531 };
1532
1533 /* Traverse an m32r ELF linker hash table.  */
1534
1535 #define m32r_elf_link_hash_traverse(table, func, info)                  \
1536   (elf_link_hash_traverse                                               \
1537    (&(table)->root,                                                     \
1538     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1539     (info)))
1540
1541 /* Get the m32r ELF linker hash table from a link_info structure.  */
1542
1543 #define m32r_elf_hash_table(p) \
1544   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1545   == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL)
1546
1547 /* Create an entry in an m32r ELF linker hash table.  */
1548
1549 static struct bfd_hash_entry *
1550 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551                             struct bfd_hash_table *table,
1552                             const char *string)
1553 {
1554   struct elf_m32r_link_hash_entry *ret =
1555     (struct elf_m32r_link_hash_entry *) entry;
1556
1557   /* Allocate the structure if it has not already been allocated by a
1558      subclass.  */
1559   if (ret == NULL)
1560     ret = bfd_hash_allocate (table,
1561                              sizeof (struct elf_m32r_link_hash_entry));
1562   if (ret == NULL)
1563     return NULL;
1564
1565   /* Call the allocation method of the superclass.  */
1566   ret = ((struct elf_m32r_link_hash_entry *)
1567          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568                                      table, string));
1569   if (ret != NULL)
1570     {
1571       struct elf_m32r_link_hash_entry *eh;
1572
1573       eh = (struct elf_m32r_link_hash_entry *) ret;
1574       eh->dyn_relocs = NULL;
1575     }
1576
1577   return (struct bfd_hash_entry *) ret;
1578 }
1579
1580 /* Create an m32r ELF linker hash table.  */
1581
1582 static struct bfd_link_hash_table *
1583 m32r_elf_link_hash_table_create (bfd *abfd)
1584 {
1585   struct elf_m32r_link_hash_table *ret;
1586   bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587
1588   ret = bfd_zmalloc (amt);
1589   if (ret == NULL)
1590     return NULL;
1591
1592   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1593                                       m32r_elf_link_hash_newfunc,
1594                                       sizeof (struct elf_m32r_link_hash_entry),
1595                                       M32R_ELF_DATA))
1596     {
1597       free (ret);
1598       return NULL;
1599     }
1600
1601   return &ret->root.root;
1602 }
1603
1604 /* Create dynamic sections when linking against a dynamic object.  */
1605
1606 static bfd_boolean
1607 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1608 {
1609   struct elf_m32r_link_hash_table *htab;
1610   flagword flags, pltflags;
1611   asection *s;
1612   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1613   int ptralign = 2; /* 32bit */
1614
1615   htab = m32r_elf_hash_table (info);
1616   if (htab == NULL)
1617     return FALSE;
1618
1619   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1620      .rel[a].bss sections.  */
1621   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1622            | SEC_LINKER_CREATED);
1623
1624   pltflags = flags;
1625   pltflags |= SEC_CODE;
1626   if (bed->plt_not_loaded)
1627     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1628   if (bed->plt_readonly)
1629     pltflags |= SEC_READONLY;
1630
1631   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
1632   htab->root.splt = s;
1633   if (s == NULL
1634       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1635     return FALSE;
1636
1637   if (bed->want_plt_sym)
1638     {
1639       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1640          .plt section.  */
1641       struct bfd_link_hash_entry *bh = NULL;
1642       struct elf_link_hash_entry *h;
1643
1644       if (! (_bfd_generic_link_add_one_symbol
1645              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1646               (bfd_vma) 0, NULL, FALSE,
1647               get_elf_backend_data (abfd)->collect, &bh)))
1648         return FALSE;
1649       h = (struct elf_link_hash_entry *) bh;
1650       h->def_regular = 1;
1651       h->type = STT_OBJECT;
1652       htab->root.hplt = h;
1653
1654       if (bfd_link_pic (info)
1655           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1656         return FALSE;
1657     }
1658
1659   s = bfd_make_section_anyway_with_flags (abfd,
1660                                           bed->default_use_rela_p
1661                                           ? ".rela.plt" : ".rel.plt",
1662                                           flags | SEC_READONLY);
1663   htab->root.srelplt = s;
1664   if (s == NULL
1665       || ! bfd_set_section_alignment (abfd, s, ptralign))
1666     return FALSE;
1667
1668   if (htab->root.sgot == NULL
1669       && !_bfd_elf_create_got_section (abfd, info))
1670     return FALSE;
1671
1672   if (bed->want_dynbss)
1673     {
1674       /* The .dynbss section is a place to put symbols which are defined
1675          by dynamic objects, are referenced by regular objects, and are
1676          not functions.  We must allocate space for them in the process
1677          image and use a R_*_COPY reloc to tell the dynamic linker to
1678          initialize them at run time.  The linker script puts the .dynbss
1679          section into the .bss section of the final image.  */
1680       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
1681                                               SEC_ALLOC | SEC_LINKER_CREATED);
1682       htab->sdynbss = s;
1683       if (s == NULL)
1684         return FALSE;
1685       /* The .rel[a].bss section holds copy relocs.  This section is not
1686          normally needed.  We need to create it here, though, so that the
1687          linker will map it to an output section.  We can't just create it
1688          only if we need it, because we will not know whether we need it
1689          until we have seen all the input files, and the first time the
1690          main linker code calls BFD after examining all the input files
1691          (size_dynamic_sections) the input sections have already been
1692          mapped to the output sections.  If the section turns out not to
1693          be needed, we can discard it later.  We will never need this
1694          section when generating a shared object, since they do not use
1695          copy relocs.  */
1696       if (! bfd_link_pic (info))
1697         {
1698           s = bfd_make_section_anyway_with_flags (abfd,
1699                                                   (bed->default_use_rela_p
1700                                                    ? ".rela.bss" : ".rel.bss"),
1701                                                   flags | SEC_READONLY);
1702           htab->srelbss = s;
1703           if (s == NULL
1704               || ! bfd_set_section_alignment (abfd, s, ptralign))
1705             return FALSE;
1706         }
1707     }
1708
1709   return TRUE;
1710 }
1711
1712 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1713
1714 static void
1715 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1716                                struct elf_link_hash_entry *dir,
1717                                struct elf_link_hash_entry *ind)
1718 {
1719   struct elf_m32r_link_hash_entry * edir;
1720   struct elf_m32r_link_hash_entry * eind;
1721
1722   edir = (struct elf_m32r_link_hash_entry *) dir;
1723   eind = (struct elf_m32r_link_hash_entry *) ind;
1724
1725   if (eind->dyn_relocs != NULL)
1726     {
1727       if (edir->dyn_relocs != NULL)
1728         {
1729           struct elf_m32r_dyn_relocs **pp;
1730           struct elf_m32r_dyn_relocs *p;
1731
1732           /* Add reloc counts against the indirect sym to the direct sym
1733              list.  Merge any entries against the same section.  */
1734           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1735             {
1736               struct elf_m32r_dyn_relocs *q;
1737
1738               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1739                 if (q->sec == p->sec)
1740                   {
1741                     q->pc_count += p->pc_count;
1742                     q->count += p->count;
1743                     *pp = p->next;
1744                     break;
1745                   }
1746               if (q == NULL)
1747                 pp = &p->next;
1748             }
1749           *pp = edir->dyn_relocs;
1750         }
1751
1752       edir->dyn_relocs = eind->dyn_relocs;
1753       eind->dyn_relocs = NULL;
1754     }
1755
1756   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1757 }
1758
1759 \f
1760 /* Find dynamic relocs for H that apply to read-only sections.  */
1761
1762 static asection *
1763 readonly_dynrelocs (struct elf_link_hash_entry *h)
1764 {
1765   struct elf_m32r_dyn_relocs *p;
1766   struct elf_m32r_link_hash_entry *eh = (struct elf_m32r_link_hash_entry *) h;
1767
1768   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1769     {
1770       asection *s = p->sec->output_section;
1771
1772       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1773         return p->sec;
1774     }
1775   return NULL;
1776 }
1777
1778 /* Adjust a symbol defined by a dynamic object and referenced by a
1779    regular object.  The current definition is in some section of the
1780    dynamic object, but we're not including those sections.  We have to
1781    change the definition to something the rest of the link can
1782    understand.  */
1783
1784 static bfd_boolean
1785 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1786                                 struct elf_link_hash_entry *h)
1787 {
1788   struct elf_m32r_link_hash_table *htab;
1789   struct elf_m32r_link_hash_entry *eh;
1790   struct elf_m32r_dyn_relocs *p;
1791   bfd *dynobj;
1792   asection *s;
1793
1794 #ifdef DEBUG_PIC
1795   printf ("m32r_elf_adjust_dynamic_symbol()\n");
1796 #endif
1797
1798   dynobj = elf_hash_table (info)->dynobj;
1799
1800   /* Make sure we know what is going on here.  */
1801   BFD_ASSERT (dynobj != NULL
1802               && (h->needs_plt
1803                   || h->is_weakalias
1804                   || (h->def_dynamic
1805                       && h->ref_regular
1806                       && !h->def_regular)));
1807
1808   /* If this is a function, put it in the procedure linkage table.  We
1809      will fill in the contents of the procedure linkage table later,
1810      when we know the address of the .got section.  */
1811   if (h->type == STT_FUNC
1812       || h->needs_plt)
1813     {
1814       if (! bfd_link_pic (info)
1815           && !h->def_dynamic
1816           && !h->ref_dynamic
1817           && h->root.type != bfd_link_hash_undefweak
1818           && h->root.type != bfd_link_hash_undefined)
1819         {
1820           /* This case can occur if we saw a PLT reloc in an input
1821              file, but the symbol was never referred to by a dynamic
1822              object.  In such a case, we don't actually need to build
1823              a procedure linkage table, and we can just do a PCREL
1824              reloc instead.  */
1825           h->plt.offset = (bfd_vma) -1;
1826           h->needs_plt = 0;
1827         }
1828
1829       return TRUE;
1830     }
1831   else
1832     h->plt.offset = (bfd_vma) -1;
1833
1834   /* If this is a weak symbol, and there is a real definition, the
1835      processor independent code will have arranged for us to see the
1836      real definition first, and we can just use the same value.  */
1837   if (h->is_weakalias)
1838     {
1839       struct elf_link_hash_entry *def = weakdef (h);
1840       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1841       h->root.u.def.section = def->root.u.def.section;
1842       h->root.u.def.value = def->root.u.def.value;
1843       return TRUE;
1844     }
1845
1846   /* This is a reference to a symbol defined by a dynamic object which
1847      is not a function.  */
1848
1849   /* If we are creating a shared library, we must presume that the
1850      only references to the symbol are via the global offset table.
1851      For such cases we need not do anything here; the relocations will
1852      be handled correctly by relocate_section.  */
1853   if (bfd_link_pic (info))
1854     return TRUE;
1855
1856   /* If there are no references to this symbol that do not use the
1857      GOT, we don't need to generate a copy reloc.  */
1858   if (!h->non_got_ref)
1859     return TRUE;
1860
1861   /* If -z nocopyreloc was given, we won't generate them either.  */
1862   if (info->nocopyreloc)
1863     {
1864       h->non_got_ref = 0;
1865       return TRUE;
1866     }
1867
1868   eh = (struct elf_m32r_link_hash_entry *) h;
1869   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1870     {
1871       s = p->sec->output_section;
1872       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1873         break;
1874     }
1875
1876   /* If we didn't find any dynamic relocs in sections which needs the
1877      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1878      the copy reloc.  */
1879   if (p == NULL)
1880     {
1881       h->non_got_ref = 0;
1882       return TRUE;
1883     }
1884
1885   /* We must allocate the symbol in our .dynbss section, which will
1886      become part of the .bss section of the executable.  There will be
1887      an entry for this symbol in the .dynsym section.  The dynamic
1888      object will contain position independent code, so all references
1889      from the dynamic object to this symbol will go through the global
1890      offset table.  The dynamic linker will use the .dynsym entry to
1891      determine the address it must put in the global offset table, so
1892      both the dynamic object and the regular object will refer to the
1893      same memory location for the variable.  */
1894
1895   htab = m32r_elf_hash_table (info);
1896   if (htab == NULL)
1897     return FALSE;
1898
1899   s = htab->sdynbss;
1900   BFD_ASSERT (s != NULL);
1901
1902   /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1903      to copy the initial value out of the dynamic object and into the
1904      runtime process image.  We need to remember the offset into the
1905      .rela.bss section we are going to use.  */
1906   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1907     {
1908       asection *srel;
1909
1910       srel = htab->srelbss;
1911       BFD_ASSERT (srel != NULL);
1912       srel->size += sizeof (Elf32_External_Rela);
1913       h->needs_copy = 1;
1914     }
1915
1916   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1917 }
1918
1919 /* Allocate space in .plt, .got and associated reloc sections for
1920    dynamic relocs.  */
1921
1922 static bfd_boolean
1923 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1924 {
1925   struct bfd_link_info *info;
1926   struct elf_m32r_link_hash_table *htab;
1927   struct elf_m32r_link_hash_entry *eh;
1928   struct elf_m32r_dyn_relocs *p;
1929
1930   if (h->root.type == bfd_link_hash_indirect)
1931     return TRUE;
1932
1933   info = (struct bfd_link_info *) inf;
1934   htab = m32r_elf_hash_table (info);
1935   if (htab == NULL)
1936     return FALSE;
1937
1938   eh = (struct elf_m32r_link_hash_entry *) h;
1939
1940   if (htab->root.dynamic_sections_created
1941       && h->plt.refcount > 0)
1942     {
1943       /* Make sure this symbol is output as a dynamic symbol.
1944          Undefined weak syms won't yet be marked as dynamic.  */
1945       if (h->dynindx == -1
1946           && !h->forced_local)
1947         {
1948           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1949             return FALSE;
1950         }
1951
1952       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1953         {
1954           asection *s = htab->root.splt;
1955
1956           /* If this is the first .plt entry, make room for the special
1957              first entry.  */
1958           if (s->size == 0)
1959             s->size += PLT_ENTRY_SIZE;
1960
1961           h->plt.offset = s->size;
1962
1963           /* If this symbol is not defined in a regular file, and we are
1964              not generating a shared library, then set the symbol to this
1965              location in the .plt.  This is required to make function
1966              pointers compare as equal between the normal executable and
1967              the shared library.  */
1968           if (! bfd_link_pic (info)
1969               && !h->def_regular)
1970             {
1971               h->root.u.def.section = s;
1972               h->root.u.def.value = h->plt.offset;
1973             }
1974
1975           /* Make room for this entry.  */
1976           s->size += PLT_ENTRY_SIZE;
1977
1978           /* We also need to make an entry in the .got.plt section, which
1979              will be placed in the .got section by the linker script.  */
1980           htab->root.sgotplt->size += 4;
1981
1982           /* We also need to make an entry in the .rel.plt section.  */
1983           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1984         }
1985       else
1986         {
1987           h->plt.offset = (bfd_vma) -1;
1988           h->needs_plt = 0;
1989         }
1990     }
1991   else
1992     {
1993       h->plt.offset = (bfd_vma) -1;
1994       h->needs_plt = 0;
1995     }
1996
1997   if (h->got.refcount > 0)
1998     {
1999       asection *s;
2000       bfd_boolean dyn;
2001
2002       /* Make sure this symbol is output as a dynamic symbol.
2003          Undefined weak syms won't yet be marked as dynamic.  */
2004       if (h->dynindx == -1
2005           && !h->forced_local)
2006         {
2007           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2008             return FALSE;
2009         }
2010
2011       s = htab->root.sgot;
2012
2013       h->got.offset = s->size;
2014       s->size += 4;
2015       dyn = htab->root.dynamic_sections_created;
2016       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
2017         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2018     }
2019   else
2020     h->got.offset = (bfd_vma) -1;
2021
2022   if (eh->dyn_relocs == NULL)
2023     return TRUE;
2024
2025   /* In the shared -Bsymbolic case, discard space allocated for
2026      dynamic pc-relative relocs against symbols which turn out to be
2027      defined in regular objects.  For the normal shared case, discard
2028      space for pc-relative relocs that have become local due to symbol
2029      visibility changes.  */
2030
2031   if (bfd_link_pic (info))
2032     {
2033       if (h->def_regular
2034           && (h->forced_local
2035               || info->symbolic))
2036         {
2037           struct elf_m32r_dyn_relocs **pp;
2038
2039           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2040             {
2041               p->count -= p->pc_count;
2042               p->pc_count = 0;
2043               if (p->count == 0)
2044                 *pp = p->next;
2045               else
2046                 pp = &p->next;
2047             }
2048         }
2049
2050       /* Also discard relocs on undefined weak syms with non-default
2051          visibility.  */
2052       if (eh->dyn_relocs != NULL
2053           && h->root.type == bfd_link_hash_undefweak)
2054         {
2055           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2056             eh->dyn_relocs = NULL;
2057
2058           /* Make sure undefined weak symbols are output as a dynamic
2059              symbol in PIEs.  */
2060           else if (h->dynindx == -1
2061                    && !h->forced_local)
2062             {
2063               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2064                 return FALSE;
2065             }
2066         }
2067     }
2068   else
2069     {
2070       /* For the non-shared case, discard space for relocs against
2071          symbols which turn out to need copy relocs or are not
2072          dynamic.  */
2073
2074       if (!h->non_got_ref
2075           && ((h->def_dynamic
2076                && !h->def_regular)
2077               || (htab->root.dynamic_sections_created
2078                   && (h->root.type == bfd_link_hash_undefweak
2079                       || h->root.type == bfd_link_hash_undefined))))
2080         {
2081           /* Make sure this symbol is output as a dynamic symbol.
2082              Undefined weak syms won't yet be marked as dynamic.  */
2083           if (h->dynindx == -1
2084               && !h->forced_local)
2085             {
2086               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2087                 return FALSE;
2088             }
2089
2090           /* If that succeeded, we know we'll be keeping all the
2091              relocs.  */
2092           if (h->dynindx != -1)
2093             goto keep;
2094         }
2095
2096       eh->dyn_relocs = NULL;
2097
2098     keep: ;
2099     }
2100
2101   /* Finally, allocate space.  */
2102   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2103     {
2104       asection *sreloc = elf_section_data (p->sec)->sreloc;
2105       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2106     }
2107
2108   return TRUE;
2109 }
2110
2111 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2112    read-only sections.  */
2113
2114 static bfd_boolean
2115 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2116 {
2117   asection *sec;
2118
2119   if (h->root.type == bfd_link_hash_indirect)
2120     return TRUE;
2121
2122   sec = readonly_dynrelocs (h);
2123   if (sec != NULL)
2124     {
2125       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2126
2127       info->flags |= DF_TEXTREL;
2128       info->callbacks->minfo
2129         (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
2130          sec->owner, h->root.root.string, sec);
2131
2132       /* Not an error, just cut short the traversal.  */
2133       return FALSE;
2134     }
2135   return TRUE;
2136 }
2137
2138 /* Set the sizes of the dynamic sections.  */
2139
2140 static bfd_boolean
2141 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2142                                 struct bfd_link_info *info)
2143 {
2144   struct elf_m32r_link_hash_table *htab;
2145   bfd *dynobj;
2146   asection *s;
2147   bfd_boolean relocs;
2148   bfd *ibfd;
2149
2150 #ifdef DEBUG_PIC
2151   printf ("m32r_elf_size_dynamic_sections()\n");
2152 #endif
2153
2154   htab = m32r_elf_hash_table (info);
2155   if (htab == NULL)
2156     return FALSE;
2157
2158   dynobj = htab->root.dynobj;
2159   BFD_ASSERT (dynobj != NULL);
2160
2161   if (htab->root.dynamic_sections_created)
2162     {
2163       /* Set the contents of the .interp section to the interpreter.  */
2164       if (bfd_link_executable (info) && !info->nointerp)
2165         {
2166           s = bfd_get_linker_section (dynobj, ".interp");
2167           BFD_ASSERT (s != NULL);
2168           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2169           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2170         }
2171     }
2172
2173   /* Set up .got offsets for local syms, and space for local dynamic
2174      relocs.  */
2175   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2176     {
2177       bfd_signed_vma *local_got;
2178       bfd_signed_vma *end_local_got;
2179       bfd_size_type locsymcount;
2180       Elf_Internal_Shdr *symtab_hdr;
2181       asection *srel;
2182
2183       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2184         continue;
2185
2186       for (s = ibfd->sections; s != NULL; s = s->next)
2187         {
2188           struct elf_m32r_dyn_relocs *p;
2189
2190           for (p = ((struct elf_m32r_dyn_relocs *)
2191                     elf_section_data (s)->local_dynrel);
2192                p != NULL;
2193                p = p->next)
2194             {
2195               if (! bfd_is_abs_section (p->sec)
2196                   && bfd_is_abs_section (p->sec->output_section))
2197                 {
2198                   /* Input section has been discarded, either because
2199                      it is a copy of a linkonce section or due to
2200                      linker script /DISCARD/, so we'll be discarding
2201                      the relocs too.  */
2202                 }
2203               else if (p->count != 0)
2204                 {
2205                   srel = elf_section_data (p->sec)->sreloc;
2206                   srel->size += p->count * sizeof (Elf32_External_Rela);
2207                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2208                     info->flags |= DF_TEXTREL;
2209                 }
2210             }
2211         }
2212
2213       local_got = elf_local_got_refcounts (ibfd);
2214       if (!local_got)
2215         continue;
2216
2217       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2218       locsymcount = symtab_hdr->sh_info;
2219       end_local_got = local_got + locsymcount;
2220       s = htab->root.sgot;
2221       srel = htab->root.srelgot;
2222       for (; local_got < end_local_got; ++local_got)
2223         {
2224           if (*local_got > 0)
2225             {
2226               *local_got = s->size;
2227               s->size += 4;
2228               if (bfd_link_pic (info))
2229                 srel->size += sizeof (Elf32_External_Rela);
2230             }
2231           else
2232             *local_got = (bfd_vma) -1;
2233         }
2234     }
2235
2236   /* Allocate global sym .plt and .got entries, and space for global
2237      sym dynamic relocs.  */
2238   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2239
2240   /* We now have determined the sizes of the various dynamic sections.
2241      Allocate memory for them.  */
2242   relocs = FALSE;
2243   for (s = dynobj->sections; s != NULL; s = s->next)
2244     {
2245       if ((s->flags & SEC_LINKER_CREATED) == 0)
2246         continue;
2247
2248       if (s == htab->root.splt
2249           || s == htab->root.sgot
2250           || s == htab->root.sgotplt
2251           || s == htab->sdynbss)
2252         {
2253           /* Strip this section if we don't need it; see the
2254              comment below.  */
2255         }
2256       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2257         {
2258           if (s->size != 0 && s != htab->root.srelplt)
2259             relocs = TRUE;
2260
2261           /* We use the reloc_count field as a counter if we need
2262              to copy relocs into the output file.  */
2263           s->reloc_count = 0;
2264         }
2265       else
2266         /* It's not one of our sections, so don't allocate space.  */
2267         continue;
2268
2269       if (s->size == 0)
2270         {
2271           /* If we don't need this section, strip it from the
2272              output file.  This is mostly to handle .rela.bss and
2273              .rela.plt.  We must create both sections in
2274              create_dynamic_sections, because they must be created
2275              before the linker maps input sections to output
2276              sections.  The linker does that before
2277              adjust_dynamic_symbol is called, and it is that
2278              function which decides whether anything needs to go
2279              into these sections.  */
2280           s->flags |= SEC_EXCLUDE;
2281           continue;
2282         }
2283
2284       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2285         continue;
2286
2287       /* Allocate memory for the section contents.  We use bfd_zalloc
2288          here in case unused entries are not reclaimed before the
2289          section's contents are written out.  This should not happen,
2290          but this way if it does, we get a R_M32R_NONE reloc instead
2291          of garbage.  */
2292       s->contents = bfd_zalloc (dynobj, s->size);
2293       if (s->contents == NULL)
2294         return FALSE;
2295     }
2296
2297   if (htab->root.dynamic_sections_created)
2298     {
2299       /* Add some entries to the .dynamic section.  We fill in the
2300          values later, in m32r_elf_finish_dynamic_sections, but we
2301          must add the entries now so that we get the correct size for
2302          the .dynamic section.  The DT_DEBUG entry is filled in by the
2303          dynamic linker and used by the debugger.  */
2304 #define add_dynamic_entry(TAG, VAL) \
2305   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2306
2307      if (bfd_link_executable (info))
2308         {
2309           if (! add_dynamic_entry (DT_DEBUG, 0))
2310             return FALSE;
2311         }
2312
2313       if (htab->root.splt->size != 0)
2314         {
2315           if (! add_dynamic_entry (DT_PLTGOT, 0)
2316               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2317               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2318               || ! add_dynamic_entry (DT_JMPREL, 0))
2319             return FALSE;
2320         }
2321
2322       if (relocs)
2323         {
2324           if (! add_dynamic_entry (DT_RELA, 0)
2325               || ! add_dynamic_entry (DT_RELASZ, 0)
2326               || ! add_dynamic_entry (DT_RELAENT,
2327                                       sizeof (Elf32_External_Rela)))
2328             return FALSE;
2329
2330           /* If any dynamic relocs apply to a read-only section,
2331              then we need a DT_TEXTREL entry.  */
2332           if ((info->flags & DF_TEXTREL) == 0)
2333             elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2334
2335           if ((info->flags & DF_TEXTREL) != 0)
2336             {
2337               if (! add_dynamic_entry (DT_TEXTREL, 0))
2338                 return FALSE;
2339             }
2340         }
2341     }
2342 #undef add_dynamic_entry
2343
2344   return TRUE;
2345 }
2346
2347 /* Relocate an M32R/D ELF section.
2348    There is some attempt to make this function usable for many architectures,
2349    both for RELA and REL type relocs, if only to serve as a learning tool.
2350
2351    The RELOCATE_SECTION function is called by the new ELF backend linker
2352    to handle the relocations for a section.
2353
2354    The relocs are always passed as Rela structures; if the section
2355    actually uses Rel structures, the r_addend field will always be
2356    zero.
2357
2358    This function is responsible for adjust the section contents as
2359    necessary, and (if using Rela relocs and generating a
2360    relocatable output file) adjusting the reloc addend as
2361    necessary.
2362
2363    This function does not have to worry about setting the reloc
2364    address or the reloc symbol index.
2365
2366    LOCAL_SYMS is a pointer to the swapped in local symbols.
2367
2368    LOCAL_SECTIONS is an array giving the section in the input file
2369    corresponding to the st_shndx field of each local symbol.
2370
2371    The global hash table entry for the global symbols can be found
2372    via elf_sym_hashes (input_bfd).
2373
2374    When generating relocatable output, this function must handle
2375    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2376    going to be the section symbol corresponding to the output
2377    section, which means that the addend must be adjusted
2378    accordingly.  */
2379
2380 static bfd_boolean
2381 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2382                            struct bfd_link_info *info,
2383                            bfd *input_bfd,
2384                            asection *input_section,
2385                            bfd_byte *contents,
2386                            Elf_Internal_Rela *relocs,
2387                            Elf_Internal_Sym *local_syms,
2388                            asection **local_sections)
2389 {
2390   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2391   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2392   Elf_Internal_Rela *rel, *relend;
2393   /* Assume success.  */
2394   bfd_boolean ret = TRUE;
2395   struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2396   bfd_vma *local_got_offsets;
2397   asection *sgot, *splt, *sreloc;
2398   bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2399
2400   if (htab == NULL)
2401     return FALSE;
2402
2403   local_got_offsets = elf_local_got_offsets (input_bfd);
2404
2405   sgot = htab->root.sgot;
2406   splt = htab->root.splt;
2407   sreloc = NULL;
2408
2409   rel = relocs;
2410   relend = relocs + input_section->reloc_count;
2411   for (; rel < relend; rel++)
2412     {
2413       int r_type;
2414       reloc_howto_type *howto;
2415       unsigned long r_symndx;
2416       struct elf_link_hash_entry *h;
2417       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2418          ensure it's zero (we use REL relocs, not RELA).  Therefore this
2419          should be assigning zero to `addend', but for clarity we use
2420          `r_addend'.  */
2421       bfd_vma addend = rel->r_addend;
2422       bfd_vma offset = rel->r_offset;
2423       bfd_vma relocation;
2424       Elf_Internal_Sym *sym;
2425       asection *sec;
2426       const char *sym_name;
2427       bfd_reloc_status_type r;
2428       const char *errmsg = NULL;
2429       bfd_boolean use_rel = FALSE;
2430
2431       h = NULL;
2432       r_type = ELF32_R_TYPE (rel->r_info);
2433       if (r_type < 0 || r_type >= (int) R_M32R_max)
2434         {
2435           /* xgettext:c-format */
2436           _bfd_error_handler (_("%B: unknown relocation type %d"),
2437                               input_bfd, (int) r_type);
2438           bfd_set_error (bfd_error_bad_value);
2439           ret = FALSE;
2440           continue;
2441         }
2442
2443       if (   r_type == R_M32R_GNU_VTENTRY
2444           || r_type == R_M32R_GNU_VTINHERIT
2445           || r_type == R_M32R_NONE
2446           || r_type == R_M32R_RELA_GNU_VTENTRY
2447           || r_type == R_M32R_RELA_GNU_VTINHERIT)
2448         continue;
2449
2450       if (r_type <= R_M32R_GNU_VTENTRY)
2451         use_rel = TRUE;
2452
2453       howto = m32r_elf_howto_table + r_type;
2454       r_symndx = ELF32_R_SYM (rel->r_info);
2455
2456       sym = NULL;
2457       sec = NULL;
2458       h = NULL;
2459
2460       if (r_symndx < symtab_hdr->sh_info)
2461         {
2462           /* Local symbol.  */
2463           sym = local_syms + r_symndx;
2464           sec = local_sections[r_symndx];
2465           sym_name = "<local symbol>";
2466
2467           if (!use_rel)
2468             {
2469               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2470               addend = rel->r_addend;
2471             }
2472           else
2473             {
2474               relocation = (sec->output_section->vma
2475                             + sec->output_offset
2476                             + sym->st_value);
2477             }
2478         }
2479       else
2480         {
2481           /* External symbol.  */
2482           relocation = 0;
2483
2484           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2485
2486           if (info->wrap_hash != NULL
2487               && (input_section->flags & SEC_DEBUGGING) != 0)
2488             h = ((struct elf_link_hash_entry *)
2489                  unwrap_hash_lookup (info, input_bfd, &h->root));
2490
2491           while (h->root.type == bfd_link_hash_indirect
2492                  || h->root.type == bfd_link_hash_warning)
2493             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2494           sym_name = h->root.root.string;
2495
2496           if (h->root.type == bfd_link_hash_defined
2497               || h->root.type == bfd_link_hash_defweak)
2498             {
2499               bfd_boolean dyn;
2500               sec = h->root.u.def.section;
2501
2502               dyn = htab->root.dynamic_sections_created;
2503               sec = h->root.u.def.section;
2504               if (r_type == R_M32R_GOTPC24
2505                   || (r_type == R_M32R_GOTPC_HI_ULO
2506                       || r_type == R_M32R_GOTPC_HI_SLO
2507                       || r_type == R_M32R_GOTPC_LO)
2508                   || (r_type == R_M32R_26_PLTREL
2509                       && h->plt.offset != (bfd_vma) -1)
2510                   || ((r_type == R_M32R_GOT24
2511                        || r_type == R_M32R_GOT16_HI_ULO
2512                        || r_type == R_M32R_GOT16_HI_SLO
2513                        || r_type == R_M32R_GOT16_LO)
2514                       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2515                                                           bfd_link_pic (info),
2516                                                           h)
2517                       && (! bfd_link_pic (info)
2518                           || (! info->symbolic && h->dynindx != -1)
2519                           || !h->def_regular))
2520                   || (bfd_link_pic (info)
2521                       && ((! info->symbolic && h->dynindx != -1)
2522                           || !h->def_regular)
2523                       && (((r_type == R_M32R_16_RELA
2524                             || r_type == R_M32R_32_RELA
2525                             || r_type == R_M32R_24_RELA
2526                             || r_type == R_M32R_HI16_ULO_RELA
2527                             || r_type == R_M32R_HI16_SLO_RELA
2528                             || r_type == R_M32R_LO16_RELA)
2529                            && !h->forced_local)
2530                           || r_type == R_M32R_REL32
2531                           || r_type == R_M32R_10_PCREL_RELA
2532                           || r_type == R_M32R_18_PCREL_RELA
2533                           || r_type == R_M32R_26_PCREL_RELA)
2534                       && ((input_section->flags & SEC_ALLOC) != 0
2535                           /* DWARF will emit R_M32R_16(24,32) relocations
2536                              in its sections against symbols defined
2537                              externally in shared libraries.  We can't do
2538                              anything with them here.  */
2539                           || ((input_section->flags & SEC_DEBUGGING) != 0
2540                               && h->def_dynamic))))
2541                 {
2542                   /* In these cases, we don't need the relocation
2543                      value.  We check specially because in some
2544                      obscure cases sec->output_section will be NULL.  */
2545                 }
2546               else if (sec->output_section != NULL)
2547                 relocation = (h->root.u.def.value
2548                               + sec->output_section->vma
2549                               + sec->output_offset);
2550               else if (!bfd_link_relocatable (info)
2551                        && (_bfd_elf_section_offset (output_bfd, info,
2552                                                     input_section,
2553                                                     rel->r_offset)
2554                            != (bfd_vma) -1))
2555                 {
2556                   _bfd_error_handler
2557                     /* xgettext:c-format */
2558                     (_("%B(%A+%#Lx): unresolvable %s relocation "
2559                        "against symbol `%s'"),
2560                      input_bfd,
2561                      input_section,
2562                      rel->r_offset,
2563                      howto->name,
2564                      h->root.root.string);
2565                 }
2566             }
2567           else if (h->root.type == bfd_link_hash_undefweak)
2568             ;
2569           else if (info->unresolved_syms_in_objects == RM_IGNORE
2570                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2571             ;
2572           else if (!bfd_link_relocatable (info))
2573             (*info->callbacks->undefined_symbol)
2574               (info, h->root.root.string, input_bfd,
2575                input_section, offset,
2576                (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2577                 || ELF_ST_VISIBILITY (h->other)));
2578         }
2579
2580       if (sec != NULL && discarded_section (sec))
2581         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2582                                          rel, 1, relend, howto, 0, contents);
2583
2584       if (bfd_link_relocatable (info) && !use_rel)
2585         {
2586           /* This is a relocatable link.  We don't have to change
2587              anything, unless the reloc is against a section symbol,
2588              in which case we have to adjust according to where the
2589              section symbol winds up in the output section.  */
2590           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2591             rel->r_addend += sec->output_offset;
2592           continue;
2593         }
2594
2595       if (bfd_link_relocatable (info) && use_rel)
2596         {
2597           /* This is a relocatable link.  We don't have to change
2598              anything, unless the reloc is against a section symbol,
2599              in which case we have to adjust according to where the
2600              section symbol winds up in the output section.  */
2601           if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2602             continue;
2603
2604           addend += sec->output_offset;
2605
2606           /* If partial_inplace, we need to store any additional addend
2607              back in the section.  */
2608           if (! howto->partial_inplace)
2609             continue;
2610           /* ??? Here is a nice place to call a special_function
2611              like handler.  */
2612           if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2613             r = _bfd_relocate_contents (howto, input_bfd,
2614                                         addend, contents + offset);
2615           else
2616             {
2617               Elf_Internal_Rela *lorel;
2618
2619               /* We allow an arbitrary number of HI16 relocs before the
2620                  LO16 reloc.  This permits gcc to emit the HI and LO relocs
2621                  itself.  */
2622               for (lorel = rel + 1;
2623                    (lorel < relend
2624                     && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2625                         || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2626                    lorel++)
2627                 continue;
2628               if (lorel < relend
2629                   && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2630                 {
2631                   m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2632                                           contents, addend);
2633                   r = bfd_reloc_ok;
2634                 }
2635               else
2636                 r = _bfd_relocate_contents (howto, input_bfd,
2637                                             addend, contents + offset);
2638             }
2639         }
2640       else
2641         {
2642           /* Sanity check the address.  */
2643           if (offset > high_address)
2644             {
2645               r = bfd_reloc_outofrange;
2646               goto check_reloc;
2647             }
2648
2649           switch ((int) r_type)
2650             {
2651             case R_M32R_GOTOFF:
2652               /* Relocation is relative to the start of the global offset
2653                  table (for ld24 rx, #uimm24). eg access at label+addend
2654
2655                  ld24 rx. #label@GOTOFF + addend
2656                  sub  rx, r12.  */
2657
2658               BFD_ASSERT (sgot != NULL);
2659
2660               relocation = -(relocation - sgot->output_section->vma);
2661               rel->r_addend = -rel->r_addend;
2662               break;
2663
2664             case R_M32R_GOTOFF_HI_ULO:
2665             case R_M32R_GOTOFF_HI_SLO:
2666             case R_M32R_GOTOFF_LO:
2667               BFD_ASSERT (sgot != NULL);
2668
2669               relocation -= sgot->output_section->vma;
2670
2671               if ((r_type == R_M32R_GOTOFF_HI_SLO)
2672                   && ((relocation + rel->r_addend) & 0x8000))
2673                 rel->r_addend += 0x10000;
2674               break;
2675
2676             case R_M32R_GOTPC24:
2677               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2678                  ld24 rx,#_GLOBAL_OFFSET_TABLE_
2679                */
2680              relocation = sgot->output_section->vma;
2681              break;
2682
2683             case R_M32R_GOTPC_HI_ULO:
2684             case R_M32R_GOTPC_HI_SLO:
2685             case R_M32R_GOTPC_LO:
2686               {
2687                 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2688                    bl .+4
2689                    seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2690                    or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2691                    or
2692                    bl .+4
2693                    seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2694                    add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2695                  */
2696                 relocation = sgot->output_section->vma;
2697                 relocation -= (input_section->output_section->vma
2698                                + input_section->output_offset
2699                                + rel->r_offset);
2700                 if ((r_type == R_M32R_GOTPC_HI_SLO)
2701                      && ((relocation + rel->r_addend) & 0x8000))
2702                   rel->r_addend += 0x10000;
2703
2704                 break;
2705               }
2706             case R_M32R_GOT16_HI_ULO:
2707             case R_M32R_GOT16_HI_SLO:
2708             case R_M32R_GOT16_LO:
2709               /* Fall through.  */
2710             case R_M32R_GOT24:
2711               /* Relocation is to the entry for this symbol in the global
2712                  offset table.  */
2713               BFD_ASSERT (sgot != NULL);
2714
2715               if (h != NULL)
2716                 {
2717                   bfd_boolean dyn;
2718                   bfd_vma off;
2719
2720                   off = h->got.offset;
2721                   BFD_ASSERT (off != (bfd_vma) -1);
2722
2723                   dyn = htab->root.dynamic_sections_created;
2724                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2725                                                          bfd_link_pic (info),
2726                                                          h)
2727                       || (bfd_link_pic (info)
2728                           && (info->symbolic
2729                               || h->dynindx == -1
2730                               || h->forced_local)
2731                           && h->def_regular))
2732                     {
2733                       /* This is actually a static link, or it is a
2734                          -Bsymbolic link and the symbol is defined
2735                          locally, or the symbol was forced to be local
2736                          because of a version file.  We must initialize
2737                          this entry in the global offset table.  Since the
2738                          offset must always be a multiple of 4, we use the
2739                          least significant bit to record whether we have
2740                          initialized it already.
2741
2742                          When doing a dynamic link, we create a .rela.got
2743                          relocation entry to initialize the value.  This
2744                          is done in the finish_dynamic_symbol routine.  */
2745                       if ((off & 1) != 0)
2746                         off &= ~1;
2747                       else
2748                         {
2749                           bfd_put_32 (output_bfd, relocation,
2750                                       sgot->contents + off);
2751                           h->got.offset |= 1;
2752                         }
2753                     }
2754
2755                   relocation = sgot->output_offset + off;
2756                 }
2757               else
2758                 {
2759                   bfd_vma off;
2760                   bfd_byte *loc;
2761
2762                   BFD_ASSERT (local_got_offsets != NULL
2763                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
2764
2765                   off = local_got_offsets[r_symndx];
2766
2767                   /* The offset must always be a multiple of 4.  We use
2768                      the least significant bit to record whether we have
2769                      already processed this entry.  */
2770                   if ((off & 1) != 0)
2771                     off &= ~1;
2772                   else
2773                     {
2774                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2775
2776                       if (bfd_link_pic (info))
2777                         {
2778                           asection *srelgot;
2779                           Elf_Internal_Rela outrel;
2780
2781                           /* We need to generate a R_M32R_RELATIVE reloc
2782                              for the dynamic linker.  */
2783                           srelgot = htab->root.srelgot;
2784                           BFD_ASSERT (srelgot != NULL);
2785
2786                           outrel.r_offset = (sgot->output_section->vma
2787                                              + sgot->output_offset
2788                                              + off);
2789                           outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2790                           outrel.r_addend = relocation;
2791                           loc = srelgot->contents;
2792                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2793                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2794                           ++srelgot->reloc_count;
2795                         }
2796
2797                       local_got_offsets[r_symndx] |= 1;
2798                     }
2799
2800                   relocation = sgot->output_offset + off;
2801                 }
2802               if ((r_type == R_M32R_GOT16_HI_SLO)
2803                   && ((relocation + rel->r_addend) & 0x8000))
2804                 rel->r_addend += 0x10000;
2805
2806               break;
2807
2808             case R_M32R_26_PLTREL:
2809               /* Relocation is to the entry for this symbol in the
2810                  procedure linkage table.  */
2811
2812               /* The native assembler will generate a 26_PLTREL reloc
2813                  for a local symbol if you assemble a call from one
2814                  section to another when using -K pic. */
2815               if (h == NULL)
2816                 break;
2817
2818               if (h->forced_local)
2819                 break;
2820
2821               if (h->plt.offset == (bfd_vma) -1)
2822                 /* We didn't make a PLT entry for this symbol.  This
2823                    happens when statically linking PIC code, or when
2824                    using -Bsymbolic.  */
2825                 break;
2826
2827               relocation = (splt->output_section->vma
2828                             + splt->output_offset
2829                             + h->plt.offset);
2830               break;
2831
2832             case R_M32R_HI16_SLO_RELA:
2833               if ((relocation + rel->r_addend) & 0x8000)
2834                 rel->r_addend += 0x10000;
2835               /* Fall through.  */
2836
2837             case R_M32R_16_RELA:
2838             case R_M32R_24_RELA:
2839             case R_M32R_32_RELA:
2840             case R_M32R_REL32:
2841             case R_M32R_10_PCREL_RELA:
2842             case R_M32R_18_PCREL_RELA:
2843             case R_M32R_26_PCREL_RELA:
2844             case R_M32R_HI16_ULO_RELA:
2845             case R_M32R_LO16_RELA:
2846               if (bfd_link_pic (info)
2847                   && r_symndx != STN_UNDEF
2848                   && (input_section->flags & SEC_ALLOC) != 0
2849                   && ((   r_type != R_M32R_10_PCREL_RELA
2850                        && r_type != R_M32R_18_PCREL_RELA
2851                        && r_type != R_M32R_26_PCREL_RELA
2852                        && r_type != R_M32R_REL32)
2853                       || (h != NULL
2854                           && h->dynindx != -1
2855                           && (! info->symbolic
2856                               || !h->def_regular))))
2857                 {
2858                   Elf_Internal_Rela outrel;
2859                   bfd_boolean skip, relocate;
2860                   bfd_byte *loc;
2861
2862                   /* When generating a shared object, these relocations
2863                      are copied into the output file to be resolved at run
2864                      time.  */
2865                   if (sreloc == NULL)
2866                     {
2867                       sreloc = _bfd_elf_get_dynamic_reloc_section
2868                         (input_bfd, input_section, /*rela?*/ TRUE);
2869                       if (sreloc == NULL)
2870                         return FALSE;
2871                     }
2872
2873                   skip = FALSE;
2874                   relocate = FALSE;
2875
2876                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2877                                                              info,
2878                                                              input_section,
2879                                                              rel->r_offset);
2880                   if (outrel.r_offset == (bfd_vma) -1)
2881                     skip = TRUE;
2882                   else if (outrel.r_offset == (bfd_vma) -2)
2883                     skip = relocate = TRUE;
2884                   outrel.r_offset += (input_section->output_section->vma
2885                                       + input_section->output_offset);
2886
2887                   if (skip)
2888                     memset (&outrel, 0, sizeof outrel);
2889                   else if (   r_type == R_M32R_10_PCREL_RELA
2890                            || r_type == R_M32R_18_PCREL_RELA
2891                            || r_type == R_M32R_26_PCREL_RELA
2892                            || r_type == R_M32R_REL32)
2893                     {
2894                       BFD_ASSERT (h != NULL && h->dynindx != -1);
2895                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2896                       outrel.r_addend = rel->r_addend;
2897                     }
2898                   else
2899                     {
2900                     /* h->dynindx may be -1 if this symbol was marked to
2901                        become local.  */
2902                     if (h == NULL
2903                         || ((info->symbolic || h->dynindx == -1)
2904                              && h->def_regular))
2905                       {
2906                         relocate = TRUE;
2907                         outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2908                         outrel.r_addend = relocation + rel->r_addend;
2909                       }
2910                     else
2911                       {
2912                         BFD_ASSERT (h->dynindx != -1);
2913                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2914                         outrel.r_addend = relocation + rel->r_addend;
2915                       }
2916                     }
2917
2918                   loc = sreloc->contents;
2919                   loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2920                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2921                   ++sreloc->reloc_count;
2922
2923                   /* If this reloc is against an external symbol, we do
2924                      not want to fiddle with the addend.  Otherwise, we
2925                      need to include the symbol value so that it becomes
2926                      an addend for the dynamic reloc.  */
2927                   if (! relocate)
2928                     continue;
2929                   break;
2930                 }
2931               else if (r_type != R_M32R_10_PCREL_RELA)
2932                 break;
2933               /* Fall through.  */
2934
2935             case (int) R_M32R_10_PCREL :
2936               r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2937                                               contents, offset,
2938                                               sec, relocation, addend);
2939               goto check_reloc;
2940
2941             case (int) R_M32R_HI16_SLO :
2942             case (int) R_M32R_HI16_ULO :
2943               {
2944                 Elf_Internal_Rela *lorel;
2945
2946                 /* We allow an arbitrary number of HI16 relocs before the
2947                    LO16 reloc.  This permits gcc to emit the HI and LO relocs
2948                    itself.  */
2949                 for (lorel = rel + 1;
2950                      (lorel < relend
2951                       && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2952                           || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2953                      lorel++)
2954                   continue;
2955                 if (lorel < relend
2956                     && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2957                   {
2958                     m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2959                                             contents, relocation + addend);
2960                     r = bfd_reloc_ok;
2961                   }
2962                 else
2963                   r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2964                                                 contents, offset,
2965                                                 relocation, addend);
2966               }
2967
2968               goto check_reloc;
2969
2970             case (int) R_M32R_SDA16_RELA:
2971             case (int) R_M32R_SDA16 :
2972               {
2973                 const char *name;
2974
2975                 BFD_ASSERT (sec != NULL);
2976                 name = bfd_get_section_name (sec->owner, sec);
2977
2978                 if (   strcmp (name, ".sdata") == 0
2979                     || strcmp (name, ".sbss") == 0
2980                     || strcmp (name, ".scommon") == 0)
2981                   {
2982                     bfd_vma sda_base;
2983                     bfd *out_bfd = sec->output_section->owner;
2984
2985                     r = m32r_elf_final_sda_base (out_bfd, info,
2986                                                  &errmsg,
2987                                                  &sda_base);
2988                     if (r != bfd_reloc_ok)
2989                       {
2990                         ret = FALSE;
2991                         goto check_reloc;
2992                       }
2993
2994                     /* At this point `relocation' contains the object's
2995                        address.  */
2996                     relocation -= sda_base;
2997                     /* Now it contains the offset from _SDA_BASE_.  */
2998                   }
2999                 else
3000                   {
3001                     _bfd_error_handler
3002                       /* xgettext:c-format */
3003                       (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3004                        input_bfd,
3005                        sym_name,
3006                        m32r_elf_howto_table[(int) r_type].name,
3007                        sec);
3008                     /*bfd_set_error (bfd_error_bad_value); ??? why? */
3009                     ret = FALSE;
3010                     continue;
3011                   }
3012               }
3013               /* Fall through.  */
3014
3015             default : /* OLD_M32R_RELOC */
3016
3017               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3018                                             contents, offset,
3019                                             relocation, addend);
3020               goto check_reloc;
3021             }
3022
3023           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3024                                         contents, rel->r_offset,
3025                                         relocation, rel->r_addend);
3026
3027         }
3028
3029     check_reloc:
3030
3031       if (r != bfd_reloc_ok)
3032         {
3033           /* FIXME: This should be generic enough to go in a utility.  */
3034           const char *name;
3035
3036           if (h != NULL)
3037             name = h->root.root.string;
3038           else
3039             {
3040               name = (bfd_elf_string_from_elf_section
3041                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
3042               if (name == NULL || *name == '\0')
3043                 name = bfd_section_name (input_bfd, sec);
3044             }
3045
3046           if (errmsg != NULL)
3047             goto common_error;
3048
3049           switch (r)
3050             {
3051             case bfd_reloc_overflow:
3052               (*info->callbacks->reloc_overflow)
3053                 (info, (h ? &h->root : NULL), name, howto->name,
3054                  (bfd_vma) 0, input_bfd, input_section, offset);
3055               break;
3056
3057             case bfd_reloc_undefined:
3058               (*info->callbacks->undefined_symbol)
3059                 (info, name, input_bfd, input_section, offset, TRUE);
3060               break;
3061
3062             case bfd_reloc_outofrange:
3063               errmsg = _("internal error: out of range error");
3064               goto common_error;
3065
3066             case bfd_reloc_notsupported:
3067               errmsg = _("internal error: unsupported relocation error");
3068               goto common_error;
3069
3070             case bfd_reloc_dangerous:
3071               errmsg = _("internal error: dangerous error");
3072               goto common_error;
3073
3074             default:
3075               errmsg = _("internal error: unknown error");
3076               /* fall through */
3077
3078             common_error:
3079               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
3080                                            input_section, offset);
3081               break;
3082             }
3083         }
3084     }
3085
3086   return ret;
3087 }
3088
3089 /* Finish up dynamic symbol handling.  We set the contents of various
3090    dynamic sections here.  */
3091
3092 static bfd_boolean
3093 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3094                                 struct bfd_link_info *info,
3095                                 struct elf_link_hash_entry *h,
3096                                 Elf_Internal_Sym *sym)
3097 {
3098   struct elf_m32r_link_hash_table *htab;
3099   bfd_byte *loc;
3100
3101 #ifdef DEBUG_PIC
3102   printf ("m32r_elf_finish_dynamic_symbol()\n");
3103 #endif
3104
3105   htab = m32r_elf_hash_table (info);
3106   if (htab == NULL)
3107     return FALSE;
3108
3109   if (h->plt.offset != (bfd_vma) -1)
3110     {
3111       asection *splt;
3112       asection *sgot;
3113       asection *srela;
3114
3115       bfd_vma plt_index;
3116       bfd_vma got_offset;
3117       Elf_Internal_Rela rela;
3118
3119       /* This symbol has an entry in the procedure linkage table.  Set
3120          it up.  */
3121
3122       BFD_ASSERT (h->dynindx != -1);
3123
3124       splt = htab->root.splt;
3125       sgot = htab->root.sgotplt;
3126       srela = htab->root.srelplt;
3127       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3128
3129       /* Get the index in the procedure linkage table which
3130          corresponds to this symbol.  This is the index of this symbol
3131          in all the symbols for which we are making plt entries.  The
3132          first entry in the procedure linkage table is reserved.  */
3133       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3134
3135       /* Get the offset into the .got table of the entry that
3136         corresponds to this function.  Each .got entry is 4 bytes.
3137         The first three are reserved.  */
3138       got_offset = (plt_index + 3) * 4;
3139
3140       /* Fill in the entry in the procedure linkage table.  */
3141       if (! bfd_link_pic (info))
3142         {
3143           bfd_put_32 (output_bfd,
3144               (PLT_ENTRY_WORD0b
3145                + (((sgot->output_section->vma
3146                     + sgot->output_offset
3147                     + got_offset) >> 16) & 0xffff)),
3148               splt->contents + h->plt.offset);
3149           bfd_put_32 (output_bfd,
3150               (PLT_ENTRY_WORD1b
3151                + ((sgot->output_section->vma
3152                    + sgot->output_offset
3153                    + got_offset) & 0xffff)),
3154               splt->contents + h->plt.offset + 4);
3155           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3156               splt->contents + h->plt.offset + 8);
3157           bfd_put_32 (output_bfd,
3158               (PLT_ENTRY_WORD3
3159                + plt_index * sizeof (Elf32_External_Rela)),
3160               splt->contents + h->plt.offset + 12);
3161           bfd_put_32 (output_bfd,
3162               (PLT_ENTRY_WORD4
3163                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3164               splt->contents + h->plt.offset + 16);
3165         }
3166       else
3167         {
3168           bfd_put_32 (output_bfd,
3169               PLT_ENTRY_WORD0 + got_offset,
3170               splt->contents + h->plt.offset);
3171           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3172               splt->contents + h->plt.offset + 4);
3173           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3174               splt->contents + h->plt.offset + 8);
3175           bfd_put_32 (output_bfd,
3176               (PLT_ENTRY_WORD3
3177                + plt_index * sizeof (Elf32_External_Rela)),
3178               splt->contents + h->plt.offset + 12);
3179           bfd_put_32 (output_bfd,
3180               (PLT_ENTRY_WORD4
3181                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3182               splt->contents + h->plt.offset + 16);
3183         }
3184
3185       /* Fill in the entry in the global offset table.  */
3186       bfd_put_32 (output_bfd,
3187                   (splt->output_section->vma
3188                    + splt->output_offset
3189                    + h->plt.offset
3190                    + 12), /* same offset */
3191                   sgot->contents + got_offset);
3192
3193       /* Fill in the entry in the .rela.plt section.  */
3194       rela.r_offset = (sgot->output_section->vma
3195                        + sgot->output_offset
3196                        + got_offset);
3197       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3198       rela.r_addend = 0;
3199       loc = srela->contents;
3200       loc += plt_index * sizeof (Elf32_External_Rela);
3201       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3202
3203       if (!h->def_regular)
3204         {
3205           /* Mark the symbol as undefined, rather than as defined in
3206              the .plt section.  Leave the value alone.  */
3207           sym->st_shndx = SHN_UNDEF;
3208         }
3209     }
3210
3211   if (h->got.offset != (bfd_vma) -1)
3212     {
3213       asection *sgot;
3214       asection *srela;
3215       Elf_Internal_Rela rela;
3216
3217       /* This symbol has an entry in the global offset table.  Set it
3218          up.  */
3219
3220       sgot = htab->root.sgot;
3221       srela = htab->root.srelgot;
3222       BFD_ASSERT (sgot != NULL && srela != NULL);
3223
3224       rela.r_offset = (sgot->output_section->vma
3225                        + sgot->output_offset
3226                        + (h->got.offset &~ 1));
3227
3228       /* If this is a -Bsymbolic link, and the symbol is defined
3229          locally, we just want to emit a RELATIVE reloc.  Likewise if
3230          the symbol was forced to be local because of a version file.
3231          The entry in the global offset table will already have been
3232          initialized in the relocate_section function.  */
3233       if (bfd_link_pic (info)
3234           && (info->symbolic
3235               || h->dynindx == -1
3236               || h->forced_local)
3237           && h->def_regular)
3238         {
3239           rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3240           rela.r_addend = (h->root.u.def.value
3241                            + h->root.u.def.section->output_section->vma
3242                            + h->root.u.def.section->output_offset);
3243         }
3244       else
3245         {
3246           BFD_ASSERT ((h->got.offset & 1) == 0);
3247           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3248           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3249           rela.r_addend = 0;
3250         }
3251
3252       loc = srela->contents;
3253       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3254       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3255       ++srela->reloc_count;
3256     }
3257
3258   if (h->needs_copy)
3259     {
3260       asection *s;
3261       Elf_Internal_Rela rela;
3262
3263       /* This symbols needs a copy reloc.  Set it up.  */
3264
3265       BFD_ASSERT (h->dynindx != -1
3266                   && (h->root.type == bfd_link_hash_defined
3267                       || h->root.type == bfd_link_hash_defweak));
3268
3269       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
3270       BFD_ASSERT (s != NULL);
3271
3272       rela.r_offset = (h->root.u.def.value
3273                        + h->root.u.def.section->output_section->vma
3274                        + h->root.u.def.section->output_offset);
3275       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3276       rela.r_addend = 0;
3277       loc = s->contents;
3278       loc += s->reloc_count * sizeof (Elf32_External_Rela);
3279       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3280       ++s->reloc_count;
3281     }
3282
3283   /* Mark some specially defined symbols as absolute.  */
3284   if (h == htab->root.hdynamic || h == htab->root.hgot)
3285     sym->st_shndx = SHN_ABS;
3286
3287   return TRUE;
3288 }
3289
3290
3291 /* Finish up the dynamic sections.  */
3292
3293 static bfd_boolean
3294 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3295                                   struct bfd_link_info *info)
3296 {
3297   struct elf_m32r_link_hash_table *htab;
3298   bfd *dynobj;
3299   asection *sdyn;
3300   asection *sgot;
3301
3302 #ifdef DEBUG_PIC
3303   printf ("m32r_elf_finish_dynamic_sections()\n");
3304 #endif
3305
3306   htab = m32r_elf_hash_table (info);
3307   if (htab == NULL)
3308     return FALSE;
3309
3310   dynobj = htab->root.dynobj;
3311
3312   sgot = htab->root.sgotplt;
3313   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3314
3315   if (htab->root.dynamic_sections_created)
3316     {
3317       asection *splt;
3318       Elf32_External_Dyn *dyncon, *dynconend;
3319
3320       BFD_ASSERT (sgot != NULL && sdyn != NULL);
3321
3322       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3323       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3324
3325       for (; dyncon < dynconend; dyncon++)
3326         {
3327           Elf_Internal_Dyn dyn;
3328           asection *s;
3329
3330           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3331
3332           switch (dyn.d_tag)
3333             {
3334             default:
3335               break;
3336
3337             case DT_PLTGOT:
3338               s = htab->root.sgotplt;
3339               goto get_vma;
3340             case DT_JMPREL:
3341               s = htab->root.srelplt;
3342             get_vma:
3343               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3344               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3345               break;
3346
3347             case DT_PLTRELSZ:
3348               s = htab->root.srelplt;
3349               dyn.d_un.d_val = s->size;
3350               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3351               break;
3352             }
3353         }
3354
3355       /* Fill in the first entry in the procedure linkage table.  */
3356       splt = htab->root.splt;
3357       if (splt && splt->size > 0)
3358         {
3359           if (bfd_link_pic (info))
3360             {
3361               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3362               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3363               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3364               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3365               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3366             }
3367           else
3368             {
3369               unsigned long addr;
3370               /* addr = .got + 4 */
3371               addr = sgot->output_section->vma + sgot->output_offset + 4;
3372               bfd_put_32 (output_bfd,
3373                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3374                           splt->contents);
3375               bfd_put_32 (output_bfd,
3376                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
3377                           splt->contents + 4);
3378               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3379               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3380               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3381             }
3382
3383           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3384             PLT_ENTRY_SIZE;
3385         }
3386     }
3387
3388   /* Fill in the first three entries in the global offset table.  */
3389   if (sgot && sgot->size > 0)
3390     {
3391       if (sdyn == NULL)
3392         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3393       else
3394         bfd_put_32 (output_bfd,
3395                     sdyn->output_section->vma + sdyn->output_offset,
3396                     sgot->contents);
3397       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3398       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3399
3400       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3401     }
3402
3403   return TRUE;
3404 }
3405
3406 \f
3407 /* Set the right machine number.  */
3408
3409 static bfd_boolean
3410 m32r_elf_object_p (bfd *abfd)
3411 {
3412   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3413     {
3414     default:
3415     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3416     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3417     case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3418     }
3419   return TRUE;
3420 }
3421
3422 /* Store the machine number in the flags field.  */
3423
3424 static void
3425 m32r_elf_final_write_processing (bfd *abfd,
3426                                  bfd_boolean linker ATTRIBUTE_UNUSED)
3427 {
3428   unsigned long val;
3429
3430   switch (bfd_get_mach (abfd))
3431     {
3432     default:
3433     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3434     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3435     case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3436     }
3437
3438   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3439   elf_elfheader (abfd)->e_flags |= val;
3440 }
3441
3442 /* Function to keep M32R specific file flags.  */
3443
3444 static bfd_boolean
3445 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3446 {
3447   BFD_ASSERT (!elf_flags_init (abfd)
3448               || elf_elfheader (abfd)->e_flags == flags);
3449
3450   elf_elfheader (abfd)->e_flags = flags;
3451   elf_flags_init (abfd) = TRUE;
3452   return TRUE;
3453 }
3454
3455 /* Merge backend specific data from an object file to the output
3456    object file when linking.  */
3457
3458 static bfd_boolean
3459 m32r_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3460 {
3461   bfd *obfd = info->output_bfd;
3462   flagword out_flags;
3463   flagword in_flags;
3464
3465   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3466       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3467     return TRUE;
3468
3469   in_flags  = elf_elfheader (ibfd)->e_flags;
3470   out_flags = elf_elfheader (obfd)->e_flags;
3471
3472   if (! elf_flags_init (obfd))
3473     {
3474       /* If the input is the default architecture then do not
3475          bother setting the flags for the output architecture,
3476          instead allow future merges to do this.  If no future
3477          merges ever set these flags then they will retain their
3478          unitialised values, which surprise surprise, correspond
3479          to the default values.  */
3480       if (bfd_get_arch_info (ibfd)->the_default)
3481         return TRUE;
3482
3483       elf_flags_init (obfd) = TRUE;
3484       elf_elfheader (obfd)->e_flags = in_flags;
3485
3486       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3487           && bfd_get_arch_info (obfd)->the_default)
3488         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3489                                   bfd_get_mach (ibfd));
3490
3491       return TRUE;
3492     }
3493
3494   /* Check flag compatibility.  */
3495   if (in_flags == out_flags)
3496     return TRUE;
3497
3498   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3499     {
3500       if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3501           || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3502           || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3503         {
3504           _bfd_error_handler
3505             (_("%B: Instruction set mismatch with previous modules"), ibfd);
3506
3507           bfd_set_error (bfd_error_bad_value);
3508           return FALSE;
3509         }
3510     }
3511
3512   return TRUE;
3513 }
3514
3515 /* Display the flags field.  */
3516
3517 static bfd_boolean
3518 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3519 {
3520   FILE * file = (FILE *) ptr;
3521
3522   BFD_ASSERT (abfd != NULL && ptr != NULL);
3523
3524   _bfd_elf_print_private_bfd_data (abfd, ptr);
3525
3526   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3527
3528   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3529     {
3530     default:
3531     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3532     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3533     case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3534     }
3535
3536   fputc ('\n', file);
3537
3538   return TRUE;
3539 }
3540
3541 static asection *
3542 m32r_elf_gc_mark_hook (asection *sec,
3543                        struct bfd_link_info *info,
3544                        Elf_Internal_Rela *rel,
3545                        struct elf_link_hash_entry *h,
3546                        Elf_Internal_Sym *sym)
3547 {
3548   if (h != NULL)
3549     switch (ELF32_R_TYPE (rel->r_info))
3550       {
3551       case R_M32R_GNU_VTINHERIT:
3552       case R_M32R_GNU_VTENTRY:
3553       case R_M32R_RELA_GNU_VTINHERIT:
3554       case R_M32R_RELA_GNU_VTENTRY:
3555         return NULL;
3556       }
3557
3558   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3559 }
3560
3561 /* Look through the relocs for a section during the first phase.
3562    Since we don't do .gots or .plts, we just need to consider the
3563    virtual table relocs for gc.  */
3564
3565 static bfd_boolean
3566 m32r_elf_check_relocs (bfd *abfd,
3567                        struct bfd_link_info *info,
3568                        asection *sec,
3569                        const Elf_Internal_Rela *relocs)
3570 {
3571   Elf_Internal_Shdr *symtab_hdr;
3572   struct elf_link_hash_entry **sym_hashes;
3573   const Elf_Internal_Rela *rel;
3574   const Elf_Internal_Rela *rel_end;
3575   struct elf_m32r_link_hash_table *htab;
3576   bfd *dynobj;
3577   asection *sreloc;
3578
3579   if (bfd_link_relocatable (info))
3580     return TRUE;
3581
3582   sreloc = NULL;
3583   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3584   sym_hashes = elf_sym_hashes (abfd);
3585
3586   htab = m32r_elf_hash_table (info);
3587   if (htab == NULL)
3588     return FALSE;
3589
3590   dynobj = htab->root.dynobj;
3591
3592   rel_end = relocs + sec->reloc_count;
3593   for (rel = relocs; rel < rel_end; rel++)
3594     {
3595       int r_type;
3596       struct elf_link_hash_entry *h;
3597       unsigned long r_symndx;
3598
3599       r_symndx = ELF32_R_SYM (rel->r_info);
3600       r_type = ELF32_R_TYPE (rel->r_info);
3601       if (r_symndx < symtab_hdr->sh_info)
3602         h = NULL;
3603       else
3604         {
3605           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3606           while (h->root.type == bfd_link_hash_indirect
3607                  || h->root.type == bfd_link_hash_warning)
3608             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3609         }
3610
3611       /* Some relocs require a global offset table.  */
3612       if (htab->root.sgot == NULL)
3613         {
3614           switch (r_type)
3615             {
3616             case R_M32R_GOT16_HI_ULO:
3617             case R_M32R_GOT16_HI_SLO:
3618             case R_M32R_GOTOFF:
3619             case R_M32R_GOTOFF_HI_ULO:
3620             case R_M32R_GOTOFF_HI_SLO:
3621             case R_M32R_GOTOFF_LO:
3622             case R_M32R_GOT16_LO:
3623             case R_M32R_GOTPC24:
3624             case R_M32R_GOTPC_HI_ULO:
3625             case R_M32R_GOTPC_HI_SLO:
3626             case R_M32R_GOTPC_LO:
3627             case R_M32R_GOT24:
3628               if (dynobj == NULL)
3629                 htab->root.dynobj = dynobj = abfd;
3630               if (!_bfd_elf_create_got_section (dynobj, info))
3631                 return FALSE;
3632               break;
3633
3634             default:
3635               break;
3636           }
3637         }
3638
3639       switch (r_type)
3640         {
3641         case R_M32R_GOT16_HI_ULO:
3642         case R_M32R_GOT16_HI_SLO:
3643         case R_M32R_GOT16_LO:
3644         case R_M32R_GOT24:
3645
3646           if (h != NULL)
3647             h->got.refcount += 1;
3648           else
3649             {
3650               bfd_signed_vma *local_got_refcounts;
3651
3652               /* This is a global offset table entry for a local
3653                  symbol.  */
3654               local_got_refcounts = elf_local_got_refcounts (abfd);
3655               if (local_got_refcounts == NULL)
3656                 {
3657                   bfd_size_type size;
3658
3659                   size = symtab_hdr->sh_info;
3660                   size *= sizeof (bfd_signed_vma);
3661                   local_got_refcounts = bfd_zalloc (abfd, size);
3662                   if (local_got_refcounts == NULL)
3663                     return FALSE;
3664                   elf_local_got_refcounts (abfd) = local_got_refcounts;
3665                 }
3666               local_got_refcounts[r_symndx] += 1;
3667             }
3668           break;
3669
3670         case R_M32R_26_PLTREL:
3671           /* This symbol requires a procedure linkage table entry.  We
3672              actually build the entry in adjust_dynamic_symbol,
3673              because this might be a case of linking PIC code without
3674              linking in any dynamic objects, in which case we don't
3675              need to generate a procedure linkage table after all.  */
3676
3677           /* If this is a local symbol, we resolve it directly without
3678              creating a procedure linkage table entry.  */
3679           if (h == NULL)
3680             continue;
3681
3682           if (h->forced_local)
3683             break;
3684
3685           h->needs_plt = 1;
3686           h->plt.refcount += 1;
3687           break;
3688
3689         case R_M32R_16_RELA:
3690         case R_M32R_24_RELA:
3691         case R_M32R_32_RELA:
3692         case R_M32R_REL32:
3693         case R_M32R_HI16_ULO_RELA:
3694         case R_M32R_HI16_SLO_RELA:
3695         case R_M32R_LO16_RELA:
3696         case R_M32R_SDA16_RELA:
3697         case R_M32R_10_PCREL_RELA:
3698         case R_M32R_18_PCREL_RELA:
3699         case R_M32R_26_PCREL_RELA:
3700
3701           if (h != NULL && !bfd_link_pic (info))
3702             {
3703               h->non_got_ref = 1;
3704               h->plt.refcount += 1;
3705             }
3706
3707           /* If we are creating a shared library, and this is a reloc
3708              against a global symbol, or a non PC relative reloc
3709              against a local symbol, then we need to copy the reloc
3710              into the shared library.  However, if we are linking with
3711              -Bsymbolic, we do not need to copy a reloc against a
3712              global symbol which is defined in an object we are
3713              including in the link (i.e., DEF_REGULAR is set).  At
3714              this point we have not seen all the input files, so it is
3715              possible that DEF_REGULAR is not set now but will be set
3716              later (it is never cleared).  We account for that
3717              possibility below by storing information in the
3718              dyn_relocs field of the hash table entry. A similar
3719              situation occurs when creating shared libraries and symbol
3720              visibility changes render the symbol local.
3721
3722              If on the other hand, we are creating an executable, we
3723              may need to keep relocations for symbols satisfied by a
3724              dynamic library if we manage to avoid copy relocs for the
3725              symbol.  */
3726           if ((bfd_link_pic (info)
3727                && (sec->flags & SEC_ALLOC) != 0
3728                && ((   r_type != R_M32R_26_PCREL_RELA
3729                     && r_type != R_M32R_18_PCREL_RELA
3730                     && r_type != R_M32R_10_PCREL_RELA
3731                     && r_type != R_M32R_REL32)
3732                    || (h != NULL
3733                        && (! info->symbolic
3734                            || h->root.type == bfd_link_hash_defweak
3735                            || !h->def_regular))))
3736               || (!bfd_link_pic (info)
3737                   && (sec->flags & SEC_ALLOC) != 0
3738                   && h != NULL
3739                   && (h->root.type == bfd_link_hash_defweak
3740                       || !h->def_regular)))
3741             {
3742               struct elf_m32r_dyn_relocs *p;
3743               struct elf_m32r_dyn_relocs **head;
3744
3745               if (dynobj == NULL)
3746                 htab->root.dynobj = dynobj = abfd;
3747
3748               /* When creating a shared object, we must copy these
3749                  relocs into the output file.  We create a reloc
3750                  section in dynobj and make room for the reloc.  */
3751               if (sreloc == NULL)
3752                 {
3753                   sreloc = _bfd_elf_make_dynamic_reloc_section
3754                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3755
3756                   if (sreloc == NULL)
3757                     return FALSE;
3758                 }
3759
3760               /* If this is a global symbol, we count the number of
3761                  relocations we need for this symbol.  */
3762               if (h != NULL)
3763                 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3764               else
3765                 {
3766                   /* Track dynamic relocs needed for local syms too.  */
3767                   asection *s;
3768                   void *vpp;
3769                   Elf_Internal_Sym *isym;
3770
3771                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3772                                                 abfd, r_symndx);
3773                   if (isym == NULL)
3774                     return FALSE;
3775
3776                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3777                   if (s == NULL)
3778                     s = sec;
3779
3780                   vpp = &elf_section_data (s)->local_dynrel;
3781                   head = (struct elf_m32r_dyn_relocs **) vpp;
3782                 }
3783
3784               p = *head;
3785               if (p == NULL || p->sec != sec)
3786                 {
3787                   bfd_size_type amt = sizeof (*p);
3788
3789                   p = bfd_alloc (dynobj, amt);
3790                   if (p == NULL)
3791                     return FALSE;
3792                   p->next = *head;
3793                   *head = p;
3794                   p->sec = sec;
3795                   p->count = 0;
3796                   p->pc_count = 0;
3797                 }
3798
3799               p->count += 1;
3800               if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3801                   || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3802                   || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3803                   || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3804                 p->pc_count += 1;
3805             }
3806           break;
3807
3808         /* This relocation describes the C++ object vtable hierarchy.
3809            Reconstruct it for later use during GC.  */
3810         case R_M32R_RELA_GNU_VTINHERIT:
3811         case R_M32R_GNU_VTINHERIT:
3812           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3813             return FALSE;
3814           break;
3815
3816         /* This relocation describes which C++ vtable entries are actually
3817            used.  Record for later use during GC.  */
3818         case R_M32R_GNU_VTENTRY:
3819           BFD_ASSERT (h != NULL);
3820           if (h != NULL
3821               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3822             return FALSE;
3823           break;
3824         case R_M32R_RELA_GNU_VTENTRY:
3825           BFD_ASSERT (h != NULL);
3826           if (h != NULL
3827               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3828             return FALSE;
3829           break;
3830         }
3831     }
3832
3833   return TRUE;
3834 }
3835
3836 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
3837 {
3838   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3839   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3840   { NULL,                     0,  0, 0,            0 }
3841 };
3842
3843 static enum elf_reloc_type_class
3844 m32r_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3845                            const asection *rel_sec ATTRIBUTE_UNUSED,
3846                            const Elf_Internal_Rela *rela)
3847 {
3848   switch ((int) ELF32_R_TYPE (rela->r_info))
3849     {
3850     case R_M32R_RELATIVE:  return reloc_class_relative;
3851     case R_M32R_JMP_SLOT:  return reloc_class_plt;
3852     case R_M32R_COPY:      return reloc_class_copy;
3853     default:               return reloc_class_normal;
3854     }
3855 }
3856 \f
3857 #define ELF_ARCH                bfd_arch_m32r
3858 #define ELF_TARGET_ID           M32R_ELF_DATA
3859 #define ELF_MACHINE_CODE        EM_M32R
3860 #define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
3861 #define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
3862
3863 #define TARGET_BIG_SYM          m32r_elf32_vec
3864 #define TARGET_BIG_NAME         "elf32-m32r"
3865 #define TARGET_LITTLE_SYM       m32r_elf32_le_vec
3866 #define TARGET_LITTLE_NAME      "elf32-m32rle"
3867
3868 #define elf_info_to_howto                       m32r_info_to_howto
3869 #define elf_info_to_howto_rel                   m32r_info_to_howto_rel
3870 #define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
3871 #define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
3872 #define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
3873 #define elf_backend_relocate_section            m32r_elf_relocate_section
3874 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
3875 #define elf_backend_check_relocs                m32r_elf_check_relocs
3876
3877 #define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
3878 #define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
3879 #define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
3880 #define elf_backend_omit_section_dynsym \
3881   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
3882 #define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
3883 #define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
3884 #define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
3885 #define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
3886 #define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
3887
3888 #define elf_backend_can_gc_sections             1
3889 /*#if !USE_REL
3890 #define elf_backend_rela_normal                 1
3891 #endif*/
3892 #define elf_backend_can_refcount 1
3893 #define elf_backend_want_got_plt 1
3894 #define elf_backend_plt_readonly 1
3895 #define elf_backend_want_plt_sym 0
3896 #define elf_backend_got_header_size 12
3897 #define elf_backend_dtrel_excludes_plt  1
3898
3899 #define elf_backend_may_use_rel_p       1
3900 #ifdef USE_M32R_OLD_RELOC
3901 #define elf_backend_default_use_rela_p  0
3902 #define elf_backend_may_use_rela_p      0
3903 #else
3904 #define elf_backend_default_use_rela_p  1
3905 #define elf_backend_may_use_rela_p      1
3906 #endif
3907
3908 #define elf_backend_object_p                    m32r_elf_object_p
3909 #define elf_backend_final_write_processing      m32r_elf_final_write_processing
3910 #define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
3911 #define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
3912 #define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
3913 #define elf_backend_special_sections            m32r_elf_special_sections
3914
3915 #define elf_backend_linux_prpsinfo32_ugid16     TRUE
3916
3917 #include "elf32-target.h"
3918
3919 #undef  ELF_MAXPAGESIZE
3920 #define ELF_MAXPAGESIZE         0x1000
3921
3922 #undef  TARGET_BIG_SYM
3923 #define TARGET_BIG_SYM          m32r_elf32_linux_vec
3924 #undef  TARGET_BIG_NAME
3925 #define TARGET_BIG_NAME         "elf32-m32r-linux"
3926 #undef  TARGET_LITTLE_SYM
3927 #define TARGET_LITTLE_SYM       m32r_elf32_linux_le_vec
3928 #undef  TARGET_LITTLE_NAME
3929 #define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
3930 #undef  elf32_bed
3931 #define elf32_bed               elf32_m32r_lin_bed
3932
3933 #include "elf32-target.h"