bfd/elf32-vax.c

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