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