bfd/elf32-m68k.c

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