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