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