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   0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
 228   0, 0, 0, 0,             /* replaced with offset to .got + 4.  */
 229   0x4e, 0xd1,             /* jmp %a1@ */
 230   0, 0, 0, 0,             /* replace with offset to .got +8. */
 231   0, 0, 0, 0,             /* pad out to 24 bytes.  */
 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 = NULL;
 851   asection *srelgot = NULL;
 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)
 859     {
 860       sgot = bfd_get_section_by_name (dynobj, ".got");
 861       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 862     }
 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
 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
 936 /* Adjust a symbol defined by a dynamic object and referenced by a
 937    regular object.  The current definition is in some section of the
 938    dynamic object, but we're not including those sections.  We have to
 939    change the definition to something the rest of the link can
 940    understand.  */
 941
 942 static boolean
 943 elf_m68k_adjust_dynamic_symbol (info, h)
 944      struct bfd_link_info *info;
 945      struct elf_link_hash_entry *h;
 946 {
 947   bfd *dynobj;
 948   asection *s;
 949   unsigned int power_of_two;
 950
 951   dynobj = elf_hash_table (info)->dynobj;
 952
 953   /* Make sure we know what is going on here.  */
 954   BFD_ASSERT (dynobj != NULL
 955               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 956                   || h->weakdef != NULL
 957                   || ((h->elf_link_hash_flags
 958                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 959                       && (h->elf_link_hash_flags
 960                           & ELF_LINK_HASH_REF_REGULAR) != 0
 961                       && (h->elf_link_hash_flags
 962                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 963
 964   /* If this is a function, put it in the procedure linkage table.  We
 965      will fill in the contents of the procedure linkage table later,
 966      when we know the address of the .got section.  */
 967   if (h->type == STT_FUNC
 968       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 969     {
 970       if (! info->shared
 971           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
 972           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
 973           /* We must always create the plt entry if it was referenced
 974              by a PLTxxO relocation.  In this case we already recorded
 975              it as a dynamic symbol.  */
 976           && h->dynindx == -1)
 977         {
 978           /* This case can occur if we saw a PLTxx reloc in an input
 979              file, but the symbol was never referred to by a dynamic
 980              object.  In such a case, we don't actually need to build
 981              a procedure linkage table, and we can just do a PCxx
 982              reloc instead.  */
 983           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
 984           h->plt.offset = (bfd_vma) -1;
 985           return true;
 986         }
 987
 988       /* GC may have rendered this entry unused.  */
 989       if (h->plt.refcount <= 0)
 990         {
 991           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 992           h->plt.offset = (bfd_vma) -1;
 993           return true;
 994         }
 995
 996       /* Make sure this symbol is output as a dynamic symbol.  */
 997       if (h->dynindx == -1)
 998         {
 999           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1000             return false;
1001         }
1002
1003       s = bfd_get_section_by_name (dynobj, ".plt");
1004       BFD_ASSERT (s != NULL);
1005
1006       /* If this is the first .plt entry, make room for the special
1007          first entry.  */
1008       if (s->_raw_size == 0)
1009         {
1010           if (CPU32_FLAG (dynobj))
1011             s->_raw_size += PLT_CPU32_ENTRY_SIZE;
1012           else
1013             s->_raw_size += PLT_ENTRY_SIZE;
1014         }
1015
1016       /* If this symbol is not defined in a regular file, and we are
1017          not generating a shared library, then set the symbol to this
1018          location in the .plt.  This is required to make function
1019          pointers compare as equal between the normal executable and
1020          the shared library.  */
1021       if (!info->shared
1022           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1023         {
1024           h->root.u.def.section = s;
1025           h->root.u.def.value = s->_raw_size;
1026         }
1027
1028       h->plt.offset = s->_raw_size;
1029
1030       /* Make room for this entry.  */
1031       if (CPU32_FLAG (dynobj))
1032         s->_raw_size += PLT_CPU32_ENTRY_SIZE;
1033       else
1034         s->_raw_size += PLT_ENTRY_SIZE;
1035
1036       /* We also need to make an entry in the .got.plt section, which
1037          will be placed in the .got section by the linker script.  */
1038
1039       s = bfd_get_section_by_name (dynobj, ".got.plt");
1040       BFD_ASSERT (s != NULL);
1041       s->_raw_size += 4;
1042
1043       /* We also need to make an entry in the .rela.plt section.  */
1044
1045       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1046       BFD_ASSERT (s != NULL);
1047       s->_raw_size += sizeof (Elf32_External_Rela);
1048
1049       return true;
1050     }
1051
1052   /* Reinitialize the plt offset now that it is not used as a reference
1053      count any more.  */
1054   h->plt.offset = (bfd_vma) -1;
1055
1056   /* If this is a weak symbol, and there is a real definition, the
1057      processor independent code will have arranged for us to see the
1058      real definition first, and we can just use the same value.  */
1059   if (h->weakdef != NULL)
1060     {
1061       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1062                   || h->weakdef->root.type == bfd_link_hash_defweak);
1063       h->root.u.def.section = h->weakdef->root.u.def.section;
1064       h->root.u.def.value = h->weakdef->root.u.def.value;
1065       return true;
1066     }
1067
1068   /* This is a reference to a symbol defined by a dynamic object which
1069      is not a function.  */
1070
1071   /* If we are creating a shared library, we must presume that the
1072      only references to the symbol are via the global offset table.
1073      For such cases we need not do anything here; the relocations will
1074      be handled correctly by relocate_section.  */
1075   if (info->shared)
1076     return true;
1077
1078   /* We must allocate the symbol in our .dynbss section, which will
1079      become part of the .bss section of the executable.  There will be
1080      an entry for this symbol in the .dynsym section.  The dynamic
1081      object will contain position independent code, so all references
1082      from the dynamic object to this symbol will go through the global
1083      offset table.  The dynamic linker will use the .dynsym entry to
1084      determine the address it must put in the global offset table, so
1085      both the dynamic object and the regular object will refer to the
1086      same memory location for the variable.  */
1087
1088   s = bfd_get_section_by_name (dynobj, ".dynbss");
1089   BFD_ASSERT (s != NULL);
1090
1091   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1092      copy the initial value out of the dynamic object and into the
1093      runtime process image.  We need to remember the offset into the
1094      .rela.bss section we are going to use.  */
1095   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1096     {
1097       asection *srel;
1098
1099       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1100       BFD_ASSERT (srel != NULL);
1101       srel->_raw_size += sizeof (Elf32_External_Rela);
1102       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1103     }
1104
1105   /* We need to figure out the alignment required for this symbol.  I
1106      have no idea how ELF linkers handle this.  */
1107   power_of_two = bfd_log2 (h->size);
1108   if (power_of_two > 3)
1109     power_of_two = 3;
1110
1111   /* Apply the required alignment.  */
1112   s->_raw_size = BFD_ALIGN (s->_raw_size,
1113                             (bfd_size_type) (1 << power_of_two));
1114   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1115     {
1116       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1117         return false;
1118     }
1119
1120   /* Define the symbol as being at this point in the section.  */
1121   h->root.u.def.section = s;
1122   h->root.u.def.value = s->_raw_size;
1123
1124   /* Increment the section size to make room for the symbol.  */
1125   s->_raw_size += h->size;
1126
1127   return true;
1128 }
1129
1130 /* Set the sizes of the dynamic sections.  */
1131
1132 static boolean
1133 elf_m68k_size_dynamic_sections (output_bfd, info)
1134      bfd *output_bfd;
1135      struct bfd_link_info *info;
1136 {
1137   bfd *dynobj;
1138   asection *s;
1139   boolean plt;
1140   boolean relocs;
1141   boolean reltext;
1142
1143   dynobj = elf_hash_table (info)->dynobj;
1144   BFD_ASSERT (dynobj != NULL);
1145
1146   if (elf_hash_table (info)->dynamic_sections_created)
1147     {
1148       /* Set the contents of the .interp section to the interpreter.  */
1149       if (!info->shared)
1150         {
1151           s = bfd_get_section_by_name (dynobj, ".interp");
1152           BFD_ASSERT (s != NULL);
1153           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1154           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1155         }
1156     }
1157   else
1158     {
1159       /* We may have created entries in the .rela.got section.
1160          However, if we are not creating the dynamic sections, we will
1161          not actually use these entries.  Reset the size of .rela.got,
1162          which will cause it to get stripped from the output file
1163          below.  */
1164       s = bfd_get_section_by_name (dynobj, ".rela.got");
1165       if (s != NULL)
1166         s->_raw_size = 0;
1167     }
1168
1169   /* If this is a -Bsymbolic shared link, then we need to discard all PC
1170      relative relocs against symbols defined in a regular object.  We
1171      allocated space for them in the check_relocs routine, but we will not
1172      fill them in in the relocate_section routine.  */
1173   if (info->shared && info->symbolic)
1174     elf_m68k_link_hash_traverse (elf_m68k_hash_table (info),
1175                                  elf_m68k_discard_copies,
1176                                  (PTR) NULL);
1177
1178   /* The check_relocs and adjust_dynamic_symbol entry points have
1179      determined the sizes of the various dynamic sections.  Allocate
1180      memory for them.  */
1181   plt = false;
1182   relocs = false;
1183   reltext = false;
1184   for (s = dynobj->sections; s != NULL; s = s->next)
1185     {
1186       const char *name;
1187       boolean strip;
1188
1189       if ((s->flags & SEC_LINKER_CREATED) == 0)
1190         continue;
1191
1192       /* It's OK to base decisions on the section name, because none
1193          of the dynobj section names depend upon the input files.  */
1194       name = bfd_get_section_name (dynobj, s);
1195
1196       strip = false;
1197
1198       if (strcmp (name, ".plt") == 0)
1199         {
1200           if (s->_raw_size == 0)
1201             {
1202               /* Strip this section if we don't need it; see the
1203                  comment below.  */
1204               strip = true;
1205             }
1206           else
1207             {
1208               /* Remember whether there is a PLT.  */
1209               plt = true;
1210             }
1211         }
1212       else if (strncmp (name, ".rela", 5) == 0)
1213         {
1214           if (s->_raw_size == 0)
1215             {
1216               /* If we don't need this section, strip it from the
1217                  output file.  This is mostly to handle .rela.bss and
1218                  .rela.plt.  We must create both sections in
1219                  create_dynamic_sections, because they must be created
1220                  before the linker maps input sections to output
1221                  sections.  The linker does that before
1222                  adjust_dynamic_symbol is called, and it is that
1223                  function which decides whether anything needs to go
1224                  into these sections.  */
1225               strip = true;
1226             }
1227           else
1228             {
1229               asection *target;
1230
1231               /* Remember whether there are any reloc sections other
1232                  than .rela.plt.  */
1233               if (strcmp (name, ".rela.plt") != 0)
1234                 {
1235                   const char *outname;
1236
1237                   relocs = true;
1238
1239                   /* If this relocation section applies to a read only
1240                      section, then we probably need a DT_TEXTREL
1241                      entry.  .rela.plt is actually associated with
1242                      .got.plt, which is never readonly.  */
1243                   outname = bfd_get_section_name (output_bfd,
1244                                                   s->output_section);
1245                   target = bfd_get_section_by_name (output_bfd, outname + 5);
1246                   if (target != NULL
1247                       && (target->flags & SEC_READONLY) != 0
1248                       && (target->flags & SEC_ALLOC) != 0)
1249                     reltext = true;
1250                 }
1251
1252               /* We use the reloc_count field as a counter if we need
1253                  to copy relocs into the output file.  */
1254               s->reloc_count = 0;
1255             }
1256         }
1257       else if (strncmp (name, ".got", 4) != 0)
1258         {
1259           /* It's not one of our sections, so don't allocate space.  */
1260           continue;
1261         }
1262
1263       if (strip)
1264         {
1265           _bfd_strip_section_from_output (info, s);
1266           continue;
1267         }
1268
1269       /* Allocate memory for the section contents.  */
1270       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1271       if (s->contents == NULL && s->_raw_size != 0)
1272         return false;
1273     }
1274
1275   if (elf_hash_table (info)->dynamic_sections_created)
1276     {
1277       /* Add some entries to the .dynamic section.  We fill in the
1278          values later, in elf_m68k_finish_dynamic_sections, but we
1279          must add the entries now so that we get the correct size for
1280          the .dynamic section.  The DT_DEBUG entry is filled in by the
1281          dynamic linker and used by the debugger.  */
1282       if (!info->shared)
1283         {
1284           if (!bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1285             return false;
1286         }
1287
1288       if (plt)
1289         {
1290           if (!bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1291               || !bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1292               || !bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1293               || !bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1294             return false;
1295         }
1296
1297       if (relocs)
1298         {
1299           if (!bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
1300               || !bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
1301               || !bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
1302                                                sizeof (Elf32_External_Rela)))
1303             return false;
1304         }
1305
1306       if (reltext)
1307         {
1308           if (!bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1309             return false;
1310         }
1311     }
1312
1313   return true;
1314 }
1315
1316 /* This function is called via elf_m68k_link_hash_traverse if we are
1317    creating a shared object with -Bsymbolic.  It discards the space
1318    allocated to copy PC relative relocs against symbols which are defined
1319    in regular objects.  We allocated space for them in the check_relocs
1320    routine, but we won't fill them in in the relocate_section routine.  */
1321
1322 /*ARGSUSED*/
1323 static boolean
1324 elf_m68k_discard_copies (h, ignore)
1325      struct elf_m68k_link_hash_entry *h;
1326      PTR ignore ATTRIBUTE_UNUSED;
1327 {
1328   struct elf_m68k_pcrel_relocs_copied *s;
1329
1330   /* We only discard relocs for symbols defined in a regular object.  */
1331   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1332     return true;
1333
1334   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1335     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
1336
1337   return true;
1338 }
1339
1340 /* Relocate an M68K ELF section.  */
1341
1342 static boolean
1343 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1344                            contents, relocs, local_syms, local_sections)
1345      bfd *output_bfd;
1346      struct bfd_link_info *info;
1347      bfd *input_bfd;
1348      asection *input_section;
1349      bfd_byte *contents;
1350      Elf_Internal_Rela *relocs;
1351      Elf_Internal_Sym *local_syms;
1352      asection **local_sections;
1353 {
1354   bfd *dynobj;
1355   Elf_Internal_Shdr *symtab_hdr;
1356   struct elf_link_hash_entry **sym_hashes;
1357   bfd_vma *local_got_offsets;
1358   asection *sgot;
1359   asection *splt;
1360   asection *sreloc;
1361   Elf_Internal_Rela *rel;
1362   Elf_Internal_Rela *relend;
1363
1364   dynobj = elf_hash_table (info)->dynobj;
1365   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1366   sym_hashes = elf_sym_hashes (input_bfd);
1367   local_got_offsets = elf_local_got_offsets (input_bfd);
1368
1369   sgot = NULL;
1370   splt = NULL;
1371   sreloc = NULL;
1372
1373   rel = relocs;
1374   relend = relocs + input_section->reloc_count;
1375   for (; rel < relend; rel++)
1376     {
1377       int r_type;
1378       reloc_howto_type *howto;
1379       unsigned long r_symndx;
1380       struct elf_link_hash_entry *h;
1381       Elf_Internal_Sym *sym;
1382       asection *sec;
1383       bfd_vma relocation;
1384       bfd_reloc_status_type r;
1385
1386       r_type = ELF32_R_TYPE (rel->r_info);
1387       if (r_type < 0 || r_type >= (int) R_68K_max)
1388         {
1389           bfd_set_error (bfd_error_bad_value);
1390           return false;
1391         }
1392       howto = howto_table + r_type;
1393
1394       r_symndx = ELF32_R_SYM (rel->r_info);
1395
1396       if (info->relocateable)
1397         {
1398           /* This is a relocateable link.  We don't have to change
1399              anything, unless the reloc is against a section symbol,
1400              in which case we have to adjust according to where the
1401              section symbol winds up in the output section.  */
1402           if (r_symndx < symtab_hdr->sh_info)
1403             {
1404               sym = local_syms + r_symndx;
1405               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1406                 {
1407                   sec = local_sections[r_symndx];
1408                   rel->r_addend += sec->output_offset + sym->st_value;
1409                 }
1410             }
1411
1412           continue;
1413         }
1414
1415       /* This is a final link.  */
1416       h = NULL;
1417       sym = NULL;
1418       sec = NULL;
1419       if (r_symndx < symtab_hdr->sh_info)
1420         {
1421           sym = local_syms + r_symndx;
1422           sec = local_sections[r_symndx];
1423           relocation = (sec->output_section->vma
1424                         + sec->output_offset
1425                         + sym->st_value);
1426         }
1427       else
1428         {
1429           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1430           while (h->root.type == bfd_link_hash_indirect
1431                  || h->root.type == bfd_link_hash_warning)
1432             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1433           if (h->root.type == bfd_link_hash_defined
1434               || h->root.type == bfd_link_hash_defweak)
1435             {
1436               sec = h->root.u.def.section;
1437               if (((r_type == R_68K_PLT8
1438                     || r_type == R_68K_PLT16
1439                     || r_type == R_68K_PLT32
1440                     || r_type == R_68K_PLT8O
1441                     || r_type == R_68K_PLT16O
1442                     || r_type == R_68K_PLT32O)
1443                    && h->plt.offset != (bfd_vma) -1
1444                    && elf_hash_table (info)->dynamic_sections_created)
1445                   || ((r_type == R_68K_GOT8O
1446                        || r_type == R_68K_GOT16O
1447                        || r_type == R_68K_GOT32O
1448                        || ((r_type == R_68K_GOT8
1449                             || r_type == R_68K_GOT16
1450                             || r_type == R_68K_GOT32)
1451                            && strcmp (h->root.root.string,
1452                                       "_GLOBAL_OFFSET_TABLE_") != 0))
1453                       && elf_hash_table (info)->dynamic_sections_created
1454                       && (! info->shared
1455                           || (! info->symbolic && h->dynindx != -1)
1456                           || (h->elf_link_hash_flags
1457                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1458                   || (info->shared
1459                       && ((! info->symbolic && h->dynindx != -1)
1460                           || (h->elf_link_hash_flags
1461                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1462                       && (input_section->flags & SEC_ALLOC) != 0
1463                       && (r_type == R_68K_8
1464                           || r_type == R_68K_16
1465                           || r_type == R_68K_32
1466                           || r_type == R_68K_PC8
1467                           || r_type == R_68K_PC16
1468                           || r_type == R_68K_PC32)))
1469                 {
1470                   /* In these cases, we don't need the relocation
1471                      value.  We check specially because in some
1472                      obscure cases sec->output_section will be NULL.  */
1473                   relocation = 0;
1474                 }
1475               else
1476                 relocation = (h->root.u.def.value
1477                               + sec->output_section->vma
1478                               + sec->output_offset);
1479             }
1480           else if (h->root.type == bfd_link_hash_undefweak)
1481             relocation = 0;
1482           else if (info->shared && !info->symbolic && !info->no_undefined)
1483             relocation = 0;
1484           else
1485             {
1486               if (!(info->callbacks->undefined_symbol
1487                     (info, h->root.root.string, input_bfd,
1488                      input_section, rel->r_offset,
1489                      (!info->shared || info->no_undefined))))
1490                 return false;
1491               relocation = 0;
1492             }
1493         }
1494
1495       switch (r_type)
1496         {
1497         case R_68K_GOT8:
1498         case R_68K_GOT16:
1499         case R_68K_GOT32:
1500           /* Relocation is to the address of the entry for this symbol
1501              in the global offset table.  */
1502           if (h != NULL
1503               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1504             break;
1505           /* Fall through.  */
1506         case R_68K_GOT8O:
1507         case R_68K_GOT16O:
1508         case R_68K_GOT32O:
1509           /* Relocation is the offset of the entry for this symbol in
1510              the global offset table.  */
1511
1512           {
1513             bfd_vma off;
1514
1515             if (sgot == NULL)
1516               {
1517                 sgot = bfd_get_section_by_name (dynobj, ".got");
1518                 BFD_ASSERT (sgot != NULL);
1519               }
1520
1521             if (h != NULL)
1522               {
1523                 off = h->got.offset;
1524                 BFD_ASSERT (off != (bfd_vma) -1);
1525
1526                 if (!elf_hash_table (info)->dynamic_sections_created
1527                     || (info->shared
1528                         && (info->symbolic || h->dynindx == -1)
1529                         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1530                   {
1531                     /* This is actually a static link, or it is a
1532                        -Bsymbolic link and the symbol is defined
1533                        locally, or the symbol was forced to be local
1534                        because of a version file..  We must initialize
1535                        this entry in the global offset table.  Since
1536                        the offset must always be a multiple of 4, we
1537                        use the least significant bit to record whether
1538                        we have initialized it already.
1539
1540                        When doing a dynamic link, we create a .rela.got
1541                        relocation entry to initialize the value.  This
1542                        is done in the finish_dynamic_symbol routine.  */
1543                     if ((off & 1) != 0)
1544                       off &= ~1;
1545                     else
1546                       {
1547                         bfd_put_32 (output_bfd, relocation,
1548                                     sgot->contents + off);
1549                         h->got.offset |= 1;
1550                       }
1551                   }
1552               }
1553             else
1554               {
1555                 BFD_ASSERT (local_got_offsets != NULL
1556                             && local_got_offsets[r_symndx] != (bfd_vma) -1);
1557
1558                 off = local_got_offsets[r_symndx];
1559
1560                 /* The offset must always be a multiple of 4.  We use
1561                    the least significant bit to record whether we have
1562                    already generated the necessary reloc.  */
1563                 if ((off & 1) != 0)
1564                   off &= ~1;
1565                 else
1566                   {
1567                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1568
1569                     if (info->shared)
1570                       {
1571                         asection *srelgot;
1572                         Elf_Internal_Rela outrel;
1573
1574                         srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1575                         BFD_ASSERT (srelgot != NULL);
1576
1577                         outrel.r_offset = (sgot->output_section->vma
1578                                            + sgot->output_offset
1579                                            + off);
1580                         outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1581                         outrel.r_addend = relocation;
1582                         bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1583                                                    (((Elf32_External_Rela *)
1584                                                      srelgot->contents)
1585                                                     + srelgot->reloc_count));
1586                         ++srelgot->reloc_count;
1587                       }
1588
1589                     local_got_offsets[r_symndx] |= 1;
1590                   }
1591               }
1592
1593             relocation = sgot->output_offset + off;
1594             if (r_type == R_68K_GOT8O
1595                 || r_type == R_68K_GOT16O
1596                 || r_type == R_68K_GOT32O)
1597               {
1598                 /* This relocation does not use the addend.  */
1599                 rel->r_addend = 0;
1600               }
1601             else
1602               relocation += sgot->output_section->vma;
1603           }
1604           break;
1605
1606         case R_68K_PLT8:
1607         case R_68K_PLT16:
1608         case R_68K_PLT32:
1609           /* Relocation is to the entry for this symbol in the
1610              procedure linkage table.  */
1611
1612           /* Resolve a PLTxx reloc against a local symbol directly,
1613              without using the procedure linkage table.  */
1614           if (h == NULL)
1615             break;
1616
1617           if (h->plt.offset == (bfd_vma) -1
1618               || !elf_hash_table (info)->dynamic_sections_created)
1619             {
1620               /* We didn't make a PLT entry for this symbol.  This
1621                  happens when statically linking PIC code, or when
1622                  using -Bsymbolic.  */
1623               break;
1624             }
1625
1626           if (splt == NULL)
1627             {
1628               splt = bfd_get_section_by_name (dynobj, ".plt");
1629               BFD_ASSERT (splt != NULL);
1630             }
1631
1632           relocation = (splt->output_section->vma
1633                         + splt->output_offset
1634                         + h->plt.offset);
1635           break;
1636
1637         case R_68K_PLT8O:
1638         case R_68K_PLT16O:
1639         case R_68K_PLT32O:
1640           /* Relocation is the offset of the entry for this symbol in
1641              the procedure linkage table.  */
1642           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1643
1644           if (splt == NULL)
1645             {
1646               splt = bfd_get_section_by_name (dynobj, ".plt");
1647               BFD_ASSERT (splt != NULL);
1648             }
1649
1650           relocation = h->plt.offset;
1651
1652           /* This relocation does not use the addend.  */
1653           rel->r_addend = 0;
1654
1655           break;
1656
1657         case R_68K_PC8:
1658         case R_68K_PC16:
1659         case R_68K_PC32:
1660           if (h == NULL)
1661             break;
1662           /* Fall through.  */
1663         case R_68K_8:
1664         case R_68K_16:
1665         case R_68K_32:
1666           if (info->shared
1667               && (input_section->flags & SEC_ALLOC) != 0
1668               && ((r_type != R_68K_PC8
1669                    && r_type != R_68K_PC16
1670                    && r_type != R_68K_PC32)
1671                   || (!info->symbolic
1672                       || (h->elf_link_hash_flags
1673                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1674             {
1675               Elf_Internal_Rela outrel;
1676               boolean skip, relocate;
1677
1678               /* When generating a shared object, these relocations
1679                  are copied into the output file to be resolved at run
1680                  time.  */
1681
1682               if (sreloc == NULL)
1683                 {
1684                   const char *name;
1685
1686                   name = (bfd_elf_string_from_elf_section
1687                           (input_bfd,
1688                            elf_elfheader (input_bfd)->e_shstrndx,
1689                            elf_section_data (input_section)->rel_hdr.sh_name));
1690                   if (name == NULL)
1691                     return false;
1692
1693                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1694                               && strcmp (bfd_get_section_name (input_bfd,
1695                                                                input_section),
1696                                          name + 5) == 0);
1697
1698                   sreloc = bfd_get_section_by_name (dynobj, name);
1699                   BFD_ASSERT (sreloc != NULL);
1700                 }
1701
1702               skip = false;
1703
1704               if (elf_section_data (input_section)->stab_info == NULL)
1705                 outrel.r_offset = rel->r_offset;
1706               else
1707                 {
1708                   bfd_vma off;
1709
1710                   off = (_bfd_stab_section_offset
1711                          (output_bfd, &elf_hash_table (info)->stab_info,
1712                           input_section,
1713                           &elf_section_data (input_section)->stab_info,
1714                           rel->r_offset));
1715                   if (off == (bfd_vma) -1)
1716                     skip = true;
1717                   outrel.r_offset = off;
1718                 }
1719
1720               outrel.r_offset += (input_section->output_section->vma
1721                                   + input_section->output_offset);
1722
1723               if (skip)
1724                 {
1725                   memset (&outrel, 0, sizeof outrel);
1726                   relocate = false;
1727                 }
1728               /* h->dynindx may be -1 if the symbol was marked to
1729                  become local.  */
1730               else if (h != NULL
1731                        && ((! info->symbolic && h->dynindx != -1)
1732                            || (h->elf_link_hash_flags
1733                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1734                 {
1735                   BFD_ASSERT (h->dynindx != -1);
1736                   relocate = false;
1737                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1738                   outrel.r_addend = relocation + rel->r_addend;
1739                 }
1740               else
1741                 {
1742                   if (r_type == R_68K_32)
1743                     {
1744                       relocate = true;
1745                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1746                       outrel.r_addend = relocation + rel->r_addend;
1747                     }
1748                   else
1749                     {
1750                       long indx;
1751
1752                       if (h == NULL)
1753                         sec = local_sections[r_symndx];
1754                       else
1755                         {
1756                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1757                                       || (h->root.type
1758                                           == bfd_link_hash_defweak));
1759                           sec = h->root.u.def.section;
1760                         }
1761                       if (sec != NULL && bfd_is_abs_section (sec))
1762                         indx = 0;
1763                       else if (sec == NULL || sec->owner == NULL)
1764                         {
1765                           bfd_set_error (bfd_error_bad_value);
1766                           return false;
1767                         }
1768                       else
1769                         {
1770                           asection *osec;
1771
1772                           osec = sec->output_section;
1773                           indx = elf_section_data (osec)->dynindx;
1774                           BFD_ASSERT (indx > 0);
1775                         }
1776
1777                       relocate = false;
1778                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1779                       outrel.r_addend = relocation + rel->r_addend;
1780                     }
1781                 }
1782
1783               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1784                                          (((Elf32_External_Rela *)
1785                                            sreloc->contents)
1786                                           + sreloc->reloc_count));
1787               ++sreloc->reloc_count;
1788
1789               /* This reloc will be computed at runtime, so there's no
1790                  need to do anything now, except for R_68K_32
1791                  relocations that have been turned into
1792                  R_68K_RELATIVE.  */
1793               if (!relocate)
1794                 continue;
1795             }
1796
1797           break;
1798
1799         case R_68K_GNU_VTINHERIT:
1800         case R_68K_GNU_VTENTRY:
1801           /* These are no-ops in the end.  */
1802           continue;
1803
1804         default:
1805           break;
1806         }
1807
1808       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1809                                     contents, rel->r_offset,
1810                                     relocation, rel->r_addend);
1811
1812       if (r != bfd_reloc_ok)
1813         {
1814           switch (r)
1815             {
1816             default:
1817             case bfd_reloc_outofrange:
1818               abort ();
1819             case bfd_reloc_overflow:
1820               {
1821                 const char *name;
1822
1823                 if (h != NULL)
1824                   name = h->root.root.string;
1825                 else
1826                   {
1827                     name = bfd_elf_string_from_elf_section (input_bfd,
1828                                                             symtab_hdr->sh_link,
1829                                                             sym->st_name);
1830                     if (name == NULL)
1831                       return false;
1832                     if (*name == '\0')
1833                       name = bfd_section_name (input_bfd, sec);
1834                   }
1835                 if (!(info->callbacks->reloc_overflow
1836                       (info, name, howto->name, (bfd_vma) 0,
1837                        input_bfd, input_section, rel->r_offset)))
1838                   return false;
1839               }
1840               break;
1841             }
1842         }
1843     }
1844
1845   return true;
1846 }
1847
1848 /* Finish up dynamic symbol handling.  We set the contents of various
1849    dynamic sections here.  */
1850
1851 static boolean
1852 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
1853      bfd *output_bfd;
1854      struct bfd_link_info *info;
1855      struct elf_link_hash_entry *h;
1856      Elf_Internal_Sym *sym;
1857 {
1858   bfd *dynobj;
1859   int plt_off1, plt_off2, plt_off3;
1860
1861   dynobj = elf_hash_table (info)->dynobj;
1862
1863   if (h->plt.offset != (bfd_vma) -1)
1864     {
1865       asection *splt;
1866       asection *sgot;
1867       asection *srela;
1868       bfd_vma plt_index;
1869       bfd_vma got_offset;
1870       Elf_Internal_Rela rela;
1871
1872       /* This symbol has an entry in the procedure linkage table.  Set
1873          it up.  */
1874
1875       BFD_ASSERT (h->dynindx != -1);
1876
1877       splt = bfd_get_section_by_name (dynobj, ".plt");
1878       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1879       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1880       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1881
1882       /* Get the index in the procedure linkage table which
1883          corresponds to this symbol.  This is the index of this symbol
1884          in all the symbols for which we are making plt entries.  The
1885          first entry in the procedure linkage table is reserved.  */
1886       if ( CPU32_FLAG (output_bfd))
1887         plt_index = h->plt.offset / PLT_CPU32_ENTRY_SIZE - 1;
1888       else
1889         plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1890
1891       /* Get the offset into the .got table of the entry that
1892          corresponds to this function.  Each .got entry is 4 bytes.
1893          The first three are reserved.  */
1894       got_offset = (plt_index + 3) * 4;
1895
1896       if ( CPU32_FLAG (output_bfd))
1897         {
1898           /* Fill in the entry in the procedure linkage table.  */
1899           memcpy (splt->contents + h->plt.offset, elf_cpu32_plt_entry,
1900                   PLT_CPU32_ENTRY_SIZE);
1901           plt_off1 = 4;
1902           plt_off2 = 12;
1903           plt_off3 = 18;
1904         }
1905       else
1906         {
1907           /* Fill in the entry in the procedure linkage table.  */
1908           memcpy (splt->contents + h->plt.offset, elf_m68k_plt_entry,
1909                   PLT_ENTRY_SIZE);
1910           plt_off1 = 4;
1911           plt_off2 = 10;
1912           plt_off3 = 16;
1913         }
1914
1915       /* The offset is relative to the first extension word.  */
1916       bfd_put_32 (output_bfd,
1917                   (sgot->output_section->vma
1918                    + sgot->output_offset
1919                    + got_offset
1920                    - (splt->output_section->vma
1921                       + h->plt.offset + 2)),
1922                   splt->contents + h->plt.offset + plt_off1);
1923
1924       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1925                   splt->contents + h->plt.offset + plt_off2);
1926       bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3),
1927                   splt->contents + h->plt.offset + plt_off3);
1928
1929       /* Fill in the entry in the global offset table.  */
1930       bfd_put_32 (output_bfd,
1931                   (splt->output_section->vma
1932                    + splt->output_offset
1933                    + h->plt.offset
1934                    + 8),
1935                   sgot->contents + got_offset);
1936
1937       /* Fill in the entry in the .rela.plt section.  */
1938       rela.r_offset = (sgot->output_section->vma
1939                        + sgot->output_offset
1940                        + got_offset);
1941       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
1942       rela.r_addend = 0;
1943       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1944                                  ((Elf32_External_Rela *) srela->contents
1945                                   + plt_index));
1946
1947       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1948         {
1949           /* Mark the symbol as undefined, rather than as defined in
1950              the .plt section.  Leave the value alone.  */
1951           sym->st_shndx = SHN_UNDEF;
1952         }
1953     }
1954
1955   if (h->got.offset != (bfd_vma) -1)
1956     {
1957       asection *sgot;
1958       asection *srela;
1959       Elf_Internal_Rela rela;
1960
1961       /* This symbol has an entry in the global offset table.  Set it
1962          up.  */
1963
1964       sgot = bfd_get_section_by_name (dynobj, ".got");
1965       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1966       BFD_ASSERT (sgot != NULL && srela != NULL);
1967
1968       rela.r_offset = (sgot->output_section->vma
1969                        + sgot->output_offset
1970                        + (h->got.offset &~ 1));
1971
1972       /* If this is a -Bsymbolic link, and the symbol is defined
1973          locally, we just want to emit a RELATIVE reloc.  Likewise if
1974          the symbol was forced to be local because of a version file.
1975          The entry in the global offset table will already have been
1976          initialized in the relocate_section function.  */
1977       if (info->shared
1978           && (info->symbolic || h->dynindx == -1)
1979           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1980         {
1981           rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1982           rela.r_addend = bfd_get_signed_32 (output_bfd,
1983                                              (sgot->contents
1984                                               + (h->got.offset & ~1)));
1985         }
1986       else
1987         {
1988           bfd_put_32 (output_bfd, (bfd_vma) 0,
1989                       sgot->contents + (h->got.offset & ~1));
1990           rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
1991           rela.r_addend = 0;
1992         }
1993
1994       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1995                                  ((Elf32_External_Rela *) srela->contents
1996                                   + srela->reloc_count));
1997       ++srela->reloc_count;
1998     }
1999
2000   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2001     {
2002       asection *s;
2003       Elf_Internal_Rela rela;
2004
2005       /* This symbol needs a copy reloc.  Set it up.  */
2006
2007       BFD_ASSERT (h->dynindx != -1
2008                   && (h->root.type == bfd_link_hash_defined
2009                       || h->root.type == bfd_link_hash_defweak));
2010
2011       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2012                                    ".rela.bss");
2013       BFD_ASSERT (s != NULL);
2014
2015       rela.r_offset = (h->root.u.def.value
2016                        + h->root.u.def.section->output_section->vma
2017                        + h->root.u.def.section->output_offset);
2018       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2019       rela.r_addend = 0;
2020       bfd_elf32_swap_reloca_out (output_bfd, &rela,
2021                                  ((Elf32_External_Rela *) s->contents
2022                                   + s->reloc_count));
2023       ++s->reloc_count;
2024     }
2025
2026   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2027   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2028       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2029     sym->st_shndx = SHN_ABS;
2030
2031   return true;
2032 }
2033
2034 /* Finish up the dynamic sections.  */
2035
2036 static boolean
2037 elf_m68k_finish_dynamic_sections (output_bfd, info)
2038      bfd *output_bfd;
2039      struct bfd_link_info *info;
2040 {
2041   bfd *dynobj;
2042   asection *sgot;
2043   asection *sdyn;
2044
2045   dynobj = elf_hash_table (info)->dynobj;
2046
2047   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2048   BFD_ASSERT (sgot != NULL);
2049   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2050
2051   if (elf_hash_table (info)->dynamic_sections_created)
2052     {
2053       asection *splt;
2054       Elf32_External_Dyn *dyncon, *dynconend;
2055
2056       splt = bfd_get_section_by_name (dynobj, ".plt");
2057       BFD_ASSERT (splt != NULL && sdyn != NULL);
2058
2059       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2060       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2061       for (; dyncon < dynconend; dyncon++)
2062         {
2063           Elf_Internal_Dyn dyn;
2064           const char *name;
2065           asection *s;
2066
2067           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2068
2069           switch (dyn.d_tag)
2070             {
2071             default:
2072               break;
2073
2074             case DT_PLTGOT:
2075               name = ".got";
2076               goto get_vma;
2077             case DT_JMPREL:
2078               name = ".rela.plt";
2079             get_vma:
2080               s = bfd_get_section_by_name (output_bfd, name);
2081               BFD_ASSERT (s != NULL);
2082               dyn.d_un.d_ptr = s->vma;
2083               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2084               break;
2085
2086             case DT_PLTRELSZ:
2087               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2088               BFD_ASSERT (s != NULL);
2089               if (s->_cooked_size != 0)
2090                 dyn.d_un.d_val = s->_cooked_size;
2091               else
2092                 dyn.d_un.d_val = s->_raw_size;
2093               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2094               break;
2095
2096             case DT_RELASZ:
2097               /* The procedure linkage table relocs (DT_JMPREL) should
2098                  not be included in the overall relocs (DT_RELA).
2099                  Therefore, we override the DT_RELASZ entry here to
2100                  make it not include the JMPREL relocs.  Since the
2101                  linker script arranges for .rela.plt to follow all
2102                  other relocation sections, we don't have to worry
2103                  about changing the DT_RELA entry.  */
2104               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2105               if (s != NULL)
2106                 {
2107                   if (s->_cooked_size != 0)
2108                     dyn.d_un.d_val -= s->_cooked_size;
2109                   else
2110                     dyn.d_un.d_val -= s->_raw_size;
2111                 }
2112               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2113               break;
2114             }
2115         }
2116
2117       /* Fill in the first entry in the procedure linkage table.  */
2118       if (splt->_raw_size > 0)
2119         {
2120           if (!CPU32_FLAG (output_bfd))
2121             {
2122               memcpy (splt->contents, elf_m68k_plt0_entry, PLT_ENTRY_SIZE);
2123               bfd_put_32 (output_bfd,
2124                           (sgot->output_section->vma
2125                            + sgot->output_offset + 4
2126                            - (splt->output_section->vma + 2)),
2127                           splt->contents + 4);
2128               bfd_put_32 (output_bfd,
2129                           (sgot->output_section->vma
2130                            + sgot->output_offset + 8
2131                            - (splt->output_section->vma + 10)),
2132                           splt->contents + 12);
2133               elf_section_data (splt->output_section)->this_hdr.sh_entsize
2134                = PLT_ENTRY_SIZE;
2135             }
2136           else /* cpu32 */
2137             {
2138               memcpy (splt->contents, elf_cpu32_plt0_entry, PLT_CPU32_ENTRY_SIZE);
2139               bfd_put_32 (output_bfd,
2140                           (sgot->output_section->vma
2141                            + sgot->output_offset + 4
2142                            - (splt->output_section->vma + 2)),
2143                           splt->contents + 4);
2144               bfd_put_32 (output_bfd,
2145                           (sgot->output_section->vma
2146                            + sgot->output_offset + 8
2147                            - (splt->output_section->vma + 10)),
2148                           splt->contents + 10);
2149               elf_section_data (splt->output_section)->this_hdr.sh_entsize
2150                = PLT_CPU32_ENTRY_SIZE;
2151             }
2152         }
2153     }
2154
2155   /* Fill in the first three entries in the global offset table.  */
2156   if (sgot->_raw_size > 0)
2157     {
2158       if (sdyn == NULL)
2159         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2160       else
2161         bfd_put_32 (output_bfd,
2162                     sdyn->output_section->vma + sdyn->output_offset,
2163                     sgot->contents);
2164       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2165       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2166     }
2167
2168   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2169
2170   return true;
2171 }
2172
2173 #define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
2174 #define TARGET_BIG_NAME                 "elf32-m68k"
2175 #define ELF_MACHINE_CODE                EM_68K
2176 #define ELF_MAXPAGESIZE                 0x2000
2177 #define elf_backend_create_dynamic_sections \
2178                                         _bfd_elf_create_dynamic_sections
2179 #define bfd_elf32_bfd_link_hash_table_create \
2180                                         elf_m68k_link_hash_table_create
2181 #define bfd_elf32_bfd_final_link        _bfd_elf32_gc_common_final_link
2182
2183 #define elf_backend_check_relocs        elf_m68k_check_relocs
2184 #define elf_backend_adjust_dynamic_symbol \
2185                                         elf_m68k_adjust_dynamic_symbol
2186 #define elf_backend_size_dynamic_sections \
2187                                         elf_m68k_size_dynamic_sections
2188 #define elf_backend_relocate_section    elf_m68k_relocate_section
2189 #define elf_backend_finish_dynamic_symbol \
2190                                         elf_m68k_finish_dynamic_symbol
2191 #define elf_backend_finish_dynamic_sections \
2192                                         elf_m68k_finish_dynamic_sections
2193 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
2194 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
2195 #define bfd_elf32_bfd_copy_private_bfd_data \
2196                                         elf32_m68k_copy_private_bfd_data
2197 #define bfd_elf32_bfd_merge_private_bfd_data \
2198                                         elf32_m68k_merge_private_bfd_data
2199 #define bfd_elf32_bfd_set_private_flags \
2200                                         elf32_m68k_set_private_flags
2201 #define bfd_elf32_bfd_print_private_bfd_data \
2202                                         elf32_m68k_print_private_bfd_data
2203
2204 #define elf_backend_can_gc_sections 1
2205 #define elf_backend_want_got_plt 1
2206 #define elf_backend_plt_readonly 1
2207 #define elf_backend_want_plt_sym 0
2208 #define elf_backend_got_header_size     12
2209
2210 #include "elf32-target.h"