bfd/elf32-m68k.c

   1 /* Motorola 68k series support for 32-bit ELF
   2    Copyright (C) 1993-2014 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/m68k.h"
  27 #include "opcode/m68k.h"
  28
  29 static bfd_boolean
  30 elf_m68k_discard_copies (struct elf_link_hash_entry *, void *);
  31
  32 static reloc_howto_type howto_table[] =
  33 {
  34   HOWTO(R_68K_NONE,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_NONE",      FALSE, 0, 0x00000000,FALSE),
  35   HOWTO(R_68K_32,         0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32",        FALSE, 0, 0xffffffff,FALSE),
  36   HOWTO(R_68K_16,         0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16",        FALSE, 0, 0x0000ffff,FALSE),
  37   HOWTO(R_68K_8,          0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8",         FALSE, 0, 0x000000ff,FALSE),
  38   HOWTO(R_68K_PC32,       0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32",      FALSE, 0, 0xffffffff,TRUE),
  39   HOWTO(R_68K_PC16,       0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC16",      FALSE, 0, 0x0000ffff,TRUE),
  40   HOWTO(R_68K_PC8,        0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC8",       FALSE, 0, 0x000000ff,TRUE),
  41   HOWTO(R_68K_GOT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32",     FALSE, 0, 0xffffffff,TRUE),
  42   HOWTO(R_68K_GOT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16",     FALSE, 0, 0x0000ffff,TRUE),
  43   HOWTO(R_68K_GOT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8",      FALSE, 0, 0x000000ff,TRUE),
  44   HOWTO(R_68K_GOT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O",    FALSE, 0, 0xffffffff,FALSE),
  45   HOWTO(R_68K_GOT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16O",    FALSE, 0, 0x0000ffff,FALSE),
  46   HOWTO(R_68K_GOT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8O",     FALSE, 0, 0x000000ff,FALSE),
  47   HOWTO(R_68K_PLT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32",     FALSE, 0, 0xffffffff,TRUE),
  48   HOWTO(R_68K_PLT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16",     FALSE, 0, 0x0000ffff,TRUE),
  49   HOWTO(R_68K_PLT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8",      FALSE, 0, 0x000000ff,TRUE),
  50   HOWTO(R_68K_PLT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O",    FALSE, 0, 0xffffffff,FALSE),
  51   HOWTO(R_68K_PLT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16O",    FALSE, 0, 0x0000ffff,FALSE),
  52   HOWTO(R_68K_PLT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8O",     FALSE, 0, 0x000000ff,FALSE),
  53   HOWTO(R_68K_COPY,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_COPY",      FALSE, 0, 0xffffffff,FALSE),
  54   HOWTO(R_68K_GLOB_DAT,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_GLOB_DAT",  FALSE, 0, 0xffffffff,FALSE),
  55   HOWTO(R_68K_JMP_SLOT,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_JMP_SLOT",  FALSE, 0, 0xffffffff,FALSE),
  56   HOWTO(R_68K_RELATIVE,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_RELATIVE",  FALSE, 0, 0xffffffff,FALSE),
  57   /* GNU extension to record C++ vtable hierarchy.  */
  58   HOWTO (R_68K_GNU_VTINHERIT,   /* type */
  59          0,                     /* rightshift */
  60          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  61          0,                     /* bitsize */
  62          FALSE,                 /* pc_relative */
  63          0,                     /* bitpos */
  64          complain_overflow_dont, /* complain_on_overflow */
  65          NULL,                  /* special_function */
  66          "R_68K_GNU_VTINHERIT", /* name */
  67          FALSE,                 /* partial_inplace */
  68          0,                     /* src_mask */
  69          0,                     /* dst_mask */
  70          FALSE),
  71   /* GNU extension to record C++ vtable member usage.  */
  72   HOWTO (R_68K_GNU_VTENTRY,     /* type */
  73          0,                     /* rightshift */
  74          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  75          0,                     /* bitsize */
  76          FALSE,                 /* pc_relative */
  77          0,                     /* bitpos */
  78          complain_overflow_dont, /* complain_on_overflow */
  79          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
  80          "R_68K_GNU_VTENTRY",   /* name */
  81          FALSE,                 /* partial_inplace */
  82          0,                     /* src_mask */
  83          0,                     /* dst_mask */
  84          FALSE),
  85
  86   /* TLS general dynamic variable reference.  */
  87   HOWTO (R_68K_TLS_GD32,        /* type */
  88          0,                     /* rightshift */
  89          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  90          32,                    /* bitsize */
  91          FALSE,                 /* pc_relative */
  92          0,                     /* bitpos */
  93          complain_overflow_bitfield, /* complain_on_overflow */
  94          bfd_elf_generic_reloc, /* special_function */
  95          "R_68K_TLS_GD32",      /* name */
  96          FALSE,                 /* partial_inplace */
  97          0,                     /* src_mask */
  98          0xffffffff,            /* dst_mask */
  99          FALSE),                /* pcrel_offset */
 100
 101   HOWTO (R_68K_TLS_GD16,        /* type */
 102          0,                     /* rightshift */
 103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 104          16,                    /* bitsize */
 105          FALSE,                 /* pc_relative */
 106          0,                     /* bitpos */
 107          complain_overflow_signed, /* complain_on_overflow */
 108          bfd_elf_generic_reloc, /* special_function */
 109          "R_68K_TLS_GD16",      /* name */
 110          FALSE,                 /* partial_inplace */
 111          0,                     /* src_mask */
 112          0x0000ffff,            /* dst_mask */
 113          FALSE),                /* pcrel_offset */
 114
 115   HOWTO (R_68K_TLS_GD8,         /* type */
 116          0,                     /* rightshift */
 117          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 118          8,                     /* bitsize */
 119          FALSE,                 /* pc_relative */
 120          0,                     /* bitpos */
 121          complain_overflow_signed, /* complain_on_overflow */
 122          bfd_elf_generic_reloc, /* special_function */
 123          "R_68K_TLS_GD8",       /* name */
 124          FALSE,                 /* partial_inplace */
 125          0,                     /* src_mask */
 126          0x000000ff,            /* dst_mask */
 127          FALSE),                /* pcrel_offset */
 128
 129   /* TLS local dynamic variable reference.  */
 130   HOWTO (R_68K_TLS_LDM32,       /* type */
 131          0,                     /* rightshift */
 132          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 133          32,                    /* bitsize */
 134          FALSE,                 /* pc_relative */
 135          0,                     /* bitpos */
 136          complain_overflow_bitfield, /* complain_on_overflow */
 137          bfd_elf_generic_reloc, /* special_function */
 138          "R_68K_TLS_LDM32",     /* name */
 139          FALSE,                 /* partial_inplace */
 140          0,                     /* src_mask */
 141          0xffffffff,            /* dst_mask */
 142          FALSE),                /* pcrel_offset */
 143
 144   HOWTO (R_68K_TLS_LDM16,       /* type */
 145          0,                     /* rightshift */
 146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 147          16,                    /* bitsize */
 148          FALSE,                 /* pc_relative */
 149          0,                     /* bitpos */
 150          complain_overflow_signed, /* complain_on_overflow */
 151          bfd_elf_generic_reloc, /* special_function */
 152          "R_68K_TLS_LDM16",     /* name */
 153          FALSE,                 /* partial_inplace */
 154          0,                     /* src_mask */
 155          0x0000ffff,            /* dst_mask */
 156          FALSE),                /* pcrel_offset */
 157
 158   HOWTO (R_68K_TLS_LDM8,                /* type */
 159          0,                     /* rightshift */
 160          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 161          8,                     /* bitsize */
 162          FALSE,                 /* pc_relative */
 163          0,                     /* bitpos */
 164          complain_overflow_signed, /* complain_on_overflow */
 165          bfd_elf_generic_reloc, /* special_function */
 166          "R_68K_TLS_LDM8",      /* name */
 167          FALSE,                 /* partial_inplace */
 168          0,                     /* src_mask */
 169          0x000000ff,            /* dst_mask */
 170          FALSE),                /* pcrel_offset */
 171
 172   HOWTO (R_68K_TLS_LDO32,       /* type */
 173          0,                     /* rightshift */
 174          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          32,                    /* bitsize */
 176          FALSE,                 /* pc_relative */
 177          0,                     /* bitpos */
 178          complain_overflow_bitfield, /* complain_on_overflow */
 179          bfd_elf_generic_reloc, /* special_function */
 180          "R_68K_TLS_LDO32",     /* name */
 181          FALSE,                 /* partial_inplace */
 182          0,                     /* src_mask */
 183          0xffffffff,            /* dst_mask */
 184          FALSE),                /* pcrel_offset */
 185
 186   HOWTO (R_68K_TLS_LDO16,       /* type */
 187          0,                     /* rightshift */
 188          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 189          16,                    /* bitsize */
 190          FALSE,                 /* pc_relative */
 191          0,                     /* bitpos */
 192          complain_overflow_signed, /* complain_on_overflow */
 193          bfd_elf_generic_reloc, /* special_function */
 194          "R_68K_TLS_LDO16",     /* name */
 195          FALSE,                 /* partial_inplace */
 196          0,                     /* src_mask */
 197          0x0000ffff,            /* dst_mask */
 198          FALSE),                /* pcrel_offset */
 199
 200   HOWTO (R_68K_TLS_LDO8,                /* type */
 201          0,                     /* rightshift */
 202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 203          8,                     /* bitsize */
 204          FALSE,                 /* pc_relative */
 205          0,                     /* bitpos */
 206          complain_overflow_signed, /* complain_on_overflow */
 207          bfd_elf_generic_reloc, /* special_function */
 208          "R_68K_TLS_LDO8",      /* name */
 209          FALSE,                 /* partial_inplace */
 210          0,                     /* src_mask */
 211          0x000000ff,            /* dst_mask */
 212          FALSE),                /* pcrel_offset */
 213
 214   /* TLS initial execution variable reference.  */
 215   HOWTO (R_68K_TLS_IE32,        /* type */
 216          0,                     /* rightshift */
 217          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 218          32,                    /* bitsize */
 219          FALSE,                 /* pc_relative */
 220          0,                     /* bitpos */
 221          complain_overflow_bitfield, /* complain_on_overflow */
 222          bfd_elf_generic_reloc, /* special_function */
 223          "R_68K_TLS_IE32",      /* name */
 224          FALSE,                 /* partial_inplace */
 225          0,                     /* src_mask */
 226          0xffffffff,            /* dst_mask */
 227          FALSE),                /* pcrel_offset */
 228
 229   HOWTO (R_68K_TLS_IE16,        /* type */
 230          0,                     /* rightshift */
 231          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 232          16,                    /* bitsize */
 233          FALSE,                 /* pc_relative */
 234          0,                     /* bitpos */
 235          complain_overflow_signed, /* complain_on_overflow */
 236          bfd_elf_generic_reloc, /* special_function */
 237          "R_68K_TLS_IE16",      /* name */
 238          FALSE,                 /* partial_inplace */
 239          0,                     /* src_mask */
 240          0x0000ffff,            /* dst_mask */
 241          FALSE),                /* pcrel_offset */
 242
 243   HOWTO (R_68K_TLS_IE8,         /* type */
 244          0,                     /* rightshift */
 245          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 246          8,                     /* bitsize */
 247          FALSE,                 /* pc_relative */
 248          0,                     /* bitpos */
 249          complain_overflow_signed, /* complain_on_overflow */
 250          bfd_elf_generic_reloc, /* special_function */
 251          "R_68K_TLS_IE8",       /* name */
 252          FALSE,                 /* partial_inplace */
 253          0,                     /* src_mask */
 254          0x000000ff,            /* dst_mask */
 255          FALSE),                /* pcrel_offset */
 256
 257   /* TLS local execution variable reference.  */
 258   HOWTO (R_68K_TLS_LE32,        /* type */
 259          0,                     /* rightshift */
 260          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 261          32,                    /* bitsize */
 262          FALSE,                 /* pc_relative */
 263          0,                     /* bitpos */
 264          complain_overflow_bitfield, /* complain_on_overflow */
 265          bfd_elf_generic_reloc, /* special_function */
 266          "R_68K_TLS_LE32",      /* name */
 267          FALSE,                 /* partial_inplace */
 268          0,                     /* src_mask */
 269          0xffffffff,            /* dst_mask */
 270          FALSE),                /* pcrel_offset */
 271
 272   HOWTO (R_68K_TLS_LE16,        /* type */
 273          0,                     /* rightshift */
 274          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          16,                    /* bitsize */
 276          FALSE,                 /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_signed, /* complain_on_overflow */
 279          bfd_elf_generic_reloc, /* special_function */
 280          "R_68K_TLS_LE16",      /* name */
 281          FALSE,                 /* partial_inplace */
 282          0,                     /* src_mask */
 283          0x0000ffff,            /* dst_mask */
 284          FALSE),                /* pcrel_offset */
 285
 286   HOWTO (R_68K_TLS_LE8,         /* type */
 287          0,                     /* rightshift */
 288          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 289          8,                     /* bitsize */
 290          FALSE,                 /* pc_relative */
 291          0,                     /* bitpos */
 292          complain_overflow_signed, /* complain_on_overflow */
 293          bfd_elf_generic_reloc, /* special_function */
 294          "R_68K_TLS_LE8",       /* name */
 295          FALSE,                 /* partial_inplace */
 296          0,                     /* src_mask */
 297          0x000000ff,            /* dst_mask */
 298          FALSE),                /* pcrel_offset */
 299
 300   /* TLS GD/LD dynamic relocations.  */
 301   HOWTO (R_68K_TLS_DTPMOD32,    /* type */
 302          0,                     /* rightshift */
 303          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 304          32,                    /* bitsize */
 305          FALSE,                 /* pc_relative */
 306          0,                     /* bitpos */
 307          complain_overflow_dont, /* complain_on_overflow */
 308          bfd_elf_generic_reloc, /* special_function */
 309          "R_68K_TLS_DTPMOD32",  /* name */
 310          FALSE,                 /* partial_inplace */
 311          0,                     /* src_mask */
 312          0xffffffff,            /* dst_mask */
 313          FALSE),                /* pcrel_offset */
 314
 315   HOWTO (R_68K_TLS_DTPREL32,    /* type */
 316          0,                     /* rightshift */
 317          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          32,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_dont, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_68K_TLS_DTPREL32",  /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffffffff,            /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   HOWTO (R_68K_TLS_TPREL32,     /* type */
 330          0,                     /* rightshift */
 331          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 332          32,                    /* bitsize */
 333          FALSE,                 /* pc_relative */
 334          0,                     /* bitpos */
 335          complain_overflow_dont, /* complain_on_overflow */
 336          bfd_elf_generic_reloc, /* special_function */
 337          "R_68K_TLS_TPREL32",   /* name */
 338          FALSE,                 /* partial_inplace */
 339          0,                     /* src_mask */
 340          0xffffffff,            /* dst_mask */
 341          FALSE),                /* pcrel_offset */
 342 };
 343
 344 static void
 345 rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
 346 {
 347   unsigned int indx = ELF32_R_TYPE (dst->r_info);
 348
 349   if (indx >= (unsigned int) R_68K_max)
 350     {
 351       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 352                              abfd, (int) indx);
 353       indx = R_68K_NONE;
 354     }
 355   cache_ptr->howto = &howto_table[indx];
 356 }
 357
 358 #define elf_info_to_howto rtype_to_howto
 359
 360 static const struct
 361 {
 362   bfd_reloc_code_real_type bfd_val;
 363   int elf_val;
 364 }
 365   reloc_map[] =
 366 {
 367   { BFD_RELOC_NONE, R_68K_NONE },
 368   { BFD_RELOC_32, R_68K_32 },
 369   { BFD_RELOC_16, R_68K_16 },
 370   { BFD_RELOC_8, R_68K_8 },
 371   { BFD_RELOC_32_PCREL, R_68K_PC32 },
 372   { BFD_RELOC_16_PCREL, R_68K_PC16 },
 373   { BFD_RELOC_8_PCREL, R_68K_PC8 },
 374   { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
 375   { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
 376   { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
 377   { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
 378   { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
 379   { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
 380   { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
 381   { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
 382   { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
 383   { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
 384   { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
 385   { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
 386   { BFD_RELOC_NONE, R_68K_COPY },
 387   { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
 388   { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
 389   { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
 390   { BFD_RELOC_CTOR, R_68K_32 },
 391   { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
 392   { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
 393   { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 },
 394   { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 },
 395   { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 },
 396   { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 },
 397   { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 },
 398   { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 },
 399   { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 },
 400   { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 },
 401   { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 },
 402   { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 },
 403   { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 },
 404   { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 },
 405   { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 },
 406   { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 },
 407   { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 },
 408 };
 409
 410 static reloc_howto_type *
 411 reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 412                    bfd_reloc_code_real_type code)
 413 {
 414   unsigned int i;
 415   for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
 416     {
 417       if (reloc_map[i].bfd_val == code)
 418         return &howto_table[reloc_map[i].elf_val];
 419     }
 420   return 0;
 421 }
 422
 423 static reloc_howto_type *
 424 reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 425 {
 426   unsigned int i;
 427
 428   for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
 429     if (howto_table[i].name != NULL
 430         && strcasecmp (howto_table[i].name, r_name) == 0)
 431       return &howto_table[i];
 432
 433   return NULL;
 434 }
 435
 436 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
 437 #define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
 438 #define ELF_ARCH bfd_arch_m68k
 439 #define ELF_TARGET_ID M68K_ELF_DATA
 440 \f
 441 /* Functions for the m68k ELF linker.  */
 442
 443 /* The name of the dynamic interpreter.  This is put in the .interp
 444    section.  */
 445
 446 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 447
 448 /* Describes one of the various PLT styles.  */
 449
 450 struct elf_m68k_plt_info
 451 {
 452   /* The size of each PLT entry.  */
 453   bfd_vma size;
 454
 455   /* The template for the first PLT entry.  */
 456   const bfd_byte *plt0_entry;
 457
 458   /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
 459      The comments by each member indicate the value that the relocation
 460      is against.  */
 461   struct {
 462     unsigned int got4; /* .got + 4 */
 463     unsigned int got8; /* .got + 8 */
 464   } plt0_relocs;
 465
 466   /* The template for a symbol's PLT entry.  */
 467   const bfd_byte *symbol_entry;
 468
 469   /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
 470      The comments by each member indicate the value that the relocation
 471      is against.  */
 472   struct {
 473     unsigned int got; /* the symbol's .got.plt entry */
 474     unsigned int plt; /* .plt */
 475   } symbol_relocs;
 476
 477   /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
 478      The stub starts with "move.l #relocoffset,%d0".  */
 479   bfd_vma symbol_resolve_entry;
 480 };
 481
 482 /* The size in bytes of an entry in the procedure linkage table.  */
 483
 484 #define PLT_ENTRY_SIZE 20
 485
 486 /* The first entry in a procedure linkage table looks like this.  See
 487    the SVR4 ABI m68k supplement to see how this works.  */
 488
 489 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
 490 {
 491   0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
 492   0, 0, 0, 2,             /* + (.got + 4) - . */
 493   0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
 494   0, 0, 0, 2,             /* + (.got + 8) - . */
 495   0, 0, 0, 0              /* pad out to 20 bytes.  */
 496 };
 497
 498 /* Subsequent entries in a procedure linkage table look like this.  */
 499
 500 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
 501 {
 502   0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
 503   0, 0, 0, 2,             /* + (.got.plt entry) - . */
 504   0x2f, 0x3c,             /* move.l #offset,-(%sp) */
 505   0, 0, 0, 0,             /* + reloc index */
 506   0x60, 0xff,             /* bra.l .plt */
 507   0, 0, 0, 0              /* + .plt - . */
 508 };
 509
 510 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
 511   PLT_ENTRY_SIZE,
 512   elf_m68k_plt0_entry, { 4, 12 },
 513   elf_m68k_plt_entry, { 4, 16 }, 8
 514 };
 515
 516 #define ISAB_PLT_ENTRY_SIZE 24
 517
 518 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
 519 {
 520   0x20, 0x3c,             /* move.l #offset,%d0 */
 521   0, 0, 0, 0,             /* + (.got + 4) - . */
 522   0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
 523   0x20, 0x3c,             /* move.l #offset,%d0 */
 524   0, 0, 0, 0,             /* + (.got + 8) - . */
 525   0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
 526   0x4e, 0xd0,             /* jmp (%a0) */
 527   0x4e, 0x71              /* nop */
 528 };
 529
 530 /* Subsequent entries in a procedure linkage table look like this.  */
 531
 532 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
 533 {
 534   0x20, 0x3c,             /* move.l #offset,%d0 */
 535   0, 0, 0, 0,             /* + (.got.plt entry) - . */
 536   0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
 537   0x4e, 0xd0,             /* jmp (%a0) */
 538   0x2f, 0x3c,             /* move.l #offset,-(%sp) */
 539   0, 0, 0, 0,             /* + reloc index */
 540   0x60, 0xff,             /* bra.l .plt */
 541   0, 0, 0, 0              /* + .plt - . */
 542 };
 543
 544 static const struct elf_m68k_plt_info elf_isab_plt_info = {
 545   ISAB_PLT_ENTRY_SIZE,
 546   elf_isab_plt0_entry, { 2, 12 },
 547   elf_isab_plt_entry, { 2, 20 }, 12
 548 };
 549
 550 #define ISAC_PLT_ENTRY_SIZE 24
 551
 552 static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
 553 {
 554   0x20, 0x3c,             /* move.l #offset,%d0 */
 555   0, 0, 0, 0,             /* replaced with .got + 4 - . */
 556   0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
 557   0x20, 0x3c,             /* move.l #offset,%d0 */
 558   0, 0, 0, 0,             /* replaced with .got + 8 - . */
 559   0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
 560   0x4e, 0xd0,             /* jmp (%a0) */
 561   0x4e, 0x71              /* nop */
 562 };
 563
 564 /* Subsequent entries in a procedure linkage table look like this.  */
 565
 566 static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
 567 {
 568   0x20, 0x3c,             /* move.l #offset,%d0 */
 569   0, 0, 0, 0,             /* replaced with (.got entry) - . */
 570   0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
 571   0x4e, 0xd0,             /* jmp (%a0) */
 572   0x2f, 0x3c,             /* move.l #offset,-(%sp) */
 573   0, 0, 0, 0,             /* replaced with offset into relocation table */
 574   0x61, 0xff,             /* bsr.l .plt */
 575   0, 0, 0, 0              /* replaced with .plt - . */
 576 };
 577
 578 static const struct elf_m68k_plt_info elf_isac_plt_info = {
 579   ISAC_PLT_ENTRY_SIZE,
 580   elf_isac_plt0_entry, { 2, 12},
 581   elf_isac_plt_entry, { 2, 20 }, 12
 582 };
 583
 584 #define CPU32_PLT_ENTRY_SIZE 24
 585 /* Procedure linkage table entries for the cpu32 */
 586 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
 587 {
 588   0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
 589   0, 0, 0, 2,             /* + (.got + 4) - . */
 590   0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
 591   0, 0, 0, 2,             /* + (.got + 8) - . */
 592   0x4e, 0xd1,             /* jmp %a1@ */
 593   0, 0, 0, 0,             /* pad out to 24 bytes.  */
 594   0, 0
 595 };
 596
 597 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
 598 {
 599   0x22, 0x7b, 0x01, 0x70,  /* moveal %pc@(0xc), %a1 */
 600   0, 0, 0, 2,              /* + (.got.plt entry) - . */
 601   0x4e, 0xd1,              /* jmp %a1@ */
 602   0x2f, 0x3c,              /* move.l #offset,-(%sp) */
 603   0, 0, 0, 0,              /* + reloc index */
 604   0x60, 0xff,              /* bra.l .plt */
 605   0, 0, 0, 0,              /* + .plt - . */
 606   0, 0
 607 };
 608
 609 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
 610   CPU32_PLT_ENTRY_SIZE,
 611   elf_cpu32_plt0_entry, { 4, 12 },
 612   elf_cpu32_plt_entry, { 4, 18 }, 10
 613 };
 614
 615 /* The m68k linker needs to keep track of the number of relocs that it
 616    decides to copy in check_relocs for each symbol.  This is so that it
 617    can discard PC relative relocs if it doesn't need them when linking
 618    with -Bsymbolic.  We store the information in a field extending the
 619    regular ELF linker hash table.  */
 620
 621 /* This structure keeps track of the number of PC relative relocs we have
 622    copied for a given symbol.  */
 623
 624 struct elf_m68k_pcrel_relocs_copied
 625 {
 626   /* Next section.  */
 627   struct elf_m68k_pcrel_relocs_copied *next;
 628   /* A section in dynobj.  */
 629   asection *section;
 630   /* Number of relocs copied in this section.  */
 631   bfd_size_type count;
 632 };
 633
 634 /* Forward declaration.  */
 635 struct elf_m68k_got_entry;
 636
 637 /* m68k ELF linker hash entry.  */
 638
 639 struct elf_m68k_link_hash_entry
 640 {
 641   struct elf_link_hash_entry root;
 642
 643   /* Number of PC relative relocs copied for this symbol.  */
 644   struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
 645
 646   /* Key to got_entries.  */
 647   unsigned long got_entry_key;
 648
 649   /* List of GOT entries for this symbol.  This list is build during
 650      offset finalization and is used within elf_m68k_finish_dynamic_symbol
 651      to traverse all GOT entries for a particular symbol.
 652
 653      ??? We could've used root.got.glist field instead, but having
 654      a separate field is cleaner.  */
 655   struct elf_m68k_got_entry *glist;
 656 };
 657
 658 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
 659
 660 /* Key part of GOT entry in hashtable.  */
 661 struct elf_m68k_got_entry_key
 662 {
 663   /* BFD in which this symbol was defined.  NULL for global symbols.  */
 664   const bfd *bfd;
 665
 666   /* Symbol index.  Either local symbol index or h->got_entry_key.  */
 667   unsigned long symndx;
 668
 669   /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32},
 670      R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}.
 671
 672      From perspective of hashtable key, only elf_m68k_got_reloc_type (type)
 673      matters.  That is, we distinguish between, say, R_68K_GOT16O
 674      and R_68K_GOT32O when allocating offsets, but they are considered to be
 675      the same when searching got->entries.  */
 676   enum elf_m68k_reloc_type type;
 677 };
 678
 679 /* Size of the GOT offset suitable for relocation.  */
 680 enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST };
 681
 682 /* Entry of the GOT.  */
 683 struct elf_m68k_got_entry
 684 {
 685   /* GOT entries are put into a got->entries hashtable.  This is the key.  */
 686   struct elf_m68k_got_entry_key key_;
 687
 688   /* GOT entry data.  We need s1 before offset finalization and s2 after.  */
 689   union
 690   {
 691     struct
 692     {
 693       /* Number of times this entry is referenced.  It is used to
 694          filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook.  */
 695       bfd_vma refcount;
 696     } s1;
 697
 698     struct
 699     {
 700       /* Offset from the start of .got section.  To calculate offset relative
 701          to GOT pointer one should substract got->offset from this value.  */
 702       bfd_vma offset;
 703
 704       /* Pointer to the next GOT entry for this global symbol.
 705          Symbols have at most one entry in one GOT, but might
 706          have entries in more than one GOT.
 707          Root of this list is h->glist.
 708          NULL for local symbols.  */
 709       struct elf_m68k_got_entry *next;
 710     } s2;
 711   } u;
 712 };
 713
 714 /* Return representative type for relocation R_TYPE.
 715    This is used to avoid enumerating many relocations in comparisons,
 716    switches etc.  */
 717
 718 static enum elf_m68k_reloc_type
 719 elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type)
 720 {
 721   switch (r_type)
 722     {
 723       /* In most cases R_68K_GOTx relocations require the very same
 724          handling as R_68K_GOT32O relocation.  In cases when we need
 725          to distinguish between the two, we use explicitly compare against
 726          r_type.  */
 727     case R_68K_GOT32:
 728     case R_68K_GOT16:
 729     case R_68K_GOT8:
 730     case R_68K_GOT32O:
 731     case R_68K_GOT16O:
 732     case R_68K_GOT8O:
 733       return R_68K_GOT32O;
 734
 735     case R_68K_TLS_GD32:
 736     case R_68K_TLS_GD16:
 737     case R_68K_TLS_GD8:
 738       return R_68K_TLS_GD32;
 739
 740     case R_68K_TLS_LDM32:
 741     case R_68K_TLS_LDM16:
 742     case R_68K_TLS_LDM8:
 743       return R_68K_TLS_LDM32;
 744
 745     case R_68K_TLS_IE32:
 746     case R_68K_TLS_IE16:
 747     case R_68K_TLS_IE8:
 748       return R_68K_TLS_IE32;
 749
 750     default:
 751       BFD_ASSERT (FALSE);
 752       return 0;
 753     }
 754 }
 755
 756 /* Return size of the GOT entry offset for relocation R_TYPE.  */
 757
 758 static enum elf_m68k_got_offset_size
 759 elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type)
 760 {
 761   switch (r_type)
 762     {
 763     case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8:
 764     case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32:
 765     case R_68K_TLS_IE32:
 766       return R_32;
 767
 768     case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16:
 769     case R_68K_TLS_IE16:
 770       return R_16;
 771
 772     case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8:
 773     case R_68K_TLS_IE8:
 774       return R_8;
 775
 776     default:
 777       BFD_ASSERT (FALSE);
 778       return 0;
 779     }
 780 }
 781
 782 /* Return number of GOT entries we need to allocate in GOT for
 783    relocation R_TYPE.  */
 784
 785 static bfd_vma
 786 elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type)
 787 {
 788   switch (elf_m68k_reloc_got_type (r_type))
 789     {
 790     case R_68K_GOT32O:
 791     case R_68K_TLS_IE32:
 792       return 1;
 793
 794     case R_68K_TLS_GD32:
 795     case R_68K_TLS_LDM32:
 796       return 2;
 797
 798     default:
 799       BFD_ASSERT (FALSE);
 800       return 0;
 801     }
 802 }
 803
 804 /* Return TRUE if relocation R_TYPE is a TLS one.  */
 805
 806 static bfd_boolean
 807 elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type)
 808 {
 809   switch (r_type)
 810     {
 811     case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8:
 812     case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8:
 813     case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8:
 814     case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8:
 815     case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8:
 816     case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32:
 817       return TRUE;
 818
 819     default:
 820       return FALSE;
 821     }
 822 }
 823
 824 /* Data structure representing a single GOT.  */
 825 struct elf_m68k_got
 826 {
 827   /* Hashtable of 'struct elf_m68k_got_entry's.
 828      Starting size of this table is the maximum number of
 829      R_68K_GOT8O entries.  */
 830   htab_t entries;
 831
 832   /* Number of R_x slots in this GOT.  Some (e.g., TLS) entries require
 833      several GOT slots.
 834
 835      n_slots[R_8] is the count of R_8 slots in this GOT.
 836      n_slots[R_16] is the cumulative count of R_8 and R_16 slots
 837      in this GOT.
 838      n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots
 839      in this GOT.  This is the total number of slots.  */
 840   bfd_vma n_slots[R_LAST];
 841
 842   /* Number of local (entry->key_.h == NULL) slots in this GOT.
 843      This is only used to properly calculate size of .rela.got section;
 844      see elf_m68k_partition_multi_got.  */
 845   bfd_vma local_n_slots;
 846
 847   /* Offset of this GOT relative to beginning of .got section.  */
 848   bfd_vma offset;
 849 };
 850
 851 /* BFD and its GOT.  This is an entry in multi_got->bfd2got hashtable.  */
 852 struct elf_m68k_bfd2got_entry
 853 {
 854   /* BFD.  */
 855   const bfd *bfd;
 856
 857   /* Assigned GOT.  Before partitioning multi-GOT each BFD has its own
 858      GOT structure.  After partitioning several BFD's might [and often do]
 859      share a single GOT.  */
 860   struct elf_m68k_got *got;
 861 };
 862
 863 /* The main data structure holding all the pieces.  */
 864 struct elf_m68k_multi_got
 865 {
 866   /* Hashtable mapping each BFD to its GOT.  If a BFD doesn't have an entry
 867      here, then it doesn't need a GOT (this includes the case of a BFD
 868      having an empty GOT).
 869
 870      ??? This hashtable can be replaced by an array indexed by bfd->id.  */
 871   htab_t bfd2got;
 872
 873   /* Next symndx to assign a global symbol.
 874      h->got_entry_key is initialized from this counter.  */
 875   unsigned long global_symndx;
 876 };
 877
 878 /* m68k ELF linker hash table.  */
 879
 880 struct elf_m68k_link_hash_table
 881 {
 882   struct elf_link_hash_table root;
 883
 884   /* Small local sym cache.  */
 885   struct sym_cache sym_cache;
 886
 887   /* The PLT format used by this link, or NULL if the format has not
 888      yet been chosen.  */
 889   const struct elf_m68k_plt_info *plt_info;
 890
 891   /* True, if GP is loaded within each function which uses it.
 892      Set to TRUE when GOT negative offsets or multi-GOT is enabled.  */
 893   bfd_boolean local_gp_p;
 894
 895   /* Switch controlling use of negative offsets to double the size of GOTs.  */
 896   bfd_boolean use_neg_got_offsets_p;
 897
 898   /* Switch controlling generation of multiple GOTs.  */
 899   bfd_boolean allow_multigot_p;
 900
 901   /* Multi-GOT data structure.  */
 902   struct elf_m68k_multi_got multi_got_;
 903 };
 904
 905 /* Get the m68k ELF linker hash table from a link_info structure.  */
 906
 907 #define elf_m68k_hash_table(p) \
 908   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 909   == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL)
 910
 911 /* Shortcut to multi-GOT data.  */
 912 #define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_)
 913
 914 /* Create an entry in an m68k ELF linker hash table.  */
 915
 916 static struct bfd_hash_entry *
 917 elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry,
 918                             struct bfd_hash_table *table,
 919                             const char *string)
 920 {
 921   struct bfd_hash_entry *ret = entry;
 922
 923   /* Allocate the structure if it has not already been allocated by a
 924      subclass.  */
 925   if (ret == NULL)
 926     ret = bfd_hash_allocate (table,
 927                              sizeof (struct elf_m68k_link_hash_entry));
 928   if (ret == NULL)
 929     return ret;
 930
 931   /* Call the allocation method of the superclass.  */
 932   ret = _bfd_elf_link_hash_newfunc (ret, table, string);
 933   if (ret != NULL)
 934     {
 935       elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
 936       elf_m68k_hash_entry (ret)->got_entry_key = 0;
 937       elf_m68k_hash_entry (ret)->glist = NULL;
 938     }
 939
 940   return ret;
 941 }
 942
 943 /* Create an m68k ELF linker hash table.  */
 944
 945 static struct bfd_link_hash_table *
 946 elf_m68k_link_hash_table_create (bfd *abfd)
 947 {
 948   struct elf_m68k_link_hash_table *ret;
 949   bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
 950
 951   ret = (struct elf_m68k_link_hash_table *) bfd_zmalloc (amt);
 952   if (ret == (struct elf_m68k_link_hash_table *) NULL)
 953     return NULL;
 954
 955   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 956                                       elf_m68k_link_hash_newfunc,
 957                                       sizeof (struct elf_m68k_link_hash_entry),
 958                                       M68K_ELF_DATA))
 959     {
 960       free (ret);
 961       return NULL;
 962     }
 963
 964   ret->multi_got_.global_symndx = 1;
 965
 966   return &ret->root.root;
 967 }
 968
 969 /* Destruct local data.  */
 970
 971 static void
 972 elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab)
 973 {
 974   struct elf_m68k_link_hash_table *htab;
 975
 976   htab = (struct elf_m68k_link_hash_table *) _htab;
 977
 978   if (htab->multi_got_.bfd2got != NULL)
 979     {
 980       htab_delete (htab->multi_got_.bfd2got);
 981       htab->multi_got_.bfd2got = NULL;
 982     }
 983   _bfd_elf_link_hash_table_free (_htab);
 984 }
 985
 986 /* Set the right machine number.  */
 987
 988 static bfd_boolean
 989 elf32_m68k_object_p (bfd *abfd)
 990 {
 991   unsigned int mach = 0;
 992   unsigned features = 0;
 993   flagword eflags = elf_elfheader (abfd)->e_flags;
 994
 995   if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
 996     features |= m68000;
 997   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
 998     features |= cpu32;
 999   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1000     features |= fido_a;
1001   else
1002     {
1003       switch (eflags & EF_M68K_CF_ISA_MASK)
1004         {
1005         case EF_M68K_CF_ISA_A_NODIV:
1006           features |= mcfisa_a;
1007           break;
1008         case EF_M68K_CF_ISA_A:
1009           features |= mcfisa_a|mcfhwdiv;
1010           break;
1011         case EF_M68K_CF_ISA_A_PLUS:
1012           features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1013           break;
1014         case EF_M68K_CF_ISA_B_NOUSP:
1015           features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1016           break;
1017         case EF_M68K_CF_ISA_B:
1018           features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1019           break;
1020         case EF_M68K_CF_ISA_C:
1021           features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1022           break;
1023         case EF_M68K_CF_ISA_C_NODIV:
1024           features |= mcfisa_a|mcfisa_c|mcfusp;
1025           break;
1026         }
1027       switch (eflags & EF_M68K_CF_MAC_MASK)
1028         {
1029         case EF_M68K_CF_MAC:
1030           features |= mcfmac;
1031           break;
1032         case EF_M68K_CF_EMAC:
1033           features |= mcfemac;
1034           break;
1035         }
1036       if (eflags & EF_M68K_CF_FLOAT)
1037         features |= cfloat;
1038     }
1039
1040   mach = bfd_m68k_features_to_mach (features);
1041   bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1042
1043   return TRUE;
1044 }
1045
1046 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1047    field based on the machine number.  */
1048
1049 static void
1050 elf_m68k_final_write_processing (bfd *abfd,
1051                                  bfd_boolean linker ATTRIBUTE_UNUSED)
1052 {
1053   int mach = bfd_get_mach (abfd);
1054   unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1055
1056   if (!e_flags)
1057     {
1058       unsigned int arch_mask;
1059
1060       arch_mask = bfd_m68k_mach_to_features (mach);
1061
1062       if (arch_mask & m68000)
1063         e_flags = EF_M68K_M68000;
1064       else if (arch_mask & cpu32)
1065         e_flags = EF_M68K_CPU32;
1066       else if (arch_mask & fido_a)
1067         e_flags = EF_M68K_FIDO;
1068       else
1069         {
1070           switch (arch_mask
1071                   & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1072             {
1073             case mcfisa_a:
1074               e_flags |= EF_M68K_CF_ISA_A_NODIV;
1075               break;
1076             case mcfisa_a | mcfhwdiv:
1077               e_flags |= EF_M68K_CF_ISA_A;
1078               break;
1079             case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1080               e_flags |= EF_M68K_CF_ISA_A_PLUS;
1081               break;
1082             case mcfisa_a | mcfisa_b | mcfhwdiv:
1083               e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1084               break;
1085             case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1086               e_flags |= EF_M68K_CF_ISA_B;
1087               break;
1088             case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1089               e_flags |= EF_M68K_CF_ISA_C;
1090               break;
1091             case mcfisa_a | mcfisa_c | mcfusp:
1092               e_flags |= EF_M68K_CF_ISA_C_NODIV;
1093               break;
1094             }
1095           if (arch_mask & mcfmac)
1096             e_flags |= EF_M68K_CF_MAC;
1097           else if (arch_mask & mcfemac)
1098             e_flags |= EF_M68K_CF_EMAC;
1099           if (arch_mask & cfloat)
1100             e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1101         }
1102       elf_elfheader (abfd)->e_flags = e_flags;
1103     }
1104 }
1105
1106 /* Keep m68k-specific flags in the ELF header.  */
1107
1108 static bfd_boolean
1109 elf32_m68k_set_private_flags (bfd *abfd, flagword flags)
1110 {
1111   elf_elfheader (abfd)->e_flags = flags;
1112   elf_flags_init (abfd) = TRUE;
1113   return TRUE;
1114 }
1115
1116 /* Merge backend specific data from an object file to the output
1117    object file when linking.  */
1118 static bfd_boolean
1119 elf32_m68k_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1120 {
1121   flagword out_flags;
1122   flagword in_flags;
1123   flagword out_isa;
1124   flagword in_isa;
1125   const bfd_arch_info_type *arch_info;
1126
1127   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1128       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1129     return FALSE;
1130
1131   /* Get the merged machine.  This checks for incompatibility between
1132      Coldfire & non-Coldfire flags, incompability between different
1133      Coldfire ISAs, and incompability between different MAC types.  */
1134   arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
1135   if (!arch_info)
1136     return FALSE;
1137
1138   bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
1139
1140   in_flags = elf_elfheader (ibfd)->e_flags;
1141   if (!elf_flags_init (obfd))
1142     {
1143       elf_flags_init (obfd) = TRUE;
1144       out_flags = in_flags;
1145     }
1146   else
1147     {
1148       out_flags = elf_elfheader (obfd)->e_flags;
1149       unsigned int variant_mask;
1150
1151       if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1152         variant_mask = 0;
1153       else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1154         variant_mask = 0;
1155       else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1156         variant_mask = 0;
1157       else
1158         variant_mask = EF_M68K_CF_ISA_MASK;
1159
1160       in_isa = (in_flags & variant_mask);
1161       out_isa = (out_flags & variant_mask);
1162       if (in_isa > out_isa)
1163         out_flags ^= in_isa ^ out_isa;
1164       if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
1165            && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1166           || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
1167               && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
1168         out_flags = EF_M68K_FIDO;
1169       else
1170       out_flags |= in_flags ^ in_isa;
1171     }
1172   elf_elfheader (obfd)->e_flags = out_flags;
1173
1174   return TRUE;
1175 }
1176
1177 /* Display the flags field.  */
1178
1179 static bfd_boolean
1180 elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr)
1181 {
1182   FILE *file = (FILE *) ptr;
1183   flagword eflags = elf_elfheader (abfd)->e_flags;
1184
1185   BFD_ASSERT (abfd != NULL && ptr != NULL);
1186
1187   /* Print normal ELF private data.  */
1188   _bfd_elf_print_private_bfd_data (abfd, ptr);
1189
1190   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
1191
1192   /* xgettext:c-format */
1193   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1194
1195   if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1196     fprintf (file, " [m68000]");
1197   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1198     fprintf (file, " [cpu32]");
1199   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1200     fprintf (file, " [fido]");
1201   else
1202     {
1203       if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
1204         fprintf (file, " [cfv4e]");
1205
1206       if (eflags & EF_M68K_CF_ISA_MASK)
1207         {
1208           char const *isa = _("unknown");
1209           char const *mac = _("unknown");
1210           char const *additional = "";
1211
1212           switch (eflags & EF_M68K_CF_ISA_MASK)
1213             {
1214             case EF_M68K_CF_ISA_A_NODIV:
1215               isa = "A";
1216               additional = " [nodiv]";
1217               break;
1218             case EF_M68K_CF_ISA_A:
1219               isa = "A";
1220               break;
1221             case EF_M68K_CF_ISA_A_PLUS:
1222               isa = "A+";
1223               break;
1224             case EF_M68K_CF_ISA_B_NOUSP:
1225               isa = "B";
1226               additional = " [nousp]";
1227               break;
1228             case EF_M68K_CF_ISA_B:
1229               isa = "B";
1230               break;
1231             case EF_M68K_CF_ISA_C:
1232               isa = "C";
1233               break;
1234             case EF_M68K_CF_ISA_C_NODIV:
1235               isa = "C";
1236               additional = " [nodiv]";
1237               break;
1238             }
1239           fprintf (file, " [isa %s]%s", isa, additional);
1240
1241           if (eflags & EF_M68K_CF_FLOAT)
1242             fprintf (file, " [float]");
1243
1244           switch (eflags & EF_M68K_CF_MAC_MASK)
1245             {
1246             case 0:
1247               mac = NULL;
1248               break;
1249             case EF_M68K_CF_MAC:
1250               mac = "mac";
1251               break;
1252             case EF_M68K_CF_EMAC:
1253               mac = "emac";
1254               break;
1255             case EF_M68K_CF_EMAC_B:
1256               mac = "emac_b";
1257               break;
1258             }
1259           if (mac)
1260             fprintf (file, " [%s]", mac);
1261         }
1262     }
1263
1264   fputc ('\n', file);
1265
1266   return TRUE;
1267 }
1268
1269 /* Multi-GOT support implementation design:
1270
1271    Multi-GOT starts in check_relocs hook.  There we scan all
1272    relocations of a BFD and build a local GOT (struct elf_m68k_got)
1273    for it.  If a single BFD appears to require too many GOT slots with
1274    R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification
1275    to user.
1276    After check_relocs has been invoked for each input BFD, we have
1277    constructed a GOT for each input BFD.
1278
1279    To minimize total number of GOTs required for a particular output BFD
1280    (as some environments support only 1 GOT per output object) we try
1281    to merge some of the GOTs to share an offset space.  Ideally [and in most
1282    cases] we end up with a single GOT.  In cases when there are too many
1283    restricted relocations (e.g., R_68K_GOT16O relocations) we end up with
1284    several GOTs, assuming the environment can handle them.
1285
1286    Partitioning is done in elf_m68k_partition_multi_got.  We start with
1287    an empty GOT and traverse bfd2got hashtable putting got_entries from
1288    local GOTs to the new 'big' one.  We do that by constructing an
1289    intermediate GOT holding all the entries the local GOT has and the big
1290    GOT lacks.  Then we check if there is room in the big GOT to accomodate
1291    all the entries from diff.  On success we add those entries to the big
1292    GOT; on failure we start the new 'big' GOT and retry the adding of
1293    entries from the local GOT.  Note that this retry will always succeed as
1294    each local GOT doesn't overflow the limits.  After partitioning we
1295    end up with each bfd assigned one of the big GOTs.  GOT entries in the
1296    big GOTs are initialized with GOT offsets.  Note that big GOTs are
1297    positioned consequently in program space and represent a single huge GOT
1298    to the outside world.
1299
1300    After that we get to elf_m68k_relocate_section.  There we
1301    adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol
1302    relocations to refer to appropriate [assigned to current input_bfd]
1303    big GOT.
1304
1305    Notes:
1306
1307    GOT entry type: We have several types of GOT entries.
1308    * R_8 type is used in entries for symbols that have at least one
1309    R_68K_GOT8O or R_68K_TLS_*8 relocation.  We can have at most 0x40
1310    such entries in one GOT.
1311    * R_16 type is used in entries for symbols that have at least one
1312    R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations.
1313    We can have at most 0x4000 such entries in one GOT.
1314    * R_32 type is used in all other cases.  We can have as many
1315    such entries in one GOT as we'd like.
1316    When counting relocations we have to include the count of the smaller
1317    ranged relocations in the counts of the larger ranged ones in order
1318    to correctly detect overflow.
1319
1320    Sorting the GOT: In each GOT starting offsets are assigned to
1321    R_8 entries, which are followed by R_16 entries, and
1322    R_32 entries go at the end.  See finalize_got_offsets for details.
1323
1324    Negative GOT offsets: To double usable offset range of GOTs we use
1325    negative offsets.  As we assign entries with GOT offsets relative to
1326    start of .got section, the offset values are positive.  They become
1327    negative only in relocate_section where got->offset value is
1328    subtracted from them.
1329
1330    3 special GOT entries: There are 3 special GOT entries used internally
1331    by loader.  These entries happen to be placed to .got.plt section,
1332    so we don't do anything about them in multi-GOT support.
1333
1334    Memory management: All data except for hashtables
1335    multi_got->bfd2got and got->entries are allocated on
1336    elf_hash_table (info)->dynobj bfd (for this reason we pass 'info'
1337    to most functions), so we don't need to care to free them.  At the
1338    moment of allocation hashtables are being linked into main data
1339    structure (multi_got), all pieces of which are reachable from
1340    elf_m68k_multi_got (info).  We deallocate them in
1341    elf_m68k_link_hash_table_free.  */
1342
1343 /* Initialize GOT.  */
1344
1345 static void
1346 elf_m68k_init_got (struct elf_m68k_got *got)
1347 {
1348   got->entries = NULL;
1349   got->n_slots[R_8] = 0;
1350   got->n_slots[R_16] = 0;
1351   got->n_slots[R_32] = 0;
1352   got->local_n_slots = 0;
1353   got->offset = (bfd_vma) -1;
1354 }
1355
1356 /* Destruct GOT.  */
1357
1358 static void
1359 elf_m68k_clear_got (struct elf_m68k_got *got)
1360 {
1361   if (got->entries != NULL)
1362     {
1363       htab_delete (got->entries);
1364       got->entries = NULL;
1365     }
1366 }
1367
1368 /* Create and empty GOT structure.  INFO is the context where memory
1369    should be allocated.  */
1370
1371 static struct elf_m68k_got *
1372 elf_m68k_create_empty_got (struct bfd_link_info *info)
1373 {
1374   struct elf_m68k_got *got;
1375
1376   got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got));
1377   if (got == NULL)
1378     return NULL;
1379
1380   elf_m68k_init_got (got);
1381
1382   return got;
1383 }
1384
1385 /* Initialize KEY.  */
1386
1387 static void
1388 elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key,
1389                              struct elf_link_hash_entry *h,
1390                              const bfd *abfd, unsigned long symndx,
1391                              enum elf_m68k_reloc_type reloc_type)
1392 {
1393   if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32)
1394     /* All TLS_LDM relocations share a single GOT entry.  */
1395     {
1396       key->bfd = NULL;
1397       key->symndx = 0;
1398     }
1399   else if (h != NULL)
1400     /* Global symbols are identified with their got_entry_key.  */
1401     {
1402       key->bfd = NULL;
1403       key->symndx = elf_m68k_hash_entry (h)->got_entry_key;
1404       BFD_ASSERT (key->symndx != 0);
1405     }
1406   else
1407     /* Local symbols are identified by BFD they appear in and symndx.  */
1408     {
1409       key->bfd = abfd;
1410       key->symndx = symndx;
1411     }
1412
1413   key->type = reloc_type;
1414 }
1415
1416 /* Calculate hash of got_entry.
1417    ??? Is it good?  */
1418
1419 static hashval_t
1420 elf_m68k_got_entry_hash (const void *_entry)
1421 {
1422   const struct elf_m68k_got_entry_key *key;
1423
1424   key = &((const struct elf_m68k_got_entry *) _entry)->key_;
1425
1426   return (key->symndx
1427           + (key->bfd != NULL ? (int) key->bfd->id : -1)
1428           + elf_m68k_reloc_got_type (key->type));
1429 }
1430
1431 /* Check if two got entries are equal.  */
1432
1433 static int
1434 elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2)
1435 {
1436   const struct elf_m68k_got_entry_key *key1;
1437   const struct elf_m68k_got_entry_key *key2;
1438
1439   key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_;
1440   key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_;
1441
1442   return (key1->bfd == key2->bfd
1443           && key1->symndx == key2->symndx
1444           && (elf_m68k_reloc_got_type (key1->type)
1445               == elf_m68k_reloc_got_type (key2->type)));
1446 }
1447
1448 /* When using negative offsets, we allocate one extra R_8, one extra R_16
1449    and one extra R_32 slots to simplify handling of 2-slot entries during
1450    offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots.  */
1451
1452 /* Maximal number of R_8 slots in a single GOT.  */
1453 #define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO)           \
1454   (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1455    ? (0x40 - 1)                                                 \
1456    : 0x20)
1457
1458 /* Maximal number of R_8 and R_16 slots in a single GOT.  */
1459 #define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO)                \
1460   (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1461    ? (0x4000 - 2)                                               \
1462    : 0x2000)
1463
1464 /* SEARCH - simply search the hashtable, don't insert new entries or fail when
1465    the entry cannot be found.
1466    FIND_OR_CREATE - search for an existing entry, but create new if there's
1467    no such.
1468    MUST_FIND - search for an existing entry and assert that it exist.
1469    MUST_CREATE - assert that there's no such entry and create new one.  */
1470 enum elf_m68k_get_entry_howto
1471   {
1472     SEARCH,
1473     FIND_OR_CREATE,
1474     MUST_FIND,
1475     MUST_CREATE
1476   };
1477
1478 /* Get or create (depending on HOWTO) entry with KEY in GOT.
1479    INFO is context in which memory should be allocated (can be NULL if
1480    HOWTO is SEARCH or MUST_FIND).  */
1481
1482 static struct elf_m68k_got_entry *
1483 elf_m68k_get_got_entry (struct elf_m68k_got *got,
1484                         const struct elf_m68k_got_entry_key *key,
1485                         enum elf_m68k_get_entry_howto howto,
1486                         struct bfd_link_info *info)
1487 {
1488   struct elf_m68k_got_entry entry_;
1489   struct elf_m68k_got_entry *entry;
1490   void **ptr;
1491
1492   BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1493
1494   if (got->entries == NULL)
1495     /* This is the first entry in ABFD.  Initialize hashtable.  */
1496     {
1497       if (howto == SEARCH)
1498         return NULL;
1499
1500       got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT
1501                                       (info),
1502                                       elf_m68k_got_entry_hash,
1503                                       elf_m68k_got_entry_eq, NULL);
1504       if (got->entries == NULL)
1505         {
1506           bfd_set_error (bfd_error_no_memory);
1507           return NULL;
1508         }
1509     }
1510
1511   entry_.key_ = *key;
1512   ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH
1513                                                 ? INSERT : NO_INSERT));
1514   if (ptr == NULL)
1515     {
1516       if (howto == SEARCH)
1517         /* Entry not found.  */
1518         return NULL;
1519
1520       /* We're out of memory.  */
1521       bfd_set_error (bfd_error_no_memory);
1522       return NULL;
1523     }
1524
1525   if (*ptr == NULL)
1526     /* We didn't find the entry and we're asked to create a new one.  */
1527     {
1528       BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1529
1530       entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry));
1531       if (entry == NULL)
1532         return NULL;
1533
1534       /* Initialize new entry.  */
1535       entry->key_ = *key;
1536
1537       entry->u.s1.refcount = 0;
1538
1539       /* Mark the entry as not initialized.  */
1540       entry->key_.type = R_68K_max;
1541
1542       *ptr = entry;
1543     }
1544   else
1545     /* We found the entry.  */
1546     {
1547       BFD_ASSERT (howto != MUST_CREATE);
1548
1549       entry = *ptr;
1550     }
1551
1552   return entry;
1553 }
1554
1555 /* Update GOT counters when merging entry of WAS type with entry of NEW type.
1556    Return the value to which ENTRY's type should be set.  */
1557
1558 static enum elf_m68k_reloc_type
1559 elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
1560                                 enum elf_m68k_reloc_type was,
1561                                 enum elf_m68k_reloc_type new_reloc)
1562 {
1563   enum elf_m68k_got_offset_size was_size;
1564   enum elf_m68k_got_offset_size new_size;
1565   bfd_vma n_slots;
1566
1567   if (was == R_68K_max)
1568     /* The type of the entry is not initialized yet.  */
1569     {
1570       /* Update all got->n_slots counters, including n_slots[R_32].  */
1571       was_size = R_LAST;
1572
1573       was = new_reloc;
1574     }
1575   else
1576     {
1577       /* !!! We, probably, should emit an error rather then fail on assert
1578          in such a case.  */
1579       BFD_ASSERT (elf_m68k_reloc_got_type (was)
1580                   == elf_m68k_reloc_got_type (new_reloc));
1581
1582       was_size = elf_m68k_reloc_got_offset_size (was);
1583     }
1584
1585   new_size = elf_m68k_reloc_got_offset_size (new_reloc);
1586   n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
1587
1588   while (was_size > new_size)
1589     {
1590       --was_size;
1591       got->n_slots[was_size] += n_slots;
1592     }
1593
1594   if (new_reloc > was)
1595     /* Relocations are ordered from bigger got offset size to lesser,
1596        so choose the relocation type with lesser offset size.  */
1597     was = new_reloc;
1598
1599   return was;
1600 }
1601
1602 /* Update GOT counters when removing an entry of type TYPE.  */
1603
1604 static void
1605 elf_m68k_remove_got_entry_type (struct elf_m68k_got *got,
1606                                 enum elf_m68k_reloc_type type)
1607 {
1608   enum elf_m68k_got_offset_size os;
1609   bfd_vma n_slots;
1610
1611   n_slots = elf_m68k_reloc_got_n_slots (type);
1612
1613   /* Decrese counter of slots with offset size corresponding to TYPE
1614      and all greater offset sizes.  */
1615   for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os)
1616     {
1617       BFD_ASSERT (got->n_slots[os] >= n_slots);
1618
1619       got->n_slots[os] -= n_slots;
1620     }
1621 }
1622
1623 /* Add new or update existing entry to GOT.
1624    H, ABFD, TYPE and SYMNDX is data for the entry.
1625    INFO is a context where memory should be allocated.  */
1626
1627 static struct elf_m68k_got_entry *
1628 elf_m68k_add_entry_to_got (struct elf_m68k_got *got,
1629                            struct elf_link_hash_entry *h,
1630                            const bfd *abfd,
1631                            enum elf_m68k_reloc_type reloc_type,
1632                            unsigned long symndx,
1633                            struct bfd_link_info *info)
1634 {
1635   struct elf_m68k_got_entry_key key_;
1636   struct elf_m68k_got_entry *entry;
1637
1638   if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0)
1639     elf_m68k_hash_entry (h)->got_entry_key
1640       = elf_m68k_multi_got (info)->global_symndx++;
1641
1642   elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type);
1643
1644   entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info);
1645   if (entry == NULL)
1646     return NULL;
1647
1648   /* Determine entry's type and update got->n_slots counters.  */
1649   entry->key_.type = elf_m68k_update_got_entry_type (got,
1650                                                      entry->key_.type,
1651                                                      reloc_type);
1652
1653   /* Update refcount.  */
1654   ++entry->u.s1.refcount;
1655
1656   if (entry->u.s1.refcount == 1)
1657     /* We see this entry for the first time.  */
1658     {
1659       if (entry->key_.bfd != NULL)
1660         got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type);
1661     }
1662
1663   BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
1664
1665   if ((got->n_slots[R_8]
1666        > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1667       || (got->n_slots[R_16]
1668           > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1669     /* This BFD has too many relocation.  */
1670     {
1671       if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1672         (*_bfd_error_handler) (_("%B: GOT overflow: "
1673                                  "Number of relocations with 8-bit "
1674                                  "offset > %d"),
1675                                abfd,
1676                                ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
1677       else
1678         (*_bfd_error_handler) (_("%B: GOT overflow: "
1679                                  "Number of relocations with 8- or 16-bit "
1680                                  "offset > %d"),
1681                                abfd,
1682                                ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
1683
1684       return NULL;
1685     }
1686
1687   return entry;
1688 }
1689
1690 /* Compute the hash value of the bfd in a bfd2got hash entry.  */
1691
1692 static hashval_t
1693 elf_m68k_bfd2got_entry_hash (const void *entry)
1694 {
1695   const struct elf_m68k_bfd2got_entry *e;
1696
1697   e = (const struct elf_m68k_bfd2got_entry *) entry;
1698
1699   return e->bfd->id;
1700 }
1701
1702 /* Check whether two hash entries have the same bfd.  */
1703
1704 static int
1705 elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2)
1706 {
1707   const struct elf_m68k_bfd2got_entry *e1;
1708   const struct elf_m68k_bfd2got_entry *e2;
1709
1710   e1 = (const struct elf_m68k_bfd2got_entry *) entry1;
1711   e2 = (const struct elf_m68k_bfd2got_entry *) entry2;
1712
1713   return e1->bfd == e2->bfd;
1714 }
1715
1716 /* Destruct a bfd2got entry.  */
1717
1718 static void
1719 elf_m68k_bfd2got_entry_del (void *_entry)
1720 {
1721   struct elf_m68k_bfd2got_entry *entry;
1722
1723   entry = (struct elf_m68k_bfd2got_entry *) _entry;
1724
1725   BFD_ASSERT (entry->got != NULL);
1726   elf_m68k_clear_got (entry->got);
1727 }
1728
1729 /* Find existing or create new (depending on HOWTO) bfd2got entry in
1730    MULTI_GOT.  ABFD is the bfd we need a GOT for.  INFO is a context where
1731    memory should be allocated.  */
1732
1733 static struct elf_m68k_bfd2got_entry *
1734 elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got,
1735                             const bfd *abfd,
1736                             enum elf_m68k_get_entry_howto howto,
1737                             struct bfd_link_info *info)
1738 {
1739   struct elf_m68k_bfd2got_entry entry_;
1740   void **ptr;
1741   struct elf_m68k_bfd2got_entry *entry;
1742
1743   BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1744
1745   if (multi_got->bfd2got == NULL)
1746     /* This is the first GOT.  Initialize bfd2got.  */
1747     {
1748       if (howto == SEARCH)
1749         return NULL;
1750
1751       multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash,
1752                                             elf_m68k_bfd2got_entry_eq,
1753                                             elf_m68k_bfd2got_entry_del);
1754       if (multi_got->bfd2got == NULL)
1755         {
1756           bfd_set_error (bfd_error_no_memory);
1757           return NULL;
1758         }
1759     }
1760
1761   entry_.bfd = abfd;
1762   ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH
1763                                                       ? INSERT : NO_INSERT));
1764   if (ptr == NULL)
1765     {
1766       if (howto == SEARCH)
1767         /* Entry not found.  */
1768         return NULL;
1769
1770       /* We're out of memory.  */
1771       bfd_set_error (bfd_error_no_memory);
1772       return NULL;
1773     }
1774
1775   if (*ptr == NULL)
1776     /* Entry was not found.  Create new one.  */
1777     {
1778       BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1779
1780       entry = ((struct elf_m68k_bfd2got_entry *)
1781                bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)));
1782       if (entry == NULL)
1783         return NULL;
1784
1785       entry->bfd = abfd;
1786
1787       entry->got = elf_m68k_create_empty_got (info);
1788       if (entry->got == NULL)
1789         return NULL;
1790
1791       *ptr = entry;
1792     }
1793   else
1794     {
1795       BFD_ASSERT (howto != MUST_CREATE);
1796
1797       /* Return existing entry.  */
1798       entry = *ptr;
1799     }
1800
1801   return entry;
1802 }
1803
1804 struct elf_m68k_can_merge_gots_arg
1805 {
1806   /* A current_got that we constructing a DIFF against.  */
1807   struct elf_m68k_got *big;
1808
1809   /* GOT holding entries not present or that should be changed in
1810      BIG.  */
1811   struct elf_m68k_got *diff;
1812
1813   /* Context where to allocate memory.  */
1814   struct bfd_link_info *info;
1815
1816   /* Error flag.  */
1817   bfd_boolean error_p;
1818 };
1819
1820 /* Process a single entry from the small GOT to see if it should be added
1821    or updated in the big GOT.  */
1822
1823 static int
1824 elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg)
1825 {
1826   const struct elf_m68k_got_entry *entry1;
1827   struct elf_m68k_can_merge_gots_arg *arg;
1828   const struct elf_m68k_got_entry *entry2;
1829   enum elf_m68k_reloc_type type;
1830
1831   entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr;
1832   arg = (struct elf_m68k_can_merge_gots_arg *) _arg;
1833
1834   entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL);
1835
1836   if (entry2 != NULL)
1837     /* We found an existing entry.  Check if we should update it.  */
1838     {
1839       type = elf_m68k_update_got_entry_type (arg->diff,
1840                                              entry2->key_.type,
1841                                              entry1->key_.type);
1842
1843       if (type == entry2->key_.type)
1844         /* ENTRY1 doesn't update data in ENTRY2.  Skip it.
1845            To skip creation of difference entry we use the type,
1846            which we won't see in GOT entries for sure.  */
1847         type = R_68K_max;
1848     }
1849   else
1850     /* We didn't find the entry.  Add entry1 to DIFF.  */
1851     {
1852       BFD_ASSERT (entry1->key_.type != R_68K_max);
1853
1854       type = elf_m68k_update_got_entry_type (arg->diff,
1855                                              R_68K_max, entry1->key_.type);
1856
1857       if (entry1->key_.bfd != NULL)
1858         arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type);
1859     }
1860
1861   if (type != R_68K_max)
1862     /* Create an entry in DIFF.  */
1863     {
1864       struct elf_m68k_got_entry *entry;
1865
1866       entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE,
1867                                       arg->info);
1868       if (entry == NULL)
1869         {
1870           arg->error_p = TRUE;
1871           return 0;
1872         }
1873
1874       entry->key_.type = type;
1875     }
1876
1877   return 1;
1878 }
1879
1880 /* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it.
1881    Construct DIFF GOT holding the entries which should be added or updated
1882    in BIG GOT to accumulate information from SMALL.
1883    INFO is the context where memory should be allocated.  */
1884
1885 static bfd_boolean
1886 elf_m68k_can_merge_gots (struct elf_m68k_got *big,
1887                          const struct elf_m68k_got *small,
1888                          struct bfd_link_info *info,
1889                          struct elf_m68k_got *diff)
1890 {
1891   struct elf_m68k_can_merge_gots_arg arg_;
1892
1893   BFD_ASSERT (small->offset == (bfd_vma) -1);
1894
1895   arg_.big = big;
1896   arg_.diff = diff;
1897   arg_.info = info;
1898   arg_.error_p = FALSE;
1899   htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_);
1900   if (arg_.error_p)
1901     {
1902       diff->offset = 0;
1903       return FALSE;
1904     }
1905
1906   /* Check for overflow.  */
1907   if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8]
1908        > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1909       || (big->n_slots[R_16] + arg_.diff->n_slots[R_16]
1910           > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1911     return FALSE;
1912
1913   return TRUE;
1914 }
1915
1916 struct elf_m68k_merge_gots_arg
1917 {
1918   /* The BIG got.  */
1919   struct elf_m68k_got *big;
1920
1921   /* Context where memory should be allocated.  */
1922   struct bfd_link_info *info;
1923
1924   /* Error flag.  */
1925   bfd_boolean error_p;
1926 };
1927
1928 /* Process a single entry from DIFF got.  Add or update corresponding
1929    entry in the BIG got.  */
1930
1931 static int
1932 elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg)
1933 {
1934   const struct elf_m68k_got_entry *from;
1935   struct elf_m68k_merge_gots_arg *arg;
1936   struct elf_m68k_got_entry *to;
1937
1938   from = (const struct elf_m68k_got_entry *) *entry_ptr;
1939   arg = (struct elf_m68k_merge_gots_arg *) _arg;
1940
1941   to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE,
1942                                arg->info);
1943   if (to == NULL)
1944     {
1945       arg->error_p = TRUE;
1946       return 0;
1947     }
1948
1949   BFD_ASSERT (to->u.s1.refcount == 0);
1950   /* All we need to merge is TYPE.  */
1951   to->key_.type = from->key_.type;
1952
1953   return 1;
1954 }
1955
1956 /* Merge data from DIFF to BIG.  INFO is context where memory should be
1957    allocated.  */
1958
1959 static bfd_boolean
1960 elf_m68k_merge_gots (struct elf_m68k_got *big,
1961                      struct elf_m68k_got *diff,
1962                      struct bfd_link_info *info)
1963 {
1964   if (diff->entries != NULL)
1965     /* DIFF is not empty.  Merge it into BIG GOT.  */
1966     {
1967       struct elf_m68k_merge_gots_arg arg_;
1968
1969       /* Merge entries.  */
1970       arg_.big = big;
1971       arg_.info = info;
1972       arg_.error_p = FALSE;
1973       htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_);
1974       if (arg_.error_p)
1975         return FALSE;
1976
1977       /* Merge counters.  */
1978       big->n_slots[R_8] += diff->n_slots[R_8];
1979       big->n_slots[R_16] += diff->n_slots[R_16];
1980       big->n_slots[R_32] += diff->n_slots[R_32];
1981       big->local_n_slots += diff->local_n_slots;
1982     }
1983   else
1984     /* DIFF is empty.  */
1985     {
1986       BFD_ASSERT (diff->n_slots[R_8] == 0);
1987       BFD_ASSERT (diff->n_slots[R_16] == 0);
1988       BFD_ASSERT (diff->n_slots[R_32] == 0);
1989       BFD_ASSERT (diff->local_n_slots == 0);
1990     }
1991
1992   BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p
1993               || ((big->n_slots[R_8]
1994                    <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1995                   && (big->n_slots[R_16]
1996                       <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))));
1997
1998   return TRUE;
1999 }
2000
2001 struct elf_m68k_finalize_got_offsets_arg
2002 {
2003   /* Ranges of the offsets for GOT entries.
2004      R_x entries receive offsets between offset1[R_x] and offset2[R_x].
2005      R_x is R_8, R_16 and R_32.  */
2006   bfd_vma *offset1;
2007   bfd_vma *offset2;
2008
2009   /* Mapping from global symndx to global symbols.
2010      This is used to build lists of got entries for global symbols.  */
2011   struct elf_m68k_link_hash_entry **symndx2h;
2012
2013   bfd_vma n_ldm_entries;
2014 };
2015
2016 /* Assign ENTRY an offset.  Build list of GOT entries for global symbols
2017    along the way.  */
2018
2019 static int
2020 elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg)
2021 {
2022   struct elf_m68k_got_entry *entry;
2023   struct elf_m68k_finalize_got_offsets_arg *arg;
2024
2025   enum elf_m68k_got_offset_size got_offset_size;
2026   bfd_vma entry_size;
2027
2028   entry = (struct elf_m68k_got_entry *) *entry_ptr;
2029   arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg;
2030
2031   /* This should be a fresh entry created in elf_m68k_can_merge_gots.  */
2032   BFD_ASSERT (entry->u.s1.refcount == 0);
2033
2034   /* Get GOT offset size for the entry .  */
2035   got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type);
2036
2037   /* Calculate entry size in bytes.  */
2038   entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type);
2039
2040   /* Check if we should switch to negative range of the offsets. */
2041   if (arg->offset1[got_offset_size] + entry_size
2042       > arg->offset2[got_offset_size])
2043     {
2044       /* Verify that this is the only switch to negative range for
2045          got_offset_size.  If this assertion fails, then we've miscalculated
2046          range for got_offset_size entries in
2047          elf_m68k_finalize_got_offsets.  */
2048       BFD_ASSERT (arg->offset2[got_offset_size]
2049                   != arg->offset2[-(int) got_offset_size - 1]);
2050
2051       /* Switch.  */
2052       arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1];
2053       arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1];
2054
2055       /* Verify that now we have enough room for the entry.  */
2056       BFD_ASSERT (arg->offset1[got_offset_size] + entry_size
2057                   <= arg->offset2[got_offset_size]);
2058     }
2059
2060   /* Assign offset to entry.  */
2061   entry->u.s2.offset = arg->offset1[got_offset_size];
2062   arg->offset1[got_offset_size] += entry_size;
2063
2064   if (entry->key_.bfd == NULL)
2065     /* Hook up this entry into the list of got_entries of H.  */
2066     {
2067       struct elf_m68k_link_hash_entry *h;
2068
2069       h = arg->symndx2h[entry->key_.symndx];
2070       if (h != NULL)
2071         {
2072           entry->u.s2.next = h->glist;
2073           h->glist = entry;
2074         }
2075       else
2076         /* This should be the entry for TLS_LDM relocation then.  */
2077         {
2078           BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type)
2079                        == R_68K_TLS_LDM32)
2080                       && entry->key_.symndx == 0);
2081
2082           ++arg->n_ldm_entries;
2083         }
2084     }
2085   else
2086     /* This entry is for local symbol.  */
2087     entry->u.s2.next = NULL;
2088
2089   return 1;
2090 }
2091
2092 /* Assign offsets within GOT.  USE_NEG_GOT_OFFSETS_P indicates if we
2093    should use negative offsets.
2094    Build list of GOT entries for global symbols along the way.
2095    SYMNDX2H is mapping from global symbol indices to actual
2096    global symbols.
2097    Return offset at which next GOT should start.  */
2098
2099 static void
2100 elf_m68k_finalize_got_offsets (struct elf_m68k_got *got,
2101                                bfd_boolean use_neg_got_offsets_p,
2102                                struct elf_m68k_link_hash_entry **symndx2h,
2103                                bfd_vma *final_offset, bfd_vma *n_ldm_entries)
2104 {
2105   struct elf_m68k_finalize_got_offsets_arg arg_;
2106   bfd_vma offset1_[2 * R_LAST];
2107   bfd_vma offset2_[2 * R_LAST];
2108   int i;
2109   bfd_vma start_offset;
2110
2111   BFD_ASSERT (got->offset != (bfd_vma) -1);
2112
2113   /* We set entry offsets relative to the .got section (and not the
2114      start of a particular GOT), so that we can use them in
2115      finish_dynamic_symbol without needing to know the GOT which they come
2116      from.  */
2117
2118   /* Put offset1 in the middle of offset1_, same for offset2.  */
2119   arg_.offset1 = offset1_ + R_LAST;
2120   arg_.offset2 = offset2_ + R_LAST;
2121
2122   start_offset = got->offset;
2123
2124   if (use_neg_got_offsets_p)
2125     /* Setup both negative and positive ranges for R_8, R_16 and R_32.  */
2126     i = -(int) R_32 - 1;
2127   else
2128     /* Setup positives ranges for R_8, R_16 and R_32.  */
2129     i = (int) R_8;
2130
2131   for (; i <= (int) R_32; ++i)
2132     {
2133       int j;
2134       size_t n;
2135
2136       /* Set beginning of the range of offsets I.  */
2137       arg_.offset1[i] = start_offset;
2138
2139       /* Calculate number of slots that require I offsets.  */
2140       j = (i >= 0) ? i : -i - 1;
2141       n = (j >= 1) ? got->n_slots[j - 1] : 0;
2142       n = got->n_slots[j] - n;
2143
2144       if (use_neg_got_offsets_p && n != 0)
2145         {
2146           if (i < 0)
2147             /* We first fill the positive side of the range, so we might
2148                end up with one empty slot at that side when we can't fit
2149                whole 2-slot entry.  Account for that at negative side of
2150                the interval with one additional entry.  */
2151             n = n / 2 + 1;
2152           else
2153             /* When the number of slots is odd, make positive side of the
2154                range one entry bigger.  */
2155             n = (n + 1) / 2;
2156         }
2157
2158       /* N is the number of slots that require I offsets.
2159          Calculate length of the range for I offsets.  */
2160       n = 4 * n;
2161
2162       /* Set end of the range.  */
2163       arg_.offset2[i] = start_offset + n;
2164
2165       start_offset = arg_.offset2[i];
2166     }
2167
2168   if (!use_neg_got_offsets_p)
2169     /* Make sure that if we try to switch to negative offsets in
2170        elf_m68k_finalize_got_offsets_1, the assert therein will catch
2171        the bug.  */
2172     for (i = R_8; i <= R_32; ++i)
2173       arg_.offset2[-i - 1] = arg_.offset2[i];
2174
2175   /* Setup got->offset.  offset1[R_8] is either in the middle or at the
2176      beginning of GOT depending on use_neg_got_offsets_p.  */
2177   got->offset = arg_.offset1[R_8];
2178
2179   arg_.symndx2h = symndx2h;
2180   arg_.n_ldm_entries = 0;
2181
2182   /* Assign offsets.  */
2183   htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_);
2184
2185   /* Check offset ranges we have actually assigned.  */
2186   for (i = (int) R_8; i <= (int) R_32; ++i)
2187     BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4);
2188
2189   *final_offset = start_offset;
2190   *n_ldm_entries = arg_.n_ldm_entries;
2191 }
2192
2193 struct elf_m68k_partition_multi_got_arg
2194 {
2195   /* The GOT we are adding entries to.  Aka big got.  */
2196   struct elf_m68k_got *current_got;
2197
2198   /* Offset to assign the next CURRENT_GOT.  */
2199   bfd_vma offset;
2200
2201   /* Context where memory should be allocated.  */
2202   struct bfd_link_info *info;
2203
2204   /* Total number of slots in the .got section.
2205      This is used to calculate size of the .got and .rela.got sections.  */
2206   bfd_vma n_slots;
2207
2208   /* Difference in numbers of allocated slots in the .got section
2209      and necessary relocations in the .rela.got section.
2210      This is used to calculate size of the .rela.got section.  */
2211   bfd_vma slots_relas_diff;
2212
2213   /* Error flag.  */
2214   bfd_boolean error_p;
2215
2216   /* Mapping from global symndx to global symbols.
2217      This is used to build lists of got entries for global symbols.  */
2218   struct elf_m68k_link_hash_entry **symndx2h;
2219 };
2220
2221 static void
2222 elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg)
2223 {
2224   bfd_vma n_ldm_entries;
2225
2226   elf_m68k_finalize_got_offsets (arg->current_got,
2227                                  (elf_m68k_hash_table (arg->info)
2228                                   ->use_neg_got_offsets_p),
2229                                  arg->symndx2h,
2230                                  &arg->offset, &n_ldm_entries);
2231
2232   arg->n_slots += arg->current_got->n_slots[R_32];
2233
2234   if (!arg->info->shared)
2235     /* If we are generating a shared object, we need to
2236        output a R_68K_RELATIVE reloc so that the dynamic
2237        linker can adjust this GOT entry.  Overwise we
2238        don't need space in .rela.got for local symbols.  */
2239     arg->slots_relas_diff += arg->current_got->local_n_slots;
2240
2241   /* @LDM relocations require a 2-slot GOT entry, but only
2242      one relocation.  Account for that.  */
2243   arg->slots_relas_diff += n_ldm_entries;
2244
2245   BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots);
2246 }
2247
2248
2249 /* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT
2250    or start a new CURRENT_GOT.  */
2251
2252 static int
2253 elf_m68k_partition_multi_got_1 (void **_entry, void *_arg)
2254 {
2255   struct elf_m68k_bfd2got_entry *entry;
2256   struct elf_m68k_partition_multi_got_arg *arg;
2257   struct elf_m68k_got *got;
2258   struct elf_m68k_got diff_;
2259   struct elf_m68k_got *diff;
2260
2261   entry = (struct elf_m68k_bfd2got_entry *) *_entry;
2262   arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2263
2264   got = entry->got;
2265   BFD_ASSERT (got != NULL);
2266   BFD_ASSERT (got->offset == (bfd_vma) -1);
2267
2268   diff = NULL;
2269
2270   if (arg->current_got != NULL)
2271     /* Construct diff.  */
2272     {
2273       diff = &diff_;
2274       elf_m68k_init_got (diff);
2275
2276       if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff))
2277         {
2278           if (diff->offset == 0)
2279             /* Offset set to 0 in the diff_ indicates an error.  */
2280             {
2281               arg->error_p = TRUE;
2282               goto final_return;
2283             }
2284
2285           if (elf_m68k_hash_table (arg->info)->allow_multigot_p)
2286             {
2287               elf_m68k_clear_got (diff);
2288               /* Schedule to finish up current_got and start new one.  */
2289               diff = NULL;
2290             }
2291           /* else
2292              Merge GOTs no matter what.  If big GOT overflows,
2293              we'll fail in relocate_section due to truncated relocations.
2294
2295              ??? May be fail earlier?  E.g., in can_merge_gots.  */
2296         }
2297     }
2298   else
2299     /* Diff of got against empty current_got is got itself.  */
2300     {
2301       /* Create empty current_got to put subsequent GOTs to.  */
2302       arg->current_got = elf_m68k_create_empty_got (arg->info);
2303       if (arg->current_got == NULL)
2304         {
2305           arg->error_p = TRUE;
2306           goto final_return;
2307         }
2308
2309       arg->current_got->offset = arg->offset;
2310
2311       diff = got;
2312     }
2313
2314   if (diff != NULL)
2315     {
2316       if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info))
2317         {
2318           arg->error_p = TRUE;
2319           goto final_return;
2320         }
2321
2322       /* Now we can free GOT.  */
2323       elf_m68k_clear_got (got);
2324
2325       entry->got = arg->current_got;
2326     }
2327   else
2328     {
2329       /* Finish up current_got.  */
2330       elf_m68k_partition_multi_got_2 (arg);
2331
2332       /* Schedule to start a new current_got.  */
2333       arg->current_got = NULL;
2334
2335       /* Retry.  */
2336       if (!elf_m68k_partition_multi_got_1 (_entry, _arg))
2337         {
2338           BFD_ASSERT (arg->error_p);
2339           goto final_return;
2340         }
2341     }
2342
2343  final_return:
2344   if (diff != NULL)
2345     elf_m68k_clear_got (diff);
2346
2347   return arg->error_p == FALSE ? 1 : 0;
2348 }
2349
2350 /* Helper function to build symndx2h mapping.  */
2351
2352 static bfd_boolean
2353 elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h,
2354                           void *_arg)
2355 {
2356   struct elf_m68k_link_hash_entry *h;
2357
2358   h = elf_m68k_hash_entry (_h);
2359
2360   if (h->got_entry_key != 0)
2361     /* H has at least one entry in the GOT.  */
2362     {
2363       struct elf_m68k_partition_multi_got_arg *arg;
2364
2365       arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2366
2367       BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL);
2368       arg->symndx2h[h->got_entry_key] = h;
2369     }
2370
2371   return TRUE;
2372 }
2373
2374 /* Merge GOTs of some BFDs, assign offsets to GOT entries and build
2375    lists of GOT entries for global symbols.
2376    Calculate sizes of .got and .rela.got sections.  */
2377
2378 static bfd_boolean
2379 elf_m68k_partition_multi_got (struct bfd_link_info *info)
2380 {
2381   struct elf_m68k_multi_got *multi_got;
2382   struct elf_m68k_partition_multi_got_arg arg_;
2383
2384   multi_got = elf_m68k_multi_got (info);
2385
2386   arg_.current_got = NULL;
2387   arg_.offset = 0;
2388   arg_.info = info;
2389   arg_.n_slots = 0;
2390   arg_.slots_relas_diff = 0;
2391   arg_.error_p = FALSE;
2392
2393   if (multi_got->bfd2got != NULL)
2394     {
2395       /* Initialize symndx2h mapping.  */
2396       {
2397         arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx
2398                                      * sizeof (*arg_.symndx2h));
2399         if (arg_.symndx2h == NULL)
2400           return FALSE;
2401
2402         elf_link_hash_traverse (elf_hash_table (info),
2403                                 elf_m68k_init_symndx2h_1, &arg_);
2404       }
2405
2406       /* Partition.  */
2407       htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1,
2408                      &arg_);
2409       if (arg_.error_p)
2410         {
2411           free (arg_.symndx2h);
2412           arg_.symndx2h = NULL;
2413
2414           return FALSE;
2415         }
2416
2417       /* Finish up last current_got.  */
2418       elf_m68k_partition_multi_got_2 (&arg_);
2419
2420       free (arg_.symndx2h);
2421     }
2422
2423   if (elf_hash_table (info)->dynobj != NULL)
2424     /* Set sizes of .got and .rela.got sections.  */
2425     {
2426       asection *s;
2427
2428       s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".got");
2429       if (s != NULL)
2430         s->size = arg_.offset;
2431       else
2432         BFD_ASSERT (arg_.offset == 0);
2433
2434       BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots);
2435       arg_.n_slots -= arg_.slots_relas_diff;
2436
2437       s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".rela.got");
2438       if (s != NULL)
2439         s->size = arg_.n_slots * sizeof (Elf32_External_Rela);
2440       else
2441         BFD_ASSERT (arg_.n_slots == 0);
2442     }
2443   else
2444     BFD_ASSERT (multi_got->bfd2got == NULL);
2445
2446   return TRUE;
2447 }
2448
2449 /* Specialized version of elf_m68k_get_got_entry that returns pointer
2450    to hashtable slot, thus allowing removal of entry via
2451    elf_m68k_remove_got_entry.  */
2452
2453 static struct elf_m68k_got_entry **
2454 elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got,
2455                              struct elf_m68k_got_entry_key *key)
2456 {
2457   void **ptr;
2458   struct elf_m68k_got_entry entry_;
2459   struct elf_m68k_got_entry **entry_ptr;
2460
2461   entry_.key_ = *key;
2462   ptr = htab_find_slot (got->entries, &entry_, NO_INSERT);
2463   BFD_ASSERT (ptr != NULL);
2464
2465   entry_ptr = (struct elf_m68k_got_entry **) ptr;
2466
2467   return entry_ptr;
2468 }
2469
2470 /* Remove entry pointed to by ENTRY_PTR from GOT.  */
2471
2472 static void
2473 elf_m68k_remove_got_entry (struct elf_m68k_got *got,
2474                            struct elf_m68k_got_entry **entry_ptr)
2475 {
2476   struct elf_m68k_got_entry *entry;
2477
2478   entry = *entry_ptr;
2479
2480   /* Check that offsets have not been finalized yet.  */
2481   BFD_ASSERT (got->offset == (bfd_vma) -1);
2482   /* Check that this entry is indeed unused.  */
2483   BFD_ASSERT (entry->u.s1.refcount == 0);
2484
2485   elf_m68k_remove_got_entry_type (got, entry->key_.type);
2486
2487   if (entry->key_.bfd != NULL)
2488     got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type);
2489
2490   BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
2491
2492   htab_clear_slot (got->entries, (void **) entry_ptr);
2493 }
2494
2495 /* Copy any information related to dynamic linking from a pre-existing
2496    symbol to a newly created symbol.  Also called to copy flags and
2497    other back-end info to a weakdef, in which case the symbol is not
2498    newly created and plt/got refcounts and dynamic indices should not
2499    be copied.  */
2500
2501 static void
2502 elf_m68k_copy_indirect_symbol (struct bfd_link_info *info,
2503                                struct elf_link_hash_entry *_dir,
2504                                struct elf_link_hash_entry *_ind)
2505 {
2506   struct elf_m68k_link_hash_entry *dir;
2507   struct elf_m68k_link_hash_entry *ind;
2508
2509   _bfd_elf_link_hash_copy_indirect (info, _dir, _ind);
2510
2511   if (_ind->root.type != bfd_link_hash_indirect)
2512     return;
2513
2514   dir = elf_m68k_hash_entry (_dir);
2515   ind = elf_m68k_hash_entry (_ind);
2516
2517   /* Any absolute non-dynamic relocations against an indirect or weak
2518      definition will be against the target symbol.  */
2519   _dir->non_got_ref |= _ind->non_got_ref;
2520
2521   /* We might have a direct symbol already having entries in the GOTs.
2522      Update its key only in case indirect symbol has GOT entries and
2523      assert that both indirect and direct symbols don't have GOT entries
2524      at the same time.  */
2525   if (ind->got_entry_key != 0)
2526     {
2527       BFD_ASSERT (dir->got_entry_key == 0);
2528       /* Assert that GOTs aren't partioned yet.  */
2529       BFD_ASSERT (ind->glist == NULL);
2530
2531       dir->got_entry_key = ind->got_entry_key;
2532       ind->got_entry_key = 0;
2533     }
2534 }
2535
2536 /* Look through the relocs for a section during the first phase, and
2537    allocate space in the global offset table or procedure linkage
2538    table.  */
2539
2540 static bfd_boolean
2541 elf_m68k_check_relocs (bfd *abfd,
2542                        struct bfd_link_info *info,
2543                        asection *sec,
2544                        const Elf_Internal_Rela *relocs)
2545 {
2546   bfd *dynobj;
2547   Elf_Internal_Shdr *symtab_hdr;
2548   struct elf_link_hash_entry **sym_hashes;
2549   const Elf_Internal_Rela *rel;
2550   const Elf_Internal_Rela *rel_end;
2551   asection *sgot;
2552   asection *srelgot;
2553   asection *sreloc;
2554   struct elf_m68k_got *got;
2555
2556   if (info->relocatable)
2557     return TRUE;
2558
2559   dynobj = elf_hash_table (info)->dynobj;
2560   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2561   sym_hashes = elf_sym_hashes (abfd);
2562
2563   sgot = NULL;
2564   srelgot = NULL;
2565   sreloc = NULL;
2566
2567   got = NULL;
2568
2569   rel_end = relocs + sec->reloc_count;
2570   for (rel = relocs; rel < rel_end; rel++)
2571     {
2572       unsigned long r_symndx;
2573       struct elf_link_hash_entry *h;
2574
2575       r_symndx = ELF32_R_SYM (rel->r_info);
2576
2577       if (r_symndx < symtab_hdr->sh_info)
2578         h = NULL;
2579       else
2580         {
2581           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2582           while (h->root.type == bfd_link_hash_indirect
2583                  || h->root.type == bfd_link_hash_warning)
2584             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2585
2586           /* PR15323, ref flags aren't set for references in the same
2587              object.  */
2588           h->root.non_ir_ref = 1;
2589         }
2590
2591       switch (ELF32_R_TYPE (rel->r_info))
2592         {
2593         case R_68K_GOT8:
2594         case R_68K_GOT16:
2595         case R_68K_GOT32:
2596           if (h != NULL
2597               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2598             break;
2599           /* Fall through.  */
2600
2601           /* Relative GOT relocations.  */
2602         case R_68K_GOT8O:
2603         case R_68K_GOT16O:
2604         case R_68K_GOT32O:
2605           /* Fall through.  */
2606
2607           /* TLS relocations.  */
2608         case R_68K_TLS_GD8:
2609         case R_68K_TLS_GD16:
2610         case R_68K_TLS_GD32:
2611         case R_68K_TLS_LDM8:
2612         case R_68K_TLS_LDM16:
2613         case R_68K_TLS_LDM32:
2614         case R_68K_TLS_IE8:
2615         case R_68K_TLS_IE16:
2616         case R_68K_TLS_IE32:
2617
2618         case R_68K_TLS_TPREL32:
2619         case R_68K_TLS_DTPREL32:
2620
2621           if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2622               && info->shared)
2623             /* Do the special chorus for libraries with static TLS.  */
2624             info->flags |= DF_STATIC_TLS;
2625
2626           /* This symbol requires a global offset table entry.  */
2627
2628           if (dynobj == NULL)
2629             {
2630               /* Create the .got section.  */
2631               elf_hash_table (info)->dynobj = dynobj = abfd;
2632               if (!_bfd_elf_create_got_section (dynobj, info))
2633                 return FALSE;
2634             }
2635
2636           if (sgot == NULL)
2637             {
2638               sgot = bfd_get_linker_section (dynobj, ".got");
2639               BFD_ASSERT (sgot != NULL);
2640             }
2641
2642           if (srelgot == NULL
2643               && (h != NULL || info->shared))
2644             {
2645               srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2646               if (srelgot == NULL)
2647                 {
2648                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2649                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
2650                                     | SEC_READONLY);
2651                   srelgot = bfd_make_section_anyway_with_flags (dynobj,
2652                                                                 ".rela.got",
2653                                                                 flags);
2654                   if (srelgot == NULL
2655                       || !bfd_set_section_alignment (dynobj, srelgot, 2))
2656                     return FALSE;
2657                 }
2658             }
2659
2660           if (got == NULL)
2661             {
2662               struct elf_m68k_bfd2got_entry *bfd2got_entry;
2663
2664               bfd2got_entry
2665                 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2666                                               abfd, FIND_OR_CREATE, info);
2667               if (bfd2got_entry == NULL)
2668                 return FALSE;
2669
2670               got = bfd2got_entry->got;
2671               BFD_ASSERT (got != NULL);
2672             }
2673
2674           {
2675             struct elf_m68k_got_entry *got_entry;
2676
2677             /* Add entry to got.  */
2678             got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2679                                                    ELF32_R_TYPE (rel->r_info),
2680                                                    r_symndx, info);
2681             if (got_entry == NULL)
2682               return FALSE;
2683
2684             if (got_entry->u.s1.refcount == 1)
2685               {
2686                 /* Make sure this symbol is output as a dynamic symbol.  */
2687                 if (h != NULL
2688                     && h->dynindx == -1
2689                     && !h->forced_local)
2690                   {
2691                     if (!bfd_elf_link_record_dynamic_symbol (info, h))
2692                       return FALSE;
2693                   }
2694               }
2695           }
2696
2697           break;
2698
2699         case R_68K_PLT8:
2700         case R_68K_PLT16:
2701         case R_68K_PLT32:
2702           /* This symbol requires a procedure linkage table entry.  We
2703              actually build the entry in adjust_dynamic_symbol,
2704              because this might be a case of linking PIC code which is
2705              never referenced by a dynamic object, in which case we
2706              don't need to generate a procedure linkage table entry
2707              after all.  */
2708
2709           /* If this is a local symbol, we resolve it directly without
2710              creating a procedure linkage table entry.  */
2711           if (h == NULL)
2712             continue;
2713
2714           h->needs_plt = 1;
2715           h->plt.refcount++;
2716           break;
2717
2718         case R_68K_PLT8O:
2719         case R_68K_PLT16O:
2720         case R_68K_PLT32O:
2721           /* This symbol requires a procedure linkage table entry.  */
2722
2723           if (h == NULL)
2724             {
2725               /* It does not make sense to have this relocation for a
2726                  local symbol.  FIXME: does it?  How to handle it if
2727                  it does make sense?  */
2728               bfd_set_error (bfd_error_bad_value);
2729               return FALSE;
2730             }
2731
2732           /* Make sure this symbol is output as a dynamic symbol.  */
2733           if (h->dynindx == -1
2734               && !h->forced_local)
2735             {
2736               if (!bfd_elf_link_record_dynamic_symbol (info, h))
2737                 return FALSE;
2738             }
2739
2740           h->needs_plt = 1;
2741           h->plt.refcount++;
2742           break;
2743
2744         case R_68K_PC8:
2745         case R_68K_PC16:
2746         case R_68K_PC32:
2747           /* If we are creating a shared library and this is not a local
2748              symbol, we need to copy the reloc into the shared library.
2749              However when linking with -Bsymbolic and this is a global
2750              symbol which is defined in an object we are including in the
2751              link (i.e., DEF_REGULAR is set), then we can resolve the
2752              reloc directly.  At this point we have not seen all the input
2753              files, so it is possible that DEF_REGULAR is not set now but
2754              will be set later (it is never cleared).  We account for that
2755              possibility below by storing information in the
2756              pcrel_relocs_copied field of the hash table entry.  */
2757           if (!(info->shared
2758                 && (sec->flags & SEC_ALLOC) != 0
2759                 && h != NULL
2760                 && (!info->symbolic
2761                     || h->root.type == bfd_link_hash_defweak
2762                     || !h->def_regular)))
2763             {
2764               if (h != NULL)
2765                 {
2766                   /* Make sure a plt entry is created for this symbol if
2767                      it turns out to be a function defined by a dynamic
2768                      object.  */
2769                   h->plt.refcount++;
2770                 }
2771               break;
2772             }
2773           /* Fall through.  */
2774         case R_68K_8:
2775         case R_68K_16:
2776         case R_68K_32:
2777           /* We don't need to handle relocs into sections not going into
2778              the "real" output.  */
2779           if ((sec->flags & SEC_ALLOC) == 0)
2780               break;
2781
2782           if (h != NULL)
2783             {
2784               /* Make sure a plt entry is created for this symbol if it
2785                  turns out to be a function defined by a dynamic object.  */
2786               h->plt.refcount++;
2787
2788               if (info->executable)
2789                 /* This symbol needs a non-GOT reference.  */
2790                 h->non_got_ref = 1;
2791             }
2792
2793           /* If we are creating a shared library, we need to copy the
2794              reloc into the shared library.  */
2795           if (info->shared)
2796             {
2797               /* When creating a shared object, we must copy these
2798                  reloc types into the output file.  We create a reloc
2799                  section in dynobj and make room for this reloc.  */
2800               if (sreloc == NULL)
2801                 {
2802                   sreloc = _bfd_elf_make_dynamic_reloc_section
2803                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2804
2805                   if (sreloc == NULL)
2806                     return FALSE;
2807                 }
2808
2809               if (sec->flags & SEC_READONLY
2810                   /* Don't set DF_TEXTREL yet for PC relative
2811                      relocations, they might be discarded later.  */
2812                   && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2813                        || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2814                        || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2815                     info->flags |= DF_TEXTREL;
2816
2817               sreloc->size += sizeof (Elf32_External_Rela);
2818
2819               /* We count the number of PC relative relocations we have
2820                  entered for this symbol, so that we can discard them
2821                  again if, in the -Bsymbolic case, the symbol is later
2822                  defined by a regular object, or, in the normal shared
2823                  case, the symbol is forced to be local.  Note that this
2824                  function is only called if we are using an m68kelf linker
2825                  hash table, which means that h is really a pointer to an
2826                  elf_m68k_link_hash_entry.  */
2827               if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2828                   || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2829                   || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2830                 {
2831                   struct elf_m68k_pcrel_relocs_copied *p;
2832                   struct elf_m68k_pcrel_relocs_copied **head;
2833
2834                   if (h != NULL)
2835                     {
2836                       struct elf_m68k_link_hash_entry *eh
2837                         = elf_m68k_hash_entry (h);
2838                       head = &eh->pcrel_relocs_copied;
2839                     }
2840                   else
2841                     {
2842                       asection *s;
2843                       void *vpp;
2844                       Elf_Internal_Sym *isym;
2845
2846                       isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2847                                                     abfd, r_symndx);
2848                       if (isym == NULL)
2849                         return FALSE;
2850
2851                       s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2852                       if (s == NULL)
2853                         s = sec;
2854
2855                       vpp = &elf_section_data (s)->local_dynrel;
2856                       head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2857                     }
2858
2859                   for (p = *head; p != NULL; p = p->next)
2860                     if (p->section == sreloc)
2861                       break;
2862
2863                   if (p == NULL)
2864                     {
2865                       p = ((struct elf_m68k_pcrel_relocs_copied *)
2866                            bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2867                       if (p == NULL)
2868                         return FALSE;
2869                       p->next = *head;
2870                       *head = p;
2871                       p->section = sreloc;
2872                       p->count = 0;
2873                     }
2874
2875                   ++p->count;
2876                 }
2877             }
2878
2879           break;
2880
2881           /* This relocation describes the C++ object vtable hierarchy.
2882              Reconstruct it for later use during GC.  */
2883         case R_68K_GNU_VTINHERIT:
2884           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2885             return FALSE;
2886           break;
2887
2888           /* This relocation describes which C++ vtable entries are actually
2889              used.  Record for later use during GC.  */
2890         case R_68K_GNU_VTENTRY:
2891           BFD_ASSERT (h != NULL);
2892           if (h != NULL
2893               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2894             return FALSE;
2895           break;
2896
2897         default:
2898           break;
2899         }
2900     }
2901
2902   return TRUE;
2903 }
2904
2905 /* Return the section that should be marked against GC for a given
2906    relocation.  */
2907
2908 static asection *
2909 elf_m68k_gc_mark_hook (asection *sec,
2910                        struct bfd_link_info *info,
2911                        Elf_Internal_Rela *rel,
2912                        struct elf_link_hash_entry *h,
2913                        Elf_Internal_Sym *sym)
2914 {
2915   if (h != NULL)
2916     switch (ELF32_R_TYPE (rel->r_info))
2917       {
2918       case R_68K_GNU_VTINHERIT:
2919       case R_68K_GNU_VTENTRY:
2920         return NULL;
2921       }
2922
2923   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2924 }
2925
2926 /* Update the got entry reference counts for the section being removed.  */
2927
2928 static bfd_boolean
2929 elf_m68k_gc_sweep_hook (bfd *abfd,
2930                         struct bfd_link_info *info,
2931                         asection *sec,
2932                         const Elf_Internal_Rela *relocs)
2933 {
2934   Elf_Internal_Shdr *symtab_hdr;
2935   struct elf_link_hash_entry **sym_hashes;
2936   const Elf_Internal_Rela *rel, *relend;
2937   bfd *dynobj;
2938   struct elf_m68k_got *got;
2939
2940   if (info->relocatable)
2941     return TRUE;
2942
2943   dynobj = elf_hash_table (info)->dynobj;
2944   if (dynobj == NULL)
2945     return TRUE;
2946
2947   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2948   sym_hashes = elf_sym_hashes (abfd);
2949   got = NULL;
2950
2951   relend = relocs + sec->reloc_count;
2952   for (rel = relocs; rel < relend; rel++)
2953     {
2954       unsigned long r_symndx;
2955       struct elf_link_hash_entry *h = NULL;
2956
2957       r_symndx = ELF32_R_SYM (rel->r_info);
2958       if (r_symndx >= symtab_hdr->sh_info)
2959         {
2960           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2961           while (h->root.type == bfd_link_hash_indirect
2962                  || h->root.type == bfd_link_hash_warning)
2963             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2964         }
2965
2966       switch (ELF32_R_TYPE (rel->r_info))
2967         {
2968         case R_68K_GOT8:
2969         case R_68K_GOT16:
2970         case R_68K_GOT32:
2971           if (h != NULL
2972               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2973             break;
2974
2975           /* FALLTHRU */
2976         case R_68K_GOT8O:
2977         case R_68K_GOT16O:
2978         case R_68K_GOT32O:
2979           /* Fall through.  */
2980
2981           /* TLS relocations.  */
2982         case R_68K_TLS_GD8:
2983         case R_68K_TLS_GD16:
2984         case R_68K_TLS_GD32:
2985         case R_68K_TLS_LDM8:
2986         case R_68K_TLS_LDM16:
2987         case R_68K_TLS_LDM32:
2988         case R_68K_TLS_IE8:
2989         case R_68K_TLS_IE16:
2990         case R_68K_TLS_IE32:
2991
2992         case R_68K_TLS_TPREL32:
2993         case R_68K_TLS_DTPREL32:
2994
2995           if (got == NULL)
2996             {
2997               got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2998                                                 abfd, MUST_FIND, NULL)->got;
2999               BFD_ASSERT (got != NULL);
3000             }
3001
3002           {
3003             struct elf_m68k_got_entry_key key_;
3004             struct elf_m68k_got_entry **got_entry_ptr;
3005             struct elf_m68k_got_entry *got_entry;
3006
3007             elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3008                                          ELF32_R_TYPE (rel->r_info));
3009             got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3010
3011             got_entry = *got_entry_ptr;
3012
3013             if (got_entry->u.s1.refcount > 0)
3014               {
3015                 --got_entry->u.s1.refcount;
3016
3017                 if (got_entry->u.s1.refcount == 0)
3018                   /* We don't need the .got entry any more.  */
3019                   elf_m68k_remove_got_entry (got, got_entry_ptr);
3020               }
3021           }
3022           break;
3023
3024         case R_68K_PLT8:
3025         case R_68K_PLT16:
3026         case R_68K_PLT32:
3027         case R_68K_PLT8O:
3028         case R_68K_PLT16O:
3029         case R_68K_PLT32O:
3030         case R_68K_PC8:
3031         case R_68K_PC16:
3032         case R_68K_PC32:
3033         case R_68K_8:
3034         case R_68K_16:
3035         case R_68K_32:
3036           if (h != NULL)
3037             {
3038               if (h->plt.refcount > 0)
3039                 --h->plt.refcount;
3040             }
3041           break;
3042
3043         default:
3044           break;
3045         }
3046     }
3047
3048   return TRUE;
3049 }
3050 \f
3051 /* Return the type of PLT associated with OUTPUT_BFD.  */
3052
3053 static const struct elf_m68k_plt_info *
3054 elf_m68k_get_plt_info (bfd *output_bfd)
3055 {
3056   unsigned int features;
3057
3058   features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3059   if (features & cpu32)
3060     return &elf_cpu32_plt_info;
3061   if (features & mcfisa_b)
3062     return &elf_isab_plt_info;
3063   if (features & mcfisa_c)
3064     return &elf_isac_plt_info;
3065   return &elf_m68k_plt_info;
3066 }
3067
3068 /* This function is called after all the input files have been read,
3069    and the input sections have been assigned to output sections.
3070    It's a convenient place to determine the PLT style.  */
3071
3072 static bfd_boolean
3073 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3074 {
3075   /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3076      sections.  */
3077   if (!elf_m68k_partition_multi_got (info))
3078     return FALSE;
3079
3080   elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3081   return TRUE;
3082 }
3083
3084 /* Adjust a symbol defined by a dynamic object and referenced by a
3085    regular object.  The current definition is in some section of the
3086    dynamic object, but we're not including those sections.  We have to
3087    change the definition to something the rest of the link can
3088    understand.  */
3089
3090 static bfd_boolean
3091 elf_m68k_adjust_dynamic_symbol (struct bfd_link_info *info,
3092                                 struct elf_link_hash_entry *h)
3093 {
3094   struct elf_m68k_link_hash_table *htab;
3095   bfd *dynobj;
3096   asection *s;
3097
3098   htab = elf_m68k_hash_table (info);
3099   dynobj = elf_hash_table (info)->dynobj;
3100
3101   /* Make sure we know what is going on here.  */
3102   BFD_ASSERT (dynobj != NULL
3103               && (h->needs_plt
3104                   || h->u.weakdef != NULL
3105                   || (h->def_dynamic
3106                       && h->ref_regular
3107                       && !h->def_regular)));
3108
3109   /* If this is a function, put it in the procedure linkage table.  We
3110      will fill in the contents of the procedure linkage table later,
3111      when we know the address of the .got section.  */
3112   if (h->type == STT_FUNC
3113       || h->needs_plt)
3114     {
3115       if ((h->plt.refcount <= 0
3116            || SYMBOL_CALLS_LOCAL (info, h)
3117            || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3118                && h->root.type == bfd_link_hash_undefweak))
3119           /* We must always create the plt entry if it was referenced
3120              by a PLTxxO relocation.  In this case we already recorded
3121              it as a dynamic symbol.  */
3122           && h->dynindx == -1)
3123         {
3124           /* This case can occur if we saw a PLTxx reloc in an input
3125              file, but the symbol was never referred to by a dynamic
3126              object, or if all references were garbage collected.  In
3127              such a case, we don't actually need to build a procedure
3128              linkage table, and we can just do a PCxx reloc instead.  */
3129           h->plt.offset = (bfd_vma) -1;
3130           h->needs_plt = 0;
3131           return TRUE;
3132         }
3133
3134       /* Make sure this symbol is output as a dynamic symbol.  */
3135       if (h->dynindx == -1
3136           && !h->forced_local)
3137         {
3138           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3139             return FALSE;
3140         }
3141
3142       s = bfd_get_linker_section (dynobj, ".plt");
3143       BFD_ASSERT (s != NULL);
3144
3145       /* If this is the first .plt entry, make room for the special
3146          first entry.  */
3147       if (s->size == 0)
3148         s->size = htab->plt_info->size;
3149
3150       /* If this symbol is not defined in a regular file, and we are
3151          not generating a shared library, then set the symbol to this
3152          location in the .plt.  This is required to make function
3153          pointers compare as equal between the normal executable and
3154          the shared library.  */
3155       if (!info->shared
3156           && !h->def_regular)
3157         {
3158           h->root.u.def.section = s;
3159           h->root.u.def.value = s->size;
3160         }
3161
3162       h->plt.offset = s->size;
3163
3164       /* Make room for this entry.  */
3165       s->size += htab->plt_info->size;
3166
3167       /* We also need to make an entry in the .got.plt section, which
3168          will be placed in the .got section by the linker script.  */
3169       s = bfd_get_linker_section (dynobj, ".got.plt");
3170       BFD_ASSERT (s != NULL);
3171       s->size += 4;
3172
3173       /* We also need to make an entry in the .rela.plt section.  */
3174       s = bfd_get_linker_section (dynobj, ".rela.plt");
3175       BFD_ASSERT (s != NULL);
3176       s->size += sizeof (Elf32_External_Rela);
3177
3178       return TRUE;
3179     }
3180
3181   /* Reinitialize the plt offset now that it is not used as a reference
3182      count any more.  */
3183   h->plt.offset = (bfd_vma) -1;
3184
3185   /* If this is a weak symbol, and there is a real definition, the
3186      processor independent code will have arranged for us to see the
3187      real definition first, and we can just use the same value.  */
3188   if (h->u.weakdef != NULL)
3189     {
3190       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3191                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3192       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3193       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3194       return TRUE;
3195     }
3196
3197   /* This is a reference to a symbol defined by a dynamic object which
3198      is not a function.  */
3199
3200   /* If we are creating a shared library, we must presume that the
3201      only references to the symbol are via the global offset table.
3202      For such cases we need not do anything here; the relocations will
3203      be handled correctly by relocate_section.  */
3204   if (info->shared)
3205     return TRUE;
3206
3207   /* If there are no references to this symbol that do not use the
3208      GOT, we don't need to generate a copy reloc.  */
3209   if (!h->non_got_ref)
3210     return TRUE;
3211
3212   /* We must allocate the symbol in our .dynbss section, which will
3213      become part of the .bss section of the executable.  There will be
3214      an entry for this symbol in the .dynsym section.  The dynamic
3215      object will contain position independent code, so all references
3216      from the dynamic object to this symbol will go through the global
3217      offset table.  The dynamic linker will use the .dynsym entry to
3218      determine the address it must put in the global offset table, so
3219      both the dynamic object and the regular object will refer to the
3220      same memory location for the variable.  */
3221
3222   s = bfd_get_linker_section (dynobj, ".dynbss");
3223   BFD_ASSERT (s != NULL);
3224
3225   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3226      copy the initial value out of the dynamic object and into the
3227      runtime process image.  We need to remember the offset into the
3228      .rela.bss section we are going to use.  */
3229   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3230     {
3231       asection *srel;
3232
3233       srel = bfd_get_linker_section (dynobj, ".rela.bss");
3234       BFD_ASSERT (srel != NULL);
3235       srel->size += sizeof (Elf32_External_Rela);
3236       h->needs_copy = 1;
3237     }
3238
3239   return _bfd_elf_adjust_dynamic_copy (h, s);
3240 }
3241
3242 /* Set the sizes of the dynamic sections.  */
3243
3244 static bfd_boolean
3245 elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3246                                 struct bfd_link_info *info)
3247 {
3248   bfd *dynobj;
3249   asection *s;
3250   bfd_boolean plt;
3251   bfd_boolean relocs;
3252
3253   dynobj = elf_hash_table (info)->dynobj;
3254   BFD_ASSERT (dynobj != NULL);
3255
3256   if (elf_hash_table (info)->dynamic_sections_created)
3257     {
3258       /* Set the contents of the .interp section to the interpreter.  */
3259       if (info->executable)
3260         {
3261           s = bfd_get_linker_section (dynobj, ".interp");
3262           BFD_ASSERT (s != NULL);
3263           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3264           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3265         }
3266     }
3267   else
3268     {
3269       /* We may have created entries in the .rela.got section.
3270          However, if we are not creating the dynamic sections, we will
3271          not actually use these entries.  Reset the size of .rela.got,
3272          which will cause it to get stripped from the output file
3273          below.  */
3274       s = bfd_get_linker_section (dynobj, ".rela.got");
3275       if (s != NULL)
3276         s->size = 0;
3277     }
3278
3279   /* If this is a -Bsymbolic shared link, then we need to discard all
3280      PC relative relocs against symbols defined in a regular object.
3281      For the normal shared case we discard the PC relative relocs
3282      against symbols that have become local due to visibility changes.
3283      We allocated space for them in the check_relocs routine, but we
3284      will not fill them in in the relocate_section routine.  */
3285   if (info->shared)
3286     elf_link_hash_traverse (elf_hash_table (info),
3287                             elf_m68k_discard_copies,
3288                             info);
3289
3290   /* The check_relocs and adjust_dynamic_symbol entry points have
3291      determined the sizes of the various dynamic sections.  Allocate
3292      memory for them.  */
3293   plt = FALSE;
3294   relocs = FALSE;
3295   for (s = dynobj->sections; s != NULL; s = s->next)
3296     {
3297       const char *name;
3298
3299       if ((s->flags & SEC_LINKER_CREATED) == 0)
3300         continue;
3301
3302       /* It's OK to base decisions on the section name, because none
3303          of the dynobj section names depend upon the input files.  */
3304       name = bfd_get_section_name (dynobj, s);
3305
3306       if (strcmp (name, ".plt") == 0)
3307         {
3308           /* Remember whether there is a PLT.  */
3309           plt = s->size != 0;
3310         }
3311       else if (CONST_STRNEQ (name, ".rela"))
3312         {
3313           if (s->size != 0)
3314             {
3315               relocs = TRUE;
3316
3317               /* We use the reloc_count field as a counter if we need
3318                  to copy relocs into the output file.  */
3319               s->reloc_count = 0;
3320             }
3321         }
3322       else if (! CONST_STRNEQ (name, ".got")
3323                && strcmp (name, ".dynbss") != 0)
3324         {
3325           /* It's not one of our sections, so don't allocate space.  */
3326           continue;
3327         }
3328
3329       if (s->size == 0)
3330         {
3331           /* If we don't need this section, strip it from the
3332              output file.  This is mostly to handle .rela.bss and
3333              .rela.plt.  We must create both sections in
3334              create_dynamic_sections, because they must be created
3335              before the linker maps input sections to output
3336              sections.  The linker does that before
3337              adjust_dynamic_symbol is called, and it is that
3338              function which decides whether anything needs to go
3339              into these sections.  */
3340           s->flags |= SEC_EXCLUDE;
3341           continue;
3342         }
3343
3344       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3345         continue;
3346
3347       /* Allocate memory for the section contents.  */
3348       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3349          Unused entries should be reclaimed before the section's contents
3350          are written out, but at the moment this does not happen.  Thus in
3351          order to prevent writing out garbage, we initialise the section's
3352          contents to zero.  */
3353       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3354       if (s->contents == NULL)
3355         return FALSE;
3356     }
3357
3358   if (elf_hash_table (info)->dynamic_sections_created)
3359     {
3360       /* Add some entries to the .dynamic section.  We fill in the
3361          values later, in elf_m68k_finish_dynamic_sections, but we
3362          must add the entries now so that we get the correct size for
3363          the .dynamic section.  The DT_DEBUG entry is filled in by the
3364          dynamic linker and used by the debugger.  */
3365 #define add_dynamic_entry(TAG, VAL) \
3366   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3367
3368       if (info->executable)
3369         {
3370           if (!add_dynamic_entry (DT_DEBUG, 0))
3371             return FALSE;
3372         }
3373
3374       if (plt)
3375         {
3376           if (!add_dynamic_entry (DT_PLTGOT, 0)
3377               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3378               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3379               || !add_dynamic_entry (DT_JMPREL, 0))
3380             return FALSE;
3381         }
3382
3383       if (relocs)
3384         {
3385           if (!add_dynamic_entry (DT_RELA, 0)
3386               || !add_dynamic_entry (DT_RELASZ, 0)
3387               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3388             return FALSE;
3389         }
3390
3391       if ((info->flags & DF_TEXTREL) != 0)
3392         {
3393           if (!add_dynamic_entry (DT_TEXTREL, 0))
3394             return FALSE;
3395         }
3396     }
3397 #undef add_dynamic_entry
3398
3399   return TRUE;
3400 }
3401
3402 /* This function is called via elf_link_hash_traverse if we are
3403    creating a shared object.  In the -Bsymbolic case it discards the
3404    space allocated to copy PC relative relocs against symbols which
3405    are defined in regular objects.  For the normal shared case, it
3406    discards space for pc-relative relocs that have become local due to
3407    symbol visibility changes.  We allocated space for them in the
3408    check_relocs routine, but we won't fill them in in the
3409    relocate_section routine.
3410
3411    We also check whether any of the remaining relocations apply
3412    against a readonly section, and set the DF_TEXTREL flag in this
3413    case.  */
3414
3415 static bfd_boolean
3416 elf_m68k_discard_copies (struct elf_link_hash_entry *h,
3417                          void * inf)
3418 {
3419   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3420   struct elf_m68k_pcrel_relocs_copied *s;
3421
3422   if (!SYMBOL_CALLS_LOCAL (info, h))
3423     {
3424       if ((info->flags & DF_TEXTREL) == 0)
3425         {
3426           /* Look for relocations against read-only sections.  */
3427           for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3428                s != NULL;
3429                s = s->next)
3430             if ((s->section->flags & SEC_READONLY) != 0)
3431               {
3432                 info->flags |= DF_TEXTREL;
3433                 break;
3434               }
3435         }
3436
3437       /* Make sure undefined weak symbols are output as a dynamic symbol
3438          in PIEs.  */
3439       if (h->non_got_ref
3440           && h->root.type == bfd_link_hash_undefweak
3441           && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3442           && h->dynindx == -1
3443           && !h->forced_local)
3444         {
3445           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3446             return FALSE;
3447         }
3448
3449       return TRUE;
3450     }
3451
3452   for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3453        s != NULL;
3454        s = s->next)
3455     s->section->size -= s->count * sizeof (Elf32_External_Rela);
3456
3457   return TRUE;
3458 }
3459
3460
3461 /* Install relocation RELA.  */
3462
3463 static void
3464 elf_m68k_install_rela (bfd *output_bfd,
3465                        asection *srela,
3466                        Elf_Internal_Rela *rela)
3467 {
3468   bfd_byte *loc;
3469
3470   loc = srela->contents;
3471   loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3472   bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3473 }
3474
3475 /* Find the base offsets for thread-local storage in this object,
3476    for GD/LD and IE/LE respectively.  */
3477
3478 #define DTP_OFFSET 0x8000
3479 #define TP_OFFSET  0x7000
3480
3481 static bfd_vma
3482 dtpoff_base (struct bfd_link_info *info)
3483 {
3484   /* If tls_sec is NULL, we should have signalled an error already.  */
3485   if (elf_hash_table (info)->tls_sec == NULL)
3486     return 0;
3487   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3488 }
3489
3490 static bfd_vma
3491 tpoff_base (struct bfd_link_info *info)
3492 {
3493   /* If tls_sec is NULL, we should have signalled an error already.  */
3494   if (elf_hash_table (info)->tls_sec == NULL)
3495     return 0;
3496   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3497 }
3498
3499 /* Output necessary relocation to handle a symbol during static link.
3500    This function is called from elf_m68k_relocate_section.  */
3501
3502 static void
3503 elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3504                                 bfd *output_bfd,
3505                                 enum elf_m68k_reloc_type r_type,
3506                                 asection *sgot,
3507                                 bfd_vma got_entry_offset,
3508                                 bfd_vma relocation)
3509 {
3510   switch (elf_m68k_reloc_got_type (r_type))
3511     {
3512     case R_68K_GOT32O:
3513       bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3514       break;
3515
3516     case R_68K_TLS_GD32:
3517       /* We know the offset within the module,
3518          put it into the second GOT slot.  */
3519       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3520                   sgot->contents + got_entry_offset + 4);
3521       /* FALLTHRU */
3522
3523     case R_68K_TLS_LDM32:
3524       /* Mark it as belonging to module 1, the executable.  */
3525       bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3526       break;
3527
3528     case R_68K_TLS_IE32:
3529       bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3530                   sgot->contents + got_entry_offset);
3531       break;
3532
3533     default:
3534       BFD_ASSERT (FALSE);
3535     }
3536 }
3537
3538 /* Output necessary relocation to handle a local symbol
3539    during dynamic link.
3540    This function is called either from elf_m68k_relocate_section
3541    or from elf_m68k_finish_dynamic_symbol.  */
3542
3543 static void
3544 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3545                                       bfd *output_bfd,
3546                                       enum elf_m68k_reloc_type r_type,
3547                                       asection *sgot,
3548                                       bfd_vma got_entry_offset,
3549                                       bfd_vma relocation,
3550                                       asection *srela)
3551 {
3552   Elf_Internal_Rela outrel;
3553
3554   switch (elf_m68k_reloc_got_type (r_type))
3555     {
3556     case R_68K_GOT32O:
3557       /* Emit RELATIVE relocation to initialize GOT slot
3558          at run-time.  */
3559       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3560       outrel.r_addend = relocation;
3561       break;
3562
3563     case R_68K_TLS_GD32:
3564       /* We know the offset within the module,
3565          put it into the second GOT slot.  */
3566       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3567                   sgot->contents + got_entry_offset + 4);
3568       /* FALLTHRU */
3569
3570     case R_68K_TLS_LDM32:
3571       /* We don't know the module number,
3572          create a relocation for it.  */
3573       outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3574       outrel.r_addend = 0;
3575       break;
3576
3577     case R_68K_TLS_IE32:
3578       /* Emit TPREL relocation to initialize GOT slot
3579          at run-time.  */
3580       outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3581       outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3582       break;
3583
3584     default:
3585       BFD_ASSERT (FALSE);
3586     }
3587
3588   /* Offset of the GOT entry.  */
3589   outrel.r_offset = (sgot->output_section->vma
3590                      + sgot->output_offset
3591                      + got_entry_offset);
3592
3593   /* Install one of the above relocations.  */
3594   elf_m68k_install_rela (output_bfd, srela, &outrel);
3595
3596   bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3597 }
3598
3599 /* Relocate an M68K ELF section.  */
3600
3601 static bfd_boolean
3602 elf_m68k_relocate_section (bfd *output_bfd,
3603                            struct bfd_link_info *info,
3604                            bfd *input_bfd,
3605                            asection *input_section,
3606                            bfd_byte *contents,
3607                            Elf_Internal_Rela *relocs,
3608                            Elf_Internal_Sym *local_syms,
3609                            asection **local_sections)
3610 {
3611   bfd *dynobj;
3612   Elf_Internal_Shdr *symtab_hdr;
3613   struct elf_link_hash_entry **sym_hashes;
3614   asection *sgot;
3615   asection *splt;
3616   asection *sreloc;
3617   asection *srela;
3618   struct elf_m68k_got *got;
3619   Elf_Internal_Rela *rel;
3620   Elf_Internal_Rela *relend;
3621
3622   dynobj = elf_hash_table (info)->dynobj;
3623   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3624   sym_hashes = elf_sym_hashes (input_bfd);
3625
3626   sgot = NULL;
3627   splt = NULL;
3628   sreloc = NULL;
3629   srela = NULL;
3630
3631   got = NULL;
3632
3633   rel = relocs;
3634   relend = relocs + input_section->reloc_count;
3635   for (; rel < relend; rel++)
3636     {
3637       int r_type;
3638       reloc_howto_type *howto;
3639       unsigned long r_symndx;
3640       struct elf_link_hash_entry *h;
3641       Elf_Internal_Sym *sym;
3642       asection *sec;
3643       bfd_vma relocation;
3644       bfd_boolean unresolved_reloc;
3645       bfd_reloc_status_type r;
3646
3647       r_type = ELF32_R_TYPE (rel->r_info);
3648       if (r_type < 0 || r_type >= (int) R_68K_max)
3649         {
3650           bfd_set_error (bfd_error_bad_value);
3651           return FALSE;
3652         }
3653       howto = howto_table + r_type;
3654
3655       r_symndx = ELF32_R_SYM (rel->r_info);
3656
3657       h = NULL;
3658       sym = NULL;
3659       sec = NULL;
3660       unresolved_reloc = FALSE;
3661
3662       if (r_symndx < symtab_hdr->sh_info)
3663         {
3664           sym = local_syms + r_symndx;
3665           sec = local_sections[r_symndx];
3666           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3667         }
3668       else
3669         {
3670           bfd_boolean warned, ignored;
3671
3672           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3673                                    r_symndx, symtab_hdr, sym_hashes,
3674                                    h, sec, relocation,
3675                                    unresolved_reloc, warned, ignored);
3676         }
3677
3678       if (sec != NULL && discarded_section (sec))
3679         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3680                                          rel, 1, relend, howto, 0, contents);
3681
3682       if (info->relocatable)
3683         continue;
3684
3685       switch (r_type)
3686         {
3687         case R_68K_GOT8:
3688         case R_68K_GOT16:
3689         case R_68K_GOT32:
3690           /* Relocation is to the address of the entry for this symbol
3691              in the global offset table.  */
3692           if (h != NULL
3693               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3694             {
3695               if (elf_m68k_hash_table (info)->local_gp_p)
3696                 {
3697                   bfd_vma sgot_output_offset;
3698                   bfd_vma got_offset;
3699
3700                   if (sgot == NULL)
3701                     {
3702                       sgot = bfd_get_linker_section (dynobj, ".got");
3703
3704                       if (sgot != NULL)
3705                         sgot_output_offset = sgot->output_offset;
3706                       else
3707                         /* In this case we have a reference to
3708                            _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3709                            empty.
3710                            ??? Issue a warning?  */
3711                         sgot_output_offset = 0;
3712                     }
3713                   else
3714                     sgot_output_offset = sgot->output_offset;
3715
3716                   if (got == NULL)
3717                     {
3718                       struct elf_m68k_bfd2got_entry *bfd2got_entry;
3719
3720                       bfd2got_entry
3721                         = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3722                                                       input_bfd, SEARCH, NULL);
3723
3724                       if (bfd2got_entry != NULL)
3725                         {
3726                           got = bfd2got_entry->got;
3727                           BFD_ASSERT (got != NULL);
3728
3729                           got_offset = got->offset;
3730                         }
3731                       else
3732                         /* In this case we have a reference to
3733                            _GLOBAL_OFFSET_TABLE_, but no other references
3734                            accessing any GOT entries.
3735                            ??? Issue a warning?  */
3736                         got_offset = 0;
3737                     }
3738                   else
3739                     got_offset = got->offset;
3740
3741                   /* Adjust GOT pointer to point to the GOT
3742                      assigned to input_bfd.  */
3743                   rel->r_addend += sgot_output_offset + got_offset;
3744                 }
3745               else
3746                 BFD_ASSERT (got == NULL || got->offset == 0);
3747
3748               break;
3749             }
3750           /* Fall through.  */
3751         case R_68K_GOT8O:
3752         case R_68K_GOT16O:
3753         case R_68K_GOT32O:
3754
3755         case R_68K_TLS_LDM32:
3756         case R_68K_TLS_LDM16:
3757         case R_68K_TLS_LDM8:
3758
3759         case R_68K_TLS_GD8:
3760         case R_68K_TLS_GD16:
3761         case R_68K_TLS_GD32:
3762
3763         case R_68K_TLS_IE8:
3764         case R_68K_TLS_IE16:
3765         case R_68K_TLS_IE32:
3766
3767           /* Relocation is the offset of the entry for this symbol in
3768              the global offset table.  */
3769
3770           {
3771             struct elf_m68k_got_entry_key key_;
3772             bfd_vma *off_ptr;
3773             bfd_vma off;
3774
3775             if (sgot == NULL)
3776               {
3777                 sgot = bfd_get_linker_section (dynobj, ".got");
3778                 BFD_ASSERT (sgot != NULL);
3779               }
3780
3781             if (got == NULL)
3782               {
3783                 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3784                                                   input_bfd, MUST_FIND,
3785                                                   NULL)->got;
3786                 BFD_ASSERT (got != NULL);
3787               }
3788
3789             /* Get GOT offset for this symbol.  */
3790             elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3791                                          r_type);
3792             off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3793                                                NULL)->u.s2.offset;
3794             off = *off_ptr;
3795
3796             /* The offset must always be a multiple of 4.  We use
3797                the least significant bit to record whether we have
3798                already generated the necessary reloc.  */
3799             if ((off & 1) != 0)
3800               off &= ~1;
3801             else
3802               {
3803                 if (h != NULL
3804                     /* @TLSLDM relocations are bounded to the module, in
3805                        which the symbol is defined -- not to the symbol
3806                        itself.  */
3807                     && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3808                   {
3809                     bfd_boolean dyn;
3810
3811                     dyn = elf_hash_table (info)->dynamic_sections_created;
3812                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3813                         || (info->shared
3814                             && SYMBOL_REFERENCES_LOCAL (info, h))
3815                         || (ELF_ST_VISIBILITY (h->other)
3816                             && h->root.type == bfd_link_hash_undefweak))
3817                       {
3818                         /* This is actually a static link, or it is a
3819                            -Bsymbolic link and the symbol is defined
3820                            locally, or the symbol was forced to be local
3821                            because of a version file.  We must initialize
3822                            this entry in the global offset table.  Since
3823                            the offset must always be a multiple of 4, we
3824                            use the least significant bit to record whether
3825                            we have initialized it already.
3826
3827                            When doing a dynamic link, we create a .rela.got
3828                            relocation entry to initialize the value.  This
3829                            is done in the finish_dynamic_symbol routine.  */
3830
3831                         elf_m68k_init_got_entry_static (info,
3832                                                         output_bfd,
3833                                                         r_type,
3834                                                         sgot,
3835                                                         off,
3836                                                         relocation);
3837
3838                         *off_ptr |= 1;
3839                       }
3840                     else
3841                       unresolved_reloc = FALSE;
3842                   }
3843                 else if (info->shared) /* && h == NULL */
3844                   /* Process local symbol during dynamic link.  */
3845                   {
3846                     if (srela == NULL)
3847                       {
3848                         srela = bfd_get_linker_section (dynobj, ".rela.got");
3849                         BFD_ASSERT (srela != NULL);
3850                       }
3851
3852                     elf_m68k_init_got_entry_local_shared (info,
3853                                                           output_bfd,
3854                                                           r_type,
3855                                                           sgot,
3856                                                           off,
3857                                                           relocation,
3858                                                           srela);
3859
3860                     *off_ptr |= 1;
3861                   }
3862                 else /* h == NULL && !info->shared */
3863                   {
3864                     elf_m68k_init_got_entry_static (info,
3865                                                     output_bfd,
3866                                                     r_type,
3867                                                     sgot,
3868                                                     off,
3869                                                     relocation);
3870
3871                     *off_ptr |= 1;
3872                   }
3873               }
3874
3875             /* We don't use elf_m68k_reloc_got_type in the condition below
3876                because this is the only place where difference between
3877                R_68K_GOTx and R_68K_GOTxO relocations matters.  */
3878             if (r_type == R_68K_GOT32O
3879                 || r_type == R_68K_GOT16O
3880                 || r_type == R_68K_GOT8O
3881                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3882                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3883                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3884               {
3885                 /* GOT pointer is adjusted to point to the start/middle
3886                    of local GOT.  Adjust the offset accordingly.  */
3887                 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3888                             || off >= got->offset);
3889
3890                 if (elf_m68k_hash_table (info)->local_gp_p)
3891                   relocation = off - got->offset;
3892                 else
3893                   {
3894                     BFD_ASSERT (got->offset == 0);
3895                     relocation = sgot->output_offset + off;
3896                   }
3897
3898                 /* This relocation does not use the addend.  */
3899                 rel->r_addend = 0;
3900               }
3901             else
3902               relocation = (sgot->output_section->vma + sgot->output_offset
3903                             + off);
3904           }
3905           break;
3906
3907         case R_68K_TLS_LDO32:
3908         case R_68K_TLS_LDO16:
3909         case R_68K_TLS_LDO8:
3910           relocation -= dtpoff_base (info);
3911           break;
3912
3913         case R_68K_TLS_LE32:
3914         case R_68K_TLS_LE16:
3915         case R_68K_TLS_LE8:
3916           if (info->shared && !info->pie)
3917             {
3918               (*_bfd_error_handler)
3919                 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3920                    "in shared object"),
3921                  input_bfd, input_section, (long) rel->r_offset, howto->name);
3922
3923               return FALSE;
3924             }
3925           else
3926             relocation -= tpoff_base (info);
3927
3928           break;
3929
3930         case R_68K_PLT8:
3931         case R_68K_PLT16:
3932         case R_68K_PLT32:
3933           /* Relocation is to the entry for this symbol in the
3934              procedure linkage table.  */
3935
3936           /* Resolve a PLTxx reloc against a local symbol directly,
3937              without using the procedure linkage table.  */
3938           if (h == NULL)
3939             break;
3940
3941           if (h->plt.offset == (bfd_vma) -1
3942               || !elf_hash_table (info)->dynamic_sections_created)
3943             {
3944               /* We didn't make a PLT entry for this symbol.  This
3945                  happens when statically linking PIC code, or when
3946                  using -Bsymbolic.  */
3947               break;
3948             }
3949
3950           if (splt == NULL)
3951             {
3952               splt = bfd_get_linker_section (dynobj, ".plt");
3953               BFD_ASSERT (splt != NULL);
3954             }
3955
3956           relocation = (splt->output_section->vma
3957                         + splt->output_offset
3958                         + h->plt.offset);
3959           unresolved_reloc = FALSE;
3960           break;
3961
3962         case R_68K_PLT8O:
3963         case R_68K_PLT16O:
3964         case R_68K_PLT32O:
3965           /* Relocation is the offset of the entry for this symbol in
3966              the procedure linkage table.  */
3967           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
3968
3969           if (splt == NULL)
3970             {
3971               splt = bfd_get_linker_section (dynobj, ".plt");
3972               BFD_ASSERT (splt != NULL);
3973             }
3974
3975           relocation = h->plt.offset;
3976           unresolved_reloc = FALSE;
3977
3978           /* This relocation does not use the addend.  */
3979           rel->r_addend = 0;
3980
3981           break;
3982
3983         case R_68K_8:
3984         case R_68K_16:
3985         case R_68K_32:
3986         case R_68K_PC8:
3987         case R_68K_PC16:
3988         case R_68K_PC32:
3989           if (info->shared
3990               && r_symndx != STN_UNDEF
3991               && (input_section->flags & SEC_ALLOC) != 0
3992               && (h == NULL
3993                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3994                   || h->root.type != bfd_link_hash_undefweak)
3995               && ((r_type != R_68K_PC8
3996                    && r_type != R_68K_PC16
3997                    && r_type != R_68K_PC32)
3998                   || !SYMBOL_CALLS_LOCAL (info, h)))
3999             {
4000               Elf_Internal_Rela outrel;
4001               bfd_byte *loc;
4002               bfd_boolean skip, relocate;
4003
4004               /* When generating a shared object, these relocations
4005                  are copied into the output file to be resolved at run
4006                  time.  */
4007
4008               skip = FALSE;
4009               relocate = FALSE;
4010
4011               outrel.r_offset =
4012                 _bfd_elf_section_offset (output_bfd, info, input_section,
4013                                          rel->r_offset);
4014               if (outrel.r_offset == (bfd_vma) -1)
4015                 skip = TRUE;
4016               else if (outrel.r_offset == (bfd_vma) -2)
4017                 skip = TRUE, relocate = TRUE;
4018               outrel.r_offset += (input_section->output_section->vma
4019                                   + input_section->output_offset);
4020
4021               if (skip)
4022                 memset (&outrel, 0, sizeof outrel);
4023               else if (h != NULL
4024                        && h->dynindx != -1
4025                        && (r_type == R_68K_PC8
4026                            || r_type == R_68K_PC16
4027                            || r_type == R_68K_PC32
4028                            || !info->shared
4029                            || !info->symbolic
4030                            || !h->def_regular))
4031                 {
4032                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4033                   outrel.r_addend = rel->r_addend;
4034                 }
4035               else
4036                 {
4037                   /* This symbol is local, or marked to become local.  */
4038                   outrel.r_addend = relocation + rel->r_addend;
4039
4040                   if (r_type == R_68K_32)
4041                     {
4042                       relocate = TRUE;
4043                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4044                     }
4045                   else
4046                     {
4047                       long indx;
4048
4049                       if (bfd_is_abs_section (sec))
4050                         indx = 0;
4051                       else if (sec == NULL || sec->owner == NULL)
4052                         {
4053                           bfd_set_error (bfd_error_bad_value);
4054                           return FALSE;
4055                         }
4056                       else
4057                         {
4058                           asection *osec;
4059
4060                           /* We are turning this relocation into one
4061                              against a section symbol.  It would be
4062                              proper to subtract the symbol's value,
4063                              osec->vma, from the emitted reloc addend,
4064                              but ld.so expects buggy relocs.  */
4065                           osec = sec->output_section;
4066                           indx = elf_section_data (osec)->dynindx;
4067                           if (indx == 0)
4068                             {
4069                               struct elf_link_hash_table *htab;
4070                               htab = elf_hash_table (info);
4071                               osec = htab->text_index_section;
4072                               indx = elf_section_data (osec)->dynindx;
4073                             }
4074                           BFD_ASSERT (indx != 0);
4075                         }
4076
4077                       outrel.r_info = ELF32_R_INFO (indx, r_type);
4078                     }
4079                 }
4080
4081               sreloc = elf_section_data (input_section)->sreloc;
4082               if (sreloc == NULL)
4083                 abort ();
4084
4085               loc = sreloc->contents;
4086               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4087               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4088
4089               /* This reloc will be computed at runtime, so there's no
4090                  need to do anything now, except for R_68K_32
4091                  relocations that have been turned into
4092                  R_68K_RELATIVE.  */
4093               if (!relocate)
4094                 continue;
4095             }
4096
4097           break;
4098
4099         case R_68K_GNU_VTINHERIT:
4100         case R_68K_GNU_VTENTRY:
4101           /* These are no-ops in the end.  */
4102           continue;
4103
4104         default:
4105           break;
4106         }
4107
4108       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4109          because such sections are not SEC_ALLOC and thus ld.so will
4110          not process them.  */
4111       if (unresolved_reloc
4112           && !((input_section->flags & SEC_DEBUGGING) != 0
4113                && h->def_dynamic)
4114           && _bfd_elf_section_offset (output_bfd, info, input_section,
4115                                       rel->r_offset) != (bfd_vma) -1)
4116         {
4117           (*_bfd_error_handler)
4118             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4119              input_bfd,
4120              input_section,
4121              (long) rel->r_offset,
4122              howto->name,
4123              h->root.root.string);
4124           return FALSE;
4125         }
4126
4127       if (r_symndx != STN_UNDEF
4128           && r_type != R_68K_NONE
4129           && (h == NULL
4130               || h->root.type == bfd_link_hash_defined
4131               || h->root.type == bfd_link_hash_defweak))
4132         {
4133           char sym_type;
4134
4135           sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4136
4137           if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4138             {
4139               const char *name;
4140
4141               if (h != NULL)
4142                 name = h->root.root.string;
4143               else
4144                 {
4145                   name = (bfd_elf_string_from_elf_section
4146                           (input_bfd, symtab_hdr->sh_link, sym->st_name));
4147                   if (name == NULL || *name == '\0')
4148                     name = bfd_section_name (input_bfd, sec);
4149                 }
4150
4151               (*_bfd_error_handler)
4152                 ((sym_type == STT_TLS
4153                   ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4154                   : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4155                  input_bfd,
4156                  input_section,
4157                  (long) rel->r_offset,
4158                  howto->name,
4159                  name);
4160             }
4161         }
4162
4163       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4164                                     contents, rel->r_offset,
4165                                     relocation, rel->r_addend);
4166
4167       if (r != bfd_reloc_ok)
4168         {
4169           const char *name;
4170
4171           if (h != NULL)
4172             name = h->root.root.string;
4173           else
4174             {
4175               name = bfd_elf_string_from_elf_section (input_bfd,
4176                                                       symtab_hdr->sh_link,
4177                                                       sym->st_name);
4178               if (name == NULL)
4179                 return FALSE;
4180               if (*name == '\0')
4181                 name = bfd_section_name (input_bfd, sec);
4182             }
4183
4184           if (r == bfd_reloc_overflow)
4185             {
4186               if (!(info->callbacks->reloc_overflow
4187                     (info, (h ? &h->root : NULL), name, howto->name,
4188                      (bfd_vma) 0, input_bfd, input_section,
4189                      rel->r_offset)))
4190                 return FALSE;
4191             }
4192           else
4193             {
4194               (*_bfd_error_handler)
4195                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4196                  input_bfd, input_section,
4197                  (long) rel->r_offset, name, (int) r);
4198               return FALSE;
4199             }
4200         }
4201     }
4202
4203   return TRUE;
4204 }
4205
4206 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
4207    into section SEC.  */
4208
4209 static void
4210 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
4211 {
4212   /* Make VALUE PC-relative.  */
4213   value -= sec->output_section->vma + offset;
4214
4215   /* Apply any in-place addend.  */
4216   value += bfd_get_32 (sec->owner, sec->contents + offset);
4217
4218   bfd_put_32 (sec->owner, value, sec->contents + offset);
4219 }
4220
4221 /* Finish up dynamic symbol handling.  We set the contents of various
4222    dynamic sections here.  */
4223
4224 static bfd_boolean
4225 elf_m68k_finish_dynamic_symbol (bfd *output_bfd,
4226                                 struct bfd_link_info *info,
4227                                 struct elf_link_hash_entry *h,
4228                                 Elf_Internal_Sym *sym)
4229 {
4230   bfd *dynobj;
4231
4232   dynobj = elf_hash_table (info)->dynobj;
4233
4234   if (h->plt.offset != (bfd_vma) -1)
4235     {
4236       const struct elf_m68k_plt_info *plt_info;
4237       asection *splt;
4238       asection *sgot;
4239       asection *srela;
4240       bfd_vma plt_index;
4241       bfd_vma got_offset;
4242       Elf_Internal_Rela rela;
4243       bfd_byte *loc;
4244
4245       /* This symbol has an entry in the procedure linkage table.  Set
4246          it up.  */
4247
4248       BFD_ASSERT (h->dynindx != -1);
4249
4250       plt_info = elf_m68k_hash_table (info)->plt_info;
4251       splt = bfd_get_linker_section (dynobj, ".plt");
4252       sgot = bfd_get_linker_section (dynobj, ".got.plt");
4253       srela = bfd_get_linker_section (dynobj, ".rela.plt");
4254       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
4255
4256       /* Get the index in the procedure linkage table which
4257          corresponds to this symbol.  This is the index of this symbol
4258          in all the symbols for which we are making plt entries.  The
4259          first entry in the procedure linkage table is reserved.  */
4260       plt_index = (h->plt.offset / plt_info->size) - 1;
4261
4262       /* Get the offset into the .got table of the entry that
4263          corresponds to this function.  Each .got entry is 4 bytes.
4264          The first three are reserved.  */
4265       got_offset = (plt_index + 3) * 4;
4266
4267       memcpy (splt->contents + h->plt.offset,
4268               plt_info->symbol_entry,
4269               plt_info->size);
4270
4271       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
4272                              (sgot->output_section->vma
4273                               + sgot->output_offset
4274                               + got_offset));
4275
4276       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4277                   splt->contents
4278                   + h->plt.offset
4279                   + plt_info->symbol_resolve_entry + 2);
4280
4281       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
4282                              splt->output_section->vma);
4283
4284       /* Fill in the entry in the global offset table.  */
4285       bfd_put_32 (output_bfd,
4286                   (splt->output_section->vma
4287                    + splt->output_offset
4288                    + h->plt.offset
4289                    + plt_info->symbol_resolve_entry),
4290                   sgot->contents + got_offset);
4291
4292       /* Fill in the entry in the .rela.plt section.  */
4293       rela.r_offset = (sgot->output_section->vma
4294                        + sgot->output_offset
4295                        + got_offset);
4296       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
4297       rela.r_addend = 0;
4298       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
4299       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4300
4301       if (!h->def_regular)
4302         {
4303           /* Mark the symbol as undefined, rather than as defined in
4304              the .plt section.  Leave the value alone.  */
4305           sym->st_shndx = SHN_UNDEF;
4306         }
4307     }
4308
4309   if (elf_m68k_hash_entry (h)->glist != NULL)
4310     {
4311       asection *sgot;
4312       asection *srela;
4313       struct elf_m68k_got_entry *got_entry;
4314
4315       /* This symbol has an entry in the global offset table.  Set it
4316          up.  */
4317
4318       sgot = bfd_get_linker_section (dynobj, ".got");
4319       srela = bfd_get_linker_section (dynobj, ".rela.got");
4320       BFD_ASSERT (sgot != NULL && srela != NULL);
4321
4322       got_entry = elf_m68k_hash_entry (h)->glist;
4323
4324       while (got_entry != NULL)
4325         {
4326           enum elf_m68k_reloc_type r_type;
4327           bfd_vma got_entry_offset;
4328
4329           r_type = got_entry->key_.type;
4330           got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1;
4331
4332           /* If this is a -Bsymbolic link, and the symbol is defined
4333              locally, we just want to emit a RELATIVE reloc.  Likewise if
4334              the symbol was forced to be local because of a version file.
4335              The entry in the global offset table already have been
4336              initialized in the relocate_section function.  */
4337           if (info->shared
4338               && SYMBOL_REFERENCES_LOCAL (info, h))
4339             {
4340               bfd_vma relocation;
4341
4342               relocation = bfd_get_signed_32 (output_bfd,
4343                                               (sgot->contents
4344                                                + got_entry_offset));
4345
4346               /* Undo TP bias.  */
4347               switch (elf_m68k_reloc_got_type (r_type))
4348                 {
4349                 case R_68K_GOT32O:
4350                 case R_68K_TLS_LDM32:
4351                   break;
4352
4353                 case R_68K_TLS_GD32:
4354                   /* The value for this relocation is actually put in
4355                      the second GOT slot.  */
4356                   relocation = bfd_get_signed_32 (output_bfd,
4357                                                   (sgot->contents
4358                                                    + got_entry_offset + 4));
4359                   relocation += dtpoff_base (info);
4360                   break;
4361
4362                 case R_68K_TLS_IE32:
4363                   relocation += tpoff_base (info);
4364                   break;
4365
4366                 default:
4367                   BFD_ASSERT (FALSE);
4368                 }
4369
4370               elf_m68k_init_got_entry_local_shared (info,
4371                                                     output_bfd,
4372                                                     r_type,
4373                                                     sgot,
4374                                                     got_entry_offset,
4375                                                     relocation,
4376                                                     srela);
4377             }
4378           else
4379             {
4380               Elf_Internal_Rela rela;
4381
4382               /* Put zeros to GOT slots that will be initialized
4383                  at run-time.  */
4384               {
4385                 bfd_vma n_slots;
4386
4387                 n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type);
4388                 while (n_slots--)
4389                   bfd_put_32 (output_bfd, (bfd_vma) 0,
4390                               (sgot->contents + got_entry_offset
4391                                + 4 * n_slots));
4392               }
4393
4394               rela.r_addend = 0;
4395               rela.r_offset = (sgot->output_section->vma
4396                                + sgot->output_offset
4397                                + got_entry_offset);
4398
4399               switch (elf_m68k_reloc_got_type (r_type))
4400                 {
4401                 case R_68K_GOT32O:
4402                   rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
4403                   elf_m68k_install_rela (output_bfd, srela, &rela);
4404                   break;
4405
4406                 case R_68K_TLS_GD32:
4407                   rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32);
4408                   elf_m68k_install_rela (output_bfd, srela, &rela);
4409
4410                   rela.r_offset += 4;
4411                   rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32);
4412                   elf_m68k_install_rela (output_bfd, srela, &rela);
4413                   break;
4414
4415                 case R_68K_TLS_IE32:
4416                   rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32);
4417                   elf_m68k_install_rela (output_bfd, srela, &rela);
4418                   break;
4419
4420                 default:
4421                   BFD_ASSERT (FALSE);
4422                   break;
4423                 }
4424             }
4425
4426           got_entry = got_entry->u.s2.next;
4427         }
4428     }
4429
4430   if (h->needs_copy)
4431     {
4432       asection *s;
4433       Elf_Internal_Rela rela;
4434       bfd_byte *loc;
4435
4436       /* This symbol needs a copy reloc.  Set it up.  */
4437
4438       BFD_ASSERT (h->dynindx != -1
4439                   && (h->root.type == bfd_link_hash_defined
4440                       || h->root.type == bfd_link_hash_defweak));
4441
4442       s = bfd_get_linker_section (dynobj, ".rela.bss");
4443       BFD_ASSERT (s != NULL);
4444
4445       rela.r_offset = (h->root.u.def.value
4446                        + h->root.u.def.section->output_section->vma
4447                        + h->root.u.def.section->output_offset);
4448       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
4449       rela.r_addend = 0;
4450       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4451       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4452     }
4453
4454   return TRUE;
4455 }
4456
4457 /* Finish up the dynamic sections.  */
4458
4459 static bfd_boolean
4460 elf_m68k_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4461 {
4462   bfd *dynobj;
4463   asection *sgot;
4464   asection *sdyn;
4465
4466   dynobj = elf_hash_table (info)->dynobj;
4467
4468   sgot = bfd_get_linker_section (dynobj, ".got.plt");
4469   BFD_ASSERT (sgot != NULL);
4470   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4471
4472   if (elf_hash_table (info)->dynamic_sections_created)
4473     {
4474       asection *splt;
4475       Elf32_External_Dyn *dyncon, *dynconend;
4476
4477       splt = bfd_get_linker_section (dynobj, ".plt");
4478       BFD_ASSERT (splt != NULL && sdyn != NULL);
4479
4480       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4481       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4482       for (; dyncon < dynconend; dyncon++)
4483         {
4484           Elf_Internal_Dyn dyn;
4485           const char *name;
4486           asection *s;
4487
4488           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4489
4490           switch (dyn.d_tag)
4491             {
4492             default:
4493               break;
4494
4495             case DT_PLTGOT:
4496               name = ".got";
4497               goto get_vma;
4498             case DT_JMPREL:
4499               name = ".rela.plt";
4500             get_vma:
4501               s = bfd_get_section_by_name (output_bfd, name);
4502               BFD_ASSERT (s != NULL);
4503               dyn.d_un.d_ptr = s->vma;
4504               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4505               break;
4506
4507             case DT_PLTRELSZ:
4508               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4509               BFD_ASSERT (s != NULL);
4510               dyn.d_un.d_val = s->size;
4511               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4512               break;
4513
4514             case DT_RELASZ:
4515               /* The procedure linkage table relocs (DT_JMPREL) should
4516                  not be included in the overall relocs (DT_RELA).
4517                  Therefore, we override the DT_RELASZ entry here to
4518                  make it not include the JMPREL relocs.  Since the
4519                  linker script arranges for .rela.plt to follow all
4520                  other relocation sections, we don't have to worry
4521                  about changing the DT_RELA entry.  */
4522               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4523               if (s != NULL)
4524                 dyn.d_un.d_val -= s->size;
4525               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4526               break;
4527             }
4528         }
4529
4530       /* Fill in the first entry in the procedure linkage table.  */
4531       if (splt->size > 0)
4532         {
4533           const struct elf_m68k_plt_info *plt_info;
4534
4535           plt_info = elf_m68k_hash_table (info)->plt_info;
4536           memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
4537
4538           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
4539                                  (sgot->output_section->vma
4540                                   + sgot->output_offset
4541                                   + 4));
4542
4543           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
4544                                  (sgot->output_section->vma
4545                                   + sgot->output_offset
4546                                   + 8));
4547
4548           elf_section_data (splt->output_section)->this_hdr.sh_entsize
4549             = plt_info->size;
4550         }
4551     }
4552
4553   /* Fill in the first three entries in the global offset table.  */
4554   if (sgot->size > 0)
4555     {
4556       if (sdyn == NULL)
4557         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4558       else
4559         bfd_put_32 (output_bfd,
4560                     sdyn->output_section->vma + sdyn->output_offset,
4561                     sgot->contents);
4562       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4563       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4564     }
4565
4566   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4567
4568   return TRUE;
4569 }
4570
4571 /* Given a .data section and a .emreloc in-memory section, store
4572    relocation information into the .emreloc section which can be
4573    used at runtime to relocate the section.  This is called by the
4574    linker when the --embedded-relocs switch is used.  This is called
4575    after the add_symbols entry point has been called for all the
4576    objects, and before the final_link entry point is called.  */
4577
4578 bfd_boolean
4579 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
4580      bfd *abfd;
4581      struct bfd_link_info *info;
4582      asection *datasec;
4583      asection *relsec;
4584      char **errmsg;
4585 {
4586   Elf_Internal_Shdr *symtab_hdr;
4587   Elf_Internal_Sym *isymbuf = NULL;
4588   Elf_Internal_Rela *internal_relocs = NULL;
4589   Elf_Internal_Rela *irel, *irelend;
4590   bfd_byte *p;
4591   bfd_size_type amt;
4592
4593   BFD_ASSERT (! info->relocatable);
4594
4595   *errmsg = NULL;
4596
4597   if (datasec->reloc_count == 0)
4598     return TRUE;
4599
4600   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4601
4602   /* Get a copy of the native relocations.  */
4603   internal_relocs = (_bfd_elf_link_read_relocs
4604                      (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
4605                       info->keep_memory));
4606   if (internal_relocs == NULL)
4607     goto error_return;
4608
4609   amt = (bfd_size_type) datasec->reloc_count * 12;
4610   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4611   if (relsec->contents == NULL)
4612     goto error_return;
4613
4614   p = relsec->contents;
4615
4616   irelend = internal_relocs + datasec->reloc_count;
4617   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4618     {
4619       asection *targetsec;
4620
4621       /* We are going to write a four byte longword into the runtime
4622        reloc section.  The longword will be the address in the data
4623        section which must be relocated.  It is followed by the name
4624        of the target section NUL-padded or truncated to 8
4625        characters.  */
4626
4627       /* We can only relocate absolute longword relocs at run time.  */
4628       if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4629         {
4630           *errmsg = _("unsupported reloc type");
4631           bfd_set_error (bfd_error_bad_value);
4632           goto error_return;
4633         }
4634
4635       /* Get the target section referred to by the reloc.  */
4636       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4637         {
4638           /* A local symbol.  */
4639           Elf_Internal_Sym *isym;
4640
4641           /* Read this BFD's local symbols if we haven't done so already.  */
4642           if (isymbuf == NULL)
4643             {
4644               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4645               if (isymbuf == NULL)
4646                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4647                                                 symtab_hdr->sh_info, 0,
4648                                                 NULL, NULL, NULL);
4649               if (isymbuf == NULL)
4650                 goto error_return;
4651             }
4652
4653           isym = isymbuf + ELF32_R_SYM (irel->r_info);
4654           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4655         }
4656       else
4657         {
4658           unsigned long indx;
4659           struct elf_link_hash_entry *h;
4660
4661           /* An external symbol.  */
4662           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4663           h = elf_sym_hashes (abfd)[indx];
4664           BFD_ASSERT (h != NULL);
4665           if (h->root.type == bfd_link_hash_defined
4666               || h->root.type == bfd_link_hash_defweak)
4667             targetsec = h->root.u.def.section;
4668           else
4669             targetsec = NULL;
4670         }
4671
4672       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4673       memset (p + 4, 0, 8);
4674       if (targetsec != NULL)
4675         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4676     }
4677
4678   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4679     free (isymbuf);
4680   if (internal_relocs != NULL
4681       && elf_section_data (datasec)->relocs != internal_relocs)
4682     free (internal_relocs);
4683   return TRUE;
4684
4685 error_return:
4686   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4687     free (isymbuf);
4688   if (internal_relocs != NULL
4689       && elf_section_data (datasec)->relocs != internal_relocs)
4690     free (internal_relocs);
4691   return FALSE;
4692 }
4693
4694 /* Set target options.  */
4695
4696 void
4697 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4698 {
4699   struct elf_m68k_link_hash_table *htab;
4700   bfd_boolean use_neg_got_offsets_p;
4701   bfd_boolean allow_multigot_p;
4702   bfd_boolean local_gp_p;
4703
4704   switch (got_handling)
4705     {
4706     case 0:
4707       /* --got=single.  */
4708       local_gp_p = FALSE;
4709       use_neg_got_offsets_p = FALSE;
4710       allow_multigot_p = FALSE;
4711       break;
4712
4713     case 1:
4714       /* --got=negative.  */
4715       local_gp_p = TRUE;
4716       use_neg_got_offsets_p = TRUE;
4717       allow_multigot_p = FALSE;
4718       break;
4719
4720     case 2:
4721       /* --got=multigot.  */
4722       local_gp_p = TRUE;
4723       use_neg_got_offsets_p = TRUE;
4724       allow_multigot_p = TRUE;
4725       break;
4726
4727     default:
4728       BFD_ASSERT (FALSE);
4729       return;
4730     }
4731
4732   htab = elf_m68k_hash_table (info);
4733   if (htab != NULL)
4734     {
4735       htab->local_gp_p = local_gp_p;
4736       htab->use_neg_got_offsets_p = use_neg_got_offsets_p;
4737       htab->allow_multigot_p = allow_multigot_p;
4738     }
4739 }
4740
4741 static enum elf_reloc_type_class
4742 elf32_m68k_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4743                              const asection *rel_sec ATTRIBUTE_UNUSED,
4744                              const Elf_Internal_Rela *rela)
4745 {
4746   switch ((int) ELF32_R_TYPE (rela->r_info))
4747     {
4748     case R_68K_RELATIVE:
4749       return reloc_class_relative;
4750     case R_68K_JMP_SLOT:
4751       return reloc_class_plt;
4752     case R_68K_COPY:
4753       return reloc_class_copy;
4754     default:
4755       return reloc_class_normal;
4756     }
4757 }
4758
4759 /* Return address for Ith PLT stub in section PLT, for relocation REL
4760    or (bfd_vma) -1 if it should not be included.  */
4761
4762 static bfd_vma
4763 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4764                       const arelent *rel ATTRIBUTE_UNUSED)
4765 {
4766   return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4767 }
4768
4769 /* Support for core dump NOTE sections.  */
4770
4771 static bfd_boolean
4772 elf_m68k_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4773 {
4774   int offset;
4775   size_t size;
4776
4777   switch (note->descsz)
4778     {
4779     default:
4780       return FALSE;
4781
4782     case 154:           /* Linux/m68k */
4783       /* pr_cursig */
4784       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
4785
4786       /* pr_pid */
4787       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 22);
4788
4789       /* pr_reg */
4790       offset = 70;
4791       size = 80;
4792
4793       break;
4794     }
4795
4796   /* Make a ".reg/999" section.  */
4797   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
4798                                           size, note->descpos + offset);
4799 }
4800
4801 static bfd_boolean
4802 elf_m68k_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4803 {
4804   switch (note->descsz)
4805     {
4806     default:
4807       return FALSE;
4808
4809     case 124:           /* Linux/m68k elf_prpsinfo.  */
4810       elf_tdata (abfd)->core->pid
4811         = bfd_get_32 (abfd, note->descdata + 12);
4812       elf_tdata (abfd)->core->program
4813         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
4814       elf_tdata (abfd)->core->command
4815         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
4816     }
4817
4818   /* Note that for some reason, a spurious space is tacked
4819      onto the end of the args in some (at least one anyway)
4820      implementations, so strip it off if it exists.  */
4821   {
4822     char *command = elf_tdata (abfd)->core->command;
4823     int n = strlen (command);
4824
4825     if (n > 0 && command[n - 1] == ' ')
4826       command[n - 1] = '\0';
4827   }
4828
4829   return TRUE;
4830 }
4831
4832 /* Hook called by the linker routine which adds symbols from an object
4833    file.  */
4834
4835 static bfd_boolean
4836 elf_m68k_add_symbol_hook (bfd *abfd,
4837                           struct bfd_link_info *info,
4838                           Elf_Internal_Sym *sym,
4839                           const char **namep ATTRIBUTE_UNUSED,
4840                           flagword *flagsp ATTRIBUTE_UNUSED,
4841                           asection **secp ATTRIBUTE_UNUSED,
4842                           bfd_vma *valp ATTRIBUTE_UNUSED)
4843 {
4844   if ((abfd->flags & DYNAMIC) == 0
4845       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4846           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4847     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4848
4849   return TRUE;
4850 }
4851
4852 #define TARGET_BIG_SYM                  m68k_elf32_vec
4853 #define TARGET_BIG_NAME                 "elf32-m68k"
4854 #define ELF_MACHINE_CODE                EM_68K
4855 #define ELF_MAXPAGESIZE                 0x2000
4856 #define elf_backend_create_dynamic_sections \
4857                                         _bfd_elf_create_dynamic_sections
4858 #define bfd_elf32_bfd_link_hash_table_create \
4859                                         elf_m68k_link_hash_table_create
4860 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create?  */
4861 #define bfd_elf32_bfd_link_hash_table_free \
4862                                         elf_m68k_link_hash_table_free
4863 #define bfd_elf32_bfd_final_link        bfd_elf_final_link
4864
4865 #define elf_backend_check_relocs        elf_m68k_check_relocs
4866 #define elf_backend_always_size_sections \
4867                                         elf_m68k_always_size_sections
4868 #define elf_backend_adjust_dynamic_symbol \
4869                                         elf_m68k_adjust_dynamic_symbol
4870 #define elf_backend_size_dynamic_sections \
4871                                         elf_m68k_size_dynamic_sections
4872 #define elf_backend_final_write_processing      elf_m68k_final_write_processing
4873 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
4874 #define elf_backend_relocate_section    elf_m68k_relocate_section
4875 #define elf_backend_finish_dynamic_symbol \
4876                                         elf_m68k_finish_dynamic_symbol
4877 #define elf_backend_finish_dynamic_sections \
4878                                         elf_m68k_finish_dynamic_sections
4879 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
4880 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
4881 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4882 #define bfd_elf32_bfd_merge_private_bfd_data \
4883                                         elf32_m68k_merge_private_bfd_data
4884 #define bfd_elf32_bfd_set_private_flags \
4885                                         elf32_m68k_set_private_flags
4886 #define bfd_elf32_bfd_print_private_bfd_data \
4887                                         elf32_m68k_print_private_bfd_data
4888 #define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
4889 #define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
4890 #define elf_backend_object_p            elf32_m68k_object_p
4891 #define elf_backend_grok_prstatus       elf_m68k_grok_prstatus
4892 #define elf_backend_grok_psinfo         elf_m68k_grok_psinfo
4893 #define elf_backend_add_symbol_hook     elf_m68k_add_symbol_hook
4894
4895 #define elf_backend_can_gc_sections 1
4896 #define elf_backend_can_refcount 1
4897 #define elf_backend_want_got_plt 1
4898 #define elf_backend_plt_readonly 1
4899 #define elf_backend_want_plt_sym 0
4900 #define elf_backend_got_header_size     12
4901 #define elf_backend_rela_normal         1
4902
4903 #include "elf32-target.h"