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