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