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