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