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