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