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