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   if (info->relocatable)
1097     return TRUE;
1098
1099   dynobj = elf_hash_table (info)->dynobj;
1100   if (dynobj == NULL)
1101     return TRUE;
1102
1103   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1104   sym_hashes = elf_sym_hashes (abfd);
1105   local_got_refcounts = elf_local_got_refcounts (abfd);
1106
1107   sgot = bfd_get_section_by_name (dynobj, ".got");
1108   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1109
1110   relend = relocs + sec->reloc_count;
1111   for (rel = relocs; rel < relend; rel++)
1112     {
1113       unsigned long r_symndx;
1114       struct elf_link_hash_entry *h = NULL;
1115
1116       r_symndx = ELF32_R_SYM (rel->r_info);
1117       if (r_symndx >= symtab_hdr->sh_info)
1118         {
1119           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1120           while (h->root.type == bfd_link_hash_indirect
1121                  || h->root.type == bfd_link_hash_warning)
1122             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1123         }
1124
1125       switch (ELF32_R_TYPE (rel->r_info))
1126         {
1127         case R_68K_GOT8:
1128         case R_68K_GOT16:
1129         case R_68K_GOT32:
1130         case R_68K_GOT8O:
1131         case R_68K_GOT16O:
1132         case R_68K_GOT32O:
1133           if (h != NULL)
1134             {
1135               if (h->got.refcount > 0)
1136                 {
1137                   --h->got.refcount;
1138                   if (h->got.refcount == 0)
1139                     {
1140                       /* We don't need the .got entry any more.  */
1141                       sgot->size -= 4;
1142                       srelgot->size -= sizeof (Elf32_External_Rela);
1143                     }
1144                 }
1145             }
1146           else if (local_got_refcounts != NULL)
1147             {
1148               if (local_got_refcounts[r_symndx] > 0)
1149                 {
1150                   --local_got_refcounts[r_symndx];
1151                   if (local_got_refcounts[r_symndx] == 0)
1152                     {
1153                       /* We don't need the .got entry any more.  */
1154                       sgot->size -= 4;
1155                       if (info->shared)
1156                         srelgot->size -= sizeof (Elf32_External_Rela);
1157                     }
1158                 }
1159             }
1160           break;
1161
1162         case R_68K_PLT8:
1163         case R_68K_PLT16:
1164         case R_68K_PLT32:
1165         case R_68K_PLT8O:
1166         case R_68K_PLT16O:
1167         case R_68K_PLT32O:
1168         case R_68K_PC8:
1169         case R_68K_PC16:
1170         case R_68K_PC32:
1171         case R_68K_8:
1172         case R_68K_16:
1173         case R_68K_32:
1174           if (h != NULL)
1175             {
1176               if (h->plt.refcount > 0)
1177                 --h->plt.refcount;
1178             }
1179           break;
1180
1181         default:
1182           break;
1183         }
1184     }
1185
1186   return TRUE;
1187 }
1188 \f
1189 /* Return the type of PLT associated with OUTPUT_BFD.  */
1190
1191 static const struct elf_m68k_plt_info *
1192 elf_m68k_get_plt_info (bfd *output_bfd)
1193 {
1194   unsigned int features;
1195
1196   features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
1197   if (features & cpu32)
1198     return &elf_cpu32_plt_info;
1199   if (features & mcfisa_b)
1200     return &elf_isab_plt_info;
1201   if (features & mcfisa_c)
1202     return &elf_isac_plt_info;
1203   return &elf_m68k_plt_info;
1204 }
1205
1206 /* This function is called after all the input files have been read,
1207    and the input sections have been assigned to output sections.
1208    It's a convenient place to determine the PLT style.  */
1209
1210 static bfd_boolean
1211 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1212 {
1213   elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
1214   return TRUE;
1215 }
1216
1217 /* Adjust a symbol defined by a dynamic object and referenced by a
1218    regular object.  The current definition is in some section of the
1219    dynamic object, but we're not including those sections.  We have to
1220    change the definition to something the rest of the link can
1221    understand.  */
1222
1223 static bfd_boolean
1224 elf_m68k_adjust_dynamic_symbol (info, h)
1225      struct bfd_link_info *info;
1226      struct elf_link_hash_entry *h;
1227 {
1228   struct elf_m68k_link_hash_table *htab;
1229   bfd *dynobj;
1230   asection *s;
1231
1232   htab = elf_m68k_hash_table (info);
1233   dynobj = elf_hash_table (info)->dynobj;
1234
1235   /* Make sure we know what is going on here.  */
1236   BFD_ASSERT (dynobj != NULL
1237               && (h->needs_plt
1238                   || h->u.weakdef != NULL
1239                   || (h->def_dynamic
1240                       && h->ref_regular
1241                       && !h->def_regular)));
1242
1243   /* If this is a function, put it in the procedure linkage table.  We
1244      will fill in the contents of the procedure linkage table later,
1245      when we know the address of the .got section.  */
1246   if (h->type == STT_FUNC
1247       || h->needs_plt)
1248     {
1249       if ((h->plt.refcount <= 0
1250            || SYMBOL_CALLS_LOCAL (info, h)
1251            || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1252                && h->root.type == bfd_link_hash_undefweak))
1253           /* We must always create the plt entry if it was referenced
1254              by a PLTxxO relocation.  In this case we already recorded
1255              it as a dynamic symbol.  */
1256           && h->dynindx == -1)
1257         {
1258           /* This case can occur if we saw a PLTxx reloc in an input
1259              file, but the symbol was never referred to by a dynamic
1260              object, or if all references were garbage collected.  In
1261              such a case, we don't actually need to build a procedure
1262              linkage table, and we can just do a PCxx reloc instead.  */
1263           h->plt.offset = (bfd_vma) -1;
1264           h->needs_plt = 0;
1265           return TRUE;
1266         }
1267
1268       /* Make sure this symbol is output as a dynamic symbol.  */
1269       if (h->dynindx == -1
1270           && !h->forced_local)
1271         {
1272           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1273             return FALSE;
1274         }
1275
1276       s = bfd_get_section_by_name (dynobj, ".plt");
1277       BFD_ASSERT (s != NULL);
1278
1279       /* If this is the first .plt entry, make room for the special
1280          first entry.  */
1281       if (s->size == 0)
1282         s->size = htab->plt_info->size;
1283
1284       /* If this symbol is not defined in a regular file, and we are
1285          not generating a shared library, then set the symbol to this
1286          location in the .plt.  This is required to make function
1287          pointers compare as equal between the normal executable and
1288          the shared library.  */
1289       if (!info->shared
1290           && !h->def_regular)
1291         {
1292           h->root.u.def.section = s;
1293           h->root.u.def.value = s->size;
1294         }
1295
1296       h->plt.offset = s->size;
1297
1298       /* Make room for this entry.  */
1299       s->size += htab->plt_info->size;
1300
1301       /* We also need to make an entry in the .got.plt section, which
1302          will be placed in the .got section by the linker script.  */
1303       s = bfd_get_section_by_name (dynobj, ".got.plt");
1304       BFD_ASSERT (s != NULL);
1305       s->size += 4;
1306
1307       /* We also need to make an entry in the .rela.plt section.  */
1308       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1309       BFD_ASSERT (s != NULL);
1310       s->size += sizeof (Elf32_External_Rela);
1311
1312       return TRUE;
1313     }
1314
1315   /* Reinitialize the plt offset now that it is not used as a reference
1316      count any more.  */
1317   h->plt.offset = (bfd_vma) -1;
1318
1319   /* If this is a weak symbol, and there is a real definition, the
1320      processor independent code will have arranged for us to see the
1321      real definition first, and we can just use the same value.  */
1322   if (h->u.weakdef != NULL)
1323     {
1324       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1325                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1326       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1327       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1328       return TRUE;
1329     }
1330
1331   /* This is a reference to a symbol defined by a dynamic object which
1332      is not a function.  */
1333
1334   /* If we are creating a shared library, we must presume that the
1335      only references to the symbol are via the global offset table.
1336      For such cases we need not do anything here; the relocations will
1337      be handled correctly by relocate_section.  */
1338   if (info->shared)
1339     return TRUE;
1340
1341   if (h->size == 0)
1342     {
1343       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1344                              h->root.root.string);
1345       return TRUE;
1346     }
1347
1348   /* We must allocate the symbol in our .dynbss section, which will
1349      become part of the .bss section of the executable.  There will be
1350      an entry for this symbol in the .dynsym section.  The dynamic
1351      object will contain position independent code, so all references
1352      from the dynamic object to this symbol will go through the global
1353      offset table.  The dynamic linker will use the .dynsym entry to
1354      determine the address it must put in the global offset table, so
1355      both the dynamic object and the regular object will refer to the
1356      same memory location for the variable.  */
1357
1358   s = bfd_get_section_by_name (dynobj, ".dynbss");
1359   BFD_ASSERT (s != NULL);
1360
1361   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1362      copy the initial value out of the dynamic object and into the
1363      runtime process image.  We need to remember the offset into the
1364      .rela.bss section we are going to use.  */
1365   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1366     {
1367       asection *srel;
1368
1369       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1370       BFD_ASSERT (srel != NULL);
1371       srel->size += sizeof (Elf32_External_Rela);
1372       h->needs_copy = 1;
1373     }
1374
1375   return _bfd_elf_adjust_dynamic_copy (h, s);
1376 }
1377
1378 /* Set the sizes of the dynamic sections.  */
1379
1380 static bfd_boolean
1381 elf_m68k_size_dynamic_sections (output_bfd, info)
1382      bfd *output_bfd ATTRIBUTE_UNUSED;
1383      struct bfd_link_info *info;
1384 {
1385   bfd *dynobj;
1386   asection *s;
1387   bfd_boolean plt;
1388   bfd_boolean relocs;
1389
1390   dynobj = elf_hash_table (info)->dynobj;
1391   BFD_ASSERT (dynobj != NULL);
1392
1393   if (elf_hash_table (info)->dynamic_sections_created)
1394     {
1395       /* Set the contents of the .interp section to the interpreter.  */
1396       if (info->executable)
1397         {
1398           s = bfd_get_section_by_name (dynobj, ".interp");
1399           BFD_ASSERT (s != NULL);
1400           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1401           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1402         }
1403     }
1404   else
1405     {
1406       /* We may have created entries in the .rela.got section.
1407          However, if we are not creating the dynamic sections, we will
1408          not actually use these entries.  Reset the size of .rela.got,
1409          which will cause it to get stripped from the output file
1410          below.  */
1411       s = bfd_get_section_by_name (dynobj, ".rela.got");
1412       if (s != NULL)
1413         s->size = 0;
1414     }
1415
1416   /* If this is a -Bsymbolic shared link, then we need to discard all
1417      PC relative relocs against symbols defined in a regular object.
1418      For the normal shared case we discard the PC relative relocs
1419      against symbols that have become local due to visibility changes.
1420      We allocated space for them in the check_relocs routine, but we
1421      will not fill them in in the relocate_section routine.  */
1422   if (info->shared)
1423     elf_link_hash_traverse (elf_hash_table (info),
1424                             elf_m68k_discard_copies,
1425                             (PTR) info);
1426
1427   /* The check_relocs and adjust_dynamic_symbol entry points have
1428      determined the sizes of the various dynamic sections.  Allocate
1429      memory for them.  */
1430   plt = FALSE;
1431   relocs = FALSE;
1432   for (s = dynobj->sections; s != NULL; s = s->next)
1433     {
1434       const char *name;
1435
1436       if ((s->flags & SEC_LINKER_CREATED) == 0)
1437         continue;
1438
1439       /* It's OK to base decisions on the section name, because none
1440          of the dynobj section names depend upon the input files.  */
1441       name = bfd_get_section_name (dynobj, s);
1442
1443       if (strcmp (name, ".plt") == 0)
1444         {
1445           /* Remember whether there is a PLT.  */
1446           plt = s->size != 0;
1447         }
1448       else if (CONST_STRNEQ (name, ".rela"))
1449         {
1450           if (s->size != 0)
1451             {
1452               relocs = TRUE;
1453
1454               /* We use the reloc_count field as a counter if we need
1455                  to copy relocs into the output file.  */
1456               s->reloc_count = 0;
1457             }
1458         }
1459       else if (! CONST_STRNEQ (name, ".got")
1460                && strcmp (name, ".dynbss") != 0)
1461         {
1462           /* It's not one of our sections, so don't allocate space.  */
1463           continue;
1464         }
1465
1466       if (s->size == 0)
1467         {
1468           /* If we don't need this section, strip it from the
1469              output file.  This is mostly to handle .rela.bss and
1470              .rela.plt.  We must create both sections in
1471              create_dynamic_sections, because they must be created
1472              before the linker maps input sections to output
1473              sections.  The linker does that before
1474              adjust_dynamic_symbol is called, and it is that
1475              function which decides whether anything needs to go
1476              into these sections.  */
1477           s->flags |= SEC_EXCLUDE;
1478           continue;
1479         }
1480
1481       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1482         continue;
1483
1484       /* Allocate memory for the section contents.  */
1485       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1486          Unused entries should be reclaimed before the section's contents
1487          are written out, but at the moment this does not happen.  Thus in
1488          order to prevent writing out garbage, we initialise the section's
1489          contents to zero.  */
1490       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1491       if (s->contents == NULL)
1492         return FALSE;
1493     }
1494
1495   if (elf_hash_table (info)->dynamic_sections_created)
1496     {
1497       /* Add some entries to the .dynamic section.  We fill in the
1498          values later, in elf_m68k_finish_dynamic_sections, but we
1499          must add the entries now so that we get the correct size for
1500          the .dynamic section.  The DT_DEBUG entry is filled in by the
1501          dynamic linker and used by the debugger.  */
1502 #define add_dynamic_entry(TAG, VAL) \
1503   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1504
1505       if (!info->shared)
1506         {
1507           if (!add_dynamic_entry (DT_DEBUG, 0))
1508             return FALSE;
1509         }
1510
1511       if (plt)
1512         {
1513           if (!add_dynamic_entry (DT_PLTGOT, 0)
1514               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1515               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1516               || !add_dynamic_entry (DT_JMPREL, 0))
1517             return FALSE;
1518         }
1519
1520       if (relocs)
1521         {
1522           if (!add_dynamic_entry (DT_RELA, 0)
1523               || !add_dynamic_entry (DT_RELASZ, 0)
1524               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1525             return FALSE;
1526         }
1527
1528       if ((info->flags & DF_TEXTREL) != 0)
1529         {
1530           if (!add_dynamic_entry (DT_TEXTREL, 0))
1531             return FALSE;
1532         }
1533     }
1534 #undef add_dynamic_entry
1535
1536   return TRUE;
1537 }
1538
1539 /* This function is called via elf_link_hash_traverse if we are
1540    creating a shared object.  In the -Bsymbolic case it discards the
1541    space allocated to copy PC relative relocs against symbols which
1542    are defined in regular objects.  For the normal shared case, it
1543    discards space for pc-relative relocs that have become local due to
1544    symbol visibility changes.  We allocated space for them in the
1545    check_relocs routine, but we won't fill them in in the
1546    relocate_section routine.
1547
1548    We also check whether any of the remaining relocations apply
1549    against a readonly section, and set the DF_TEXTREL flag in this
1550    case.  */
1551
1552 static bfd_boolean
1553 elf_m68k_discard_copies (h, inf)
1554      struct elf_link_hash_entry *h;
1555      PTR inf;
1556 {
1557   struct bfd_link_info *info = (struct bfd_link_info *) inf;
1558   struct elf_m68k_pcrel_relocs_copied *s;
1559
1560   if (h->root.type == bfd_link_hash_warning)
1561     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1562
1563   if (!h->def_regular
1564       || (!info->symbolic
1565           && !h->forced_local))
1566     {
1567       if ((info->flags & DF_TEXTREL) == 0)
1568         {
1569           /* Look for relocations against read-only sections.  */
1570           for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1571                s != NULL;
1572                s = s->next)
1573             if ((s->section->flags & SEC_READONLY) != 0)
1574               {
1575                 info->flags |= DF_TEXTREL;
1576                 break;
1577               }
1578         }
1579
1580       return TRUE;
1581     }
1582
1583   for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1584        s != NULL;
1585        s = s->next)
1586     s->section->size -= s->count * sizeof (Elf32_External_Rela);
1587
1588   return TRUE;
1589 }
1590
1591 /* Relocate an M68K ELF section.  */
1592
1593 static bfd_boolean
1594 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1595                            contents, relocs, local_syms, local_sections)
1596      bfd *output_bfd;
1597      struct bfd_link_info *info;
1598      bfd *input_bfd;
1599      asection *input_section;
1600      bfd_byte *contents;
1601      Elf_Internal_Rela *relocs;
1602      Elf_Internal_Sym *local_syms;
1603      asection **local_sections;
1604 {
1605   bfd *dynobj;
1606   Elf_Internal_Shdr *symtab_hdr;
1607   struct elf_link_hash_entry **sym_hashes;
1608   bfd_vma *local_got_offsets;
1609   asection *sgot;
1610   asection *splt;
1611   asection *sreloc;
1612   Elf_Internal_Rela *rel;
1613   Elf_Internal_Rela *relend;
1614
1615   dynobj = elf_hash_table (info)->dynobj;
1616   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1617   sym_hashes = elf_sym_hashes (input_bfd);
1618   local_got_offsets = elf_local_got_offsets (input_bfd);
1619
1620   sgot = NULL;
1621   splt = NULL;
1622   sreloc = NULL;
1623
1624   rel = relocs;
1625   relend = relocs + input_section->reloc_count;
1626   for (; rel < relend; rel++)
1627     {
1628       int r_type;
1629       reloc_howto_type *howto;
1630       unsigned long r_symndx;
1631       struct elf_link_hash_entry *h;
1632       Elf_Internal_Sym *sym;
1633       asection *sec;
1634       bfd_vma relocation;
1635       bfd_boolean unresolved_reloc;
1636       bfd_reloc_status_type r;
1637
1638       r_type = ELF32_R_TYPE (rel->r_info);
1639       if (r_type < 0 || r_type >= (int) R_68K_max)
1640         {
1641           bfd_set_error (bfd_error_bad_value);
1642           return FALSE;
1643         }
1644       howto = howto_table + r_type;
1645
1646       r_symndx = ELF32_R_SYM (rel->r_info);
1647
1648       h = NULL;
1649       sym = NULL;
1650       sec = NULL;
1651       unresolved_reloc = FALSE;
1652
1653       if (r_symndx < symtab_hdr->sh_info)
1654         {
1655           sym = local_syms + r_symndx;
1656           sec = local_sections[r_symndx];
1657           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1658         }
1659       else
1660         {
1661           bfd_boolean warned;
1662
1663           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1664                                    r_symndx, symtab_hdr, sym_hashes,
1665                                    h, sec, relocation,
1666                                    unresolved_reloc, warned);
1667         }
1668
1669       if (sec != NULL && elf_discarded_section (sec))
1670         {
1671           /* For relocs against symbols from removed linkonce sections,
1672              or sections discarded by a linker script, we just want the
1673              section contents zeroed.  Avoid any special processing.  */
1674           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1675           rel->r_info = 0;
1676           rel->r_addend = 0;
1677           continue;
1678         }
1679
1680       if (info->relocatable)
1681         continue;
1682
1683       switch (r_type)
1684         {
1685         case R_68K_GOT8:
1686         case R_68K_GOT16:
1687         case R_68K_GOT32:
1688           /* Relocation is to the address of the entry for this symbol
1689              in the global offset table.  */
1690           if (h != NULL
1691               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1692             break;
1693           /* Fall through.  */
1694         case R_68K_GOT8O:
1695         case R_68K_GOT16O:
1696         case R_68K_GOT32O:
1697           /* Relocation is the offset of the entry for this symbol in
1698              the global offset table.  */
1699
1700           {
1701             bfd_vma off;
1702
1703             if (sgot == NULL)
1704               {
1705                 sgot = bfd_get_section_by_name (dynobj, ".got");
1706                 BFD_ASSERT (sgot != NULL);
1707               }
1708
1709             if (h != NULL)
1710               {
1711                 bfd_boolean dyn;
1712
1713                 off = h->got.offset;
1714                 BFD_ASSERT (off != (bfd_vma) -1);
1715
1716                 dyn = elf_hash_table (info)->dynamic_sections_created;
1717                 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1718                     || (info->shared
1719                         && (info->symbolic
1720                             || h->dynindx == -1
1721                             || h->forced_local)
1722                         && h->def_regular))
1723                   {
1724                     /* This is actually a static link, or it is a
1725                        -Bsymbolic link and the symbol is defined
1726                        locally, or the symbol was forced to be local
1727                        because of a version file..  We must initialize
1728                        this entry in the global offset table.  Since
1729                        the offset must always be a multiple of 4, we
1730                        use the least significant bit to record whether
1731                        we have initialized it already.
1732
1733                        When doing a dynamic link, we create a .rela.got
1734                        relocation entry to initialize the value.  This
1735                        is done in the finish_dynamic_symbol routine.  */
1736                     if ((off & 1) != 0)
1737                       off &= ~1;
1738                     else
1739                       {
1740                         bfd_put_32 (output_bfd, relocation,
1741                                     sgot->contents + off);
1742                         h->got.offset |= 1;
1743                       }
1744                   }
1745                 else
1746                   unresolved_reloc = FALSE;
1747               }
1748             else
1749               {
1750                 BFD_ASSERT (local_got_offsets != NULL
1751                             && local_got_offsets[r_symndx] != (bfd_vma) -1);
1752
1753                 off = local_got_offsets[r_symndx];
1754
1755                 /* The offset must always be a multiple of 4.  We use
1756                    the least significant bit to record whether we have
1757                    already generated the necessary reloc.  */
1758                 if ((off & 1) != 0)
1759                   off &= ~1;
1760                 else
1761                   {
1762                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1763
1764                     if (info->shared)
1765                       {
1766                         asection *s;
1767                         Elf_Internal_Rela outrel;
1768                         bfd_byte *loc;
1769
1770                         s = bfd_get_section_by_name (dynobj, ".rela.got");
1771                         BFD_ASSERT (s != NULL);
1772
1773                         outrel.r_offset = (sgot->output_section->vma
1774                                            + sgot->output_offset
1775                                            + off);
1776                         outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1777                         outrel.r_addend = relocation;
1778                         loc = s->contents;
1779                         loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1780                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1781                       }
1782
1783                     local_got_offsets[r_symndx] |= 1;
1784                   }
1785               }
1786
1787             relocation = sgot->output_offset + off;
1788             if (r_type == R_68K_GOT8O
1789                 || r_type == R_68K_GOT16O
1790                 || r_type == R_68K_GOT32O)
1791               {
1792                 /* This relocation does not use the addend.  */
1793                 rel->r_addend = 0;
1794               }
1795             else
1796               relocation += sgot->output_section->vma;
1797           }
1798           break;
1799
1800         case R_68K_PLT8:
1801         case R_68K_PLT16:
1802         case R_68K_PLT32:
1803           /* Relocation is to the entry for this symbol in the
1804              procedure linkage table.  */
1805
1806           /* Resolve a PLTxx reloc against a local symbol directly,
1807              without using the procedure linkage table.  */
1808           if (h == NULL)
1809             break;
1810
1811           if (h->plt.offset == (bfd_vma) -1
1812               || !elf_hash_table (info)->dynamic_sections_created)
1813             {
1814               /* We didn't make a PLT entry for this symbol.  This
1815                  happens when statically linking PIC code, or when
1816                  using -Bsymbolic.  */
1817               break;
1818             }
1819
1820           if (splt == NULL)
1821             {
1822               splt = bfd_get_section_by_name (dynobj, ".plt");
1823               BFD_ASSERT (splt != NULL);
1824             }
1825
1826           relocation = (splt->output_section->vma
1827                         + splt->output_offset
1828                         + h->plt.offset);
1829           unresolved_reloc = FALSE;
1830           break;
1831
1832         case R_68K_PLT8O:
1833         case R_68K_PLT16O:
1834         case R_68K_PLT32O:
1835           /* Relocation is the offset of the entry for this symbol in
1836              the procedure linkage table.  */
1837           BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1838
1839           if (splt == NULL)
1840             {
1841               splt = bfd_get_section_by_name (dynobj, ".plt");
1842               BFD_ASSERT (splt != NULL);
1843             }
1844
1845           relocation = h->plt.offset;
1846           unresolved_reloc = FALSE;
1847
1848           /* This relocation does not use the addend.  */
1849           rel->r_addend = 0;
1850
1851           break;
1852
1853         case R_68K_PC8:
1854         case R_68K_PC16:
1855         case R_68K_PC32:
1856           if (h == NULL
1857               || (info->shared
1858                   && h->forced_local))
1859             break;
1860           /* Fall through.  */
1861         case R_68K_8:
1862         case R_68K_16:
1863         case R_68K_32:
1864           if (info->shared
1865               && r_symndx != 0
1866               && (input_section->flags & SEC_ALLOC) != 0
1867               && (h == NULL
1868                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1869                   || h->root.type != bfd_link_hash_undefweak)
1870               && ((r_type != R_68K_PC8
1871                    && r_type != R_68K_PC16
1872                    && r_type != R_68K_PC32)
1873                   || (h != NULL
1874                       && h->dynindx != -1
1875                       && (!info->symbolic
1876                           || !h->def_regular))))
1877             {
1878               Elf_Internal_Rela outrel;
1879               bfd_byte *loc;
1880               bfd_boolean skip, relocate;
1881
1882               /* When generating a shared object, these relocations
1883                  are copied into the output file to be resolved at run
1884                  time.  */
1885
1886               skip = FALSE;
1887               relocate = FALSE;
1888
1889               outrel.r_offset =
1890                 _bfd_elf_section_offset (output_bfd, info, input_section,
1891                                          rel->r_offset);
1892               if (outrel.r_offset == (bfd_vma) -1)
1893                 skip = TRUE;
1894               else if (outrel.r_offset == (bfd_vma) -2)
1895                 skip = TRUE, relocate = TRUE;
1896               outrel.r_offset += (input_section->output_section->vma
1897                                   + input_section->output_offset);
1898
1899               if (skip)
1900                 memset (&outrel, 0, sizeof outrel);
1901               else if (h != NULL
1902                        && h->dynindx != -1
1903                        && (r_type == R_68K_PC8
1904                            || r_type == R_68K_PC16
1905                            || r_type == R_68K_PC32
1906                            || !info->shared
1907                            || !info->symbolic
1908                            || !h->def_regular))
1909                 {
1910                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1911                   outrel.r_addend = rel->r_addend;
1912                 }
1913               else
1914                 {
1915                   /* This symbol is local, or marked to become local.  */
1916                   outrel.r_addend = relocation + rel->r_addend;
1917
1918                   if (r_type == R_68K_32)
1919                     {
1920                       relocate = TRUE;
1921                       outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1922                     }
1923                   else
1924                     {
1925                       long indx;
1926
1927                       if (bfd_is_abs_section (sec))
1928                         indx = 0;
1929                       else if (sec == NULL || sec->owner == NULL)
1930                         {
1931                           bfd_set_error (bfd_error_bad_value);
1932                           return FALSE;
1933                         }
1934                       else
1935                         {
1936                           asection *osec;
1937
1938                           /* We are turning this relocation into one
1939                              against a section symbol.  It would be
1940                              proper to subtract the symbol's value,
1941                              osec->vma, from the emitted reloc addend,
1942                              but ld.so expects buggy relocs.  */
1943                           osec = sec->output_section;
1944                           indx = elf_section_data (osec)->dynindx;
1945                           if (indx == 0)
1946                             {
1947                               struct elf_link_hash_table *htab;
1948                               htab = elf_hash_table (info);
1949                               osec = htab->text_index_section;
1950                               indx = elf_section_data (osec)->dynindx;
1951                             }
1952                           BFD_ASSERT (indx != 0);
1953                         }
1954
1955                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1956                     }
1957                 }
1958
1959               sreloc = elf_section_data (input_section)->sreloc;
1960               if (sreloc == NULL)
1961                 abort ();
1962
1963               loc = sreloc->contents;
1964               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1965               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1966
1967               /* This reloc will be computed at runtime, so there's no
1968                  need to do anything now, except for R_68K_32
1969                  relocations that have been turned into
1970                  R_68K_RELATIVE.  */
1971               if (!relocate)
1972                 continue;
1973             }
1974
1975           break;
1976
1977         case R_68K_GNU_VTINHERIT:
1978         case R_68K_GNU_VTENTRY:
1979           /* These are no-ops in the end.  */
1980           continue;
1981
1982         default:
1983           break;
1984         }
1985
1986       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1987          because such sections are not SEC_ALLOC and thus ld.so will
1988          not process them.  */
1989       if (unresolved_reloc
1990           && !((input_section->flags & SEC_DEBUGGING) != 0
1991                && h->def_dynamic))
1992         {
1993           (*_bfd_error_handler)
1994             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1995              input_bfd,
1996              input_section,
1997              (long) rel->r_offset,
1998              howto->name,
1999              h->root.root.string);
2000           return FALSE;
2001         }
2002
2003       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2004                                     contents, rel->r_offset,
2005                                     relocation, rel->r_addend);
2006
2007       if (r != bfd_reloc_ok)
2008         {
2009           const char *name;
2010
2011           if (h != NULL)
2012             name = h->root.root.string;
2013           else
2014             {
2015               name = bfd_elf_string_from_elf_section (input_bfd,
2016                                                       symtab_hdr->sh_link,
2017                                                       sym->st_name);
2018               if (name == NULL)
2019                 return FALSE;
2020               if (*name == '\0')
2021                 name = bfd_section_name (input_bfd, sec);
2022             }
2023
2024           if (r == bfd_reloc_overflow)
2025             {
2026               if (!(info->callbacks->reloc_overflow
2027                     (info, (h ? &h->root : NULL), name, howto->name,
2028                      (bfd_vma) 0, input_bfd, input_section,
2029                      rel->r_offset)))
2030                 return FALSE;
2031             }
2032           else
2033             {
2034               (*_bfd_error_handler)
2035                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2036                  input_bfd, input_section,
2037                  (long) rel->r_offset, name, (int) r);
2038               return FALSE;
2039             }
2040         }
2041     }
2042
2043   return TRUE;
2044 }
2045
2046 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
2047    into section SEC.  */
2048
2049 static void
2050 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
2051 {
2052   /* Make VALUE PC-relative.  */
2053   value -= sec->output_section->vma + offset;
2054
2055   /* Apply any in-place addend.  */
2056   value += bfd_get_32 (sec->owner, sec->contents + offset);
2057
2058   bfd_put_32 (sec->owner, value, sec->contents + offset);
2059 }
2060
2061 /* Finish up dynamic symbol handling.  We set the contents of various
2062    dynamic sections here.  */
2063
2064 static bfd_boolean
2065 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
2066      bfd *output_bfd;
2067      struct bfd_link_info *info;
2068      struct elf_link_hash_entry *h;
2069      Elf_Internal_Sym *sym;
2070 {
2071   bfd *dynobj;
2072
2073   dynobj = elf_hash_table (info)->dynobj;
2074
2075   if (h->plt.offset != (bfd_vma) -1)
2076     {
2077       const struct elf_m68k_plt_info *plt_info;
2078       asection *splt;
2079       asection *sgot;
2080       asection *srela;
2081       bfd_vma plt_index;
2082       bfd_vma got_offset;
2083       Elf_Internal_Rela rela;
2084       bfd_byte *loc;
2085
2086       /* This symbol has an entry in the procedure linkage table.  Set
2087          it up.  */
2088
2089       BFD_ASSERT (h->dynindx != -1);
2090
2091       plt_info = elf_m68k_hash_table (info)->plt_info;
2092       splt = bfd_get_section_by_name (dynobj, ".plt");
2093       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2094       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2095       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2096
2097       /* Get the index in the procedure linkage table which
2098          corresponds to this symbol.  This is the index of this symbol
2099          in all the symbols for which we are making plt entries.  The
2100          first entry in the procedure linkage table is reserved.  */
2101       plt_index = (h->plt.offset / plt_info->size) - 1;
2102
2103       /* Get the offset into the .got table of the entry that
2104          corresponds to this function.  Each .got entry is 4 bytes.
2105          The first three are reserved.  */
2106       got_offset = (plt_index + 3) * 4;
2107
2108       memcpy (splt->contents + h->plt.offset,
2109               plt_info->symbol_entry,
2110               plt_info->size);
2111
2112       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2113                              (sgot->output_section->vma
2114                               + sgot->output_offset
2115                               + got_offset));
2116
2117       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2118                   splt->contents
2119                   + h->plt.offset
2120                   + plt_info->symbol_resolve_entry + 2);
2121
2122       elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2123                              splt->output_section->vma);
2124
2125       /* Fill in the entry in the global offset table.  */
2126       bfd_put_32 (output_bfd,
2127                   (splt->output_section->vma
2128                    + splt->output_offset
2129                    + h->plt.offset
2130                    + plt_info->symbol_resolve_entry),
2131                   sgot->contents + got_offset);
2132
2133       /* Fill in the entry in the .rela.plt section.  */
2134       rela.r_offset = (sgot->output_section->vma
2135                        + sgot->output_offset
2136                        + got_offset);
2137       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2138       rela.r_addend = 0;
2139       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2140       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2141
2142       if (!h->def_regular)
2143         {
2144           /* Mark the symbol as undefined, rather than as defined in
2145              the .plt section.  Leave the value alone.  */
2146           sym->st_shndx = SHN_UNDEF;
2147         }
2148     }
2149
2150   if (h->got.offset != (bfd_vma) -1)
2151     {
2152       asection *sgot;
2153       asection *srela;
2154       Elf_Internal_Rela rela;
2155       bfd_byte *loc;
2156
2157       /* This symbol has an entry in the global offset table.  Set it
2158          up.  */
2159
2160       sgot = bfd_get_section_by_name (dynobj, ".got");
2161       srela = bfd_get_section_by_name (dynobj, ".rela.got");
2162       BFD_ASSERT (sgot != NULL && srela != NULL);
2163
2164       rela.r_offset = (sgot->output_section->vma
2165                        + sgot->output_offset
2166                        + (h->got.offset &~ (bfd_vma) 1));
2167
2168       /* If this is a -Bsymbolic link, and the symbol is defined
2169          locally, we just want to emit a RELATIVE reloc.  Likewise if
2170          the symbol was forced to be local because of a version file.
2171          The entry in the global offset table will already have been
2172          initialized in the relocate_section function.  */
2173       if (info->shared
2174           && (info->symbolic
2175               || h->dynindx == -1
2176               || h->forced_local)
2177           && h->def_regular)
2178         {
2179           rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2180           rela.r_addend = bfd_get_signed_32 (output_bfd,
2181                                              (sgot->contents
2182                                               + (h->got.offset &~ (bfd_vma) 1)));
2183         }
2184       else
2185         {
2186           bfd_put_32 (output_bfd, (bfd_vma) 0,
2187                       sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2188           rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2189           rela.r_addend = 0;
2190         }
2191
2192       loc = srela->contents;
2193       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2194       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2195     }
2196
2197   if (h->needs_copy)
2198     {
2199       asection *s;
2200       Elf_Internal_Rela rela;
2201       bfd_byte *loc;
2202
2203       /* This symbol needs a copy reloc.  Set it up.  */
2204
2205       BFD_ASSERT (h->dynindx != -1
2206                   && (h->root.type == bfd_link_hash_defined
2207                       || h->root.type == bfd_link_hash_defweak));
2208
2209       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2210                                    ".rela.bss");
2211       BFD_ASSERT (s != NULL);
2212
2213       rela.r_offset = (h->root.u.def.value
2214                        + h->root.u.def.section->output_section->vma
2215                        + h->root.u.def.section->output_offset);
2216       rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2217       rela.r_addend = 0;
2218       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2219       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2220     }
2221
2222   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2223   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2224       || h == elf_hash_table (info)->hgot)
2225     sym->st_shndx = SHN_ABS;
2226
2227   return TRUE;
2228 }
2229
2230 /* Finish up the dynamic sections.  */
2231
2232 static bfd_boolean
2233 elf_m68k_finish_dynamic_sections (output_bfd, info)
2234      bfd *output_bfd;
2235      struct bfd_link_info *info;
2236 {
2237   bfd *dynobj;
2238   asection *sgot;
2239   asection *sdyn;
2240
2241   dynobj = elf_hash_table (info)->dynobj;
2242
2243   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2244   BFD_ASSERT (sgot != NULL);
2245   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2246
2247   if (elf_hash_table (info)->dynamic_sections_created)
2248     {
2249       asection *splt;
2250       Elf32_External_Dyn *dyncon, *dynconend;
2251
2252       splt = bfd_get_section_by_name (dynobj, ".plt");
2253       BFD_ASSERT (splt != NULL && sdyn != NULL);
2254
2255       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2256       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2257       for (; dyncon < dynconend; dyncon++)
2258         {
2259           Elf_Internal_Dyn dyn;
2260           const char *name;
2261           asection *s;
2262
2263           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2264
2265           switch (dyn.d_tag)
2266             {
2267             default:
2268               break;
2269
2270             case DT_PLTGOT:
2271               name = ".got";
2272               goto get_vma;
2273             case DT_JMPREL:
2274               name = ".rela.plt";
2275             get_vma:
2276               s = bfd_get_section_by_name (output_bfd, name);
2277               BFD_ASSERT (s != NULL);
2278               dyn.d_un.d_ptr = s->vma;
2279               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2280               break;
2281
2282             case DT_PLTRELSZ:
2283               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2284               BFD_ASSERT (s != NULL);
2285               dyn.d_un.d_val = s->size;
2286               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2287               break;
2288
2289             case DT_RELASZ:
2290               /* The procedure linkage table relocs (DT_JMPREL) should
2291                  not be included in the overall relocs (DT_RELA).
2292                  Therefore, we override the DT_RELASZ entry here to
2293                  make it not include the JMPREL relocs.  Since the
2294                  linker script arranges for .rela.plt to follow all
2295                  other relocation sections, we don't have to worry
2296                  about changing the DT_RELA entry.  */
2297               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2298               if (s != NULL)
2299                 dyn.d_un.d_val -= s->size;
2300               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2301               break;
2302             }
2303         }
2304
2305       /* Fill in the first entry in the procedure linkage table.  */
2306       if (splt->size > 0)
2307         {
2308           const struct elf_m68k_plt_info *plt_info;
2309
2310           plt_info = elf_m68k_hash_table (info)->plt_info;
2311           memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2312
2313           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2314                                  (sgot->output_section->vma
2315                                   + sgot->output_offset
2316                                   + 4));
2317
2318           elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2319                                  (sgot->output_section->vma
2320                                   + sgot->output_offset
2321                                   + 8));
2322
2323           elf_section_data (splt->output_section)->this_hdr.sh_entsize
2324             = plt_info->size;
2325         }
2326     }
2327
2328   /* Fill in the first three entries in the global offset table.  */
2329   if (sgot->size > 0)
2330     {
2331       if (sdyn == NULL)
2332         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2333       else
2334         bfd_put_32 (output_bfd,
2335                     sdyn->output_section->vma + sdyn->output_offset,
2336                     sgot->contents);
2337       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2338       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2339     }
2340
2341   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2342
2343   return TRUE;
2344 }
2345
2346 /* Given a .data section and a .emreloc in-memory section, store
2347    relocation information into the .emreloc section which can be
2348    used at runtime to relocate the section.  This is called by the
2349    linker when the --embedded-relocs switch is used.  This is called
2350    after the add_symbols entry point has been called for all the
2351    objects, and before the final_link entry point is called.  */
2352
2353 bfd_boolean
2354 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2355      bfd *abfd;
2356      struct bfd_link_info *info;
2357      asection *datasec;
2358      asection *relsec;
2359      char **errmsg;
2360 {
2361   Elf_Internal_Shdr *symtab_hdr;
2362   Elf_Internal_Sym *isymbuf = NULL;
2363   Elf_Internal_Rela *internal_relocs = NULL;
2364   Elf_Internal_Rela *irel, *irelend;
2365   bfd_byte *p;
2366   bfd_size_type amt;
2367
2368   BFD_ASSERT (! info->relocatable);
2369
2370   *errmsg = NULL;
2371
2372   if (datasec->reloc_count == 0)
2373     return TRUE;
2374
2375   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2376
2377   /* Get a copy of the native relocations.  */
2378   internal_relocs = (_bfd_elf_link_read_relocs
2379                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2380                       info->keep_memory));
2381   if (internal_relocs == NULL)
2382     goto error_return;
2383
2384   amt = (bfd_size_type) datasec->reloc_count * 12;
2385   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2386   if (relsec->contents == NULL)
2387     goto error_return;
2388
2389   p = relsec->contents;
2390
2391   irelend = internal_relocs + datasec->reloc_count;
2392   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2393     {
2394       asection *targetsec;
2395
2396       /* We are going to write a four byte longword into the runtime
2397        reloc section.  The longword will be the address in the data
2398        section which must be relocated.  It is followed by the name
2399        of the target section NUL-padded or truncated to 8
2400        characters.  */
2401
2402       /* We can only relocate absolute longword relocs at run time.  */
2403       if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2404         {
2405           *errmsg = _("unsupported reloc type");
2406           bfd_set_error (bfd_error_bad_value);
2407           goto error_return;
2408         }
2409
2410       /* Get the target section referred to by the reloc.  */
2411       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2412         {
2413           /* A local symbol.  */
2414           Elf_Internal_Sym *isym;
2415
2416           /* Read this BFD's local symbols if we haven't done so already.  */
2417           if (isymbuf == NULL)
2418             {
2419               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2420               if (isymbuf == NULL)
2421                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2422                                                 symtab_hdr->sh_info, 0,
2423                                                 NULL, NULL, NULL);
2424               if (isymbuf == NULL)
2425                 goto error_return;
2426             }
2427
2428           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2429           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2430         }
2431       else
2432         {
2433           unsigned long indx;
2434           struct elf_link_hash_entry *h;
2435
2436           /* An external symbol.  */
2437           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2438           h = elf_sym_hashes (abfd)[indx];
2439           BFD_ASSERT (h != NULL);
2440           if (h->root.type == bfd_link_hash_defined
2441               || h->root.type == bfd_link_hash_defweak)
2442             targetsec = h->root.u.def.section;
2443           else
2444             targetsec = NULL;
2445         }
2446
2447       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2448       memset (p + 4, 0, 8);
2449       if (targetsec != NULL)
2450         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2451     }
2452
2453   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2454     free (isymbuf);
2455   if (internal_relocs != NULL
2456       && elf_section_data (datasec)->relocs != internal_relocs)
2457     free (internal_relocs);
2458   return TRUE;
2459
2460 error_return:
2461   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2462     free (isymbuf);
2463   if (internal_relocs != NULL
2464       && elf_section_data (datasec)->relocs != internal_relocs)
2465     free (internal_relocs);
2466   return FALSE;
2467 }
2468
2469 static enum elf_reloc_type_class
2470 elf32_m68k_reloc_type_class (rela)
2471      const Elf_Internal_Rela *rela;
2472 {
2473   switch ((int) ELF32_R_TYPE (rela->r_info))
2474     {
2475     case R_68K_RELATIVE:
2476       return reloc_class_relative;
2477     case R_68K_JMP_SLOT:
2478       return reloc_class_plt;
2479     case R_68K_COPY:
2480       return reloc_class_copy;
2481     default:
2482       return reloc_class_normal;
2483     }
2484 }
2485
2486 /* Return address for Ith PLT stub in section PLT, for relocation REL
2487    or (bfd_vma) -1 if it should not be included.  */
2488
2489 static bfd_vma
2490 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2491                       const arelent *rel ATTRIBUTE_UNUSED)
2492 {
2493   return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2494 }
2495
2496 #define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
2497 #define TARGET_BIG_NAME                 "elf32-m68k"
2498 #define ELF_MACHINE_CODE                EM_68K
2499 #define ELF_MAXPAGESIZE                 0x2000
2500 #define elf_backend_create_dynamic_sections \
2501                                         _bfd_elf_create_dynamic_sections
2502 #define bfd_elf32_bfd_link_hash_table_create \
2503                                         elf_m68k_link_hash_table_create
2504 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
2505
2506 #define elf_backend_check_relocs        elf_m68k_check_relocs
2507 #define elf_backend_always_size_sections \
2508                                         elf_m68k_always_size_sections
2509 #define elf_backend_adjust_dynamic_symbol \
2510                                         elf_m68k_adjust_dynamic_symbol
2511 #define elf_backend_size_dynamic_sections \
2512                                         elf_m68k_size_dynamic_sections
2513 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
2514 #define elf_backend_relocate_section    elf_m68k_relocate_section
2515 #define elf_backend_finish_dynamic_symbol \
2516                                         elf_m68k_finish_dynamic_symbol
2517 #define elf_backend_finish_dynamic_sections \
2518                                         elf_m68k_finish_dynamic_sections
2519 #define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
2520 #define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
2521 #define bfd_elf32_bfd_merge_private_bfd_data \
2522                                         elf32_m68k_merge_private_bfd_data
2523 #define bfd_elf32_bfd_set_private_flags \
2524                                         elf32_m68k_set_private_flags
2525 #define bfd_elf32_bfd_print_private_bfd_data \
2526                                         elf32_m68k_print_private_bfd_data
2527 #define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
2528 #define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
2529 #define elf_backend_object_p            elf32_m68k_object_p
2530
2531 #define elf_backend_can_gc_sections 1
2532 #define elf_backend_can_refcount 1
2533 #define elf_backend_want_got_plt 1
2534 #define elf_backend_plt_readonly 1
2535 #define elf_backend_want_plt_sym 0
2536 #define elf_backend_got_header_size     12
2537 #define elf_backend_rela_normal         1
2538
2539 #include "elf32-target.h"