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 (!SYMBOL_CALLS_LOCAL (info, h))
2984     {
2985       if ((info->flags & DF_TEXTREL) == 0)
2986         {
2987           /* Look for relocations against read-only sections.  */
2988           for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
2989                s != NULL;
2990                s = s->next)
2991             if ((s->section->flags & SEC_READONLY) != 0)
2992               {
2993                 info->flags |= DF_TEXTREL;
2994                 break;
2995               }
2996         }
2997
2998       return TRUE;
2999     }
3000
3001   for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3002        s != NULL;
3003        s = s->next)
3004     s->section->size -= s->count * sizeof (Elf32_External_Rela);
3005
3006   return TRUE;
3007 }
3008
3009 /* Relocate an M68K ELF section.  */
3010
3011 static bfd_boolean
3012 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
3013                            contents, relocs, local_syms, local_sections)
3014      bfd *output_bfd;
3015      struct bfd_link_info *info;
3016      bfd *input_bfd;
3017      asection *input_section;
3018      bfd_byte *contents;
3019      Elf_Internal_Rela *relocs;
3020      Elf_Internal_Sym *local_syms;
3021      asection **local_sections;
3022 {
3023   bfd *dynobj;
3024   Elf_Internal_Shdr *symtab_hdr;
3025   struct elf_link_hash_entry **sym_hashes;
3026   asection *sgot;
3027   asection *splt;
3028   asection *sreloc;
3029   struct elf_m68k_got *got;
3030   Elf_Internal_Rela *rel;
3031   Elf_Internal_Rela *relend;
3032
3033   dynobj = elf_hash_table (info)->dynobj;
3034   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3035   sym_hashes = elf_sym_hashes (input_bfd);
3036
3037   sgot = NULL;
3038   splt = NULL;
3039   sreloc = NULL;
3040
3041   got = NULL;
3042
3043   rel = relocs;
3044   relend = relocs + input_section->reloc_count;
3045   for (; rel < relend; rel++)
3046     {
3047       int r_type;
3048       reloc_howto_type *howto;
3049       unsigned long r_symndx;
3050       struct elf_link_hash_entry *h;
3051       Elf_Internal_Sym *sym;
3052       asection *sec;
3053       bfd_vma relocation;
3054       bfd_boolean unresolved_reloc;
3055       bfd_reloc_status_type r;
3056
3057       r_type = ELF32_R_TYPE (rel->r_info);
3058       if (r_type < 0 || r_type >= (int) R_68K_max)
3059         {
3060           bfd_set_error (bfd_error_bad_value);
3061           return FALSE;
3062         }
3063       howto = howto_table + r_type;
3064
3065       r_symndx = ELF32_R_SYM (rel->r_info);
3066
3067       h = NULL;
3068       sym = NULL;
3069       sec = NULL;
3070       unresolved_reloc = FALSE;
3071
3072       if (r_symndx < symtab_hdr->sh_info)
3073         {
3074           sym = local_syms + r_symndx;
3075           sec = local_sections[r_symndx];
3076           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3077         }
3078       else
3079         {
3080           bfd_boolean warned;
3081
3082           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3083                                    r_symndx, symtab_hdr, sym_hashes,
3084                                    h, sec, relocation,
3085                                    unresolved_reloc, warned);
3086         }
3087
3088       if (sec != NULL && elf_discarded_section (sec))
3089         {
3090           /* For relocs against symbols from removed linkonce sections,
3091              or sections discarded by a linker script, we just want the
3092              section contents zeroed.  Avoid any special processing.  */
3093           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
3094           rel->r_info = 0;
3095           rel->r_addend = 0;
3096           continue;
3097         }
3098
3099       if (info->relocatable)
3100         continue;
3101
3102       switch (r_type)
3103         {
3104         case R_68K_GOT8:
3105         case R_68K_GOT16:
3106         case R_68K_GOT32:
3107           /* Relocation is to the address of the entry for this symbol
3108              in the global offset table.  */
3109           if (h != NULL
3110               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3111             {
3112               if (elf_m68k_hash_table (info)->local_gp_p)
3113                 {
3114                   bfd_vma sgot_output_offset;
3115                   bfd_vma got_offset;
3116
3117                   if (sgot == NULL)
3118                     {
3119                       sgot = bfd_get_section_by_name (dynobj, ".got");
3120
3121                       if (sgot != NULL)
3122                         sgot_output_offset = sgot->output_offset;
3123                       else
3124                         /* In this case we have a reference to
3125                            _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3126                            empty.
3127                            ??? Issue a warning?  */
3128                         sgot_output_offset = 0;
3129                     }
3130                   else
3131                     sgot_output_offset = sgot->output_offset;
3132
3133                   if (got == NULL)
3134                     {
3135                       struct elf_m68k_bfd2got_entry *bfd2got_entry;
3136
3137                       bfd2got_entry
3138                         = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3139                                                       input_bfd, SEARCH, NULL);
3140
3141                       if (bfd2got_entry != NULL)
3142                         {
3143                           got = bfd2got_entry->got;
3144                           BFD_ASSERT (got != NULL);
3145
3146                           got_offset = got->offset;
3147                         }
3148                       else
3149                         /* In this case we have a reference to
3150                            _GLOBAL_OFFSET_TABLE_, but no other references
3151                            accessing any GOT entries.
3152                            ??? Issue a warning?  */
3153                         got_offset = 0;
3154                     }
3155                   else
3156                     got_offset = got->offset;
3157
3158                   /* Adjust GOT pointer to point to the GOT
3159                      assigned to input_bfd.  */
3160                   rel->r_addend += sgot_output_offset + got_offset;
3161                 }
3162               else
3163                 BFD_ASSERT (got == NULL || got->offset == 0);
3164
3165               break;
3166             }
3167           /* Fall through.  */
3168         case R_68K_GOT8O:
3169         case R_68K_GOT16O:
3170         case R_68K_GOT32O:
3171           /* Relocation is the offset of the entry for this symbol in
3172              the global offset table.  */
3173
3174           {
3175             struct elf_m68k_got_entry_key key_;
3176             bfd_vma *off_ptr;
3177             bfd_vma off;
3178
3179             if (sgot == NULL)
3180               {
3181                 sgot = bfd_get_section_by_name (dynobj, ".got");
3182                 BFD_ASSERT (sgot != NULL);
3183               }
3184
3185             if (got == NULL)
3186               {
3187                 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3188                                                   input_bfd, MUST_FIND,
3189                                                   NULL)->got;
3190                 BFD_ASSERT (got != NULL);
3191               }
3192
3193             /* Get GOT offset for this symbol.  */
3194             elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx);
3195             off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3196                                                NULL)->u.s2.offset;
3197             off = *off_ptr;
3198
3199             if (h != NULL)
3200               {
3201                 bfd_boolean dyn;
3202
3203                 dyn = elf_hash_table (info)->dynamic_sections_created;
3204                 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3205                     || (info->shared
3206                         && SYMBOL_REFERENCES_LOCAL (info, h))
3207                     || (ELF_ST_VISIBILITY (h->other)
3208                         && h->root.type == bfd_link_hash_undefweak))
3209                   {
3210                     /* This is actually a static link, or it is a
3211                        -Bsymbolic link and the symbol is defined
3212                        locally, or the symbol was forced to be local
3213                        because of a version file..  We must initialize
3214                        this entry in the global offset table.  Since
3215                        the offset must always be a multiple of 4, we
3216                        use the least significant bit to record whether
3217                        we have initialized it already.
3218
3219                        When doing a dynamic link, we create a .rela.got
3220                        relocation entry to initialize the value.  This
3221                        is done in the finish_dynamic_symbol routine.  */
3222                     if ((off & 1) != 0)
3223                       off &= ~1;
3224                     else
3225                       {
3226                         bfd_put_32 (output_bfd, relocation,
3227                                     sgot->contents + off);
3228                         *off_ptr |= 1;
3229                       }
3230                   }
3231                 else
3232                   unresolved_reloc = FALSE;
3233               }
3234             else
3235               {
3236                 /* The offset must always be a multiple of 4.  We use
3237                    the least significant bit to record whether we have
3238                    already generated the necessary reloc.  */
3239                 if ((off & 1) != 0)
3240                   off &= ~1;
3241                 else
3242                   {
3243                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3244
3245                     if (info->shared)
3246                       {
3247                         asection *s;
3248                         Elf_Internal_Rela outrel;
3249                         bfd_byte *loc;
3250
3251                         s = bfd_get_section_by_name (dynobj, ".rela.got");
3252                         BFD_ASSERT (s != NULL);
3253
3254                         outrel.r_offset = (sgot->output_section->vma
3255                                            + sgot->output_offset
3256                                            + off);
3257                         outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3258                         outrel.r_addend = relocation;
3259                         loc = s->contents;
3260                         loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
3261                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3262                       }
3263
3264                     *off_ptr |= 1;
3265                   }
3266               }
3267
3268             if (r_type == R_68K_GOT8O
3269                 || r_type == R_68K_GOT16O
3270                 || r_type == R_68K_GOT32O)
3271               {
3272                 /* GOT pointer is adjusted to point to the start/middle
3273                    of local GOT.  Adjust the offset accordingly.  */
3274                 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3275                             || off >= got->offset);
3276
3277                 if (elf_m68k_hash_table (info)->local_gp_p)
3278                   relocation = off - got->offset;
3279                 else
3280                   {
3281                     BFD_ASSERT (got->offset == 0);
3282                     relocation = sgot->output_offset + off;
3283                   }
3284
3285                 /* This relocation does not use the addend.  */
3286                 BFD_ASSERT (rel->r_addend == 0);
3287                 rel->r_addend = 0;
3288               }
3289             else
3290               relocation = (sgot->output_section->vma + sgot->output_offset
3291                             + off);
3292           }
3293           break;
3294
3295         case R_68K_PLT8:
3296         case R_68K_PLT16:
3297         case R_68K_PLT32:
3298           /* Relocation is to the entry for this symbol in the
3299              procedure linkage table.  */
3300
3301           /* Resolve a PLTxx reloc against a local symbol directly,
3302              without using the procedure linkage table.  */
3303           if (h == NULL)
3304             break;
3305
3306           if (h->plt.offset == (bfd_vma) -1
3307               || !elf_hash_table (info)->dynamic_sections_created)
3308             {
3309               /* We didn't make a PLT entry for this symbol.  This
3310                  happens when statically linking PIC code, or when
3311                  using -Bsymbolic.  */
3312               break;
3313             }
3314
3315           if (splt == NULL)
3316             {
3317               splt = bfd_get_section_by_name (dynobj, ".plt");
3318               BFD_ASSERT (splt != NULL);
3319             }
3320
3321           relocation = (splt->output_section->vma
3322                         + splt->output_offset
3323                         + h->plt.offset);
3324           unresolved_reloc = FALSE;
3325           break;
3326
3327         case R_68K_PLT8O:
3328         case R_68K_PLT16O:
3329         case R_68K_PLT32O:
3330           /* Relocation is the offset of the entry for this symbol in
3331              the procedure linkage table.  */
3332           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
3333
3334           if (splt == NULL)
3335             {
3336               splt = bfd_get_section_by_name (dynobj, ".plt");
3337               BFD_ASSERT (splt != NULL);
3338             }
3339
3340           relocation = h->plt.offset;
3341           unresolved_reloc = FALSE;
3342
3343           /* This relocation does not use the addend.  */
3344           rel->r_addend = 0;
3345
3346           break;
3347
3348         case R_68K_8:
3349         case R_68K_16:
3350         case R_68K_32:
3351         case R_68K_PC8:
3352         case R_68K_PC16:
3353         case R_68K_PC32:
3354           if (info->shared
3355               && r_symndx != 0
3356               && (input_section->flags & SEC_ALLOC) != 0
3357               && (h == NULL
3358                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3359                   || h->root.type != bfd_link_hash_undefweak)
3360               && ((r_type != R_68K_PC8
3361                    && r_type != R_68K_PC16
3362                    && r_type != R_68K_PC32)
3363                   || !SYMBOL_CALLS_LOCAL (info, h)))
3364             {
3365               Elf_Internal_Rela outrel;
3366               bfd_byte *loc;
3367               bfd_boolean skip, relocate;
3368
3369               /* When generating a shared object, these relocations
3370                  are copied into the output file to be resolved at run
3371                  time.  */
3372
3373               skip = FALSE;
3374               relocate = FALSE;
3375
3376               outrel.r_offset =
3377                 _bfd_elf_section_offset (output_bfd, info, input_section,
3378                                          rel->r_offset);
3379               if (outrel.r_offset == (bfd_vma) -1)
3380                 skip = TRUE;
3381               else if (outrel.r_offset == (bfd_vma) -2)
3382                 skip = TRUE, relocate = TRUE;
3383               outrel.r_offset += (input_section->output_section->vma
3384                                   + input_section->output_offset);
3385
3386               if (skip)
3387                 memset (&outrel, 0, sizeof outrel);
3388               else if (h != NULL
3389                        && h->dynindx != -1
3390                        && (r_type == R_68K_PC8
3391                            || r_type == R_68K_PC16
3392                            || r_type == R_68K_PC32
3393                            || !info->shared
3394                            || !info->symbolic
3395                            || !h->def_regular))
3396                 {
3397                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3398                   outrel.r_addend = rel->r_addend;
3399                 }
3400               else
3401                 {
3402                   /* This symbol is local, or marked to become local.  */
3403                   outrel.r_addend = relocation + rel->r_addend;
3404
3405                   if (r_type == R_68K_32)
3406                     {
3407                       relocate = TRUE;
3408                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3409                     }
3410                   else
3411                     {
3412                       long indx;
3413
3414                       if (bfd_is_abs_section (sec))
3415                         indx = 0;
3416                       else if (sec == NULL || sec->owner == NULL)
3417                         {
3418                           bfd_set_error (bfd_error_bad_value);
3419                           return FALSE;
3420                         }
3421                       else
3422                         {
3423                           asection *osec;
3424
3425                           /* We are turning this relocation into one
3426                              against a section symbol.  It would be
3427                              proper to subtract the symbol's value,
3428                              osec->vma, from the emitted reloc addend,
3429                              but ld.so expects buggy relocs.  */
3430                           osec = sec->output_section;
3431                           indx = elf_section_data (osec)->dynindx;
3432                           if (indx == 0)
3433                             {
3434                               struct elf_link_hash_table *htab;
3435                               htab = elf_hash_table (info);
3436                               osec = htab->text_index_section;
3437                               indx = elf_section_data (osec)->dynindx;
3438                             }
3439                           BFD_ASSERT (indx != 0);
3440                         }
3441
3442                       outrel.r_info = ELF32_R_INFO (indx, r_type);
3443                     }
3444                 }
3445
3446               sreloc = elf_section_data (input_section)->sreloc;
3447               if (sreloc == NULL)
3448                 abort ();
3449
3450               loc = sreloc->contents;
3451               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3452               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3453
3454               /* This reloc will be computed at runtime, so there's no
3455                  need to do anything now, except for R_68K_32
3456                  relocations that have been turned into
3457                  R_68K_RELATIVE.  */
3458               if (!relocate)
3459                 continue;
3460             }
3461
3462           break;
3463
3464         case R_68K_GNU_VTINHERIT:
3465         case R_68K_GNU_VTENTRY:
3466           /* These are no-ops in the end.  */
3467           continue;
3468
3469         default:
3470           break;
3471         }
3472
3473       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3474          because such sections are not SEC_ALLOC and thus ld.so will
3475          not process them.  */
3476       if (unresolved_reloc
3477           && !((input_section->flags & SEC_DEBUGGING) != 0
3478                && h->def_dynamic))
3479         {
3480           (*_bfd_error_handler)
3481             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3482              input_bfd,
3483              input_section,
3484              (long) rel->r_offset,
3485              howto->name,
3486              h->root.root.string);
3487           return FALSE;
3488         }
3489
3490       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3491                                     contents, rel->r_offset,
3492                                     relocation, rel->r_addend);
3493
3494       if (r != bfd_reloc_ok)
3495         {
3496           const char *name;
3497
3498           if (h != NULL)
3499             name = h->root.root.string;
3500           else
3501             {
3502               name = bfd_elf_string_from_elf_section (input_bfd,
3503                                                       symtab_hdr->sh_link,
3504                                                       sym->st_name);
3505               if (name == NULL)
3506                 return FALSE;
3507               if (*name == '\0')
3508                 name = bfd_section_name (input_bfd, sec);
3509             }
3510
3511           if (r == bfd_reloc_overflow)
3512             {
3513               if (!(info->callbacks->reloc_overflow
3514                     (info, (h ? &h->root : NULL), name, howto->name,
3515                      (bfd_vma) 0, input_bfd, input_section,
3516                      rel->r_offset)))
3517                 return FALSE;
3518             }
3519           else
3520             {
3521               (*_bfd_error_handler)
3522                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3523                  input_bfd, input_section,
3524                  (long) rel->r_offset, name, (int) r);
3525               return FALSE;
3526             }
3527         }
3528     }
3529
3530   return TRUE;
3531 }
3532
3533 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
3534    into section SEC.  */
3535
3536 static void
3537 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
3538 {
3539   /* Make VALUE PC-relative.  */
3540   value -= sec->output_section->vma + offset;
3541
3542   /* Apply any in-place addend.  */
3543   value += bfd_get_32 (sec->owner, sec->contents + offset);
3544
3545   bfd_put_32 (sec->owner, value, sec->contents + offset);
3546 }
3547
3548 /* Finish up dynamic symbol handling.  We set the contents of various
3549    dynamic sections here.  */
3550
3551 static bfd_boolean
3552 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
3553      bfd *output_bfd;
3554      struct bfd_link_info *info;
3555      struct elf_link_hash_entry *h;
3556      Elf_Internal_Sym *sym;
3557 {
3558   bfd *dynobj;
3559
3560   dynobj = elf_hash_table (info)->dynobj;
3561
3562   if (h->plt.offset != (bfd_vma) -1)
3563     {
3564       const struct elf_m68k_plt_info *plt_info;
3565       asection *splt;
3566       asection *sgot;
3567       asection *srela;
3568       bfd_vma plt_index;
3569       bfd_vma got_offset;
3570       Elf_Internal_Rela rela;
3571       bfd_byte *loc;
3572
3573       /* This symbol has an entry in the procedure linkage table.  Set
3574          it up.  */
3575
3576       BFD_ASSERT (h->dynindx != -1);
3577
3578       plt_info = elf_m68k_hash_table (info)->plt_info;
3579       splt = bfd_get_section_by_name (dynobj, ".plt");
3580       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3581       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
3582       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3583
3584       /* Get the index in the procedure linkage table which
3585          corresponds to this symbol.  This is the index of this symbol
3586          in all the symbols for which we are making plt entries.  The
3587          first entry in the procedure linkage table is reserved.  */
3588       plt_index = (h->plt.offset / plt_info->size) - 1;
3589
3590       /* Get the offset into the .got table of the entry that
3591          corresponds to this function.  Each .got entry is 4 bytes.
3592          The first three are reserved.  */
3593       got_offset = (plt_index + 3) * 4;
3594
3595       memcpy (splt->contents + h->plt.offset,
3596               plt_info->symbol_entry,
3597               plt_info->size);
3598
3599       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
3600                              (sgot->output_section->vma
3601                               + sgot->output_offset
3602                               + got_offset));
3603
3604       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3605                   splt->contents
3606                   + h->plt.offset
3607                   + plt_info->symbol_resolve_entry + 2);
3608
3609       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
3610                              splt->output_section->vma);
3611
3612       /* Fill in the entry in the global offset table.  */
3613       bfd_put_32 (output_bfd,
3614                   (splt->output_section->vma
3615                    + splt->output_offset
3616                    + h->plt.offset
3617                    + plt_info->symbol_resolve_entry),
3618                   sgot->contents + got_offset);
3619
3620       /* Fill in the entry in the .rela.plt section.  */
3621       rela.r_offset = (sgot->output_section->vma
3622                        + sgot->output_offset
3623                        + got_offset);
3624       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
3625       rela.r_addend = 0;
3626       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
3627       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3628
3629       if (!h->def_regular)
3630         {
3631           /* Mark the symbol as undefined, rather than as defined in
3632              the .plt section.  Leave the value alone.  */
3633           sym->st_shndx = SHN_UNDEF;
3634         }
3635     }
3636
3637   if (elf_m68k_hash_entry (h)->glist != NULL)
3638     {
3639       asection *sgot;
3640       asection *srela;
3641       struct elf_m68k_got_entry *got_entry;
3642
3643       /* This symbol has an entry in the global offset table.  Set it
3644          up.  */
3645
3646       sgot = bfd_get_section_by_name (dynobj, ".got");
3647       srela = bfd_get_section_by_name (dynobj, ".rela.got");
3648       BFD_ASSERT (sgot != NULL && srela != NULL);
3649
3650       got_entry = elf_m68k_hash_entry (h)->glist;
3651
3652       while (got_entry != NULL)
3653         {
3654           Elf_Internal_Rela rela;
3655           bfd_byte *loc;
3656
3657           rela.r_offset = (sgot->output_section->vma
3658                            + sgot->output_offset
3659                            + (got_entry->u.s2.offset &~ (bfd_vma) 1));
3660
3661           /* If this is a -Bsymbolic link, and the symbol is defined
3662              locally, we just want to emit a RELATIVE reloc.  Likewise if
3663              the symbol was forced to be local because of a version file.
3664              The entry in the global offset table will already have been
3665              initialized in the relocate_section function.  */
3666           if (info->shared
3667               && SYMBOL_REFERENCES_LOCAL (info, h))
3668             {
3669               rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3670               rela.r_addend = bfd_get_signed_32 (output_bfd,
3671                                                  (sgot->contents
3672                                                   + (got_entry->u.s2.offset
3673                                                      &~ (bfd_vma) 1)));
3674             }
3675           else
3676             {
3677               bfd_put_32 (output_bfd, (bfd_vma) 0,
3678                           sgot->contents + (got_entry->u.s2.offset
3679                                             &~ (bfd_vma) 1));
3680               rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
3681               rela.r_addend = 0;
3682             }
3683
3684           loc = srela->contents;
3685           loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3686           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3687
3688           got_entry = got_entry->u.s2.next;
3689         }
3690     }
3691
3692   if (h->needs_copy)
3693     {
3694       asection *s;
3695       Elf_Internal_Rela rela;
3696       bfd_byte *loc;
3697
3698       /* This symbol needs a copy reloc.  Set it up.  */
3699
3700       BFD_ASSERT (h->dynindx != -1
3701                   && (h->root.type == bfd_link_hash_defined
3702                       || h->root.type == bfd_link_hash_defweak));
3703
3704       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3705                                    ".rela.bss");
3706       BFD_ASSERT (s != NULL);
3707
3708       rela.r_offset = (h->root.u.def.value
3709                        + h->root.u.def.section->output_section->vma
3710                        + h->root.u.def.section->output_offset);
3711       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
3712       rela.r_addend = 0;
3713       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3714       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3715     }
3716
3717   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3718   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3719       || h == elf_hash_table (info)->hgot)
3720     sym->st_shndx = SHN_ABS;
3721
3722   return TRUE;
3723 }
3724
3725 /* Finish up the dynamic sections.  */
3726
3727 static bfd_boolean
3728 elf_m68k_finish_dynamic_sections (output_bfd, info)
3729      bfd *output_bfd;
3730      struct bfd_link_info *info;
3731 {
3732   bfd *dynobj;
3733   asection *sgot;
3734   asection *sdyn;
3735
3736   dynobj = elf_hash_table (info)->dynobj;
3737
3738   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3739   BFD_ASSERT (sgot != NULL);
3740   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3741
3742   if (elf_hash_table (info)->dynamic_sections_created)
3743     {
3744       asection *splt;
3745       Elf32_External_Dyn *dyncon, *dynconend;
3746
3747       splt = bfd_get_section_by_name (dynobj, ".plt");
3748       BFD_ASSERT (splt != NULL && sdyn != NULL);
3749
3750       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3751       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3752       for (; dyncon < dynconend; dyncon++)
3753         {
3754           Elf_Internal_Dyn dyn;
3755           const char *name;
3756           asection *s;
3757
3758           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3759
3760           switch (dyn.d_tag)
3761             {
3762             default:
3763               break;
3764
3765             case DT_PLTGOT:
3766               name = ".got";
3767               goto get_vma;
3768             case DT_JMPREL:
3769               name = ".rela.plt";
3770             get_vma:
3771               s = bfd_get_section_by_name (output_bfd, name);
3772               BFD_ASSERT (s != NULL);
3773               dyn.d_un.d_ptr = s->vma;
3774               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3775               break;
3776
3777             case DT_PLTRELSZ:
3778               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3779               BFD_ASSERT (s != NULL);
3780               dyn.d_un.d_val = s->size;
3781               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3782               break;
3783
3784             case DT_RELASZ:
3785               /* The procedure linkage table relocs (DT_JMPREL) should
3786                  not be included in the overall relocs (DT_RELA).
3787                  Therefore, we override the DT_RELASZ entry here to
3788                  make it not include the JMPREL relocs.  Since the
3789                  linker script arranges for .rela.plt to follow all
3790                  other relocation sections, we don't have to worry
3791                  about changing the DT_RELA entry.  */
3792               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3793               if (s != NULL)
3794                 dyn.d_un.d_val -= s->size;
3795               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3796               break;
3797             }
3798         }
3799
3800       /* Fill in the first entry in the procedure linkage table.  */
3801       if (splt->size > 0)
3802         {
3803           const struct elf_m68k_plt_info *plt_info;
3804
3805           plt_info = elf_m68k_hash_table (info)->plt_info;
3806           memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
3807
3808           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
3809                                  (sgot->output_section->vma
3810                                   + sgot->output_offset
3811                                   + 4));
3812
3813           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
3814                                  (sgot->output_section->vma
3815                                   + sgot->output_offset
3816                                   + 8));
3817
3818           elf_section_data (splt->output_section)->this_hdr.sh_entsize
3819             = plt_info->size;
3820         }
3821     }
3822
3823   /* Fill in the first three entries in the global offset table.  */
3824   if (sgot->size > 0)
3825     {
3826       if (sdyn == NULL)
3827         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3828       else
3829         bfd_put_32 (output_bfd,
3830                     sdyn->output_section->vma + sdyn->output_offset,
3831                     sgot->contents);
3832       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3833       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3834     }
3835
3836   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3837
3838   return TRUE;
3839 }
3840
3841 /* Given a .data section and a .emreloc in-memory section, store
3842    relocation information into the .emreloc section which can be
3843    used at runtime to relocate the section.  This is called by the
3844    linker when the --embedded-relocs switch is used.  This is called
3845    after the add_symbols entry point has been called for all the
3846    objects, and before the final_link entry point is called.  */
3847
3848 bfd_boolean
3849 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
3850      bfd *abfd;
3851      struct bfd_link_info *info;
3852      asection *datasec;
3853      asection *relsec;
3854      char **errmsg;
3855 {
3856   Elf_Internal_Shdr *symtab_hdr;
3857   Elf_Internal_Sym *isymbuf = NULL;
3858   Elf_Internal_Rela *internal_relocs = NULL;
3859   Elf_Internal_Rela *irel, *irelend;
3860   bfd_byte *p;
3861   bfd_size_type amt;
3862
3863   BFD_ASSERT (! info->relocatable);
3864
3865   *errmsg = NULL;
3866
3867   if (datasec->reloc_count == 0)
3868     return TRUE;
3869
3870   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3871
3872   /* Get a copy of the native relocations.  */
3873   internal_relocs = (_bfd_elf_link_read_relocs
3874                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3875                       info->keep_memory));
3876   if (internal_relocs == NULL)
3877     goto error_return;
3878
3879   amt = (bfd_size_type) datasec->reloc_count * 12;
3880   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
3881   if (relsec->contents == NULL)
3882     goto error_return;
3883
3884   p = relsec->contents;
3885
3886   irelend = internal_relocs + datasec->reloc_count;
3887   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
3888     {
3889       asection *targetsec;
3890
3891       /* We are going to write a four byte longword into the runtime
3892        reloc section.  The longword will be the address in the data
3893        section which must be relocated.  It is followed by the name
3894        of the target section NUL-padded or truncated to 8
3895        characters.  */
3896
3897       /* We can only relocate absolute longword relocs at run time.  */
3898       if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
3899         {
3900           *errmsg = _("unsupported reloc type");
3901           bfd_set_error (bfd_error_bad_value);
3902           goto error_return;
3903         }
3904
3905       /* Get the target section referred to by the reloc.  */
3906       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
3907         {
3908           /* A local symbol.  */
3909           Elf_Internal_Sym *isym;
3910
3911           /* Read this BFD's local symbols if we haven't done so already.  */
3912           if (isymbuf == NULL)
3913             {
3914               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3915               if (isymbuf == NULL)
3916                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3917                                                 symtab_hdr->sh_info, 0,
3918                                                 NULL, NULL, NULL);
3919               if (isymbuf == NULL)
3920                 goto error_return;
3921             }
3922
3923           isym = isymbuf + ELF32_R_SYM (irel->r_info);
3924           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3925         }
3926       else
3927         {
3928           unsigned long indx;
3929           struct elf_link_hash_entry *h;
3930
3931           /* An external symbol.  */
3932           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
3933           h = elf_sym_hashes (abfd)[indx];
3934           BFD_ASSERT (h != NULL);
3935           if (h->root.type == bfd_link_hash_defined
3936               || h->root.type == bfd_link_hash_defweak)
3937             targetsec = h->root.u.def.section;
3938           else
3939             targetsec = NULL;
3940         }
3941
3942       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
3943       memset (p + 4, 0, 8);
3944       if (targetsec != NULL)
3945         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
3946     }
3947
3948   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3949     free (isymbuf);
3950   if (internal_relocs != NULL
3951       && elf_section_data (datasec)->relocs != internal_relocs)
3952     free (internal_relocs);
3953   return TRUE;
3954
3955 error_return:
3956   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3957     free (isymbuf);
3958   if (internal_relocs != NULL
3959       && elf_section_data (datasec)->relocs != internal_relocs)
3960     free (internal_relocs);
3961   return FALSE;
3962 }
3963
3964 /* Set target options.  */
3965
3966 void
3967 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
3968 {
3969   struct elf_m68k_link_hash_table *htab;
3970
3971   htab = elf_m68k_hash_table (info);
3972
3973   switch (got_handling)
3974     {
3975     case 0:
3976       /* --got=single.  */
3977       htab->local_gp_p = FALSE;
3978       htab->use_neg_got_offsets_p = FALSE;
3979       htab->allow_multigot_p = FALSE;
3980       break;
3981
3982     case 1:
3983       /* --got=negative.  */
3984       htab->local_gp_p = TRUE;
3985       htab->use_neg_got_offsets_p = TRUE;
3986       htab->allow_multigot_p = FALSE;
3987       break;
3988
3989     case 2:
3990       /* --got=multigot.  */
3991       htab->local_gp_p = TRUE;
3992       htab->use_neg_got_offsets_p = TRUE;
3993       htab->allow_multigot_p = TRUE;
3994       break;
3995
3996     default:
3997       BFD_ASSERT (FALSE);
3998     }
3999 }
4000
4001 static enum elf_reloc_type_class
4002 elf32_m68k_reloc_type_class (rela)
4003      const Elf_Internal_Rela *rela;
4004 {
4005   switch ((int) ELF32_R_TYPE (rela->r_info))
4006     {
4007     case R_68K_RELATIVE:
4008       return reloc_class_relative;
4009     case R_68K_JMP_SLOT:
4010       return reloc_class_plt;
4011     case R_68K_COPY:
4012       return reloc_class_copy;
4013     default:
4014       return reloc_class_normal;
4015     }
4016 }
4017
4018 /* Return address for Ith PLT stub in section PLT, for relocation REL
4019    or (bfd_vma) -1 if it should not be included.  */
4020
4021 static bfd_vma
4022 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4023                       const arelent *rel ATTRIBUTE_UNUSED)
4024 {
4025   return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4026 }
4027
4028 #define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
4029 #define TARGET_BIG_NAME                 "elf32-m68k"
4030 #define ELF_MACHINE_CODE                EM_68K
4031 #define ELF_MAXPAGESIZE                 0x2000
4032 #define elf_backend_create_dynamic_sections \
4033                                         _bfd_elf_create_dynamic_sections
4034 #define bfd_elf32_bfd_link_hash_table_create \
4035                                         elf_m68k_link_hash_table_create
4036 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create?  */
4037 #define bfd_elf32_bfd_link_hash_table_free \
4038                                         elf_m68k_link_hash_table_free
4039 #define bfd_elf32_bfd_final_link        bfd_elf_final_link
4040
4041 #define elf_backend_check_relocs        elf_m68k_check_relocs
4042 #define elf_backend_always_size_sections \
4043                                         elf_m68k_always_size_sections
4044 #define elf_backend_adjust_dynamic_symbol \
4045                                         elf_m68k_adjust_dynamic_symbol
4046 #define elf_backend_size_dynamic_sections \
4047                                         elf_m68k_size_dynamic_sections
4048 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
4049 #define elf_backend_relocate_section    elf_m68k_relocate_section
4050 #define elf_backend_finish_dynamic_symbol \
4051                                         elf_m68k_finish_dynamic_symbol
4052 #define elf_backend_finish_dynamic_sections \
4053                                         elf_m68k_finish_dynamic_sections
4054 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
4055 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
4056 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4057 #define bfd_elf32_bfd_merge_private_bfd_data \
4058                                         elf32_m68k_merge_private_bfd_data
4059 #define bfd_elf32_bfd_set_private_flags \
4060                                         elf32_m68k_set_private_flags
4061 #define bfd_elf32_bfd_print_private_bfd_data \
4062                                         elf32_m68k_print_private_bfd_data
4063 #define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
4064 #define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
4065 #define elf_backend_object_p            elf32_m68k_object_p
4066
4067 #define elf_backend_can_gc_sections 1
4068 #define elf_backend_can_refcount 1
4069 #define elf_backend_want_got_plt 1
4070 #define elf_backend_plt_readonly 1
4071 #define elf_backend_want_plt_sym 0
4072 #define elf_backend_got_header_size     12
4073 #define elf_backend_rela_normal         1
4074
4075 #include "elf32-target.h"