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