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