bfd/elf32-m68k.c

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