bfd/elf32-vax.c

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