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