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