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