bfd/elf32-m68k.c

   1 /* Motorola 68k series support for 32-bit ELF
   2    Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/m68k.h"
  27
  28 static reloc_howto_type *reloc_type_lookup
  29   PARAMS ((bfd *, bfd_reloc_code_real_type));
  30 static void rtype_to_howto
  31   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  32 static struct bfd_hash_entry *elf_m68k_link_hash_newfunc
  33   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  34 static struct bfd_link_hash_table *elf_m68k_link_hash_table_create
  35   PARAMS ((bfd *));
  36 static bfd_boolean elf_m68k_check_relocs
  37   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  38            const Elf_Internal_Rela *));
  39 static asection *elf_m68k_gc_mark_hook
  40   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  41            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  42 static bfd_boolean elf_m68k_gc_sweep_hook
  43   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  44            const Elf_Internal_Rela *));
  45 static bfd_boolean elf_m68k_adjust_dynamic_symbol
  46   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  47 static bfd_boolean elf_m68k_size_dynamic_sections
  48   PARAMS ((bfd *, struct bfd_link_info *));
  49 static bfd_boolean elf_m68k_relocate_section
  50   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  51            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  52 static bfd_boolean elf_m68k_finish_dynamic_symbol
  53   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  54            Elf_Internal_Sym *));
  55 static bfd_boolean elf_m68k_finish_dynamic_sections
  56   PARAMS ((bfd *, struct bfd_link_info *));
  57
  58 static bfd_boolean elf32_m68k_set_private_flags
  59   PARAMS ((bfd *, flagword));
  60 static bfd_boolean elf32_m68k_merge_private_bfd_data
  61   PARAMS ((bfd *, bfd *));
  62 static bfd_boolean elf32_m68k_print_private_bfd_data
  63   PARAMS ((bfd *, PTR));
  64 static enum elf_reloc_type_class elf32_m68k_reloc_type_class
  65   PARAMS ((const Elf_Internal_Rela *));
  66
  67 static reloc_howto_type howto_table[] = {
  68   HOWTO(R_68K_NONE,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_NONE",      FALSE, 0, 0x00000000,FALSE),
  69   HOWTO(R_68K_32,         0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32",        FALSE, 0, 0xffffffff,FALSE),
  70   HOWTO(R_68K_16,         0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16",        FALSE, 0, 0x0000ffff,FALSE),
  71   HOWTO(R_68K_8,          0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8",         FALSE, 0, 0x000000ff,FALSE),
  72   HOWTO(R_68K_PC32,       0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32",      FALSE, 0, 0xffffffff,TRUE),
  73   HOWTO(R_68K_PC16,       0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC16",      FALSE, 0, 0x0000ffff,TRUE),
  74   HOWTO(R_68K_PC8,        0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC8",       FALSE, 0, 0x000000ff,TRUE),
  75   HOWTO(R_68K_GOT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32",     FALSE, 0, 0xffffffff,TRUE),
  76   HOWTO(R_68K_GOT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16",     FALSE, 0, 0x0000ffff,TRUE),
  77   HOWTO(R_68K_GOT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8",      FALSE, 0, 0x000000ff,TRUE),
  78   HOWTO(R_68K_GOT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O",    FALSE, 0, 0xffffffff,FALSE),
  79   HOWTO(R_68K_GOT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16O",    FALSE, 0, 0x0000ffff,FALSE),
  80   HOWTO(R_68K_GOT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8O",     FALSE, 0, 0x000000ff,FALSE),
  81   HOWTO(R_68K_PLT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32",     FALSE, 0, 0xffffffff,TRUE),
  82   HOWTO(R_68K_PLT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16",     FALSE, 0, 0x0000ffff,TRUE),
  83   HOWTO(R_68K_PLT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8",      FALSE, 0, 0x000000ff,TRUE),
  84   HOWTO(R_68K_PLT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O",    FALSE, 0, 0xffffffff,FALSE),
  85   HOWTO(R_68K_PLT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16O",    FALSE, 0, 0x0000ffff,FALSE),
  86   HOWTO(R_68K_PLT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8O",     FALSE, 0, 0x000000ff,FALSE),
  87   HOWTO(R_68K_COPY,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_COPY",      FALSE, 0, 0xffffffff,FALSE),
  88   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),
  89   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),
  90   HOWTO(R_68K_RELATIVE,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_RELATIVE",  FALSE, 0, 0xffffffff,FALSE),
  91   /* GNU extension to record C++ vtable hierarchy */
  92   HOWTO (R_68K_GNU_VTINHERIT,   /* type */
  93          0,                     /* rightshift */
  94          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  95          0,                     /* bitsize */
  96          FALSE,                 /* pc_relative */
  97          0,                     /* bitpos */
  98          complain_overflow_dont, /* complain_on_overflow */
  99          NULL,                  /* special_function */
 100          "R_68K_GNU_VTINHERIT", /* name */
 101          FALSE,                 /* partial_inplace */
 102          0,                     /* src_mask */
 103          0,                     /* dst_mask */
 104          FALSE),
 105   /* GNU extension to record C++ vtable member usage */
 106   HOWTO (R_68K_GNU_VTENTRY,     /* type */
 107          0,                     /* rightshift */
 108          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 109          0,                     /* bitsize */
 110          FALSE,                 /* pc_relative */
 111          0,                     /* bitpos */
 112          complain_overflow_dont, /* complain_on_overflow */
 113          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 114          "R_68K_GNU_VTENTRY",   /* name */
 115          FALSE,                 /* partial_inplace */
 116          0,                     /* src_mask */
 117          0,                     /* dst_mask */
 118          FALSE),
 119 };
 120
 121 static void
 122 rtype_to_howto (abfd, cache_ptr, dst)
 123      bfd *abfd ATTRIBUTE_UNUSED;
 124      arelent *cache_ptr;
 125      Elf_Internal_Rela *dst;
 126 {
 127   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_68K_max);
 128   cache_ptr->howto = &howto_table[ELF32_R_TYPE(dst->r_info)];
 129 }
 130
 131 #define elf_info_to_howto rtype_to_howto
 132
 133 static const struct
 134 {
 135   bfd_reloc_code_real_type bfd_val;
 136   int elf_val;
 137 } reloc_map[] = {
 138   { BFD_RELOC_NONE, R_68K_NONE },
 139   { BFD_RELOC_32, R_68K_32 },
 140   { BFD_RELOC_16, R_68K_16 },
 141   { BFD_RELOC_8, R_68K_8 },
 142   { BFD_RELOC_32_PCREL, R_68K_PC32 },
 143   { BFD_RELOC_16_PCREL, R_68K_PC16 },
 144   { BFD_RELOC_8_PCREL, R_68K_PC8 },
 145   { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
 146   { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
 147   { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
 148   { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
 149   { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
 150   { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
 151   { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
 152   { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
 153   { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
 154   { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
 155   { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
 156   { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
 157   { BFD_RELOC_NONE, R_68K_COPY },
 158   { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
 159   { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
 160   { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
 161   { BFD_RELOC_CTOR, R_68K_32 },
 162   { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
 163   { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
 164 };
 165
 166 static reloc_howto_type *
 167 reloc_type_lookup (abfd, code)
 168      bfd *abfd ATTRIBUTE_UNUSED;
 169      bfd_reloc_code_real_type code;
 170 {
 171   unsigned int i;
 172   for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
 173     {
 174       if (reloc_map[i].bfd_val == code)
 175         return &howto_table[reloc_map[i].elf_val];
 176     }
 177   return 0;
 178 }
 179
 180 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
 181 #define ELF_ARCH bfd_arch_m68k
 182 /* end code generated by elf.el */
 183 \f
 184 /* Functions for the m68k ELF linker.  */
 185
 186 /* The name of the dynamic interpreter.  This is put in the .interp
 187    section.  */
 188
 189 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 190
 191 /* The size in bytes of an entry in the procedure linkage table.  */
 192
 193 #define PLT_ENTRY_SIZE 20
 194
 195 /* The first entry in a procedure linkage table looks like this.  See
 196    the SVR4 ABI m68k supplement to see how this works.  */
 197
 198 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
 199 {
 200   0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
 201   0, 0, 0, 0,             /* replaced with offset to .got + 4.  */
 202   0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
 203   0, 0, 0, 0,             /* replaced with offset to .got + 8.  */
 204   0, 0, 0, 0              /* pad out to 20 bytes.  */
 205 };
 206
 207 /* Subsequent entries in a procedure linkage table look like this.  */
 208
 209 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
 210 {
 211   0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
 212   0, 0, 0, 0,             /* replaced with offset to symbol's .got entry.  */
 213   0x2f, 0x3c,             /* move.l #offset,-(%sp) */
 214   0, 0, 0, 0,             /* replaced with offset into relocation table.  */
 215   0x60, 0xff,             /* bra.l .plt */
 216   0, 0, 0, 0              /* replaced with offset to start of .plt.  */
 217 };
 218
 219 #define CPU32_FLAG(abfd)  (elf_elfheader (abfd)->e_flags & EF_CPU32)
 220
 221 #define PLT_CPU32_ENTRY_SIZE 24
 222 /* Procedure linkage table entries for the cpu32 */
 223 static const bfd_byte elf_cpu32_plt0_entry[PLT_CPU32_ENTRY_SIZE] =
 224 {
 225   0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
 226   0, 0, 0, 0,             /* replaced with offset to .got + 4.  */
 227   0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
 228   0, 0, 0, 0,             /* replace with offset to .got +8.  */
 229   0x4e, 0xd1,             /* jmp %a1@ */
 230   0, 0, 0, 0,             /* pad out to 24 bytes.  */
 231   0, 0
 232 };
 233
 234 static const bfd_byte elf_cpu32_plt_entry[PLT_CPU32_ENTRY_SIZE] =
 235 {
 236   0x22, 0x7b, 0x01, 0x70,  /* moveal %pc@(0xc), %a1 */
 237   0, 0, 0, 0,              /* replaced with offset to symbol's .got entry.  */
 238   0x4e, 0xd1,              /* jmp %a1@ */
 239   0x2f, 0x3c,              /* move.l #offset,-(%sp) */
 240   0, 0, 0, 0,              /* replaced with offset into relocation table.  */
 241   0x60, 0xff,              /* bra.l .plt */
 242   0, 0, 0, 0,              /* replaced with offset to start of .plt.  */
 243   0, 0
 244 };
 245
 246 /* The m68k linker needs to keep track of the number of relocs that it
 247    decides to copy in check_relocs for each symbol.  This is so that it
 248    can discard PC relative relocs if it doesn't need them when linking
 249    with -Bsymbolic.  We store the information in a field extending the
 250    regular ELF linker hash table.  */
 251
 252 /* This structure keeps track of the number of PC relative relocs we have
 253    copied for a given symbol.  */
 254
 255 struct elf_m68k_pcrel_relocs_copied
 256 {
 257   /* Next section.  */
 258   struct elf_m68k_pcrel_relocs_copied *next;
 259   /* A section in dynobj.  */
 260   asection *section;
 261   /* Number of relocs copied in this section.  */
 262   bfd_size_type count;
 263 };
 264
 265 /* m68k ELF linker hash entry.  */
 266
 267 struct elf_m68k_link_hash_entry
 268 {
 269   struct elf_link_hash_entry root;
 270
 271   /* Number of PC relative relocs copied for this symbol.  */
 272   struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
 273 };
 274
 275 /* m68k ELF linker hash table.  */
 276
 277 struct elf_m68k_link_hash_table
 278 {
 279   struct elf_link_hash_table root;
 280 };
 281
 282 /* Declare this now that the above structures are defined.  */
 283
 284 static bfd_boolean elf_m68k_discard_copies
 285   PARAMS ((struct elf_m68k_link_hash_entry *, PTR));
 286
 287 /* Traverse an m68k ELF linker hash table.  */
 288
 289 #define elf_m68k_link_hash_traverse(table, func, info)                  \
 290   (elf_link_hash_traverse                                               \
 291    (&(table)->root,                                                     \
 292     (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
 293     (info)))
 294
 295 /* Get the m68k ELF linker hash table from a link_info structure.  */
 296
 297 #define elf_m68k_hash_table(p) \
 298   ((struct elf_m68k_link_hash_table *) (p)->hash)
 299
 300 /* Create an entry in an m68k ELF linker hash table.  */
 301
 302 static struct bfd_hash_entry *
 303 elf_m68k_link_hash_newfunc (entry, table, string)
 304      struct bfd_hash_entry *entry;
 305      struct bfd_hash_table *table;
 306      const char *string;
 307 {
 308   struct elf_m68k_link_hash_entry *ret =
 309     (struct elf_m68k_link_hash_entry *) entry;
 310
 311   /* Allocate the structure if it has not already been allocated by a
 312      subclass.  */
 313   if (ret == (struct elf_m68k_link_hash_entry *) NULL)
 314     ret = ((struct elf_m68k_link_hash_entry *)
 315            bfd_hash_allocate (table,
 316                               sizeof (struct elf_m68k_link_hash_entry)));
 317   if (ret == (struct elf_m68k_link_hash_entry *) NULL)
 318     return (struct bfd_hash_entry *) ret;
 319
 320   /* Call the allocation method of the superclass.  */
 321   ret = ((struct elf_m68k_link_hash_entry *)
 322          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 323                                      table, string));
 324   if (ret != (struct elf_m68k_link_hash_entry *) NULL)
 325     {
 326       ret->pcrel_relocs_copied = NULL;
 327     }
 328
 329   return (struct bfd_hash_entry *) ret;
 330 }
 331
 332 /* Create an m68k ELF linker hash table.  */
 333
 334 static struct bfd_link_hash_table *
 335 elf_m68k_link_hash_table_create (abfd)
 336      bfd *abfd;
 337 {
 338   struct elf_m68k_link_hash_table *ret;
 339   bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
 340
 341   ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
 342   if (ret == (struct elf_m68k_link_hash_table *) NULL)
 343     return NULL;
 344
 345   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
 346                                        elf_m68k_link_hash_newfunc))
 347     {
 348       free (ret);
 349       return NULL;
 350     }
 351
 352   return &ret->root.root;
 353 }
 354
 355 /* Keep m68k-specific flags in the ELF header */
 356 static bfd_boolean
 357 elf32_m68k_set_private_flags (abfd, flags)
 358      bfd *abfd;
 359      flagword flags;
 360 {
 361   elf_elfheader (abfd)->e_flags = flags;
 362   elf_flags_init (abfd) = TRUE;
 363   return TRUE;
 364 }
 365
 366 /* Merge backend specific data from an object file to the output
 367    object file when linking.  */
 368 static bfd_boolean
 369 elf32_m68k_merge_private_bfd_data (ibfd, obfd)
 370      bfd *ibfd;
 371      bfd *obfd;
 372 {
 373   flagword out_flags;
 374   flagword in_flags;
 375
 376   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 377       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 378     return TRUE;
 379
 380   in_flags  = elf_elfheader (ibfd)->e_flags;
 381   out_flags = elf_elfheader (obfd)->e_flags;
 382
 383   if (!elf_flags_init (obfd))
 384     {
 385       elf_flags_init (obfd) = TRUE;
 386       elf_elfheader (obfd)->e_flags = in_flags;
 387     }
 388
 389   return TRUE;
 390 }
 391
 392 /* Display the flags field */
 393 static bfd_boolean
 394 elf32_m68k_print_private_bfd_data (abfd, ptr)
 395      bfd *abfd;
 396      PTR ptr;
 397 {
 398   FILE *file = (FILE *) ptr;
 399
 400   BFD_ASSERT (abfd != NULL && ptr != NULL);
 401
 402   /* Print normal ELF private data.  */
 403   _bfd_elf_print_private_bfd_data (abfd, ptr);
 404
 405   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
 406
 407   /* xgettext:c-format */
 408   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
 409
 410   if (elf_elfheader (abfd)->e_flags & EF_CPU32)
 411     fprintf (file, _(" [cpu32]"));
 412
 413   if (elf_elfheader (abfd)->e_flags & EF_M68000)
 414     fprintf (file, _(" [m68000]"));
 415
 416   fputc ('\n', file);
 417
 418   return TRUE;
 419 }
 420 /* Look through the relocs for a section during the first phase, and
 421    allocate space in the global offset table or procedure linkage
 422    table.  */
 423
 424 static bfd_boolean
 425 elf_m68k_check_relocs (abfd, info, sec, relocs)
 426      bfd *abfd;
 427      struct bfd_link_info *info;
 428      asection *sec;
 429      const Elf_Internal_Rela *relocs;
 430 {
 431   bfd *dynobj;
 432   Elf_Internal_Shdr *symtab_hdr;
 433   struct elf_link_hash_entry **sym_hashes;
 434   bfd_signed_vma *local_got_refcounts;
 435   const Elf_Internal_Rela *rel;
 436   const Elf_Internal_Rela *rel_end;
 437   asection *sgot;
 438   asection *srelgot;
 439   asection *sreloc;
 440
 441   if (info->relocateable)
 442     return TRUE;
 443
 444   dynobj = elf_hash_table (info)->dynobj;
 445   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 446   sym_hashes = elf_sym_hashes (abfd);
 447   local_got_refcounts = elf_local_got_refcounts (abfd);
 448
 449   sgot = NULL;
 450   srelgot = NULL;
 451   sreloc = NULL;
 452
 453   rel_end = relocs + sec->reloc_count;
 454   for (rel = relocs; rel < rel_end; rel++)
 455     {
 456       unsigned long r_symndx;
 457       struct elf_link_hash_entry *h;
 458
 459       r_symndx = ELF32_R_SYM (rel->r_info);
 460
 461       if (r_symndx < symtab_hdr->sh_info)
 462         h = NULL;
 463       else
 464         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 465
 466       switch (ELF32_R_TYPE (rel->r_info))
 467         {
 468         case R_68K_GOT8:
 469         case R_68K_GOT16:
 470         case R_68K_GOT32:
 471           if (h != NULL
 472               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
 473             break;
 474           /* Fall through.  */
 475         case R_68K_GOT8O:
 476         case R_68K_GOT16O:
 477         case R_68K_GOT32O:
 478           /* This symbol requires a global offset table entry.  */
 479
 480           if (dynobj == NULL)
 481             {
 482               /* Create the .got section.  */
 483               elf_hash_table (info)->dynobj = dynobj = abfd;
 484               if (!_bfd_elf_create_got_section (dynobj, info))
 485                 return FALSE;
 486             }
 487
 488           if (sgot == NULL)
 489             {
 490               sgot = bfd_get_section_by_name (dynobj, ".got");
 491               BFD_ASSERT (sgot != NULL);
 492             }
 493
 494           if (srelgot == NULL
 495               && (h != NULL || info->shared))
 496             {
 497               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 498               if (srelgot == NULL)
 499                 {
 500                   srelgot = bfd_make_section (dynobj, ".rela.got");
 501                   if (srelgot == NULL
 502                       || !bfd_set_section_flags (dynobj, srelgot,
 503                                                  (SEC_ALLOC
 504                                                   | SEC_LOAD
 505                                                   | SEC_HAS_CONTENTS
 506                                                   | SEC_IN_MEMORY
 507                                                   | SEC_LINKER_CREATED
 508                                                   | SEC_READONLY))
 509                       || !bfd_set_section_alignment (dynobj, srelgot, 2))
 510                     return FALSE;
 511                 }
 512             }
 513
 514           if (h != NULL)
 515             {
 516               if (h->got.refcount == 0)
 517                 {
 518                   /* Make sure this symbol is output as a dynamic symbol.  */
 519                   if (h->dynindx == -1)
 520                     {
 521                       if (!bfd_elf32_link_record_dynamic_symbol (info, h))
 522                         return FALSE;
 523                     }
 524
 525                   /* Allocate space in the .got section.  */
 526                   sgot->_raw_size += 4;
 527                   /* Allocate relocation space.  */
 528                   srelgot->_raw_size += sizeof (Elf32_External_Rela);
 529                 }
 530               h->got.refcount++;
 531             }
 532           else
 533             {
 534               /* This is a global offset table entry for a local symbol.  */
 535               if (local_got_refcounts == NULL)
 536                 {
 537                   bfd_size_type size;
 538
 539                   size = symtab_hdr->sh_info;
 540                   size *= sizeof (bfd_signed_vma);
 541                   local_got_refcounts = ((bfd_signed_vma *)
 542                                          bfd_zalloc (abfd, size));
 543                   if (local_got_refcounts == NULL)
 544                     return FALSE;
 545                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 546                 }
 547               if (local_got_refcounts[r_symndx] == 0)
 548                 {
 549                   sgot->_raw_size += 4;
 550                   if (info->shared)
 551                     {
 552                       /* If we are generating a shared object, we need to
 553                          output a R_68K_RELATIVE reloc so that the dynamic
 554                          linker can adjust this GOT entry.  */
 555                       srelgot->_raw_size += sizeof (Elf32_External_Rela);
 556                     }
 557                 }
 558               local_got_refcounts[r_symndx]++;
 559             }
 560           break;
 561
 562         case R_68K_PLT8:
 563         case R_68K_PLT16:
 564         case R_68K_PLT32:
 565           /* This symbol requires a procedure linkage table entry.  We
 566              actually build the entry in adjust_dynamic_symbol,
 567              because this might be a case of linking PIC code which is
 568              never referenced by a dynamic object, in which case we
 569              don't need to generate a procedure linkage table entry
 570              after all.  */
 571
 572           /* If this is a local symbol, we resolve it directly without
 573              creating a procedure linkage table entry.  */
 574           if (h == NULL)
 575             continue;
 576
 577           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 578           h->plt.refcount++;
 579           break;
 580
 581         case R_68K_PLT8O:
 582         case R_68K_PLT16O:
 583         case R_68K_PLT32O:
 584           /* This symbol requires a procedure linkage table entry.  */
 585
 586           if (h == NULL)
 587             {
 588               /* It does not make sense to have this relocation for a
 589                  local symbol.  FIXME: does it?  How to handle it if
 590                  it does make sense?  */
 591               bfd_set_error (bfd_error_bad_value);
 592               return FALSE;
 593             }
 594
 595           /* Make sure this symbol is output as a dynamic symbol.  */
 596           if (h->dynindx == -1)
 597             {
 598               if (!bfd_elf32_link_record_dynamic_symbol (info, h))
 599                 return FALSE;
 600             }
 601
 602           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 603           h->plt.refcount++;
 604           break;
 605
 606         case R_68K_PC8:
 607         case R_68K_PC16:
 608         case R_68K_PC32:
 609           /* If we are creating a shared library and this is not a local
 610              symbol, we need to copy the reloc into the shared library.
 611              However when linking with -Bsymbolic and this is a global
 612              symbol which is defined in an object we are including in the
 613              link (i.e., DEF_REGULAR is set), then we can resolve the
 614              reloc directly.  At this point we have not seen all the input
 615              files, so it is possible that DEF_REGULAR is not set now but
 616              will be set later (it is never cleared).  We account for that
 617              possibility below by storing information in the
 618              pcrel_relocs_copied field of the hash table entry.  */
 619           if (!(info->shared
 620                 && (sec->flags & SEC_ALLOC) != 0
 621                 && h != NULL
 622                 && (!info->symbolic
 623                     || (h->elf_link_hash_flags
 624                         & ELF_LINK_HASH_DEF_REGULAR) == 0)))
 625             {
 626               if (h != NULL)
 627                 {
 628                   /* Make sure a plt entry is created for this symbol if
 629                      it turns out to be a function defined by a dynamic
 630                      object.  */
 631                   h->plt.refcount++;
 632                 }
 633               break;
 634             }
 635           /* Fall through.  */
 636         case R_68K_8:
 637         case R_68K_16:
 638         case R_68K_32:
 639           if (h != NULL)
 640             {
 641               /* Make sure a plt entry is created for this symbol if it
 642                  turns out to be a function defined by a dynamic object.  */
 643               h->plt.refcount++;
 644             }
 645
 646           /* If we are creating a shared library, we need to copy the
 647              reloc into the shared library.  */
 648           if (info->shared
 649               && (sec->flags & SEC_ALLOC) != 0)
 650             {
 651               /* When creating a shared object, we must copy these
 652                  reloc types into the output file.  We create a reloc
 653                  section in dynobj and make room for this reloc.  */
 654               if (sreloc == NULL)
 655                 {
 656                   const char *name;
 657
 658                   name = (bfd_elf_string_from_elf_section
 659                           (abfd,
 660                            elf_elfheader (abfd)->e_shstrndx,
 661                            elf_section_data (sec)->rel_hdr.sh_name));
 662                   if (name == NULL)
 663                     return FALSE;
 664
 665                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
 666                               && strcmp (bfd_get_section_name (abfd, sec),
 667                                          name + 5) == 0);
 668
 669                   sreloc = bfd_get_section_by_name (dynobj, name);
 670                   if (sreloc == NULL)
 671                     {
 672                       sreloc = bfd_make_section (dynobj, name);
 673                       if (sreloc == NULL
 674                           || !bfd_set_section_flags (dynobj, sreloc,
 675                                                      (SEC_ALLOC
 676                                                       | SEC_LOAD
 677                                                       | SEC_HAS_CONTENTS
 678                                                       | SEC_IN_MEMORY
 679                                                       | SEC_LINKER_CREATED
 680                                                       | SEC_READONLY))
 681                           || !bfd_set_section_alignment (dynobj, sreloc, 2))
 682                         return FALSE;
 683                     }
 684                   if (sec->flags & SEC_READONLY)
 685                     info->flags |= DF_TEXTREL;
 686                 }
 687
 688               sreloc->_raw_size += sizeof (Elf32_External_Rela);
 689
 690               /* If we are linking with -Bsymbolic, we count the number of
 691                  PC relative relocations we have entered for this symbol,
 692                  so that we can discard them again if the symbol is later
 693                  defined by a regular object.  Note that this function is
 694                  only called if we are using an m68kelf linker hash table,
 695                  which means that h is really a pointer to an
 696                  elf_m68k_link_hash_entry.  */
 697               if ((ELF32_R_TYPE (rel->r_info) == R_68K_PC8
 698                    || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
 699                    || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
 700                   && info->symbolic)
 701                 {
 702                   struct elf_m68k_link_hash_entry *eh;
 703                   struct elf_m68k_pcrel_relocs_copied *p;
 704
 705                   eh = (struct elf_m68k_link_hash_entry *) h;
 706
 707                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
 708                     if (p->section == sreloc)
 709                       break;
 710
 711                   if (p == NULL)
 712                     {
 713                       p = ((struct elf_m68k_pcrel_relocs_copied *)
 714                            bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
 715                       if (p == NULL)
 716                         return FALSE;
 717                       p->next = eh->pcrel_relocs_copied;
 718                       eh->pcrel_relocs_copied = p;
 719                       p->section = sreloc;
 720                       p->count = 0;
 721                     }
 722
 723                   ++p->count;
 724                 }
 725             }
 726
 727           break;
 728
 729           /* This relocation describes the C++ object vtable hierarchy.
 730              Reconstruct it for later use during GC.  */
 731         case R_68K_GNU_VTINHERIT:
 732           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 733             return FALSE;
 734           break;
 735
 736           /* This relocation describes which C++ vtable entries are actually
 737              used.  Record for later use during GC.  */
 738         case R_68K_GNU_VTENTRY:
 739           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 740             return FALSE;
 741           break;
 742
 743         default:
 744           break;
 745         }
 746     }
 747
 748   return TRUE;
 749 }
 750
 751 /* Return the section that should be marked against GC for a given
 752    relocation.  */
 753
 754 static asection *
 755 elf_m68k_gc_mark_hook (sec, info, rel, h, sym)
 756      asection *sec;
 757      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 758      Elf_Internal_Rela *rel;
 759      struct elf_link_hash_entry *h;
 760      Elf_Internal_Sym *sym;
 761 {
 762   if (h != NULL)
 763     {
 764       switch (ELF32_R_TYPE (rel->r_info))
 765         {
 766         case R_68K_GNU_VTINHERIT:
 767         case R_68K_GNU_VTENTRY:
 768           break;
 769
 770         default:
 771           switch (h->root.type)
 772             {
 773             default:
 774               break;
 775
 776             case bfd_link_hash_defined:
 777             case bfd_link_hash_defweak:
 778               return h->root.u.def.section;
 779
 780             case bfd_link_hash_common:
 781               return h->root.u.c.p->section;
 782             }
 783         }
 784     }
 785   else
 786     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 787
 788   return NULL;
 789 }
 790
 791 /* Update the got entry reference counts for the section being removed.  */
 792
 793 static bfd_boolean
 794 elf_m68k_gc_sweep_hook (abfd, info, sec, relocs)
 795      bfd *abfd;
 796      struct bfd_link_info *info;
 797      asection *sec;
 798      const Elf_Internal_Rela *relocs;
 799 {
 800   Elf_Internal_Shdr *symtab_hdr;
 801   struct elf_link_hash_entry **sym_hashes;
 802   bfd_signed_vma *local_got_refcounts;
 803   const Elf_Internal_Rela *rel, *relend;
 804   unsigned long r_symndx;
 805   struct elf_link_hash_entry *h;
 806   bfd *dynobj;
 807   asection *sgot;
 808   asection *srelgot;
 809
 810   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 811   sym_hashes = elf_sym_hashes (abfd);
 812   local_got_refcounts = elf_local_got_refcounts (abfd);
 813
 814   dynobj = elf_hash_table (info)->dynobj;
 815   if (dynobj == NULL)
 816     return TRUE;
 817
 818   sgot = bfd_get_section_by_name (dynobj, ".got");
 819   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 820
 821   relend = relocs + sec->reloc_count;
 822   for (rel = relocs; rel < relend; rel++)
 823     {
 824       switch (ELF32_R_TYPE (rel->r_info))
 825         {
 826         case R_68K_GOT8:
 827         case R_68K_GOT16:
 828         case R_68K_GOT32:
 829         case R_68K_GOT8O:
 830         case R_68K_GOT16O:
 831         case R_68K_GOT32O:
 832           r_symndx = ELF32_R_SYM (rel->r_info);
 833           if (r_symndx >= symtab_hdr->sh_info)
 834             {
 835               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 836               if (h->got.refcount > 0)
 837                 {
 838                   --h->got.refcount;
 839                   if (h->got.refcount == 0)
 840                     {
 841                       /* We don't need the .got entry any more.  */
 842                       sgot->_raw_size -= 4;
 843                       srelgot->_raw_size -= sizeof (Elf32_External_Rela);
 844                     }
 845                 }
 846             }
 847           else if (local_got_refcounts != NULL)
 848             {
 849               if (local_got_refcounts[r_symndx] > 0)
 850                 {
 851                   --local_got_refcounts[r_symndx];
 852                   if (local_got_refcounts[r_symndx] == 0)
 853                     {
 854                       /* We don't need the .got entry any more.  */
 855                       sgot->_raw_size -= 4;
 856                       if (info->shared)
 857                         srelgot->_raw_size -= sizeof (Elf32_External_Rela);
 858                     }
 859                 }
 860             }
 861           break;
 862
 863         case R_68K_PLT8:
 864         case R_68K_PLT16:
 865         case R_68K_PLT32:
 866         case R_68K_PLT8O:
 867         case R_68K_PLT16O:
 868         case R_68K_PLT32O:
 869         case R_68K_PC8:
 870         case R_68K_PC16:
 871         case R_68K_PC32:
 872         case R_68K_8:
 873         case R_68K_16:
 874         case R_68K_32:
 875           r_symndx = ELF32_R_SYM (rel->r_info);
 876           if (r_symndx >= symtab_hdr->sh_info)
 877             {
 878               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 879               if (h->plt.refcount > 0)
 880                 --h->plt.refcount;
 881             }
 882           break;
 883
 884         default:
 885           break;
 886         }
 887     }
 888
 889   return TRUE;
 890 }
 891
 892 /* Adjust a symbol defined by a dynamic object and referenced by a
 893    regular object.  The current definition is in some section of the
 894    dynamic object, but we're not including those sections.  We have to
 895    change the definition to something the rest of the link can
 896    understand.  */
 897
 898 static bfd_boolean
 899 elf_m68k_adjust_dynamic_symbol (info, h)
 900      struct bfd_link_info *info;
 901      struct elf_link_hash_entry *h;
 902 {
 903   bfd *dynobj;
 904   asection *s;
 905   unsigned int power_of_two;
 906
 907   dynobj = elf_hash_table (info)->dynobj;
 908
 909   /* Make sure we know what is going on here.  */
 910   BFD_ASSERT (dynobj != NULL
 911               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 912                   || h->weakdef != NULL
 913                   || ((h->elf_link_hash_flags
 914                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 915                       && (h->elf_link_hash_flags
 916                           & ELF_LINK_HASH_REF_REGULAR) != 0
 917                       && (h->elf_link_hash_flags
 918                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 919
 920   /* If this is a function, put it in the procedure linkage table.  We
 921      will fill in the contents of the procedure linkage table later,
 922      when we know the address of the .got section.  */
 923   if (h->type == STT_FUNC
 924       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 925     {
 926       if (! info->shared
 927           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
 928           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
 929           /* We must always create the plt entry if it was referenced
 930              by a PLTxxO relocation.  In this case we already recorded
 931              it as a dynamic symbol.  */
 932           && h->dynindx == -1)
 933         {
 934           /* This case can occur if we saw a PLTxx reloc in an input
 935              file, but the symbol was never referred to by a dynamic
 936              object.  In such a case, we don't actually need to build
 937              a procedure linkage table, and we can just do a PCxx
 938              reloc instead.  */
 939           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
 940           h->plt.offset = (bfd_vma) -1;
 941           return TRUE;
 942         }
 943
 944       /* GC may have rendered this entry unused.  */
 945       if (h->plt.refcount <= 0)
 946         {
 947           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 948           h->plt.offset = (bfd_vma) -1;
 949           return TRUE;
 950         }
 951
 952       /* Make sure this symbol is output as a dynamic symbol.  */
 953       if (h->dynindx == -1)
 954         {
 955           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 956             return FALSE;
 957         }
 958
 959       s = bfd_get_section_by_name (dynobj, ".plt");
 960       BFD_ASSERT (s != NULL);
 961
 962       /* If this is the first .plt entry, make room for the special
 963          first entry.  */
 964       if (s->_raw_size == 0)
 965         {
 966           if (CPU32_FLAG (dynobj))
 967             s->_raw_size += PLT_CPU32_ENTRY_SIZE;
 968           else
 969             s->_raw_size += PLT_ENTRY_SIZE;
 970         }
 971
 972       /* If this symbol is not defined in a regular file, and we are
 973          not generating a shared library, then set the symbol to this
 974          location in the .plt.  This is required to make function
 975          pointers compare as equal between the normal executable and
 976          the shared library.  */
 977       if (!info->shared
 978           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 979         {
 980           h->root.u.def.section = s;
 981           h->root.u.def.value = s->_raw_size;
 982         }
 983
 984       h->plt.offset = s->_raw_size;
 985
 986       /* Make room for this entry.  */
 987       if (CPU32_FLAG (dynobj))
 988         s->_raw_size += PLT_CPU32_ENTRY_SIZE;
 989       else
 990         s->_raw_size += PLT_ENTRY_SIZE;
 991
 992       /* We also need to make an entry in the .got.plt section, which
 993          will be placed in the .got section by the linker script.  */
 994
 995       s = bfd_get_section_by_name (dynobj, ".got.plt");
 996       BFD_ASSERT (s != NULL);
 997       s->_raw_size += 4;
 998
 999       /* We also need to make an entry in the .rela.plt section.  */
1000
1001       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1002       BFD_ASSERT (s != NULL);
1003       s->_raw_size += sizeof (Elf32_External_Rela);
1004
1005       return TRUE;
1006     }
1007
1008   /* Reinitialize the plt offset now that it is not used as a reference
1009      count any more.  */
1010   h->plt.offset = (bfd_vma) -1;
1011
1012   /* If this is a weak symbol, and there is a real definition, the
1013      processor independent code will have arranged for us to see the
1014      real definition first, and we can just use the same value.  */
1015   if (h->weakdef != NULL)
1016     {
1017       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1018                   || h->weakdef->root.type == bfd_link_hash_defweak);
1019       h->root.u.def.section = h->weakdef->root.u.def.section;
1020       h->root.u.def.value = h->weakdef->root.u.def.value;
1021       return TRUE;
1022     }
1023
1024   /* This is a reference to a symbol defined by a dynamic object which
1025      is not a function.  */
1026
1027   /* If we are creating a shared library, we must presume that the
1028      only references to the symbol are via the global offset table.
1029      For such cases we need not do anything here; the relocations will
1030      be handled correctly by relocate_section.  */
1031   if (info->shared)
1032     return TRUE;
1033
1034   /* We must allocate the symbol in our .dynbss section, which will
1035      become part of the .bss section of the executable.  There will be
1036      an entry for this symbol in the .dynsym section.  The dynamic
1037      object will contain position independent code, so all references
1038      from the dynamic object to this symbol will go through the global
1039      offset table.  The dynamic linker will use the .dynsym entry to
1040      determine the address it must put in the global offset table, so
1041      both the dynamic object and the regular object will refer to the
1042      same memory location for the variable.  */
1043
1044   s = bfd_get_section_by_name (dynobj, ".dynbss");
1045   BFD_ASSERT (s != NULL);
1046
1047   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1048      copy the initial value out of the dynamic object and into the
1049      runtime process image.  We need to remember the offset into the
1050      .rela.bss section we are going to use.  */
1051   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1052     {
1053       asection *srel;
1054
1055       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1056       BFD_ASSERT (srel != NULL);
1057       srel->_raw_size += sizeof (Elf32_External_Rela);
1058       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1059     }
1060
1061   /* We need to figure out the alignment required for this symbol.  I
1062      have no idea how ELF linkers handle this.  */
1063   power_of_two = bfd_log2 (h->size);
1064   if (power_of_two > 3)
1065     power_of_two = 3;
1066
1067   /* Apply the required alignment.  */
1068   s->_raw_size = BFD_ALIGN (s->_raw_size,
1069                             (bfd_size_type) (1 << power_of_two));
1070   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1071     {
1072       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1073         return FALSE;
1074     }
1075
1076   /* Define the symbol as being at this point in the section.  */
1077   h->root.u.def.section = s;
1078   h->root.u.def.value = s->_raw_size;
1079
1080   /* Increment the section size to make room for the symbol.  */
1081   s->_raw_size += h->size;
1082
1083   return TRUE;
1084 }
1085
1086 /* Set the sizes of the dynamic sections.  */
1087
1088 static bfd_boolean
1089 elf_m68k_size_dynamic_sections (output_bfd, info)
1090      bfd *output_bfd ATTRIBUTE_UNUSED;
1091      struct bfd_link_info *info;
1092 {
1093   bfd *dynobj;
1094   asection *s;
1095   bfd_boolean plt;
1096   bfd_boolean relocs;
1097
1098   dynobj = elf_hash_table (info)->dynobj;
1099   BFD_ASSERT (dynobj != NULL);
1100
1101   if (elf_hash_table (info)->dynamic_sections_created)
1102     {
1103       /* Set the contents of the .interp section to the interpreter.  */
1104       if (!info->shared)
1105         {
1106           s = bfd_get_section_by_name (dynobj, ".interp");
1107           BFD_ASSERT (s != NULL);
1108           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1109           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1110         }
1111     }
1112   else
1113     {
1114       /* We may have created entries in the .rela.got section.
1115          However, if we are not creating the dynamic sections, we will
1116          not actually use these entries.  Reset the size of .rela.got,
1117          which will cause it to get stripped from the output file
1118          below.  */
1119       s = bfd_get_section_by_name (dynobj, ".rela.got");
1120       if (s != NULL)
1121         s->_raw_size = 0;
1122     }
1123
1124   /* If this is a -Bsymbolic shared link, then we need to discard all PC
1125      relative relocs against symbols defined in a regular object.  We
1126      allocated space for them in the check_relocs routine, but we will not
1127      fill them in in the relocate_section routine.  */
1128   if (info->shared && info->symbolic)
1129     elf_m68k_link_hash_traverse (elf_m68k_hash_table (info),
1130                                  elf_m68k_discard_copies,
1131                                  (PTR) NULL);
1132
1133   /* The check_relocs and adjust_dynamic_symbol entry points have
1134      determined the sizes of the various dynamic sections.  Allocate
1135      memory for them.  */
1136   plt = FALSE;
1137   relocs = FALSE;
1138   for (s = dynobj->sections; s != NULL; s = s->next)
1139     {
1140       const char *name;
1141       bfd_boolean strip;
1142
1143       if ((s->flags & SEC_LINKER_CREATED) == 0)
1144         continue;
1145
1146       /* It's OK to base decisions on the section name, because none
1147          of the dynobj section names depend upon the input files.  */
1148       name = bfd_get_section_name (dynobj, s);
1149
1150       strip = FALSE;
1151
1152       if (strcmp (name, ".plt") == 0)
1153         {
1154           if (s->_raw_size == 0)
1155             {
1156               /* Strip this section if we don't need it; see the
1157                  comment below.  */
1158               strip = TRUE;
1159             }
1160           else
1161             {
1162               /* Remember whether there is a PLT.  */
1163               plt = TRUE;
1164             }
1165         }
1166       else if (strncmp (name, ".rela", 5) == 0)
1167         {
1168           if (s->_raw_size == 0)
1169             {
1170               /* If we don't need this section, strip it from the
1171                  output file.  This is mostly to handle .rela.bss and
1172                  .rela.plt.  We must create both sections in
1173                  create_dynamic_sections, because they must be created
1174                  before the linker maps input sections to output
1175                  sections.  The linker does that before
1176                  adjust_dynamic_symbol is called, and it is that
1177                  function which decides whether anything needs to go
1178                  into these sections.  */
1179               strip = TRUE;
1180             }
1181           else
1182             {
1183               relocs = TRUE;
1184
1185               /* We use the reloc_count field as a counter if we need
1186                  to copy relocs into the output file.  */
1187               s->reloc_count = 0;
1188             }
1189         }
1190       else if (strncmp (name, ".got", 4) != 0)
1191         {
1192           /* It's not one of our sections, so don't allocate space.  */
1193           continue;
1194         }
1195
1196       if (strip)
1197         {
1198           _bfd_strip_section_from_output (info, s);
1199           continue;
1200         }
1201
1202       /* Allocate memory for the section contents.  */
1203       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1204          Unused entries should be reclaimed before the section's contents
1205          are written out, but at the moment this does not happen.  Thus in
1206          order to prevent writing out garbage, we initialise the section's
1207          contents to zero.  */
1208       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1209       if (s->contents == NULL && s->_raw_size != 0)
1210         return FALSE;
1211     }
1212
1213   if (elf_hash_table (info)->dynamic_sections_created)
1214     {
1215       /* Add some entries to the .dynamic section.  We fill in the
1216          values later, in elf_m68k_finish_dynamic_sections, but we
1217          must add the entries now so that we get the correct size for
1218          the .dynamic section.  The DT_DEBUG entry is filled in by the
1219          dynamic linker and used by the debugger.  */
1220 #define add_dynamic_entry(TAG, VAL) \
1221   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1222
1223       if (!info->shared)
1224         {
1225           if (!add_dynamic_entry (DT_DEBUG, 0))
1226             return FALSE;
1227         }
1228
1229       if (plt)
1230         {
1231           if (!add_dynamic_entry (DT_PLTGOT, 0)
1232               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1233               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1234               || !add_dynamic_entry (DT_JMPREL, 0))
1235             return FALSE;
1236         }
1237
1238       if (relocs)
1239         {
1240           if (!add_dynamic_entry (DT_RELA, 0)
1241               || !add_dynamic_entry (DT_RELASZ, 0)
1242               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1243             return FALSE;
1244         }
1245
1246       if ((info->flags & DF_TEXTREL) != 0)
1247         {
1248           if (!add_dynamic_entry (DT_TEXTREL, 0))
1249             return FALSE;
1250         }
1251     }
1252 #undef add_dynamic_entry
1253
1254   return TRUE;
1255 }
1256
1257 /* This function is called via elf_m68k_link_hash_traverse if we are
1258    creating a shared object with -Bsymbolic.  It discards the space
1259    allocated to copy PC relative relocs against symbols which are defined
1260    in regular objects.  We allocated space for them in the check_relocs
1261    routine, but we won't fill them in in the relocate_section routine.  */
1262
1263 static bfd_boolean
1264 elf_m68k_discard_copies (h, ignore)
1265      struct elf_m68k_link_hash_entry *h;
1266      PTR ignore ATTRIBUTE_UNUSED;
1267 {
1268   struct elf_m68k_pcrel_relocs_copied *s;
1269
1270   if (h->root.root.type == bfd_link_hash_warning)
1271     h = (struct elf_m68k_link_hash_entry *) h->root.root.u.i.link;
1272
1273   /* We only discard relocs for symbols defined in a regular object.  */
1274   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1275     return TRUE;
1276
1277   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1278     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
1279
1280   return TRUE;
1281 }
1282
1283 /* Relocate an M68K ELF section.  */
1284
1285 static bfd_boolean
1286 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1287                            contents, relocs, local_syms, local_sections)
1288      bfd *output_bfd;
1289      struct bfd_link_info *info;
1290      bfd *input_bfd;
1291      asection *input_section;
1292      bfd_byte *contents;
1293      Elf_Internal_Rela *relocs;
1294      Elf_Internal_Sym *local_syms;
1295      asection **local_sections;
1296 {
1297   bfd *dynobj;
1298   Elf_Internal_Shdr *symtab_hdr;
1299   struct elf_link_hash_entry **sym_hashes;
1300   bfd_vma *local_got_offsets;
1301   asection *sgot;
1302   asection *splt;
1303   asection *sreloc;
1304   Elf_Internal_Rela *rel;
1305   Elf_Internal_Rela *relend;
1306
1307   if (info->relocateable)
1308     return TRUE;
1309
1310   dynobj = elf_hash_table (info)->dynobj;
1311   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1312   sym_hashes = elf_sym_hashes (input_bfd);
1313   local_got_offsets = elf_local_got_offsets (input_bfd);
1314
1315   sgot = NULL;
1316   splt = NULL;
1317   sreloc = NULL;
1318
1319   rel = relocs;
1320   relend = relocs + input_section->reloc_count;
1321   for (; rel < relend; rel++)
1322     {
1323       int r_type;
1324       reloc_howto_type *howto;
1325       unsigned long r_symndx;
1326       struct elf_link_hash_entry *h;
1327       Elf_Internal_Sym *sym;
1328       asection *sec;
1329       bfd_vma relocation;
1330       bfd_reloc_status_type r;
1331
1332       r_type = ELF32_R_TYPE (rel->r_info);
1333       if (r_type < 0 || r_type >= (int) R_68K_max)
1334         {
1335           bfd_set_error (bfd_error_bad_value);
1336           return FALSE;
1337         }
1338       howto = howto_table + r_type;
1339
1340       r_symndx = ELF32_R_SYM (rel->r_info);
1341
1342       h = NULL;
1343       sym = NULL;
1344       sec = NULL;
1345       if (r_symndx < symtab_hdr->sh_info)
1346         {
1347           sym = local_syms + r_symndx;
1348           sec = local_sections[r_symndx];
1349           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1350         }
1351       else
1352         {
1353           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1354           while (h->root.type == bfd_link_hash_indirect
1355                  || h->root.type == bfd_link_hash_warning)
1356             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1357           if (h->root.type == bfd_link_hash_defined
1358               || h->root.type == bfd_link_hash_defweak)
1359             {
1360               sec = h->root.u.def.section;
1361               if (((r_type == R_68K_PLT8
1362                     || r_type == R_68K_PLT16
1363                     || r_type == R_68K_PLT32
1364                     || r_type == R_68K_PLT8O
1365                     || r_type == R_68K_PLT16O
1366                     || r_type == R_68K_PLT32O)
1367                    && h->plt.offset != (bfd_vma) -1
1368                    && elf_hash_table (info)->dynamic_sections_created)
1369                   || ((r_type == R_68K_GOT8O
1370                        || r_type == R_68K_GOT16O
1371                        || r_type == R_68K_GOT32O
1372                        || ((r_type == R_68K_GOT8
1373                             || r_type == R_68K_GOT16
1374                             || r_type == R_68K_GOT32)
1375                            && strcmp (h->root.root.string,
1376                                       "_GLOBAL_OFFSET_TABLE_") != 0))
1377                       && elf_hash_table (info)->dynamic_sections_created
1378                       && (! info->shared
1379                           || (! info->symbolic && h->dynindx != -1)
1380                           || (h->elf_link_hash_flags
1381                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1382                   || (info->shared
1383                       && ((! info->symbolic && h->dynindx != -1)
1384                           || (h->elf_link_hash_flags
1385                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1386                       && ((input_section->flags & SEC_ALLOC) != 0
1387                           /* DWARF will emit R_68K_32 relocations in its
1388                              sections against symbols defined externally
1389                              in shared libraries.  We can't do anything
1390                              with them here.  */
1391                           || ((input_section->flags & SEC_DEBUGGING) != 0
1392                               && (h->elf_link_hash_flags
1393                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1394                       && (r_type == R_68K_8
1395                           || r_type == R_68K_16
1396                           || r_type == R_68K_32
1397                           || r_type == R_68K_PC8
1398                           || r_type == R_68K_PC16
1399                           || r_type == R_68K_PC32)))
1400                 {
1401                   /* In these cases, we don't need the relocation
1402                      value.  We check specially because in some
1403                      obscure cases sec->output_section will be NULL.  */
1404                   relocation = 0;
1405                 }
1406               else
1407                 relocation = (h->root.u.def.value
1408                               + sec->output_section->vma
1409                               + sec->output_offset);
1410             }
1411           else if (h->root.type == bfd_link_hash_undefweak)
1412             relocation = 0;
1413           else if (info->shared
1414                    && (!info->symbolic || info->allow_shlib_undefined)
1415                    && !info->no_undefined
1416                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1417             relocation = 0;
1418           else
1419             {
1420               if (!(info->callbacks->undefined_symbol
1421                     (info, h->root.root.string, input_bfd,
1422                      input_section, rel->r_offset,
1423                      (!info->shared || info->no_undefined
1424                       || ELF_ST_VISIBILITY (h->other)))))
1425                 return FALSE;
1426               relocation = 0;
1427             }
1428         }
1429
1430       switch (r_type)
1431         {
1432         case R_68K_GOT8:
1433         case R_68K_GOT16:
1434         case R_68K_GOT32:
1435           /* Relocation is to the address of the entry for this symbol
1436              in the global offset table.  */
1437           if (h != NULL
1438               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1439             break;
1440           /* Fall through.  */
1441         case R_68K_GOT8O:
1442         case R_68K_GOT16O:
1443         case R_68K_GOT32O:
1444           /* Relocation is the offset of the entry for this symbol in
1445              the global offset table.  */
1446
1447           {
1448             bfd_vma off;
1449
1450             if (sgot == NULL)
1451               {
1452                 sgot = bfd_get_section_by_name (dynobj, ".got");
1453                 BFD_ASSERT (sgot != NULL);
1454               }
1455
1456             if (h != NULL)
1457               {
1458                 off = h->got.offset;
1459                 BFD_ASSERT (off != (bfd_vma) -1);
1460
1461                 if (!elf_hash_table (info)->dynamic_sections_created
1462                     || (info->shared
1463                         && (info->symbolic || h->dynindx == -1)
1464                         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1465                   {
1466                     /* This is actually a static link, or it is a
1467                        -Bsymbolic link and the symbol is defined
1468                        locally, or the symbol was forced to be local
1469                        because of a version file..  We must initialize
1470                        this entry in the global offset table.  Since
1471                        the offset must always be a multiple of 4, we
1472                        use the least significant bit to record whether
1473                        we have initialized it already.
1474
1475                        When doing a dynamic link, we create a .rela.got
1476                        relocation entry to initialize the value.  This
1477                        is done in the finish_dynamic_symbol routine.  */
1478                     if ((off & 1) != 0)
1479                       off &= ~1;
1480                     else
1481                       {
1482                         bfd_put_32 (output_bfd, relocation,
1483                                     sgot->contents + off);
1484                         h->got.offset |= 1;
1485                       }
1486                   }
1487               }
1488             else
1489               {
1490                 BFD_ASSERT (local_got_offsets != NULL
1491                             && local_got_offsets[r_symndx] != (bfd_vma) -1);
1492
1493                 off = local_got_offsets[r_symndx];
1494
1495                 /* The offset must always be a multiple of 4.  We use
1496                    the least significant bit to record whether we have
1497                    already generated the necessary reloc.  */
1498                 if ((off & 1) != 0)
1499                   off &= ~1;
1500                 else
1501                   {
1502                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1503
1504                     if (info->shared)
1505                       {
1506                         asection *s;
1507                         Elf_Internal_Rela outrel;
1508                         bfd_byte *loc;
1509
1510                         s = bfd_get_section_by_name (dynobj, ".rela.got");
1511                         BFD_ASSERT (s != NULL);
1512
1513                         outrel.r_offset = (sgot->output_section->vma
1514                                            + sgot->output_offset
1515                                            + off);
1516                         outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1517                         outrel.r_addend = relocation;
1518                         loc = s->contents;
1519                         loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1520                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1521                       }
1522
1523                     local_got_offsets[r_symndx] |= 1;
1524                   }
1525               }
1526
1527             relocation = sgot->output_offset + off;
1528             if (r_type == R_68K_GOT8O
1529                 || r_type == R_68K_GOT16O
1530                 || r_type == R_68K_GOT32O)
1531               {
1532                 /* This relocation does not use the addend.  */
1533                 rel->r_addend = 0;
1534               }
1535             else
1536               relocation += sgot->output_section->vma;
1537           }
1538           break;
1539
1540         case R_68K_PLT8:
1541         case R_68K_PLT16:
1542         case R_68K_PLT32:
1543           /* Relocation is to the entry for this symbol in the
1544              procedure linkage table.  */
1545
1546           /* Resolve a PLTxx reloc against a local symbol directly,
1547              without using the procedure linkage table.  */
1548           if (h == NULL)
1549             break;
1550
1551           if (h->plt.offset == (bfd_vma) -1
1552               || !elf_hash_table (info)->dynamic_sections_created)
1553             {
1554               /* We didn't make a PLT entry for this symbol.  This
1555                  happens when statically linking PIC code, or when
1556                  using -Bsymbolic.  */
1557               break;
1558             }
1559
1560           if (splt == NULL)
1561             {
1562               splt = bfd_get_section_by_name (dynobj, ".plt");
1563               BFD_ASSERT (splt != NULL);
1564             }
1565
1566           relocation = (splt->output_section->vma
1567                         + splt->output_offset
1568                         + h->plt.offset);
1569           break;
1570
1571         case R_68K_PLT8O:
1572         case R_68K_PLT16O:
1573         case R_68K_PLT32O:
1574           /* Relocation is the offset of the entry for this symbol in
1575              the procedure linkage table.  */
1576           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1577
1578           if (splt == NULL)
1579             {
1580               splt = bfd_get_section_by_name (dynobj, ".plt");
1581               BFD_ASSERT (splt != NULL);
1582             }
1583
1584           relocation = h->plt.offset;
1585
1586           /* This relocation does not use the addend.  */
1587           rel->r_addend = 0;
1588
1589           break;
1590
1591         case R_68K_PC8:
1592         case R_68K_PC16:
1593         case R_68K_PC32:
1594           if (h == NULL)
1595             break;
1596           /* Fall through.  */
1597         case R_68K_8:
1598         case R_68K_16:
1599         case R_68K_32:
1600           if (info->shared
1601               && r_symndx != 0
1602               && (input_section->flags & SEC_ALLOC) != 0
1603               && ((r_type != R_68K_PC8
1604                    && r_type != R_68K_PC16
1605                    && r_type != R_68K_PC32)
1606                   || (!info->symbolic
1607                       || (h->elf_link_hash_flags
1608                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1609             {
1610               Elf_Internal_Rela outrel;
1611               bfd_byte *loc;
1612               bfd_boolean skip, relocate;
1613
1614               /* When generating a shared object, these relocations
1615                  are copied into the output file to be resolved at run
1616                  time.  */
1617
1618               if (sreloc == NULL)
1619                 {
1620                   const char *name;
1621
1622                   name = (bfd_elf_string_from_elf_section
1623                           (input_bfd,
1624                            elf_elfheader (input_bfd)->e_shstrndx,
1625                            elf_section_data (input_section)->rel_hdr.sh_name));
1626                   if (name == NULL)
1627                     return FALSE;
1628
1629                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1630                               && strcmp (bfd_get_section_name (input_bfd,
1631                                                                input_section),
1632                                          name + 5) == 0);
1633
1634                   sreloc = bfd_get_section_by_name (dynobj, name);
1635                   BFD_ASSERT (sreloc != NULL);
1636                 }
1637
1638               skip = FALSE;
1639               relocate = FALSE;
1640
1641               outrel.r_offset =
1642                 _bfd_elf_section_offset (output_bfd, info, input_section,
1643                                          rel->r_offset);
1644               if (outrel.r_offset == (bfd_vma) -1)
1645                 skip = TRUE;
1646               else if (outrel.r_offset == (bfd_vma) -2)
1647                 skip = TRUE, relocate = TRUE;
1648               outrel.r_offset += (input_section->output_section->vma
1649                                   + input_section->output_offset);
1650
1651               if (skip)
1652                 memset (&outrel, 0, sizeof outrel);
1653               /* h->dynindx may be -1 if the symbol was marked to
1654                  become local.  */
1655               else if (h != NULL
1656                        && ((! info->symbolic && h->dynindx != -1)
1657                            || (h->elf_link_hash_flags
1658                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1659                 {
1660                   BFD_ASSERT (h->dynindx != -1);
1661                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1662                   outrel.r_addend = relocation + rel->r_addend;
1663                 }
1664               else
1665                 {
1666                   if (r_type == R_68K_32)
1667                     {
1668                       relocate = TRUE;
1669                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1670                       outrel.r_addend = relocation + rel->r_addend;
1671                     }
1672                   else
1673                     {
1674                       long indx;
1675
1676                       if (h == NULL)
1677                         sec = local_sections[r_symndx];
1678                       else
1679                         {
1680                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1681                                       || (h->root.type
1682                                           == bfd_link_hash_defweak));
1683                           sec = h->root.u.def.section;
1684                         }
1685                       if (sec != NULL && bfd_is_abs_section (sec))
1686                         indx = 0;
1687                       else if (sec == NULL || sec->owner == NULL)
1688                         {
1689                           bfd_set_error (bfd_error_bad_value);
1690                           return FALSE;
1691                         }
1692                       else
1693                         {
1694                           asection *osec;
1695
1696                           osec = sec->output_section;
1697                           indx = elf_section_data (osec)->dynindx;
1698                           BFD_ASSERT (indx > 0);
1699                         }
1700
1701                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1702                       outrel.r_addend = relocation + rel->r_addend;
1703                     }
1704                 }
1705
1706               loc = sreloc->contents;
1707               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1708               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1709
1710               /* This reloc will be computed at runtime, so there's no
1711                  need to do anything now, except for R_68K_32
1712                  relocations that have been turned into
1713                  R_68K_RELATIVE.  */
1714               if (!relocate)
1715                 continue;
1716             }
1717
1718           break;
1719
1720         case R_68K_GNU_VTINHERIT:
1721         case R_68K_GNU_VTENTRY:
1722           /* These are no-ops in the end.  */
1723           continue;
1724
1725         default:
1726           break;
1727         }
1728
1729       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1730                                     contents, rel->r_offset,
1731                                     relocation, rel->r_addend);
1732
1733       if (r != bfd_reloc_ok)
1734         {
1735           switch (r)
1736             {
1737             default:
1738             case bfd_reloc_outofrange:
1739               abort ();
1740             case bfd_reloc_overflow:
1741               {
1742                 const char *name;
1743
1744                 if (h != NULL)
1745                   name = h->root.root.string;
1746                 else
1747                   {
1748                     name = bfd_elf_string_from_elf_section (input_bfd,
1749                                                             symtab_hdr->sh_link,
1750                                                             sym->st_name);
1751                     if (name == NULL)
1752                       return FALSE;
1753                     if (*name == '\0')
1754                       name = bfd_section_name (input_bfd, sec);
1755                   }
1756                 if (!(info->callbacks->reloc_overflow
1757                       (info, name, howto->name, (bfd_vma) 0,
1758                        input_bfd, input_section, rel->r_offset)))
1759                   return FALSE;
1760               }
1761               break;
1762             }
1763         }
1764     }
1765
1766   return TRUE;
1767 }
1768
1769 /* Finish up dynamic symbol handling.  We set the contents of various
1770    dynamic sections here.  */
1771
1772 static bfd_boolean
1773 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
1774      bfd *output_bfd;
1775      struct bfd_link_info *info;
1776      struct elf_link_hash_entry *h;
1777      Elf_Internal_Sym *sym;
1778 {
1779   bfd *dynobj;
1780   int plt_off1, plt_off2, plt_off3;
1781
1782   dynobj = elf_hash_table (info)->dynobj;
1783
1784   if (h->plt.offset != (bfd_vma) -1)
1785     {
1786       asection *splt;
1787       asection *sgot;
1788       asection *srela;
1789       bfd_vma plt_index;
1790       bfd_vma got_offset;
1791       Elf_Internal_Rela rela;
1792       bfd_byte *loc;
1793
1794       /* This symbol has an entry in the procedure linkage table.  Set
1795          it up.  */
1796
1797       BFD_ASSERT (h->dynindx != -1);
1798
1799       splt = bfd_get_section_by_name (dynobj, ".plt");
1800       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1801       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1802       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1803
1804       /* Get the index in the procedure linkage table which
1805          corresponds to this symbol.  This is the index of this symbol
1806          in all the symbols for which we are making plt entries.  The
1807          first entry in the procedure linkage table is reserved.  */
1808       if ( CPU32_FLAG (output_bfd))
1809         plt_index = h->plt.offset / PLT_CPU32_ENTRY_SIZE - 1;
1810       else
1811         plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1812
1813       /* Get the offset into the .got table of the entry that
1814          corresponds to this function.  Each .got entry is 4 bytes.
1815          The first three are reserved.  */
1816       got_offset = (plt_index + 3) * 4;
1817
1818       if ( CPU32_FLAG (output_bfd))
1819         {
1820           /* Fill in the entry in the procedure linkage table.  */
1821           memcpy (splt->contents + h->plt.offset, elf_cpu32_plt_entry,
1822                   PLT_CPU32_ENTRY_SIZE);
1823           plt_off1 = 4;
1824           plt_off2 = 12;
1825           plt_off3 = 18;
1826         }
1827       else
1828         {
1829           /* Fill in the entry in the procedure linkage table.  */
1830           memcpy (splt->contents + h->plt.offset, elf_m68k_plt_entry,
1831                   PLT_ENTRY_SIZE);
1832           plt_off1 = 4;
1833           plt_off2 = 10;
1834           plt_off3 = 16;
1835         }
1836
1837       /* The offset is relative to the first extension word.  */
1838       bfd_put_32 (output_bfd,
1839                   (sgot->output_section->vma
1840                    + sgot->output_offset
1841                    + got_offset
1842                    - (splt->output_section->vma
1843                       + h->plt.offset + 2)),
1844                   splt->contents + h->plt.offset + plt_off1);
1845
1846       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1847                   splt->contents + h->plt.offset + plt_off2);
1848       bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3),
1849                   splt->contents + h->plt.offset + plt_off3);
1850
1851       /* Fill in the entry in the global offset table.  */
1852       bfd_put_32 (output_bfd,
1853                   (splt->output_section->vma
1854                    + splt->output_offset
1855                    + h->plt.offset
1856                    + 8),
1857                   sgot->contents + got_offset);
1858
1859       /* Fill in the entry in the .rela.plt section.  */
1860       rela.r_offset = (sgot->output_section->vma
1861                        + sgot->output_offset
1862                        + got_offset);
1863       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
1864       rela.r_addend = 0;
1865       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1866       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1867
1868       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1869         {
1870           /* Mark the symbol as undefined, rather than as defined in
1871              the .plt section.  Leave the value alone.  */
1872           sym->st_shndx = SHN_UNDEF;
1873         }
1874     }
1875
1876   if (h->got.offset != (bfd_vma) -1)
1877     {
1878       asection *sgot;
1879       asection *srela;
1880       Elf_Internal_Rela rela;
1881       bfd_byte *loc;
1882
1883       /* This symbol has an entry in the global offset table.  Set it
1884          up.  */
1885
1886       sgot = bfd_get_section_by_name (dynobj, ".got");
1887       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1888       BFD_ASSERT (sgot != NULL && srela != NULL);
1889
1890       rela.r_offset = (sgot->output_section->vma
1891                        + sgot->output_offset
1892                        + (h->got.offset &~ (bfd_vma) 1));
1893
1894       /* If this is a -Bsymbolic link, and the symbol is defined
1895          locally, we just want to emit a RELATIVE reloc.  Likewise if
1896          the symbol was forced to be local because of a version file.
1897          The entry in the global offset table will already have been
1898          initialized in the relocate_section function.  */
1899       if (info->shared
1900           && (info->symbolic || h->dynindx == -1)
1901           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1902         {
1903           rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1904           rela.r_addend = bfd_get_signed_32 (output_bfd,
1905                                              (sgot->contents
1906                                               + (h->got.offset &~ (bfd_vma) 1)));
1907         }
1908       else
1909         {
1910           bfd_put_32 (output_bfd, (bfd_vma) 0,
1911                       sgot->contents + (h->got.offset &~ (bfd_vma) 1));
1912           rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
1913           rela.r_addend = 0;
1914         }
1915
1916       loc = srela->contents;
1917       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1918       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1919     }
1920
1921   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1922     {
1923       asection *s;
1924       Elf_Internal_Rela rela;
1925       bfd_byte *loc;
1926
1927       /* This symbol needs a copy reloc.  Set it up.  */
1928
1929       BFD_ASSERT (h->dynindx != -1
1930                   && (h->root.type == bfd_link_hash_defined
1931                       || h->root.type == bfd_link_hash_defweak));
1932
1933       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1934                                    ".rela.bss");
1935       BFD_ASSERT (s != NULL);
1936
1937       rela.r_offset = (h->root.u.def.value
1938                        + h->root.u.def.section->output_section->vma
1939                        + h->root.u.def.section->output_offset);
1940       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
1941       rela.r_addend = 0;
1942       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1943       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1944     }
1945
1946   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1947   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1948       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1949     sym->st_shndx = SHN_ABS;
1950
1951   return TRUE;
1952 }
1953
1954 /* Finish up the dynamic sections.  */
1955
1956 static bfd_boolean
1957 elf_m68k_finish_dynamic_sections (output_bfd, info)
1958      bfd *output_bfd;
1959      struct bfd_link_info *info;
1960 {
1961   bfd *dynobj;
1962   asection *sgot;
1963   asection *sdyn;
1964
1965   dynobj = elf_hash_table (info)->dynobj;
1966
1967   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1968   BFD_ASSERT (sgot != NULL);
1969   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1970
1971   if (elf_hash_table (info)->dynamic_sections_created)
1972     {
1973       asection *splt;
1974       Elf32_External_Dyn *dyncon, *dynconend;
1975
1976       splt = bfd_get_section_by_name (dynobj, ".plt");
1977       BFD_ASSERT (splt != NULL && sdyn != NULL);
1978
1979       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1980       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1981       for (; dyncon < dynconend; dyncon++)
1982         {
1983           Elf_Internal_Dyn dyn;
1984           const char *name;
1985           asection *s;
1986
1987           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1988
1989           switch (dyn.d_tag)
1990             {
1991             default:
1992               break;
1993
1994             case DT_PLTGOT:
1995               name = ".got";
1996               goto get_vma;
1997             case DT_JMPREL:
1998               name = ".rela.plt";
1999             get_vma:
2000               s = bfd_get_section_by_name (output_bfd, name);
2001               BFD_ASSERT (s != NULL);
2002               dyn.d_un.d_ptr = s->vma;
2003               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2004               break;
2005
2006             case DT_PLTRELSZ:
2007               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2008               BFD_ASSERT (s != NULL);
2009               if (s->_cooked_size != 0)
2010                 dyn.d_un.d_val = s->_cooked_size;
2011               else
2012                 dyn.d_un.d_val = s->_raw_size;
2013               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2014               break;
2015
2016             case DT_RELASZ:
2017               /* The procedure linkage table relocs (DT_JMPREL) should
2018                  not be included in the overall relocs (DT_RELA).
2019                  Therefore, we override the DT_RELASZ entry here to
2020                  make it not include the JMPREL relocs.  Since the
2021                  linker script arranges for .rela.plt to follow all
2022                  other relocation sections, we don't have to worry
2023                  about changing the DT_RELA entry.  */
2024               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2025               if (s != NULL)
2026                 {
2027                   if (s->_cooked_size != 0)
2028                     dyn.d_un.d_val -= s->_cooked_size;
2029                   else
2030                     dyn.d_un.d_val -= s->_raw_size;
2031                 }
2032               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2033               break;
2034             }
2035         }
2036
2037       /* Fill in the first entry in the procedure linkage table.  */
2038       if (splt->_raw_size > 0)
2039         {
2040           if (!CPU32_FLAG (output_bfd))
2041             {
2042               memcpy (splt->contents, elf_m68k_plt0_entry, PLT_ENTRY_SIZE);
2043               bfd_put_32 (output_bfd,
2044                           (sgot->output_section->vma
2045                            + sgot->output_offset + 4
2046                            - (splt->output_section->vma + 2)),
2047                           splt->contents + 4);
2048               bfd_put_32 (output_bfd,
2049                           (sgot->output_section->vma
2050                            + sgot->output_offset + 8
2051                            - (splt->output_section->vma + 10)),
2052                           splt->contents + 12);
2053               elf_section_data (splt->output_section)->this_hdr.sh_entsize
2054                = PLT_ENTRY_SIZE;
2055             }
2056           else /* cpu32 */
2057             {
2058               memcpy (splt->contents, elf_cpu32_plt0_entry, PLT_CPU32_ENTRY_SIZE);
2059               bfd_put_32 (output_bfd,
2060                           (sgot->output_section->vma
2061                            + sgot->output_offset + 4
2062                            - (splt->output_section->vma + 2)),
2063                           splt->contents + 4);
2064               bfd_put_32 (output_bfd,
2065                           (sgot->output_section->vma
2066                            + sgot->output_offset + 8
2067                            - (splt->output_section->vma + 10)),
2068                           splt->contents + 12);
2069               elf_section_data (splt->output_section)->this_hdr.sh_entsize
2070                = PLT_CPU32_ENTRY_SIZE;
2071             }
2072         }
2073     }
2074
2075   /* Fill in the first three entries in the global offset table.  */
2076   if (sgot->_raw_size > 0)
2077     {
2078       if (sdyn == NULL)
2079         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2080       else
2081         bfd_put_32 (output_bfd,
2082                     sdyn->output_section->vma + sdyn->output_offset,
2083                     sgot->contents);
2084       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2085       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2086     }
2087
2088   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2089
2090   return TRUE;
2091 }
2092
2093 /* Given a .data section and a .emreloc in-memory section, store
2094    relocation information into the .emreloc section which can be
2095    used at runtime to relocate the section.  This is called by the
2096    linker when the --embedded-relocs switch is used.  This is called
2097    after the add_symbols entry point has been called for all the
2098    objects, and before the final_link entry point is called.  */
2099
2100 bfd_boolean
2101 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2102      bfd *abfd;
2103      struct bfd_link_info *info;
2104      asection *datasec;
2105      asection *relsec;
2106      char **errmsg;
2107 {
2108   Elf_Internal_Shdr *symtab_hdr;
2109   Elf_Internal_Sym *isymbuf = NULL;
2110   Elf_Internal_Rela *internal_relocs = NULL;
2111   Elf_Internal_Rela *irel, *irelend;
2112   bfd_byte *p;
2113   bfd_size_type amt;
2114
2115   BFD_ASSERT (! info->relocateable);
2116
2117   *errmsg = NULL;
2118
2119   if (datasec->reloc_count == 0)
2120     return TRUE;
2121
2122   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2123
2124   /* Get a copy of the native relocations.  */
2125   internal_relocs = (_bfd_elf32_link_read_relocs
2126                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2127                       info->keep_memory));
2128   if (internal_relocs == NULL)
2129     goto error_return;
2130
2131   amt = (bfd_size_type) datasec->reloc_count * 12;
2132   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2133   if (relsec->contents == NULL)
2134     goto error_return;
2135
2136   p = relsec->contents;
2137
2138   irelend = internal_relocs + datasec->reloc_count;
2139   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2140     {
2141       asection *targetsec;
2142
2143       /* We are going to write a four byte longword into the runtime
2144        reloc section.  The longword will be the address in the data
2145        section which must be relocated.  It is followed by the name
2146        of the target section NUL-padded or truncated to 8
2147        characters.  */
2148
2149       /* We can only relocate absolute longword relocs at run time.  */
2150       if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2151         {
2152           *errmsg = _("unsupported reloc type");
2153           bfd_set_error (bfd_error_bad_value);
2154           goto error_return;
2155         }
2156
2157       /* Get the target section referred to by the reloc.  */
2158       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2159         {
2160           /* A local symbol.  */
2161           Elf_Internal_Sym *isym;
2162
2163           /* Read this BFD's local symbols if we haven't done so already.  */
2164           if (isymbuf == NULL)
2165             {
2166               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2167               if (isymbuf == NULL)
2168                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2169                                                 symtab_hdr->sh_info, 0,
2170                                                 NULL, NULL, NULL);
2171               if (isymbuf == NULL)
2172                 goto error_return;
2173             }
2174
2175           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2176           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2177         }
2178       else
2179         {
2180           unsigned long indx;
2181           struct elf_link_hash_entry *h;
2182
2183           /* An external symbol.  */
2184           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2185           h = elf_sym_hashes (abfd)[indx];
2186           BFD_ASSERT (h != NULL);
2187           if (h->root.type == bfd_link_hash_defined
2188               || h->root.type == bfd_link_hash_defweak)
2189             targetsec = h->root.u.def.section;
2190           else
2191             targetsec = NULL;
2192         }
2193
2194       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2195       memset (p + 4, 0, 8);
2196       if (targetsec != NULL)
2197         strncpy (p + 4, targetsec->output_section->name, 8);
2198     }
2199
2200   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2201     free (isymbuf);
2202   if (internal_relocs != NULL
2203       && elf_section_data (datasec)->relocs != internal_relocs)
2204     free (internal_relocs);
2205   return TRUE;
2206
2207 error_return:
2208   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2209     free (isymbuf);
2210   if (internal_relocs != NULL
2211       && elf_section_data (datasec)->relocs != internal_relocs)
2212     free (internal_relocs);
2213   return FALSE;
2214 }
2215
2216 static enum elf_reloc_type_class
2217 elf32_m68k_reloc_type_class (rela)
2218      const Elf_Internal_Rela *rela;
2219 {
2220   switch ((int) ELF32_R_TYPE (rela->r_info))
2221     {
2222     case R_68K_RELATIVE:
2223       return reloc_class_relative;
2224     case R_68K_JMP_SLOT:
2225       return reloc_class_plt;
2226     case R_68K_COPY:
2227       return reloc_class_copy;
2228     default:
2229       return reloc_class_normal;
2230     }
2231 }
2232
2233 #define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
2234 #define TARGET_BIG_NAME                 "elf32-m68k"
2235 #define ELF_MACHINE_CODE                EM_68K
2236 #define ELF_MAXPAGESIZE                 0x2000
2237 #define elf_backend_create_dynamic_sections \
2238                                         _bfd_elf_create_dynamic_sections
2239 #define bfd_elf32_bfd_link_hash_table_create \
2240                                         elf_m68k_link_hash_table_create
2241 #define bfd_elf32_bfd_final_link        _bfd_elf32_gc_common_final_link
2242
2243 #define elf_backend_check_relocs        elf_m68k_check_relocs
2244 #define elf_backend_adjust_dynamic_symbol \
2245                                         elf_m68k_adjust_dynamic_symbol
2246 #define elf_backend_size_dynamic_sections \
2247                                         elf_m68k_size_dynamic_sections
2248 #define elf_backend_relocate_section    elf_m68k_relocate_section
2249 #define elf_backend_finish_dynamic_symbol \
2250                                         elf_m68k_finish_dynamic_symbol
2251 #define elf_backend_finish_dynamic_sections \
2252                                         elf_m68k_finish_dynamic_sections
2253 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
2254 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
2255 #define bfd_elf32_bfd_merge_private_bfd_data \
2256                                         elf32_m68k_merge_private_bfd_data
2257 #define bfd_elf32_bfd_set_private_flags \
2258                                         elf32_m68k_set_private_flags
2259 #define bfd_elf32_bfd_print_private_bfd_data \
2260                                         elf32_m68k_print_private_bfd_data
2261 #define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
2262
2263 #define elf_backend_can_gc_sections 1
2264 #define elf_backend_can_refcount 1
2265 #define elf_backend_want_got_plt 1
2266 #define elf_backend_plt_readonly 1
2267 #define elf_backend_want_plt_sym 0
2268 #define elf_backend_got_header_size     12
2269 #define elf_backend_rela_normal         1
2270
2271 #include "elf32-target.h"