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