bfd/elf32-m32r.c

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