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 is in the wrong section (%pA)"),
2973                        input_bfd,
2974                        sym_name,
2975                        m32r_elf_howto_table[(int) r_type].name,
2976                        sec);
2977                     /*bfd_set_error (bfd_error_bad_value); ??? why? */
2978                     ret = FALSE;
2979                     continue;
2980                   }
2981               }
2982               /* Fall through.  */
2983
2984             default : /* OLD_M32R_RELOC */
2985
2986               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2987                                             contents, offset,
2988                                             relocation, addend);
2989               goto check_reloc;
2990             }
2991
2992           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2993                                         contents, rel->r_offset,
2994                                         relocation, rel->r_addend);
2995
2996         }
2997
2998     check_reloc:
2999
3000       if (r != bfd_reloc_ok)
3001         {
3002           /* FIXME: This should be generic enough to go in a utility.  */
3003           const char *name;
3004
3005           if (h != NULL)
3006             name = h->root.root.string;
3007           else
3008             {
3009               name = (bfd_elf_string_from_elf_section
3010                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
3011               if (name == NULL || *name == '\0')
3012                 name = bfd_section_name (input_bfd, sec);
3013             }
3014
3015           if (errmsg != NULL)
3016             goto common_error;
3017
3018           switch (r)
3019             {
3020             case bfd_reloc_overflow:
3021               (*info->callbacks->reloc_overflow)
3022                 (info, (h ? &h->root : NULL), name, howto->name,
3023                  (bfd_vma) 0, input_bfd, input_section, offset);
3024               break;
3025
3026             case bfd_reloc_undefined:
3027               (*info->callbacks->undefined_symbol)
3028                 (info, name, input_bfd, input_section, offset, TRUE);
3029               break;
3030
3031             case bfd_reloc_outofrange:
3032               errmsg = _("internal error: out of range error");
3033               goto common_error;
3034
3035             case bfd_reloc_notsupported:
3036               errmsg = _("internal error: unsupported relocation error");
3037               goto common_error;
3038
3039             case bfd_reloc_dangerous:
3040               errmsg = _("internal error: dangerous error");
3041               goto common_error;
3042
3043             default:
3044               errmsg = _("internal error: unknown error");
3045               /* fall through */
3046
3047             common_error:
3048               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
3049                                            input_section, offset);
3050               break;
3051             }
3052         }
3053     }
3054
3055   return ret;
3056 }
3057
3058 /* Finish up dynamic symbol handling.  We set the contents of various
3059    dynamic sections here.  */
3060
3061 static bfd_boolean
3062 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3063                                 struct bfd_link_info *info,
3064                                 struct elf_link_hash_entry *h,
3065                                 Elf_Internal_Sym *sym)
3066 {
3067   struct elf_m32r_link_hash_table *htab;
3068   bfd_byte *loc;
3069
3070 #ifdef DEBUG_PIC
3071   printf ("m32r_elf_finish_dynamic_symbol()\n");
3072 #endif
3073
3074   htab = m32r_elf_hash_table (info);
3075   if (htab == NULL)
3076     return FALSE;
3077
3078   if (h->plt.offset != (bfd_vma) -1)
3079     {
3080       asection *splt;
3081       asection *sgot;
3082       asection *srela;
3083
3084       bfd_vma plt_index;
3085       bfd_vma got_offset;
3086       Elf_Internal_Rela rela;
3087
3088       /* This symbol has an entry in the procedure linkage table.  Set
3089          it up.  */
3090
3091       BFD_ASSERT (h->dynindx != -1);
3092
3093       splt = htab->root.splt;
3094       sgot = htab->root.sgotplt;
3095       srela = htab->root.srelplt;
3096       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3097
3098       /* Get the index in the procedure linkage table which
3099          corresponds to this symbol.  This is the index of this symbol
3100          in all the symbols for which we are making plt entries.  The
3101          first entry in the procedure linkage table is reserved.  */
3102       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3103
3104       /* Get the offset into the .got table of the entry that
3105         corresponds to this function.  Each .got entry is 4 bytes.
3106         The first three are reserved.  */
3107       got_offset = (plt_index + 3) * 4;
3108
3109       /* Fill in the entry in the procedure linkage table.  */
3110       if (! bfd_link_pic (info))
3111         {
3112           bfd_put_32 (output_bfd,
3113               (PLT_ENTRY_WORD0b
3114                + (((sgot->output_section->vma
3115                     + sgot->output_offset
3116                     + got_offset) >> 16) & 0xffff)),
3117               splt->contents + h->plt.offset);
3118           bfd_put_32 (output_bfd,
3119               (PLT_ENTRY_WORD1b
3120                + ((sgot->output_section->vma
3121                    + sgot->output_offset
3122                    + got_offset) & 0xffff)),
3123               splt->contents + h->plt.offset + 4);
3124           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3125               splt->contents + h->plt.offset + 8);
3126           bfd_put_32 (output_bfd,
3127               (PLT_ENTRY_WORD3
3128                + plt_index * sizeof (Elf32_External_Rela)),
3129               splt->contents + h->plt.offset + 12);
3130           bfd_put_32 (output_bfd,
3131               (PLT_ENTRY_WORD4
3132                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3133               splt->contents + h->plt.offset + 16);
3134         }
3135       else
3136         {
3137           bfd_put_32 (output_bfd,
3138               PLT_ENTRY_WORD0 + got_offset,
3139               splt->contents + h->plt.offset);
3140           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3141               splt->contents + h->plt.offset + 4);
3142           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3143               splt->contents + h->plt.offset + 8);
3144           bfd_put_32 (output_bfd,
3145               (PLT_ENTRY_WORD3
3146                + plt_index * sizeof (Elf32_External_Rela)),
3147               splt->contents + h->plt.offset + 12);
3148           bfd_put_32 (output_bfd,
3149               (PLT_ENTRY_WORD4
3150                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3151               splt->contents + h->plt.offset + 16);
3152         }
3153
3154       /* Fill in the entry in the global offset table.  */
3155       bfd_put_32 (output_bfd,
3156                   (splt->output_section->vma
3157                    + splt->output_offset
3158                    + h->plt.offset
3159                    + 12), /* same offset */
3160                   sgot->contents + got_offset);
3161
3162       /* Fill in the entry in the .rela.plt section.  */
3163       rela.r_offset = (sgot->output_section->vma
3164                        + sgot->output_offset
3165                        + got_offset);
3166       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3167       rela.r_addend = 0;
3168       loc = srela->contents;
3169       loc += plt_index * sizeof (Elf32_External_Rela);
3170       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3171
3172       if (!h->def_regular)
3173         {
3174           /* Mark the symbol as undefined, rather than as defined in
3175              the .plt section.  Leave the value alone.  */
3176           sym->st_shndx = SHN_UNDEF;
3177         }
3178     }
3179
3180   if (h->got.offset != (bfd_vma) -1)
3181     {
3182       asection *sgot;
3183       asection *srela;
3184       Elf_Internal_Rela rela;
3185
3186       /* This symbol has an entry in the global offset table.  Set it
3187          up.  */
3188
3189       sgot = htab->root.sgot;
3190       srela = htab->root.srelgot;
3191       BFD_ASSERT (sgot != NULL && srela != NULL);
3192
3193       rela.r_offset = (sgot->output_section->vma
3194                        + sgot->output_offset
3195                        + (h->got.offset &~ 1));
3196
3197       /* If this is a -Bsymbolic link, and the symbol is defined
3198          locally, we just want to emit a RELATIVE reloc.  Likewise if
3199          the symbol was forced to be local because of a version file.
3200          The entry in the global offset table will already have been
3201          initialized in the relocate_section function.  */
3202       if (bfd_link_pic (info)
3203           && (info->symbolic
3204               || h->dynindx == -1
3205               || h->forced_local)
3206           && h->def_regular)
3207         {
3208           rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3209           rela.r_addend = (h->root.u.def.value
3210                            + h->root.u.def.section->output_section->vma
3211                            + h->root.u.def.section->output_offset);
3212         }
3213       else
3214         {
3215           BFD_ASSERT ((h->got.offset & 1) == 0);
3216           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3217           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3218           rela.r_addend = 0;
3219         }
3220
3221       loc = srela->contents;
3222       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3223       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3224       ++srela->reloc_count;
3225     }
3226
3227   if (h->needs_copy)
3228     {
3229       asection *s;
3230       Elf_Internal_Rela rela;
3231
3232       /* This symbols needs a copy reloc.  Set it up.  */
3233
3234       BFD_ASSERT (h->dynindx != -1
3235                   && (h->root.type == bfd_link_hash_defined
3236                       || h->root.type == bfd_link_hash_defweak));
3237
3238       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
3239       BFD_ASSERT (s != NULL);
3240
3241       rela.r_offset = (h->root.u.def.value
3242                        + h->root.u.def.section->output_section->vma
3243                        + h->root.u.def.section->output_offset);
3244       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3245       rela.r_addend = 0;
3246       loc = s->contents;
3247       loc += s->reloc_count * sizeof (Elf32_External_Rela);
3248       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3249       ++s->reloc_count;
3250     }
3251
3252   /* Mark some specially defined symbols as absolute.  */
3253   if (h == htab->root.hdynamic || h == htab->root.hgot)
3254     sym->st_shndx = SHN_ABS;
3255
3256   return TRUE;
3257 }
3258
3259
3260 /* Finish up the dynamic sections.  */
3261
3262 static bfd_boolean
3263 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3264                                   struct bfd_link_info *info)
3265 {
3266   struct elf_m32r_link_hash_table *htab;
3267   bfd *dynobj;
3268   asection *sdyn;
3269   asection *sgot;
3270
3271 #ifdef DEBUG_PIC
3272   printf ("m32r_elf_finish_dynamic_sections()\n");
3273 #endif
3274
3275   htab = m32r_elf_hash_table (info);
3276   if (htab == NULL)
3277     return FALSE;
3278
3279   dynobj = htab->root.dynobj;
3280
3281   sgot = htab->root.sgotplt;
3282   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3283
3284   if (htab->root.dynamic_sections_created)
3285     {
3286       asection *splt;
3287       Elf32_External_Dyn *dyncon, *dynconend;
3288
3289       BFD_ASSERT (sgot != NULL && sdyn != NULL);
3290
3291       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3292       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3293
3294       for (; dyncon < dynconend; dyncon++)
3295         {
3296           Elf_Internal_Dyn dyn;
3297           asection *s;
3298
3299           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3300
3301           switch (dyn.d_tag)
3302             {
3303             default:
3304               break;
3305
3306             case DT_PLTGOT:
3307               s = htab->root.sgotplt;
3308               goto get_vma;
3309             case DT_JMPREL:
3310               s = htab->root.srelplt;
3311             get_vma:
3312               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3313               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3314               break;
3315
3316             case DT_PLTRELSZ:
3317               s = htab->root.srelplt;
3318               dyn.d_un.d_val = s->size;
3319               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3320               break;
3321             }
3322         }
3323
3324       /* Fill in the first entry in the procedure linkage table.  */
3325       splt = htab->root.splt;
3326       if (splt && splt->size > 0)
3327         {
3328           if (bfd_link_pic (info))
3329             {
3330               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3331               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3332               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3333               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3334               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3335             }
3336           else
3337             {
3338               unsigned long addr;
3339               /* addr = .got + 4 */
3340               addr = sgot->output_section->vma + sgot->output_offset + 4;
3341               bfd_put_32 (output_bfd,
3342                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3343                           splt->contents);
3344               bfd_put_32 (output_bfd,
3345                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
3346                           splt->contents + 4);
3347               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3348               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3349               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3350             }
3351
3352           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3353             PLT_ENTRY_SIZE;
3354         }
3355     }
3356
3357   /* Fill in the first three entries in the global offset table.  */
3358   if (sgot && sgot->size > 0)
3359     {
3360       if (sdyn == NULL)
3361         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3362       else
3363         bfd_put_32 (output_bfd,
3364                     sdyn->output_section->vma + sdyn->output_offset,
3365                     sgot->contents);
3366       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3367       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3368
3369       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3370     }
3371
3372   return TRUE;
3373 }
3374
3375 \f
3376 /* Set the right machine number.  */
3377
3378 static bfd_boolean
3379 m32r_elf_object_p (bfd *abfd)
3380 {
3381   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3382     {
3383     default:
3384     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3385     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3386     case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3387     }
3388   return TRUE;
3389 }
3390
3391 /* Store the machine number in the flags field.  */
3392
3393 static void
3394 m32r_elf_final_write_processing (bfd *abfd,
3395                                  bfd_boolean linker ATTRIBUTE_UNUSED)
3396 {
3397   unsigned long val;
3398
3399   switch (bfd_get_mach (abfd))
3400     {
3401     default:
3402     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3403     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3404     case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3405     }
3406
3407   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3408   elf_elfheader (abfd)->e_flags |= val;
3409 }
3410
3411 /* Function to keep M32R specific file flags.  */
3412
3413 static bfd_boolean
3414 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3415 {
3416   BFD_ASSERT (!elf_flags_init (abfd)
3417               || elf_elfheader (abfd)->e_flags == flags);
3418
3419   elf_elfheader (abfd)->e_flags = flags;
3420   elf_flags_init (abfd) = TRUE;
3421   return TRUE;
3422 }
3423
3424 /* Merge backend specific data from an object file to the output
3425    object file when linking.  */
3426
3427 static bfd_boolean
3428 m32r_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3429 {
3430   bfd *obfd = info->output_bfd;
3431   flagword out_flags;
3432   flagword in_flags;
3433
3434   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3435       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3436     return TRUE;
3437
3438   in_flags  = elf_elfheader (ibfd)->e_flags;
3439   out_flags = elf_elfheader (obfd)->e_flags;
3440
3441   if (! elf_flags_init (obfd))
3442     {
3443       /* If the input is the default architecture then do not
3444          bother setting the flags for the output architecture,
3445          instead allow future merges to do this.  If no future
3446          merges ever set these flags then they will retain their
3447          unitialised values, which surprise surprise, correspond
3448          to the default values.  */
3449       if (bfd_get_arch_info (ibfd)->the_default)
3450         return TRUE;
3451
3452       elf_flags_init (obfd) = TRUE;
3453       elf_elfheader (obfd)->e_flags = in_flags;
3454
3455       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3456           && bfd_get_arch_info (obfd)->the_default)
3457         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3458                                   bfd_get_mach (ibfd));
3459
3460       return TRUE;
3461     }
3462
3463   /* Check flag compatibility.  */
3464   if (in_flags == out_flags)
3465     return TRUE;
3466
3467   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3468     {
3469       if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3470           || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3471           || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3472         {
3473           _bfd_error_handler
3474             (_("%pB: Instruction set mismatch with previous modules"), ibfd);
3475
3476           bfd_set_error (bfd_error_bad_value);
3477           return FALSE;
3478         }
3479     }
3480
3481   return TRUE;
3482 }
3483
3484 /* Display the flags field.  */
3485
3486 static bfd_boolean
3487 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3488 {
3489   FILE * file = (FILE *) ptr;
3490
3491   BFD_ASSERT (abfd != NULL && ptr != NULL);
3492
3493   _bfd_elf_print_private_bfd_data (abfd, ptr);
3494
3495   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3496
3497   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3498     {
3499     default:
3500     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3501     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3502     case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3503     }
3504
3505   fputc ('\n', file);
3506
3507   return TRUE;
3508 }
3509
3510 static asection *
3511 m32r_elf_gc_mark_hook (asection *sec,
3512                        struct bfd_link_info *info,
3513                        Elf_Internal_Rela *rel,
3514                        struct elf_link_hash_entry *h,
3515                        Elf_Internal_Sym *sym)
3516 {
3517   if (h != NULL)
3518     switch (ELF32_R_TYPE (rel->r_info))
3519       {
3520       case R_M32R_GNU_VTINHERIT:
3521       case R_M32R_GNU_VTENTRY:
3522       case R_M32R_RELA_GNU_VTINHERIT:
3523       case R_M32R_RELA_GNU_VTENTRY:
3524         return NULL;
3525       }
3526
3527   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3528 }
3529
3530 /* Look through the relocs for a section during the first phase.
3531    Since we don't do .gots or .plts, we just need to consider the
3532    virtual table relocs for gc.  */
3533
3534 static bfd_boolean
3535 m32r_elf_check_relocs (bfd *abfd,
3536                        struct bfd_link_info *info,
3537                        asection *sec,
3538                        const Elf_Internal_Rela *relocs)
3539 {
3540   Elf_Internal_Shdr *symtab_hdr;
3541   struct elf_link_hash_entry **sym_hashes;
3542   const Elf_Internal_Rela *rel;
3543   const Elf_Internal_Rela *rel_end;
3544   struct elf_m32r_link_hash_table *htab;
3545   bfd *dynobj;
3546   asection *sreloc;
3547
3548   if (bfd_link_relocatable (info))
3549     return TRUE;
3550
3551   /* Don't do anything special with non-loaded, non-alloced sections.
3552      In particular, any relocs in such sections should not affect GOT
3553      and PLT reference counting (ie. we don't allow them to create GOT
3554      or PLT entries), there's no possibility or desire to optimize TLS
3555      relocs, and there's not much point in propagating relocs to shared
3556      libs that the dynamic linker won't relocate.  */
3557   if ((sec->flags & SEC_ALLOC) == 0)
3558     return TRUE;
3559
3560   sreloc = NULL;
3561   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3562   sym_hashes = elf_sym_hashes (abfd);
3563
3564   htab = m32r_elf_hash_table (info);
3565   if (htab == NULL)
3566     return FALSE;
3567
3568   dynobj = htab->root.dynobj;
3569
3570   rel_end = relocs + sec->reloc_count;
3571   for (rel = relocs; rel < rel_end; rel++)
3572     {
3573       int r_type;
3574       struct elf_link_hash_entry *h;
3575       unsigned long r_symndx;
3576
3577       r_symndx = ELF32_R_SYM (rel->r_info);
3578       r_type = ELF32_R_TYPE (rel->r_info);
3579       if (r_symndx < symtab_hdr->sh_info)
3580         h = NULL;
3581       else
3582         {
3583           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3584           while (h->root.type == bfd_link_hash_indirect
3585                  || h->root.type == bfd_link_hash_warning)
3586             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3587         }
3588
3589       /* Some relocs require a global offset table.  */
3590       if (htab->root.sgot == NULL)
3591         {
3592           switch (r_type)
3593             {
3594             case R_M32R_GOT16_HI_ULO:
3595             case R_M32R_GOT16_HI_SLO:
3596             case R_M32R_GOTOFF:
3597             case R_M32R_GOTOFF_HI_ULO:
3598             case R_M32R_GOTOFF_HI_SLO:
3599             case R_M32R_GOTOFF_LO:
3600             case R_M32R_GOT16_LO:
3601             case R_M32R_GOTPC24:
3602             case R_M32R_GOTPC_HI_ULO:
3603             case R_M32R_GOTPC_HI_SLO:
3604             case R_M32R_GOTPC_LO:
3605             case R_M32R_GOT24:
3606               if (dynobj == NULL)
3607                 htab->root.dynobj = dynobj = abfd;
3608               if (!_bfd_elf_create_got_section (dynobj, info))
3609                 return FALSE;
3610               break;
3611
3612             default:
3613               break;
3614           }
3615         }
3616
3617       switch (r_type)
3618         {
3619         case R_M32R_GOT16_HI_ULO:
3620         case R_M32R_GOT16_HI_SLO:
3621         case R_M32R_GOT16_LO:
3622         case R_M32R_GOT24:
3623
3624           if (h != NULL)
3625             h->got.refcount += 1;
3626           else
3627             {
3628               bfd_signed_vma *local_got_refcounts;
3629
3630               /* This is a global offset table entry for a local
3631                  symbol.  */
3632               local_got_refcounts = elf_local_got_refcounts (abfd);
3633               if (local_got_refcounts == NULL)
3634                 {
3635                   bfd_size_type size;
3636
3637                   size = symtab_hdr->sh_info;
3638                   size *= sizeof (bfd_signed_vma);
3639                   local_got_refcounts = bfd_zalloc (abfd, size);
3640                   if (local_got_refcounts == NULL)
3641                     return FALSE;
3642                   elf_local_got_refcounts (abfd) = local_got_refcounts;
3643                 }
3644               local_got_refcounts[r_symndx] += 1;
3645             }
3646           break;
3647
3648         case R_M32R_26_PLTREL:
3649           /* This symbol requires a procedure linkage table entry.  We
3650              actually build the entry in adjust_dynamic_symbol,
3651              because this might be a case of linking PIC code without
3652              linking in any dynamic objects, in which case we don't
3653              need to generate a procedure linkage table after all.  */
3654
3655           /* If this is a local symbol, we resolve it directly without
3656              creating a procedure linkage table entry.  */
3657           if (h == NULL)
3658             continue;
3659
3660           if (h->forced_local)
3661             break;
3662
3663           h->needs_plt = 1;
3664           h->plt.refcount += 1;
3665           break;
3666
3667         case R_M32R_16_RELA:
3668         case R_M32R_24_RELA:
3669         case R_M32R_32_RELA:
3670         case R_M32R_REL32:
3671         case R_M32R_HI16_ULO_RELA:
3672         case R_M32R_HI16_SLO_RELA:
3673         case R_M32R_LO16_RELA:
3674         case R_M32R_SDA16_RELA:
3675         case R_M32R_10_PCREL_RELA:
3676         case R_M32R_18_PCREL_RELA:
3677         case R_M32R_26_PCREL_RELA:
3678
3679           if (h != NULL && !bfd_link_pic (info))
3680             {
3681               h->non_got_ref = 1;
3682               h->plt.refcount += 1;
3683             }
3684
3685           /* If we are creating a shared library, and this is a reloc
3686              against a global symbol, or a non PC relative reloc
3687              against a local symbol, then we need to copy the reloc
3688              into the shared library.  However, if we are linking with
3689              -Bsymbolic, we do not need to copy a reloc against a
3690              global symbol which is defined in an object we are
3691              including in the link (i.e., DEF_REGULAR is set).  At
3692              this point we have not seen all the input files, so it is
3693              possible that DEF_REGULAR is not set now but will be set
3694              later (it is never cleared).  We account for that
3695              possibility below by storing information in the
3696              dyn_relocs field of the hash table entry. A similar
3697              situation occurs when creating shared libraries and symbol
3698              visibility changes render the symbol local.
3699
3700              If on the other hand, we are creating an executable, we
3701              may need to keep relocations for symbols satisfied by a
3702              dynamic library if we manage to avoid copy relocs for the
3703              symbol.  */
3704           if ((bfd_link_pic (info)
3705                && (sec->flags & SEC_ALLOC) != 0
3706                && ((   r_type != R_M32R_26_PCREL_RELA
3707                     && r_type != R_M32R_18_PCREL_RELA
3708                     && r_type != R_M32R_10_PCREL_RELA
3709                     && r_type != R_M32R_REL32)
3710                    || (h != NULL
3711                        && (! info->symbolic
3712                            || h->root.type == bfd_link_hash_defweak
3713                            || !h->def_regular))))
3714               || (!bfd_link_pic (info)
3715                   && (sec->flags & SEC_ALLOC) != 0
3716                   && h != NULL
3717                   && (h->root.type == bfd_link_hash_defweak
3718                       || !h->def_regular)))
3719             {
3720               struct elf_dyn_relocs *p;
3721               struct elf_dyn_relocs **head;
3722
3723               if (dynobj == NULL)
3724                 htab->root.dynobj = dynobj = abfd;
3725
3726               /* When creating a shared object, we must copy these
3727                  relocs into the output file.  We create a reloc
3728                  section in dynobj and make room for the reloc.  */
3729               if (sreloc == NULL)
3730                 {
3731                   sreloc = _bfd_elf_make_dynamic_reloc_section
3732                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3733
3734                   if (sreloc == NULL)
3735                     return FALSE;
3736                 }
3737
3738               /* If this is a global symbol, we count the number of
3739                  relocations we need for this symbol.  */
3740               if (h != NULL)
3741                 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3742               else
3743                 {
3744                   /* Track dynamic relocs needed for local syms too.  */
3745                   asection *s;
3746                   void *vpp;
3747                   Elf_Internal_Sym *isym;
3748
3749                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3750                                                 abfd, r_symndx);
3751                   if (isym == NULL)
3752                     return FALSE;
3753
3754                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3755                   if (s == NULL)
3756                     s = sec;
3757
3758                   vpp = &elf_section_data (s)->local_dynrel;
3759                   head = (struct elf_dyn_relocs **) vpp;
3760                 }
3761
3762               p = *head;
3763               if (p == NULL || p->sec != sec)
3764                 {
3765                   bfd_size_type amt = sizeof (*p);
3766
3767                   p = bfd_alloc (dynobj, amt);
3768                   if (p == NULL)
3769                     return FALSE;
3770                   p->next = *head;
3771                   *head = p;
3772                   p->sec = sec;
3773                   p->count = 0;
3774                   p->pc_count = 0;
3775                 }
3776
3777               p->count += 1;
3778               if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3779                   || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3780                   || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3781                   || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3782                 p->pc_count += 1;
3783             }
3784           break;
3785
3786         /* This relocation describes the C++ object vtable hierarchy.
3787            Reconstruct it for later use during GC.  */
3788         case R_M32R_RELA_GNU_VTINHERIT:
3789         case R_M32R_GNU_VTINHERIT:
3790           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3791             return FALSE;
3792           break;
3793
3794         /* This relocation describes which C++ vtable entries are actually
3795            used.  Record for later use during GC.  */
3796         case R_M32R_GNU_VTENTRY:
3797           BFD_ASSERT (h != NULL);
3798           if (h != NULL
3799               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3800             return FALSE;
3801           break;
3802         case R_M32R_RELA_GNU_VTENTRY:
3803           BFD_ASSERT (h != NULL);
3804           if (h != NULL
3805               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3806             return FALSE;
3807           break;
3808         }
3809     }
3810
3811   return TRUE;
3812 }
3813
3814 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
3815 {
3816   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3817   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3818   { NULL,                     0,  0, 0,            0 }
3819 };
3820
3821 static enum elf_reloc_type_class
3822 m32r_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3823                            const asection *rel_sec ATTRIBUTE_UNUSED,
3824                            const Elf_Internal_Rela *rela)
3825 {
3826   switch ((int) ELF32_R_TYPE (rela->r_info))
3827     {
3828     case R_M32R_RELATIVE:  return reloc_class_relative;
3829     case R_M32R_JMP_SLOT:  return reloc_class_plt;
3830     case R_M32R_COPY:      return reloc_class_copy;
3831     default:               return reloc_class_normal;
3832     }
3833 }
3834 \f
3835 #define ELF_ARCH                bfd_arch_m32r
3836 #define ELF_TARGET_ID           M32R_ELF_DATA
3837 #define ELF_MACHINE_CODE        EM_M32R
3838 #define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
3839 #define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
3840
3841 #define TARGET_BIG_SYM          m32r_elf32_vec
3842 #define TARGET_BIG_NAME         "elf32-m32r"
3843 #define TARGET_LITTLE_SYM       m32r_elf32_le_vec
3844 #define TARGET_LITTLE_NAME      "elf32-m32rle"
3845
3846 #define elf_info_to_howto                       m32r_info_to_howto
3847 #define elf_info_to_howto_rel                   m32r_info_to_howto_rel
3848 #define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
3849 #define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
3850 #define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
3851 #define elf_backend_relocate_section            m32r_elf_relocate_section
3852 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
3853 #define elf_backend_check_relocs                m32r_elf_check_relocs
3854
3855 #define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
3856 #define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
3857 #define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
3858 #define elf_backend_omit_section_dynsym         _bfd_elf_omit_section_dynsym_all
3859 #define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
3860 #define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
3861 #define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
3862 #define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
3863 #define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
3864
3865 #define elf_backend_can_gc_sections             1
3866 /*#if !USE_REL
3867 #define elf_backend_rela_normal                 1
3868 #endif*/
3869 #define elf_backend_can_refcount 1
3870 #define elf_backend_want_got_plt 1
3871 #define elf_backend_plt_readonly 1
3872 #define elf_backend_want_plt_sym 0
3873 #define elf_backend_got_header_size 12
3874 #define elf_backend_dtrel_excludes_plt  1
3875
3876 #define elf_backend_may_use_rel_p       1
3877 #ifdef USE_M32R_OLD_RELOC
3878 #define elf_backend_default_use_rela_p  0
3879 #define elf_backend_may_use_rela_p      0
3880 #else
3881 #define elf_backend_default_use_rela_p  1
3882 #define elf_backend_may_use_rela_p      1
3883 #endif
3884
3885 #define elf_backend_object_p                    m32r_elf_object_p
3886 #define elf_backend_final_write_processing      m32r_elf_final_write_processing
3887 #define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
3888 #define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
3889 #define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
3890 #define elf_backend_special_sections            m32r_elf_special_sections
3891
3892 #define elf_backend_linux_prpsinfo32_ugid16     TRUE
3893
3894 #include "elf32-target.h"
3895
3896 #undef  ELF_MAXPAGESIZE
3897 #define ELF_MAXPAGESIZE         0x1000
3898
3899 #undef  TARGET_BIG_SYM
3900 #define TARGET_BIG_SYM          m32r_elf32_linux_vec
3901 #undef  TARGET_BIG_NAME
3902 #define TARGET_BIG_NAME         "elf32-m32r-linux"
3903 #undef  TARGET_LITTLE_SYM
3904 #define TARGET_LITTLE_SYM       m32r_elf32_linux_le_vec
3905 #undef  TARGET_LITTLE_NAME
3906 #define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
3907 #undef  elf32_bed
3908 #define elf32_bed               elf32_m32r_lin_bed
3909
3910 #include "elf32-target.h"