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 "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
  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
 929   dynobj = elf_hash_table (info)->dynobj;
 930
 931   /* Make sure we know what is going on here.  */
 932   BFD_ASSERT (dynobj != NULL
 933               && (h->needs_plt
 934                   || h->u.weakdef != NULL
 935                   || (h->def_dynamic
 936                       && h->ref_regular
 937                       && !h->def_regular)));
 938
 939   /* If this is a function, put it in the procedure linkage table.  We
 940      will fill in the contents of the procedure linkage table later,
 941      when we know the address of the .got section.  */
 942   if (h->type == STT_FUNC
 943       || h->needs_plt)
 944     {
 945       if (! info->shared
 946           && !h->def_dynamic
 947           && !h->ref_dynamic
 948           /* We must always create the plt entry if it was referenced
 949              by a PLTxxO relocation.  In this case we already recorded
 950              it as a dynamic symbol.  */
 951           && h->dynindx == -1)
 952         {
 953           /* This case can occur if we saw a PLTxx reloc in an input
 954              file, but the symbol was never referred to by a dynamic
 955              object.  In such a case, we don't actually need to build
 956              a procedure linkage table, and we can just do a PCxx
 957              reloc instead.  */
 958           BFD_ASSERT (h->needs_plt);
 959           h->plt.offset = (bfd_vma) -1;
 960           return TRUE;
 961         }
 962
 963       /* GC may have rendered this entry unused.  */
 964       if (h->plt.refcount <= 0)
 965         {
 966           h->needs_plt = 0;
 967           h->plt.offset = (bfd_vma) -1;
 968           return TRUE;
 969         }
 970
 971       /* Make sure this symbol is output as a dynamic symbol.  */
 972       if (h->dynindx == -1)
 973         {
 974           if (! bfd_elf_link_record_dynamic_symbol (info, h))
 975             return FALSE;
 976         }
 977
 978       s = bfd_get_section_by_name (dynobj, ".plt");
 979       BFD_ASSERT (s != NULL);
 980
 981       /* If this is the first .plt entry, make room for the special
 982          first entry.  */
 983       if (s->size == 0)
 984         {
 985           s->size += PLT_ENTRY_SIZE;
 986         }
 987
 988       /* If this symbol is not defined in a regular file, and we are
 989          not generating a shared library, then set the symbol to this
 990          location in the .plt.  This is required to make function
 991          pointers compare as equal between the normal executable and
 992          the shared library.  */
 993       if (!info->shared
 994           && !h->def_regular)
 995         {
 996           h->root.u.def.section = s;
 997           h->root.u.def.value = s->size;
 998         }
 999
1000       h->plt.offset = s->size;
1001
1002       /* Make room for this entry.  */
1003       s->size += PLT_ENTRY_SIZE;
1004
1005       /* We also need to make an entry in the .got.plt section, which
1006          will be placed in the .got section by the linker script.  */
1007
1008       s = bfd_get_section_by_name (dynobj, ".got.plt");
1009       BFD_ASSERT (s != NULL);
1010       s->size += 4;
1011
1012       /* We also need to make an entry in the .rela.plt section.  */
1013
1014       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1015       BFD_ASSERT (s != NULL);
1016       s->size += sizeof (Elf32_External_Rela);
1017
1018       return TRUE;
1019     }
1020
1021   /* Reinitialize the plt offset now that it is not used as a reference
1022      count any more.  */
1023   h->plt.offset = (bfd_vma) -1;
1024
1025   /* If this is a weak symbol, and there is a real definition, the
1026      processor independent code will have arranged for us to see the
1027      real definition first, and we can just use the same value.  */
1028   if (h->u.weakdef != NULL)
1029     {
1030       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1031                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1032       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1033       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1034       return TRUE;
1035     }
1036
1037   /* This is a reference to a symbol defined by a dynamic object which
1038      is not a function.  */
1039
1040   /* If we are creating a shared library, we must presume that the
1041      only references to the symbol are via the global offset table.
1042      For such cases we need not do anything here; the relocations will
1043      be handled correctly by relocate_section.  */
1044   if (info->shared)
1045     return TRUE;
1046
1047   if (h->size == 0)
1048     {
1049       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1050                              h->root.root.string);
1051       return TRUE;
1052     }
1053
1054   /* We must allocate the symbol in our .dynbss section, which will
1055      become part of the .bss section of the executable.  There will be
1056      an entry for this symbol in the .dynsym section.  The dynamic
1057      object will contain position independent code, so all references
1058      from the dynamic object to this symbol will go through the global
1059      offset table.  The dynamic linker will use the .dynsym entry to
1060      determine the address it must put in the global offset table, so
1061      both the dynamic object and the regular object will refer to the
1062      same memory location for the variable.  */
1063
1064   s = bfd_get_section_by_name (dynobj, ".dynbss");
1065   BFD_ASSERT (s != NULL);
1066
1067   /* We must generate a R_VAX_COPY reloc to tell the dynamic linker to
1068      copy the initial value out of the dynamic object and into the
1069      runtime process image.  We need to remember the offset into the
1070      .rela.bss section we are going to use.  */
1071   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1072     {
1073       asection *srel;
1074
1075       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1076       BFD_ASSERT (srel != NULL);
1077       srel->size += sizeof (Elf32_External_Rela);
1078       h->needs_copy = 1;
1079     }
1080
1081   return _bfd_elf_adjust_dynamic_copy (h, s);
1082 }
1083
1084 /* Set the sizes of the dynamic sections.  */
1085
1086 static bfd_boolean
1087 elf_vax_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1088 {
1089   bfd *dynobj;
1090   asection *s;
1091   bfd_boolean plt;
1092   bfd_boolean relocs;
1093   bfd_boolean reltext;
1094
1095   dynobj = elf_hash_table (info)->dynobj;
1096   BFD_ASSERT (dynobj != NULL);
1097
1098   if (elf_hash_table (info)->dynamic_sections_created)
1099     {
1100       /* Set the contents of the .interp section to the interpreter.  */
1101       if (info->executable)
1102         {
1103           s = bfd_get_section_by_name (dynobj, ".interp");
1104           BFD_ASSERT (s != NULL);
1105           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1106           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1107         }
1108     }
1109   else
1110     {
1111       /* We may have created entries in the .rela.got and .got sections.
1112          However, if we are not creating the dynamic sections, we will
1113          not actually use these entries.  Reset the size of .rela.got
1114          and .got, which will cause it to get stripped from the output
1115          file below.  */
1116       s = bfd_get_section_by_name (dynobj, ".rela.got");
1117       if (s != NULL)
1118         s->size = 0;
1119       s = bfd_get_section_by_name (dynobj, ".got.plt");
1120       if (s != NULL)
1121         s->size = 0;
1122       s = bfd_get_section_by_name (dynobj, ".got");
1123       if (s != NULL)
1124         s->size = 0;
1125     }
1126
1127   /* If this is a -Bsymbolic shared link, then we need to discard all PC
1128      relative relocs against symbols defined in a regular object.  We
1129      allocated space for them in the check_relocs routine, but we will not
1130      fill them in in the relocate_section routine.  */
1131   if (info->shared && info->symbolic)
1132     elf_vax_link_hash_traverse (elf_vax_hash_table (info),
1133                                 elf_vax_discard_copies,
1134                                 NULL);
1135
1136   /* If this is a -Bsymbolic shared link or a static link, we need to
1137      discard all the got entries we've recorded.  Otherwise, we need to
1138      instantiate (allocate space for them).  */
1139   elf_link_hash_traverse (elf_hash_table (info),
1140                           elf_vax_instantiate_got_entries,
1141                           (PTR) info);
1142
1143   /* The check_relocs and adjust_dynamic_symbol entry points have
1144      determined the sizes of the various dynamic sections.  Allocate
1145      memory for them.  */
1146   plt = FALSE;
1147   relocs = FALSE;
1148   reltext = FALSE;
1149   for (s = dynobj->sections; s != NULL; s = s->next)
1150     {
1151       const char *name;
1152
1153       if ((s->flags & SEC_LINKER_CREATED) == 0)
1154         continue;
1155
1156       /* It's OK to base decisions on the section name, because none
1157          of the dynobj section names depend upon the input files.  */
1158       name = bfd_get_section_name (dynobj, s);
1159
1160       if (strcmp (name, ".plt") == 0)
1161         {
1162           /* Remember whether there is a PLT.  */
1163           plt = s->size != 0;
1164         }
1165       else if (CONST_STRNEQ (name, ".rela"))
1166         {
1167           if (s->size != 0)
1168             {
1169               asection *target;
1170
1171               /* Remember whether there are any reloc sections other
1172                  than .rela.plt.  */
1173               if (strcmp (name, ".rela.plt") != 0)
1174                 {
1175                   const char *outname;
1176
1177                   relocs = TRUE;
1178
1179                   /* If this relocation section applies to a read only
1180                      section, then we probably need a DT_TEXTREL
1181                      entry.  .rela.plt is actually associated with
1182                      .got.plt, which is never readonly.  */
1183                   outname = bfd_get_section_name (output_bfd,
1184                                                   s->output_section);
1185                   target = bfd_get_section_by_name (output_bfd, outname + 5);
1186                   if (target != NULL
1187                       && (target->flags & SEC_READONLY) != 0
1188                       && (target->flags & SEC_ALLOC) != 0)
1189                     reltext = TRUE;
1190                 }
1191
1192               /* We use the reloc_count field as a counter if we need
1193                  to copy relocs into the output file.  */
1194               s->reloc_count = 0;
1195             }
1196         }
1197       else if (! CONST_STRNEQ (name, ".got")
1198                && strcmp (name, ".dynbss") != 0)
1199         {
1200           /* It's not one of our sections, so don't allocate space.  */
1201           continue;
1202         }
1203
1204       if (s->size == 0)
1205         {
1206           /* If we don't need this section, strip it from the
1207              output file.  This is mostly to handle .rela.bss and
1208              .rela.plt.  We must create both sections in
1209              create_dynamic_sections, because they must be created
1210              before the linker maps input sections to output
1211              sections.  The linker does that before
1212              adjust_dynamic_symbol is called, and it is that
1213              function which decides whether anything needs to go
1214              into these sections.  */
1215           s->flags |= SEC_EXCLUDE;
1216           continue;
1217         }
1218
1219       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1220         continue;
1221
1222       /* Allocate memory for the section contents.  */
1223       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->size);
1224       if (s->contents == NULL)
1225         return FALSE;
1226     }
1227
1228   if (elf_hash_table (info)->dynamic_sections_created)
1229     {
1230       /* Add some entries to the .dynamic section.  We fill in the
1231          values later, in elf_vax_finish_dynamic_sections, but we
1232          must add the entries now so that we get the correct size for
1233          the .dynamic section.  The DT_DEBUG entry is filled in by the
1234          dynamic linker and used by the debugger.  */
1235 #define add_dynamic_entry(TAG, VAL) \
1236   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1237
1238       if (!info->shared)
1239         {
1240           if (!add_dynamic_entry (DT_DEBUG, 0))
1241             return FALSE;
1242         }
1243
1244       if (plt)
1245         {
1246           if (!add_dynamic_entry (DT_PLTGOT, 0)
1247               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1248               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1249               || !add_dynamic_entry (DT_JMPREL, 0))
1250             return FALSE;
1251         }
1252
1253       if (relocs)
1254         {
1255           if (!add_dynamic_entry (DT_RELA, 0)
1256               || !add_dynamic_entry (DT_RELASZ, 0)
1257               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1258             return FALSE;
1259         }
1260
1261       if (reltext || (info->flags & DF_TEXTREL) != 0)
1262         {
1263           if (!add_dynamic_entry (DT_TEXTREL, 0))
1264             return FALSE;
1265         }
1266     }
1267 #undef add_dynamic_entry
1268
1269   return TRUE;
1270 }
1271
1272 /* This function is called via elf_vax_link_hash_traverse if we are
1273    creating a shared object with -Bsymbolic.  It discards the space
1274    allocated to copy PC relative relocs against symbols which are defined
1275    in regular objects.  We allocated space for them in the check_relocs
1276    routine, but we won't fill them in in the relocate_section routine.  */
1277
1278 static bfd_boolean
1279 elf_vax_discard_copies (struct elf_vax_link_hash_entry *h,
1280                         PTR ignore ATTRIBUTE_UNUSED)
1281 {
1282   struct elf_vax_pcrel_relocs_copied *s;
1283
1284   if (h->root.root.type == bfd_link_hash_warning)
1285     h = (struct elf_vax_link_hash_entry *) h->root.root.u.i.link;
1286
1287   /* We only discard relocs for symbols defined in a regular object.  */
1288   if (!h->root.def_regular)
1289     return TRUE;
1290
1291   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1292     s->section->size -= s->count * sizeof (Elf32_External_Rela);
1293
1294   return TRUE;
1295 }
1296
1297 /* This function is called via elf_link_hash_traverse.  It looks for entries
1298    that have GOT or PLT (.GOT) references.  If creating a static object or a
1299    shared object with -Bsymbolic, it resets the reference count back to 0
1300    and sets the offset to -1 so normal PC32 relocation will be done.  If
1301    creating a shared object or executable, space in the .got and .rela.got
1302    will be reserved for the symbol.  */
1303
1304 static bfd_boolean
1305 elf_vax_instantiate_got_entries (struct elf_link_hash_entry *h, PTR infoptr)
1306 {
1307   struct bfd_link_info *info = (struct bfd_link_info *) infoptr;
1308   bfd *dynobj;
1309   asection *sgot;
1310   asection *srelgot;
1311
1312   /* We don't care about non-GOT (and non-PLT) entries.  */
1313   if (h->got.refcount <= 0 && h->plt.refcount <= 0)
1314     return TRUE;
1315
1316   dynobj = elf_hash_table (info)->dynobj;
1317   if (dynobj == NULL)
1318     return TRUE;
1319
1320   sgot = bfd_get_section_by_name (dynobj, ".got");
1321   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1322
1323   if (!elf_hash_table (info)->dynamic_sections_created
1324       || (info->shared && info->symbolic))
1325     {
1326       h->got.refcount = 0;
1327       h->got.offset = (bfd_vma) -1;
1328       h->plt.refcount = 0;
1329       h->plt.offset = (bfd_vma) -1;
1330     }
1331   else if (h->got.refcount > 0)
1332     {
1333       /* Make sure this symbol is output as a dynamic symbol.  */
1334       if (h->dynindx == -1)
1335         {
1336           if (!bfd_elf_link_record_dynamic_symbol (info, h))
1337             return FALSE;
1338         }
1339
1340       /* Allocate space in the .got and .rela.got sections.  */
1341       sgot->size += 4;
1342       srelgot->size += sizeof (Elf32_External_Rela);
1343     }
1344
1345   return TRUE;
1346 }
1347
1348 /* Relocate an VAX ELF section.  */
1349
1350 static bfd_boolean
1351 elf_vax_relocate_section (bfd *output_bfd,
1352                           struct bfd_link_info *info,
1353                           bfd *input_bfd,
1354                           asection *input_section,
1355                           bfd_byte *contents,
1356                           Elf_Internal_Rela *relocs,
1357                           Elf_Internal_Sym *local_syms,
1358                           asection **local_sections)
1359 {
1360   bfd *dynobj;
1361   Elf_Internal_Shdr *symtab_hdr;
1362   struct elf_link_hash_entry **sym_hashes;
1363   bfd_vma *local_got_offsets;
1364   bfd_vma plt_index;
1365   bfd_vma got_offset;
1366   asection *sgot;
1367   asection *splt;
1368   asection *sgotplt;
1369   asection *sreloc;
1370   Elf_Internal_Rela *rel;
1371   Elf_Internal_Rela *relend;
1372
1373   dynobj = elf_hash_table (info)->dynobj;
1374   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1375   sym_hashes = elf_sym_hashes (input_bfd);
1376   local_got_offsets = elf_local_got_offsets (input_bfd);
1377
1378   sgot = NULL;
1379   splt = NULL;
1380   sgotplt = NULL;
1381   sreloc = NULL;
1382
1383   rel = relocs;
1384   relend = relocs + input_section->reloc_count;
1385   for (; rel < relend; rel++)
1386     {
1387       int r_type;
1388       reloc_howto_type *howto;
1389       unsigned long r_symndx;
1390       struct elf_link_hash_entry *h;
1391       Elf_Internal_Sym *sym;
1392       asection *sec;
1393       bfd_vma relocation;
1394       bfd_reloc_status_type r;
1395
1396       r_type = ELF32_R_TYPE (rel->r_info);
1397       if (r_type < 0 || r_type >= (int) R_VAX_max)
1398         {
1399           bfd_set_error (bfd_error_bad_value);
1400           return FALSE;
1401         }
1402       howto = howto_table + r_type;
1403
1404       r_symndx = ELF32_R_SYM (rel->r_info);
1405       h = NULL;
1406       sym = NULL;
1407       sec = NULL;
1408       if (r_symndx < symtab_hdr->sh_info)
1409         {
1410           sym = local_syms + r_symndx;
1411           sec = local_sections[r_symndx];
1412           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1413         }
1414       else
1415         {
1416           bfd_boolean unresolved_reloc;
1417           bfd_boolean warned;
1418
1419           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1420                                    r_symndx, symtab_hdr, sym_hashes,
1421                                    h, sec, relocation,
1422                                    unresolved_reloc, warned);
1423
1424           if ((h->root.type == bfd_link_hash_defined
1425               || h->root.type == bfd_link_hash_defweak)
1426               && ((r_type == R_VAX_PLT32
1427                    && h->plt.offset != (bfd_vma) -1
1428                    && elf_hash_table (info)->dynamic_sections_created)
1429                   || (r_type == R_VAX_GOT32
1430                       && strcmp (h->root.root.string,
1431                                  "_GLOBAL_OFFSET_TABLE_") != 0
1432                       && elf_hash_table (info)->dynamic_sections_created
1433                       && (! info->shared
1434                           || (! info->symbolic && h->dynindx != -1)
1435                           || !h->def_regular))
1436                   || (info->shared
1437                       && ((! info->symbolic && h->dynindx != -1)
1438                           || !h->def_regular)
1439                       && ((input_section->flags & SEC_ALLOC) != 0
1440                           /* DWARF will emit R_VAX_32 relocations in its
1441                              sections against symbols defined externally
1442                              in shared libraries.  We can't do anything
1443                              with them here.  */
1444
1445                           || ((input_section->flags & SEC_DEBUGGING) != 0
1446                               && h->def_dynamic))
1447                       && (r_type == R_VAX_8
1448                           || r_type == R_VAX_16
1449                           || r_type == R_VAX_32
1450                           || r_type == R_VAX_PC8
1451                           || r_type == R_VAX_PC16
1452                           || r_type == R_VAX_PC32))))
1453             /* In these cases, we don't need the relocation
1454                value.  We check specially because in some
1455                obscure cases sec->output_section will be NULL.  */
1456             relocation = 0;
1457         }
1458
1459       if (sec != NULL && elf_discarded_section (sec))
1460         {
1461           /* For relocs against symbols from removed linkonce sections,
1462              or sections discarded by a linker script, we just want the
1463              section contents zeroed.  Avoid any special processing.  */
1464           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1465           rel->r_info = 0;
1466           rel->r_addend = 0;
1467           continue;
1468         }
1469
1470       if (info->relocatable)
1471         continue;
1472
1473       switch (r_type)
1474         {
1475         case R_VAX_GOT32:
1476           /* Relocation is to the address of the entry for this symbol
1477              in the global offset table.  */
1478           if (h == NULL || h->got.offset == (bfd_vma) -1)
1479             break;
1480
1481           /* Relocation is the offset of the entry for this symbol in
1482              the global offset table.  */
1483
1484           {
1485             bfd_vma off;
1486
1487             if (sgot == NULL)
1488               {
1489                 sgot = bfd_get_section_by_name (dynobj, ".got");
1490                 BFD_ASSERT (sgot != NULL);
1491               }
1492
1493             BFD_ASSERT (h != NULL);
1494             off = h->got.offset;
1495             BFD_ASSERT (off != (bfd_vma) -1);
1496             BFD_ASSERT (off < sgot->size);
1497
1498             if (info->shared
1499                 && h->dynindx == -1
1500                 && h->def_regular)
1501               {
1502                 /* The symbol was forced to be local
1503                    because of a version file..  We must initialize
1504                    this entry in the global offset table.  Since
1505                    the offset must always be a multiple of 4, we
1506                    use the least significant bit to record whether
1507                    we have initialized it already.
1508
1509                    When doing a dynamic link, we create a .rela.got
1510                    relocation entry to initialize the value.  This
1511                    is done in the finish_dynamic_symbol routine.  */
1512                 if ((off & 1) != 0)
1513                   off &= ~1;
1514                 else
1515                   {
1516                     bfd_put_32 (output_bfd, relocation + rel->r_addend,
1517                                 sgot->contents + off);
1518                     h->got.offset |= 1;
1519                   }
1520               } else {
1521                 bfd_put_32 (output_bfd, rel->r_addend, sgot->contents + off);
1522               }
1523
1524             relocation = sgot->output_offset + off;
1525             /* The GOT relocation uses the addend.  */
1526             rel->r_addend = 0;
1527
1528             /* Change the reference to be indirect.  */
1529             contents[rel->r_offset - 1] |= 0x10;
1530             relocation += sgot->output_section->vma;
1531           }
1532           break;
1533
1534         case R_VAX_PLT32:
1535           /* Relocation is to the entry for this symbol in the
1536              procedure linkage table.  */
1537
1538           /* Resolve a PLTxx reloc against a local symbol directly,
1539              without using the procedure linkage table.  */
1540           if (h == NULL)
1541             break;
1542
1543           if (h->plt.offset == (bfd_vma) -1
1544               || !elf_hash_table (info)->dynamic_sections_created)
1545             {
1546               /* We didn't make a PLT entry for this symbol.  This
1547                  happens when statically linking PIC code, or when
1548                  using -Bsymbolic.  */
1549               break;
1550             }
1551
1552           if (splt == NULL)
1553             {
1554               splt = bfd_get_section_by_name (dynobj, ".plt");
1555               BFD_ASSERT (splt != NULL);
1556             }
1557
1558           if (sgotplt == NULL)
1559             {
1560               sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1561               BFD_ASSERT (splt != NULL);
1562             }
1563
1564           plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1565
1566           /* Get the offset into the .got table of the entry that
1567              corresponds to this function.  Each .got entry is 4 bytes.
1568              The first two are reserved.  */
1569           got_offset = (plt_index + 3) * 4;
1570
1571           /* We want the relocate to point into the .got.plt instead
1572              of the plt itself.  */
1573           relocation = (sgotplt->output_section->vma
1574                         + sgotplt->output_offset
1575                         + got_offset);
1576           contents[rel->r_offset-1] |= 0x10; /* make indirect */
1577           if (rel->r_addend == 2)
1578             {
1579               h->plt.offset |= 1;
1580             }
1581           else if (rel->r_addend != 0)
1582             (*_bfd_error_handler)
1583               (_("%s: warning: PLT addend of %d to `%s' from %s section ignored"),
1584                       bfd_get_filename (input_bfd), rel->r_addend,
1585                       h->root.root.string,
1586                       bfd_get_section_name (input_bfd, input_section));
1587           rel->r_addend = 0;
1588
1589           break;
1590
1591         case R_VAX_PC8:
1592         case R_VAX_PC16:
1593         case R_VAX_PC32:
1594           if (h == NULL)
1595             break;
1596           /* Fall through.  */
1597         case R_VAX_8:
1598         case R_VAX_16:
1599         case R_VAX_32:
1600           if (info->shared
1601               && r_symndx != 0
1602               && (input_section->flags & SEC_ALLOC) != 0
1603               && ((r_type != R_VAX_PC8
1604                    && r_type != R_VAX_PC16
1605                    && r_type != R_VAX_PC32)
1606                   || ((input_section->flags & SEC_CODE)
1607                       && (!info->symbolic
1608                           || (!h->def_regular && h->type != STT_SECTION)))))
1609             {
1610               Elf_Internal_Rela outrel;
1611               bfd_byte *loc;
1612               bfd_boolean skip, relocate;
1613
1614               /* When generating a shared object, these relocations
1615                  are copied into the output file to be resolved at run
1616                  time.  */
1617               if (sreloc == NULL)
1618                 {
1619                   const char *name;
1620
1621                   name = (bfd_elf_string_from_elf_section
1622                           (input_bfd,
1623                            elf_elfheader (input_bfd)->e_shstrndx,
1624                            elf_section_data (input_section)->rel_hdr.sh_name));
1625                   if (name == NULL)
1626                     return FALSE;
1627
1628                   BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1629                               && strcmp (bfd_get_section_name (input_bfd,
1630                                                                input_section),
1631                                          name + 5) == 0);
1632
1633                   sreloc = bfd_get_section_by_name (dynobj, name);
1634                   BFD_ASSERT (sreloc != NULL);
1635                 }
1636
1637               skip = FALSE;
1638               relocate = FALSE;
1639
1640               outrel.r_offset =
1641                 _bfd_elf_section_offset (output_bfd, info, input_section,
1642                                          rel->r_offset);
1643               if (outrel.r_offset == (bfd_vma) -1)
1644                 skip = TRUE;
1645               if (outrel.r_offset == (bfd_vma) -2)
1646                 skip = TRUE, relocate = TRUE;
1647               outrel.r_offset += (input_section->output_section->vma
1648                                   + input_section->output_offset);
1649
1650               if (skip)
1651                   memset (&outrel, 0, sizeof outrel);
1652               /* h->dynindx may be -1 if the symbol was marked to
1653                  become local.  */
1654               else if (h != NULL
1655                        && ((! info->symbolic && h->dynindx != -1)
1656                            || !h->def_regular))
1657                 {
1658                   BFD_ASSERT (h->dynindx != -1);
1659                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1660                   outrel.r_addend = relocation + rel->r_addend;
1661                 }
1662               else
1663                 {
1664                   if (r_type == R_VAX_32)
1665                     {
1666                       relocate = TRUE;
1667                       outrel.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1668                       BFD_ASSERT (bfd_get_signed_32 (input_bfd,
1669                                                      &contents[rel->r_offset]) == 0);
1670                       outrel.r_addend = relocation + rel->r_addend;
1671                     }
1672                   else
1673                     {
1674                       long indx;
1675
1676                       if (bfd_is_abs_section (sec))
1677                         indx = 0;
1678                       else if (sec == NULL || sec->owner == NULL)
1679                         {
1680                           bfd_set_error (bfd_error_bad_value);
1681                           return FALSE;
1682                         }
1683                       else
1684                         {
1685                           asection *osec;
1686
1687                           /* We are turning this relocation into one
1688                              against a section symbol.  It would be
1689                              proper to subtract the symbol's value,
1690                              osec->vma, from the emitted reloc addend,
1691                              but ld.so expects buggy relocs.  */
1692                           osec = sec->output_section;
1693                           indx = elf_section_data (osec)->dynindx;
1694                           if (indx == 0)
1695                             {
1696                               struct elf_link_hash_table *htab;
1697                               htab = elf_hash_table (info);
1698                               osec = htab->text_index_section;
1699                               indx = elf_section_data (osec)->dynindx;
1700                             }
1701                           BFD_ASSERT (indx != 0);
1702                         }
1703
1704                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1705                       outrel.r_addend = relocation + rel->r_addend;
1706                     }
1707                 }
1708
1709               if (!strcmp (bfd_get_section_name (input_bfd, input_section),
1710                            ".text") != 0 ||
1711                   (info->shared
1712                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_32
1713                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_RELATIVE
1714                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_COPY
1715                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_JMP_SLOT
1716                    && ELF32_R_TYPE(outrel.r_info) != R_VAX_GLOB_DAT))
1717                 {
1718                   if (h != NULL)
1719                     (*_bfd_error_handler)
1720                       (_("%s: warning: %s relocation against symbol `%s' from %s section"),
1721                       bfd_get_filename (input_bfd), howto->name,
1722                       h->root.root.string,
1723                       bfd_get_section_name (input_bfd, input_section));
1724                   else
1725                     (*_bfd_error_handler)
1726                       (_("%s: warning: %s relocation to 0x%x from %s section"),
1727                       bfd_get_filename (input_bfd), howto->name,
1728                       outrel.r_addend,
1729                       bfd_get_section_name (input_bfd, input_section));
1730                 }
1731               loc = sreloc->contents;
1732               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1733               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1734
1735               /* This reloc will be computed at runtime, so there's no
1736                  need to do anything now, except for R_VAX_32
1737                  relocations that have been turned into
1738                  R_VAX_RELATIVE.  */
1739               if (!relocate)
1740                 continue;
1741             }
1742
1743           break;
1744
1745         case R_VAX_GNU_VTINHERIT:
1746         case R_VAX_GNU_VTENTRY:
1747           /* These are no-ops in the end.  */
1748           continue;
1749
1750         default:
1751           break;
1752         }
1753
1754       /* VAX PCREL relocations are from the end of relocation, not the start.
1755          So subtract the difference from the relocation amount since we can't
1756          add it to the offset.  */
1757       if (howto->pc_relative && howto->pcrel_offset)
1758         relocation -= bfd_get_reloc_size(howto);
1759
1760       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1761                                     contents, rel->r_offset,
1762                                     relocation, rel->r_addend);
1763
1764       if (r != bfd_reloc_ok)
1765         {
1766           switch (r)
1767             {
1768             default:
1769             case bfd_reloc_outofrange:
1770               abort ();
1771             case bfd_reloc_overflow:
1772               {
1773                 const char *name;
1774
1775                 if (h != NULL)
1776                   name = NULL;
1777                 else
1778                   {
1779                     name = bfd_elf_string_from_elf_section (input_bfd,
1780                                                             symtab_hdr->sh_link,
1781                                                             sym->st_name);
1782                     if (name == NULL)
1783                       return FALSE;
1784                     if (*name == '\0')
1785                       name = bfd_section_name (input_bfd, sec);
1786                   }
1787                 if (!(info->callbacks->reloc_overflow
1788                       (info, (h ? &h->root : NULL), name, howto->name,
1789                        (bfd_vma) 0, input_bfd, input_section,
1790                        rel->r_offset)))
1791                   return FALSE;
1792               }
1793               break;
1794             }
1795         }
1796     }
1797
1798   return TRUE;
1799 }
1800
1801 /* Finish up dynamic symbol handling.  We set the contents of various
1802    dynamic sections here.  */
1803
1804 static bfd_boolean
1805 elf_vax_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
1806                                struct elf_link_hash_entry *h,
1807                                Elf_Internal_Sym *sym)
1808 {
1809   bfd *dynobj;
1810
1811   dynobj = elf_hash_table (info)->dynobj;
1812
1813   if (h->plt.offset != (bfd_vma) -1)
1814     {
1815       asection *splt;
1816       asection *sgot;
1817       asection *srela;
1818       bfd_vma plt_index;
1819       bfd_vma got_offset;
1820       bfd_vma addend;
1821       Elf_Internal_Rela rela;
1822       bfd_byte *loc;
1823
1824       /* This symbol has an entry in the procedure linkage table.  Set
1825          it up.  */
1826       BFD_ASSERT (h->dynindx != -1);
1827
1828       splt = bfd_get_section_by_name (dynobj, ".plt");
1829       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1830       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1831       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1832
1833       addend = 2 * (h->plt.offset & 1);
1834       h->plt.offset &= ~1;
1835
1836       /* Get the index in the procedure linkage table which
1837          corresponds to this symbol.  This is the index of this symbol
1838          in all the symbols for which we are making plt entries.  The
1839          first entry in the procedure linkage table is reserved.  */
1840       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1841
1842       /* Get the offset into the .got table of the entry that
1843          corresponds to this function.  Each .got entry is 4 bytes.
1844          The first two are reserved.  */
1845       got_offset = (plt_index + 3) * 4;
1846
1847       /* Fill in the entry in the procedure linkage table.  */
1848       memcpy (splt->contents + h->plt.offset, elf_vax_plt_entry,
1849                   PLT_ENTRY_SIZE);
1850
1851       /* The offset is relative to the first extension word.  */
1852       bfd_put_32 (output_bfd,
1853                   -(h->plt.offset + 8),
1854                   splt->contents + h->plt.offset + 4);
1855
1856       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1857                   splt->contents + h->plt.offset + 8);
1858
1859       /* Fill in the entry in the global offset table.  */
1860       bfd_put_32 (output_bfd,
1861                   (splt->output_section->vma
1862                    + splt->output_offset
1863                    + h->plt.offset) + addend,
1864                   sgot->contents + got_offset);
1865
1866       /* Fill in the entry in the .rela.plt section.  */
1867       rela.r_offset = (sgot->output_section->vma
1868                        + sgot->output_offset
1869                        + got_offset);
1870       rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_JMP_SLOT);
1871       rela.r_addend = addend;
1872       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1873       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1874
1875       if (!h->def_regular)
1876         {
1877           /* Mark the symbol as undefined, rather than as defined in
1878              the .plt section.  Leave the value alone.  */
1879           sym->st_shndx = SHN_UNDEF;
1880         }
1881     }
1882
1883   if (h->got.offset != (bfd_vma) -1)
1884     {
1885       asection *sgot;
1886       asection *srela;
1887       Elf_Internal_Rela rela;
1888       bfd_byte *loc;
1889
1890       /* This symbol has an entry in the global offset table.  Set it
1891          up.  */
1892       sgot = bfd_get_section_by_name (dynobj, ".got");
1893       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1894       BFD_ASSERT (sgot != NULL && srela != NULL);
1895
1896       rela.r_offset = (sgot->output_section->vma
1897                        + sgot->output_offset
1898                        + (h->got.offset &~ 1));
1899
1900       /* If the symbol was forced to be local because of a version file
1901          locally we just want to emit a RELATIVE reloc.  The entry in
1902          the global offset table will already have been initialized in
1903          the relocate_section function.  */
1904       if (info->shared
1905           && h->dynindx == -1
1906           && h->def_regular)
1907         {
1908           rela.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1909         }
1910       else
1911         {
1912           rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_GLOB_DAT);
1913         }
1914       rela.r_addend = bfd_get_signed_32 (output_bfd,
1915                                          (sgot->contents
1916                                           + (h->got.offset & ~1)));
1917
1918       loc = srela->contents;
1919       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1920       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1921     }
1922
1923   if (h->needs_copy)
1924     {
1925       asection *s;
1926       Elf_Internal_Rela rela;
1927       bfd_byte *loc;
1928
1929       /* This symbol needs a copy reloc.  Set it up.  */
1930       BFD_ASSERT (h->dynindx != -1
1931                   && (h->root.type == bfd_link_hash_defined
1932                       || h->root.type == bfd_link_hash_defweak));
1933
1934       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1935                                    ".rela.bss");
1936       BFD_ASSERT (s != NULL);
1937
1938       rela.r_offset = (h->root.u.def.value
1939                        + h->root.u.def.section->output_section->vma
1940                        + h->root.u.def.section->output_offset);
1941       rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_COPY);
1942       rela.r_addend = 0;
1943       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1944       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1945     }
1946
1947   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1948   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1949       || h == elf_hash_table (info)->hgot)
1950     sym->st_shndx = SHN_ABS;
1951
1952   return TRUE;
1953 }
1954
1955 /* Finish up the dynamic sections.  */
1956
1957 static bfd_boolean
1958 elf_vax_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1959 {
1960   bfd *dynobj;
1961   asection *sgot;
1962   asection *sdyn;
1963
1964   dynobj = elf_hash_table (info)->dynobj;
1965
1966   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1967   BFD_ASSERT (sgot != NULL);
1968   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1969
1970   if (elf_hash_table (info)->dynamic_sections_created)
1971     {
1972       asection *splt;
1973       Elf32_External_Dyn *dyncon, *dynconend;
1974
1975       splt = bfd_get_section_by_name (dynobj, ".plt");
1976       BFD_ASSERT (splt != NULL && sdyn != NULL);
1977
1978       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1979       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1980       for (; dyncon < dynconend; dyncon++)
1981         {
1982           Elf_Internal_Dyn dyn;
1983           const char *name;
1984           asection *s;
1985
1986           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1987
1988           switch (dyn.d_tag)
1989             {
1990             default:
1991               break;
1992
1993             case DT_PLTGOT:
1994               name = ".got";
1995               goto get_vma;
1996             case DT_JMPREL:
1997               name = ".rela.plt";
1998             get_vma:
1999               s = bfd_get_section_by_name (output_bfd, name);
2000               BFD_ASSERT (s != NULL);
2001               dyn.d_un.d_ptr = s->vma;
2002               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2003               break;
2004
2005             case DT_PLTRELSZ:
2006               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2007               BFD_ASSERT (s != NULL);
2008               dyn.d_un.d_val = s->size;
2009               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2010               break;
2011
2012             case DT_RELASZ:
2013               /* The procedure linkage table relocs (DT_JMPREL) should
2014                  not be included in the overall relocs (DT_RELA).
2015                  Therefore, we override the DT_RELASZ entry here to
2016                  make it not include the JMPREL relocs.  Since the
2017                  linker script arranges for .rela.plt to follow all
2018                  other relocation sections, we don't have to worry
2019                  about changing the DT_RELA entry.  */
2020               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2021               if (s != NULL)
2022                 dyn.d_un.d_val -= s->size;
2023               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2024               break;
2025             }
2026         }
2027
2028       /* Fill in the first entry in the procedure linkage table.  */
2029       if (splt->size > 0)
2030         {
2031           memcpy (splt->contents, elf_vax_plt0_entry, PLT_ENTRY_SIZE);
2032           bfd_put_32 (output_bfd,
2033                           (sgot->output_section->vma
2034                            + sgot->output_offset + 4
2035                            - (splt->output_section->vma + 6)),
2036                           splt->contents + 2);
2037           bfd_put_32 (output_bfd,
2038                           (sgot->output_section->vma
2039                            + sgot->output_offset + 8
2040                            - (splt->output_section->vma + 12)),
2041                           splt->contents + 8);
2042           elf_section_data (splt->output_section)->this_hdr.sh_entsize
2043            = PLT_ENTRY_SIZE;
2044         }
2045     }
2046
2047   /* Fill in the first three entries in the global offset table.  */
2048   if (sgot->size > 0)
2049     {
2050       if (sdyn == NULL)
2051         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2052       else
2053         bfd_put_32 (output_bfd,
2054                     sdyn->output_section->vma + sdyn->output_offset,
2055                     sgot->contents);
2056       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2057       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2058     }
2059
2060   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2061
2062   return TRUE;
2063 }
2064
2065 #define TARGET_LITTLE_SYM               bfd_elf32_vax_vec
2066 #define TARGET_LITTLE_NAME              "elf32-vax"
2067 #define ELF_MACHINE_CODE                EM_VAX
2068 #define ELF_MAXPAGESIZE                 0x1000
2069
2070 #define elf_backend_create_dynamic_sections \
2071                                         _bfd_elf_create_dynamic_sections
2072 #define bfd_elf32_bfd_link_hash_table_create \
2073                                         elf_vax_link_hash_table_create
2074 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
2075
2076 #define elf_backend_check_relocs        elf_vax_check_relocs
2077 #define elf_backend_adjust_dynamic_symbol \
2078                                         elf_vax_adjust_dynamic_symbol
2079 #define elf_backend_size_dynamic_sections \
2080                                         elf_vax_size_dynamic_sections
2081 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
2082 #define elf_backend_relocate_section    elf_vax_relocate_section
2083 #define elf_backend_finish_dynamic_symbol \
2084                                         elf_vax_finish_dynamic_symbol
2085 #define elf_backend_finish_dynamic_sections \
2086                                         elf_vax_finish_dynamic_sections
2087 #define elf_backend_gc_mark_hook        elf_vax_gc_mark_hook
2088 #define elf_backend_gc_sweep_hook       elf_vax_gc_sweep_hook
2089 #define bfd_elf32_bfd_merge_private_bfd_data \
2090                                         elf32_vax_merge_private_bfd_data
2091 #define bfd_elf32_bfd_set_private_flags \
2092                                         elf32_vax_set_private_flags
2093 #define bfd_elf32_bfd_print_private_bfd_data \
2094                                         elf32_vax_print_private_bfd_data
2095
2096 #define elf_backend_can_gc_sections     1
2097 #define elf_backend_want_got_plt        1
2098 #define elf_backend_plt_readonly        1
2099 #define elf_backend_want_plt_sym        0
2100 #define elf_backend_got_header_size     16
2101 #define elf_backend_rela_normal         1
2102
2103 #include "elf32-target.h"