bfd/elf32-m32r.c

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