bfd/elf32-vax.c

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