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