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