projects / deliverable / binutils-gdb.git / blob
? search:


8faf99c519016b76ebe23003ae1de595d6255491
[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
1177 if ((s->flags & SEC_LINKER_CREATED) == 0)
1178 continue;
1179
1180 /* It's OK to base decisions on the section name, because none
1181 of the dynobj section names depend upon the input files. */
1182 name = bfd_get_section_name (dynobj, s);
1183
1184 if (strcmp (name, ".plt") == 0)
1185 {
1186 /* Remember whether there is a PLT. */
1187 plt = s->size != 0;
1188 }
1189 else if (strncmp (name, ".rela", 5) == 0)
1190 {
1191 if (s->size != 0)
1192 {
1193 asection *target;
1194
1195 /* Remember whether there are any reloc sections other
1196 than .rela.plt. */
1197 if (strcmp (name, ".rela.plt") != 0)
1198 {
1199 const char *outname;
1200
1201 relocs = TRUE;
1202
1203 /* If this relocation section applies to a read only
1204 section, then we probably need a DT_TEXTREL
1205 entry. .rela.plt is actually associated with
1206 .got.plt, which is never readonly. */
1207 outname = bfd_get_section_name (output_bfd,
1208 s->output_section);
1209 target = bfd_get_section_by_name (output_bfd, outname + 5);
1210 if (target != NULL
1211 && (target->flags & SEC_READONLY) != 0
1212 && (target->flags & SEC_ALLOC) != 0)
1213 reltext = TRUE;
1214 }
1215
1216 /* We use the reloc_count field as a counter if we need
1217 to copy relocs into the output file. */
1218 s->reloc_count = 0;
1219 }
1220 }
1221 else if (strncmp (name, ".got", 4) != 0
1222 && strcmp (name, ".dynbss") != 0)
1223 {
1224 /* It's not one of our sections, so don't allocate space. */
1225 continue;
1226 }
1227
1228 if (s->size == 0)
1229 {
1230 /* If we don't need this section, strip it from the
1231 output file. This is mostly to handle .rela.bss and
1232 .rela.plt. We must create both sections in
1233 create_dynamic_sections, because they must be created
1234 before the linker maps input sections to output
1235 sections. The linker does that before
1236 adjust_dynamic_symbol is called, and it is that
1237 function which decides whether anything needs to go
1238 into these sections. */
1239 s->flags |= SEC_EXCLUDE;
1240 continue;
1241 }
1242
1243 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1244 continue;
1245
1246 /* Allocate memory for the section contents. */
1247 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->size);
1248 if (s->contents == NULL)
1249 return FALSE;
1250 }
1251
1252 if (elf_hash_table (info)->dynamic_sections_created)
1253 {
1254 /* Add some entries to the .dynamic section. We fill in the
1255 values later, in elf_vax_finish_dynamic_sections, but we
1256 must add the entries now so that we get the correct size for
1257 the .dynamic section. The DT_DEBUG entry is filled in by the
1258 dynamic linker and used by the debugger. */
1259 #define add_dynamic_entry(TAG, VAL) \
1260 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1261
1262 if (!info->shared)
1263 {
1264 if (!add_dynamic_entry (DT_DEBUG, 0))
1265 return FALSE;
1266 }
1267
1268 if (plt)
1269 {
1270 if (!add_dynamic_entry (DT_PLTGOT, 0)
1271 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1272 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1273 || !add_dynamic_entry (DT_JMPREL, 0))
1274 return FALSE;
1275 }
1276
1277 if (relocs)
1278 {
1279 if (!add_dynamic_entry (DT_RELA, 0)
1280 || !add_dynamic_entry (DT_RELASZ, 0)
1281 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1282 return FALSE;
1283 }
1284
1285 if (reltext || (info->flags & DF_TEXTREL) != 0)
1286 {
1287 if (!add_dynamic_entry (DT_TEXTREL, 0))
1288 return FALSE;
1289 }
1290 }
1291 #undef add_dynamic_entry
1292
1293 return TRUE;
1294 }
1295
1296 /* This function is called via elf_vax_link_hash_traverse if we are
1297 creating a shared object with -Bsymbolic. It discards the space
1298 allocated to copy PC relative relocs against symbols which are defined
1299 in regular objects. We allocated space for them in the check_relocs
1300 routine, but we won't fill them in in the relocate_section routine. */
1301
1302 static bfd_boolean
1303 elf_vax_discard_copies (struct elf_vax_link_hash_entry *h,
1304 PTR ignore ATTRIBUTE_UNUSED)
1305 {
1306 struct elf_vax_pcrel_relocs_copied *s;
1307
1308 if (h->root.root.type == bfd_link_hash_warning)
1309 h = (struct elf_vax_link_hash_entry *) h->root.root.u.i.link;
1310
1311 /* We only discard relocs for symbols defined in a regular object. */
1312 if (!h->root.def_regular)
1313 return TRUE;
1314
1315 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1316 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1317
1318 return TRUE;
1319 }
1320
1321 /* This function is called via elf_link_hash_traverse. It looks for entries
1322 that have GOT or PLT (.GOT) references. If creating a static object or a
1323 shared object with -Bsymbolic, it resets the reference count back to 0
1324 and sets the offset to -1 so normal PC32 relocation will be done. If
1325 creating a shared object or executable, space in the .got and .rela.got
1326 will be reserved for the symbol. */
1327
1328 static bfd_boolean
1329 elf_vax_instantiate_got_entries (struct elf_link_hash_entry *h, PTR infoptr)
1330 {
1331 struct bfd_link_info *info = (struct bfd_link_info *) infoptr;
1332 bfd *dynobj;
1333 asection *sgot;
1334 asection *srelgot;
1335
1336 /* We don't care about non-GOT (and non-PLT) entries. */
1337 if (h->got.refcount <= 0 && h->plt.refcount <= 0)
1338 return TRUE;
1339
1340 dynobj = elf_hash_table (info)->dynobj;
1341 if (dynobj == NULL)
1342 return TRUE;
1343
1344 sgot = bfd_get_section_by_name (dynobj, ".got");
1345 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1346
1347 if (!elf_hash_table (info)->dynamic_sections_created
1348 || (info->shared && info->symbolic))
1349 {
1350 h->got.refcount = 0;
1351 h->got.offset = (bfd_vma) -1;
1352 h->plt.refcount = 0;
1353 h->plt.offset = (bfd_vma) -1;
1354 }
1355 else if (h->got.refcount > 0)
1356 {
1357 /* Make sure this symbol is output as a dynamic symbol. */
1358 if (h->dynindx == -1)
1359 {
1360 if (!bfd_elf_link_record_dynamic_symbol (info, h))
1361 return FALSE;
1362 }
1363
1364 /* Allocate space in the .got and .rela.got sections. */
1365 sgot->size += 4;
1366 srelgot->size += sizeof (Elf32_External_Rela);
1367 }
1368
1369 return TRUE;
1370 }
1371
1372 /* Relocate an VAX ELF section. */
1373
1374 static bfd_boolean
1375 elf_vax_relocate_section (bfd *output_bfd,
1376 struct bfd_link_info *info,
1377 bfd *input_bfd,
1378 asection *input_section,
1379 bfd_byte *contents,
1380 Elf_Internal_Rela *relocs,
1381 Elf_Internal_Sym *local_syms,
1382 asection **local_sections)
1383 {
1384 bfd *dynobj;
1385 Elf_Internal_Shdr *symtab_hdr;
1386 struct elf_link_hash_entry **sym_hashes;
1387 bfd_vma *local_got_offsets;
1388 bfd_vma plt_index;
1389 bfd_vma got_offset;
1390 asection *sgot;
1391 asection *splt;
1392 asection *sgotplt;
1393 asection *sreloc;
1394 Elf_Internal_Rela *rel;
1395 Elf_Internal_Rela *relend;
1396
1397 if (info->relocatable)
1398 return TRUE;
1399
1400 dynobj = elf_hash_table (info)->dynobj;
1401 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1402 sym_hashes = elf_sym_hashes (input_bfd);
1403 local_got_offsets = elf_local_got_offsets (input_bfd);
1404
1405 sgot = NULL;
1406 splt = NULL;
1407 sgotplt = NULL;
1408 sreloc = NULL;
1409
1410 rel = relocs;
1411 relend = relocs + input_section->reloc_count;
1412 for (; rel < relend; rel++)
1413 {
1414 int r_type;
1415 reloc_howto_type *howto;
1416 unsigned long r_symndx;
1417 struct elf_link_hash_entry *h;
1418 Elf_Internal_Sym *sym;
1419 asection *sec;
1420 bfd_vma relocation;
1421 bfd_reloc_status_type r;
1422
1423 r_type = ELF32_R_TYPE (rel->r_info);
1424 if (r_type < 0 || r_type >= (int) R_VAX_max)
1425 {
1426 bfd_set_error (bfd_error_bad_value);
1427 return FALSE;
1428 }
1429 howto = howto_table + r_type;
1430
1431 /* This is a final link. */
1432 r_symndx = ELF32_R_SYM (rel->r_info);
1433 h = NULL;
1434 sym = NULL;
1435 sec = NULL;
1436 if (r_symndx < symtab_hdr->sh_info)
1437 {
1438 sym = local_syms + r_symndx;
1439 sec = local_sections[r_symndx];
1440 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1441 }
1442 else
1443 {
1444 bfd_boolean unresolved_reloc;
1445 bfd_boolean warned;
1446
1447 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1448 r_symndx, symtab_hdr, sym_hashes,
1449 h, sec, relocation,
1450 unresolved_reloc, warned);
1451
1452 if ((h->root.type == bfd_link_hash_defined
1453 || h->root.type == bfd_link_hash_defweak)
1454 && ((r_type == R_VAX_PLT32
1455 && h->plt.offset != (bfd_vma) -1
1456 && elf_hash_table (info)->dynamic_sections_created)
1457 || (r_type == R_VAX_GOT32
1458 && strcmp (h->root.root.string,
1459 "_GLOBAL_OFFSET_TABLE_") != 0
1460 && elf_hash_table (info)->dynamic_sections_created
1461 && (! info->shared
1462 || (! info->symbolic && h->dynindx != -1)
1463 || !h->def_regular))
1464 || (info->shared
1465 && ((! info->symbolic && h->dynindx != -1)
1466 || !h->def_regular)
1467 && ((input_section->flags & SEC_ALLOC) != 0
1468 /* DWARF will emit R_VAX_32 relocations in its
1469 sections against symbols defined externally
1470 in shared libraries. We can't do anything
1471 with them here. */
1472
1473 || ((input_section->flags & SEC_DEBUGGING) != 0
1474 && h->def_dynamic))
1475 && (r_type == R_VAX_8
1476 || r_type == R_VAX_16
1477 || r_type == R_VAX_32
1478 || r_type == R_VAX_PC8
1479 || r_type == R_VAX_PC16
1480 || r_type == R_VAX_PC32))))
1481 /* In these cases, we don't need the relocation
1482 value. We check specially because in some
1483 obscure cases sec->output_section will be NULL. */
1484 relocation = 0;
1485 }
1486
1487 switch (r_type)
1488 {
1489 case R_VAX_GOT32:
1490 /* Relocation is to the address of the entry for this symbol
1491 in the global offset table. */
1492 if (h == NULL || h->got.offset == (bfd_vma) -1)
1493 break;
1494
1495 /* Relocation is the offset of the entry for this symbol in
1496 the global offset table. */
1497
1498 {
1499 bfd_vma off;
1500
1501 if (sgot == NULL)
1502 {
1503 sgot = bfd_get_section_by_name (dynobj, ".got");
1504 BFD_ASSERT (sgot != NULL);
1505 }
1506
1507 BFD_ASSERT (h != NULL);
1508 off = h->got.offset;
1509 BFD_ASSERT (off != (bfd_vma) -1);
1510 BFD_ASSERT (off < sgot->size);
1511
1512 if (info->shared
1513 && h->dynindx == -1
1514 && h->def_regular)
1515 {
1516 /* The symbol was forced to be local
1517 because of a version file.. We must initialize
1518 this entry in the global offset table. Since
1519 the offset must always be a multiple of 4, we
1520 use the least significant bit to record whether
1521 we have initialized it already.
1522
1523 When doing a dynamic link, we create a .rela.got
1524 relocation entry to initialize the value. This
1525 is done in the finish_dynamic_symbol routine. */
1526 if ((off & 1) != 0)
1527 off &= ~1;
1528 else
1529 {
1530 bfd_put_32 (output_bfd, relocation + rel->r_addend,
1531 sgot->contents + off);
1532 h->got.offset |= 1;
1533 }
1534 } else {
1535 bfd_put_32 (output_bfd, rel->r_addend, sgot->contents + off);
1536 }
1537
1538 relocation = sgot->output_offset + off;
1539 /* The GOT relocation uses the addend. */
1540 rel->r_addend = 0;
1541
1542 /* Change the reference to be indirect. */
1543 contents[rel->r_offset - 1] |= 0x10;
1544 relocation += sgot->output_section->vma;
1545 }
1546 break;
1547
1548 case R_VAX_PLT32:
1549 /* Relocation is to the entry for this symbol in the
1550 procedure linkage table. */
1551
1552 /* Resolve a PLTxx reloc against a local symbol directly,
1553 without using the procedure linkage table. */
1554 if (h == NULL)
1555 break;
1556
1557 if (h->plt.offset == (bfd_vma) -1
1558 || !elf_hash_table (info)->dynamic_sections_created)
1559 {
1560 /* We didn't make a PLT entry for this symbol. This
1561 happens when statically linking PIC code, or when
1562 using -Bsymbolic. */
1563 break;
1564 }
1565
1566 if (splt == NULL)
1567 {
1568 splt = bfd_get_section_by_name (dynobj, ".plt");
1569 BFD_ASSERT (splt != NULL);
1570 }
1571
1572 if (sgotplt == NULL)
1573 {
1574 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1575 BFD_ASSERT (splt != NULL);
1576 }
1577
1578 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1579
1580 /* Get the offset into the .got table of the entry that
1581 corresponds to this function. Each .got entry is 4 bytes.
1582 The first two are reserved. */
1583 got_offset = (plt_index + 3) * 4;
1584
1585 /* We want the relocate to point into the .got.plt instead
1586 of the plt itself. */
1587 relocation = (sgotplt->output_section->vma
1588 + sgotplt->output_offset
1589 + got_offset);
1590 contents[rel->r_offset-1] |= 0x10; /* make indirect */
1591 if (rel->r_addend == 2)
1592 {
1593 h->plt.offset |= 1;
1594 }
1595 else if (rel->r_addend != 0)
1596 (*_bfd_error_handler)
1597 (_("%s: warning: PLT addend of %d to `%s' from %s section ignored"),
1598 bfd_get_filename (input_bfd), rel->r_addend,
1599 h->root.root.string,
1600 bfd_get_section_name (input_bfd, input_section));
1601 rel->r_addend = 0;
1602
1603 break;
1604
1605 case R_VAX_PC8:
1606 case R_VAX_PC16:
1607 case R_VAX_PC32:
1608 if (h == NULL)
1609 break;
1610 /* Fall through. */
1611 case R_VAX_8:
1612 case R_VAX_16:
1613 case R_VAX_32:
1614 if (info->shared
1615 && r_symndx != 0
1616 && (input_section->flags & SEC_ALLOC) != 0
1617 && ((r_type != R_VAX_PC8
1618 && r_type != R_VAX_PC16
1619 && r_type != R_VAX_PC32)
1620 || (!info->symbolic
1621 || !h->def_regular)))
1622 {
1623 Elf_Internal_Rela outrel;
1624 bfd_byte *loc;
1625 bfd_boolean skip, relocate;
1626
1627 /* When generating a shared object, these relocations
1628 are copied into the output file to be resolved at run
1629 time. */
1630 if (sreloc == NULL)
1631 {
1632 const char *name;
1633
1634 name = (bfd_elf_string_from_elf_section
1635 (input_bfd,
1636 elf_elfheader (input_bfd)->e_shstrndx,
1637 elf_section_data (input_section)->rel_hdr.sh_name));
1638 if (name == NULL)
1639 return FALSE;
1640
1641 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1642 && strcmp (bfd_get_section_name (input_bfd,
1643 input_section),
1644 name + 5) == 0);
1645
1646 sreloc = bfd_get_section_by_name (dynobj, name);
1647 BFD_ASSERT (sreloc != NULL);
1648 }
1649
1650 skip = FALSE;
1651 relocate = FALSE;
1652
1653 outrel.r_offset =
1654 _bfd_elf_section_offset (output_bfd, info, input_section,
1655 rel->r_offset);
1656 if (outrel.r_offset == (bfd_vma) -1)
1657 skip = TRUE;
1658 if (outrel.r_offset == (bfd_vma) -2)
1659 skip = TRUE, relocate = TRUE;
1660 outrel.r_offset += (input_section->output_section->vma
1661 + input_section->output_offset);
1662
1663 if (skip)
1664 memset (&outrel, 0, sizeof outrel);
1665 /* h->dynindx may be -1 if the symbol was marked to
1666 become local. */
1667 else if (h != NULL
1668 && ((! info->symbolic && h->dynindx != -1)
1669 || !h->def_regular))
1670 {
1671 BFD_ASSERT (h->dynindx != -1);
1672 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1673 outrel.r_addend = relocation + rel->r_addend;
1674 }
1675 else
1676 {
1677 if (r_type == R_VAX_32)
1678 {
1679 relocate = TRUE;
1680 outrel.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1681 BFD_ASSERT (bfd_get_signed_32 (input_bfd,
1682 &contents[rel->r_offset]) == 0);
1683 outrel.r_addend = relocation + rel->r_addend;
1684 }
1685 else
1686 {
1687 long indx;
1688
1689 if (bfd_is_abs_section (sec))
1690 indx = 0;
1691 else if (sec == NULL || sec->owner == NULL)
1692 {
1693 bfd_set_error (bfd_error_bad_value);
1694 return FALSE;
1695 }
1696 else
1697 {
1698 asection *osec;
1699
1700 osec = sec->output_section;
1701 indx = elf_section_data (osec)->dynindx;
1702 BFD_ASSERT (indx > 0);
1703 }
1704
1705 outrel.r_info = ELF32_R_INFO (indx, r_type);
1706 outrel.r_addend = relocation + rel->r_addend;
1707 }
1708 }
1709
1710 if (!strcmp (bfd_get_section_name (input_bfd, input_section),
1711 ".text") != 0 ||
1712 (info->shared
1713 && ELF32_R_TYPE(outrel.r_info) != R_VAX_32
1714 && ELF32_R_TYPE(outrel.r_info) != R_VAX_RELATIVE
1715 && ELF32_R_TYPE(outrel.r_info) != R_VAX_COPY
1716 && ELF32_R_TYPE(outrel.r_info) != R_VAX_JMP_SLOT
1717 && ELF32_R_TYPE(outrel.r_info) != R_VAX_GLOB_DAT))
1718 {
1719 if (h != NULL)
1720 (*_bfd_error_handler)
1721 (_("%s: warning: %s relocation against symbol `%s' from %s section"),
1722 bfd_get_filename (input_bfd), howto->name,
1723 h->root.root.string,
1724 bfd_get_section_name (input_bfd, input_section));
1725 else
1726 (*_bfd_error_handler)
1727 (_("%s: warning: %s relocation to 0x%x from %s section"),
1728 bfd_get_filename (input_bfd), howto->name,
1729 outrel.r_addend,
1730 bfd_get_section_name (input_bfd, input_section));
1731 }
1732 loc = sreloc->contents;
1733 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1734 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1735
1736 /* This reloc will be computed at runtime, so there's no
1737 need to do anything now, except for R_VAX_32
1738 relocations that have been turned into
1739 R_VAX_RELATIVE. */
1740 if (!relocate)
1741 continue;
1742 }
1743
1744 break;
1745
1746 case R_VAX_GNU_VTINHERIT:
1747 case R_VAX_GNU_VTENTRY:
1748 /* These are no-ops in the end. */
1749 continue;
1750
1751 default:
1752 break;
1753 }
1754
1755 /* VAX PCREL relocations are from the end of relocation, not the start.
1756 So subtract the difference from the relocation amount since we can't
1757 add it to the offset. */
1758 if (howto->pc_relative && howto->pcrel_offset)
1759 relocation -= bfd_get_reloc_size(howto);
1760
1761 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1762 contents, rel->r_offset,
1763 relocation, rel->r_addend);
1764
1765 if (r != bfd_reloc_ok)
1766 {
1767 switch (r)
1768 {
1769 default:
1770 case bfd_reloc_outofrange:
1771 abort ();
1772 case bfd_reloc_overflow:
1773 {
1774 const char *name;
1775
1776 if (h != NULL)
1777 name = NULL;
1778 else
1779 {
1780 name = bfd_elf_string_from_elf_section (input_bfd,
1781 symtab_hdr->sh_link,
1782 sym->st_name);
1783 if (name == NULL)
1784 return FALSE;
1785 if (*name == '\0')
1786 name = bfd_section_name (input_bfd, sec);
1787 }
1788 if (!(info->callbacks->reloc_overflow
1789 (info, (h ? &h->root : NULL), name, howto->name,
1790 (bfd_vma) 0, input_bfd, input_section,
1791 rel->r_offset)))
1792 return FALSE;
1793 }
1794 break;
1795 }
1796 }
1797 }
1798
1799 return TRUE;
1800 }
1801
1802 /* Finish up dynamic symbol handling. We set the contents of various
1803 dynamic sections here. */
1804
1805 static bfd_boolean
1806 elf_vax_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
1807 struct elf_link_hash_entry *h,
1808 Elf_Internal_Sym *sym)
1809 {
1810 bfd *dynobj;
1811
1812 dynobj = elf_hash_table (info)->dynobj;
1813
1814 if (h->plt.offset != (bfd_vma) -1)
1815 {
1816 asection *splt;
1817 asection *sgot;
1818 asection *srela;
1819 bfd_vma plt_index;
1820 bfd_vma got_offset;
1821 bfd_vma addend;
1822 Elf_Internal_Rela rela;
1823 bfd_byte *loc;
1824
1825 /* This symbol has an entry in the procedure linkage table. Set
1826 it up. */
1827 BFD_ASSERT (h->dynindx != -1);
1828
1829 splt = bfd_get_section_by_name (dynobj, ".plt");
1830 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1831 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1832 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1833
1834 addend = 2 * (h->plt.offset & 1);
1835 h->plt.offset &= ~1;
1836
1837 /* Get the index in the procedure linkage table which
1838 corresponds to this symbol. This is the index of this symbol
1839 in all the symbols for which we are making plt entries. The
1840 first entry in the procedure linkage table is reserved. */
1841 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1842
1843 /* Get the offset into the .got table of the entry that
1844 corresponds to this function. Each .got entry is 4 bytes.
1845 The first two are reserved. */
1846 got_offset = (plt_index + 3) * 4;
1847
1848 /* Fill in the entry in the procedure linkage table. */
1849 memcpy (splt->contents + h->plt.offset, elf_vax_plt_entry,
1850 PLT_ENTRY_SIZE);
1851
1852 /* The offset is relative to the first extension word. */
1853 bfd_put_32 (output_bfd,
1854 -(h->plt.offset + 8),
1855 splt->contents + h->plt.offset + 4);
1856
1857 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1858 splt->contents + h->plt.offset + 8);
1859
1860 /* Fill in the entry in the global offset table. */
1861 bfd_put_32 (output_bfd,
1862 (splt->output_section->vma
1863 + splt->output_offset
1864 + h->plt.offset) + addend,
1865 sgot->contents + got_offset);
1866
1867 /* Fill in the entry in the .rela.plt section. */
1868 rela.r_offset = (sgot->output_section->vma
1869 + sgot->output_offset
1870 + got_offset);
1871 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_JMP_SLOT);
1872 rela.r_addend = addend;
1873 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1874 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1875
1876 if (!h->def_regular)
1877 {
1878 /* Mark the symbol as undefined, rather than as defined in
1879 the .plt section. Leave the value alone. */
1880 sym->st_shndx = SHN_UNDEF;
1881 }
1882 }
1883
1884 if (h->got.offset != (bfd_vma) -1)
1885 {
1886 asection *sgot;
1887 asection *srela;
1888 Elf_Internal_Rela rela;
1889 bfd_byte *loc;
1890
1891 /* This symbol has an entry in the global offset table. Set it
1892 up. */
1893 sgot = bfd_get_section_by_name (dynobj, ".got");
1894 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1895 BFD_ASSERT (sgot != NULL && srela != NULL);
1896
1897 rela.r_offset = (sgot->output_section->vma
1898 + sgot->output_offset
1899 + (h->got.offset &~ 1));
1900
1901 /* If the symbol was forced to be local because of a version file
1902 locally we just want to emit a RELATIVE reloc. The entry in
1903 the global offset table will already have been initialized in
1904 the relocate_section function. */
1905 if (info->shared
1906 && h->dynindx == -1
1907 && h->def_regular)
1908 {
1909 rela.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1910 }
1911 else
1912 {
1913 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_GLOB_DAT);
1914 }
1915 rela.r_addend = bfd_get_signed_32 (output_bfd,
1916 (sgot->contents
1917 + (h->got.offset & ~1)));
1918
1919 loc = srela->contents;
1920 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1921 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1922 }
1923
1924 if (h->needs_copy)
1925 {
1926 asection *s;
1927 Elf_Internal_Rela rela;
1928 bfd_byte *loc;
1929
1930 /* This symbol needs a copy reloc. Set it up. */
1931 BFD_ASSERT (h->dynindx != -1
1932 && (h->root.type == bfd_link_hash_defined
1933 || h->root.type == bfd_link_hash_defweak));
1934
1935 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1936 ".rela.bss");
1937 BFD_ASSERT (s != NULL);
1938
1939 rela.r_offset = (h->root.u.def.value
1940 + h->root.u.def.section->output_section->vma
1941 + h->root.u.def.section->output_offset);
1942 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_COPY);
1943 rela.r_addend = 0;
1944 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1945 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1946 }
1947
1948 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1949 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1950 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1951 sym->st_shndx = SHN_ABS;
1952
1953 return TRUE;
1954 }
1955
1956 /* Finish up the dynamic sections. */
1957
1958 static bfd_boolean
1959 elf_vax_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1960 {
1961 bfd *dynobj;
1962 asection *sgot;
1963 asection *sdyn;
1964
1965 dynobj = elf_hash_table (info)->dynobj;
1966
1967 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1968 BFD_ASSERT (sgot != NULL);
1969 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1970
1971 if (elf_hash_table (info)->dynamic_sections_created)
1972 {
1973 asection *splt;
1974 Elf32_External_Dyn *dyncon, *dynconend;
1975
1976 splt = bfd_get_section_by_name (dynobj, ".plt");
1977 BFD_ASSERT (splt != NULL && sdyn != NULL);
1978
1979 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1980 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1981 for (; dyncon < dynconend; dyncon++)
1982 {
1983 Elf_Internal_Dyn dyn;
1984 const char *name;
1985 asection *s;
1986
1987 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1988
1989 switch (dyn.d_tag)
1990 {
1991 default:
1992 break;
1993
1994 case DT_PLTGOT:
1995 name = ".got";
1996 goto get_vma;
1997 case DT_JMPREL:
1998 name = ".rela.plt";
1999 get_vma:
2000 s = bfd_get_section_by_name (output_bfd, name);
2001 BFD_ASSERT (s != NULL);
2002 dyn.d_un.d_ptr = s->vma;
2003 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2004 break;
2005
2006 case DT_PLTRELSZ:
2007 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2008 BFD_ASSERT (s != NULL);
2009 dyn.d_un.d_val = s->size;
2010 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2011 break;
2012
2013 case DT_RELASZ:
2014 /* The procedure linkage table relocs (DT_JMPREL) should
2015 not be included in the overall relocs (DT_RELA).
2016 Therefore, we override the DT_RELASZ entry here to
2017 make it not include the JMPREL relocs. Since the
2018 linker script arranges for .rela.plt to follow all
2019 other relocation sections, we don't have to worry
2020 about changing the DT_RELA entry. */
2021 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2022 if (s != NULL)
2023 dyn.d_un.d_val -= s->size;
2024 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2025 break;
2026 }
2027 }
2028
2029 /* Fill in the first entry in the procedure linkage table. */
2030 if (splt->size > 0)
2031 {
2032 memcpy (splt->contents, elf_vax_plt0_entry, PLT_ENTRY_SIZE);
2033 bfd_put_32 (output_bfd,
2034 (sgot->output_section->vma
2035 + sgot->output_offset + 4
2036 - (splt->output_section->vma + 6)),
2037 splt->contents + 2);
2038 bfd_put_32 (output_bfd,
2039 (sgot->output_section->vma
2040 + sgot->output_offset + 8
2041 - (splt->output_section->vma + 12)),
2042 splt->contents + 8);
2043 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2044 = PLT_ENTRY_SIZE;
2045 }
2046 }
2047
2048 /* Fill in the first three entries in the global offset table. */
2049 if (sgot->size > 0)
2050 {
2051 if (sdyn == NULL)
2052 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2053 else
2054 bfd_put_32 (output_bfd,
2055 sdyn->output_section->vma + sdyn->output_offset,
2056 sgot->contents);
2057 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2058 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2059 }
2060
2061 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2062
2063 return TRUE;
2064 }
2065
2066 #define TARGET_LITTLE_SYM bfd_elf32_vax_vec
2067 #define TARGET_LITTLE_NAME "elf32-vax"
2068 #define ELF_MACHINE_CODE EM_VAX
2069 #define ELF_MAXPAGESIZE 0x1000
2070
2071 #define elf_backend_create_dynamic_sections \
2072 _bfd_elf_create_dynamic_sections
2073 #define bfd_elf32_bfd_link_hash_table_create \
2074 elf_vax_link_hash_table_create
2075 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2076
2077 #define elf_backend_check_relocs elf_vax_check_relocs
2078 #define elf_backend_adjust_dynamic_symbol \
2079 elf_vax_adjust_dynamic_symbol
2080 #define elf_backend_size_dynamic_sections \
2081 elf_vax_size_dynamic_sections
2082 #define elf_backend_relocate_section elf_vax_relocate_section
2083 #define elf_backend_finish_dynamic_symbol \
2084 elf_vax_finish_dynamic_symbol
2085 #define elf_backend_finish_dynamic_sections \
2086 elf_vax_finish_dynamic_sections
2087 #define elf_backend_gc_mark_hook elf_vax_gc_mark_hook
2088 #define elf_backend_gc_sweep_hook elf_vax_gc_sweep_hook
2089 #define bfd_elf32_bfd_merge_private_bfd_data \
2090 elf32_vax_merge_private_bfd_data
2091 #define bfd_elf32_bfd_set_private_flags \
2092 elf32_vax_set_private_flags
2093 #define bfd_elf32_bfd_print_private_bfd_data \
2094 elf32_vax_print_private_bfd_data
2095
2096 #define elf_backend_can_gc_sections 1
2097 #define elf_backend_want_got_plt 1
2098 #define elf_backend_plt_readonly 1
2099 #define elf_backend_want_plt_sym 0
2100 #define elf_backend_got_header_size 16
2101 #define elf_backend_rela_normal 1
2102
2103 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.069897 seconds and 3 git commands to generate.