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