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