bfd/elf32-m68k.c

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