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   if (info->relocatable)
1381     return TRUE;
1382
1383   dynobj = elf_hash_table (info)->dynobj;
1384   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1385   sym_hashes = elf_sym_hashes (input_bfd);
1386   local_got_offsets = elf_local_got_offsets (input_bfd);
1387
1388   sgot = NULL;
1389   splt = NULL;
1390   sgotplt = NULL;
1391   sreloc = NULL;
1392
1393   rel = relocs;
1394   relend = relocs + input_section->reloc_count;
1395   for (; rel < relend; rel++)
1396     {
1397       int r_type;
1398       reloc_howto_type *howto;
1399       unsigned long r_symndx;
1400       struct elf_link_hash_entry *h;
1401       Elf_Internal_Sym *sym;
1402       asection *sec;
1403       bfd_vma relocation;
1404       bfd_reloc_status_type r;
1405
1406       r_type = ELF32_R_TYPE (rel->r_info);
1407       if (r_type < 0 || r_type >= (int) R_VAX_max)
1408         {
1409           bfd_set_error (bfd_error_bad_value);
1410           return FALSE;
1411         }
1412       howto = howto_table + r_type;
1413
1414       /* This is a final link.  */
1415       r_symndx = ELF32_R_SYM (rel->r_info);
1416       h = NULL;
1417       sym = NULL;
1418       sec = NULL;
1419       if (r_symndx < symtab_hdr->sh_info)
1420         {
1421           sym = local_syms + r_symndx;
1422           sec = local_sections[r_symndx];
1423           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1424         }
1425       else
1426         {
1427           bfd_boolean unresolved_reloc;
1428           bfd_boolean warned;
1429
1430           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1431                                    r_symndx, symtab_hdr, sym_hashes,
1432                                    h, sec, relocation,
1433                                    unresolved_reloc, warned);
1434
1435           if ((h->root.type == bfd_link_hash_defined
1436               || h->root.type == bfd_link_hash_defweak)
1437               && ((r_type == R_VAX_PLT32
1438                    && h->plt.offset != (bfd_vma) -1
1439                    && elf_hash_table (info)->dynamic_sections_created)
1440                   || (r_type == R_VAX_GOT32
1441                       && strcmp (h->root.root.string,
1442                                  "_GLOBAL_OFFSET_TABLE_") != 0
1443                       && elf_hash_table (info)->dynamic_sections_created
1444                       && (! info->shared
1445                           || (! info->symbolic && h->dynindx != -1)
1446                           || !h->def_regular))
1447                   || (info->shared
1448                       && ((! info->symbolic && h->dynindx != -1)
1449                           || !h->def_regular)
1450                       && ((input_section->flags & SEC_ALLOC) != 0
1451                           /* DWARF will emit R_VAX_32 relocations in its
1452                              sections against symbols defined externally
1453                              in shared libraries.  We can't do anything
1454                              with them here.  */
1455
1456                           || ((input_section->flags & SEC_DEBUGGING) != 0
1457                               && h->def_dynamic))
1458                       && (r_type == R_VAX_8
1459                           || r_type == R_VAX_16
1460                           || r_type == R_VAX_32
1461                           || r_type == R_VAX_PC8
1462                           || r_type == R_VAX_PC16
1463                           || r_type == R_VAX_PC32))))
1464             /* In these cases, we don't need the relocation
1465                value.  We check specially because in some
1466                obscure cases sec->output_section will be NULL.  */
1467             relocation = 0;
1468         }
1469
1470       switch (r_type)
1471         {
1472         case R_VAX_GOT32:
1473           /* Relocation is to the address of the entry for this symbol
1474              in the global offset table.  */
1475           if (h == NULL || h->got.offset == (bfd_vma) -1)
1476             break;
1477
1478           /* Relocation is the offset of the entry for this symbol in
1479              the global offset table.  */
1480
1481           {
1482             bfd_vma off;
1483
1484             if (sgot == NULL)
1485               {
1486                 sgot = bfd_get_section_by_name (dynobj, ".got");
1487                 BFD_ASSERT (sgot != NULL);
1488               }
1489
1490             BFD_ASSERT (h != NULL);
1491             off = h->got.offset;
1492             BFD_ASSERT (off != (bfd_vma) -1);
1493             BFD_ASSERT (off < sgot->size);
1494
1495             if (info->shared
1496                 && h->dynindx == -1
1497                 && h->def_regular)
1498               {
1499                 /* The symbol was forced to be local
1500                    because of a version file..  We must initialize
1501                    this entry in the global offset table.  Since
1502                    the offset must always be a multiple of 4, we
1503                    use the least significant bit to record whether
1504                    we have initialized it already.
1505
1506                    When doing a dynamic link, we create a .rela.got
1507                    relocation entry to initialize the value.  This
1508                    is done in the finish_dynamic_symbol routine.  */
1509                 if ((off & 1) != 0)
1510                   off &= ~1;
1511                 else
1512                   {
1513                     bfd_put_32 (output_bfd, relocation + rel->r_addend,
1514                                 sgot->contents + off);
1515                     h->got.offset |= 1;
1516                   }
1517               } else {
1518                 bfd_put_32 (output_bfd, rel->r_addend, sgot->contents + off);
1519               }
1520
1521             relocation = sgot->output_offset + off;
1522             /* The GOT relocation uses the addend.  */
1523             rel->r_addend = 0;
1524
1525             /* Change the reference to be indirect.  */
1526             contents[rel->r_offset - 1] |= 0x10;
1527             relocation += sgot->output_section->vma;
1528           }
1529           break;
1530
1531         case R_VAX_PLT32:
1532           /* Relocation is to the entry for this symbol in the
1533              procedure linkage table.  */
1534
1535           /* Resolve a PLTxx reloc against a local symbol directly,
1536              without using the procedure linkage table.  */
1537           if (h == NULL)
1538             break;
1539
1540           if (h->plt.offset == (bfd_vma) -1
1541               || !elf_hash_table (info)->dynamic_sections_created)
1542             {
1543               /* We didn't make a PLT entry for this symbol.  This
1544                  happens when statically linking PIC code, or when
1545                  using -Bsymbolic.  */
1546               break;
1547             }
1548
1549           if (splt == NULL)
1550             {
1551               splt = bfd_get_section_by_name (dynobj, ".plt");
1552               BFD_ASSERT (splt != NULL);
1553             }
1554
1555           if (sgotplt == NULL)
1556             {
1557               sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1558               BFD_ASSERT (splt != NULL);
1559             }
1560
1561           plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1562
1563           /* Get the offset into the .got table of the entry that
1564              corresponds to this function.  Each .got entry is 4 bytes.
1565              The first two are reserved.  */
1566           got_offset = (plt_index + 3) * 4;
1567
1568           /* We want the relocate to point into the .got.plt instead
1569              of the plt itself.  */
1570           relocation = (sgotplt->output_section->vma
1571                         + sgotplt->output_offset
1572                         + got_offset);
1573           contents[rel->r_offset-1] |= 0x10; /* make indirect */
1574           if (rel->r_addend == 2)
1575             {
1576               h->plt.offset |= 1;
1577             }
1578           else if (rel->r_addend != 0)
1579             (*_bfd_error_handler)
1580               (_("%s: warning: PLT addend of %d to `%s' from %s section ignored"),
1581                       bfd_get_filename (input_bfd), rel->r_addend,
1582                       h->root.root.string,
1583                       bfd_get_section_name (input_bfd, input_section));
1584           rel->r_addend = 0;
1585
1586           break;
1587
1588         case R_VAX_PC8:
1589         case R_VAX_PC16:
1590         case R_VAX_PC32:
1591           if (h == NULL)
1592             break;
1593           /* Fall through.  */
1594         case R_VAX_8:
1595         case R_VAX_16:
1596         case R_VAX_32:
1597           if (info->shared
1598               && r_symndx != 0
1599               && (input_section->flags & SEC_ALLOC) != 0
1600               && ((r_type != R_VAX_PC8
1601                    && r_type != R_VAX_PC16
1602                    && r_type != R_VAX_PC32)
1603                   || (!info->symbolic
1604                       || !h->def_regular)))
1605             {
1606               Elf_Internal_Rela outrel;
1607               bfd_byte *loc;
1608               bfd_boolean skip, relocate;
1609
1610               /* When generating a shared object, these relocations
1611                  are copied into the output file to be resolved at run
1612                  time.  */
1613               if (sreloc == NULL)
1614                 {
1615                   const char *name;
1616
1617                   name = (bfd_elf_string_from_elf_section
1618                           (input_bfd,
1619                            elf_elfheader (input_bfd)->e_shstrndx,
1620                            elf_section_data (input_section)->rel_hdr.sh_name));
1621                   if (name == NULL)
1622                     return FALSE;
1623
1624                   BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1625                               && strcmp (bfd_get_section_name (input_bfd,
1626                                                                input_section),
1627                                          name + 5) == 0);
1628
1629                   sreloc = bfd_get_section_by_name (dynobj, name);
1630                   BFD_ASSERT (sreloc != NULL);
1631                 }
1632
1633               skip = FALSE;
1634               relocate = FALSE;
1635
1636               outrel.r_offset =
1637                 _bfd_elf_section_offset (output_bfd, info, input_section,
1638                                          rel->r_offset);
1639               if (outrel.r_offset == (bfd_vma) -1)
1640                 skip = TRUE;
1641               if (outrel.r_offset == (bfd_vma) -2)
1642                 skip = TRUE, relocate = TRUE;
1643               outrel.r_offset += (input_section->output_section->vma
1644                                   + input_section->output_offset);
1645
1646               if (skip)
1647                   memset (&outrel, 0, sizeof outrel);
1648               /* h->dynindx may be -1 if the symbol was marked to
1649                  become local.  */
1650               else if (h != NULL
1651                        && ((! info->symbolic && h->dynindx != -1)
1652                            || !h->def_regular))
1653                 {
1654                   BFD_ASSERT (h->dynindx != -1);
1655                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1656                   outrel.r_addend = relocation + rel->r_addend;
1657                 }
1658               else
1659                 {
1660                   if (r_type == R_VAX_32)
1661                     {
1662                       relocate = TRUE;
1663                       outrel.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1664                       BFD_ASSERT (bfd_get_signed_32 (input_bfd,
1665                                                      &contents[rel->r_offset]) == 0);
1666                       outrel.r_addend = relocation + rel->r_addend;
1667                     }
1668                   else
1669                     {
1670                       long indx;
1671
1672                       if (bfd_is_abs_section (sec))
1673                         indx = 0;
1674                       else if (sec == NULL || sec->owner == NULL)
1675                         {
1676                           bfd_set_error (bfd_error_bad_value);
1677                           return FALSE;
1678                         }
1679                       else
1680                         {
1681                           asection *osec;
1682
1683                           osec = sec->output_section;
1684                           indx = elf_section_data (osec)->dynindx;
1685                           BFD_ASSERT (indx > 0);
1686                         }
1687
1688                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1689                       outrel.r_addend = relocation + rel->r_addend;
1690                     }
1691                 }
1692
1693               if (!strcmp (bfd_get_section_name (input_bfd, input_section),
1694                            ".text") != 0 ||
1695                   (info->shared
1696                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_32
1697                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_RELATIVE
1698                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_COPY
1699                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_JMP_SLOT
1700                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_GLOB_DAT))
1701                 {
1702                   if (h != NULL)
1703                     (*_bfd_error_handler)
1704                       (_("%s: warning: %s relocation against symbol `%s' from %s section"),
1705                       bfd_get_filename (input_bfd), howto->name,
1706                       h->root.root.string,
1707                       bfd_get_section_name (input_bfd, input_section));
1708                   else
1709                     (*_bfd_error_handler)
1710                       (_("%s: warning: %s relocation to 0x%x from %s section"),
1711                       bfd_get_filename (input_bfd), howto->name,
1712                       outrel.r_addend,
1713                       bfd_get_section_name (input_bfd, input_section));
1714                 }
1715               loc = sreloc->contents;
1716               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1717               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1718
1719               /* This reloc will be computed at runtime, so there's no
1720                  need to do anything now, except for R_VAX_32
1721                  relocations that have been turned into
1722                  R_VAX_RELATIVE.  */
1723               if (!relocate)
1724                 continue;
1725             }
1726
1727           break;
1728
1729         case R_VAX_GNU_VTINHERIT:
1730         case R_VAX_GNU_VTENTRY:
1731           /* These are no-ops in the end.  */
1732           continue;
1733
1734         default:
1735           break;
1736         }
1737
1738       /* VAX PCREL relocations are from the end of relocation, not the start.
1739          So subtract the difference from the relocation amount since we can't
1740          add it to the offset.  */
1741       if (howto->pc_relative && howto->pcrel_offset)
1742         relocation -= bfd_get_reloc_size(howto);
1743
1744       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1745                                     contents, rel->r_offset,
1746                                     relocation, rel->r_addend);
1747
1748       if (r != bfd_reloc_ok)
1749         {
1750           switch (r)
1751             {
1752             default:
1753             case bfd_reloc_outofrange:
1754               abort ();
1755             case bfd_reloc_overflow:
1756               {
1757                 const char *name;
1758
1759                 if (h != NULL)
1760                   name = NULL;
1761                 else
1762                   {
1763                     name = bfd_elf_string_from_elf_section (input_bfd,
1764                                                             symtab_hdr->sh_link,
1765                                                             sym->st_name);
1766                     if (name == NULL)
1767                       return FALSE;
1768                     if (*name == '\0')
1769                       name = bfd_section_name (input_bfd, sec);
1770                   }
1771                 if (!(info->callbacks->reloc_overflow
1772                       (info, (h ? &h->root : NULL), name, howto->name,
1773                        (bfd_vma) 0, input_bfd, input_section,
1774                        rel->r_offset)))
1775                   return FALSE;
1776               }
1777               break;
1778             }
1779         }
1780     }
1781
1782   return TRUE;
1783 }
1784
1785 /* Finish up dynamic symbol handling.  We set the contents of various
1786    dynamic sections here.  */
1787
1788 static bfd_boolean
1789 elf_vax_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
1790                                struct elf_link_hash_entry *h,
1791                                Elf_Internal_Sym *sym)
1792 {
1793   bfd *dynobj;
1794
1795   dynobj = elf_hash_table (info)->dynobj;
1796
1797   if (h->plt.offset != (bfd_vma) -1)
1798     {
1799       asection *splt;
1800       asection *sgot;
1801       asection *srela;
1802       bfd_vma plt_index;
1803       bfd_vma got_offset;
1804       bfd_vma addend;
1805       Elf_Internal_Rela rela;
1806       bfd_byte *loc;
1807
1808       /* This symbol has an entry in the procedure linkage table.  Set
1809          it up.  */
1810       BFD_ASSERT (h->dynindx != -1);
1811
1812       splt = bfd_get_section_by_name (dynobj, ".plt");
1813       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1814       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1815       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1816
1817       addend = 2 * (h->plt.offset & 1);
1818       h->plt.offset &= ~1;
1819
1820       /* Get the index in the procedure linkage table which
1821          corresponds to this symbol.  This is the index of this symbol
1822          in all the symbols for which we are making plt entries.  The
1823          first entry in the procedure linkage table is reserved.  */
1824       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1825
1826       /* Get the offset into the .got table of the entry that
1827          corresponds to this function.  Each .got entry is 4 bytes.
1828          The first two are reserved.  */
1829       got_offset = (plt_index + 3) * 4;
1830
1831       /* Fill in the entry in the procedure linkage table.  */
1832       memcpy (splt->contents + h->plt.offset, elf_vax_plt_entry,
1833                   PLT_ENTRY_SIZE);
1834
1835       /* The offset is relative to the first extension word.  */
1836       bfd_put_32 (output_bfd,
1837                   -(h->plt.offset + 8),
1838                   splt->contents + h->plt.offset + 4);
1839
1840       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1841                   splt->contents + h->plt.offset + 8);
1842
1843       /* Fill in the entry in the global offset table.  */
1844       bfd_put_32 (output_bfd,
1845                   (splt->output_section->vma
1846                    + splt->output_offset
1847                    + h->plt.offset) + addend,
1848                   sgot->contents + got_offset);
1849
1850       /* Fill in the entry in the .rela.plt section.  */
1851       rela.r_offset = (sgot->output_section->vma
1852                        + sgot->output_offset
1853                        + got_offset);
1854       rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_JMP_SLOT);
1855       rela.r_addend = addend;
1856       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1857       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1858
1859       if (!h->def_regular)
1860         {
1861           /* Mark the symbol as undefined, rather than as defined in
1862              the .plt section.  Leave the value alone.  */
1863           sym->st_shndx = SHN_UNDEF;
1864         }
1865     }
1866
1867   if (h->got.offset != (bfd_vma) -1)
1868     {
1869       asection *sgot;
1870       asection *srela;
1871       Elf_Internal_Rela rela;
1872       bfd_byte *loc;
1873
1874       /* This symbol has an entry in the global offset table.  Set it
1875          up.  */
1876       sgot = bfd_get_section_by_name (dynobj, ".got");
1877       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1878       BFD_ASSERT (sgot != NULL && srela != NULL);
1879
1880       rela.r_offset = (sgot->output_section->vma
1881                        + sgot->output_offset
1882                        + (h->got.offset &~ 1));
1883
1884       /* If the symbol was forced to be local because of a version file
1885          locally we just want to emit a RELATIVE reloc.  The entry in
1886          the global offset table will already have been initialized in
1887          the relocate_section function.  */
1888       if (info->shared
1889           && h->dynindx == -1
1890           && h->def_regular)
1891         {
1892           rela.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1893         }
1894       else
1895         {
1896           rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_GLOB_DAT);
1897         }
1898       rela.r_addend = bfd_get_signed_32 (output_bfd,
1899                                          (sgot->contents
1900                                           + (h->got.offset & ~1)));
1901
1902       loc = srela->contents;
1903       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1904       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1905     }
1906
1907   if (h->needs_copy)
1908     {
1909       asection *s;
1910       Elf_Internal_Rela rela;
1911       bfd_byte *loc;
1912
1913       /* This symbol needs a copy reloc.  Set it up.  */
1914       BFD_ASSERT (h->dynindx != -1
1915                   && (h->root.type == bfd_link_hash_defined
1916                       || h->root.type == bfd_link_hash_defweak));
1917
1918       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1919                                    ".rela.bss");
1920       BFD_ASSERT (s != NULL);
1921
1922       rela.r_offset = (h->root.u.def.value
1923                        + h->root.u.def.section->output_section->vma
1924                        + h->root.u.def.section->output_offset);
1925       rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_COPY);
1926       rela.r_addend = 0;
1927       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1928       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1929     }
1930
1931   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1932   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1933       || h == elf_hash_table (info)->hgot)
1934     sym->st_shndx = SHN_ABS;
1935
1936   return TRUE;
1937 }
1938
1939 /* Finish up the dynamic sections.  */
1940
1941 static bfd_boolean
1942 elf_vax_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1943 {
1944   bfd *dynobj;
1945   asection *sgot;
1946   asection *sdyn;
1947
1948   dynobj = elf_hash_table (info)->dynobj;
1949
1950   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1951   BFD_ASSERT (sgot != NULL);
1952   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1953
1954   if (elf_hash_table (info)->dynamic_sections_created)
1955     {
1956       asection *splt;
1957       Elf32_External_Dyn *dyncon, *dynconend;
1958
1959       splt = bfd_get_section_by_name (dynobj, ".plt");
1960       BFD_ASSERT (splt != NULL && sdyn != NULL);
1961
1962       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1963       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1964       for (; dyncon < dynconend; dyncon++)
1965         {
1966           Elf_Internal_Dyn dyn;
1967           const char *name;
1968           asection *s;
1969
1970           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1971
1972           switch (dyn.d_tag)
1973             {
1974             default:
1975               break;
1976
1977             case DT_PLTGOT:
1978               name = ".got";
1979               goto get_vma;
1980             case DT_JMPREL:
1981               name = ".rela.plt";
1982             get_vma:
1983               s = bfd_get_section_by_name (output_bfd, name);
1984               BFD_ASSERT (s != NULL);
1985               dyn.d_un.d_ptr = s->vma;
1986               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1987               break;
1988
1989             case DT_PLTRELSZ:
1990               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1991               BFD_ASSERT (s != NULL);
1992               dyn.d_un.d_val = s->size;
1993               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1994               break;
1995
1996             case DT_RELASZ:
1997               /* The procedure linkage table relocs (DT_JMPREL) should
1998                  not be included in the overall relocs (DT_RELA).
1999                  Therefore, we override the DT_RELASZ entry here to
2000                  make it not include the JMPREL relocs.  Since the
2001                  linker script arranges for .rela.plt to follow all
2002                  other relocation sections, we don't have to worry
2003                  about changing the DT_RELA entry.  */
2004               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2005               if (s != NULL)
2006                 dyn.d_un.d_val -= s->size;
2007               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2008               break;
2009             }
2010         }
2011
2012       /* Fill in the first entry in the procedure linkage table.  */
2013       if (splt->size > 0)
2014         {
2015           memcpy (splt->contents, elf_vax_plt0_entry, PLT_ENTRY_SIZE);
2016           bfd_put_32 (output_bfd,
2017                           (sgot->output_section->vma
2018                            + sgot->output_offset + 4
2019                            - (splt->output_section->vma + 6)),
2020                           splt->contents + 2);
2021           bfd_put_32 (output_bfd,
2022                           (sgot->output_section->vma
2023                            + sgot->output_offset + 8
2024                            - (splt->output_section->vma + 12)),
2025                           splt->contents + 8);
2026           elf_section_data (splt->output_section)->this_hdr.sh_entsize
2027            = PLT_ENTRY_SIZE;
2028         }
2029     }
2030
2031   /* Fill in the first three entries in the global offset table.  */
2032   if (sgot->size > 0)
2033     {
2034       if (sdyn == NULL)
2035         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2036       else
2037         bfd_put_32 (output_bfd,
2038                     sdyn->output_section->vma + sdyn->output_offset,
2039                     sgot->contents);
2040       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2041       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2042     }
2043
2044   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2045
2046   return TRUE;
2047 }
2048
2049 #define TARGET_LITTLE_SYM               bfd_elf32_vax_vec
2050 #define TARGET_LITTLE_NAME              "elf32-vax"
2051 #define ELF_MACHINE_CODE                EM_VAX
2052 #define ELF_MAXPAGESIZE                 0x1000
2053
2054 #define elf_backend_create_dynamic_sections \
2055                                         _bfd_elf_create_dynamic_sections
2056 #define bfd_elf32_bfd_link_hash_table_create \
2057                                         elf_vax_link_hash_table_create
2058 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
2059
2060 #define elf_backend_check_relocs        elf_vax_check_relocs
2061 #define elf_backend_adjust_dynamic_symbol \
2062                                         elf_vax_adjust_dynamic_symbol
2063 #define elf_backend_size_dynamic_sections \
2064                                         elf_vax_size_dynamic_sections
2065 #define elf_backend_relocate_section    elf_vax_relocate_section
2066 #define elf_backend_finish_dynamic_symbol \
2067                                         elf_vax_finish_dynamic_symbol
2068 #define elf_backend_finish_dynamic_sections \
2069                                         elf_vax_finish_dynamic_sections
2070 #define elf_backend_gc_mark_hook        elf_vax_gc_mark_hook
2071 #define elf_backend_gc_sweep_hook       elf_vax_gc_sweep_hook
2072 #define bfd_elf32_bfd_merge_private_bfd_data \
2073                                         elf32_vax_merge_private_bfd_data
2074 #define bfd_elf32_bfd_set_private_flags \
2075                                         elf32_vax_set_private_flags
2076 #define bfd_elf32_bfd_print_private_bfd_data \
2077                                         elf32_vax_print_private_bfd_data
2078
2079 #define elf_backend_can_gc_sections     1
2080 #define elf_backend_want_got_plt        1
2081 #define elf_backend_plt_readonly        1
2082 #define elf_backend_want_plt_sym        0
2083 #define elf_backend_got_header_size     16
2084 #define elf_backend_rela_normal         1
2085
2086 #include "elf32-target.h"