bfd/elf32-m68k.c

   1 /* Motorola 68k series support for 32-bit ELF
   2    Copyright (C) 1993-2016 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, 3, 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 /* Destroy an m68k ELF linker hash table.  */
 944
 945 static void
 946 elf_m68k_link_hash_table_free (bfd *obfd)
 947 {
 948   struct elf_m68k_link_hash_table *htab;
 949
 950   htab = (struct elf_m68k_link_hash_table *) obfd->link.hash;
 951
 952   if (htab->multi_got_.bfd2got != NULL)
 953     {
 954       htab_delete (htab->multi_got_.bfd2got);
 955       htab->multi_got_.bfd2got = NULL;
 956     }
 957   _bfd_elf_link_hash_table_free (obfd);
 958 }
 959
 960 /* Create an m68k ELF linker hash table.  */
 961
 962 static struct bfd_link_hash_table *
 963 elf_m68k_link_hash_table_create (bfd *abfd)
 964 {
 965   struct elf_m68k_link_hash_table *ret;
 966   bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
 967
 968   ret = (struct elf_m68k_link_hash_table *) bfd_zmalloc (amt);
 969   if (ret == (struct elf_m68k_link_hash_table *) NULL)
 970     return NULL;
 971
 972   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 973                                       elf_m68k_link_hash_newfunc,
 974                                       sizeof (struct elf_m68k_link_hash_entry),
 975                                       M68K_ELF_DATA))
 976     {
 977       free (ret);
 978       return NULL;
 979     }
 980   ret->root.root.hash_table_free = elf_m68k_link_hash_table_free;
 981
 982   ret->multi_got_.global_symndx = 1;
 983
 984   return &ret->root.root;
 985 }
 986
 987 /* Set the right machine number.  */
 988
 989 static bfd_boolean
 990 elf32_m68k_object_p (bfd *abfd)
 991 {
 992   unsigned int mach = 0;
 993   unsigned features = 0;
 994   flagword eflags = elf_elfheader (abfd)->e_flags;
 995
 996   if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
 997     features |= m68000;
 998   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
 999     features |= cpu32;
1000   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1001     features |= fido_a;
1002   else
1003     {
1004       switch (eflags & EF_M68K_CF_ISA_MASK)
1005         {
1006         case EF_M68K_CF_ISA_A_NODIV:
1007           features |= mcfisa_a;
1008           break;
1009         case EF_M68K_CF_ISA_A:
1010           features |= mcfisa_a|mcfhwdiv;
1011           break;
1012         case EF_M68K_CF_ISA_A_PLUS:
1013           features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1014           break;
1015         case EF_M68K_CF_ISA_B_NOUSP:
1016           features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1017           break;
1018         case EF_M68K_CF_ISA_B:
1019           features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1020           break;
1021         case EF_M68K_CF_ISA_C:
1022           features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1023           break;
1024         case EF_M68K_CF_ISA_C_NODIV:
1025           features |= mcfisa_a|mcfisa_c|mcfusp;
1026           break;
1027         }
1028       switch (eflags & EF_M68K_CF_MAC_MASK)
1029         {
1030         case EF_M68K_CF_MAC:
1031           features |= mcfmac;
1032           break;
1033         case EF_M68K_CF_EMAC:
1034           features |= mcfemac;
1035           break;
1036         }
1037       if (eflags & EF_M68K_CF_FLOAT)
1038         features |= cfloat;
1039     }
1040
1041   mach = bfd_m68k_features_to_mach (features);
1042   bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1043
1044   return TRUE;
1045 }
1046
1047 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1048    field based on the machine number.  */
1049
1050 static void
1051 elf_m68k_final_write_processing (bfd *abfd,
1052                                  bfd_boolean linker ATTRIBUTE_UNUSED)
1053 {
1054   int mach = bfd_get_mach (abfd);
1055   unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1056
1057   if (!e_flags)
1058     {
1059       unsigned int arch_mask;
1060
1061       arch_mask = bfd_m68k_mach_to_features (mach);
1062
1063       if (arch_mask & m68000)
1064         e_flags = EF_M68K_M68000;
1065       else if (arch_mask & cpu32)
1066         e_flags = EF_M68K_CPU32;
1067       else if (arch_mask & fido_a)
1068         e_flags = EF_M68K_FIDO;
1069       else
1070         {
1071           switch (arch_mask
1072                   & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1073             {
1074             case mcfisa_a:
1075               e_flags |= EF_M68K_CF_ISA_A_NODIV;
1076               break;
1077             case mcfisa_a | mcfhwdiv:
1078               e_flags |= EF_M68K_CF_ISA_A;
1079               break;
1080             case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1081               e_flags |= EF_M68K_CF_ISA_A_PLUS;
1082               break;
1083             case mcfisa_a | mcfisa_b | mcfhwdiv:
1084               e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1085               break;
1086             case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1087               e_flags |= EF_M68K_CF_ISA_B;
1088               break;
1089             case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1090               e_flags |= EF_M68K_CF_ISA_C;
1091               break;
1092             case mcfisa_a | mcfisa_c | mcfusp:
1093               e_flags |= EF_M68K_CF_ISA_C_NODIV;
1094               break;
1095             }
1096           if (arch_mask & mcfmac)
1097             e_flags |= EF_M68K_CF_MAC;
1098           else if (arch_mask & mcfemac)
1099             e_flags |= EF_M68K_CF_EMAC;
1100           if (arch_mask & cfloat)
1101             e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1102         }
1103       elf_elfheader (abfd)->e_flags = e_flags;
1104     }
1105 }
1106
1107 /* Keep m68k-specific flags in the ELF header.  */
1108
1109 static bfd_boolean
1110 elf32_m68k_set_private_flags (bfd *abfd, flagword flags)
1111 {
1112   elf_elfheader (abfd)->e_flags = flags;
1113   elf_flags_init (abfd) = TRUE;
1114   return TRUE;
1115 }
1116
1117 /* Merge backend specific data from an object file to the output
1118    object file when linking.  */
1119 static bfd_boolean
1120 elf32_m68k_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
1121 {
1122   bfd *obfd = info->output_bfd;
1123   flagword out_flags;
1124   flagword in_flags;
1125   flagword out_isa;
1126   flagword in_isa;
1127   const bfd_arch_info_type *arch_info;
1128
1129   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1130       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1131     return FALSE;
1132
1133   /* Get the merged machine.  This checks for incompatibility between
1134      Coldfire & non-Coldfire flags, incompability between different
1135      Coldfire ISAs, and incompability between different MAC types.  */
1136   arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
1137   if (!arch_info)
1138     return FALSE;
1139
1140   bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
1141
1142   in_flags = elf_elfheader (ibfd)->e_flags;
1143   if (!elf_flags_init (obfd))
1144     {
1145       elf_flags_init (obfd) = TRUE;
1146       out_flags = in_flags;
1147     }
1148   else
1149     {
1150       out_flags = elf_elfheader (obfd)->e_flags;
1151       unsigned int variant_mask;
1152
1153       if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1154         variant_mask = 0;
1155       else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1156         variant_mask = 0;
1157       else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1158         variant_mask = 0;
1159       else
1160         variant_mask = EF_M68K_CF_ISA_MASK;
1161
1162       in_isa = (in_flags & variant_mask);
1163       out_isa = (out_flags & variant_mask);
1164       if (in_isa > out_isa)
1165         out_flags ^= in_isa ^ out_isa;
1166       if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
1167            && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1168           || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
1169               && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
1170         out_flags = EF_M68K_FIDO;
1171       else
1172       out_flags |= in_flags ^ in_isa;
1173     }
1174   elf_elfheader (obfd)->e_flags = out_flags;
1175
1176   return TRUE;
1177 }
1178
1179 /* Display the flags field.  */
1180
1181 static bfd_boolean
1182 elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr)
1183 {
1184   FILE *file = (FILE *) ptr;
1185   flagword eflags = elf_elfheader (abfd)->e_flags;
1186
1187   BFD_ASSERT (abfd != NULL && ptr != NULL);
1188
1189   /* Print normal ELF private data.  */
1190   _bfd_elf_print_private_bfd_data (abfd, ptr);
1191
1192   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
1193
1194   /* xgettext:c-format */
1195   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1196
1197   if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1198     fprintf (file, " [m68000]");
1199   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1200     fprintf (file, " [cpu32]");
1201   else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1202     fprintf (file, " [fido]");
1203   else
1204     {
1205       if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
1206         fprintf (file, " [cfv4e]");
1207
1208       if (eflags & EF_M68K_CF_ISA_MASK)
1209         {
1210           char const *isa = _("unknown");
1211           char const *mac = _("unknown");
1212           char const *additional = "";
1213
1214           switch (eflags & EF_M68K_CF_ISA_MASK)
1215             {
1216             case EF_M68K_CF_ISA_A_NODIV:
1217               isa = "A";
1218               additional = " [nodiv]";
1219               break;
1220             case EF_M68K_CF_ISA_A:
1221               isa = "A";
1222               break;
1223             case EF_M68K_CF_ISA_A_PLUS:
1224               isa = "A+";
1225               break;
1226             case EF_M68K_CF_ISA_B_NOUSP:
1227               isa = "B";
1228               additional = " [nousp]";
1229               break;
1230             case EF_M68K_CF_ISA_B:
1231               isa = "B";
1232               break;
1233             case EF_M68K_CF_ISA_C:
1234               isa = "C";
1235               break;
1236             case EF_M68K_CF_ISA_C_NODIV:
1237               isa = "C";
1238               additional = " [nodiv]";
1239               break;
1240             }
1241           fprintf (file, " [isa %s]%s", isa, additional);
1242
1243           if (eflags & EF_M68K_CF_FLOAT)
1244             fprintf (file, " [float]");
1245
1246           switch (eflags & EF_M68K_CF_MAC_MASK)
1247             {
1248             case 0:
1249               mac = NULL;
1250               break;
1251             case EF_M68K_CF_MAC:
1252               mac = "mac";
1253               break;
1254             case EF_M68K_CF_EMAC:
1255               mac = "emac";
1256               break;
1257             case EF_M68K_CF_EMAC_B:
1258               mac = "emac_b";
1259               break;
1260             }
1261           if (mac)
1262             fprintf (file, " [%s]", mac);
1263         }
1264     }
1265
1266   fputc ('\n', file);
1267
1268   return TRUE;
1269 }
1270
1271 /* Multi-GOT support implementation design:
1272
1273    Multi-GOT starts in check_relocs hook.  There we scan all
1274    relocations of a BFD and build a local GOT (struct elf_m68k_got)
1275    for it.  If a single BFD appears to require too many GOT slots with
1276    R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification
1277    to user.
1278    After check_relocs has been invoked for each input BFD, we have
1279    constructed a GOT for each input BFD.
1280
1281    To minimize total number of GOTs required for a particular output BFD
1282    (as some environments support only 1 GOT per output object) we try
1283    to merge some of the GOTs to share an offset space.  Ideally [and in most
1284    cases] we end up with a single GOT.  In cases when there are too many
1285    restricted relocations (e.g., R_68K_GOT16O relocations) we end up with
1286    several GOTs, assuming the environment can handle them.
1287
1288    Partitioning is done in elf_m68k_partition_multi_got.  We start with
1289    an empty GOT and traverse bfd2got hashtable putting got_entries from
1290    local GOTs to the new 'big' one.  We do that by constructing an
1291    intermediate GOT holding all the entries the local GOT has and the big
1292    GOT lacks.  Then we check if there is room in the big GOT to accomodate
1293    all the entries from diff.  On success we add those entries to the big
1294    GOT; on failure we start the new 'big' GOT and retry the adding of
1295    entries from the local GOT.  Note that this retry will always succeed as
1296    each local GOT doesn't overflow the limits.  After partitioning we
1297    end up with each bfd assigned one of the big GOTs.  GOT entries in the
1298    big GOTs are initialized with GOT offsets.  Note that big GOTs are
1299    positioned consequently in program space and represent a single huge GOT
1300    to the outside world.
1301
1302    After that we get to elf_m68k_relocate_section.  There we
1303    adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol
1304    relocations to refer to appropriate [assigned to current input_bfd]
1305    big GOT.
1306
1307    Notes:
1308
1309    GOT entry type: We have several types of GOT entries.
1310    * R_8 type is used in entries for symbols that have at least one
1311    R_68K_GOT8O or R_68K_TLS_*8 relocation.  We can have at most 0x40
1312    such entries in one GOT.
1313    * R_16 type is used in entries for symbols that have at least one
1314    R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations.
1315    We can have at most 0x4000 such entries in one GOT.
1316    * R_32 type is used in all other cases.  We can have as many
1317    such entries in one GOT as we'd like.
1318    When counting relocations we have to include the count of the smaller
1319    ranged relocations in the counts of the larger ranged ones in order
1320    to correctly detect overflow.
1321
1322    Sorting the GOT: In each GOT starting offsets are assigned to
1323    R_8 entries, which are followed by R_16 entries, and
1324    R_32 entries go at the end.  See finalize_got_offsets for details.
1325
1326    Negative GOT offsets: To double usable offset range of GOTs we use
1327    negative offsets.  As we assign entries with GOT offsets relative to
1328    start of .got section, the offset values are positive.  They become
1329    negative only in relocate_section where got->offset value is
1330    subtracted from them.
1331
1332    3 special GOT entries: There are 3 special GOT entries used internally
1333    by loader.  These entries happen to be placed to .got.plt section,
1334    so we don't do anything about them in multi-GOT support.
1335
1336    Memory management: All data except for hashtables
1337    multi_got->bfd2got and got->entries are allocated on
1338    elf_hash_table (info)->dynobj bfd (for this reason we pass 'info'
1339    to most functions), so we don't need to care to free them.  At the
1340    moment of allocation hashtables are being linked into main data
1341    structure (multi_got), all pieces of which are reachable from
1342    elf_m68k_multi_got (info).  We deallocate them in
1343    elf_m68k_link_hash_table_free.  */
1344
1345 /* Initialize GOT.  */
1346
1347 static void
1348 elf_m68k_init_got (struct elf_m68k_got *got)
1349 {
1350   got->entries = NULL;
1351   got->n_slots[R_8] = 0;
1352   got->n_slots[R_16] = 0;
1353   got->n_slots[R_32] = 0;
1354   got->local_n_slots = 0;
1355   got->offset = (bfd_vma) -1;
1356 }
1357
1358 /* Destruct GOT.  */
1359
1360 static void
1361 elf_m68k_clear_got (struct elf_m68k_got *got)
1362 {
1363   if (got->entries != NULL)
1364     {
1365       htab_delete (got->entries);
1366       got->entries = NULL;
1367     }
1368 }
1369
1370 /* Create and empty GOT structure.  INFO is the context where memory
1371    should be allocated.  */
1372
1373 static struct elf_m68k_got *
1374 elf_m68k_create_empty_got (struct bfd_link_info *info)
1375 {
1376   struct elf_m68k_got *got;
1377
1378   got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got));
1379   if (got == NULL)
1380     return NULL;
1381
1382   elf_m68k_init_got (got);
1383
1384   return got;
1385 }
1386
1387 /* Initialize KEY.  */
1388
1389 static void
1390 elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key,
1391                              struct elf_link_hash_entry *h,
1392                              const bfd *abfd, unsigned long symndx,
1393                              enum elf_m68k_reloc_type reloc_type)
1394 {
1395   if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32)
1396     /* All TLS_LDM relocations share a single GOT entry.  */
1397     {
1398       key->bfd = NULL;
1399       key->symndx = 0;
1400     }
1401   else if (h != NULL)
1402     /* Global symbols are identified with their got_entry_key.  */
1403     {
1404       key->bfd = NULL;
1405       key->symndx = elf_m68k_hash_entry (h)->got_entry_key;
1406       BFD_ASSERT (key->symndx != 0);
1407     }
1408   else
1409     /* Local symbols are identified by BFD they appear in and symndx.  */
1410     {
1411       key->bfd = abfd;
1412       key->symndx = symndx;
1413     }
1414
1415   key->type = reloc_type;
1416 }
1417
1418 /* Calculate hash of got_entry.
1419    ??? Is it good?  */
1420
1421 static hashval_t
1422 elf_m68k_got_entry_hash (const void *_entry)
1423 {
1424   const struct elf_m68k_got_entry_key *key;
1425
1426   key = &((const struct elf_m68k_got_entry *) _entry)->key_;
1427
1428   return (key->symndx
1429           + (key->bfd != NULL ? (int) key->bfd->id : -1)
1430           + elf_m68k_reloc_got_type (key->type));
1431 }
1432
1433 /* Check if two got entries are equal.  */
1434
1435 static int
1436 elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2)
1437 {
1438   const struct elf_m68k_got_entry_key *key1;
1439   const struct elf_m68k_got_entry_key *key2;
1440
1441   key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_;
1442   key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_;
1443
1444   return (key1->bfd == key2->bfd
1445           && key1->symndx == key2->symndx
1446           && (elf_m68k_reloc_got_type (key1->type)
1447               == elf_m68k_reloc_got_type (key2->type)));
1448 }
1449
1450 /* When using negative offsets, we allocate one extra R_8, one extra R_16
1451    and one extra R_32 slots to simplify handling of 2-slot entries during
1452    offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots.  */
1453
1454 /* Maximal number of R_8 slots in a single GOT.  */
1455 #define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO)           \
1456   (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1457    ? (0x40 - 1)                                                 \
1458    : 0x20)
1459
1460 /* Maximal number of R_8 and R_16 slots in a single GOT.  */
1461 #define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO)                \
1462   (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1463    ? (0x4000 - 2)                                               \
1464    : 0x2000)
1465
1466 /* SEARCH - simply search the hashtable, don't insert new entries or fail when
1467    the entry cannot be found.
1468    FIND_OR_CREATE - search for an existing entry, but create new if there's
1469    no such.
1470    MUST_FIND - search for an existing entry and assert that it exist.
1471    MUST_CREATE - assert that there's no such entry and create new one.  */
1472 enum elf_m68k_get_entry_howto
1473   {
1474     SEARCH,
1475     FIND_OR_CREATE,
1476     MUST_FIND,
1477     MUST_CREATE
1478   };
1479
1480 /* Get or create (depending on HOWTO) entry with KEY in GOT.
1481    INFO is context in which memory should be allocated (can be NULL if
1482    HOWTO is SEARCH or MUST_FIND).  */
1483
1484 static struct elf_m68k_got_entry *
1485 elf_m68k_get_got_entry (struct elf_m68k_got *got,
1486                         const struct elf_m68k_got_entry_key *key,
1487                         enum elf_m68k_get_entry_howto howto,
1488                         struct bfd_link_info *info)
1489 {
1490   struct elf_m68k_got_entry entry_;
1491   struct elf_m68k_got_entry *entry;
1492   void **ptr;
1493
1494   BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1495
1496   if (got->entries == NULL)
1497     /* This is the first entry in ABFD.  Initialize hashtable.  */
1498     {
1499       if (howto == SEARCH)
1500         return NULL;
1501
1502       got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT
1503                                       (info),
1504                                       elf_m68k_got_entry_hash,
1505                                       elf_m68k_got_entry_eq, NULL);
1506       if (got->entries == NULL)
1507         {
1508           bfd_set_error (bfd_error_no_memory);
1509           return NULL;
1510         }
1511     }
1512
1513   entry_.key_ = *key;
1514   ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH
1515                                                 ? INSERT : NO_INSERT));
1516   if (ptr == NULL)
1517     {
1518       if (howto == SEARCH)
1519         /* Entry not found.  */
1520         return NULL;
1521
1522       /* We're out of memory.  */
1523       bfd_set_error (bfd_error_no_memory);
1524       return NULL;
1525     }
1526
1527   if (*ptr == NULL)
1528     /* We didn't find the entry and we're asked to create a new one.  */
1529     {
1530       BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1531
1532       entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry));
1533       if (entry == NULL)
1534         return NULL;
1535
1536       /* Initialize new entry.  */
1537       entry->key_ = *key;
1538
1539       entry->u.s1.refcount = 0;
1540
1541       /* Mark the entry as not initialized.  */
1542       entry->key_.type = R_68K_max;
1543
1544       *ptr = entry;
1545     }
1546   else
1547     /* We found the entry.  */
1548     {
1549       BFD_ASSERT (howto != MUST_CREATE);
1550
1551       entry = *ptr;
1552     }
1553
1554   return entry;
1555 }
1556
1557 /* Update GOT counters when merging entry of WAS type with entry of NEW type.
1558    Return the value to which ENTRY's type should be set.  */
1559
1560 static enum elf_m68k_reloc_type
1561 elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
1562                                 enum elf_m68k_reloc_type was,
1563                                 enum elf_m68k_reloc_type new_reloc)
1564 {
1565   enum elf_m68k_got_offset_size was_size;
1566   enum elf_m68k_got_offset_size new_size;
1567   bfd_vma n_slots;
1568
1569   if (was == R_68K_max)
1570     /* The type of the entry is not initialized yet.  */
1571     {
1572       /* Update all got->n_slots counters, including n_slots[R_32].  */
1573       was_size = R_LAST;
1574
1575       was = new_reloc;
1576     }
1577   else
1578     {
1579       /* !!! We, probably, should emit an error rather then fail on assert
1580          in such a case.  */
1581       BFD_ASSERT (elf_m68k_reloc_got_type (was)
1582                   == elf_m68k_reloc_got_type (new_reloc));
1583
1584       was_size = elf_m68k_reloc_got_offset_size (was);
1585     }
1586
1587   new_size = elf_m68k_reloc_got_offset_size (new_reloc);
1588   n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
1589
1590   while (was_size > new_size)
1591     {
1592       --was_size;
1593       got->n_slots[was_size] += n_slots;
1594     }
1595
1596   if (new_reloc > was)
1597     /* Relocations are ordered from bigger got offset size to lesser,
1598        so choose the relocation type with lesser offset size.  */
1599     was = new_reloc;
1600
1601   return was;
1602 }
1603
1604 /* Update GOT counters when removing an entry of type TYPE.  */
1605
1606 static void
1607 elf_m68k_remove_got_entry_type (struct elf_m68k_got *got,
1608                                 enum elf_m68k_reloc_type type)
1609 {
1610   enum elf_m68k_got_offset_size os;
1611   bfd_vma n_slots;
1612
1613   n_slots = elf_m68k_reloc_got_n_slots (type);
1614
1615   /* Decrese counter of slots with offset size corresponding to TYPE
1616      and all greater offset sizes.  */
1617   for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os)
1618     {
1619       BFD_ASSERT (got->n_slots[os] >= n_slots);
1620
1621       got->n_slots[os] -= n_slots;
1622     }
1623 }
1624
1625 /* Add new or update existing entry to GOT.
1626    H, ABFD, TYPE and SYMNDX is data for the entry.
1627    INFO is a context where memory should be allocated.  */
1628
1629 static struct elf_m68k_got_entry *
1630 elf_m68k_add_entry_to_got (struct elf_m68k_got *got,
1631                            struct elf_link_hash_entry *h,
1632                            const bfd *abfd,
1633                            enum elf_m68k_reloc_type reloc_type,
1634                            unsigned long symndx,
1635                            struct bfd_link_info *info)
1636 {
1637   struct elf_m68k_got_entry_key key_;
1638   struct elf_m68k_got_entry *entry;
1639
1640   if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0)
1641     elf_m68k_hash_entry (h)->got_entry_key
1642       = elf_m68k_multi_got (info)->global_symndx++;
1643
1644   elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type);
1645
1646   entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info);
1647   if (entry == NULL)
1648     return NULL;
1649
1650   /* Determine entry's type and update got->n_slots counters.  */
1651   entry->key_.type = elf_m68k_update_got_entry_type (got,
1652                                                      entry->key_.type,
1653                                                      reloc_type);
1654
1655   /* Update refcount.  */
1656   ++entry->u.s1.refcount;
1657
1658   if (entry->u.s1.refcount == 1)
1659     /* We see this entry for the first time.  */
1660     {
1661       if (entry->key_.bfd != NULL)
1662         got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type);
1663     }
1664
1665   BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
1666
1667   if ((got->n_slots[R_8]
1668        > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1669       || (got->n_slots[R_16]
1670           > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1671     /* This BFD has too many relocation.  */
1672     {
1673       if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1674         _bfd_error_handler (_("%B: GOT overflow: "
1675                               "Number of relocations with 8-bit "
1676                               "offset > %d"),
1677                             abfd,
1678                             ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
1679       else
1680         _bfd_error_handler (_("%B: GOT overflow: "
1681                               "Number of relocations with 8- or 16-bit "
1682                               "offset > %d"),
1683                             abfd,
1684                             ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
1685
1686       return NULL;
1687     }
1688
1689   return entry;
1690 }
1691
1692 /* Compute the hash value of the bfd in a bfd2got hash entry.  */
1693
1694 static hashval_t
1695 elf_m68k_bfd2got_entry_hash (const void *entry)
1696 {
1697   const struct elf_m68k_bfd2got_entry *e;
1698
1699   e = (const struct elf_m68k_bfd2got_entry *) entry;
1700
1701   return e->bfd->id;
1702 }
1703
1704 /* Check whether two hash entries have the same bfd.  */
1705
1706 static int
1707 elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2)
1708 {
1709   const struct elf_m68k_bfd2got_entry *e1;
1710   const struct elf_m68k_bfd2got_entry *e2;
1711
1712   e1 = (const struct elf_m68k_bfd2got_entry *) entry1;
1713   e2 = (const struct elf_m68k_bfd2got_entry *) entry2;
1714
1715   return e1->bfd == e2->bfd;
1716 }
1717
1718 /* Destruct a bfd2got entry.  */
1719
1720 static void
1721 elf_m68k_bfd2got_entry_del (void *_entry)
1722 {
1723   struct elf_m68k_bfd2got_entry *entry;
1724
1725   entry = (struct elf_m68k_bfd2got_entry *) _entry;
1726
1727   BFD_ASSERT (entry->got != NULL);
1728   elf_m68k_clear_got (entry->got);
1729 }
1730
1731 /* Find existing or create new (depending on HOWTO) bfd2got entry in
1732    MULTI_GOT.  ABFD is the bfd we need a GOT for.  INFO is a context where
1733    memory should be allocated.  */
1734
1735 static struct elf_m68k_bfd2got_entry *
1736 elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got,
1737                             const bfd *abfd,
1738                             enum elf_m68k_get_entry_howto howto,
1739                             struct bfd_link_info *info)
1740 {
1741   struct elf_m68k_bfd2got_entry entry_;
1742   void **ptr;
1743   struct elf_m68k_bfd2got_entry *entry;
1744
1745   BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1746
1747   if (multi_got->bfd2got == NULL)
1748     /* This is the first GOT.  Initialize bfd2got.  */
1749     {
1750       if (howto == SEARCH)
1751         return NULL;
1752
1753       multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash,
1754                                             elf_m68k_bfd2got_entry_eq,
1755                                             elf_m68k_bfd2got_entry_del);
1756       if (multi_got->bfd2got == NULL)
1757         {
1758           bfd_set_error (bfd_error_no_memory);
1759           return NULL;
1760         }
1761     }
1762
1763   entry_.bfd = abfd;
1764   ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH
1765                                                       ? INSERT : NO_INSERT));
1766   if (ptr == NULL)
1767     {
1768       if (howto == SEARCH)
1769         /* Entry not found.  */
1770         return NULL;
1771
1772       /* We're out of memory.  */
1773       bfd_set_error (bfd_error_no_memory);
1774       return NULL;
1775     }
1776
1777   if (*ptr == NULL)
1778     /* Entry was not found.  Create new one.  */
1779     {
1780       BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1781
1782       entry = ((struct elf_m68k_bfd2got_entry *)
1783                bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)));
1784       if (entry == NULL)
1785         return NULL;
1786
1787       entry->bfd = abfd;
1788
1789       entry->got = elf_m68k_create_empty_got (info);
1790       if (entry->got == NULL)
1791         return NULL;
1792
1793       *ptr = entry;
1794     }
1795   else
1796     {
1797       BFD_ASSERT (howto != MUST_CREATE);
1798
1799       /* Return existing entry.  */
1800       entry = *ptr;
1801     }
1802
1803   return entry;
1804 }
1805
1806 struct elf_m68k_can_merge_gots_arg
1807 {
1808   /* A current_got that we constructing a DIFF against.  */
1809   struct elf_m68k_got *big;
1810
1811   /* GOT holding entries not present or that should be changed in
1812      BIG.  */
1813   struct elf_m68k_got *diff;
1814
1815   /* Context where to allocate memory.  */
1816   struct bfd_link_info *info;
1817
1818   /* Error flag.  */
1819   bfd_boolean error_p;
1820 };
1821
1822 /* Process a single entry from the small GOT to see if it should be added
1823    or updated in the big GOT.  */
1824
1825 static int
1826 elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg)
1827 {
1828   const struct elf_m68k_got_entry *entry1;
1829   struct elf_m68k_can_merge_gots_arg *arg;
1830   const struct elf_m68k_got_entry *entry2;
1831   enum elf_m68k_reloc_type type;
1832
1833   entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr;
1834   arg = (struct elf_m68k_can_merge_gots_arg *) _arg;
1835
1836   entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL);
1837
1838   if (entry2 != NULL)
1839     /* We found an existing entry.  Check if we should update it.  */
1840     {
1841       type = elf_m68k_update_got_entry_type (arg->diff,
1842                                              entry2->key_.type,
1843                                              entry1->key_.type);
1844
1845       if (type == entry2->key_.type)
1846         /* ENTRY1 doesn't update data in ENTRY2.  Skip it.
1847            To skip creation of difference entry we use the type,
1848            which we won't see in GOT entries for sure.  */
1849         type = R_68K_max;
1850     }
1851   else
1852     /* We didn't find the entry.  Add entry1 to DIFF.  */
1853     {
1854       BFD_ASSERT (entry1->key_.type != R_68K_max);
1855
1856       type = elf_m68k_update_got_entry_type (arg->diff,
1857                                              R_68K_max, entry1->key_.type);
1858
1859       if (entry1->key_.bfd != NULL)
1860         arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type);
1861     }
1862
1863   if (type != R_68K_max)
1864     /* Create an entry in DIFF.  */
1865     {
1866       struct elf_m68k_got_entry *entry;
1867
1868       entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE,
1869                                       arg->info);
1870       if (entry == NULL)
1871         {
1872           arg->error_p = TRUE;
1873           return 0;
1874         }
1875
1876       entry->key_.type = type;
1877     }
1878
1879   return 1;
1880 }
1881
1882 /* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it.
1883    Construct DIFF GOT holding the entries which should be added or updated
1884    in BIG GOT to accumulate information from SMALL.
1885    INFO is the context where memory should be allocated.  */
1886
1887 static bfd_boolean
1888 elf_m68k_can_merge_gots (struct elf_m68k_got *big,
1889                          const struct elf_m68k_got *small,
1890                          struct bfd_link_info *info,
1891                          struct elf_m68k_got *diff)
1892 {
1893   struct elf_m68k_can_merge_gots_arg arg_;
1894
1895   BFD_ASSERT (small->offset == (bfd_vma) -1);
1896
1897   arg_.big = big;
1898   arg_.diff = diff;
1899   arg_.info = info;
1900   arg_.error_p = FALSE;
1901   htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_);
1902   if (arg_.error_p)
1903     {
1904       diff->offset = 0;
1905       return FALSE;
1906     }
1907
1908   /* Check for overflow.  */
1909   if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8]
1910        > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1911       || (big->n_slots[R_16] + arg_.diff->n_slots[R_16]
1912           > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1913     return FALSE;
1914
1915   return TRUE;
1916 }
1917
1918 struct elf_m68k_merge_gots_arg
1919 {
1920   /* The BIG got.  */
1921   struct elf_m68k_got *big;
1922
1923   /* Context where memory should be allocated.  */
1924   struct bfd_link_info *info;
1925
1926   /* Error flag.  */
1927   bfd_boolean error_p;
1928 };
1929
1930 /* Process a single entry from DIFF got.  Add or update corresponding
1931    entry in the BIG got.  */
1932
1933 static int
1934 elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg)
1935 {
1936   const struct elf_m68k_got_entry *from;
1937   struct elf_m68k_merge_gots_arg *arg;
1938   struct elf_m68k_got_entry *to;
1939
1940   from = (const struct elf_m68k_got_entry *) *entry_ptr;
1941   arg = (struct elf_m68k_merge_gots_arg *) _arg;
1942
1943   to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE,
1944                                arg->info);
1945   if (to == NULL)
1946     {
1947       arg->error_p = TRUE;
1948       return 0;
1949     }
1950
1951   BFD_ASSERT (to->u.s1.refcount == 0);
1952   /* All we need to merge is TYPE.  */
1953   to->key_.type = from->key_.type;
1954
1955   return 1;
1956 }
1957
1958 /* Merge data from DIFF to BIG.  INFO is context where memory should be
1959    allocated.  */
1960
1961 static bfd_boolean
1962 elf_m68k_merge_gots (struct elf_m68k_got *big,
1963                      struct elf_m68k_got *diff,
1964                      struct bfd_link_info *info)
1965 {
1966   if (diff->entries != NULL)
1967     /* DIFF is not empty.  Merge it into BIG GOT.  */
1968     {
1969       struct elf_m68k_merge_gots_arg arg_;
1970
1971       /* Merge entries.  */
1972       arg_.big = big;
1973       arg_.info = info;
1974       arg_.error_p = FALSE;
1975       htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_);
1976       if (arg_.error_p)
1977         return FALSE;
1978
1979       /* Merge counters.  */
1980       big->n_slots[R_8] += diff->n_slots[R_8];
1981       big->n_slots[R_16] += diff->n_slots[R_16];
1982       big->n_slots[R_32] += diff->n_slots[R_32];
1983       big->local_n_slots += diff->local_n_slots;
1984     }
1985   else
1986     /* DIFF is empty.  */
1987     {
1988       BFD_ASSERT (diff->n_slots[R_8] == 0);
1989       BFD_ASSERT (diff->n_slots[R_16] == 0);
1990       BFD_ASSERT (diff->n_slots[R_32] == 0);
1991       BFD_ASSERT (diff->local_n_slots == 0);
1992     }
1993
1994   BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p
1995               || ((big->n_slots[R_8]
1996                    <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1997                   && (big->n_slots[R_16]
1998                       <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))));
1999
2000   return TRUE;
2001 }
2002
2003 struct elf_m68k_finalize_got_offsets_arg
2004 {
2005   /* Ranges of the offsets for GOT entries.
2006      R_x entries receive offsets between offset1[R_x] and offset2[R_x].
2007      R_x is R_8, R_16 and R_32.  */
2008   bfd_vma *offset1;
2009   bfd_vma *offset2;
2010
2011   /* Mapping from global symndx to global symbols.
2012      This is used to build lists of got entries for global symbols.  */
2013   struct elf_m68k_link_hash_entry **symndx2h;
2014
2015   bfd_vma n_ldm_entries;
2016 };
2017
2018 /* Assign ENTRY an offset.  Build list of GOT entries for global symbols
2019    along the way.  */
2020
2021 static int
2022 elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg)
2023 {
2024   struct elf_m68k_got_entry *entry;
2025   struct elf_m68k_finalize_got_offsets_arg *arg;
2026
2027   enum elf_m68k_got_offset_size got_offset_size;
2028   bfd_vma entry_size;
2029
2030   entry = (struct elf_m68k_got_entry *) *entry_ptr;
2031   arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg;
2032
2033   /* This should be a fresh entry created in elf_m68k_can_merge_gots.  */
2034   BFD_ASSERT (entry->u.s1.refcount == 0);
2035
2036   /* Get GOT offset size for the entry .  */
2037   got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type);
2038
2039   /* Calculate entry size in bytes.  */
2040   entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type);
2041
2042   /* Check if we should switch to negative range of the offsets. */
2043   if (arg->offset1[got_offset_size] + entry_size
2044       > arg->offset2[got_offset_size])
2045     {
2046       /* Verify that this is the only switch to negative range for
2047          got_offset_size.  If this assertion fails, then we've miscalculated
2048          range for got_offset_size entries in
2049          elf_m68k_finalize_got_offsets.  */
2050       BFD_ASSERT (arg->offset2[got_offset_size]
2051                   != arg->offset2[-(int) got_offset_size - 1]);
2052
2053       /* Switch.  */
2054       arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1];
2055       arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1];
2056
2057       /* Verify that now we have enough room for the entry.  */
2058       BFD_ASSERT (arg->offset1[got_offset_size] + entry_size
2059                   <= arg->offset2[got_offset_size]);
2060     }
2061
2062   /* Assign offset to entry.  */
2063   entry->u.s2.offset = arg->offset1[got_offset_size];
2064   arg->offset1[got_offset_size] += entry_size;
2065
2066   if (entry->key_.bfd == NULL)
2067     /* Hook up this entry into the list of got_entries of H.  */
2068     {
2069       struct elf_m68k_link_hash_entry *h;
2070
2071       h = arg->symndx2h[entry->key_.symndx];
2072       if (h != NULL)
2073         {
2074           entry->u.s2.next = h->glist;
2075           h->glist = entry;
2076         }
2077       else
2078         /* This should be the entry for TLS_LDM relocation then.  */
2079         {
2080           BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type)
2081                        == R_68K_TLS_LDM32)
2082                       && entry->key_.symndx == 0);
2083
2084           ++arg->n_ldm_entries;
2085         }
2086     }
2087   else
2088     /* This entry is for local symbol.  */
2089     entry->u.s2.next = NULL;
2090
2091   return 1;
2092 }
2093
2094 /* Assign offsets within GOT.  USE_NEG_GOT_OFFSETS_P indicates if we
2095    should use negative offsets.
2096    Build list of GOT entries for global symbols along the way.
2097    SYMNDX2H is mapping from global symbol indices to actual
2098    global symbols.
2099    Return offset at which next GOT should start.  */
2100
2101 static void
2102 elf_m68k_finalize_got_offsets (struct elf_m68k_got *got,
2103                                bfd_boolean use_neg_got_offsets_p,
2104                                struct elf_m68k_link_hash_entry **symndx2h,
2105                                bfd_vma *final_offset, bfd_vma *n_ldm_entries)
2106 {
2107   struct elf_m68k_finalize_got_offsets_arg arg_;
2108   bfd_vma offset1_[2 * R_LAST];
2109   bfd_vma offset2_[2 * R_LAST];
2110   int i;
2111   bfd_vma start_offset;
2112
2113   BFD_ASSERT (got->offset != (bfd_vma) -1);
2114
2115   /* We set entry offsets relative to the .got section (and not the
2116      start of a particular GOT), so that we can use them in
2117      finish_dynamic_symbol without needing to know the GOT which they come
2118      from.  */
2119
2120   /* Put offset1 in the middle of offset1_, same for offset2.  */
2121   arg_.offset1 = offset1_ + R_LAST;
2122   arg_.offset2 = offset2_ + R_LAST;
2123
2124   start_offset = got->offset;
2125
2126   if (use_neg_got_offsets_p)
2127     /* Setup both negative and positive ranges for R_8, R_16 and R_32.  */
2128     i = -(int) R_32 - 1;
2129   else
2130     /* Setup positives ranges for R_8, R_16 and R_32.  */
2131     i = (int) R_8;
2132
2133   for (; i <= (int) R_32; ++i)
2134     {
2135       int j;
2136       size_t n;
2137
2138       /* Set beginning of the range of offsets I.  */
2139       arg_.offset1[i] = start_offset;
2140
2141       /* Calculate number of slots that require I offsets.  */
2142       j = (i >= 0) ? i : -i - 1;
2143       n = (j >= 1) ? got->n_slots[j - 1] : 0;
2144       n = got->n_slots[j] - n;
2145
2146       if (use_neg_got_offsets_p && n != 0)
2147         {
2148           if (i < 0)
2149             /* We first fill the positive side of the range, so we might
2150                end up with one empty slot at that side when we can't fit
2151                whole 2-slot entry.  Account for that at negative side of
2152                the interval with one additional entry.  */
2153             n = n / 2 + 1;
2154           else
2155             /* When the number of slots is odd, make positive side of the
2156                range one entry bigger.  */
2157             n = (n + 1) / 2;
2158         }
2159
2160       /* N is the number of slots that require I offsets.
2161          Calculate length of the range for I offsets.  */
2162       n = 4 * n;
2163
2164       /* Set end of the range.  */
2165       arg_.offset2[i] = start_offset + n;
2166
2167       start_offset = arg_.offset2[i];
2168     }
2169
2170   if (!use_neg_got_offsets_p)
2171     /* Make sure that if we try to switch to negative offsets in
2172        elf_m68k_finalize_got_offsets_1, the assert therein will catch
2173        the bug.  */
2174     for (i = R_8; i <= R_32; ++i)
2175       arg_.offset2[-i - 1] = arg_.offset2[i];
2176
2177   /* Setup got->offset.  offset1[R_8] is either in the middle or at the
2178      beginning of GOT depending on use_neg_got_offsets_p.  */
2179   got->offset = arg_.offset1[R_8];
2180
2181   arg_.symndx2h = symndx2h;
2182   arg_.n_ldm_entries = 0;
2183
2184   /* Assign offsets.  */
2185   htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_);
2186
2187   /* Check offset ranges we have actually assigned.  */
2188   for (i = (int) R_8; i <= (int) R_32; ++i)
2189     BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4);
2190
2191   *final_offset = start_offset;
2192   *n_ldm_entries = arg_.n_ldm_entries;
2193 }
2194
2195 struct elf_m68k_partition_multi_got_arg
2196 {
2197   /* The GOT we are adding entries to.  Aka big got.  */
2198   struct elf_m68k_got *current_got;
2199
2200   /* Offset to assign the next CURRENT_GOT.  */
2201   bfd_vma offset;
2202
2203   /* Context where memory should be allocated.  */
2204   struct bfd_link_info *info;
2205
2206   /* Total number of slots in the .got section.
2207      This is used to calculate size of the .got and .rela.got sections.  */
2208   bfd_vma n_slots;
2209
2210   /* Difference in numbers of allocated slots in the .got section
2211      and necessary relocations in the .rela.got section.
2212      This is used to calculate size of the .rela.got section.  */
2213   bfd_vma slots_relas_diff;
2214
2215   /* Error flag.  */
2216   bfd_boolean error_p;
2217
2218   /* Mapping from global symndx to global symbols.
2219      This is used to build lists of got entries for global symbols.  */
2220   struct elf_m68k_link_hash_entry **symndx2h;
2221 };
2222
2223 static void
2224 elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg)
2225 {
2226   bfd_vma n_ldm_entries;
2227
2228   elf_m68k_finalize_got_offsets (arg->current_got,
2229                                  (elf_m68k_hash_table (arg->info)
2230                                   ->use_neg_got_offsets_p),
2231                                  arg->symndx2h,
2232                                  &arg->offset, &n_ldm_entries);
2233
2234   arg->n_slots += arg->current_got->n_slots[R_32];
2235
2236   if (!bfd_link_pic (arg->info))
2237     /* If we are generating a shared object, we need to
2238        output a R_68K_RELATIVE reloc so that the dynamic
2239        linker can adjust this GOT entry.  Overwise we
2240        don't need space in .rela.got for local symbols.  */
2241     arg->slots_relas_diff += arg->current_got->local_n_slots;
2242
2243   /* @LDM relocations require a 2-slot GOT entry, but only
2244      one relocation.  Account for that.  */
2245   arg->slots_relas_diff += n_ldm_entries;
2246
2247   BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots);
2248 }
2249
2250
2251 /* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT
2252    or start a new CURRENT_GOT.  */
2253
2254 static int
2255 elf_m68k_partition_multi_got_1 (void **_entry, void *_arg)
2256 {
2257   struct elf_m68k_bfd2got_entry *entry;
2258   struct elf_m68k_partition_multi_got_arg *arg;
2259   struct elf_m68k_got *got;
2260   struct elf_m68k_got diff_;
2261   struct elf_m68k_got *diff;
2262
2263   entry = (struct elf_m68k_bfd2got_entry *) *_entry;
2264   arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2265
2266   got = entry->got;
2267   BFD_ASSERT (got != NULL);
2268   BFD_ASSERT (got->offset == (bfd_vma) -1);
2269
2270   diff = NULL;
2271
2272   if (arg->current_got != NULL)
2273     /* Construct diff.  */
2274     {
2275       diff = &diff_;
2276       elf_m68k_init_got (diff);
2277
2278       if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff))
2279         {
2280           if (diff->offset == 0)
2281             /* Offset set to 0 in the diff_ indicates an error.  */
2282             {
2283               arg->error_p = TRUE;
2284               goto final_return;
2285             }
2286
2287           if (elf_m68k_hash_table (arg->info)->allow_multigot_p)
2288             {
2289               elf_m68k_clear_got (diff);
2290               /* Schedule to finish up current_got and start new one.  */
2291               diff = NULL;
2292             }
2293           /* else
2294              Merge GOTs no matter what.  If big GOT overflows,
2295              we'll fail in relocate_section due to truncated relocations.
2296
2297              ??? May be fail earlier?  E.g., in can_merge_gots.  */
2298         }
2299     }
2300   else
2301     /* Diff of got against empty current_got is got itself.  */
2302     {
2303       /* Create empty current_got to put subsequent GOTs to.  */
2304       arg->current_got = elf_m68k_create_empty_got (arg->info);
2305       if (arg->current_got == NULL)
2306         {
2307           arg->error_p = TRUE;
2308           goto final_return;
2309         }
2310
2311       arg->current_got->offset = arg->offset;
2312
2313       diff = got;
2314     }
2315
2316   if (diff != NULL)
2317     {
2318       if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info))
2319         {
2320           arg->error_p = TRUE;
2321           goto final_return;
2322         }
2323
2324       /* Now we can free GOT.  */
2325       elf_m68k_clear_got (got);
2326
2327       entry->got = arg->current_got;
2328     }
2329   else
2330     {
2331       /* Finish up current_got.  */
2332       elf_m68k_partition_multi_got_2 (arg);
2333
2334       /* Schedule to start a new current_got.  */
2335       arg->current_got = NULL;
2336
2337       /* Retry.  */
2338       if (!elf_m68k_partition_multi_got_1 (_entry, _arg))
2339         {
2340           BFD_ASSERT (arg->error_p);
2341           goto final_return;
2342         }
2343     }
2344
2345  final_return:
2346   if (diff != NULL)
2347     elf_m68k_clear_got (diff);
2348
2349   return arg->error_p == FALSE ? 1 : 0;
2350 }
2351
2352 /* Helper function to build symndx2h mapping.  */
2353
2354 static bfd_boolean
2355 elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h,
2356                           void *_arg)
2357 {
2358   struct elf_m68k_link_hash_entry *h;
2359
2360   h = elf_m68k_hash_entry (_h);
2361
2362   if (h->got_entry_key != 0)
2363     /* H has at least one entry in the GOT.  */
2364     {
2365       struct elf_m68k_partition_multi_got_arg *arg;
2366
2367       arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2368
2369       BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL);
2370       arg->symndx2h[h->got_entry_key] = h;
2371     }
2372
2373   return TRUE;
2374 }
2375
2376 /* Merge GOTs of some BFDs, assign offsets to GOT entries and build
2377    lists of GOT entries for global symbols.
2378    Calculate sizes of .got and .rela.got sections.  */
2379
2380 static bfd_boolean
2381 elf_m68k_partition_multi_got (struct bfd_link_info *info)
2382 {
2383   struct elf_m68k_multi_got *multi_got;
2384   struct elf_m68k_partition_multi_got_arg arg_;
2385
2386   multi_got = elf_m68k_multi_got (info);
2387
2388   arg_.current_got = NULL;
2389   arg_.offset = 0;
2390   arg_.info = info;
2391   arg_.n_slots = 0;
2392   arg_.slots_relas_diff = 0;
2393   arg_.error_p = FALSE;
2394
2395   if (multi_got->bfd2got != NULL)
2396     {
2397       /* Initialize symndx2h mapping.  */
2398       {
2399         arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx
2400                                      * sizeof (*arg_.symndx2h));
2401         if (arg_.symndx2h == NULL)
2402           return FALSE;
2403
2404         elf_link_hash_traverse (elf_hash_table (info),
2405                                 elf_m68k_init_symndx2h_1, &arg_);
2406       }
2407
2408       /* Partition.  */
2409       htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1,
2410                      &arg_);
2411       if (arg_.error_p)
2412         {
2413           free (arg_.symndx2h);
2414           arg_.symndx2h = NULL;
2415
2416           return FALSE;
2417         }
2418
2419       /* Finish up last current_got.  */
2420       elf_m68k_partition_multi_got_2 (&arg_);
2421
2422       free (arg_.symndx2h);
2423     }
2424
2425   if (elf_hash_table (info)->dynobj != NULL)
2426     /* Set sizes of .got and .rela.got sections.  */
2427     {
2428       asection *s;
2429
2430       s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".got");
2431       if (s != NULL)
2432         s->size = arg_.offset;
2433       else
2434         BFD_ASSERT (arg_.offset == 0);
2435
2436       BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots);
2437       arg_.n_slots -= arg_.slots_relas_diff;
2438
2439       s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".rela.got");
2440       if (s != NULL)
2441         s->size = arg_.n_slots * sizeof (Elf32_External_Rela);
2442       else
2443         BFD_ASSERT (arg_.n_slots == 0);
2444     }
2445   else
2446     BFD_ASSERT (multi_got->bfd2got == NULL);
2447
2448   return TRUE;
2449 }
2450
2451 /* Specialized version of elf_m68k_get_got_entry that returns pointer
2452    to hashtable slot, thus allowing removal of entry via
2453    elf_m68k_remove_got_entry.  */
2454
2455 static struct elf_m68k_got_entry **
2456 elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got,
2457                              struct elf_m68k_got_entry_key *key)
2458 {
2459   void **ptr;
2460   struct elf_m68k_got_entry entry_;
2461   struct elf_m68k_got_entry **entry_ptr;
2462
2463   entry_.key_ = *key;
2464   ptr = htab_find_slot (got->entries, &entry_, NO_INSERT);
2465   BFD_ASSERT (ptr != NULL);
2466
2467   entry_ptr = (struct elf_m68k_got_entry **) ptr;
2468
2469   return entry_ptr;
2470 }
2471
2472 /* Remove entry pointed to by ENTRY_PTR from GOT.  */
2473
2474 static void
2475 elf_m68k_remove_got_entry (struct elf_m68k_got *got,
2476                            struct elf_m68k_got_entry **entry_ptr)
2477 {
2478   struct elf_m68k_got_entry *entry;
2479
2480   entry = *entry_ptr;
2481
2482   /* Check that offsets have not been finalized yet.  */
2483   BFD_ASSERT (got->offset == (bfd_vma) -1);
2484   /* Check that this entry is indeed unused.  */
2485   BFD_ASSERT (entry->u.s1.refcount == 0);
2486
2487   elf_m68k_remove_got_entry_type (got, entry->key_.type);
2488
2489   if (entry->key_.bfd != NULL)
2490     got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type);
2491
2492   BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
2493
2494   htab_clear_slot (got->entries, (void **) entry_ptr);
2495 }
2496
2497 /* Copy any information related to dynamic linking from a pre-existing
2498    symbol to a newly created symbol.  Also called to copy flags and
2499    other back-end info to a weakdef, in which case the symbol is not
2500    newly created and plt/got refcounts and dynamic indices should not
2501    be copied.  */
2502
2503 static void
2504 elf_m68k_copy_indirect_symbol (struct bfd_link_info *info,
2505                                struct elf_link_hash_entry *_dir,
2506                                struct elf_link_hash_entry *_ind)
2507 {
2508   struct elf_m68k_link_hash_entry *dir;
2509   struct elf_m68k_link_hash_entry *ind;
2510
2511   _bfd_elf_link_hash_copy_indirect (info, _dir, _ind);
2512
2513   if (_ind->root.type != bfd_link_hash_indirect)
2514     return;
2515
2516   dir = elf_m68k_hash_entry (_dir);
2517   ind = elf_m68k_hash_entry (_ind);
2518
2519   /* Any absolute non-dynamic relocations against an indirect or weak
2520      definition will be against the target symbol.  */
2521   _dir->non_got_ref |= _ind->non_got_ref;
2522
2523   /* We might have a direct symbol already having entries in the GOTs.
2524      Update its key only in case indirect symbol has GOT entries and
2525      assert that both indirect and direct symbols don't have GOT entries
2526      at the same time.  */
2527   if (ind->got_entry_key != 0)
2528     {
2529       BFD_ASSERT (dir->got_entry_key == 0);
2530       /* Assert that GOTs aren't partioned yet.  */
2531       BFD_ASSERT (ind->glist == NULL);
2532
2533       dir->got_entry_key = ind->got_entry_key;
2534       ind->got_entry_key = 0;
2535     }
2536 }
2537
2538 /* Look through the relocs for a section during the first phase, and
2539    allocate space in the global offset table or procedure linkage
2540    table.  */
2541
2542 static bfd_boolean
2543 elf_m68k_check_relocs (bfd *abfd,
2544                        struct bfd_link_info *info,
2545                        asection *sec,
2546                        const Elf_Internal_Rela *relocs)
2547 {
2548   bfd *dynobj;
2549   Elf_Internal_Shdr *symtab_hdr;
2550   struct elf_link_hash_entry **sym_hashes;
2551   const Elf_Internal_Rela *rel;
2552   const Elf_Internal_Rela *rel_end;
2553   asection *sgot;
2554   asection *srelgot;
2555   asection *sreloc;
2556   struct elf_m68k_got *got;
2557
2558   if (bfd_link_relocatable (info))
2559     return TRUE;
2560
2561   dynobj = elf_hash_table (info)->dynobj;
2562   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2563   sym_hashes = elf_sym_hashes (abfd);
2564
2565   sgot = NULL;
2566   srelgot = NULL;
2567   sreloc = NULL;
2568
2569   got = NULL;
2570
2571   rel_end = relocs + sec->reloc_count;
2572   for (rel = relocs; rel < rel_end; rel++)
2573     {
2574       unsigned long r_symndx;
2575       struct elf_link_hash_entry *h;
2576
2577       r_symndx = ELF32_R_SYM (rel->r_info);
2578
2579       if (r_symndx < symtab_hdr->sh_info)
2580         h = NULL;
2581       else
2582         {
2583           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2584           while (h->root.type == bfd_link_hash_indirect
2585                  || h->root.type == bfd_link_hash_warning)
2586             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2587
2588           /* PR15323, ref flags aren't set for references in the same
2589              object.  */
2590           h->root.non_ir_ref = 1;
2591         }
2592
2593       switch (ELF32_R_TYPE (rel->r_info))
2594         {
2595         case R_68K_GOT8:
2596         case R_68K_GOT16:
2597         case R_68K_GOT32:
2598           if (h != NULL
2599               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2600             break;
2601           /* Fall through.  */
2602
2603           /* Relative GOT relocations.  */
2604         case R_68K_GOT8O:
2605         case R_68K_GOT16O:
2606         case R_68K_GOT32O:
2607           /* Fall through.  */
2608
2609           /* TLS relocations.  */
2610         case R_68K_TLS_GD8:
2611         case R_68K_TLS_GD16:
2612         case R_68K_TLS_GD32:
2613         case R_68K_TLS_LDM8:
2614         case R_68K_TLS_LDM16:
2615         case R_68K_TLS_LDM32:
2616         case R_68K_TLS_IE8:
2617         case R_68K_TLS_IE16:
2618         case R_68K_TLS_IE32:
2619
2620         case R_68K_TLS_TPREL32:
2621         case R_68K_TLS_DTPREL32:
2622
2623           if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2624               && bfd_link_pic (info))
2625             /* Do the special chorus for libraries with static TLS.  */
2626             info->flags |= DF_STATIC_TLS;
2627
2628           /* This symbol requires a global offset table entry.  */
2629
2630           if (dynobj == NULL)
2631             {
2632               /* Create the .got section.  */
2633               elf_hash_table (info)->dynobj = dynobj = abfd;
2634               if (!_bfd_elf_create_got_section (dynobj, info))
2635                 return FALSE;
2636             }
2637
2638           if (sgot == NULL)
2639             {
2640               sgot = bfd_get_linker_section (dynobj, ".got");
2641               BFD_ASSERT (sgot != NULL);
2642             }
2643
2644           if (srelgot == NULL
2645               && (h != NULL || bfd_link_pic (info)))
2646             {
2647               srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2648               if (srelgot == NULL)
2649                 {
2650                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2651                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
2652                                     | SEC_READONLY);
2653                   srelgot = bfd_make_section_anyway_with_flags (dynobj,
2654                                                                 ".rela.got",
2655                                                                 flags);
2656                   if (srelgot == NULL
2657                       || !bfd_set_section_alignment (dynobj, srelgot, 2))
2658                     return FALSE;
2659                 }
2660             }
2661
2662           if (got == NULL)
2663             {
2664               struct elf_m68k_bfd2got_entry *bfd2got_entry;
2665
2666               bfd2got_entry
2667                 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2668                                               abfd, FIND_OR_CREATE, info);
2669               if (bfd2got_entry == NULL)
2670                 return FALSE;
2671
2672               got = bfd2got_entry->got;
2673               BFD_ASSERT (got != NULL);
2674             }
2675
2676           {
2677             struct elf_m68k_got_entry *got_entry;
2678
2679             /* Add entry to got.  */
2680             got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2681                                                    ELF32_R_TYPE (rel->r_info),
2682                                                    r_symndx, info);
2683             if (got_entry == NULL)
2684               return FALSE;
2685
2686             if (got_entry->u.s1.refcount == 1)
2687               {
2688                 /* Make sure this symbol is output as a dynamic symbol.  */
2689                 if (h != NULL
2690                     && h->dynindx == -1
2691                     && !h->forced_local)
2692                   {
2693                     if (!bfd_elf_link_record_dynamic_symbol (info, h))
2694                       return FALSE;
2695                   }
2696               }
2697           }
2698
2699           break;
2700
2701         case R_68K_PLT8:
2702         case R_68K_PLT16:
2703         case R_68K_PLT32:
2704           /* This symbol requires a procedure linkage table entry.  We
2705              actually build the entry in adjust_dynamic_symbol,
2706              because this might be a case of linking PIC code which is
2707              never referenced by a dynamic object, in which case we
2708              don't need to generate a procedure linkage table entry
2709              after all.  */
2710
2711           /* If this is a local symbol, we resolve it directly without
2712              creating a procedure linkage table entry.  */
2713           if (h == NULL)
2714             continue;
2715
2716           h->needs_plt = 1;
2717           h->plt.refcount++;
2718           break;
2719
2720         case R_68K_PLT8O:
2721         case R_68K_PLT16O:
2722         case R_68K_PLT32O:
2723           /* This symbol requires a procedure linkage table entry.  */
2724
2725           if (h == NULL)
2726             {
2727               /* It does not make sense to have this relocation for a
2728                  local symbol.  FIXME: does it?  How to handle it if
2729                  it does make sense?  */
2730               bfd_set_error (bfd_error_bad_value);
2731               return FALSE;
2732             }
2733
2734           /* Make sure this symbol is output as a dynamic symbol.  */
2735           if (h->dynindx == -1
2736               && !h->forced_local)
2737             {
2738               if (!bfd_elf_link_record_dynamic_symbol (info, h))
2739                 return FALSE;
2740             }
2741
2742           h->needs_plt = 1;
2743           h->plt.refcount++;
2744           break;
2745
2746         case R_68K_PC8:
2747         case R_68K_PC16:
2748         case R_68K_PC32:
2749           /* If we are creating a shared library and this is not a local
2750              symbol, we need to copy the reloc into the shared library.
2751              However when linking with -Bsymbolic and this is a global
2752              symbol which is defined in an object we are including in the
2753              link (i.e., DEF_REGULAR is set), then we can resolve the
2754              reloc directly.  At this point we have not seen all the input
2755              files, so it is possible that DEF_REGULAR is not set now but
2756              will be set later (it is never cleared).  We account for that
2757              possibility below by storing information in the
2758              pcrel_relocs_copied field of the hash table entry.  */
2759           if (!(bfd_link_pic (info)
2760                 && (sec->flags & SEC_ALLOC) != 0
2761                 && h != NULL
2762                 && (!SYMBOLIC_BIND (info, h)
2763                     || h->root.type == bfd_link_hash_defweak
2764                     || !h->def_regular)))
2765             {
2766               if (h != NULL)
2767                 {
2768                   /* Make sure a plt entry is created for this symbol if
2769                      it turns out to be a function defined by a dynamic
2770                      object.  */
2771                   h->plt.refcount++;
2772                 }
2773               break;
2774             }
2775           /* Fall through.  */
2776         case R_68K_8:
2777         case R_68K_16:
2778         case R_68K_32:
2779           /* We don't need to handle relocs into sections not going into
2780              the "real" output.  */
2781           if ((sec->flags & SEC_ALLOC) == 0)
2782               break;
2783
2784           if (h != NULL)
2785             {
2786               /* Make sure a plt entry is created for this symbol if it
2787                  turns out to be a function defined by a dynamic object.  */
2788               h->plt.refcount++;
2789
2790               if (bfd_link_executable (info))
2791                 /* This symbol needs a non-GOT reference.  */
2792                 h->non_got_ref = 1;
2793             }
2794
2795           /* If we are creating a shared library, we need to copy the
2796              reloc into the shared library.  */
2797           if (bfd_link_pic (info))
2798             {
2799               /* When creating a shared object, we must copy these
2800                  reloc types into the output file.  We create a reloc
2801                  section in dynobj and make room for this reloc.  */
2802               if (sreloc == NULL)
2803                 {
2804                   sreloc = _bfd_elf_make_dynamic_reloc_section
2805                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2806
2807                   if (sreloc == NULL)
2808                     return FALSE;
2809                 }
2810
2811               if (sec->flags & SEC_READONLY
2812                   /* Don't set DF_TEXTREL yet for PC relative
2813                      relocations, they might be discarded later.  */
2814                   && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2815                        || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2816                        || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2817                     info->flags |= DF_TEXTREL;
2818
2819               sreloc->size += sizeof (Elf32_External_Rela);
2820
2821               /* We count the number of PC relative relocations we have
2822                  entered for this symbol, so that we can discard them
2823                  again if, in the -Bsymbolic case, the symbol is later
2824                  defined by a regular object, or, in the normal shared
2825                  case, the symbol is forced to be local.  Note that this
2826                  function is only called if we are using an m68kelf linker
2827                  hash table, which means that h is really a pointer to an
2828                  elf_m68k_link_hash_entry.  */
2829               if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2830                   || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2831                   || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2832                 {
2833                   struct elf_m68k_pcrel_relocs_copied *p;
2834                   struct elf_m68k_pcrel_relocs_copied **head;
2835
2836                   if (h != NULL)
2837                     {
2838                       struct elf_m68k_link_hash_entry *eh
2839                         = elf_m68k_hash_entry (h);
2840                       head = &eh->pcrel_relocs_copied;
2841                     }
2842                   else
2843                     {
2844                       asection *s;
2845                       void *vpp;
2846                       Elf_Internal_Sym *isym;
2847
2848                       isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2849                                                     abfd, r_symndx);
2850                       if (isym == NULL)
2851                         return FALSE;
2852
2853                       s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2854                       if (s == NULL)
2855                         s = sec;
2856
2857                       vpp = &elf_section_data (s)->local_dynrel;
2858                       head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2859                     }
2860
2861                   for (p = *head; p != NULL; p = p->next)
2862                     if (p->section == sreloc)
2863                       break;
2864
2865                   if (p == NULL)
2866                     {
2867                       p = ((struct elf_m68k_pcrel_relocs_copied *)
2868                            bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2869                       if (p == NULL)
2870                         return FALSE;
2871                       p->next = *head;
2872                       *head = p;
2873                       p->section = sreloc;
2874                       p->count = 0;
2875                     }
2876
2877                   ++p->count;
2878                 }
2879             }
2880
2881           break;
2882
2883           /* This relocation describes the C++ object vtable hierarchy.
2884              Reconstruct it for later use during GC.  */
2885         case R_68K_GNU_VTINHERIT:
2886           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2887             return FALSE;
2888           break;
2889
2890           /* This relocation describes which C++ vtable entries are actually
2891              used.  Record for later use during GC.  */
2892         case R_68K_GNU_VTENTRY:
2893           BFD_ASSERT (h != NULL);
2894           if (h != NULL
2895               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2896             return FALSE;
2897           break;
2898
2899         default:
2900           break;
2901         }
2902     }
2903
2904   return TRUE;
2905 }
2906
2907 /* Return the section that should be marked against GC for a given
2908    relocation.  */
2909
2910 static asection *
2911 elf_m68k_gc_mark_hook (asection *sec,
2912                        struct bfd_link_info *info,
2913                        Elf_Internal_Rela *rel,
2914                        struct elf_link_hash_entry *h,
2915                        Elf_Internal_Sym *sym)
2916 {
2917   if (h != NULL)
2918     switch (ELF32_R_TYPE (rel->r_info))
2919       {
2920       case R_68K_GNU_VTINHERIT:
2921       case R_68K_GNU_VTENTRY:
2922         return NULL;
2923       }
2924
2925   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2926 }
2927
2928 /* Update the got entry reference counts for the section being removed.  */
2929
2930 static bfd_boolean
2931 elf_m68k_gc_sweep_hook (bfd *abfd,
2932                         struct bfd_link_info *info,
2933                         asection *sec,
2934                         const Elf_Internal_Rela *relocs)
2935 {
2936   Elf_Internal_Shdr *symtab_hdr;
2937   struct elf_link_hash_entry **sym_hashes;
2938   const Elf_Internal_Rela *rel, *relend;
2939   bfd *dynobj;
2940   struct elf_m68k_got *got;
2941
2942   if (bfd_link_relocatable (info))
2943     return TRUE;
2944
2945   dynobj = elf_hash_table (info)->dynobj;
2946   if (dynobj == NULL)
2947     return TRUE;
2948
2949   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2950   sym_hashes = elf_sym_hashes (abfd);
2951   got = NULL;
2952
2953   relend = relocs + sec->reloc_count;
2954   for (rel = relocs; rel < relend; rel++)
2955     {
2956       unsigned long r_symndx;
2957       struct elf_link_hash_entry *h = NULL;
2958
2959       r_symndx = ELF32_R_SYM (rel->r_info);
2960       if (r_symndx >= symtab_hdr->sh_info)
2961         {
2962           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2963           while (h->root.type == bfd_link_hash_indirect
2964                  || h->root.type == bfd_link_hash_warning)
2965             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2966         }
2967
2968       switch (ELF32_R_TYPE (rel->r_info))
2969         {
2970         case R_68K_GOT8:
2971         case R_68K_GOT16:
2972         case R_68K_GOT32:
2973           if (h != NULL
2974               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2975             break;
2976
2977           /* FALLTHRU */
2978         case R_68K_GOT8O:
2979         case R_68K_GOT16O:
2980         case R_68K_GOT32O:
2981           /* Fall through.  */
2982
2983           /* TLS relocations.  */
2984         case R_68K_TLS_GD8:
2985         case R_68K_TLS_GD16:
2986         case R_68K_TLS_GD32:
2987         case R_68K_TLS_LDM8:
2988         case R_68K_TLS_LDM16:
2989         case R_68K_TLS_LDM32:
2990         case R_68K_TLS_IE8:
2991         case R_68K_TLS_IE16:
2992         case R_68K_TLS_IE32:
2993
2994         case R_68K_TLS_TPREL32:
2995         case R_68K_TLS_DTPREL32:
2996
2997           if (got == NULL)
2998             {
2999               got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3000                                                 abfd, MUST_FIND, NULL)->got;
3001               BFD_ASSERT (got != NULL);
3002             }
3003
3004           {
3005             struct elf_m68k_got_entry_key key_;
3006             struct elf_m68k_got_entry **got_entry_ptr;
3007             struct elf_m68k_got_entry *got_entry;
3008
3009             elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3010                                          ELF32_R_TYPE (rel->r_info));
3011             got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3012
3013             got_entry = *got_entry_ptr;
3014
3015             if (got_entry->u.s1.refcount > 0)
3016               {
3017                 --got_entry->u.s1.refcount;
3018
3019                 if (got_entry->u.s1.refcount == 0)
3020                   /* We don't need the .got entry any more.  */
3021                   elf_m68k_remove_got_entry (got, got_entry_ptr);
3022               }
3023           }
3024           break;
3025
3026         case R_68K_PLT8:
3027         case R_68K_PLT16:
3028         case R_68K_PLT32:
3029         case R_68K_PLT8O:
3030         case R_68K_PLT16O:
3031         case R_68K_PLT32O:
3032         case R_68K_PC8:
3033         case R_68K_PC16:
3034         case R_68K_PC32:
3035         case R_68K_8:
3036         case R_68K_16:
3037         case R_68K_32:
3038           if (h != NULL)
3039             {
3040               if (h->plt.refcount > 0)
3041                 --h->plt.refcount;
3042             }
3043           break;
3044
3045         default:
3046           break;
3047         }
3048     }
3049
3050   return TRUE;
3051 }
3052 \f
3053 /* Return the type of PLT associated with OUTPUT_BFD.  */
3054
3055 static const struct elf_m68k_plt_info *
3056 elf_m68k_get_plt_info (bfd *output_bfd)
3057 {
3058   unsigned int features;
3059
3060   features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3061   if (features & cpu32)
3062     return &elf_cpu32_plt_info;
3063   if (features & mcfisa_b)
3064     return &elf_isab_plt_info;
3065   if (features & mcfisa_c)
3066     return &elf_isac_plt_info;
3067   return &elf_m68k_plt_info;
3068 }
3069
3070 /* This function is called after all the input files have been read,
3071    and the input sections have been assigned to output sections.
3072    It's a convenient place to determine the PLT style.  */
3073
3074 static bfd_boolean
3075 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3076 {
3077   /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3078      sections.  */
3079   if (!elf_m68k_partition_multi_got (info))
3080     return FALSE;
3081
3082   elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3083   return TRUE;
3084 }
3085
3086 /* Adjust a symbol defined by a dynamic object and referenced by a
3087    regular object.  The current definition is in some section of the
3088    dynamic object, but we're not including those sections.  We have to
3089    change the definition to something the rest of the link can
3090    understand.  */
3091
3092 static bfd_boolean
3093 elf_m68k_adjust_dynamic_symbol (struct bfd_link_info *info,
3094                                 struct elf_link_hash_entry *h)
3095 {
3096   struct elf_m68k_link_hash_table *htab;
3097   bfd *dynobj;
3098   asection *s;
3099
3100   htab = elf_m68k_hash_table (info);
3101   dynobj = elf_hash_table (info)->dynobj;
3102
3103   /* Make sure we know what is going on here.  */
3104   BFD_ASSERT (dynobj != NULL
3105               && (h->needs_plt
3106                   || h->u.weakdef != NULL
3107                   || (h->def_dynamic
3108                       && h->ref_regular
3109                       && !h->def_regular)));
3110
3111   /* If this is a function, put it in the procedure linkage table.  We
3112      will fill in the contents of the procedure linkage table later,
3113      when we know the address of the .got section.  */
3114   if (h->type == STT_FUNC
3115       || h->needs_plt)
3116     {
3117       if ((h->plt.refcount <= 0
3118            || SYMBOL_CALLS_LOCAL (info, h)
3119            || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3120                && h->root.type == bfd_link_hash_undefweak))
3121           /* We must always create the plt entry if it was referenced
3122              by a PLTxxO relocation.  In this case we already recorded
3123              it as a dynamic symbol.  */
3124           && h->dynindx == -1)
3125         {
3126           /* This case can occur if we saw a PLTxx reloc in an input
3127              file, but the symbol was never referred to by a dynamic
3128              object, or if all references were garbage collected.  In
3129              such a case, we don't actually need to build a procedure
3130              linkage table, and we can just do a PCxx reloc instead.  */
3131           h->plt.offset = (bfd_vma) -1;
3132           h->needs_plt = 0;
3133           return TRUE;
3134         }
3135
3136       /* Make sure this symbol is output as a dynamic symbol.  */
3137       if (h->dynindx == -1
3138           && !h->forced_local)
3139         {
3140           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3141             return FALSE;
3142         }
3143
3144       s = bfd_get_linker_section (dynobj, ".plt");
3145       BFD_ASSERT (s != NULL);
3146
3147       /* If this is the first .plt entry, make room for the special
3148          first entry.  */
3149       if (s->size == 0)
3150         s->size = htab->plt_info->size;
3151
3152       /* If this symbol is not defined in a regular file, and we are
3153          not generating a shared library, then set the symbol to this
3154          location in the .plt.  This is required to make function
3155          pointers compare as equal between the normal executable and
3156          the shared library.  */
3157       if (!bfd_link_pic (info)
3158           && !h->def_regular)
3159         {
3160           h->root.u.def.section = s;
3161           h->root.u.def.value = s->size;
3162         }
3163
3164       h->plt.offset = s->size;
3165
3166       /* Make room for this entry.  */
3167       s->size += htab->plt_info->size;
3168
3169       /* We also need to make an entry in the .got.plt section, which
3170          will be placed in the .got section by the linker script.  */
3171       s = bfd_get_linker_section (dynobj, ".got.plt");
3172       BFD_ASSERT (s != NULL);
3173       s->size += 4;
3174
3175       /* We also need to make an entry in the .rela.plt section.  */
3176       s = bfd_get_linker_section (dynobj, ".rela.plt");
3177       BFD_ASSERT (s != NULL);
3178       s->size += sizeof (Elf32_External_Rela);
3179
3180       return TRUE;
3181     }
3182
3183   /* Reinitialize the plt offset now that it is not used as a reference
3184      count any more.  */
3185   h->plt.offset = (bfd_vma) -1;
3186
3187   /* If this is a weak symbol, and there is a real definition, the
3188      processor independent code will have arranged for us to see the
3189      real definition first, and we can just use the same value.  */
3190   if (h->u.weakdef != NULL)
3191     {
3192       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3193                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3194       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3195       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3196       return TRUE;
3197     }
3198
3199   /* This is a reference to a symbol defined by a dynamic object which
3200      is not a function.  */
3201
3202   /* If we are creating a shared library, we must presume that the
3203      only references to the symbol are via the global offset table.
3204      For such cases we need not do anything here; the relocations will
3205      be handled correctly by relocate_section.  */
3206   if (bfd_link_pic (info))
3207     return TRUE;
3208
3209   /* If there are no references to this symbol that do not use the
3210      GOT, we don't need to generate a copy reloc.  */
3211   if (!h->non_got_ref)
3212     return TRUE;
3213
3214   /* We must allocate the symbol in our .dynbss section, which will
3215      become part of the .bss section of the executable.  There will be
3216      an entry for this symbol in the .dynsym section.  The dynamic
3217      object will contain position independent code, so all references
3218      from the dynamic object to this symbol will go through the global
3219      offset table.  The dynamic linker will use the .dynsym entry to
3220      determine the address it must put in the global offset table, so
3221      both the dynamic object and the regular object will refer to the
3222      same memory location for the variable.  */
3223
3224   s = bfd_get_linker_section (dynobj, ".dynbss");
3225   BFD_ASSERT (s != NULL);
3226
3227   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3228      copy the initial value out of the dynamic object and into the
3229      runtime process image.  We need to remember the offset into the
3230      .rela.bss section we are going to use.  */
3231   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3232     {
3233       asection *srel;
3234
3235       srel = bfd_get_linker_section (dynobj, ".rela.bss");
3236       BFD_ASSERT (srel != NULL);
3237       srel->size += sizeof (Elf32_External_Rela);
3238       h->needs_copy = 1;
3239     }
3240
3241   return _bfd_elf_adjust_dynamic_copy (info, h, s);
3242 }
3243
3244 /* Set the sizes of the dynamic sections.  */
3245
3246 static bfd_boolean
3247 elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3248                                 struct bfd_link_info *info)
3249 {
3250   bfd *dynobj;
3251   asection *s;
3252   bfd_boolean plt;
3253   bfd_boolean relocs;
3254
3255   dynobj = elf_hash_table (info)->dynobj;
3256   BFD_ASSERT (dynobj != NULL);
3257
3258   if (elf_hash_table (info)->dynamic_sections_created)
3259     {
3260       /* Set the contents of the .interp section to the interpreter.  */
3261       if (bfd_link_executable (info) && !info->nointerp)
3262         {
3263           s = bfd_get_linker_section (dynobj, ".interp");
3264           BFD_ASSERT (s != NULL);
3265           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3266           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3267         }
3268     }
3269   else
3270     {
3271       /* We may have created entries in the .rela.got section.
3272          However, if we are not creating the dynamic sections, we will
3273          not actually use these entries.  Reset the size of .rela.got,
3274          which will cause it to get stripped from the output file
3275          below.  */
3276       s = bfd_get_linker_section (dynobj, ".rela.got");
3277       if (s != NULL)
3278         s->size = 0;
3279     }
3280
3281   /* If this is a -Bsymbolic shared link, then we need to discard all
3282      PC relative relocs against symbols defined in a regular object.
3283      For the normal shared case we discard the PC relative relocs
3284      against symbols that have become local due to visibility changes.
3285      We allocated space for them in the check_relocs routine, but we
3286      will not fill them in in the relocate_section routine.  */
3287   if (bfd_link_pic (info))
3288     elf_link_hash_traverse (elf_hash_table (info),
3289                             elf_m68k_discard_copies,
3290                             info);
3291
3292   /* The check_relocs and adjust_dynamic_symbol entry points have
3293      determined the sizes of the various dynamic sections.  Allocate
3294      memory for them.  */
3295   plt = FALSE;
3296   relocs = FALSE;
3297   for (s = dynobj->sections; s != NULL; s = s->next)
3298     {
3299       const char *name;
3300
3301       if ((s->flags & SEC_LINKER_CREATED) == 0)
3302         continue;
3303
3304       /* It's OK to base decisions on the section name, because none
3305          of the dynobj section names depend upon the input files.  */
3306       name = bfd_get_section_name (dynobj, s);
3307
3308       if (strcmp (name, ".plt") == 0)
3309         {
3310           /* Remember whether there is a PLT.  */
3311           plt = s->size != 0;
3312         }
3313       else if (CONST_STRNEQ (name, ".rela"))
3314         {
3315           if (s->size != 0)
3316             {
3317               relocs = TRUE;
3318
3319               /* We use the reloc_count field as a counter if we need
3320                  to copy relocs into the output file.  */
3321               s->reloc_count = 0;
3322             }
3323         }
3324       else if (! CONST_STRNEQ (name, ".got")
3325                && strcmp (name, ".dynbss") != 0)
3326         {
3327           /* It's not one of our sections, so don't allocate space.  */
3328           continue;
3329         }
3330
3331       if (s->size == 0)
3332         {
3333           /* If we don't need this section, strip it from the
3334              output file.  This is mostly to handle .rela.bss and
3335              .rela.plt.  We must create both sections in
3336              create_dynamic_sections, because they must be created
3337              before the linker maps input sections to output
3338              sections.  The linker does that before
3339              adjust_dynamic_symbol is called, and it is that
3340              function which decides whether anything needs to go
3341              into these sections.  */
3342           s->flags |= SEC_EXCLUDE;
3343           continue;
3344         }
3345
3346       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3347         continue;
3348
3349       /* Allocate memory for the section contents.  */
3350       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3351          Unused entries should be reclaimed before the section's contents
3352          are written out, but at the moment this does not happen.  Thus in
3353          order to prevent writing out garbage, we initialise the section's
3354          contents to zero.  */
3355       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3356       if (s->contents == NULL)
3357         return FALSE;
3358     }
3359
3360   if (elf_hash_table (info)->dynamic_sections_created)
3361     {
3362       /* Add some entries to the .dynamic section.  We fill in the
3363          values later, in elf_m68k_finish_dynamic_sections, but we
3364          must add the entries now so that we get the correct size for
3365          the .dynamic section.  The DT_DEBUG entry is filled in by the
3366          dynamic linker and used by the debugger.  */
3367 #define add_dynamic_entry(TAG, VAL) \
3368   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3369
3370       if (bfd_link_executable (info))
3371         {
3372           if (!add_dynamic_entry (DT_DEBUG, 0))
3373             return FALSE;
3374         }
3375
3376       if (plt)
3377         {
3378           if (!add_dynamic_entry (DT_PLTGOT, 0)
3379               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3380               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3381               || !add_dynamic_entry (DT_JMPREL, 0))
3382             return FALSE;
3383         }
3384
3385       if (relocs)
3386         {
3387           if (!add_dynamic_entry (DT_RELA, 0)
3388               || !add_dynamic_entry (DT_RELASZ, 0)
3389               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3390             return FALSE;
3391         }
3392
3393       if ((info->flags & DF_TEXTREL) != 0)
3394         {
3395           if (!add_dynamic_entry (DT_TEXTREL, 0))
3396             return FALSE;
3397         }
3398     }
3399 #undef add_dynamic_entry
3400
3401   return TRUE;
3402 }
3403
3404 /* This function is called via elf_link_hash_traverse if we are
3405    creating a shared object.  In the -Bsymbolic case it discards the
3406    space allocated to copy PC relative relocs against symbols which
3407    are defined in regular objects.  For the normal shared case, it
3408    discards space for pc-relative relocs that have become local due to
3409    symbol visibility changes.  We allocated space for them in the
3410    check_relocs routine, but we won't fill them in in the
3411    relocate_section routine.
3412
3413    We also check whether any of the remaining relocations apply
3414    against a readonly section, and set the DF_TEXTREL flag in this
3415    case.  */
3416
3417 static bfd_boolean
3418 elf_m68k_discard_copies (struct elf_link_hash_entry *h,
3419                          void * inf)
3420 {
3421   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3422   struct elf_m68k_pcrel_relocs_copied *s;
3423
3424   if (!SYMBOL_CALLS_LOCAL (info, h))
3425     {
3426       if ((info->flags & DF_TEXTREL) == 0)
3427         {
3428           /* Look for relocations against read-only sections.  */
3429           for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3430                s != NULL;
3431                s = s->next)
3432             if ((s->section->flags & SEC_READONLY) != 0)
3433               {
3434                 info->flags |= DF_TEXTREL;
3435                 break;
3436               }
3437         }
3438
3439       /* Make sure undefined weak symbols are output as a dynamic symbol
3440          in PIEs.  */
3441       if (h->non_got_ref
3442           && h->root.type == bfd_link_hash_undefweak
3443           && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3444           && h->dynindx == -1
3445           && !h->forced_local)
3446         {
3447           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3448             return FALSE;
3449         }
3450
3451       return TRUE;
3452     }
3453
3454   for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3455        s != NULL;
3456        s = s->next)
3457     s->section->size -= s->count * sizeof (Elf32_External_Rela);
3458
3459   return TRUE;
3460 }
3461
3462
3463 /* Install relocation RELA.  */
3464
3465 static void
3466 elf_m68k_install_rela (bfd *output_bfd,
3467                        asection *srela,
3468                        Elf_Internal_Rela *rela)
3469 {
3470   bfd_byte *loc;
3471
3472   loc = srela->contents;
3473   loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3474   bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3475 }
3476
3477 /* Find the base offsets for thread-local storage in this object,
3478    for GD/LD and IE/LE respectively.  */
3479
3480 #define DTP_OFFSET 0x8000
3481 #define TP_OFFSET  0x7000
3482
3483 static bfd_vma
3484 dtpoff_base (struct bfd_link_info *info)
3485 {
3486   /* If tls_sec is NULL, we should have signalled an error already.  */
3487   if (elf_hash_table (info)->tls_sec == NULL)
3488     return 0;
3489   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3490 }
3491
3492 static bfd_vma
3493 tpoff_base (struct bfd_link_info *info)
3494 {
3495   /* If tls_sec is NULL, we should have signalled an error already.  */
3496   if (elf_hash_table (info)->tls_sec == NULL)
3497     return 0;
3498   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3499 }
3500
3501 /* Output necessary relocation to handle a symbol during static link.
3502    This function is called from elf_m68k_relocate_section.  */
3503
3504 static void
3505 elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3506                                 bfd *output_bfd,
3507                                 enum elf_m68k_reloc_type r_type,
3508                                 asection *sgot,
3509                                 bfd_vma got_entry_offset,
3510                                 bfd_vma relocation)
3511 {
3512   switch (elf_m68k_reloc_got_type (r_type))
3513     {
3514     case R_68K_GOT32O:
3515       bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3516       break;
3517
3518     case R_68K_TLS_GD32:
3519       /* We know the offset within the module,
3520          put it into the second GOT slot.  */
3521       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3522                   sgot->contents + got_entry_offset + 4);
3523       /* FALLTHRU */
3524
3525     case R_68K_TLS_LDM32:
3526       /* Mark it as belonging to module 1, the executable.  */
3527       bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3528       break;
3529
3530     case R_68K_TLS_IE32:
3531       bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3532                   sgot->contents + got_entry_offset);
3533       break;
3534
3535     default:
3536       BFD_ASSERT (FALSE);
3537     }
3538 }
3539
3540 /* Output necessary relocation to handle a local symbol
3541    during dynamic link.
3542    This function is called either from elf_m68k_relocate_section
3543    or from elf_m68k_finish_dynamic_symbol.  */
3544
3545 static void
3546 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3547                                       bfd *output_bfd,
3548                                       enum elf_m68k_reloc_type r_type,
3549                                       asection *sgot,
3550                                       bfd_vma got_entry_offset,
3551                                       bfd_vma relocation,
3552                                       asection *srela)
3553 {
3554   Elf_Internal_Rela outrel;
3555
3556   switch (elf_m68k_reloc_got_type (r_type))
3557     {
3558     case R_68K_GOT32O:
3559       /* Emit RELATIVE relocation to initialize GOT slot
3560          at run-time.  */
3561       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3562       outrel.r_addend = relocation;
3563       break;
3564
3565     case R_68K_TLS_GD32:
3566       /* We know the offset within the module,
3567          put it into the second GOT slot.  */
3568       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3569                   sgot->contents + got_entry_offset + 4);
3570       /* FALLTHRU */
3571
3572     case R_68K_TLS_LDM32:
3573       /* We don't know the module number,
3574          create a relocation for it.  */
3575       outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3576       outrel.r_addend = 0;
3577       break;
3578
3579     case R_68K_TLS_IE32:
3580       /* Emit TPREL relocation to initialize GOT slot
3581          at run-time.  */
3582       outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3583       outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3584       break;
3585
3586     default:
3587       BFD_ASSERT (FALSE);
3588     }
3589
3590   /* Offset of the GOT entry.  */
3591   outrel.r_offset = (sgot->output_section->vma
3592                      + sgot->output_offset
3593                      + got_entry_offset);
3594
3595   /* Install one of the above relocations.  */
3596   elf_m68k_install_rela (output_bfd, srela, &outrel);
3597
3598   bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3599 }
3600
3601 /* Relocate an M68K ELF section.  */
3602
3603 static bfd_boolean
3604 elf_m68k_relocate_section (bfd *output_bfd,
3605                            struct bfd_link_info *info,
3606                            bfd *input_bfd,
3607                            asection *input_section,
3608                            bfd_byte *contents,
3609                            Elf_Internal_Rela *relocs,
3610                            Elf_Internal_Sym *local_syms,
3611                            asection **local_sections)
3612 {
3613   bfd *dynobj;
3614   Elf_Internal_Shdr *symtab_hdr;
3615   struct elf_link_hash_entry **sym_hashes;
3616   asection *sgot;
3617   asection *splt;
3618   asection *sreloc;
3619   asection *srela;
3620   struct elf_m68k_got *got;
3621   Elf_Internal_Rela *rel;
3622   Elf_Internal_Rela *relend;
3623
3624   dynobj = elf_hash_table (info)->dynobj;
3625   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3626   sym_hashes = elf_sym_hashes (input_bfd);
3627
3628   sgot = NULL;
3629   splt = NULL;
3630   sreloc = NULL;
3631   srela = NULL;
3632
3633   got = NULL;
3634
3635   rel = relocs;
3636   relend = relocs + input_section->reloc_count;
3637   for (; rel < relend; rel++)
3638     {
3639       int r_type;
3640       reloc_howto_type *howto;
3641       unsigned long r_symndx;
3642       struct elf_link_hash_entry *h;
3643       Elf_Internal_Sym *sym;
3644       asection *sec;
3645       bfd_vma relocation;
3646       bfd_boolean unresolved_reloc;
3647       bfd_reloc_status_type r;
3648
3649       r_type = ELF32_R_TYPE (rel->r_info);
3650       if (r_type < 0 || r_type >= (int) R_68K_max)
3651         {
3652           bfd_set_error (bfd_error_bad_value);
3653           return FALSE;
3654         }
3655       howto = howto_table + r_type;
3656
3657       r_symndx = ELF32_R_SYM (rel->r_info);
3658
3659       h = NULL;
3660       sym = NULL;
3661       sec = NULL;
3662       unresolved_reloc = FALSE;
3663
3664       if (r_symndx < symtab_hdr->sh_info)
3665         {
3666           sym = local_syms + r_symndx;
3667           sec = local_sections[r_symndx];
3668           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3669         }
3670       else
3671         {
3672           bfd_boolean warned, ignored;
3673
3674           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3675                                    r_symndx, symtab_hdr, sym_hashes,
3676                                    h, sec, relocation,
3677                                    unresolved_reloc, warned, ignored);
3678         }
3679
3680       if (sec != NULL && discarded_section (sec))
3681         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3682                                          rel, 1, relend, howto, 0, contents);
3683
3684       if (bfd_link_relocatable (info))
3685         continue;
3686
3687       switch (r_type)
3688         {
3689         case R_68K_GOT8:
3690         case R_68K_GOT16:
3691         case R_68K_GOT32:
3692           /* Relocation is to the address of the entry for this symbol
3693              in the global offset table.  */
3694           if (h != NULL
3695               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3696             {
3697               if (elf_m68k_hash_table (info)->local_gp_p)
3698                 {
3699                   bfd_vma sgot_output_offset;
3700                   bfd_vma got_offset;
3701
3702                   if (sgot == NULL)
3703                     {
3704                       sgot = bfd_get_linker_section (dynobj, ".got");
3705
3706                       if (sgot != NULL)
3707                         sgot_output_offset = sgot->output_offset;
3708                       else
3709                         /* In this case we have a reference to
3710                            _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3711                            empty.
3712                            ??? Issue a warning?  */
3713                         sgot_output_offset = 0;
3714                     }
3715                   else
3716                     sgot_output_offset = sgot->output_offset;
3717
3718                   if (got == NULL)
3719                     {
3720                       struct elf_m68k_bfd2got_entry *bfd2got_entry;
3721
3722                       bfd2got_entry
3723                         = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3724                                                       input_bfd, SEARCH, NULL);
3725
3726                       if (bfd2got_entry != NULL)
3727                         {
3728                           got = bfd2got_entry->got;
3729                           BFD_ASSERT (got != NULL);
3730
3731                           got_offset = got->offset;
3732                         }
3733                       else
3734                         /* In this case we have a reference to
3735                            _GLOBAL_OFFSET_TABLE_, but no other references
3736                            accessing any GOT entries.
3737                            ??? Issue a warning?  */
3738                         got_offset = 0;
3739                     }
3740                   else
3741                     got_offset = got->offset;
3742
3743                   /* Adjust GOT pointer to point to the GOT
3744                      assigned to input_bfd.  */
3745                   rel->r_addend += sgot_output_offset + got_offset;
3746                 }
3747               else
3748                 BFD_ASSERT (got == NULL || got->offset == 0);
3749
3750               break;
3751             }
3752           /* Fall through.  */
3753         case R_68K_GOT8O:
3754         case R_68K_GOT16O:
3755         case R_68K_GOT32O:
3756
3757         case R_68K_TLS_LDM32:
3758         case R_68K_TLS_LDM16:
3759         case R_68K_TLS_LDM8:
3760
3761         case R_68K_TLS_GD8:
3762         case R_68K_TLS_GD16:
3763         case R_68K_TLS_GD32:
3764
3765         case R_68K_TLS_IE8:
3766         case R_68K_TLS_IE16:
3767         case R_68K_TLS_IE32:
3768
3769           /* Relocation is the offset of the entry for this symbol in
3770              the global offset table.  */
3771
3772           {
3773             struct elf_m68k_got_entry_key key_;
3774             bfd_vma *off_ptr;
3775             bfd_vma off;
3776
3777             if (sgot == NULL)
3778               {
3779                 sgot = bfd_get_linker_section (dynobj, ".got");
3780                 BFD_ASSERT (sgot != NULL);
3781               }
3782
3783             if (got == NULL)
3784               {
3785                 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3786                                                   input_bfd, MUST_FIND,
3787                                                   NULL)->got;
3788                 BFD_ASSERT (got != NULL);
3789               }
3790
3791             /* Get GOT offset for this symbol.  */
3792             elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3793                                          r_type);
3794             off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3795                                                NULL)->u.s2.offset;
3796             off = *off_ptr;
3797
3798             /* The offset must always be a multiple of 4.  We use
3799                the least significant bit to record whether we have
3800                already generated the necessary reloc.  */
3801             if ((off & 1) != 0)
3802               off &= ~1;
3803             else
3804               {
3805                 if (h != NULL
3806                     /* @TLSLDM relocations are bounded to the module, in
3807                        which the symbol is defined -- not to the symbol
3808                        itself.  */
3809                     && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3810                   {
3811                     bfd_boolean dyn;
3812
3813                     dyn = elf_hash_table (info)->dynamic_sections_created;
3814                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3815                                                           bfd_link_pic (info),
3816                                                           h)
3817                         || (bfd_link_pic (info)
3818                             && SYMBOL_REFERENCES_LOCAL (info, h))
3819                         || (ELF_ST_VISIBILITY (h->other)
3820                             && h->root.type == bfd_link_hash_undefweak))
3821                       {
3822                         /* This is actually a static link, or it is a
3823                            -Bsymbolic link and the symbol is defined
3824                            locally, or the symbol was forced to be local
3825                            because of a version file.  We must initialize
3826                            this entry in the global offset table.  Since
3827                            the offset must always be a multiple of 4, we
3828                            use the least significant bit to record whether
3829                            we have initialized it already.
3830
3831                            When doing a dynamic link, we create a .rela.got
3832                            relocation entry to initialize the value.  This
3833                            is done in the finish_dynamic_symbol routine.  */
3834
3835                         elf_m68k_init_got_entry_static (info,
3836                                                         output_bfd,
3837                                                         r_type,
3838                                                         sgot,
3839                                                         off,
3840                                                         relocation);
3841
3842                         *off_ptr |= 1;
3843                       }
3844                     else
3845                       unresolved_reloc = FALSE;
3846                   }
3847                 else if (bfd_link_pic (info)) /* && h == NULL */
3848                   /* Process local symbol during dynamic link.  */
3849                   {
3850                     if (srela == NULL)
3851                       {
3852                         srela = bfd_get_linker_section (dynobj, ".rela.got");
3853                         BFD_ASSERT (srela != NULL);
3854                       }
3855
3856                     elf_m68k_init_got_entry_local_shared (info,
3857                                                           output_bfd,
3858                                                           r_type,
3859                                                           sgot,
3860                                                           off,
3861                                                           relocation,
3862                                                           srela);
3863
3864                     *off_ptr |= 1;
3865                   }
3866                 else /* h == NULL && !bfd_link_pic (info) */
3867                   {
3868                     elf_m68k_init_got_entry_static (info,
3869                                                     output_bfd,
3870                                                     r_type,
3871                                                     sgot,
3872                                                     off,
3873                                                     relocation);
3874
3875                     *off_ptr |= 1;
3876                   }
3877               }
3878
3879             /* We don't use elf_m68k_reloc_got_type in the condition below
3880                because this is the only place where difference between
3881                R_68K_GOTx and R_68K_GOTxO relocations matters.  */
3882             if (r_type == R_68K_GOT32O
3883                 || r_type == R_68K_GOT16O
3884                 || r_type == R_68K_GOT8O
3885                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3886                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3887                 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3888               {
3889                 /* GOT pointer is adjusted to point to the start/middle
3890                    of local GOT.  Adjust the offset accordingly.  */
3891                 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3892                             || off >= got->offset);
3893
3894                 if (elf_m68k_hash_table (info)->local_gp_p)
3895                   relocation = off - got->offset;
3896                 else
3897                   {
3898                     BFD_ASSERT (got->offset == 0);
3899                     relocation = sgot->output_offset + off;
3900                   }
3901
3902                 /* This relocation does not use the addend.  */
3903                 rel->r_addend = 0;
3904               }
3905             else
3906               relocation = (sgot->output_section->vma + sgot->output_offset
3907                             + off);
3908           }
3909           break;
3910
3911         case R_68K_TLS_LDO32:
3912         case R_68K_TLS_LDO16:
3913         case R_68K_TLS_LDO8:
3914           relocation -= dtpoff_base (info);
3915           break;
3916
3917         case R_68K_TLS_LE32:
3918         case R_68K_TLS_LE16:
3919         case R_68K_TLS_LE8:
3920           if (bfd_link_dll (info))
3921             {
3922               _bfd_error_handler
3923                 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3924                    "in shared object"),
3925                  input_bfd, input_section, (long) rel->r_offset, howto->name);
3926
3927               return FALSE;
3928             }
3929           else
3930             relocation -= tpoff_base (info);
3931
3932           break;
3933
3934         case R_68K_PLT8:
3935         case R_68K_PLT16:
3936         case R_68K_PLT32:
3937           /* Relocation is to the entry for this symbol in the
3938              procedure linkage table.  */
3939
3940           /* Resolve a PLTxx reloc against a local symbol directly,
3941              without using the procedure linkage table.  */
3942           if (h == NULL)
3943             break;
3944
3945           if (h->plt.offset == (bfd_vma) -1
3946               || !elf_hash_table (info)->dynamic_sections_created)
3947             {
3948               /* We didn't make a PLT entry for this symbol.  This
3949                  happens when statically linking PIC code, or when
3950                  using -Bsymbolic.  */
3951               break;
3952             }
3953
3954           if (splt == NULL)
3955             {
3956               splt = bfd_get_linker_section (dynobj, ".plt");
3957               BFD_ASSERT (splt != NULL);
3958             }
3959
3960           relocation = (splt->output_section->vma
3961                         + splt->output_offset
3962                         + h->plt.offset);
3963           unresolved_reloc = FALSE;
3964           break;
3965
3966         case R_68K_PLT8O:
3967         case R_68K_PLT16O:
3968         case R_68K_PLT32O:
3969           /* Relocation is the offset of the entry for this symbol in
3970              the procedure linkage table.  */
3971           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
3972
3973           if (splt == NULL)
3974             {
3975               splt = bfd_get_linker_section (dynobj, ".plt");
3976               BFD_ASSERT (splt != NULL);
3977             }
3978
3979           relocation = h->plt.offset;
3980           unresolved_reloc = FALSE;
3981
3982           /* This relocation does not use the addend.  */
3983           rel->r_addend = 0;
3984
3985           break;
3986
3987         case R_68K_8:
3988         case R_68K_16:
3989         case R_68K_32:
3990         case R_68K_PC8:
3991         case R_68K_PC16:
3992         case R_68K_PC32:
3993           if (bfd_link_pic (info)
3994               && r_symndx != STN_UNDEF
3995               && (input_section->flags & SEC_ALLOC) != 0
3996               && (h == NULL
3997                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3998                   || h->root.type != bfd_link_hash_undefweak)
3999               && ((r_type != R_68K_PC8
4000                    && r_type != R_68K_PC16
4001                    && r_type != R_68K_PC32)
4002                   || !SYMBOL_CALLS_LOCAL (info, h)))
4003             {
4004               Elf_Internal_Rela outrel;
4005               bfd_byte *loc;
4006               bfd_boolean skip, relocate;
4007
4008               /* When generating a shared object, these relocations
4009                  are copied into the output file to be resolved at run
4010                  time.  */
4011
4012               skip = FALSE;
4013               relocate = FALSE;
4014
4015               outrel.r_offset =
4016                 _bfd_elf_section_offset (output_bfd, info, input_section,
4017                                          rel->r_offset);
4018               if (outrel.r_offset == (bfd_vma) -1)
4019                 skip = TRUE;
4020               else if (outrel.r_offset == (bfd_vma) -2)
4021                 skip = TRUE, relocate = TRUE;
4022               outrel.r_offset += (input_section->output_section->vma
4023                                   + input_section->output_offset);
4024
4025               if (skip)
4026                 memset (&outrel, 0, sizeof outrel);
4027               else if (h != NULL
4028                        && h->dynindx != -1
4029                        && (r_type == R_68K_PC8
4030                            || r_type == R_68K_PC16
4031                            || r_type == R_68K_PC32
4032                            || !bfd_link_pic (info)
4033                            || !SYMBOLIC_BIND (info, h)
4034                            || !h->def_regular))
4035                 {
4036                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4037                   outrel.r_addend = rel->r_addend;
4038                 }
4039               else
4040                 {
4041                   /* This symbol is local, or marked to become local.  */
4042                   outrel.r_addend = relocation + rel->r_addend;
4043
4044                   if (r_type == R_68K_32)
4045                     {
4046                       relocate = TRUE;
4047                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4048                     }
4049                   else
4050                     {
4051                       long indx;
4052
4053                       if (bfd_is_abs_section (sec))
4054                         indx = 0;
4055                       else if (sec == NULL || sec->owner == NULL)
4056                         {
4057                           bfd_set_error (bfd_error_bad_value);
4058                           return FALSE;
4059                         }
4060                       else
4061                         {
4062                           asection *osec;
4063
4064                           /* We are turning this relocation into one
4065                              against a section symbol.  It would be
4066                              proper to subtract the symbol's value,
4067                              osec->vma, from the emitted reloc addend,
4068                              but ld.so expects buggy relocs.  */
4069                           osec = sec->output_section;
4070                           indx = elf_section_data (osec)->dynindx;
4071                           if (indx == 0)
4072                             {
4073                               struct elf_link_hash_table *htab;
4074                               htab = elf_hash_table (info);
4075                               osec = htab->text_index_section;
4076                               indx = elf_section_data (osec)->dynindx;
4077                             }
4078                           BFD_ASSERT (indx != 0);
4079                         }
4080
4081                       outrel.r_info = ELF32_R_INFO (indx, r_type);
4082                     }
4083                 }
4084
4085               sreloc = elf_section_data (input_section)->sreloc;
4086               if (sreloc == NULL)
4087                 abort ();
4088
4089               loc = sreloc->contents;
4090               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4091               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4092
4093               /* This reloc will be computed at runtime, so there's no
4094                  need to do anything now, except for R_68K_32
4095                  relocations that have been turned into
4096                  R_68K_RELATIVE.  */
4097               if (!relocate)
4098                 continue;
4099             }
4100
4101           break;
4102
4103         case R_68K_GNU_VTINHERIT:
4104         case R_68K_GNU_VTENTRY:
4105           /* These are no-ops in the end.  */
4106           continue;
4107
4108         default:
4109           break;
4110         }
4111
4112       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4113          because such sections are not SEC_ALLOC and thus ld.so will
4114          not process them.  */
4115       if (unresolved_reloc
4116           && !((input_section->flags & SEC_DEBUGGING) != 0
4117                && h->def_dynamic)
4118           && _bfd_elf_section_offset (output_bfd, info, input_section,
4119                                       rel->r_offset) != (bfd_vma) -1)
4120         {
4121           _bfd_error_handler
4122             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4123              input_bfd,
4124              input_section,
4125              (long) rel->r_offset,
4126              howto->name,
4127              h->root.root.string);
4128           return FALSE;
4129         }
4130
4131       if (r_symndx != STN_UNDEF
4132           && r_type != R_68K_NONE
4133           && (h == NULL
4134               || h->root.type == bfd_link_hash_defined
4135               || h->root.type == bfd_link_hash_defweak))
4136         {
4137           char sym_type;
4138
4139           sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4140
4141           if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4142             {
4143               const char *name;
4144
4145               if (h != NULL)
4146                 name = h->root.root.string;
4147               else
4148                 {
4149                   name = (bfd_elf_string_from_elf_section
4150                           (input_bfd, symtab_hdr->sh_link, sym->st_name));
4151                   if (name == NULL || *name == '\0')
4152                     name = bfd_section_name (input_bfd, sec);
4153                 }
4154
4155               _bfd_error_handler
4156                 ((sym_type == STT_TLS
4157                   ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4158                   : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4159                  input_bfd,
4160                  input_section,
4161                  (long) rel->r_offset,
4162                  howto->name,
4163                  name);
4164             }
4165         }
4166
4167       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4168                                     contents, rel->r_offset,
4169                                     relocation, rel->r_addend);
4170
4171       if (r != bfd_reloc_ok)
4172         {
4173           const char *name;
4174
4175           if (h != NULL)
4176             name = h->root.root.string;
4177           else
4178             {
4179               name = bfd_elf_string_from_elf_section (input_bfd,
4180                                                       symtab_hdr->sh_link,
4181                                                       sym->st_name);
4182               if (name == NULL)
4183                 return FALSE;
4184               if (*name == '\0')
4185                 name = bfd_section_name (input_bfd, sec);
4186             }
4187
4188           if (r == bfd_reloc_overflow)
4189             (*info->callbacks->reloc_overflow)
4190               (info, (h ? &h->root : NULL), name, howto->name,
4191                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
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 (bfd_link_pic (info)
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.plt";
4497               goto get_vma;
4498             case DT_JMPREL:
4499               name = ".rela.plt";
4500             get_vma:
4501               s = bfd_get_linker_section (dynobj, name);
4502               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4503               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4504               break;
4505
4506             case DT_PLTRELSZ:
4507               s = bfd_get_linker_section (dynobj, ".rela.plt");
4508               dyn.d_un.d_val = s->size;
4509               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4510               break;
4511
4512             case DT_RELASZ:
4513               /* The procedure linkage table relocs (DT_JMPREL) should
4514                  not be included in the overall relocs (DT_RELA).
4515                  Therefore, we override the DT_RELASZ entry here to
4516                  make it not include the JMPREL relocs.  Since the
4517                  linker script arranges for .rela.plt to follow all
4518                  other relocation sections, we don't have to worry
4519                  about changing the DT_RELA entry.  */
4520               s = bfd_get_linker_section (dynobj, ".rela.plt");
4521               if (s != NULL)
4522                 dyn.d_un.d_val -= s->size;
4523               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4524               break;
4525             }
4526         }
4527
4528       /* Fill in the first entry in the procedure linkage table.  */
4529       if (splt->size > 0)
4530         {
4531           const struct elf_m68k_plt_info *plt_info;
4532
4533           plt_info = elf_m68k_hash_table (info)->plt_info;
4534           memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
4535
4536           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
4537                                  (sgot->output_section->vma
4538                                   + sgot->output_offset
4539                                   + 4));
4540
4541           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
4542                                  (sgot->output_section->vma
4543                                   + sgot->output_offset
4544                                   + 8));
4545
4546           elf_section_data (splt->output_section)->this_hdr.sh_entsize
4547             = plt_info->size;
4548         }
4549     }
4550
4551   /* Fill in the first three entries in the global offset table.  */
4552   if (sgot->size > 0)
4553     {
4554       if (sdyn == NULL)
4555         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4556       else
4557         bfd_put_32 (output_bfd,
4558                     sdyn->output_section->vma + sdyn->output_offset,
4559                     sgot->contents);
4560       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4561       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4562     }
4563
4564   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4565
4566   return TRUE;
4567 }
4568
4569 /* Given a .data section and a .emreloc in-memory section, store
4570    relocation information into the .emreloc section which can be
4571    used at runtime to relocate the section.  This is called by the
4572    linker when the --embedded-relocs switch is used.  This is called
4573    after the add_symbols entry point has been called for all the
4574    objects, and before the final_link entry point is called.  */
4575
4576 bfd_boolean
4577 bfd_m68k_elf32_create_embedded_relocs (bfd *abfd, struct bfd_link_info *info,
4578                                        asection *datasec, asection *relsec,
4579                                        char **errmsg)
4580 {
4581   Elf_Internal_Shdr *symtab_hdr;
4582   Elf_Internal_Sym *isymbuf = NULL;
4583   Elf_Internal_Rela *internal_relocs = NULL;
4584   Elf_Internal_Rela *irel, *irelend;
4585   bfd_byte *p;
4586   bfd_size_type amt;
4587
4588   BFD_ASSERT (! bfd_link_relocatable (info));
4589
4590   *errmsg = NULL;
4591
4592   if (datasec->reloc_count == 0)
4593     return TRUE;
4594
4595   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4596
4597   /* Get a copy of the native relocations.  */
4598   internal_relocs = (_bfd_elf_link_read_relocs
4599                      (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
4600                       info->keep_memory));
4601   if (internal_relocs == NULL)
4602     goto error_return;
4603
4604   amt = (bfd_size_type) datasec->reloc_count * 12;
4605   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4606   if (relsec->contents == NULL)
4607     goto error_return;
4608
4609   p = relsec->contents;
4610
4611   irelend = internal_relocs + datasec->reloc_count;
4612   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4613     {
4614       asection *targetsec;
4615
4616       /* We are going to write a four byte longword into the runtime
4617        reloc section.  The longword will be the address in the data
4618        section which must be relocated.  It is followed by the name
4619        of the target section NUL-padded or truncated to 8
4620        characters.  */
4621
4622       /* We can only relocate absolute longword relocs at run time.  */
4623       if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4624         {
4625           *errmsg = _("unsupported reloc type");
4626           bfd_set_error (bfd_error_bad_value);
4627           goto error_return;
4628         }
4629
4630       /* Get the target section referred to by the reloc.  */
4631       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4632         {
4633           /* A local symbol.  */
4634           Elf_Internal_Sym *isym;
4635
4636           /* Read this BFD's local symbols if we haven't done so already.  */
4637           if (isymbuf == NULL)
4638             {
4639               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4640               if (isymbuf == NULL)
4641                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4642                                                 symtab_hdr->sh_info, 0,
4643                                                 NULL, NULL, NULL);
4644               if (isymbuf == NULL)
4645                 goto error_return;
4646             }
4647
4648           isym = isymbuf + ELF32_R_SYM (irel->r_info);
4649           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4650         }
4651       else
4652         {
4653           unsigned long indx;
4654           struct elf_link_hash_entry *h;
4655
4656           /* An external symbol.  */
4657           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4658           h = elf_sym_hashes (abfd)[indx];
4659           BFD_ASSERT (h != NULL);
4660           if (h->root.type == bfd_link_hash_defined
4661               || h->root.type == bfd_link_hash_defweak)
4662             targetsec = h->root.u.def.section;
4663           else
4664             targetsec = NULL;
4665         }
4666
4667       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4668       memset (p + 4, 0, 8);
4669       if (targetsec != NULL)
4670         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4671     }
4672
4673   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4674     free (isymbuf);
4675   if (internal_relocs != NULL
4676       && elf_section_data (datasec)->relocs != internal_relocs)
4677     free (internal_relocs);
4678   return TRUE;
4679
4680 error_return:
4681   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4682     free (isymbuf);
4683   if (internal_relocs != NULL
4684       && elf_section_data (datasec)->relocs != internal_relocs)
4685     free (internal_relocs);
4686   return FALSE;
4687 }
4688
4689 /* Set target options.  */
4690
4691 void
4692 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4693 {
4694   struct elf_m68k_link_hash_table *htab;
4695   bfd_boolean use_neg_got_offsets_p;
4696   bfd_boolean allow_multigot_p;
4697   bfd_boolean local_gp_p;
4698
4699   switch (got_handling)
4700     {
4701     case 0:
4702       /* --got=single.  */
4703       local_gp_p = FALSE;
4704       use_neg_got_offsets_p = FALSE;
4705       allow_multigot_p = FALSE;
4706       break;
4707
4708     case 1:
4709       /* --got=negative.  */
4710       local_gp_p = TRUE;
4711       use_neg_got_offsets_p = TRUE;
4712       allow_multigot_p = FALSE;
4713       break;
4714
4715     case 2:
4716       /* --got=multigot.  */
4717       local_gp_p = TRUE;
4718       use_neg_got_offsets_p = TRUE;
4719       allow_multigot_p = TRUE;
4720       break;
4721
4722     default:
4723       BFD_ASSERT (FALSE);
4724       return;
4725     }
4726
4727   htab = elf_m68k_hash_table (info);
4728   if (htab != NULL)
4729     {
4730       htab->local_gp_p = local_gp_p;
4731       htab->use_neg_got_offsets_p = use_neg_got_offsets_p;
4732       htab->allow_multigot_p = allow_multigot_p;
4733     }
4734 }
4735
4736 static enum elf_reloc_type_class
4737 elf32_m68k_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4738                              const asection *rel_sec ATTRIBUTE_UNUSED,
4739                              const Elf_Internal_Rela *rela)
4740 {
4741   switch ((int) ELF32_R_TYPE (rela->r_info))
4742     {
4743     case R_68K_RELATIVE:
4744       return reloc_class_relative;
4745     case R_68K_JMP_SLOT:
4746       return reloc_class_plt;
4747     case R_68K_COPY:
4748       return reloc_class_copy;
4749     default:
4750       return reloc_class_normal;
4751     }
4752 }
4753
4754 /* Return address for Ith PLT stub in section PLT, for relocation REL
4755    or (bfd_vma) -1 if it should not be included.  */
4756
4757 static bfd_vma
4758 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4759                       const arelent *rel ATTRIBUTE_UNUSED)
4760 {
4761   return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4762 }
4763
4764 /* Support for core dump NOTE sections.  */
4765
4766 static bfd_boolean
4767 elf_m68k_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4768 {
4769   int offset;
4770   size_t size;
4771
4772   switch (note->descsz)
4773     {
4774     default:
4775       return FALSE;
4776
4777     case 154:           /* Linux/m68k */
4778       /* pr_cursig */
4779       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
4780
4781       /* pr_pid */
4782       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 22);
4783
4784       /* pr_reg */
4785       offset = 70;
4786       size = 80;
4787
4788       break;
4789     }
4790
4791   /* Make a ".reg/999" section.  */
4792   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
4793                                           size, note->descpos + offset);
4794 }
4795
4796 static bfd_boolean
4797 elf_m68k_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4798 {
4799   switch (note->descsz)
4800     {
4801     default:
4802       return FALSE;
4803
4804     case 124:           /* Linux/m68k elf_prpsinfo.  */
4805       elf_tdata (abfd)->core->pid
4806         = bfd_get_32 (abfd, note->descdata + 12);
4807       elf_tdata (abfd)->core->program
4808         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
4809       elf_tdata (abfd)->core->command
4810         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
4811     }
4812
4813   /* Note that for some reason, a spurious space is tacked
4814      onto the end of the args in some (at least one anyway)
4815      implementations, so strip it off if it exists.  */
4816   {
4817     char *command = elf_tdata (abfd)->core->command;
4818     int n = strlen (command);
4819
4820     if (n > 0 && command[n - 1] == ' ')
4821       command[n - 1] = '\0';
4822   }
4823
4824   return TRUE;
4825 }
4826
4827 /* Hook called by the linker routine which adds symbols from an object
4828    file.  */
4829
4830 static bfd_boolean
4831 elf_m68k_add_symbol_hook (bfd *abfd,
4832                           struct bfd_link_info *info,
4833                           Elf_Internal_Sym *sym,
4834                           const char **namep ATTRIBUTE_UNUSED,
4835                           flagword *flagsp ATTRIBUTE_UNUSED,
4836                           asection **secp ATTRIBUTE_UNUSED,
4837                           bfd_vma *valp ATTRIBUTE_UNUSED)
4838 {
4839   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4840       && (abfd->flags & DYNAMIC) == 0
4841       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4842     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4843
4844   return TRUE;
4845 }
4846
4847 #define TARGET_BIG_SYM                  m68k_elf32_vec
4848 #define TARGET_BIG_NAME                 "elf32-m68k"
4849 #define ELF_MACHINE_CODE                EM_68K
4850 #define ELF_MAXPAGESIZE                 0x2000
4851 #define elf_backend_create_dynamic_sections \
4852                                         _bfd_elf_create_dynamic_sections
4853 #define bfd_elf32_bfd_link_hash_table_create \
4854                                         elf_m68k_link_hash_table_create
4855 #define bfd_elf32_bfd_final_link        bfd_elf_final_link
4856
4857 #define elf_backend_check_relocs        elf_m68k_check_relocs
4858 #define elf_backend_always_size_sections \
4859                                         elf_m68k_always_size_sections
4860 #define elf_backend_adjust_dynamic_symbol \
4861                                         elf_m68k_adjust_dynamic_symbol
4862 #define elf_backend_size_dynamic_sections \
4863                                         elf_m68k_size_dynamic_sections
4864 #define elf_backend_final_write_processing      elf_m68k_final_write_processing
4865 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
4866 #define elf_backend_relocate_section    elf_m68k_relocate_section
4867 #define elf_backend_finish_dynamic_symbol \
4868                                         elf_m68k_finish_dynamic_symbol
4869 #define elf_backend_finish_dynamic_sections \
4870                                         elf_m68k_finish_dynamic_sections
4871 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
4872 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
4873 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4874 #define bfd_elf32_bfd_merge_private_bfd_data \
4875                                         elf32_m68k_merge_private_bfd_data
4876 #define bfd_elf32_bfd_set_private_flags \
4877                                         elf32_m68k_set_private_flags
4878 #define bfd_elf32_bfd_print_private_bfd_data \
4879                                         elf32_m68k_print_private_bfd_data
4880 #define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
4881 #define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
4882 #define elf_backend_object_p            elf32_m68k_object_p
4883 #define elf_backend_grok_prstatus       elf_m68k_grok_prstatus
4884 #define elf_backend_grok_psinfo         elf_m68k_grok_psinfo
4885 #define elf_backend_add_symbol_hook     elf_m68k_add_symbol_hook
4886
4887 #define elf_backend_can_gc_sections 1
4888 #define elf_backend_can_refcount 1
4889 #define elf_backend_want_got_plt 1
4890 #define elf_backend_plt_readonly 1
4891 #define elf_backend_want_plt_sym 0
4892 #define elf_backend_got_header_size     12
4893 #define elf_backend_rela_normal         1
4894
4895 #include "elf32-target.h"