projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add c-format tags to translatable strings with more than one argument-using formattin...
[deliverable/binutils-gdb.git] / bfd / elf32-vax.c
1 /* VAX series support for 32-bit ELF
2 Copyright (C) 1993-2016 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 *sgot;
565 asection *srelgot;
566 asection *sreloc;
567
568 if (bfd_link_relocatable (info))
569 return TRUE;
570
571 dynobj = elf_hash_table (info)->dynobj;
572 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
573 sym_hashes = elf_sym_hashes (abfd);
574
575 sgot = NULL;
576 srelgot = NULL;
577 sreloc = NULL;
578
579 rel_end = relocs + sec->reloc_count;
580 for (rel = relocs; rel < rel_end; rel++)
581 {
582 unsigned long r_symndx;
583 struct elf_link_hash_entry *h;
584
585 r_symndx = ELF32_R_SYM (rel->r_info);
586
587 if (r_symndx < symtab_hdr->sh_info)
588 h = NULL;
589 else
590 {
591 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
592 while (h->root.type == bfd_link_hash_indirect
593 || h->root.type == bfd_link_hash_warning)
594 h = (struct elf_link_hash_entry *) h->root.u.i.link;
595
596 /* PR15323, ref flags aren't set for references in the same
597 object. */
598 h->root.non_ir_ref = 1;
599 }
600
601 switch (ELF32_R_TYPE (rel->r_info))
602 {
603 case R_VAX_GOT32:
604 BFD_ASSERT (h != NULL);
605
606 /* If this is a local symbol, we resolve it directly without
607 creating a global offset table entry. */
608 if (h->forced_local
609 || h == elf_hash_table (info)->hgot
610 || h == elf_hash_table (info)->hplt)
611 break;
612
613 /* This symbol requires a global offset table entry. */
614
615 if (dynobj == NULL)
616 {
617 /* Create the .got section. */
618 elf_hash_table (info)->dynobj = dynobj = abfd;
619 if (!_bfd_elf_create_got_section (dynobj, info))
620 return FALSE;
621 }
622
623 if (sgot == NULL)
624 {
625 sgot = bfd_get_linker_section (dynobj, ".got");
626 BFD_ASSERT (sgot != NULL);
627 }
628
629 if (srelgot == NULL
630 && (h != NULL || bfd_link_pic (info)))
631 {
632 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
633 if (srelgot == NULL)
634 {
635 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
636 | SEC_IN_MEMORY | SEC_LINKER_CREATED
637 | SEC_READONLY);
638
639 srelgot = bfd_make_section_anyway_with_flags (dynobj,
640 ".rela.got",
641 flags);
642 if (srelgot == NULL
643 || !bfd_set_section_alignment (dynobj, srelgot, 2))
644 return FALSE;
645 }
646 }
647
648 if (h != NULL)
649 {
650 struct elf_vax_link_hash_entry *eh;
651
652 eh = (struct elf_vax_link_hash_entry *) h;
653 if (h->got.refcount == -1)
654 {
655 h->got.refcount = 1;
656 eh->got_addend = rel->r_addend;
657 }
658 else
659 {
660 h->got.refcount++;
661 if (eh->got_addend != (bfd_vma) rel->r_addend)
662 _bfd_error_handler
663 /* xgettext:c-format */
664 (_("%s: warning: GOT addend of %ld to `%s' does"
665 " not match previous GOT addend of %ld"),
666 bfd_get_filename (abfd), rel->r_addend,
667 h->root.root.string,
668 eh->got_addend);
669
670 }
671 }
672 break;
673
674 case R_VAX_PLT32:
675 /* This symbol requires a procedure linkage table entry. We
676 actually build the entry in adjust_dynamic_symbol,
677 because this might be a case of linking PIC code which is
678 never referenced by a dynamic object, in which case we
679 don't need to generate a procedure linkage table entry
680 after all. */
681 BFD_ASSERT (h != NULL);
682
683 /* If this is a local symbol, we resolve it directly without
684 creating a procedure linkage table entry. */
685 if (h->forced_local)
686 break;
687
688 h->needs_plt = 1;
689 if (h->plt.refcount == -1)
690 h->plt.refcount = 1;
691 else
692 h->plt.refcount++;
693 break;
694
695 case R_VAX_PC8:
696 case R_VAX_PC16:
697 case R_VAX_PC32:
698 /* If we are creating a shared library and this is not a local
699 symbol, we need to copy the reloc into the shared library.
700 However when linking with -Bsymbolic and this is a global
701 symbol which is defined in an object we are including in the
702 link (i.e., DEF_REGULAR is set), then we can resolve the
703 reloc directly. At this point we have not seen all the input
704 files, so it is possible that DEF_REGULAR is not set now but
705 will be set later (it is never cleared). We account for that
706 possibility below by storing information in the
707 pcrel_relocs_copied field of the hash table entry. */
708 if (!(bfd_link_pic (info)
709 && (sec->flags & SEC_ALLOC) != 0
710 && h != NULL
711 && (!info->symbolic
712 || !h->def_regular)))
713 {
714 if (h != NULL
715 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
716 && !h->forced_local)
717 {
718 /* Make sure a plt entry is created for this symbol if
719 it turns out to be a function defined by a dynamic
720 object. */
721 if (h->plt.refcount == -1)
722 h->plt.refcount = 1;
723 else
724 h->plt.refcount++;
725 }
726 break;
727 }
728 /* If this is a local symbol, we can resolve it directly. */
729 if (h != NULL
730 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
731 || h->forced_local))
732 break;
733
734 /* Fall through. */
735 case R_VAX_8:
736 case R_VAX_16:
737 case R_VAX_32:
738 if (h != NULL && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
739 {
740 /* Make sure a plt entry is created for this symbol if it
741 turns out to be a function defined by a dynamic object. */
742 if (h->plt.refcount == -1)
743 h->plt.refcount = 1;
744 else
745 h->plt.refcount++;
746 }
747
748 /* If we are creating a shared library, we need to copy the
749 reloc into the shared library. */
750 if (bfd_link_pic (info)
751 && (sec->flags & SEC_ALLOC) != 0)
752 {
753 /* When creating a shared object, we must copy these
754 reloc types into the output file. We create a reloc
755 section in dynobj and make room for this reloc. */
756 if (sreloc == NULL)
757 {
758 sreloc = _bfd_elf_make_dynamic_reloc_section
759 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
760
761 if (sreloc == NULL)
762 return FALSE;
763
764 if (sec->flags & SEC_READONLY)
765 info->flags |= DF_TEXTREL;
766 }
767
768 sreloc->size += sizeof (Elf32_External_Rela);
769
770 /* If we are linking with -Bsymbolic, we count the number of
771 PC relative relocations we have entered for this symbol,
772 so that we can discard them again if the symbol is later
773 defined by a regular object. Note that this function is
774 only called if we are using a vaxelf linker hash table,
775 which means that h is really a pointer to an
776 elf_vax_link_hash_entry. */
777 if ((ELF32_R_TYPE (rel->r_info) == R_VAX_PC8
778 || ELF32_R_TYPE (rel->r_info) == R_VAX_PC16
779 || ELF32_R_TYPE (rel->r_info) == R_VAX_PC32)
780 && info->symbolic)
781 {
782 struct elf_vax_link_hash_entry *eh;
783 struct elf_vax_pcrel_relocs_copied *p;
784
785 eh = (struct elf_vax_link_hash_entry *) h;
786
787 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
788 if (p->section == sreloc)
789 break;
790
791 if (p == NULL)
792 {
793 p = ((struct elf_vax_pcrel_relocs_copied *)
794 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
795 if (p == NULL)
796 return FALSE;
797 p->next = eh->pcrel_relocs_copied;
798 eh->pcrel_relocs_copied = p;
799 p->section = sreloc;
800 p->count = 0;
801 }
802
803 ++p->count;
804 }
805 }
806
807 break;
808
809 /* This relocation describes the C++ object vtable hierarchy.
810 Reconstruct it for later use during GC. */
811 case R_VAX_GNU_VTINHERIT:
812 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
813 return FALSE;
814 break;
815
816 /* This relocation describes which C++ vtable entries are actually
817 used. Record for later use during GC. */
818 case R_VAX_GNU_VTENTRY:
819 BFD_ASSERT (h != NULL);
820 if (h != NULL
821 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
822 return FALSE;
823 break;
824
825 default:
826 break;
827 }
828 }
829
830 return TRUE;
831 }
832
833 /* Return the section that should be marked against GC for a given
834 relocation. */
835
836 static asection *
837 elf_vax_gc_mark_hook (asection *sec,
838 struct bfd_link_info *info,
839 Elf_Internal_Rela *rel,
840 struct elf_link_hash_entry *h,
841 Elf_Internal_Sym *sym)
842 {
843 if (h != NULL)
844 switch (ELF32_R_TYPE (rel->r_info))
845 {
846 case R_VAX_GNU_VTINHERIT:
847 case R_VAX_GNU_VTENTRY:
848 return NULL;
849 }
850
851 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
852 }
853
854 /* Update the got entry reference counts for the section being removed. */
855
856 static bfd_boolean
857 elf_vax_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
858 const Elf_Internal_Rela *relocs)
859 {
860 Elf_Internal_Shdr *symtab_hdr;
861 struct elf_link_hash_entry **sym_hashes;
862 const Elf_Internal_Rela *rel, *relend;
863 bfd *dynobj;
864
865 if (bfd_link_relocatable (info))
866 return TRUE;
867
868 dynobj = elf_hash_table (info)->dynobj;
869 if (dynobj == NULL)
870 return TRUE;
871
872 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
873 sym_hashes = elf_sym_hashes (abfd);
874
875 relend = relocs + sec->reloc_count;
876 for (rel = relocs; rel < relend; rel++)
877 {
878 unsigned long r_symndx;
879 struct elf_link_hash_entry *h = NULL;
880
881 r_symndx = ELF32_R_SYM (rel->r_info);
882 if (r_symndx >= symtab_hdr->sh_info)
883 {
884 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
885 while (h->root.type == bfd_link_hash_indirect
886 || h->root.type == bfd_link_hash_warning)
887 h = (struct elf_link_hash_entry *) h->root.u.i.link;
888 }
889
890 switch (ELF32_R_TYPE (rel->r_info))
891 {
892 case R_VAX_GOT32:
893 if (h != NULL && h->got.refcount > 0)
894 --h->got.refcount;
895 break;
896
897 case R_VAX_PLT32:
898 case R_VAX_PC8:
899 case R_VAX_PC16:
900 case R_VAX_PC32:
901 case R_VAX_8:
902 case R_VAX_16:
903 case R_VAX_32:
904 if (h != NULL && h->plt.refcount > 0)
905 --h->plt.refcount;
906 break;
907
908 default:
909 break;
910 }
911 }
912
913 return TRUE;
914 }
915
916 /* Adjust a symbol defined by a dynamic object and referenced by a
917 regular object. The current definition is in some section of the
918 dynamic object, but we're not including those sections. We have to
919 change the definition to something the rest of the link can
920 understand. */
921
922 static bfd_boolean
923 elf_vax_adjust_dynamic_symbol (struct bfd_link_info *info,
924 struct elf_link_hash_entry *h)
925 {
926 bfd *dynobj;
927 asection *s;
928
929 dynobj = elf_hash_table (info)->dynobj;
930
931 /* Make sure we know what is going on here. */
932 BFD_ASSERT (dynobj != NULL
933 && (h->needs_plt
934 || h->u.weakdef != NULL
935 || (h->def_dynamic
936 && h->ref_regular
937 && !h->def_regular)));
938
939 /* If this is a function, put it in the procedure linkage table. We
940 will fill in the contents of the procedure linkage table later,
941 when we know the address of the .got section. */
942 if (h->type == STT_FUNC
943 || h->needs_plt)
944 {
945 if (h->plt.refcount <= 0
946 || SYMBOL_CALLS_LOCAL (info, h)
947 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
948 && h->root.type == bfd_link_hash_undefweak))
949 {
950 /* This case can occur if we saw a PLTxx reloc in an input
951 file, but the symbol was never referred to by a dynamic
952 object, or if all references were garbage collected. In
953 such a case, we don't actually need to build a procedure
954 linkage table, and we can just do a PCxx reloc instead. */
955 h->plt.offset = (bfd_vma) -1;
956 h->needs_plt = 0;
957 return TRUE;
958 }
959
960 s = bfd_get_linker_section (dynobj, ".plt");
961 BFD_ASSERT (s != NULL);
962
963 /* If this is the first .plt entry, make room for the special
964 first entry. */
965 if (s->size == 0)
966 {
967 s->size += PLT_ENTRY_SIZE;
968 }
969
970 /* If this symbol is not defined in a regular file, and we are
971 not generating a shared library, then set the symbol to this
972 location in the .plt. This is required to make function
973 pointers compare as equal between the normal executable and
974 the shared library. */
975 if (!bfd_link_pic (info)
976 && !h->def_regular)
977 {
978 h->root.u.def.section = s;
979 h->root.u.def.value = s->size;
980 }
981
982 h->plt.offset = s->size;
983
984 /* Make room for this entry. */
985 s->size += PLT_ENTRY_SIZE;
986
987 /* We also need to make an entry in the .got.plt section, which
988 will be placed in the .got section by the linker script. */
989
990 s = bfd_get_linker_section (dynobj, ".got.plt");
991 BFD_ASSERT (s != NULL);
992 s->size += 4;
993
994 /* We also need to make an entry in the .rela.plt section. */
995
996 s = bfd_get_linker_section (dynobj, ".rela.plt");
997 BFD_ASSERT (s != NULL);
998 s->size += sizeof (Elf32_External_Rela);
999
1000 return TRUE;
1001 }
1002
1003 /* Reinitialize the plt offset now that it is not used as a reference
1004 count any more. */
1005 h->plt.offset = (bfd_vma) -1;
1006
1007 /* If this is a weak symbol, and there is a real definition, the
1008 processor independent code will have arranged for us to see the
1009 real definition first, and we can just use the same value. */
1010 if (h->u.weakdef != NULL)
1011 {
1012 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1013 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1014 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1015 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1016 return TRUE;
1017 }
1018
1019 /* This is a reference to a symbol defined by a dynamic object which
1020 is not a function. */
1021
1022 /* If we are creating a shared library, we must presume that the
1023 only references to the symbol are via the global offset table.
1024 For such cases we need not do anything here; the relocations will
1025 be handled correctly by relocate_section. */
1026 if (bfd_link_pic (info))
1027 return TRUE;
1028
1029 /* We must allocate the symbol in our .dynbss section, which will
1030 become part of the .bss section of the executable. There will be
1031 an entry for this symbol in the .dynsym section. The dynamic
1032 object will contain position independent code, so all references
1033 from the dynamic object to this symbol will go through the global
1034 offset table. The dynamic linker will use the .dynsym entry to
1035 determine the address it must put in the global offset table, so
1036 both the dynamic object and the regular object will refer to the
1037 same memory location for the variable. */
1038
1039 s = bfd_get_linker_section (dynobj, ".dynbss");
1040 BFD_ASSERT (s != NULL);
1041
1042 /* We must generate a R_VAX_COPY reloc to tell the dynamic linker to
1043 copy the initial value out of the dynamic object and into the
1044 runtime process image. We need to remember the offset into the
1045 .rela.bss section we are going to use. */
1046 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1047 {
1048 asection *srel;
1049
1050 srel = bfd_get_linker_section (dynobj, ".rela.bss");
1051 BFD_ASSERT (srel != NULL);
1052 srel->size += sizeof (Elf32_External_Rela);
1053 h->needs_copy = 1;
1054 }
1055
1056 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1057 }
1058
1059 /* This function is called via elf_link_hash_traverse. It resets GOT
1060 and PLT (.GOT) reference counts back to -1 so normal PC32 relocation
1061 will be done. */
1062
1063 static bfd_boolean
1064 elf_vax_discard_got_entries (struct elf_link_hash_entry *h,
1065 void *infoptr ATTRIBUTE_UNUSED)
1066 {
1067 h->got.refcount = -1;
1068 h->plt.refcount = -1;
1069
1070 return TRUE;
1071 }
1072
1073 /* Discard unused dynamic data if this is a static link. */
1074
1075 static bfd_boolean
1076 elf_vax_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1077 struct bfd_link_info *info)
1078 {
1079 bfd *dynobj;
1080 asection *s;
1081
1082 dynobj = elf_hash_table (info)->dynobj;
1083
1084 if (dynobj && !elf_hash_table (info)->dynamic_sections_created)
1085 {
1086 /* We may have created entries in the .rela.got and .got sections.
1087 However, if we are not creating the dynamic sections, we will
1088 not actually use these entries. Reset the size of .rela.got
1089 and .got, which will cause them to get stripped from the output
1090 file below. */
1091 s = bfd_get_linker_section (dynobj, ".rela.got");
1092 if (s != NULL)
1093 s->size = 0;
1094 s = bfd_get_linker_section (dynobj, ".got.plt");
1095 if (s != NULL)
1096 s->size = 0;
1097 s = bfd_get_linker_section (dynobj, ".got");
1098 if (s != NULL)
1099 s->size = 0;
1100 }
1101
1102 /* If this is a static link, we need to discard all the got entries we've
1103 recorded. */
1104 if (!dynobj || !elf_hash_table (info)->dynamic_sections_created)
1105 elf_link_hash_traverse (elf_hash_table (info),
1106 elf_vax_discard_got_entries,
1107 info);
1108
1109 return TRUE;
1110 }
1111
1112 /* Set the sizes of the dynamic sections. */
1113
1114 static bfd_boolean
1115 elf_vax_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1116 {
1117 bfd *dynobj;
1118 asection *s;
1119 bfd_boolean plt;
1120 bfd_boolean relocs;
1121 bfd_boolean reltext;
1122
1123 dynobj = elf_hash_table (info)->dynobj;
1124 BFD_ASSERT (dynobj != NULL);
1125
1126 if (elf_hash_table (info)->dynamic_sections_created)
1127 {
1128 /* Set the contents of the .interp section to the interpreter. */
1129 if (bfd_link_executable (info) && !info->nointerp)
1130 {
1131 s = bfd_get_linker_section (dynobj, ".interp");
1132 BFD_ASSERT (s != NULL);
1133 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1134 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1135 }
1136 }
1137
1138 /* If this is a -Bsymbolic shared link, then we need to discard all PC
1139 relative relocs against symbols defined in a regular object. We
1140 allocated space for them in the check_relocs routine, but we will not
1141 fill them in in the relocate_section routine. */
1142 if (bfd_link_pic (info) && info->symbolic)
1143 elf_vax_link_hash_traverse (elf_hash_table (info),
1144 elf_vax_discard_copies,
1145 NULL);
1146
1147 /* If this is a -Bsymbolic shared link, we need to discard all the got
1148 entries we've recorded. Otherwise, we need to instantiate (allocate
1149 space for them). */
1150 elf_link_hash_traverse (elf_hash_table (info),
1151 elf_vax_instantiate_got_entries,
1152 info);
1153
1154 /* The check_relocs and adjust_dynamic_symbol entry points have
1155 determined the sizes of the various dynamic sections. Allocate
1156 memory for them. */
1157 plt = FALSE;
1158 relocs = FALSE;
1159 reltext = FALSE;
1160 for (s = dynobj->sections; s != NULL; s = s->next)
1161 {
1162 const char *name;
1163
1164 if ((s->flags & SEC_LINKER_CREATED) == 0)
1165 continue;
1166
1167 /* It's OK to base decisions on the section name, because none
1168 of the dynobj section names depend upon the input files. */
1169 name = bfd_get_section_name (dynobj, s);
1170
1171 if (strcmp (name, ".plt") == 0)
1172 {
1173 /* Remember whether there is a PLT. */
1174 plt = s->size != 0;
1175 }
1176 else if (CONST_STRNEQ (name, ".rela"))
1177 {
1178 if (s->size != 0)
1179 {
1180 asection *target;
1181
1182 /* Remember whether there are any reloc sections other
1183 than .rela.plt. */
1184 if (strcmp (name, ".rela.plt") != 0)
1185 {
1186 const char *outname;
1187
1188 relocs = TRUE;
1189
1190 /* If this relocation section applies to a read only
1191 section, then we probably need a DT_TEXTREL
1192 entry. .rela.plt is actually associated with
1193 .got.plt, which is never readonly. */
1194 outname = bfd_get_section_name (output_bfd,
1195 s->output_section);
1196 target = bfd_get_section_by_name (output_bfd, outname + 5);
1197 if (target != NULL
1198 && (target->flags & SEC_READONLY) != 0
1199 && (target->flags & SEC_ALLOC) != 0)
1200 reltext = TRUE;
1201 }
1202
1203 /* We use the reloc_count field as a counter if we need
1204 to copy relocs into the output file. */
1205 s->reloc_count = 0;
1206 }
1207 }
1208 else if (! CONST_STRNEQ (name, ".got")
1209 && strcmp (name, ".dynbss") != 0)
1210 {
1211 /* It's not one of our sections, so don't allocate space. */
1212 continue;
1213 }
1214
1215 if (s->size == 0)
1216 {
1217 /* If we don't need this section, strip it from the
1218 output file. This is mostly to handle .rela.bss and
1219 .rela.plt. We must create both sections in
1220 create_dynamic_sections, because they must be created
1221 before the linker maps input sections to output
1222 sections. The linker does that before
1223 adjust_dynamic_symbol is called, and it is that
1224 function which decides whether anything needs to go
1225 into these sections. */
1226 s->flags |= SEC_EXCLUDE;
1227 continue;
1228 }
1229
1230 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1231 continue;
1232
1233 /* Allocate memory for the section contents. */
1234 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1235 if (s->contents == NULL)
1236 return FALSE;
1237 }
1238
1239 if (elf_hash_table (info)->dynamic_sections_created)
1240 {
1241 /* Add some entries to the .dynamic section. We fill in the
1242 values later, in elf_vax_finish_dynamic_sections, but we
1243 must add the entries now so that we get the correct size for
1244 the .dynamic section. The DT_DEBUG entry is filled in by the
1245 dynamic linker and used by the debugger. */
1246 #define add_dynamic_entry(TAG, VAL) \
1247 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1248
1249 if (!bfd_link_pic (info))
1250 {
1251 if (!add_dynamic_entry (DT_DEBUG, 0))
1252 return FALSE;
1253 }
1254
1255 if (plt)
1256 {
1257 if (!add_dynamic_entry (DT_PLTGOT, 0)
1258 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1259 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1260 || !add_dynamic_entry (DT_JMPREL, 0))
1261 return FALSE;
1262 }
1263
1264 if (relocs)
1265 {
1266 if (!add_dynamic_entry (DT_RELA, 0)
1267 || !add_dynamic_entry (DT_RELASZ, 0)
1268 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1269 return FALSE;
1270 }
1271
1272 if (reltext || (info->flags & DF_TEXTREL) != 0)
1273 {
1274 if (!add_dynamic_entry (DT_TEXTREL, 0))
1275 return FALSE;
1276 }
1277 }
1278 #undef add_dynamic_entry
1279
1280 return TRUE;
1281 }
1282
1283 /* This function is called via elf_vax_link_hash_traverse if we are
1284 creating a shared object with -Bsymbolic. It discards the space
1285 allocated to copy PC relative relocs against symbols which are defined
1286 in regular objects. We allocated space for them in the check_relocs
1287 routine, but we won't fill them in in the relocate_section routine. */
1288
1289 static bfd_boolean
1290 elf_vax_discard_copies (struct elf_vax_link_hash_entry *h,
1291 void * ignore ATTRIBUTE_UNUSED)
1292 {
1293 struct elf_vax_pcrel_relocs_copied *s;
1294
1295 /* We only discard relocs for symbols defined in a regular object. */
1296 if (!h->root.def_regular)
1297 return TRUE;
1298
1299 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1300 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1301
1302 return TRUE;
1303 }
1304
1305 /* This function is called via elf_link_hash_traverse. It looks for
1306 entries that have GOT or PLT (.GOT) references. If creating a shared
1307 object with -Bsymbolic, or the symbol has been forced local, then it
1308 resets the reference count back to -1 so normal PC32 relocation will
1309 be done. Otherwise space in the .got and .rela.got will be reserved
1310 for the symbol. */
1311
1312 static bfd_boolean
1313 elf_vax_instantiate_got_entries (struct elf_link_hash_entry *h, void * infoptr)
1314 {
1315 struct bfd_link_info *info = (struct bfd_link_info *) infoptr;
1316 bfd *dynobj;
1317 asection *sgot;
1318 asection *srelgot;
1319
1320 /* We don't care about non-GOT (and non-PLT) entries. */
1321 if (h->got.refcount <= 0 && h->plt.refcount <= 0)
1322 return TRUE;
1323
1324 dynobj = elf_hash_table (info)->dynobj;
1325 BFD_ASSERT (dynobj != NULL);
1326
1327 sgot = bfd_get_linker_section (dynobj, ".got");
1328 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1329
1330 if (SYMBOL_REFERENCES_LOCAL (info, h))
1331 {
1332 h->got.refcount = -1;
1333 h->plt.refcount = -1;
1334 }
1335 else if (h->got.refcount > 0)
1336 {
1337 /* Make sure this symbol is output as a dynamic symbol. */
1338 if (h->dynindx == -1)
1339 {
1340 if (!bfd_elf_link_record_dynamic_symbol (info, h))
1341 return FALSE;
1342 }
1343
1344 /* Allocate space in the .got and .rela.got sections. */
1345 sgot->size += 4;
1346 srelgot->size += sizeof (Elf32_External_Rela);
1347 }
1348
1349 return TRUE;
1350 }
1351
1352 /* Relocate an VAX ELF section. */
1353
1354 static bfd_boolean
1355 elf_vax_relocate_section (bfd *output_bfd,
1356 struct bfd_link_info *info,
1357 bfd *input_bfd,
1358 asection *input_section,
1359 bfd_byte *contents,
1360 Elf_Internal_Rela *relocs,
1361 Elf_Internal_Sym *local_syms,
1362 asection **local_sections)
1363 {
1364 bfd *dynobj;
1365 Elf_Internal_Shdr *symtab_hdr;
1366 struct elf_link_hash_entry **sym_hashes;
1367 bfd_vma plt_index;
1368 bfd_vma got_offset;
1369 asection *sgot;
1370 asection *splt;
1371 asection *sgotplt;
1372 asection *sreloc;
1373 Elf_Internal_Rela *rel;
1374 Elf_Internal_Rela *relend;
1375
1376 dynobj = elf_hash_table (info)->dynobj;
1377 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1378 sym_hashes = elf_sym_hashes (input_bfd);
1379
1380 sgot = NULL;
1381 splt = NULL;
1382 sgotplt = NULL;
1383 sreloc = NULL;
1384
1385 rel = relocs;
1386 relend = relocs + input_section->reloc_count;
1387 for (; rel < relend; rel++)
1388 {
1389 int r_type;
1390 reloc_howto_type *howto;
1391 unsigned long r_symndx;
1392 struct elf_link_hash_entry *h;
1393 Elf_Internal_Sym *sym;
1394 asection *sec;
1395 bfd_vma relocation;
1396 bfd_reloc_status_type r;
1397
1398 r_type = ELF32_R_TYPE (rel->r_info);
1399 if (r_type < 0 || r_type >= (int) R_VAX_max)
1400 {
1401 bfd_set_error (bfd_error_bad_value);
1402 return FALSE;
1403 }
1404 howto = howto_table + r_type;
1405
1406 r_symndx = ELF32_R_SYM (rel->r_info);
1407 h = NULL;
1408 sym = NULL;
1409 sec = NULL;
1410 if (r_symndx < symtab_hdr->sh_info)
1411 {
1412 sym = local_syms + r_symndx;
1413 sec = local_sections[r_symndx];
1414 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1415 }
1416 else
1417 {
1418 bfd_boolean unresolved_reloc;
1419 bfd_boolean warned, ignored;
1420
1421 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1422 r_symndx, symtab_hdr, sym_hashes,
1423 h, sec, relocation,
1424 unresolved_reloc, warned, ignored);
1425
1426 if ((h->root.type == bfd_link_hash_defined
1427 || h->root.type == bfd_link_hash_defweak)
1428 && ((r_type == R_VAX_PLT32
1429 && h->plt.offset != (bfd_vma) -1
1430 && !h->forced_local
1431 && elf_hash_table (info)->dynamic_sections_created)
1432 || (r_type == R_VAX_GOT32
1433 && h->got.offset != (bfd_vma) -1
1434 && !h->forced_local
1435 && elf_hash_table (info)->dynamic_sections_created
1436 && (! bfd_link_pic (info)
1437 || (! info->symbolic && h->dynindx != -1)
1438 || !h->def_regular))
1439 || (bfd_link_pic (info)
1440 && ((! info->symbolic && h->dynindx != -1)
1441 || !h->def_regular)
1442 && ((input_section->flags & SEC_ALLOC) != 0
1443 /* DWARF will emit R_VAX_32 relocations in its
1444 sections against symbols defined externally
1445 in shared libraries. We can't do anything
1446 with them here. */
1447
1448 || ((input_section->flags & SEC_DEBUGGING) != 0
1449 && h->def_dynamic))
1450 && (r_type == R_VAX_8
1451 || r_type == R_VAX_16
1452 || r_type == R_VAX_32))))
1453 /* In these cases, we don't need the relocation
1454 value. We check specially because in some
1455 obscure cases sec->output_section will be NULL. */
1456 relocation = 0;
1457 }
1458
1459 if (sec != NULL && discarded_section (sec))
1460 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1461 rel, 1, relend, howto, 0, contents);
1462
1463 if (bfd_link_relocatable (info))
1464 continue;
1465
1466 switch (r_type)
1467 {
1468 case R_VAX_GOT32:
1469 /* Relocation is to the address of the entry for this symbol
1470 in the global offset table. */
1471
1472 /* Resolve a GOTxx reloc against a local symbol directly,
1473 without using the global offset table. */
1474 if (h == NULL
1475 || h->got.offset == (bfd_vma) -1)
1476 break;
1477
1478 {
1479 bfd_vma off;
1480
1481 if (sgot == NULL)
1482 {
1483 sgot = bfd_get_linker_section (dynobj, ".got");
1484 BFD_ASSERT (sgot != NULL);
1485 }
1486
1487 off = h->got.offset;
1488 BFD_ASSERT (off < sgot->size);
1489
1490 bfd_put_32 (output_bfd, rel->r_addend, sgot->contents + off);
1491
1492 relocation = sgot->output_offset + off;
1493 /* The GOT relocation uses the addend. */
1494 rel->r_addend = 0;
1495
1496 /* Change the reference to be indirect. */
1497 contents[rel->r_offset - 1] |= 0x10;
1498 relocation += sgot->output_section->vma;
1499 }
1500 break;
1501
1502 case R_VAX_PC32:
1503 /* If we are creating an executable and the function this
1504 reloc refers to is in a shared lib, then we made a PLT
1505 entry for this symbol and need to handle the reloc like
1506 a PLT reloc. */
1507 if (bfd_link_pic (info))
1508 goto r_vax_pc32_shared;
1509 /* Fall through. */
1510 case R_VAX_PLT32:
1511 /* Relocation is to the entry for this symbol in the
1512 procedure linkage table. */
1513
1514 /* Resolve a PLTxx reloc against a local symbol directly,
1515 without using the procedure linkage table. */
1516 if (h == NULL
1517 || h->plt.offset == (bfd_vma) -1)
1518 break;
1519
1520 if (splt == NULL)
1521 {
1522 splt = bfd_get_linker_section (dynobj, ".plt");
1523 BFD_ASSERT (splt != NULL);
1524 }
1525
1526 if (sgotplt == NULL)
1527 {
1528 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1529 BFD_ASSERT (sgotplt != NULL);
1530 }
1531
1532 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1533
1534 /* Get the offset into the .got table of the entry that
1535 corresponds to this function. Each .got entry is 4 bytes.
1536 The first two are reserved. */
1537 got_offset = (plt_index + 3) * 4;
1538
1539 /* We want the relocation to point into the .got.plt instead
1540 of the plt itself. */
1541 relocation = (sgotplt->output_section->vma
1542 + sgotplt->output_offset
1543 + got_offset);
1544 contents[rel->r_offset-1] |= 0x10; /* make indirect */
1545 if (rel->r_addend == 2)
1546 {
1547 h->plt.offset |= 1;
1548 }
1549 else if (rel->r_addend != 0)
1550 _bfd_error_handler
1551 /* xgettext:c-format */
1552 (_("%s: warning: PLT addend of %d to `%s' from %s section ignored"),
1553 bfd_get_filename (input_bfd), rel->r_addend,
1554 h->root.root.string,
1555 bfd_get_section_name (input_bfd, input_section));
1556 rel->r_addend = 0;
1557
1558 break;
1559
1560 case R_VAX_PC8:
1561 case R_VAX_PC16:
1562 r_vax_pc32_shared:
1563 if (h == NULL
1564 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1565 || h->forced_local)
1566 break;
1567 /* Fall through. */
1568 case R_VAX_8:
1569 case R_VAX_16:
1570 case R_VAX_32:
1571 if (bfd_link_pic (info)
1572 && r_symndx != STN_UNDEF
1573 && (input_section->flags & SEC_ALLOC) != 0
1574 && ((r_type != R_VAX_PC8
1575 && r_type != R_VAX_PC16
1576 && r_type != R_VAX_PC32)
1577 || ((input_section->flags & SEC_CODE)
1578 && (!info->symbolic
1579 || (!h->def_regular && h->type != STT_SECTION)))))
1580 {
1581 Elf_Internal_Rela outrel;
1582 bfd_byte *loc;
1583 bfd_boolean skip, relocate;
1584
1585 /* When generating a shared object, these relocations
1586 are copied into the output file to be resolved at run
1587 time. */
1588 if (sreloc == NULL)
1589 {
1590 sreloc = _bfd_elf_get_dynamic_reloc_section
1591 (input_bfd, input_section, /*rela?*/ TRUE);
1592 if (sreloc == NULL)
1593 return FALSE;
1594 }
1595
1596 skip = FALSE;
1597 relocate = FALSE;
1598
1599 outrel.r_offset =
1600 _bfd_elf_section_offset (output_bfd, info, input_section,
1601 rel->r_offset);
1602 if (outrel.r_offset == (bfd_vma) -1)
1603 skip = TRUE;
1604 if (outrel.r_offset == (bfd_vma) -2)
1605 skip = TRUE, relocate = TRUE;
1606 outrel.r_offset += (input_section->output_section->vma
1607 + input_section->output_offset);
1608
1609 if (skip)
1610 memset (&outrel, 0, sizeof outrel);
1611 /* h->dynindx may be -1 if the symbol was marked to
1612 become local. */
1613 else if (h != NULL
1614 && ((! info->symbolic && h->dynindx != -1)
1615 || !h->def_regular))
1616 {
1617 BFD_ASSERT (h->dynindx != -1);
1618 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1619 outrel.r_addend = relocation + rel->r_addend;
1620 }
1621 else
1622 {
1623 if (r_type == R_VAX_32)
1624 {
1625 relocate = TRUE;
1626 outrel.r_info = ELF32_R_INFO (0, R_VAX_RELATIVE);
1627 BFD_ASSERT (bfd_get_signed_32 (input_bfd,
1628 &contents[rel->r_offset]) == 0);
1629 outrel.r_addend = relocation + rel->r_addend;
1630 }
1631 else
1632 {
1633 long indx;
1634
1635 if (bfd_is_abs_section (sec))
1636 indx = 0;
1637 else if (sec == NULL || sec->owner == NULL)
1638 {
1639 bfd_set_error (bfd_error_bad_value);
1640 return FALSE;
1641 }
1642 else
1643 {
1644 asection *osec;
1645
1646 /* We are turning this relocation into one
1647 against a section symbol. It would be
1648 proper to subtract the symbol's value,
1649 osec->vma, from the emitted reloc addend,
1650 but ld.so expects buggy relocs. */
1651 osec = sec->output_section;
1652 indx = elf_section_data (osec)->dynindx;
1653 if (indx == 0)
1654 {
1655 struct elf_link_hash_table *htab;
1656 htab = elf_hash_table (info);
1657 osec = htab->text_index_section;
1658 indx = elf_section_data (osec)->dynindx;
1659 }
1660 BFD_ASSERT (indx != 0);
1661 }
1662
1663 outrel.r_info = ELF32_R_INFO (indx, r_type);
1664 outrel.r_addend = relocation + rel->r_addend;
1665 }
1666 }
1667
1668 if ((input_section->flags & SEC_CODE) != 0
1669 || (ELF32_R_TYPE (outrel.r_info) != R_VAX_32
1670 && ELF32_R_TYPE (outrel.r_info) != R_VAX_RELATIVE
1671 && ELF32_R_TYPE (outrel.r_info) != R_VAX_COPY
1672 && ELF32_R_TYPE (outrel.r_info) != R_VAX_JMP_SLOT
1673 && ELF32_R_TYPE (outrel.r_info) != R_VAX_GLOB_DAT))
1674 {
1675 if (h != NULL)
1676 _bfd_error_handler
1677 /* xgettext:c-format */
1678 (_("%s: warning: %s relocation against symbol `%s' from %s section"),
1679 bfd_get_filename (input_bfd), howto->name,
1680 h->root.root.string,
1681 bfd_get_section_name (input_bfd, input_section));
1682 else
1683 _bfd_error_handler
1684 /* xgettext:c-format */
1685 (_("%s: warning: %s relocation to 0x%x from %s section"),
1686 bfd_get_filename (input_bfd), howto->name,
1687 outrel.r_addend,
1688 bfd_get_section_name (input_bfd, input_section));
1689 }
1690 loc = sreloc->contents;
1691 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1692 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1693
1694 /* This reloc will be computed at runtime, so there's no
1695 need to do anything now, except for R_VAX_32
1696 relocations that have been turned into
1697 R_VAX_RELATIVE. */
1698 if (!relocate)
1699 continue;
1700 }
1701
1702 break;
1703
1704 case R_VAX_GNU_VTINHERIT:
1705 case R_VAX_GNU_VTENTRY:
1706 /* These are no-ops in the end. */
1707 continue;
1708
1709 default:
1710 break;
1711 }
1712
1713 /* VAX PCREL relocations are from the end of relocation, not the start.
1714 So subtract the difference from the relocation amount since we can't
1715 add it to the offset. */
1716 if (howto->pc_relative && howto->pcrel_offset)
1717 relocation -= bfd_get_reloc_size(howto);
1718
1719 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1720 contents, rel->r_offset,
1721 relocation, rel->r_addend);
1722
1723 if (r != bfd_reloc_ok)
1724 {
1725 switch (r)
1726 {
1727 default:
1728 case bfd_reloc_outofrange:
1729 abort ();
1730 case bfd_reloc_overflow:
1731 {
1732 const char *name;
1733
1734 if (h != NULL)
1735 name = NULL;
1736 else
1737 {
1738 name = bfd_elf_string_from_elf_section (input_bfd,
1739 symtab_hdr->sh_link,
1740 sym->st_name);
1741 if (name == NULL)
1742 return FALSE;
1743 if (*name == '\0')
1744 name = bfd_section_name (input_bfd, sec);
1745 }
1746 info->callbacks->reloc_overflow
1747 (info, (h ? &h->root : NULL), name, howto->name,
1748 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1749 }
1750 break;
1751 }
1752 }
1753 }
1754
1755 return TRUE;
1756 }
1757
1758 /* Finish up dynamic symbol handling. We set the contents of various
1759 dynamic sections here. */
1760
1761 static bfd_boolean
1762 elf_vax_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
1763 struct elf_link_hash_entry *h,
1764 Elf_Internal_Sym *sym)
1765 {
1766 bfd *dynobj;
1767
1768 dynobj = elf_hash_table (info)->dynobj;
1769
1770 if (h->plt.offset != (bfd_vma) -1)
1771 {
1772 asection *splt;
1773 asection *sgot;
1774 asection *srela;
1775 bfd_vma plt_index;
1776 bfd_vma got_offset;
1777 bfd_vma addend;
1778 Elf_Internal_Rela rela;
1779 bfd_byte *loc;
1780
1781 /* This symbol has an entry in the procedure linkage table. Set
1782 it up. */
1783 BFD_ASSERT (h->dynindx != -1);
1784
1785 splt = bfd_get_linker_section (dynobj, ".plt");
1786 sgot = bfd_get_linker_section (dynobj, ".got.plt");
1787 srela = bfd_get_linker_section (dynobj, ".rela.plt");
1788 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1789
1790 addend = 2 * (h->plt.offset & 1);
1791 h->plt.offset &= ~1;
1792
1793 /* Get the index in the procedure linkage table which
1794 corresponds to this symbol. This is the index of this symbol
1795 in all the symbols for which we are making plt entries. The
1796 first entry in the procedure linkage table is reserved. */
1797 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1798
1799 /* Get the offset into the .got table of the entry that
1800 corresponds to this function. Each .got entry is 4 bytes.
1801 The first two are reserved. */
1802 got_offset = (plt_index + 3) * 4;
1803
1804 /* Fill in the entry in the procedure linkage table. */
1805 memcpy (splt->contents + h->plt.offset, elf_vax_plt_entry,
1806 PLT_ENTRY_SIZE);
1807
1808 /* The offset is relative to the first extension word. */
1809 bfd_put_32 (output_bfd,
1810 -(h->plt.offset + 8),
1811 splt->contents + h->plt.offset + 4);
1812
1813 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1814 splt->contents + h->plt.offset + 8);
1815
1816 /* Fill in the entry in the global offset table. */
1817 bfd_put_32 (output_bfd,
1818 (splt->output_section->vma
1819 + splt->output_offset
1820 + h->plt.offset) + addend,
1821 sgot->contents + got_offset);
1822
1823 /* Fill in the entry in the .rela.plt section. */
1824 rela.r_offset = (sgot->output_section->vma
1825 + sgot->output_offset
1826 + got_offset);
1827 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_JMP_SLOT);
1828 rela.r_addend = addend;
1829 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1830 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1831
1832 if (!h->def_regular)
1833 {
1834 /* Mark the symbol as undefined, rather than as defined in
1835 the .plt section. Leave the value alone. */
1836 sym->st_shndx = SHN_UNDEF;
1837 }
1838 }
1839
1840 if (h->got.offset != (bfd_vma) -1)
1841 {
1842 asection *sgot;
1843 asection *srela;
1844 Elf_Internal_Rela rela;
1845 bfd_byte *loc;
1846
1847 /* This symbol has an entry in the global offset table. Set it
1848 up. */
1849 sgot = bfd_get_linker_section (dynobj, ".got");
1850 srela = bfd_get_linker_section (dynobj, ".rela.got");
1851 BFD_ASSERT (sgot != NULL && srela != NULL);
1852
1853 rela.r_offset = (sgot->output_section->vma
1854 + sgot->output_offset
1855 + h->got.offset);
1856 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_GLOB_DAT);
1857 rela.r_addend = bfd_get_signed_32 (output_bfd,
1858 sgot->contents + h->got.offset);
1859
1860 loc = srela->contents;
1861 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1862 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1863 }
1864
1865 if (h->needs_copy)
1866 {
1867 asection *s;
1868 Elf_Internal_Rela rela;
1869 bfd_byte *loc;
1870
1871 /* This symbol needs a copy reloc. Set it up. */
1872 BFD_ASSERT (h->dynindx != -1
1873 && (h->root.type == bfd_link_hash_defined
1874 || h->root.type == bfd_link_hash_defweak));
1875
1876 s = bfd_get_linker_section (dynobj, ".rela.bss");
1877 BFD_ASSERT (s != NULL);
1878
1879 rela.r_offset = (h->root.u.def.value
1880 + h->root.u.def.section->output_section->vma
1881 + h->root.u.def.section->output_offset);
1882 rela.r_info = ELF32_R_INFO (h->dynindx, R_VAX_COPY);
1883 rela.r_addend = 0;
1884 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1885 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1886 }
1887
1888 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1889 if (h == elf_hash_table (info)->hdynamic
1890 || h == elf_hash_table (info)->hgot)
1891 sym->st_shndx = SHN_ABS;
1892
1893 return TRUE;
1894 }
1895
1896 /* Finish up the dynamic sections. */
1897
1898 static bfd_boolean
1899 elf_vax_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1900 {
1901 bfd *dynobj;
1902 asection *sgot;
1903 asection *sdyn;
1904
1905 dynobj = elf_hash_table (info)->dynobj;
1906
1907 sgot = bfd_get_linker_section (dynobj, ".got.plt");
1908 BFD_ASSERT (sgot != NULL);
1909 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1910
1911 if (elf_hash_table (info)->dynamic_sections_created)
1912 {
1913 asection *splt;
1914 Elf32_External_Dyn *dyncon, *dynconend;
1915
1916 splt = bfd_get_linker_section (dynobj, ".plt");
1917 BFD_ASSERT (splt != NULL && sdyn != NULL);
1918
1919 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1920 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1921 for (; dyncon < dynconend; dyncon++)
1922 {
1923 Elf_Internal_Dyn dyn;
1924 const char *name;
1925 asection *s;
1926
1927 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1928
1929 switch (dyn.d_tag)
1930 {
1931 default:
1932 break;
1933
1934 case DT_PLTGOT:
1935 name = ".got.plt";
1936 goto get_vma;
1937 case DT_JMPREL:
1938 name = ".rela.plt";
1939 get_vma:
1940 s = bfd_get_linker_section (dynobj, name);
1941 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1942 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1943 break;
1944
1945 case DT_PLTRELSZ:
1946 s = bfd_get_linker_section (dynobj, ".rela.plt");
1947 dyn.d_un.d_val = s->size;
1948 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1949 break;
1950
1951 case DT_RELASZ:
1952 /* The procedure linkage table relocs (DT_JMPREL) should
1953 not be included in the overall relocs (DT_RELA).
1954 Therefore, we override the DT_RELASZ entry here to
1955 make it not include the JMPREL relocs. Since the
1956 linker script arranges for .rela.plt to follow all
1957 other relocation sections, we don't have to worry
1958 about changing the DT_RELA entry. */
1959 s = bfd_get_linker_section (dynobj, ".rela.plt");
1960 if (s != NULL)
1961 dyn.d_un.d_val -= s->size;
1962 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1963 break;
1964 }
1965 }
1966
1967 /* Fill in the first entry in the procedure linkage table. */
1968 if (splt->size > 0)
1969 {
1970 memcpy (splt->contents, elf_vax_plt0_entry, PLT_ENTRY_SIZE);
1971 bfd_put_32 (output_bfd,
1972 (sgot->output_section->vma
1973 + sgot->output_offset + 4
1974 - (splt->output_section->vma + 6)),
1975 splt->contents + 2);
1976 bfd_put_32 (output_bfd,
1977 (sgot->output_section->vma
1978 + sgot->output_offset + 8
1979 - (splt->output_section->vma + 12)),
1980 splt->contents + 8);
1981 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1982 = PLT_ENTRY_SIZE;
1983 }
1984 }
1985
1986 /* Fill in the first three entries in the global offset table. */
1987 if (sgot->size > 0)
1988 {
1989 if (sdyn == NULL)
1990 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1991 else
1992 bfd_put_32 (output_bfd,
1993 sdyn->output_section->vma + sdyn->output_offset,
1994 sgot->contents);
1995 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1996 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1997 }
1998
1999 if (elf_section_data (sgot->output_section) != NULL)
2000 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2001
2002 return TRUE;
2003 }
2004
2005 static enum elf_reloc_type_class
2006 elf_vax_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2007 const asection *rel_sec ATTRIBUTE_UNUSED,
2008 const Elf_Internal_Rela *rela)
2009 {
2010 switch ((int) ELF32_R_TYPE (rela->r_info))
2011 {
2012 case R_VAX_RELATIVE:
2013 return reloc_class_relative;
2014 case R_VAX_JMP_SLOT:
2015 return reloc_class_plt;
2016 case R_VAX_COPY:
2017 return reloc_class_copy;
2018 default:
2019 return reloc_class_normal;
2020 }
2021 }
2022
2023 static bfd_vma
2024 elf_vax_plt_sym_val (bfd_vma i, const asection *plt,
2025 const arelent *rel ATTRIBUTE_UNUSED)
2026 {
2027 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
2028 }
2029
2030 #define TARGET_LITTLE_SYM vax_elf32_vec
2031 #define TARGET_LITTLE_NAME "elf32-vax"
2032 #define ELF_MACHINE_CODE EM_VAX
2033 #define ELF_MAXPAGESIZE 0x1000
2034
2035 #define elf_backend_create_dynamic_sections \
2036 _bfd_elf_create_dynamic_sections
2037 #define bfd_elf32_bfd_link_hash_table_create \
2038 elf_vax_link_hash_table_create
2039 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2040
2041 #define elf_backend_check_relocs elf_vax_check_relocs
2042 #define elf_backend_adjust_dynamic_symbol \
2043 elf_vax_adjust_dynamic_symbol
2044 #define elf_backend_always_size_sections \
2045 elf_vax_always_size_sections
2046 #define elf_backend_size_dynamic_sections \
2047 elf_vax_size_dynamic_sections
2048 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
2049 #define elf_backend_relocate_section elf_vax_relocate_section
2050 #define elf_backend_finish_dynamic_symbol \
2051 elf_vax_finish_dynamic_symbol
2052 #define elf_backend_finish_dynamic_sections \
2053 elf_vax_finish_dynamic_sections
2054 #define elf_backend_reloc_type_class elf_vax_reloc_type_class
2055 #define elf_backend_gc_mark_hook elf_vax_gc_mark_hook
2056 #define elf_backend_gc_sweep_hook elf_vax_gc_sweep_hook
2057 #define elf_backend_plt_sym_val elf_vax_plt_sym_val
2058 #define bfd_elf32_bfd_merge_private_bfd_data \
2059 elf32_vax_merge_private_bfd_data
2060 #define bfd_elf32_bfd_set_private_flags \
2061 elf32_vax_set_private_flags
2062 #define bfd_elf32_bfd_print_private_bfd_data \
2063 elf32_vax_print_private_bfd_data
2064
2065 #define elf_backend_can_gc_sections 1
2066 #define elf_backend_want_got_plt 1
2067 #define elf_backend_plt_readonly 1
2068 #define elf_backend_want_plt_sym 0
2069 #define elf_backend_got_header_size 16
2070 #define elf_backend_rela_normal 1
2071
2072 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.108431 seconds and 4 git commands to generate.