bfd/elf32-vax.c

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