bfd/elf32-m32r.c

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