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