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