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