bfd/elf32-vax.c

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