bfd/elf32-m68k.c

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