bfd/elf32-m68k.c

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