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