elf64-ia64-vms.c revision 1.1.1.11
1 /* IA-64 support for OpenVMS 2 Copyright (C) 1998-2025 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "opcode/ia64.h" 26 #include "elf/ia64.h" 27 #include "objalloc.h" 28 #include "hashtab.h" 29 #include "elfxx-ia64.h" 30 #include "vms.h" 31 #include "bfdver.h" 32 33 /* THE RULES for all the stuff the linker creates -- 34 35 GOT Entries created in response to LTOFF or LTOFF_FPTR 36 relocations. Dynamic relocs created for dynamic 37 symbols in an application; REL relocs for locals 38 in a shared library. 39 40 FPTR The canonical function descriptor. Created for local 41 symbols in applications. Descriptors for dynamic symbols 42 and local symbols in shared libraries are created by 43 ld.so. Thus there are no dynamic relocs against these 44 objects. The FPTR relocs for such _are_ passed through 45 to the dynamic relocation tables. 46 47 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol. 48 Requires the creation of a PLTOFF entry. This does not 49 require any dynamic relocations. 50 51 PLTOFF Created by PLTOFF relocations. For local symbols, this 52 is an alternate function descriptor, and in shared libraries 53 requires two REL relocations. Note that this cannot be 54 transformed into an FPTR relocation, since it must be in 55 range of the GP. For dynamic symbols, this is a function 56 descriptor. */ 57 58 typedef struct bfd_hash_entry *(*new_hash_entry_func) 59 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); 60 61 /* In dynamically (linker-) created sections, we generally need to keep track 62 of the place a symbol or expression got allocated to. This is done via hash 63 tables that store entries of the following type. */ 64 65 struct elf64_ia64_dyn_sym_info 66 { 67 /* The addend for which this entry is relevant. */ 68 bfd_vma addend; 69 70 bfd_vma got_offset; 71 bfd_vma fptr_offset; 72 bfd_vma pltoff_offset; 73 bfd_vma plt_offset; 74 bfd_vma plt2_offset; 75 76 /* The symbol table entry, if any, that this was derived from. */ 77 struct elf_link_hash_entry *h; 78 79 /* Used to count non-got, non-plt relocations for delayed sizing 80 of relocation sections. */ 81 struct elf64_ia64_dyn_reloc_entry 82 { 83 struct elf64_ia64_dyn_reloc_entry *next; 84 asection *srel; 85 int type; 86 int count; 87 } *reloc_entries; 88 89 /* TRUE when the section contents have been updated. */ 90 unsigned got_done : 1; 91 unsigned fptr_done : 1; 92 unsigned pltoff_done : 1; 93 94 /* TRUE for the different kinds of linker data we want created. */ 95 unsigned want_got : 1; 96 unsigned want_gotx : 1; 97 unsigned want_fptr : 1; 98 unsigned want_ltoff_fptr : 1; 99 unsigned want_plt : 1; /* A MIN_PLT entry. */ 100 unsigned want_plt2 : 1; /* A FULL_PLT. */ 101 unsigned want_pltoff : 1; 102 }; 103 104 struct elf64_ia64_local_hash_entry 105 { 106 int id; 107 unsigned int r_sym; 108 /* The number of elements in elf64_ia64_dyn_sym_info array. */ 109 unsigned int count; 110 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */ 111 unsigned int sorted_count; 112 /* The size of elf64_ia64_dyn_sym_info array. */ 113 unsigned int size; 114 /* The array of elf64_ia64_dyn_sym_info. */ 115 struct elf64_ia64_dyn_sym_info *info; 116 117 /* TRUE if this hash entry's addends was translated for 118 SHF_MERGE optimization. */ 119 unsigned sec_merge_done : 1; 120 }; 121 122 struct elf64_ia64_link_hash_entry 123 { 124 struct elf_link_hash_entry root; 125 126 /* Set if this symbol is defined in a shared library. 127 We can't use root.u.def.section->owner as the symbol is an absolute 128 symbol. */ 129 bfd *shl; 130 131 /* The number of elements in elf64_ia64_dyn_sym_info array. */ 132 unsigned int count; 133 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */ 134 unsigned int sorted_count; 135 /* The size of elf64_ia64_dyn_sym_info array. */ 136 unsigned int size; 137 /* The array of elf64_ia64_dyn_sym_info. */ 138 struct elf64_ia64_dyn_sym_info *info; 139 }; 140 141 struct elf64_ia64_link_hash_table 142 { 143 /* The main hash table. */ 144 struct elf_link_hash_table root; 145 146 asection *fptr_sec; /* Function descriptor table (or NULL). */ 147 asection *rel_fptr_sec; /* Dynamic relocation section for same. */ 148 asection *pltoff_sec; /* Private descriptors for plt (or NULL). */ 149 asection *fixups_sec; /* Fixups section. */ 150 asection *transfer_sec; /* Transfer vector section. */ 151 asection *note_sec; /* .note section. */ 152 153 /* There are maybe R_IA64_GPREL22 relocations, including those 154 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT 155 sections. We need to record those sections so that we can choose 156 a proper GP to cover all R_IA64_GPREL22 relocations. */ 157 asection *max_short_sec; /* Maximum short output section. */ 158 bfd_vma max_short_offset; /* Maximum short offset. */ 159 asection *min_short_sec; /* Minimum short output section. */ 160 bfd_vma min_short_offset; /* Minimum short offset. */ 161 162 htab_t loc_hash_table; 163 void *loc_hash_memory; 164 }; 165 166 struct elf64_ia64_allocate_data 167 { 168 struct bfd_link_info *info; 169 bfd_size_type ofs; 170 }; 171 172 #define elf64_ia64_hash_table(p) \ 173 ((is_elf_hash_table ((p)->hash) \ 174 && elf_hash_table_id (elf_hash_table (p)) == IA64_ELF_DATA) \ 175 ? (struct elf64_ia64_link_hash_table *) (p)->hash : NULL) 176 177 struct elf64_ia64_vms_obj_tdata 178 { 179 struct elf_obj_tdata root; 180 181 /* Ident for shared library. */ 182 uint64_t ident; 183 184 /* Used only during link: offset in the .fixups section for this bfd. */ 185 bfd_vma fixups_off; 186 187 /* Max number of shared libraries. */ 188 unsigned int needed_count; 189 }; 190 191 #define elf_ia64_vms_tdata(abfd) \ 192 ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any)) 193 #define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident) 194 195 struct elf64_vms_transfer 196 { 197 unsigned char size[4]; 198 unsigned char spare[4]; 199 unsigned char tfradr1[8]; 200 unsigned char tfradr2[8]; 201 unsigned char tfradr3[8]; 202 unsigned char tfradr4[8]; 203 unsigned char tfradr5[8]; 204 205 /* Local function descriptor for tfr3. */ 206 unsigned char tfr3_func[8]; 207 unsigned char tfr3_gp[8]; 208 }; 209 210 typedef struct 211 { 212 Elf64_External_Ehdr ehdr; 213 unsigned char vms_needed_count[8]; 214 } Elf64_External_VMS_Ehdr; 215 216 static struct elf64_ia64_dyn_sym_info * get_dyn_sym_info 217 (struct elf64_ia64_link_hash_table *, 218 struct elf_link_hash_entry *, 219 bfd *, const Elf_Internal_Rela *, bool); 220 static bool elf64_ia64_dynamic_symbol_p 221 (struct elf_link_hash_entry *); 222 static bool elf64_ia64_choose_gp 223 (bfd *, struct bfd_link_info *, bool); 224 static void elf64_ia64_dyn_sym_traverse 225 (struct elf64_ia64_link_hash_table *, 226 bool (*) (struct elf64_ia64_dyn_sym_info *, void *), 227 void *); 228 static bool allocate_global_data_got 229 (struct elf64_ia64_dyn_sym_info *, void *); 230 static bool allocate_global_fptr_got 231 (struct elf64_ia64_dyn_sym_info *, void *); 232 static bool allocate_local_got 233 (struct elf64_ia64_dyn_sym_info *, void *); 234 static bool allocate_dynrel_entries 235 (struct elf64_ia64_dyn_sym_info *, void *); 236 static asection *get_pltoff 237 (bfd *, struct elf64_ia64_link_hash_table *); 238 static asection *get_got 239 (bfd *, struct elf64_ia64_link_hash_table *); 240 241 242 /* Given a ELF reloc, return the matching HOWTO structure. */ 243 244 static bool 245 elf64_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 246 arelent *bfd_reloc, 247 Elf_Internal_Rela *elf_reloc) 248 { 249 unsigned int r_type = ELF32_R_TYPE (elf_reloc->r_info); 250 251 bfd_reloc->howto = ia64_elf_lookup_howto (r_type); 252 if (bfd_reloc->howto == NULL) 253 { 254 /* xgettext:c-format */ 255 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 256 abfd, r_type); 257 bfd_set_error (bfd_error_bad_value); 258 return false; 259 } 260 261 return true; 262 } 263 264 265 #define PLT_FULL_ENTRY_SIZE (2 * 16) 266 267 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] = 268 { 269 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */ 270 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/ 271 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */ 272 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */ 273 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */ 274 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */ 275 }; 276 277 static const bfd_byte oor_brl[16] = 278 { 279 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */ 280 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/ 281 0x00, 0x00, 0x00, 0xc0 282 }; 283 284 285 /* These functions do relaxation for IA-64 ELF. */ 286 287 /* Rename some of the generic section flags to better document how they 288 are used here. */ 289 #define skip_relax_pass_0 sec_flg0 290 #define skip_relax_pass_1 sec_flg1 291 292 static void 293 elf64_ia64_update_short_info (asection *sec, bfd_vma offset, 294 struct elf64_ia64_link_hash_table *ia64_info) 295 { 296 /* Skip ABS and SHF_IA_64_SHORT sections. */ 297 if (sec == bfd_abs_section_ptr 298 || (sec->flags & SEC_SMALL_DATA) != 0) 299 return; 300 301 if (!ia64_info->min_short_sec) 302 { 303 ia64_info->max_short_sec = sec; 304 ia64_info->max_short_offset = offset; 305 ia64_info->min_short_sec = sec; 306 ia64_info->min_short_offset = offset; 307 } 308 else if (sec == ia64_info->max_short_sec 309 && offset > ia64_info->max_short_offset) 310 ia64_info->max_short_offset = offset; 311 else if (sec == ia64_info->min_short_sec 312 && offset < ia64_info->min_short_offset) 313 ia64_info->min_short_offset = offset; 314 else if (sec->output_section->vma 315 > ia64_info->max_short_sec->vma) 316 { 317 ia64_info->max_short_sec = sec; 318 ia64_info->max_short_offset = offset; 319 } 320 else if (sec->output_section->vma 321 < ia64_info->min_short_sec->vma) 322 { 323 ia64_info->min_short_sec = sec; 324 ia64_info->min_short_offset = offset; 325 } 326 } 327 328 /* Use a two passes algorithm. In the first pass, branches are relaxed 329 (which may increase the size of the section). In the second pass, 330 the other relaxations are done. 331 */ 332 333 static bool 334 elf64_ia64_relax_section (bfd *abfd, asection *sec, 335 struct bfd_link_info *link_info, 336 bool *again) 337 { 338 struct one_fixup 339 { 340 struct one_fixup *next; 341 asection *tsec; 342 bfd_vma toff; 343 bfd_vma trampoff; 344 }; 345 346 Elf_Internal_Shdr *symtab_hdr; 347 Elf_Internal_Rela *internal_relocs; 348 Elf_Internal_Rela *irel, *irelend; 349 bfd_byte *contents; 350 Elf_Internal_Sym *isymbuf = NULL; 351 struct elf64_ia64_link_hash_table *ia64_info; 352 struct one_fixup *fixups = NULL; 353 bool changed_contents = false; 354 bool changed_relocs = false; 355 bool skip_relax_pass_0 = true; 356 bool skip_relax_pass_1 = true; 357 bfd_vma gp = 0; 358 359 /* Assume we're not going to change any sizes, and we'll only need 360 one pass. */ 361 *again = false; 362 363 if (bfd_link_relocatable (link_info)) 364 link_info->callbacks->fatal 365 (_("%P: --relax and -r may not be used together\n")); 366 367 /* Don't even try to relax for non-ELF outputs. */ 368 if (!is_elf_hash_table (link_info->hash)) 369 return false; 370 371 /* Nothing to do if there are no relocations or there is no need for 372 the current pass. */ 373 if (sec->reloc_count == 0 374 || (sec->flags & SEC_RELOC) == 0 375 || (sec->flags & SEC_HAS_CONTENTS) == 0 376 || (link_info->relax_pass == 0 && sec->skip_relax_pass_0) 377 || (link_info->relax_pass == 1 && sec->skip_relax_pass_1)) 378 return true; 379 380 ia64_info = elf64_ia64_hash_table (link_info); 381 if (ia64_info == NULL) 382 return false; 383 384 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 385 386 /* Load the relocations for this section. */ 387 internal_relocs = (_bfd_elf_link_read_relocs 388 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 389 link_info->keep_memory)); 390 if (internal_relocs == NULL) 391 return false; 392 393 irelend = internal_relocs + sec->reloc_count; 394 395 /* Get the section contents. */ 396 if (elf_section_data (sec)->this_hdr.contents != NULL) 397 contents = elf_section_data (sec)->this_hdr.contents; 398 else 399 { 400 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 401 goto error_return; 402 } 403 404 for (irel = internal_relocs; irel < irelend; irel++) 405 { 406 unsigned long r_type = ELF64_R_TYPE (irel->r_info); 407 bfd_vma symaddr, reladdr, trampoff, toff, roff; 408 asection *tsec; 409 struct one_fixup *f; 410 bfd_size_type amt; 411 bool is_branch; 412 struct elf64_ia64_dyn_sym_info *dyn_i; 413 414 switch (r_type) 415 { 416 case R_IA64_PCREL21B: 417 case R_IA64_PCREL21BI: 418 case R_IA64_PCREL21M: 419 case R_IA64_PCREL21F: 420 /* In pass 1, all br relaxations are done. We can skip it. */ 421 if (link_info->relax_pass == 1) 422 continue; 423 skip_relax_pass_0 = false; 424 is_branch = true; 425 break; 426 427 case R_IA64_PCREL60B: 428 /* We can't optimize brl to br in pass 0 since br relaxations 429 will increase the code size. Defer it to pass 1. */ 430 if (link_info->relax_pass == 0) 431 { 432 skip_relax_pass_1 = false; 433 continue; 434 } 435 is_branch = true; 436 break; 437 438 case R_IA64_GPREL22: 439 /* Update max_short_sec/min_short_sec. */ 440 441 case R_IA64_LTOFF22X: 442 case R_IA64_LDXMOV: 443 /* We can't relax ldx/mov in pass 0 since br relaxations will 444 increase the code size. Defer it to pass 1. */ 445 if (link_info->relax_pass == 0) 446 { 447 skip_relax_pass_1 = false; 448 continue; 449 } 450 is_branch = false; 451 break; 452 453 default: 454 continue; 455 } 456 457 /* Get the value of the symbol referred to by the reloc. */ 458 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info) 459 { 460 /* A local symbol. */ 461 Elf_Internal_Sym *isym; 462 463 /* Read this BFD's local symbols. */ 464 if (isymbuf == NULL) 465 { 466 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 467 if (isymbuf == NULL) 468 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 469 symtab_hdr->sh_info, 0, 470 NULL, NULL, NULL); 471 if (isymbuf == 0) 472 goto error_return; 473 } 474 475 isym = isymbuf + ELF64_R_SYM (irel->r_info); 476 if (isym->st_shndx == SHN_UNDEF) 477 continue; /* We can't do anything with undefined symbols. */ 478 else if (isym->st_shndx == SHN_ABS) 479 tsec = bfd_abs_section_ptr; 480 else if (isym->st_shndx == SHN_COMMON) 481 tsec = bfd_com_section_ptr; 482 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON) 483 tsec = bfd_com_section_ptr; 484 else 485 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 486 487 toff = isym->st_value; 488 dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, false); 489 } 490 else 491 { 492 unsigned long indx; 493 struct elf_link_hash_entry *h; 494 495 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info; 496 h = elf_sym_hashes (abfd)[indx]; 497 BFD_ASSERT (h != NULL); 498 499 while (h->root.type == bfd_link_hash_indirect 500 || h->root.type == bfd_link_hash_warning) 501 h = (struct elf_link_hash_entry *) h->root.u.i.link; 502 503 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false); 504 505 /* For branches to dynamic symbols, we're interested instead 506 in a branch to the PLT entry. */ 507 if (is_branch && dyn_i && dyn_i->want_plt2) 508 { 509 /* Internal branches shouldn't be sent to the PLT. 510 Leave this for now and we'll give an error later. */ 511 if (r_type != R_IA64_PCREL21B) 512 continue; 513 514 tsec = ia64_info->root.splt; 515 toff = dyn_i->plt2_offset; 516 BFD_ASSERT (irel->r_addend == 0); 517 } 518 519 /* Can't do anything else with dynamic symbols. */ 520 else if (elf64_ia64_dynamic_symbol_p (h)) 521 continue; 522 523 else 524 { 525 /* We can't do anything with undefined symbols. */ 526 if (h->root.type == bfd_link_hash_undefined 527 || h->root.type == bfd_link_hash_undefweak) 528 continue; 529 530 tsec = h->root.u.def.section; 531 toff = h->root.u.def.value; 532 } 533 } 534 535 toff += irel->r_addend; 536 537 symaddr = tsec->output_section->vma + tsec->output_offset + toff; 538 539 roff = irel->r_offset; 540 541 if (is_branch) 542 { 543 bfd_signed_vma offset; 544 545 reladdr = (sec->output_section->vma 546 + sec->output_offset 547 + roff) & (bfd_vma) -4; 548 549 /* The .plt section is aligned at 32byte and the .text section 550 is aligned at 64byte. The .text section is right after the 551 .plt section. After the first relaxation pass, linker may 552 increase the gap between the .plt and .text sections up 553 to 32byte. We assume linker will always insert 32byte 554 between the .plt and .text sections after the first 555 relaxation pass. */ 556 if (tsec == ia64_info->root.splt) 557 offset = -0x1000000 + 32; 558 else 559 offset = -0x1000000; 560 561 /* If the branch is in range, no need to do anything. */ 562 if ((bfd_signed_vma) (symaddr - reladdr) >= offset 563 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0) 564 { 565 /* If the 60-bit branch is in 21-bit range, optimize it. */ 566 if (r_type == R_IA64_PCREL60B) 567 { 568 ia64_elf_relax_brl (contents, roff); 569 570 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), 571 R_IA64_PCREL21B); 572 573 /* If the original relocation offset points to slot 574 1, change it to slot 2. */ 575 if ((irel->r_offset & 3) == 1) 576 irel->r_offset += 1; 577 } 578 579 continue; 580 } 581 else if (r_type == R_IA64_PCREL60B) 582 continue; 583 else if (ia64_elf_relax_br (contents, roff)) 584 { 585 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), 586 R_IA64_PCREL60B); 587 588 /* Make the relocation offset point to slot 1. */ 589 irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1; 590 continue; 591 } 592 593 /* We can't put a trampoline in a .init/.fini section. Issue 594 an error. */ 595 if (strcmp (sec->output_section->name, ".init") == 0 596 || strcmp (sec->output_section->name, ".fini") == 0) 597 { 598 _bfd_error_handler 599 /* xgettext:c-format */ 600 (_("%pB: can't relax br at %#" PRIx64 " in section `%pA';" 601 " please use brl or indirect branch"), 602 sec->owner, (uint64_t) roff, sec); 603 bfd_set_error (bfd_error_bad_value); 604 goto error_return; 605 } 606 607 /* If the branch and target are in the same section, you've 608 got one honking big section and we can't help you unless 609 you are branching backwards. You'll get an error message 610 later. */ 611 if (tsec == sec && toff > roff) 612 continue; 613 614 /* Look for an existing fixup to this address. */ 615 for (f = fixups; f ; f = f->next) 616 if (f->tsec == tsec && f->toff == toff) 617 break; 618 619 if (f == NULL) 620 { 621 /* Two alternatives: If it's a branch to a PLT entry, we can 622 make a copy of the FULL_PLT entry. Otherwise, we'll have 623 to use a `brl' insn to get where we're going. */ 624 625 size_t size; 626 627 if (tsec == ia64_info->root.splt) 628 size = sizeof (plt_full_entry); 629 else 630 size = sizeof (oor_brl); 631 632 /* Resize the current section to make room for the new branch. */ 633 trampoff = (sec->size + 15) & (bfd_vma) -16; 634 635 /* If trampoline is out of range, there is nothing we 636 can do. */ 637 offset = trampoff - (roff & (bfd_vma) -4); 638 if (offset < -0x1000000 || offset > 0x0FFFFF0) 639 continue; 640 641 amt = trampoff + size; 642 contents = (bfd_byte *) bfd_realloc (contents, amt); 643 if (contents == NULL) 644 goto error_return; 645 sec->size = amt; 646 647 if (tsec == ia64_info->root.splt) 648 { 649 memcpy (contents + trampoff, plt_full_entry, size); 650 651 /* Hijack the old relocation for use as the PLTOFF reloc. */ 652 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), 653 R_IA64_PLTOFF22); 654 irel->r_offset = trampoff; 655 } 656 else 657 { 658 memcpy (contents + trampoff, oor_brl, size); 659 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), 660 R_IA64_PCREL60B); 661 irel->r_offset = trampoff + 2; 662 } 663 664 /* Record the fixup so we don't do it again this section. */ 665 f = (struct one_fixup *) 666 bfd_malloc ((bfd_size_type) sizeof (*f)); 667 f->next = fixups; 668 f->tsec = tsec; 669 f->toff = toff; 670 f->trampoff = trampoff; 671 fixups = f; 672 } 673 else 674 { 675 /* If trampoline is out of range, there is nothing we 676 can do. */ 677 offset = f->trampoff - (roff & (bfd_vma) -4); 678 if (offset < -0x1000000 || offset > 0x0FFFFF0) 679 continue; 680 681 /* Nop out the reloc, since we're finalizing things here. */ 682 irel->r_info = ELF64_R_INFO (0, R_IA64_NONE); 683 } 684 685 /* Fix up the existing branch to hit the trampoline. */ 686 if (ia64_elf_install_value (contents + roff, offset, r_type) 687 != bfd_reloc_ok) 688 goto error_return; 689 690 changed_contents = true; 691 changed_relocs = true; 692 } 693 else 694 { 695 /* Fetch the gp. */ 696 if (gp == 0) 697 { 698 bfd *obfd = sec->output_section->owner; 699 gp = _bfd_get_gp_value (obfd); 700 if (gp == 0) 701 { 702 if (!elf64_ia64_choose_gp (obfd, link_info, false)) 703 goto error_return; 704 gp = _bfd_get_gp_value (obfd); 705 } 706 } 707 708 /* If the data is out of range, do nothing. */ 709 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000 710 ||(bfd_signed_vma) (symaddr - gp) < -0x200000) 711 continue; 712 713 if (r_type == R_IA64_GPREL22) 714 elf64_ia64_update_short_info (tsec->output_section, 715 tsec->output_offset + toff, 716 ia64_info); 717 else if (r_type == R_IA64_LTOFF22X) 718 { 719 /* Can't deal yet correctly with ABS symbols. */ 720 if (bfd_is_abs_section (tsec)) 721 continue; 722 723 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), 724 R_IA64_GPREL22); 725 changed_relocs = true; 726 727 elf64_ia64_update_short_info (tsec->output_section, 728 tsec->output_offset + toff, 729 ia64_info); 730 } 731 else 732 { 733 ia64_elf_relax_ldxmov (contents, roff); 734 irel->r_info = ELF64_R_INFO (0, R_IA64_NONE); 735 changed_contents = true; 736 changed_relocs = true; 737 } 738 } 739 } 740 741 /* ??? If we created fixups, this may push the code segment large 742 enough that the data segment moves, which will change the GP. 743 Reset the GP so that we re-calculate next round. We need to 744 do this at the _beginning_ of the next round; now will not do. */ 745 746 /* Clean up and go home. */ 747 while (fixups) 748 { 749 struct one_fixup *f = fixups; 750 fixups = fixups->next; 751 free (f); 752 } 753 754 if (isymbuf != NULL 755 && symtab_hdr->contents != (unsigned char *) isymbuf) 756 { 757 if (! link_info->keep_memory) 758 free (isymbuf); 759 else 760 { 761 /* Cache the symbols for elf_link_input_bfd. */ 762 symtab_hdr->contents = (unsigned char *) isymbuf; 763 } 764 } 765 766 if (contents != NULL 767 && elf_section_data (sec)->this_hdr.contents != contents) 768 { 769 if (!changed_contents && !link_info->keep_memory) 770 free (contents); 771 else 772 { 773 /* Cache the section contents for elf_link_input_bfd. */ 774 elf_section_data (sec)->this_hdr.contents = contents; 775 } 776 } 777 778 if (elf_section_data (sec)->relocs != internal_relocs) 779 { 780 if (!changed_relocs) 781 free (internal_relocs); 782 else 783 elf_section_data (sec)->relocs = internal_relocs; 784 } 785 786 if (link_info->relax_pass == 0) 787 { 788 /* Pass 0 is only needed to relax br. */ 789 sec->skip_relax_pass_0 = skip_relax_pass_0; 790 sec->skip_relax_pass_1 = skip_relax_pass_1; 791 } 792 793 *again = changed_contents || changed_relocs; 794 return true; 795 796 error_return: 797 if ((unsigned char *) isymbuf != symtab_hdr->contents) 798 free (isymbuf); 799 if (elf_section_data (sec)->this_hdr.contents != contents) 800 free (contents); 801 if (elf_section_data (sec)->relocs != internal_relocs) 802 free (internal_relocs); 803 return false; 804 } 805 #undef skip_relax_pass_0 806 #undef skip_relax_pass_1 807 808 /* Return TRUE if NAME is an unwind table section name. */ 809 810 static inline bool 811 is_unwind_section_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name) 812 { 813 return ((startswith (name, ELF_STRING_ia64_unwind) 814 && ! startswith (name, ELF_STRING_ia64_unwind_info)) 815 || startswith (name, ELF_STRING_ia64_unwind_once)); 816 } 817 818 819 /* Convert IA-64 specific section flags to bfd internal section flags. */ 820 821 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV 822 flag. */ 823 824 static bool 825 elf64_ia64_section_flags (const Elf_Internal_Shdr *hdr) 826 { 827 if (hdr->sh_flags & SHF_IA_64_SHORT) 828 hdr->bfd_section->flags |= SEC_SMALL_DATA; 829 830 return true; 831 } 832 833 /* Set the correct type for an IA-64 ELF section. We do this by the 834 section name, which is a hack, but ought to work. */ 835 836 static bool 837 elf64_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, 838 asection *sec) 839 { 840 const char *name; 841 842 name = bfd_section_name (sec); 843 844 if (is_unwind_section_name (abfd, name)) 845 { 846 /* We don't have the sections numbered at this point, so sh_info 847 is set later, in elf64_ia64_final_write_processing. */ 848 hdr->sh_type = SHT_IA_64_UNWIND; 849 hdr->sh_flags |= SHF_LINK_ORDER; 850 } 851 else if (strcmp (name, ELF_STRING_ia64_archext) == 0) 852 hdr->sh_type = SHT_IA_64_EXT; 853 854 if (sec->flags & SEC_SMALL_DATA) 855 hdr->sh_flags |= SHF_IA_64_SHORT; 856 857 return true; 858 } 859 860 /* Hook called by the linker routine which adds symbols from an object 861 file. We use it to put .comm items in .sbss, and not .bss. */ 862 863 static bool 864 elf64_ia64_add_symbol_hook (bfd *abfd, 865 struct bfd_link_info *info, 866 Elf_Internal_Sym *sym, 867 const char **namep ATTRIBUTE_UNUSED, 868 flagword *flagsp ATTRIBUTE_UNUSED, 869 asection **secp, 870 bfd_vma *valp) 871 { 872 if (sym->st_shndx == SHN_COMMON 873 && !bfd_link_relocatable (info) 874 && sym->st_size <= elf_gp_size (abfd)) 875 { 876 /* Common symbols less than or equal to -G nn bytes are 877 automatically put into .sbss. */ 878 879 asection *scomm = bfd_get_section_by_name (abfd, ".scommon"); 880 881 if (scomm == NULL) 882 { 883 scomm = bfd_make_section_with_flags (abfd, ".scommon", 884 (SEC_ALLOC 885 | SEC_IS_COMMON 886 | SEC_SMALL_DATA 887 | SEC_LINKER_CREATED)); 888 if (scomm == NULL) 889 return false; 890 } 891 892 *secp = scomm; 893 *valp = sym->st_size; 894 } 895 896 return true; 897 } 898 899 /* According to the Tahoe assembler spec, all labels starting with a 900 '.' are local. */ 901 902 static bool 903 elf64_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 904 const char *name) 905 { 906 return name[0] == '.'; 907 } 908 909 /* Should we do dynamic things to this symbol? */ 910 911 static bool 912 elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h) 913 { 914 return h != NULL && h->def_dynamic; 915 } 916 917 static struct bfd_hash_entry* 918 elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry, 919 struct bfd_hash_table *table, 920 const char *string) 921 { 922 struct elf64_ia64_link_hash_entry *ret; 923 ret = (struct elf64_ia64_link_hash_entry *) entry; 924 925 /* Allocate the structure if it has not already been allocated by a 926 subclass. */ 927 if (!ret) 928 ret = bfd_hash_allocate (table, sizeof (*ret)); 929 930 if (!ret) 931 return 0; 932 933 /* Call the allocation method of the superclass. */ 934 ret = ((struct elf64_ia64_link_hash_entry *) 935 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 936 table, string)); 937 938 ret->info = NULL; 939 ret->count = 0; 940 ret->sorted_count = 0; 941 ret->size = 0; 942 return (struct bfd_hash_entry *) ret; 943 } 944 945 static void 946 elf64_ia64_hash_hide_symbol (struct bfd_link_info *info, 947 struct elf_link_hash_entry *xh, 948 bool force_local) 949 { 950 struct elf64_ia64_link_hash_entry *h; 951 struct elf64_ia64_dyn_sym_info *dyn_i; 952 unsigned int count; 953 954 h = (struct elf64_ia64_link_hash_entry *)xh; 955 956 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local); 957 958 for (count = h->count, dyn_i = h->info; 959 count != 0; 960 count--, dyn_i++) 961 { 962 dyn_i->want_plt2 = 0; 963 dyn_i->want_plt = 0; 964 } 965 } 966 967 /* Compute a hash of a local hash entry. */ 968 969 static hashval_t 970 elf64_ia64_local_htab_hash (const void *ptr) 971 { 972 struct elf64_ia64_local_hash_entry *entry 973 = (struct elf64_ia64_local_hash_entry *) ptr; 974 975 return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym); 976 } 977 978 /* Compare local hash entries. */ 979 980 static int 981 elf64_ia64_local_htab_eq (const void *ptr1, const void *ptr2) 982 { 983 struct elf64_ia64_local_hash_entry *entry1 984 = (struct elf64_ia64_local_hash_entry *) ptr1; 985 struct elf64_ia64_local_hash_entry *entry2 986 = (struct elf64_ia64_local_hash_entry *) ptr2; 987 988 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym; 989 } 990 991 /* Free the global elf64_ia64_dyn_sym_info array. */ 992 993 static bool 994 elf64_ia64_global_dyn_info_free (struct elf_link_hash_entry *xentry, 995 void * unused ATTRIBUTE_UNUSED) 996 { 997 struct elf64_ia64_link_hash_entry *entry 998 = (struct elf64_ia64_link_hash_entry *) xentry; 999 1000 if (entry->root.root.type == bfd_link_hash_warning) 1001 entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link; 1002 1003 free (entry->info); 1004 entry->info = NULL; 1005 entry->count = 0; 1006 entry->sorted_count = 0; 1007 entry->size = 0; 1008 1009 return true; 1010 } 1011 1012 /* Free the local elf64_ia64_dyn_sym_info array. */ 1013 1014 static int 1015 elf64_ia64_local_dyn_info_free (void **slot, 1016 void * unused ATTRIBUTE_UNUSED) 1017 { 1018 struct elf64_ia64_local_hash_entry *entry 1019 = (struct elf64_ia64_local_hash_entry *) *slot; 1020 1021 free (entry->info); 1022 entry->info = NULL; 1023 entry->count = 0; 1024 entry->sorted_count = 0; 1025 entry->size = 0; 1026 1027 return true; 1028 } 1029 1030 /* Destroy IA-64 linker hash table. */ 1031 1032 static void 1033 elf64_ia64_link_hash_table_free (bfd *obfd) 1034 { 1035 struct elf64_ia64_link_hash_table *ia64_info 1036 = (struct elf64_ia64_link_hash_table *) obfd->link.hash; 1037 if (ia64_info->loc_hash_table) 1038 { 1039 htab_traverse (ia64_info->loc_hash_table, 1040 elf64_ia64_local_dyn_info_free, NULL); 1041 htab_delete (ia64_info->loc_hash_table); 1042 } 1043 if (ia64_info->loc_hash_memory) 1044 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory); 1045 elf_link_hash_traverse (&ia64_info->root, 1046 elf64_ia64_global_dyn_info_free, NULL); 1047 _bfd_elf_link_hash_table_free (obfd); 1048 } 1049 1050 /* Create the derived linker hash table. The IA-64 ELF port uses this 1051 derived hash table to keep information specific to the IA-64 ElF 1052 linker (without using static variables). */ 1053 1054 static struct bfd_link_hash_table * 1055 elf64_ia64_hash_table_create (bfd *abfd) 1056 { 1057 struct elf64_ia64_link_hash_table *ret; 1058 1059 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret)); 1060 if (!ret) 1061 return NULL; 1062 1063 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 1064 elf64_ia64_new_elf_hash_entry, 1065 sizeof (struct elf64_ia64_link_hash_entry))) 1066 { 1067 free (ret); 1068 return NULL; 1069 } 1070 1071 ret->loc_hash_table = htab_try_create (1024, elf64_ia64_local_htab_hash, 1072 elf64_ia64_local_htab_eq, NULL); 1073 ret->loc_hash_memory = objalloc_create (); 1074 if (!ret->loc_hash_table || !ret->loc_hash_memory) 1075 { 1076 elf64_ia64_link_hash_table_free (abfd); 1077 return NULL; 1078 } 1079 ret->root.root.hash_table_free = elf64_ia64_link_hash_table_free; 1080 1081 return &ret->root.root; 1082 } 1083 1084 /* Traverse both local and global hash tables. */ 1085 1086 struct elf64_ia64_dyn_sym_traverse_data 1087 { 1088 bool (*func) (struct elf64_ia64_dyn_sym_info *, void *); 1089 void * data; 1090 }; 1091 1092 static bool 1093 elf64_ia64_global_dyn_sym_thunk (struct elf_link_hash_entry *xentry, 1094 void * xdata) 1095 { 1096 struct elf64_ia64_link_hash_entry *entry 1097 = (struct elf64_ia64_link_hash_entry *) xentry; 1098 struct elf64_ia64_dyn_sym_traverse_data *data 1099 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata; 1100 struct elf64_ia64_dyn_sym_info *dyn_i; 1101 unsigned int count; 1102 1103 if (entry->root.root.type == bfd_link_hash_warning) 1104 entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link; 1105 1106 for (count = entry->count, dyn_i = entry->info; 1107 count != 0; 1108 count--, dyn_i++) 1109 if (! (*data->func) (dyn_i, data->data)) 1110 return false; 1111 return true; 1112 } 1113 1114 static int 1115 elf64_ia64_local_dyn_sym_thunk (void **slot, void * xdata) 1116 { 1117 struct elf64_ia64_local_hash_entry *entry 1118 = (struct elf64_ia64_local_hash_entry *) *slot; 1119 struct elf64_ia64_dyn_sym_traverse_data *data 1120 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata; 1121 struct elf64_ia64_dyn_sym_info *dyn_i; 1122 unsigned int count; 1123 1124 for (count = entry->count, dyn_i = entry->info; 1125 count != 0; 1126 count--, dyn_i++) 1127 if (! (*data->func) (dyn_i, data->data)) 1128 return false; 1129 return true; 1130 } 1131 1132 static void 1133 elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table *ia64_info, 1134 bool (*func) (struct elf64_ia64_dyn_sym_info *, void *), 1135 void * data) 1136 { 1137 struct elf64_ia64_dyn_sym_traverse_data xdata; 1138 1139 xdata.func = func; 1140 xdata.data = data; 1141 1142 elf_link_hash_traverse (&ia64_info->root, 1143 elf64_ia64_global_dyn_sym_thunk, &xdata); 1144 htab_traverse (ia64_info->loc_hash_table, 1145 elf64_ia64_local_dyn_sym_thunk, &xdata); 1146 } 1147 1148 #define NOTE_NAME "IPF/VMS" 1149 1150 static bool 1151 create_ia64_vms_notes (bfd *abfd, struct bfd_link_info *info, 1152 unsigned int time_hi, unsigned int time_lo) 1153 { 1154 #define NBR_NOTES 7 1155 Elf_Internal_Note notes[NBR_NOTES]; 1156 char *module_name; 1157 int module_name_len; 1158 unsigned char cur_time[8]; 1159 Elf64_External_VMS_ORIG_DYN_Note *orig_dyn; 1160 unsigned int orig_dyn_size; 1161 unsigned int note_size; 1162 int i; 1163 unsigned char *noteptr; 1164 unsigned char *note_contents; 1165 struct elf64_ia64_link_hash_table *ia64_info; 1166 1167 ia64_info = elf64_ia64_hash_table (info); 1168 1169 module_name = vms_get_module_name (bfd_get_filename (abfd), true); 1170 module_name_len = strlen (module_name) + 1; 1171 1172 bfd_putl32 (time_lo, cur_time + 0); 1173 bfd_putl32 (time_hi, cur_time + 4); 1174 1175 /* Note 0: IMGNAM. */ 1176 notes[0].type = NT_VMS_IMGNAM; 1177 notes[0].descdata = module_name; 1178 notes[0].descsz = module_name_len; 1179 1180 /* Note 1: GSTNAM. */ 1181 notes[1].type = NT_VMS_GSTNAM; 1182 notes[1].descdata = module_name; 1183 notes[1].descsz = module_name_len; 1184 1185 /* Note 2: IMGID. */ 1186 #define IMG_ID "V1.0" 1187 notes[2].type = NT_VMS_IMGID; 1188 notes[2].descdata = IMG_ID; 1189 notes[2].descsz = sizeof (IMG_ID); 1190 1191 /* Note 3: Linktime. */ 1192 notes[3].type = NT_VMS_LINKTIME; 1193 notes[3].descdata = (char *)cur_time; 1194 notes[3].descsz = sizeof (cur_time); 1195 1196 /* Note 4: Linker id. */ 1197 notes[4].type = NT_VMS_LINKID; 1198 notes[4].descdata = "GNU ld " BFD_VERSION_STRING; 1199 notes[4].descsz = strlen (notes[4].descdata) + 1; 1200 1201 /* Note 5: Original dyn. */ 1202 orig_dyn_size = (sizeof (*orig_dyn) + sizeof (IMG_ID) - 1 + 7) & ~7; 1203 orig_dyn = bfd_zalloc (abfd, orig_dyn_size); 1204 if (orig_dyn == NULL) 1205 return false; 1206 bfd_putl32 (1, orig_dyn->major_id); 1207 bfd_putl32 (3, orig_dyn->minor_id); 1208 memcpy (orig_dyn->manipulation_date, cur_time, sizeof (cur_time)); 1209 bfd_putl64 (VMS_LF_IMGSTA | VMS_LF_MAIN, orig_dyn->link_flags); 1210 bfd_putl32 (EF_IA_64_ABI64, orig_dyn->elf_flags); 1211 memcpy (orig_dyn->imgid, IMG_ID, sizeof (IMG_ID)); 1212 notes[5].type = NT_VMS_ORIG_DYN; 1213 notes[5].descdata = (char *)orig_dyn; 1214 notes[5].descsz = orig_dyn_size; 1215 1216 /* Note 3: Patchtime. */ 1217 notes[6].type = NT_VMS_PATCHTIME; 1218 notes[6].descdata = (char *)cur_time; 1219 notes[6].descsz = sizeof (cur_time); 1220 1221 /* Compute notes size. */ 1222 note_size = 0; 1223 for (i = 0; i < NBR_NOTES; i++) 1224 note_size += sizeof (Elf64_External_VMS_Note) - 1 1225 + ((sizeof (NOTE_NAME) - 1 + 7) & ~7) 1226 + ((notes[i].descsz + 7) & ~7); 1227 1228 /* Malloc a temporary buffer large enough for most notes */ 1229 note_contents = (unsigned char *) bfd_zalloc (abfd, note_size); 1230 if (note_contents == NULL) 1231 return false; 1232 noteptr = note_contents; 1233 1234 /* Fill notes. */ 1235 for (i = 0; i < NBR_NOTES; i++) 1236 { 1237 Elf64_External_VMS_Note *enote = (Elf64_External_VMS_Note *) noteptr; 1238 1239 bfd_putl64 (sizeof (NOTE_NAME) - 1, enote->namesz); 1240 bfd_putl64 (notes[i].descsz, enote->descsz); 1241 bfd_putl64 (notes[i].type, enote->type); 1242 1243 noteptr = (unsigned char *)enote->name; 1244 memcpy (noteptr, NOTE_NAME, sizeof (NOTE_NAME) - 1); 1245 noteptr += (sizeof (NOTE_NAME) - 1 + 7) & ~7; 1246 memcpy (noteptr, notes[i].descdata, notes[i].descsz); 1247 noteptr += (notes[i].descsz + 7) & ~7; 1248 } 1249 1250 ia64_info->note_sec->contents = note_contents; 1251 ia64_info->note_sec->alloced = 1; 1252 ia64_info->note_sec->size = note_size; 1253 1254 free (module_name); 1255 1256 return true; 1257 } 1258 1259 static bool 1260 elf64_ia64_create_dynamic_sections (bfd *abfd, 1261 struct bfd_link_info *info) 1262 { 1263 struct elf64_ia64_link_hash_table *ia64_info; 1264 asection *s; 1265 flagword flags; 1266 const struct elf_backend_data *bed; 1267 1268 ia64_info = elf64_ia64_hash_table (info); 1269 if (ia64_info == NULL) 1270 return false; 1271 1272 if (elf_hash_table (info)->dynamic_sections_created) 1273 return true; 1274 1275 abfd = elf_hash_table (info)->dynobj; 1276 bed = get_elf_backend_data (abfd); 1277 1278 flags = bed->dynamic_sec_flags; 1279 1280 s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", 1281 flags | SEC_READONLY); 1282 if (s == NULL 1283 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 1284 return false; 1285 1286 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags | SEC_READONLY); 1287 if (s == NULL 1288 || !bfd_set_section_alignment (s, bed->plt_alignment)) 1289 return false; 1290 ia64_info->root.splt = s; 1291 1292 if (!get_got (abfd, ia64_info)) 1293 return false; 1294 1295 if (!get_pltoff (abfd, ia64_info)) 1296 return false; 1297 1298 s = bfd_make_section_anyway_with_flags (abfd, ".vmsdynstr", 1299 (SEC_ALLOC 1300 | SEC_HAS_CONTENTS 1301 | SEC_IN_MEMORY 1302 | SEC_LINKER_CREATED)); 1303 if (s == NULL 1304 || !bfd_set_section_alignment (s, 0)) 1305 return false; 1306 1307 /* Create a fixup section. */ 1308 s = bfd_make_section_anyway_with_flags (abfd, ".fixups", 1309 (SEC_ALLOC 1310 | SEC_HAS_CONTENTS 1311 | SEC_IN_MEMORY 1312 | SEC_LINKER_CREATED)); 1313 if (s == NULL 1314 || !bfd_set_section_alignment (s, 3)) 1315 return false; 1316 ia64_info->fixups_sec = s; 1317 1318 /* Create the transfer fixup section. */ 1319 s = bfd_make_section_anyway_with_flags (abfd, ".transfer", 1320 (SEC_ALLOC 1321 | SEC_HAS_CONTENTS 1322 | SEC_IN_MEMORY 1323 | SEC_LINKER_CREATED)); 1324 if (s == NULL 1325 || !bfd_set_section_alignment (s, 3)) 1326 return false; 1327 s->size = sizeof (struct elf64_vms_transfer); 1328 ia64_info->transfer_sec = s; 1329 1330 /* Create note section. */ 1331 s = bfd_make_section_anyway_with_flags (abfd, ".vms.note", 1332 (SEC_LINKER_CREATED 1333 | SEC_HAS_CONTENTS 1334 | SEC_IN_MEMORY 1335 | SEC_READONLY)); 1336 if (s == NULL 1337 || !bfd_set_section_alignment (s, 3)) 1338 return false; 1339 ia64_info->note_sec = s; 1340 1341 elf_hash_table (info)->dynamic_sections_created = true; 1342 return true; 1343 } 1344 1345 /* Find and/or create a hash entry for local symbol. */ 1346 static struct elf64_ia64_local_hash_entry * 1347 get_local_sym_hash (struct elf64_ia64_link_hash_table *ia64_info, 1348 bfd *abfd, const Elf_Internal_Rela *rel, 1349 bool create) 1350 { 1351 struct elf64_ia64_local_hash_entry e, *ret; 1352 asection *sec = abfd->sections; 1353 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, 1354 ELF64_R_SYM (rel->r_info)); 1355 void **slot; 1356 1357 e.id = sec->id; 1358 e.r_sym = ELF64_R_SYM (rel->r_info); 1359 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h, 1360 create ? INSERT : NO_INSERT); 1361 1362 if (!slot) 1363 return NULL; 1364 1365 if (*slot) 1366 return (struct elf64_ia64_local_hash_entry *) *slot; 1367 1368 ret = (struct elf64_ia64_local_hash_entry *) 1369 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory, 1370 sizeof (struct elf64_ia64_local_hash_entry)); 1371 if (ret) 1372 { 1373 memset (ret, 0, sizeof (*ret)); 1374 ret->id = sec->id; 1375 ret->r_sym = ELF64_R_SYM (rel->r_info); 1376 *slot = ret; 1377 } 1378 return ret; 1379 } 1380 1381 /* Used to sort elf64_ia64_dyn_sym_info array. */ 1382 1383 static int 1384 addend_compare (const void *xp, const void *yp) 1385 { 1386 const struct elf64_ia64_dyn_sym_info *x 1387 = (const struct elf64_ia64_dyn_sym_info *) xp; 1388 const struct elf64_ia64_dyn_sym_info *y 1389 = (const struct elf64_ia64_dyn_sym_info *) yp; 1390 1391 return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0; 1392 } 1393 1394 /* Sort elf64_ia64_dyn_sym_info array and remove duplicates. */ 1395 1396 static unsigned int 1397 sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info *info, 1398 unsigned int count) 1399 { 1400 bfd_vma curr, prev, got_offset; 1401 unsigned int i, kept, dupes, diff, dest, src, len; 1402 1403 qsort (info, count, sizeof (*info), addend_compare); 1404 1405 /* Find the first duplicate. */ 1406 prev = info [0].addend; 1407 got_offset = info [0].got_offset; 1408 for (i = 1; i < count; i++) 1409 { 1410 curr = info [i].addend; 1411 if (curr == prev) 1412 { 1413 /* For duplicates, make sure that GOT_OFFSET is valid. */ 1414 if (got_offset == (bfd_vma) -1) 1415 got_offset = info [i].got_offset; 1416 break; 1417 } 1418 got_offset = info [i].got_offset; 1419 prev = curr; 1420 } 1421 1422 /* We may move a block of elements to here. */ 1423 dest = i++; 1424 1425 /* Remove duplicates. */ 1426 if (i < count) 1427 { 1428 while (i < count) 1429 { 1430 /* For duplicates, make sure that the kept one has a valid 1431 got_offset. */ 1432 kept = dest - 1; 1433 if (got_offset != (bfd_vma) -1) 1434 info [kept].got_offset = got_offset; 1435 1436 curr = info [i].addend; 1437 got_offset = info [i].got_offset; 1438 1439 /* Move a block of elements whose first one is different from 1440 the previous. */ 1441 if (curr == prev) 1442 { 1443 for (src = i + 1; src < count; src++) 1444 { 1445 if (info [src].addend != curr) 1446 break; 1447 /* For duplicates, make sure that GOT_OFFSET is 1448 valid. */ 1449 if (got_offset == (bfd_vma) -1) 1450 got_offset = info [src].got_offset; 1451 } 1452 1453 /* Make sure that the kept one has a valid got_offset. */ 1454 if (got_offset != (bfd_vma) -1) 1455 info [kept].got_offset = got_offset; 1456 } 1457 else 1458 src = i; 1459 1460 if (src >= count) 1461 break; 1462 1463 /* Find the next duplicate. SRC will be kept. */ 1464 prev = info [src].addend; 1465 got_offset = info [src].got_offset; 1466 for (dupes = src + 1; dupes < count; dupes ++) 1467 { 1468 curr = info [dupes].addend; 1469 if (curr == prev) 1470 { 1471 /* Make sure that got_offset is valid. */ 1472 if (got_offset == (bfd_vma) -1) 1473 got_offset = info [dupes].got_offset; 1474 1475 /* For duplicates, make sure that the kept one has 1476 a valid got_offset. */ 1477 if (got_offset != (bfd_vma) -1) 1478 info [dupes - 1].got_offset = got_offset; 1479 break; 1480 } 1481 got_offset = info [dupes].got_offset; 1482 prev = curr; 1483 } 1484 1485 /* How much to move. */ 1486 len = dupes - src; 1487 i = dupes + 1; 1488 1489 if (len == 1 && dupes < count) 1490 { 1491 /* If we only move 1 element, we combine it with the next 1492 one. There must be at least a duplicate. Find the 1493 next different one. */ 1494 for (diff = dupes + 1, src++; diff < count; diff++, src++) 1495 { 1496 if (info [diff].addend != curr) 1497 break; 1498 /* Make sure that got_offset is valid. */ 1499 if (got_offset == (bfd_vma) -1) 1500 got_offset = info [diff].got_offset; 1501 } 1502 1503 /* Makre sure that the last duplicated one has an valid 1504 offset. */ 1505 BFD_ASSERT (curr == prev); 1506 if (got_offset != (bfd_vma) -1) 1507 info [diff - 1].got_offset = got_offset; 1508 1509 if (diff < count) 1510 { 1511 /* Find the next duplicate. Track the current valid 1512 offset. */ 1513 prev = info [diff].addend; 1514 got_offset = info [diff].got_offset; 1515 for (dupes = diff + 1; dupes < count; dupes ++) 1516 { 1517 curr = info [dupes].addend; 1518 if (curr == prev) 1519 { 1520 /* For duplicates, make sure that GOT_OFFSET 1521 is valid. */ 1522 if (got_offset == (bfd_vma) -1) 1523 got_offset = info [dupes].got_offset; 1524 break; 1525 } 1526 got_offset = info [dupes].got_offset; 1527 prev = curr; 1528 diff++; 1529 } 1530 1531 len = diff - src + 1; 1532 i = diff + 1; 1533 } 1534 } 1535 1536 memmove (&info [dest], &info [src], len * sizeof (*info)); 1537 1538 dest += len; 1539 } 1540 1541 count = dest; 1542 } 1543 else 1544 { 1545 /* When we get here, either there is no duplicate at all or 1546 the only duplicate is the last element. */ 1547 if (dest < count) 1548 { 1549 /* If the last element is a duplicate, make sure that the 1550 kept one has a valid got_offset. We also update count. */ 1551 if (got_offset != (bfd_vma) -1) 1552 info [dest - 1].got_offset = got_offset; 1553 count = dest; 1554 } 1555 } 1556 1557 return count; 1558 } 1559 1560 /* Find and/or create a descriptor for dynamic symbol info. This will 1561 vary based on global or local symbol, and the addend to the reloc. 1562 1563 We don't sort when inserting. Also, we sort and eliminate 1564 duplicates if there is an unsorted section. Typically, this will 1565 only happen once, because we do all insertions before lookups. We 1566 then use bsearch to do a lookup. This also allows lookups to be 1567 fast. So we have fast insertion (O(log N) due to duplicate check), 1568 fast lookup (O(log N)) and one sort (O(N log N) expected time). 1569 Previously, all lookups were O(N) because of the use of the linked 1570 list and also all insertions were O(N) because of the check for 1571 duplicates. There are some complications here because the array 1572 size grows occasionally, which may add an O(N) factor, but this 1573 should be rare. Also, we free the excess array allocation, which 1574 requires a copy which is O(N), but this only happens once. */ 1575 1576 static struct elf64_ia64_dyn_sym_info * 1577 get_dyn_sym_info (struct elf64_ia64_link_hash_table *ia64_info, 1578 struct elf_link_hash_entry *h, bfd *abfd, 1579 const Elf_Internal_Rela *rel, bool create) 1580 { 1581 struct elf64_ia64_dyn_sym_info **info_p, *info, *dyn_i, key; 1582 unsigned int *count_p, *sorted_count_p, *size_p; 1583 unsigned int count, sorted_count, size; 1584 bfd_vma addend = rel ? rel->r_addend : 0; 1585 bfd_size_type amt; 1586 1587 if (h) 1588 { 1589 struct elf64_ia64_link_hash_entry *global_h; 1590 1591 global_h = (struct elf64_ia64_link_hash_entry *) h; 1592 info_p = &global_h->info; 1593 count_p = &global_h->count; 1594 sorted_count_p = &global_h->sorted_count; 1595 size_p = &global_h->size; 1596 } 1597 else 1598 { 1599 struct elf64_ia64_local_hash_entry *loc_h; 1600 1601 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create); 1602 if (!loc_h) 1603 { 1604 BFD_ASSERT (!create); 1605 return NULL; 1606 } 1607 1608 info_p = &loc_h->info; 1609 count_p = &loc_h->count; 1610 sorted_count_p = &loc_h->sorted_count; 1611 size_p = &loc_h->size; 1612 } 1613 1614 count = *count_p; 1615 sorted_count = *sorted_count_p; 1616 size = *size_p; 1617 info = *info_p; 1618 if (create) 1619 { 1620 /* When we create the array, we don't check for duplicates, 1621 except in the previously sorted section if one exists, and 1622 against the last inserted entry. This allows insertions to 1623 be fast. */ 1624 if (info) 1625 { 1626 if (sorted_count) 1627 { 1628 /* Try bsearch first on the sorted section. */ 1629 key.addend = addend; 1630 dyn_i = bsearch (&key, info, sorted_count, 1631 sizeof (*info), addend_compare); 1632 1633 if (dyn_i) 1634 { 1635 return dyn_i; 1636 } 1637 } 1638 1639 /* Do a quick check for the last inserted entry. */ 1640 dyn_i = info + count - 1; 1641 if (dyn_i->addend == addend) 1642 { 1643 return dyn_i; 1644 } 1645 } 1646 1647 if (size == 0) 1648 { 1649 /* It is the very first element. We create the array of size 1650 1. */ 1651 size = 1; 1652 amt = size * sizeof (*info); 1653 info = bfd_malloc (amt); 1654 } 1655 else if (size <= count) 1656 { 1657 /* We double the array size every time when we reach the 1658 size limit. */ 1659 size += size; 1660 amt = size * sizeof (*info); 1661 info = bfd_realloc (info, amt); 1662 } 1663 else 1664 goto has_space; 1665 1666 if (info == NULL) 1667 return NULL; 1668 *size_p = size; 1669 *info_p = info; 1670 1671 has_space: 1672 /* Append the new one to the array. */ 1673 dyn_i = info + count; 1674 memset (dyn_i, 0, sizeof (*dyn_i)); 1675 dyn_i->got_offset = (bfd_vma) -1; 1676 dyn_i->addend = addend; 1677 1678 /* We increment count only since the new ones are unsorted and 1679 may have duplicate. */ 1680 (*count_p)++; 1681 } 1682 else 1683 { 1684 /* It is a lookup without insertion. Sort array if part of the 1685 array isn't sorted. */ 1686 if (count != sorted_count) 1687 { 1688 count = sort_dyn_sym_info (info, count); 1689 *count_p = count; 1690 *sorted_count_p = count; 1691 } 1692 1693 /* Free unused memory. */ 1694 if (size != count) 1695 { 1696 amt = count * sizeof (*info); 1697 info = bfd_malloc (amt); 1698 if (info != NULL) 1699 { 1700 memcpy (info, *info_p, amt); 1701 free (*info_p); 1702 *size_p = count; 1703 *info_p = info; 1704 } 1705 } 1706 1707 key.addend = addend; 1708 dyn_i = bsearch (&key, info, count, 1709 sizeof (*info), addend_compare); 1710 } 1711 1712 return dyn_i; 1713 } 1714 1715 static asection * 1716 get_got (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info) 1717 { 1718 asection *got; 1719 bfd *dynobj; 1720 1721 got = ia64_info->root.sgot; 1722 if (!got) 1723 { 1724 flagword flags; 1725 1726 dynobj = ia64_info->root.dynobj; 1727 if (!dynobj) 1728 ia64_info->root.dynobj = dynobj = abfd; 1729 1730 /* The .got section is always aligned at 8 bytes. */ 1731 flags = get_elf_backend_data (dynobj)->dynamic_sec_flags; 1732 got = bfd_make_section_anyway_with_flags (dynobj, ".got", 1733 flags | SEC_SMALL_DATA); 1734 if (got == NULL 1735 || !bfd_set_section_alignment (got, 3)) 1736 return NULL; 1737 ia64_info->root.sgot = got; 1738 } 1739 1740 return got; 1741 } 1742 1743 /* Create function descriptor section (.opd). This section is called .opd 1744 because it contains "official procedure descriptors". The "official" 1745 refers to the fact that these descriptors are used when taking the address 1746 of a procedure, thus ensuring a unique address for each procedure. */ 1747 1748 static asection * 1749 get_fptr (bfd *abfd, struct bfd_link_info *info, 1750 struct elf64_ia64_link_hash_table *ia64_info) 1751 { 1752 asection *fptr; 1753 bfd *dynobj; 1754 1755 fptr = ia64_info->fptr_sec; 1756 if (!fptr) 1757 { 1758 dynobj = ia64_info->root.dynobj; 1759 if (!dynobj) 1760 ia64_info->root.dynobj = dynobj = abfd; 1761 1762 fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd", 1763 (SEC_ALLOC 1764 | SEC_LOAD 1765 | SEC_HAS_CONTENTS 1766 | SEC_IN_MEMORY 1767 | (bfd_link_pie (info) ? 0 1768 : SEC_READONLY) 1769 | SEC_LINKER_CREATED)); 1770 if (!fptr 1771 || !bfd_set_section_alignment (fptr, 4)) 1772 { 1773 BFD_ASSERT (0); 1774 return NULL; 1775 } 1776 1777 ia64_info->fptr_sec = fptr; 1778 1779 if (bfd_link_pie (info)) 1780 { 1781 asection *fptr_rel; 1782 fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd", 1783 (SEC_ALLOC | SEC_LOAD 1784 | SEC_HAS_CONTENTS 1785 | SEC_IN_MEMORY 1786 | SEC_LINKER_CREATED 1787 | SEC_READONLY)); 1788 if (fptr_rel == NULL 1789 || !bfd_set_section_alignment (fptr_rel, 3)) 1790 { 1791 BFD_ASSERT (0); 1792 return NULL; 1793 } 1794 1795 ia64_info->rel_fptr_sec = fptr_rel; 1796 } 1797 } 1798 1799 return fptr; 1800 } 1801 1802 static asection * 1803 get_pltoff (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info) 1804 { 1805 asection *pltoff; 1806 bfd *dynobj; 1807 1808 pltoff = ia64_info->pltoff_sec; 1809 if (!pltoff) 1810 { 1811 dynobj = ia64_info->root.dynobj; 1812 if (!dynobj) 1813 ia64_info->root.dynobj = dynobj = abfd; 1814 1815 pltoff = bfd_make_section_anyway_with_flags (dynobj, 1816 ELF_STRING_ia64_pltoff, 1817 (SEC_ALLOC 1818 | SEC_LOAD 1819 | SEC_HAS_CONTENTS 1820 | SEC_IN_MEMORY 1821 | SEC_SMALL_DATA 1822 | SEC_LINKER_CREATED)); 1823 if (!pltoff 1824 || !bfd_set_section_alignment (pltoff, 4)) 1825 { 1826 BFD_ASSERT (0); 1827 return NULL; 1828 } 1829 1830 ia64_info->pltoff_sec = pltoff; 1831 } 1832 1833 return pltoff; 1834 } 1835 1836 static asection * 1837 get_reloc_section (bfd *abfd, 1838 struct elf64_ia64_link_hash_table *ia64_info, 1839 asection *sec, bool create) 1840 { 1841 const char *srel_name; 1842 asection *srel; 1843 bfd *dynobj; 1844 1845 srel_name = (bfd_elf_string_from_elf_section 1846 (abfd, elf_elfheader(abfd)->e_shstrndx, 1847 _bfd_elf_single_rel_hdr (sec)->sh_name)); 1848 if (srel_name == NULL) 1849 return NULL; 1850 1851 BFD_ASSERT ((startswith (srel_name, ".rela") 1852 && strcmp (bfd_section_name (sec), srel_name+5) == 0) 1853 || (startswith (srel_name, ".rel") 1854 && strcmp (bfd_section_name (sec), srel_name+4) == 0)); 1855 1856 dynobj = ia64_info->root.dynobj; 1857 if (!dynobj) 1858 ia64_info->root.dynobj = dynobj = abfd; 1859 1860 srel = bfd_get_linker_section (dynobj, srel_name); 1861 if (srel == NULL && create) 1862 { 1863 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name, 1864 (SEC_ALLOC | SEC_LOAD 1865 | SEC_HAS_CONTENTS 1866 | SEC_IN_MEMORY 1867 | SEC_LINKER_CREATED 1868 | SEC_READONLY)); 1869 if (srel == NULL 1870 || !bfd_set_section_alignment (srel, 3)) 1871 return NULL; 1872 } 1873 1874 return srel; 1875 } 1876 1877 static bool 1878 count_dyn_reloc (bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i, 1879 asection *srel, int type) 1880 { 1881 struct elf64_ia64_dyn_reloc_entry *rent; 1882 1883 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 1884 if (rent->srel == srel && rent->type == type) 1885 break; 1886 1887 if (!rent) 1888 { 1889 rent = ((struct elf64_ia64_dyn_reloc_entry *) 1890 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent))); 1891 if (!rent) 1892 return false; 1893 1894 rent->next = dyn_i->reloc_entries; 1895 rent->srel = srel; 1896 rent->type = type; 1897 rent->count = 0; 1898 dyn_i->reloc_entries = rent; 1899 } 1900 rent->count++; 1901 1902 return true; 1903 } 1904 1905 static bool 1906 elf64_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info, 1907 asection *sec, 1908 const Elf_Internal_Rela *relocs) 1909 { 1910 struct elf64_ia64_link_hash_table *ia64_info; 1911 const Elf_Internal_Rela *relend; 1912 Elf_Internal_Shdr *symtab_hdr; 1913 const Elf_Internal_Rela *rel; 1914 asection *got, *fptr, *srel, *pltoff; 1915 enum { 1916 NEED_GOT = 1, 1917 NEED_GOTX = 2, 1918 NEED_FPTR = 4, 1919 NEED_PLTOFF = 8, 1920 NEED_MIN_PLT = 16, 1921 NEED_FULL_PLT = 32, 1922 NEED_DYNREL = 64, 1923 NEED_LTOFF_FPTR = 128 1924 }; 1925 int need_entry; 1926 struct elf_link_hash_entry *h; 1927 unsigned long r_symndx; 1928 bool maybe_dynamic; 1929 1930 if (bfd_link_relocatable (info)) 1931 return true; 1932 1933 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1934 ia64_info = elf64_ia64_hash_table (info); 1935 if (ia64_info == NULL) 1936 return false; 1937 1938 got = fptr = srel = pltoff = NULL; 1939 1940 relend = relocs + sec->reloc_count; 1941 1942 /* We scan relocations first to create dynamic relocation arrays. We 1943 modified get_dyn_sym_info to allow fast insertion and support fast 1944 lookup in the next loop. */ 1945 for (rel = relocs; rel < relend; ++rel) 1946 { 1947 r_symndx = ELF64_R_SYM (rel->r_info); 1948 if (r_symndx >= symtab_hdr->sh_info) 1949 { 1950 long indx = r_symndx - symtab_hdr->sh_info; 1951 h = elf_sym_hashes (abfd)[indx]; 1952 while (h->root.type == bfd_link_hash_indirect 1953 || h->root.type == bfd_link_hash_warning) 1954 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1955 } 1956 else 1957 h = NULL; 1958 1959 /* We can only get preliminary data on whether a symbol is 1960 locally or externally defined, as not all of the input files 1961 have yet been processed. Do something with what we know, as 1962 this may help reduce memory usage and processing time later. */ 1963 maybe_dynamic = (h && ((!bfd_link_executable (info) 1964 && (!SYMBOLIC_BIND (info, h) 1965 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 1966 || !h->def_regular 1967 || h->root.type == bfd_link_hash_defweak)); 1968 1969 need_entry = 0; 1970 switch (ELF64_R_TYPE (rel->r_info)) 1971 { 1972 case R_IA64_TPREL64MSB: 1973 case R_IA64_TPREL64LSB: 1974 case R_IA64_LTOFF_TPREL22: 1975 case R_IA64_DTPREL32MSB: 1976 case R_IA64_DTPREL32LSB: 1977 case R_IA64_DTPREL64MSB: 1978 case R_IA64_DTPREL64LSB: 1979 case R_IA64_LTOFF_DTPREL22: 1980 case R_IA64_DTPMOD64MSB: 1981 case R_IA64_DTPMOD64LSB: 1982 case R_IA64_LTOFF_DTPMOD22: 1983 abort (); 1984 break; 1985 1986 case R_IA64_IPLTMSB: 1987 case R_IA64_IPLTLSB: 1988 break; 1989 1990 case R_IA64_LTOFF_FPTR22: 1991 case R_IA64_LTOFF_FPTR64I: 1992 case R_IA64_LTOFF_FPTR32MSB: 1993 case R_IA64_LTOFF_FPTR32LSB: 1994 case R_IA64_LTOFF_FPTR64MSB: 1995 case R_IA64_LTOFF_FPTR64LSB: 1996 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; 1997 break; 1998 1999 case R_IA64_FPTR64I: 2000 case R_IA64_FPTR32MSB: 2001 case R_IA64_FPTR32LSB: 2002 case R_IA64_FPTR64MSB: 2003 case R_IA64_FPTR64LSB: 2004 if (bfd_link_pic (info) || h) 2005 need_entry = NEED_FPTR | NEED_DYNREL; 2006 else 2007 need_entry = NEED_FPTR; 2008 break; 2009 2010 case R_IA64_LTOFF22: 2011 case R_IA64_LTOFF64I: 2012 need_entry = NEED_GOT; 2013 break; 2014 2015 case R_IA64_LTOFF22X: 2016 need_entry = NEED_GOTX; 2017 break; 2018 2019 case R_IA64_PLTOFF22: 2020 case R_IA64_PLTOFF64I: 2021 case R_IA64_PLTOFF64MSB: 2022 case R_IA64_PLTOFF64LSB: 2023 need_entry = NEED_PLTOFF; 2024 if (h) 2025 { 2026 if (maybe_dynamic) 2027 need_entry |= NEED_MIN_PLT; 2028 } 2029 else 2030 { 2031 (*info->callbacks->warning) 2032 (info, _("@pltoff reloc against local symbol"), 0, 2033 abfd, 0, (bfd_vma) 0); 2034 } 2035 break; 2036 2037 case R_IA64_PCREL21B: 2038 case R_IA64_PCREL60B: 2039 /* Depending on where this symbol is defined, we may or may not 2040 need a full plt entry. Only skip if we know we'll not need 2041 the entry -- static or symbolic, and the symbol definition 2042 has already been seen. */ 2043 if (maybe_dynamic && rel->r_addend == 0) 2044 need_entry = NEED_FULL_PLT; 2045 break; 2046 2047 case R_IA64_IMM14: 2048 case R_IA64_IMM22: 2049 case R_IA64_IMM64: 2050 case R_IA64_DIR32MSB: 2051 case R_IA64_DIR32LSB: 2052 case R_IA64_DIR64MSB: 2053 case R_IA64_DIR64LSB: 2054 /* Shared objects will always need at least a REL relocation. */ 2055 if (bfd_link_pic (info) || maybe_dynamic) 2056 need_entry = NEED_DYNREL; 2057 break; 2058 2059 case R_IA64_PCREL22: 2060 case R_IA64_PCREL64I: 2061 case R_IA64_PCREL32MSB: 2062 case R_IA64_PCREL32LSB: 2063 case R_IA64_PCREL64MSB: 2064 case R_IA64_PCREL64LSB: 2065 if (maybe_dynamic) 2066 need_entry = NEED_DYNREL; 2067 break; 2068 } 2069 2070 if (!need_entry) 2071 continue; 2072 2073 if ((need_entry & NEED_FPTR) != 0 2074 && rel->r_addend) 2075 { 2076 (*info->callbacks->warning) 2077 (info, _("non-zero addend in @fptr reloc"), 0, 2078 abfd, 0, (bfd_vma) 0); 2079 } 2080 2081 if (get_dyn_sym_info (ia64_info, h, abfd, rel, true) == NULL) 2082 return false; 2083 } 2084 2085 /* Now, we only do lookup without insertion, which is very fast 2086 with the modified get_dyn_sym_info. */ 2087 for (rel = relocs; rel < relend; ++rel) 2088 { 2089 struct elf64_ia64_dyn_sym_info *dyn_i; 2090 int dynrel_type = R_IA64_NONE; 2091 2092 r_symndx = ELF64_R_SYM (rel->r_info); 2093 if (r_symndx >= symtab_hdr->sh_info) 2094 { 2095 /* We're dealing with a global symbol -- find its hash entry 2096 and mark it as being referenced. */ 2097 long indx = r_symndx - symtab_hdr->sh_info; 2098 h = elf_sym_hashes (abfd)[indx]; 2099 while (h->root.type == bfd_link_hash_indirect 2100 || h->root.type == bfd_link_hash_warning) 2101 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2102 2103 /* PR15323, ref flags aren't set for references in the same 2104 object. */ 2105 h->ref_regular = 1; 2106 } 2107 else 2108 h = NULL; 2109 2110 /* We can only get preliminary data on whether a symbol is 2111 locally or externally defined, as not all of the input files 2112 have yet been processed. Do something with what we know, as 2113 this may help reduce memory usage and processing time later. */ 2114 maybe_dynamic = (h && ((!bfd_link_executable (info) 2115 && (!SYMBOLIC_BIND (info, h) 2116 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 2117 || !h->def_regular 2118 || h->root.type == bfd_link_hash_defweak)); 2119 2120 need_entry = 0; 2121 switch (ELF64_R_TYPE (rel->r_info)) 2122 { 2123 case R_IA64_TPREL64MSB: 2124 case R_IA64_TPREL64LSB: 2125 case R_IA64_LTOFF_TPREL22: 2126 case R_IA64_DTPREL32MSB: 2127 case R_IA64_DTPREL32LSB: 2128 case R_IA64_DTPREL64MSB: 2129 case R_IA64_DTPREL64LSB: 2130 case R_IA64_LTOFF_DTPREL22: 2131 case R_IA64_DTPMOD64MSB: 2132 case R_IA64_DTPMOD64LSB: 2133 case R_IA64_LTOFF_DTPMOD22: 2134 abort (); 2135 break; 2136 2137 case R_IA64_LTOFF_FPTR22: 2138 case R_IA64_LTOFF_FPTR64I: 2139 case R_IA64_LTOFF_FPTR32MSB: 2140 case R_IA64_LTOFF_FPTR32LSB: 2141 case R_IA64_LTOFF_FPTR64MSB: 2142 case R_IA64_LTOFF_FPTR64LSB: 2143 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; 2144 break; 2145 2146 case R_IA64_FPTR64I: 2147 case R_IA64_FPTR32MSB: 2148 case R_IA64_FPTR32LSB: 2149 case R_IA64_FPTR64MSB: 2150 case R_IA64_FPTR64LSB: 2151 if (bfd_link_pic (info) || h) 2152 need_entry = NEED_FPTR | NEED_DYNREL; 2153 else 2154 need_entry = NEED_FPTR; 2155 dynrel_type = R_IA64_FPTR64LSB; 2156 break; 2157 2158 case R_IA64_LTOFF22: 2159 case R_IA64_LTOFF64I: 2160 need_entry = NEED_GOT; 2161 break; 2162 2163 case R_IA64_LTOFF22X: 2164 need_entry = NEED_GOTX; 2165 break; 2166 2167 case R_IA64_PLTOFF22: 2168 case R_IA64_PLTOFF64I: 2169 case R_IA64_PLTOFF64MSB: 2170 case R_IA64_PLTOFF64LSB: 2171 need_entry = NEED_PLTOFF; 2172 if (h) 2173 { 2174 if (maybe_dynamic) 2175 need_entry |= NEED_MIN_PLT; 2176 } 2177 break; 2178 2179 case R_IA64_PCREL21B: 2180 case R_IA64_PCREL60B: 2181 /* Depending on where this symbol is defined, we may or may not 2182 need a full plt entry. Only skip if we know we'll not need 2183 the entry -- static or symbolic, and the symbol definition 2184 has already been seen. */ 2185 if (maybe_dynamic && rel->r_addend == 0) 2186 need_entry = NEED_FULL_PLT; 2187 break; 2188 2189 case R_IA64_IMM14: 2190 case R_IA64_IMM22: 2191 case R_IA64_IMM64: 2192 case R_IA64_DIR32MSB: 2193 case R_IA64_DIR32LSB: 2194 case R_IA64_DIR64MSB: 2195 case R_IA64_DIR64LSB: 2196 /* Shared objects will always need at least a REL relocation. */ 2197 if (bfd_link_pic (info) || maybe_dynamic) 2198 need_entry = NEED_DYNREL; 2199 dynrel_type = R_IA64_DIR64LSB; 2200 break; 2201 2202 case R_IA64_IPLTMSB: 2203 case R_IA64_IPLTLSB: 2204 break; 2205 2206 case R_IA64_PCREL22: 2207 case R_IA64_PCREL64I: 2208 case R_IA64_PCREL32MSB: 2209 case R_IA64_PCREL32LSB: 2210 case R_IA64_PCREL64MSB: 2211 case R_IA64_PCREL64LSB: 2212 if (maybe_dynamic) 2213 need_entry = NEED_DYNREL; 2214 dynrel_type = R_IA64_PCREL64LSB; 2215 break; 2216 } 2217 2218 if (!need_entry) 2219 continue; 2220 2221 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, false); 2222 2223 /* Record whether or not this is a local symbol. */ 2224 dyn_i->h = h; 2225 2226 /* Create what's needed. */ 2227 if (need_entry & (NEED_GOT | NEED_GOTX)) 2228 { 2229 if (!got) 2230 { 2231 got = get_got (abfd, ia64_info); 2232 if (!got) 2233 return false; 2234 } 2235 if (need_entry & NEED_GOT) 2236 dyn_i->want_got = 1; 2237 if (need_entry & NEED_GOTX) 2238 dyn_i->want_gotx = 1; 2239 } 2240 if (need_entry & NEED_FPTR) 2241 { 2242 /* Create the .opd section. */ 2243 if (!fptr) 2244 { 2245 fptr = get_fptr (abfd, info, ia64_info); 2246 if (!fptr) 2247 return false; 2248 } 2249 dyn_i->want_fptr = 1; 2250 } 2251 if (need_entry & NEED_LTOFF_FPTR) 2252 dyn_i->want_ltoff_fptr = 1; 2253 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT)) 2254 { 2255 if (!ia64_info->root.dynobj) 2256 ia64_info->root.dynobj = abfd; 2257 h->needs_plt = 1; 2258 dyn_i->want_plt = 1; 2259 } 2260 if (need_entry & NEED_FULL_PLT) 2261 dyn_i->want_plt2 = 1; 2262 if (need_entry & NEED_PLTOFF) 2263 { 2264 /* This is needed here, in case @pltoff is used in a non-shared 2265 link. */ 2266 if (!pltoff) 2267 { 2268 pltoff = get_pltoff (abfd, ia64_info); 2269 if (!pltoff) 2270 return false; 2271 } 2272 2273 dyn_i->want_pltoff = 1; 2274 } 2275 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) 2276 { 2277 if (!srel) 2278 { 2279 srel = get_reloc_section (abfd, ia64_info, sec, true); 2280 if (!srel) 2281 return false; 2282 } 2283 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type)) 2284 return false; 2285 } 2286 } 2287 2288 return true; 2289 } 2290 2291 /* For cleanliness, and potentially faster dynamic loading, allocate 2292 external GOT entries first. */ 2293 2294 static bool 2295 allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i, 2296 void * data) 2297 { 2298 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; 2299 2300 if ((dyn_i->want_got || dyn_i->want_gotx) 2301 && ! dyn_i->want_fptr 2302 && elf64_ia64_dynamic_symbol_p (dyn_i->h)) 2303 { 2304 /* GOT entry with FPTR is done by allocate_global_fptr_got. */ 2305 dyn_i->got_offset = x->ofs; 2306 x->ofs += 8; 2307 } 2308 return true; 2309 } 2310 2311 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */ 2312 2313 static bool 2314 allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i, 2315 void * data) 2316 { 2317 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; 2318 2319 if (dyn_i->want_got 2320 && dyn_i->want_fptr 2321 && elf64_ia64_dynamic_symbol_p (dyn_i->h)) 2322 { 2323 dyn_i->got_offset = x->ofs; 2324 x->ofs += 8; 2325 } 2326 return true; 2327 } 2328 2329 /* Lastly, allocate all the GOT entries for local data. */ 2330 2331 static bool 2332 allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i, 2333 void * data) 2334 { 2335 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data; 2336 2337 if ((dyn_i->want_got || dyn_i->want_gotx) 2338 && !elf64_ia64_dynamic_symbol_p (dyn_i->h)) 2339 { 2340 dyn_i->got_offset = x->ofs; 2341 x->ofs += 8; 2342 } 2343 return true; 2344 } 2345 2346 /* Allocate function descriptors. We can do these for every function 2347 in a main executable that is not exported. */ 2348 2349 static bool 2350 allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data) 2351 { 2352 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data; 2353 2354 if (dyn_i->want_fptr) 2355 { 2356 struct elf_link_hash_entry *h = dyn_i->h; 2357 2358 if (h) 2359 while (h->root.type == bfd_link_hash_indirect 2360 || h->root.type == bfd_link_hash_warning) 2361 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2362 2363 if (h == NULL || !h->def_dynamic) 2364 { 2365 /* A non dynamic symbol. */ 2366 dyn_i->fptr_offset = x->ofs; 2367 x->ofs += 16; 2368 } 2369 else 2370 dyn_i->want_fptr = 0; 2371 } 2372 return true; 2373 } 2374 2375 /* Allocate all the minimal PLT entries. */ 2376 2377 static bool 2378 allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i, 2379 void * data ATTRIBUTE_UNUSED) 2380 { 2381 if (dyn_i->want_plt) 2382 { 2383 struct elf_link_hash_entry *h = dyn_i->h; 2384 2385 if (h) 2386 while (h->root.type == bfd_link_hash_indirect 2387 || h->root.type == bfd_link_hash_warning) 2388 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2389 2390 /* ??? Versioned symbols seem to lose NEEDS_PLT. */ 2391 if (elf64_ia64_dynamic_symbol_p (h)) 2392 { 2393 dyn_i->want_pltoff = 1; 2394 } 2395 else 2396 { 2397 dyn_i->want_plt = 0; 2398 dyn_i->want_plt2 = 0; 2399 } 2400 } 2401 return true; 2402 } 2403 2404 /* Allocate all the full PLT entries. */ 2405 2406 static bool 2407 allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i, 2408 void * data) 2409 { 2410 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; 2411 2412 if (dyn_i->want_plt2) 2413 { 2414 struct elf_link_hash_entry *h = dyn_i->h; 2415 bfd_size_type ofs = x->ofs; 2416 2417 dyn_i->plt2_offset = ofs; 2418 x->ofs = ofs + PLT_FULL_ENTRY_SIZE; 2419 2420 while (h->root.type == bfd_link_hash_indirect 2421 || h->root.type == bfd_link_hash_warning) 2422 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2423 dyn_i->h->plt.offset = ofs; 2424 } 2425 return true; 2426 } 2427 2428 /* Allocate all the PLTOFF entries requested by relocations and 2429 plt entries. We can't share space with allocated FPTR entries, 2430 because the latter are not necessarily addressable by the GP. 2431 ??? Relaxation might be able to determine that they are. */ 2432 2433 static bool 2434 allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i, 2435 void * data) 2436 { 2437 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; 2438 2439 if (dyn_i->want_pltoff) 2440 { 2441 dyn_i->pltoff_offset = x->ofs; 2442 x->ofs += 16; 2443 } 2444 return true; 2445 } 2446 2447 /* Allocate dynamic relocations for those symbols that turned out 2448 to be dynamic. */ 2449 2450 static bool 2451 allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i, 2452 void * data) 2453 { 2454 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; 2455 struct elf64_ia64_link_hash_table *ia64_info; 2456 struct elf64_ia64_dyn_reloc_entry *rent; 2457 bool dynamic_symbol, shared, resolved_zero; 2458 struct elf64_ia64_link_hash_entry *h_ia64; 2459 2460 ia64_info = elf64_ia64_hash_table (x->info); 2461 if (ia64_info == NULL) 2462 return false; 2463 2464 /* Note that this can't be used in relation to FPTR relocs below. */ 2465 dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h); 2466 2467 shared = bfd_link_pic (x->info); 2468 resolved_zero = (dyn_i->h 2469 && ELF_ST_VISIBILITY (dyn_i->h->other) 2470 && dyn_i->h->root.type == bfd_link_hash_undefweak); 2471 2472 /* Take care of the GOT and PLT relocations. */ 2473 2474 if ((!resolved_zero 2475 && (dynamic_symbol || shared) 2476 && (dyn_i->want_got || dyn_i->want_gotx)) 2477 || (dyn_i->want_ltoff_fptr 2478 && dyn_i->h 2479 && dyn_i->h->def_dynamic)) 2480 { 2481 /* VMS: FIX64. */ 2482 if (dyn_i->h != NULL && dyn_i->h->def_dynamic) 2483 { 2484 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; 2485 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += 2486 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2487 ia64_info->fixups_sec->size += 2488 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2489 } 2490 } 2491 2492 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr) 2493 { 2494 /* VMS: only image reloc. */ 2495 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak) 2496 ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela); 2497 } 2498 2499 if (!resolved_zero && dyn_i->want_pltoff) 2500 { 2501 /* VMS: FIXFD. */ 2502 if (dyn_i->h != NULL && dyn_i->h->def_dynamic) 2503 { 2504 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; 2505 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += 2506 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2507 ia64_info->fixups_sec->size += 2508 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2509 } 2510 } 2511 2512 /* Take care of the normal data relocations. */ 2513 2514 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 2515 { 2516 switch (rent->type) 2517 { 2518 case R_IA64_FPTR32LSB: 2519 case R_IA64_FPTR64LSB: 2520 /* Allocate one iff !want_fptr and not PIE, which by this point 2521 will be true only if we're actually allocating one statically 2522 in the main executable. Position independent executables 2523 need a relative reloc. */ 2524 if (dyn_i->want_fptr && !bfd_link_pie (x->info)) 2525 continue; 2526 break; 2527 case R_IA64_PCREL32LSB: 2528 case R_IA64_PCREL64LSB: 2529 if (!dynamic_symbol) 2530 continue; 2531 break; 2532 case R_IA64_DIR32LSB: 2533 case R_IA64_DIR64LSB: 2534 if (!dynamic_symbol && !shared) 2535 continue; 2536 break; 2537 case R_IA64_IPLTLSB: 2538 if (!dynamic_symbol && !shared) 2539 continue; 2540 break; 2541 case R_IA64_DTPREL32LSB: 2542 case R_IA64_TPREL64LSB: 2543 case R_IA64_DTPREL64LSB: 2544 case R_IA64_DTPMOD64LSB: 2545 break; 2546 default: 2547 abort (); 2548 } 2549 2550 /* Add a fixup. */ 2551 if (!dynamic_symbol) 2552 abort (); 2553 2554 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; 2555 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += 2556 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2557 ia64_info->fixups_sec->size += 2558 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2559 } 2560 2561 return true; 2562 } 2563 2564 static bool 2565 elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, 2566 struct elf_link_hash_entry *h) 2567 { 2568 /* ??? Undefined symbols with PLT entries should be re-defined 2569 to be the PLT entry. */ 2570 2571 /* If this is a weak symbol, and there is a real definition, the 2572 processor independent code will have arranged for us to see the 2573 real definition first, and we can just use the same value. */ 2574 if (h->is_weakalias) 2575 { 2576 struct elf_link_hash_entry *def = weakdef (h); 2577 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2578 h->root.u.def.section = def->root.u.def.section; 2579 h->root.u.def.value = def->root.u.def.value; 2580 return true; 2581 } 2582 2583 /* If this is a reference to a symbol defined by a dynamic object which 2584 is not a function, we might allocate the symbol in our .dynbss section 2585 and allocate a COPY dynamic relocation. 2586 2587 But IA-64 code is canonically PIC, so as a rule we can avoid this sort 2588 of hackery. */ 2589 2590 return true; 2591 } 2592 2593 static bool 2594 elf64_ia64_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2595 struct bfd_link_info *info) 2596 { 2597 struct elf64_ia64_allocate_data data; 2598 struct elf64_ia64_link_hash_table *ia64_info; 2599 asection *sec; 2600 bfd *dynobj; 2601 struct elf_link_hash_table *hash_table; 2602 2603 hash_table = elf_hash_table (info); 2604 ia64_info = elf64_ia64_hash_table (info); 2605 if (ia64_info == NULL) 2606 return false; 2607 dynobj = hash_table->dynobj; 2608 if (dynobj == NULL) 2609 return true; 2610 data.info = info; 2611 2612 /* Allocate the GOT entries. */ 2613 2614 if (ia64_info->root.sgot) 2615 { 2616 data.ofs = 0; 2617 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data); 2618 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data); 2619 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data); 2620 ia64_info->root.sgot->size = data.ofs; 2621 } 2622 2623 /* Allocate the FPTR entries. */ 2624 2625 if (ia64_info->fptr_sec) 2626 { 2627 data.ofs = 0; 2628 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data); 2629 ia64_info->fptr_sec->size = data.ofs; 2630 } 2631 2632 /* Now that we've seen all of the input files, we can decide which 2633 symbols need plt entries. Allocate the minimal PLT entries first. 2634 We do this even though dynamic_sections_created may be FALSE, because 2635 this has the side-effect of clearing want_plt and want_plt2. */ 2636 2637 data.ofs = 0; 2638 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data); 2639 2640 /* Align the pointer for the plt2 entries. */ 2641 data.ofs = (data.ofs + 31) & (bfd_vma) -32; 2642 2643 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data); 2644 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created) 2645 { 2646 /* FIXME: we always reserve the memory for dynamic linker even if 2647 there are no PLT entries since dynamic linker may assume the 2648 reserved memory always exists. */ 2649 2650 BFD_ASSERT (ia64_info->root.dynamic_sections_created); 2651 2652 ia64_info->root.splt->size = data.ofs; 2653 } 2654 2655 /* Allocate the PLTOFF entries. */ 2656 2657 if (ia64_info->pltoff_sec) 2658 { 2659 data.ofs = 0; 2660 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data); 2661 ia64_info->pltoff_sec->size = data.ofs; 2662 } 2663 2664 if (ia64_info->root.dynamic_sections_created) 2665 { 2666 /* Allocate space for the dynamic relocations that turned out to be 2667 required. */ 2668 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data); 2669 } 2670 2671 /* We have now determined the sizes of the various dynamic sections. 2672 Allocate memory for them. */ 2673 for (sec = dynobj->sections; sec != NULL; sec = sec->next) 2674 { 2675 bool strip; 2676 2677 if (!(sec->flags & SEC_LINKER_CREATED)) 2678 continue; 2679 2680 /* If we don't need this section, strip it from the output file. 2681 There were several sections primarily related to dynamic 2682 linking that must be create before the linker maps input 2683 sections to output sections. The linker does that before 2684 bfd_elf_size_dynamic_sections is called, and it is that 2685 function which decides whether anything needs to go into 2686 these sections. */ 2687 2688 strip = (sec->size == 0); 2689 2690 if (sec == ia64_info->root.sgot) 2691 strip = false; 2692 else if (sec == ia64_info->root.srelgot) 2693 { 2694 if (strip) 2695 ia64_info->root.srelgot = NULL; 2696 else 2697 /* We use the reloc_count field as a counter if we need to 2698 copy relocs into the output file. */ 2699 sec->reloc_count = 0; 2700 } 2701 else if (sec == ia64_info->fptr_sec) 2702 { 2703 if (strip) 2704 ia64_info->fptr_sec = NULL; 2705 } 2706 else if (sec == ia64_info->rel_fptr_sec) 2707 { 2708 if (strip) 2709 ia64_info->rel_fptr_sec = NULL; 2710 else 2711 /* We use the reloc_count field as a counter if we need to 2712 copy relocs into the output file. */ 2713 sec->reloc_count = 0; 2714 } 2715 else if (sec == ia64_info->root.splt) 2716 { 2717 if (strip) 2718 ia64_info->root.splt = NULL; 2719 } 2720 else if (sec == ia64_info->pltoff_sec) 2721 { 2722 if (strip) 2723 ia64_info->pltoff_sec = NULL; 2724 } 2725 else if (sec == ia64_info->fixups_sec) 2726 { 2727 if (strip) 2728 ia64_info->fixups_sec = NULL; 2729 } 2730 else if (sec == ia64_info->transfer_sec) 2731 { 2732 ; 2733 } 2734 else 2735 { 2736 const char *name; 2737 2738 /* It's OK to base decisions on the section name, because none 2739 of the dynobj section names depend upon the input files. */ 2740 name = bfd_section_name (sec); 2741 2742 if (strcmp (name, ".got.plt") == 0) 2743 strip = false; 2744 else if (startswith (name, ".rel")) 2745 { 2746 if (!strip) 2747 { 2748 /* We use the reloc_count field as a counter if we need to 2749 copy relocs into the output file. */ 2750 sec->reloc_count = 0; 2751 } 2752 } 2753 else 2754 continue; 2755 } 2756 2757 if (strip) 2758 sec->flags |= SEC_EXCLUDE; 2759 else 2760 { 2761 /* Allocate memory for the section contents. */ 2762 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size); 2763 if (sec->contents == NULL && sec->size != 0) 2764 return false; 2765 sec->alloced = 1; 2766 } 2767 } 2768 2769 if (elf_hash_table (info)->dynamic_sections_created) 2770 { 2771 bfd *abfd; 2772 asection *dynsec; 2773 asection *dynstrsec; 2774 Elf_Internal_Dyn dyn; 2775 const struct elf_backend_data *bed; 2776 unsigned int shl_num = 0; 2777 bfd_vma fixups_off = 0; 2778 bfd_vma strdyn_off; 2779 unsigned int time_hi, time_lo; 2780 2781 /* The .dynamic section must exist and be empty. */ 2782 dynsec = bfd_get_linker_section (hash_table->dynobj, ".dynamic"); 2783 BFD_ASSERT (dynsec != NULL); 2784 BFD_ASSERT (dynsec->size == 0); 2785 2786 dynstrsec = bfd_get_linker_section (hash_table->dynobj, ".vmsdynstr"); 2787 BFD_ASSERT (dynstrsec != NULL); 2788 BFD_ASSERT (dynstrsec->size == 0); 2789 dynstrsec->size = 1; /* Initial blank. */ 2790 2791 /* Ident + link time. */ 2792 vms_get_time (&time_hi, &time_lo); 2793 2794 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0)) 2795 return false; 2796 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME, 2797 ((uint64_t) time_hi << 32) 2798 + time_lo)) 2799 return false; 2800 2801 /* Strtab. */ 2802 strdyn_off = dynsec->size; 2803 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0)) 2804 return false; 2805 if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0)) 2806 return false; 2807 2808 /* PLTGOT */ 2809 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0)) 2810 return false; 2811 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0)) 2812 return false; 2813 2814 /* Misc. */ 2815 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000)) 2816 return false; 2817 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS, 2818 VMS_LF_IMGSTA | VMS_LF_MAIN)) 2819 return false; 2820 2821 /* Add entries for shared libraries. */ 2822 for (abfd = info->input_bfds; abfd; abfd = abfd->link.next) 2823 { 2824 char *soname; 2825 size_t soname_len; 2826 bfd_size_type strindex; 2827 bfd_byte *newcontents; 2828 bfd_vma fixups_shl_off; 2829 2830 if (!(abfd->flags & DYNAMIC)) 2831 continue; 2832 BFD_ASSERT (abfd->xvec == output_bfd->xvec); 2833 2834 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT, 2835 elf_ia64_vms_ident (abfd))) 2836 return false; 2837 2838 soname = vms_get_module_name (bfd_get_filename (abfd), true); 2839 if (soname == NULL) 2840 return false; 2841 strindex = dynstrsec->size; 2842 soname_len = strlen (soname) + 1; 2843 newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents, 2844 strindex + soname_len); 2845 if (newcontents == NULL) 2846 return false; 2847 memcpy (newcontents + strindex, soname, soname_len); 2848 dynstrsec->size += soname_len; 2849 dynstrsec->contents = newcontents; 2850 2851 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) 2852 return false; 2853 2854 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED, 2855 shl_num)) 2856 return false; 2857 shl_num++; 2858 2859 /* The fixups_off was in fact containing the size of the fixup 2860 section. Remap into the offset. */ 2861 fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off; 2862 elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off; 2863 2864 if (!_bfd_elf_add_dynamic_entry 2865 (info, DT_IA_64_VMS_FIXUP_RELA_CNT, 2866 fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP))) 2867 return false; 2868 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF, 2869 fixups_off)) 2870 return false; 2871 fixups_off += fixups_shl_off; 2872 } 2873 2874 /* Unwind. */ 2875 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0)) 2876 return false; 2877 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0)) 2878 return false; 2879 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0)) 2880 return false; 2881 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0)) 2882 return false; 2883 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0)) 2884 return false; 2885 2886 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead)) 2887 return false; 2888 2889 /* Fix the strtab entries. */ 2890 bed = get_elf_backend_data (hash_table->dynobj); 2891 2892 if (dynstrsec->size > 1) 2893 dynstrsec->contents[0] = 0; 2894 else 2895 dynstrsec->size = 0; 2896 2897 /* Note: one 'spare' (ie DT_NULL) entry is added by 2898 bfd_elf_size_dynsym_hash_dynstr. */ 2899 dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET; 2900 dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */; 2901 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, 2902 dynsec->contents + strdyn_off); 2903 2904 dyn.d_tag = DT_STRSZ; 2905 dyn.d_un.d_val = dynstrsec->size; 2906 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, 2907 dynsec->contents + strdyn_off + bed->s->sizeof_dyn); 2908 2909 elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num; 2910 2911 /* Note section. */ 2912 if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo)) 2913 return false; 2914 } 2915 2916 /* ??? Perhaps force __gp local. */ 2917 2918 return true; 2919 } 2920 2921 static void 2922 elf64_ia64_install_fixup (bfd *output_bfd, 2923 struct elf64_ia64_link_hash_table *ia64_info, 2924 struct elf_link_hash_entry *h, 2925 unsigned int type, asection *sec, bfd_vma offset, 2926 bfd_vma addend) 2927 { 2928 asection *relsec; 2929 Elf64_External_VMS_IMAGE_FIXUP *fixup; 2930 struct elf64_ia64_link_hash_entry *h_ia64; 2931 bfd_vma fixoff; 2932 Elf_Internal_Phdr *phdr; 2933 2934 if (h == NULL || !h->def_dynamic) 2935 abort (); 2936 2937 h_ia64 = (struct elf64_ia64_link_hash_entry *) h; 2938 fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off; 2939 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += 2940 sizeof (Elf64_External_VMS_IMAGE_FIXUP); 2941 relsec = ia64_info->fixups_sec; 2942 2943 fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff); 2944 offset += sec->output_section->vma + sec->output_offset; 2945 2946 /* FIXME: this is slow. We should cache the last one used, or create a 2947 map. */ 2948 phdr = _bfd_elf_find_segment_containing_section 2949 (output_bfd, sec->output_section); 2950 BFD_ASSERT (phdr != NULL); 2951 2952 bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset); 2953 bfd_putl32 (type, fixup->type); 2954 bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg); 2955 bfd_putl64 (addend, fixup->addend); 2956 bfd_putl32 (h->root.u.def.value, fixup->symvec_index); 2957 bfd_putl32 (2, fixup->data_type); 2958 } 2959 2960 /* Store an entry for target address TARGET_ADDR in the linkage table 2961 and return the gp-relative address of the linkage table entry. */ 2962 2963 static bfd_vma 2964 set_got_entry (bfd *abfd, struct bfd_link_info *info, 2965 struct elf64_ia64_dyn_sym_info *dyn_i, 2966 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type) 2967 { 2968 struct elf64_ia64_link_hash_table *ia64_info; 2969 asection *got_sec; 2970 bool done; 2971 bfd_vma got_offset; 2972 2973 ia64_info = elf64_ia64_hash_table (info); 2974 if (ia64_info == NULL) 2975 return 0; 2976 2977 got_sec = ia64_info->root.sgot; 2978 2979 switch (dyn_r_type) 2980 { 2981 case R_IA64_TPREL64LSB: 2982 case R_IA64_DTPMOD64LSB: 2983 case R_IA64_DTPREL32LSB: 2984 case R_IA64_DTPREL64LSB: 2985 abort (); 2986 break; 2987 default: 2988 done = dyn_i->got_done; 2989 dyn_i->got_done = true; 2990 got_offset = dyn_i->got_offset; 2991 break; 2992 } 2993 2994 BFD_ASSERT ((got_offset & 7) == 0); 2995 2996 if (! done) 2997 { 2998 /* Store the target address in the linkage table entry. */ 2999 bfd_put_64 (abfd, value, got_sec->contents + got_offset); 3000 3001 /* Install a dynamic relocation if needed. */ 3002 if (((bfd_link_pic (info) 3003 && (!dyn_i->h 3004 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT 3005 || dyn_i->h->root.type != bfd_link_hash_undefweak)) 3006 || elf64_ia64_dynamic_symbol_p (dyn_i->h)) 3007 && (!dyn_i->want_ltoff_fptr 3008 || !bfd_link_pie (info) 3009 || !dyn_i->h 3010 || dyn_i->h->root.type != bfd_link_hash_undefweak)) 3011 { 3012 if (!dyn_i->h || !dyn_i->h->def_dynamic) 3013 { 3014 dyn_r_type = R_IA64_REL64LSB; 3015 addend = value; 3016 } 3017 3018 /* VMS: install a FIX32 or FIX64. */ 3019 switch (dyn_r_type) 3020 { 3021 case R_IA64_DIR32LSB: 3022 case R_IA64_FPTR32LSB: 3023 dyn_r_type = R_IA64_VMS_FIX32; 3024 break; 3025 case R_IA64_DIR64LSB: 3026 case R_IA64_FPTR64LSB: 3027 dyn_r_type = R_IA64_VMS_FIX64; 3028 break; 3029 default: 3030 BFD_ASSERT (false); 3031 break; 3032 } 3033 elf64_ia64_install_fixup 3034 (info->output_bfd, ia64_info, dyn_i->h, 3035 dyn_r_type, got_sec, got_offset, addend); 3036 } 3037 } 3038 3039 /* Return the address of the linkage table entry. */ 3040 value = (got_sec->output_section->vma 3041 + got_sec->output_offset 3042 + got_offset); 3043 3044 return value; 3045 } 3046 3047 /* Fill in a function descriptor consisting of the function's code 3048 address and its global pointer. Return the descriptor's address. */ 3049 3050 static bfd_vma 3051 set_fptr_entry (bfd *abfd, struct bfd_link_info *info, 3052 struct elf64_ia64_dyn_sym_info *dyn_i, 3053 bfd_vma value) 3054 { 3055 struct elf64_ia64_link_hash_table *ia64_info; 3056 asection *fptr_sec; 3057 3058 ia64_info = elf64_ia64_hash_table (info); 3059 if (ia64_info == NULL) 3060 return 0; 3061 3062 fptr_sec = ia64_info->fptr_sec; 3063 3064 if (!dyn_i->fptr_done) 3065 { 3066 dyn_i->fptr_done = 1; 3067 3068 /* Fill in the function descriptor. */ 3069 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset); 3070 bfd_put_64 (abfd, _bfd_get_gp_value (abfd), 3071 fptr_sec->contents + dyn_i->fptr_offset + 8); 3072 } 3073 3074 /* Return the descriptor's address. */ 3075 value = (fptr_sec->output_section->vma 3076 + fptr_sec->output_offset 3077 + dyn_i->fptr_offset); 3078 3079 return value; 3080 } 3081 3082 /* Fill in a PLTOFF entry consisting of the function's code address 3083 and its global pointer. Return the descriptor's address. */ 3084 3085 static bfd_vma 3086 set_pltoff_entry (bfd *abfd, struct bfd_link_info *info, 3087 struct elf64_ia64_dyn_sym_info *dyn_i, 3088 bfd_vma value, bool is_plt) 3089 { 3090 struct elf64_ia64_link_hash_table *ia64_info; 3091 asection *pltoff_sec; 3092 3093 ia64_info = elf64_ia64_hash_table (info); 3094 if (ia64_info == NULL) 3095 return 0; 3096 3097 pltoff_sec = ia64_info->pltoff_sec; 3098 3099 /* Don't do anything if this symbol uses a real PLT entry. In 3100 that case, we'll fill this in during finish_dynamic_symbol. */ 3101 if ((! dyn_i->want_plt || is_plt) 3102 && !dyn_i->pltoff_done) 3103 { 3104 bfd_vma gp = _bfd_get_gp_value (abfd); 3105 3106 /* Fill in the function descriptor. */ 3107 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset); 3108 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8); 3109 3110 /* Install dynamic relocations if needed. */ 3111 if (!is_plt 3112 && bfd_link_pic (info) 3113 && (!dyn_i->h 3114 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT 3115 || dyn_i->h->root.type != bfd_link_hash_undefweak)) 3116 { 3117 /* VMS: */ 3118 abort (); 3119 } 3120 3121 dyn_i->pltoff_done = 1; 3122 } 3123 3124 /* Return the descriptor's address. */ 3125 value = (pltoff_sec->output_section->vma 3126 + pltoff_sec->output_offset 3127 + dyn_i->pltoff_offset); 3128 3129 return value; 3130 } 3131 3132 /* Called through qsort to sort the .IA_64.unwind section during a 3133 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd 3134 to the output bfd so we can do proper endianness frobbing. */ 3135 3136 static bfd *elf64_ia64_unwind_entry_compare_bfd; 3137 3138 static int 3139 elf64_ia64_unwind_entry_compare (const void * a, const void * b) 3140 { 3141 bfd_vma av, bv; 3142 3143 av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a); 3144 bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b); 3145 3146 return (av < bv ? -1 : av > bv ? 1 : 0); 3147 } 3148 3149 /* Make sure we've got ourselves a nice fat __gp value. */ 3150 static bool 3151 elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bool final) 3152 { 3153 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0; 3154 bfd_vma min_short_vma = min_vma, max_short_vma = 0; 3155 struct elf_link_hash_entry *gp; 3156 bfd_vma gp_val; 3157 asection *os; 3158 struct elf64_ia64_link_hash_table *ia64_info; 3159 3160 ia64_info = elf64_ia64_hash_table (info); 3161 if (ia64_info == NULL) 3162 return false; 3163 3164 /* Find the min and max vma of all sections marked short. Also collect 3165 min and max vma of any type, for use in selecting a nice gp. */ 3166 for (os = abfd->sections; os ; os = os->next) 3167 { 3168 bfd_vma lo, hi; 3169 3170 if ((os->flags & SEC_ALLOC) == 0) 3171 continue; 3172 3173 lo = os->vma; 3174 /* When this function is called from elfNN_ia64_final_link 3175 the correct value to use is os->size. When called from 3176 elfNN_ia64_relax_section we are in the middle of section 3177 sizing; some sections will already have os->size set, others 3178 will have os->size zero and os->rawsize the previous size. */ 3179 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size); 3180 if (hi < lo) 3181 hi = (bfd_vma) -1; 3182 3183 if (min_vma > lo) 3184 min_vma = lo; 3185 if (max_vma < hi) 3186 max_vma = hi; 3187 if (os->flags & SEC_SMALL_DATA) 3188 { 3189 if (min_short_vma > lo) 3190 min_short_vma = lo; 3191 if (max_short_vma < hi) 3192 max_short_vma = hi; 3193 } 3194 } 3195 3196 if (ia64_info->min_short_sec) 3197 { 3198 if (min_short_vma 3199 > (ia64_info->min_short_sec->vma 3200 + ia64_info->min_short_offset)) 3201 min_short_vma = (ia64_info->min_short_sec->vma 3202 + ia64_info->min_short_offset); 3203 if (max_short_vma 3204 < (ia64_info->max_short_sec->vma 3205 + ia64_info->max_short_offset)) 3206 max_short_vma = (ia64_info->max_short_sec->vma 3207 + ia64_info->max_short_offset); 3208 } 3209 3210 /* See if the user wants to force a value. */ 3211 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false, 3212 false, false); 3213 3214 if (gp 3215 && (gp->root.type == bfd_link_hash_defined 3216 || gp->root.type == bfd_link_hash_defweak)) 3217 { 3218 asection *gp_sec = gp->root.u.def.section; 3219 gp_val = (gp->root.u.def.value 3220 + gp_sec->output_section->vma 3221 + gp_sec->output_offset); 3222 } 3223 else 3224 { 3225 /* Pick a sensible value. */ 3226 3227 if (ia64_info->min_short_sec) 3228 { 3229 bfd_vma short_range = max_short_vma - min_short_vma; 3230 3231 /* If min_short_sec is set, pick one in the middle bewteen 3232 min_short_vma and max_short_vma. */ 3233 if (short_range >= 0x400000) 3234 goto overflow; 3235 gp_val = min_short_vma + short_range / 2; 3236 } 3237 else 3238 { 3239 asection *got_sec = ia64_info->root.sgot; 3240 3241 /* Start with just the address of the .got. */ 3242 if (got_sec) 3243 gp_val = got_sec->output_section->vma; 3244 else if (max_short_vma != 0) 3245 gp_val = min_short_vma; 3246 else if (max_vma - min_vma < 0x200000) 3247 gp_val = min_vma; 3248 else 3249 gp_val = max_vma - 0x200000 + 8; 3250 } 3251 3252 /* If it is possible to address the entire image, but we 3253 don't with the choice above, adjust. */ 3254 if (max_vma - min_vma < 0x400000 3255 && (max_vma - gp_val >= 0x200000 3256 || gp_val - min_vma > 0x200000)) 3257 gp_val = min_vma + 0x200000; 3258 else if (max_short_vma != 0) 3259 { 3260 /* If we don't cover all the short data, adjust. */ 3261 if (max_short_vma - gp_val >= 0x200000) 3262 gp_val = min_short_vma + 0x200000; 3263 3264 /* If we're addressing stuff past the end, adjust back. */ 3265 if (gp_val > max_vma) 3266 gp_val = max_vma - 0x200000 + 8; 3267 } 3268 } 3269 3270 /* Validate whether all SHF_IA_64_SHORT sections are within 3271 range of the chosen GP. */ 3272 3273 if (max_short_vma != 0) 3274 { 3275 if (max_short_vma - min_short_vma >= 0x400000) 3276 { 3277 overflow: 3278 _bfd_error_handler 3279 /* xgettext:c-format */ 3280 (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"), 3281 abfd, (uint64_t) (max_short_vma - min_short_vma)); 3282 return false; 3283 } 3284 else if ((gp_val > min_short_vma 3285 && gp_val - min_short_vma > 0x200000) 3286 || (gp_val < max_short_vma 3287 && max_short_vma - gp_val >= 0x200000)) 3288 { 3289 _bfd_error_handler 3290 (_("%pB: __gp does not cover short data segment"), abfd); 3291 return false; 3292 } 3293 } 3294 3295 _bfd_set_gp_value (abfd, gp_val); 3296 3297 return true; 3298 } 3299 3300 static bool 3301 elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info) 3302 { 3303 struct elf64_ia64_link_hash_table *ia64_info; 3304 asection *unwind_output_sec; 3305 3306 ia64_info = elf64_ia64_hash_table (info); 3307 if (ia64_info == NULL) 3308 return false; 3309 3310 /* Make sure we've got ourselves a nice fat __gp value. */ 3311 if (!bfd_link_relocatable (info)) 3312 { 3313 bfd_vma gp_val; 3314 struct elf_link_hash_entry *gp; 3315 3316 /* We assume after gp is set, section size will only decrease. We 3317 need to adjust gp for it. */ 3318 _bfd_set_gp_value (abfd, 0); 3319 if (! elf64_ia64_choose_gp (abfd, info, true)) 3320 return false; 3321 gp_val = _bfd_get_gp_value (abfd); 3322 3323 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false, 3324 false, false); 3325 if (gp) 3326 { 3327 gp->root.type = bfd_link_hash_defined; 3328 gp->root.u.def.value = gp_val; 3329 gp->root.u.def.section = bfd_abs_section_ptr; 3330 } 3331 } 3332 3333 /* If we're producing a final executable, we need to sort the contents 3334 of the .IA_64.unwind section. Force this section to be relocated 3335 into memory rather than written immediately to the output file. */ 3336 unwind_output_sec = NULL; 3337 if (!bfd_link_relocatable (info)) 3338 { 3339 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); 3340 if (s) 3341 { 3342 unwind_output_sec = s->output_section; 3343 unwind_output_sec->contents 3344 = bfd_malloc (unwind_output_sec->size); 3345 if (unwind_output_sec->contents == NULL) 3346 return false; 3347 } 3348 } 3349 3350 /* Invoke the regular ELF backend linker to do all the work. */ 3351 if (!bfd_elf_final_link (abfd, info)) 3352 return false; 3353 3354 if (unwind_output_sec) 3355 { 3356 elf64_ia64_unwind_entry_compare_bfd = abfd; 3357 qsort (unwind_output_sec->contents, 3358 (size_t) (unwind_output_sec->size / 24), 3359 24, 3360 elf64_ia64_unwind_entry_compare); 3361 3362 if (! bfd_set_section_contents (abfd, unwind_output_sec, 3363 unwind_output_sec->contents, (bfd_vma) 0, 3364 unwind_output_sec->size)) 3365 return false; 3366 } 3367 3368 return true; 3369 } 3370 3371 static int 3372 elf64_ia64_relocate_section (bfd *output_bfd, 3373 struct bfd_link_info *info, 3374 bfd *input_bfd, 3375 asection *input_section, 3376 bfd_byte *contents, 3377 Elf_Internal_Rela *relocs, 3378 Elf_Internal_Sym *local_syms, 3379 asection **local_sections) 3380 { 3381 struct elf64_ia64_link_hash_table *ia64_info; 3382 Elf_Internal_Shdr *symtab_hdr; 3383 Elf_Internal_Rela *rel; 3384 Elf_Internal_Rela *relend; 3385 bool ret_val = true; /* for non-fatal errors */ 3386 bfd_vma gp_val; 3387 3388 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3389 ia64_info = elf64_ia64_hash_table (info); 3390 if (ia64_info == NULL) 3391 return false; 3392 3393 /* Infect various flags from the input section to the output section. */ 3394 if (bfd_link_relocatable (info)) 3395 { 3396 bfd_vma flags; 3397 3398 flags = elf_section_data(input_section)->this_hdr.sh_flags; 3399 flags &= SHF_IA_64_NORECOV; 3400 3401 elf_section_data(input_section->output_section) 3402 ->this_hdr.sh_flags |= flags; 3403 } 3404 3405 gp_val = _bfd_get_gp_value (output_bfd); 3406 3407 rel = relocs; 3408 relend = relocs + input_section->reloc_count; 3409 for (; rel < relend; ++rel) 3410 { 3411 struct elf_link_hash_entry *h; 3412 struct elf64_ia64_dyn_sym_info *dyn_i; 3413 bfd_reloc_status_type r; 3414 reloc_howto_type *howto; 3415 unsigned long r_symndx; 3416 Elf_Internal_Sym *sym; 3417 unsigned int r_type; 3418 bfd_vma value; 3419 asection *sym_sec; 3420 bfd_byte *hit_addr; 3421 bool dynamic_symbol_p; 3422 bool undef_weak_ref; 3423 3424 r_type = ELF64_R_TYPE (rel->r_info); 3425 if (r_type > R_IA64_MAX_RELOC_CODE) 3426 { 3427 /* xgettext:c-format */ 3428 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 3429 input_bfd, (int) r_type); 3430 bfd_set_error (bfd_error_bad_value); 3431 ret_val = false; 3432 continue; 3433 } 3434 3435 howto = ia64_elf_lookup_howto (r_type); 3436 if (howto == NULL) 3437 { 3438 ret_val = false; 3439 continue; 3440 } 3441 r_symndx = ELF64_R_SYM (rel->r_info); 3442 h = NULL; 3443 sym = NULL; 3444 sym_sec = NULL; 3445 undef_weak_ref = false; 3446 3447 if (r_symndx < symtab_hdr->sh_info) 3448 { 3449 /* Reloc against local symbol. */ 3450 asection *msec; 3451 sym = local_syms + r_symndx; 3452 sym_sec = local_sections[r_symndx]; 3453 msec = sym_sec; 3454 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel); 3455 if (!bfd_link_relocatable (info) 3456 && (sym_sec->flags & SEC_MERGE) != 0 3457 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 3458 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE) 3459 { 3460 struct elf64_ia64_local_hash_entry *loc_h; 3461 3462 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false); 3463 if (loc_h && ! loc_h->sec_merge_done) 3464 { 3465 struct elf64_ia64_dyn_sym_info *dynent; 3466 unsigned int count; 3467 3468 for (count = loc_h->count, dynent = loc_h->info; 3469 count != 0; 3470 count--, dynent++) 3471 { 3472 msec = sym_sec; 3473 dynent->addend = 3474 _bfd_merged_section_offset (output_bfd, &msec, 3475 elf_section_data (msec)-> 3476 sec_info, 3477 sym->st_value 3478 + dynent->addend); 3479 dynent->addend -= sym->st_value; 3480 dynent->addend += msec->output_section->vma 3481 + msec->output_offset 3482 - sym_sec->output_section->vma 3483 - sym_sec->output_offset; 3484 } 3485 3486 /* We may have introduced duplicated entries. We need 3487 to remove them properly. */ 3488 count = sort_dyn_sym_info (loc_h->info, loc_h->count); 3489 if (count != loc_h->count) 3490 { 3491 loc_h->count = count; 3492 loc_h->sorted_count = count; 3493 } 3494 3495 loc_h->sec_merge_done = 1; 3496 } 3497 } 3498 } 3499 else 3500 { 3501 bool unresolved_reloc; 3502 bool warned, ignored; 3503 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 3504 3505 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 3506 r_symndx, symtab_hdr, sym_hashes, 3507 h, sym_sec, value, 3508 unresolved_reloc, warned, ignored); 3509 3510 if (h->root.type == bfd_link_hash_undefweak) 3511 undef_weak_ref = true; 3512 else if (warned) 3513 continue; 3514 } 3515 3516 /* For relocs against symbols from removed linkonce sections, 3517 or sections discarded by a linker script, we just want the 3518 section contents zeroed. Avoid any special processing. */ 3519 if (sym_sec != NULL && discarded_section (sym_sec)) 3520 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3521 rel, 1, relend, R_IA64_NONE, 3522 howto, 0, contents); 3523 3524 if (bfd_link_relocatable (info)) 3525 continue; 3526 3527 hit_addr = contents + rel->r_offset; 3528 value += rel->r_addend; 3529 dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h); 3530 3531 switch (r_type) 3532 { 3533 case R_IA64_NONE: 3534 case R_IA64_LDXMOV: 3535 continue; 3536 3537 case R_IA64_IMM14: 3538 case R_IA64_IMM22: 3539 case R_IA64_IMM64: 3540 case R_IA64_DIR32MSB: 3541 case R_IA64_DIR32LSB: 3542 case R_IA64_DIR64MSB: 3543 case R_IA64_DIR64LSB: 3544 /* Install a dynamic relocation for this reloc. */ 3545 if ((dynamic_symbol_p || bfd_link_pic (info)) 3546 && r_symndx != 0 3547 && (input_section->flags & SEC_ALLOC) != 0) 3548 { 3549 unsigned int dyn_r_type; 3550 bfd_vma addend; 3551 3552 switch (r_type) 3553 { 3554 case R_IA64_IMM14: 3555 case R_IA64_IMM22: 3556 case R_IA64_IMM64: 3557 /* ??? People shouldn't be doing non-pic code in 3558 shared libraries nor dynamic executables. */ 3559 _bfd_error_handler 3560 /* xgettext:c-format */ 3561 (_("%pB: non-pic code with imm relocation against" 3562 " dynamic symbol `%s'"), 3563 input_bfd, 3564 h ? h->root.root.string 3565 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3566 sym_sec)); 3567 ret_val = false; 3568 continue; 3569 3570 default: 3571 break; 3572 } 3573 3574 /* If we don't need dynamic symbol lookup, find a 3575 matching RELATIVE relocation. */ 3576 dyn_r_type = r_type; 3577 if (dynamic_symbol_p) 3578 { 3579 addend = rel->r_addend; 3580 value = 0; 3581 } 3582 else 3583 { 3584 addend = value; 3585 } 3586 3587 /* VMS: install a FIX64. */ 3588 switch (dyn_r_type) 3589 { 3590 case R_IA64_DIR32LSB: 3591 dyn_r_type = R_IA64_VMS_FIX32; 3592 break; 3593 case R_IA64_DIR64LSB: 3594 dyn_r_type = R_IA64_VMS_FIX64; 3595 break; 3596 default: 3597 BFD_ASSERT (false); 3598 break; 3599 } 3600 elf64_ia64_install_fixup 3601 (output_bfd, ia64_info, h, 3602 dyn_r_type, input_section, rel->r_offset, addend); 3603 r = bfd_reloc_ok; 3604 break; 3605 } 3606 /* Fall through. */ 3607 3608 case R_IA64_LTV32MSB: 3609 case R_IA64_LTV32LSB: 3610 case R_IA64_LTV64MSB: 3611 case R_IA64_LTV64LSB: 3612 r = ia64_elf_install_value (hit_addr, value, r_type); 3613 break; 3614 3615 case R_IA64_GPREL22: 3616 case R_IA64_GPREL64I: 3617 case R_IA64_GPREL32MSB: 3618 case R_IA64_GPREL32LSB: 3619 case R_IA64_GPREL64MSB: 3620 case R_IA64_GPREL64LSB: 3621 if (dynamic_symbol_p) 3622 { 3623 _bfd_error_handler 3624 /* xgettext:c-format */ 3625 (_("%pB: @gprel relocation against dynamic symbol %s"), 3626 input_bfd, 3627 h ? h->root.root.string 3628 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3629 sym_sec)); 3630 ret_val = false; 3631 continue; 3632 } 3633 value -= gp_val; 3634 r = ia64_elf_install_value (hit_addr, value, r_type); 3635 break; 3636 3637 case R_IA64_LTOFF22: 3638 case R_IA64_LTOFF22X: 3639 case R_IA64_LTOFF64I: 3640 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3641 value = set_got_entry (input_bfd, info, dyn_i, 3642 rel->r_addend, value, R_IA64_DIR64LSB); 3643 value -= gp_val; 3644 r = ia64_elf_install_value (hit_addr, value, r_type); 3645 break; 3646 3647 case R_IA64_PLTOFF22: 3648 case R_IA64_PLTOFF64I: 3649 case R_IA64_PLTOFF64MSB: 3650 case R_IA64_PLTOFF64LSB: 3651 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3652 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false); 3653 value -= gp_val; 3654 r = ia64_elf_install_value (hit_addr, value, r_type); 3655 break; 3656 3657 case R_IA64_FPTR64I: 3658 case R_IA64_FPTR32MSB: 3659 case R_IA64_FPTR32LSB: 3660 case R_IA64_FPTR64MSB: 3661 case R_IA64_FPTR64LSB: 3662 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3663 if (dyn_i->want_fptr) 3664 { 3665 if (!undef_weak_ref) 3666 value = set_fptr_entry (output_bfd, info, dyn_i, value); 3667 } 3668 if (!dyn_i->want_fptr || bfd_link_pie (info)) 3669 { 3670 /* Otherwise, we expect the dynamic linker to create 3671 the entry. */ 3672 3673 if (dyn_i->want_fptr) 3674 { 3675 if (r_type == R_IA64_FPTR64I) 3676 { 3677 /* We can't represent this without a dynamic symbol. 3678 Adjust the relocation to be against an output 3679 section symbol, which are always present in the 3680 dynamic symbol table. */ 3681 /* ??? People shouldn't be doing non-pic code in 3682 shared libraries. Hork. */ 3683 _bfd_error_handler 3684 (_("%pB: linking non-pic code in a position independent executable"), 3685 input_bfd); 3686 ret_val = false; 3687 continue; 3688 } 3689 } 3690 else 3691 { 3692 value = 0; 3693 } 3694 3695 /* VMS: FIXFD. */ 3696 elf64_ia64_install_fixup 3697 (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, 3698 input_section, rel->r_offset, 0); 3699 r = bfd_reloc_ok; 3700 break; 3701 } 3702 3703 r = ia64_elf_install_value (hit_addr, value, r_type); 3704 break; 3705 3706 case R_IA64_LTOFF_FPTR22: 3707 case R_IA64_LTOFF_FPTR64I: 3708 case R_IA64_LTOFF_FPTR32MSB: 3709 case R_IA64_LTOFF_FPTR32LSB: 3710 case R_IA64_LTOFF_FPTR64MSB: 3711 case R_IA64_LTOFF_FPTR64LSB: 3712 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3713 if (dyn_i->want_fptr) 3714 { 3715 BFD_ASSERT (h == NULL || !h->def_dynamic); 3716 if (!undef_weak_ref) 3717 value = set_fptr_entry (output_bfd, info, dyn_i, value); 3718 } 3719 else 3720 value = 0; 3721 3722 value = set_got_entry (output_bfd, info, dyn_i, 3723 rel->r_addend, value, R_IA64_FPTR64LSB); 3724 value -= gp_val; 3725 r = ia64_elf_install_value (hit_addr, value, r_type); 3726 break; 3727 3728 case R_IA64_PCREL32MSB: 3729 case R_IA64_PCREL32LSB: 3730 case R_IA64_PCREL64MSB: 3731 case R_IA64_PCREL64LSB: 3732 /* Install a dynamic relocation for this reloc. */ 3733 if (dynamic_symbol_p && r_symndx != 0) 3734 { 3735 /* VMS: doesn't exist ??? */ 3736 abort (); 3737 } 3738 goto finish_pcrel; 3739 3740 case R_IA64_PCREL21B: 3741 case R_IA64_PCREL60B: 3742 /* We should have created a PLT entry for any dynamic symbol. */ 3743 dyn_i = NULL; 3744 if (h) 3745 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 3746 3747 if (dyn_i && dyn_i->want_plt2) 3748 { 3749 /* Should have caught this earlier. */ 3750 BFD_ASSERT (rel->r_addend == 0); 3751 3752 value = (ia64_info->root.splt->output_section->vma 3753 + ia64_info->root.splt->output_offset 3754 + dyn_i->plt2_offset); 3755 } 3756 else 3757 { 3758 /* Since there's no PLT entry, Validate that this is 3759 locally defined. */ 3760 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL); 3761 3762 /* If the symbol is undef_weak, we shouldn't be trying 3763 to call it. There's every chance that we'd wind up 3764 with an out-of-range fixup here. Don't bother setting 3765 any value at all. */ 3766 if (undef_weak_ref) 3767 continue; 3768 } 3769 goto finish_pcrel; 3770 3771 case R_IA64_PCREL21BI: 3772 case R_IA64_PCREL21F: 3773 case R_IA64_PCREL21M: 3774 case R_IA64_PCREL22: 3775 case R_IA64_PCREL64I: 3776 /* The PCREL21BI reloc is specifically not intended for use with 3777 dynamic relocs. PCREL21F and PCREL21M are used for speculation 3778 fixup code, and thus probably ought not be dynamic. The 3779 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */ 3780 if (dynamic_symbol_p) 3781 { 3782 const char *msg; 3783 3784 if (r_type == R_IA64_PCREL21BI) 3785 /* xgettext:c-format */ 3786 msg = _("%pB: @internal branch to dynamic symbol %s"); 3787 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M) 3788 /* xgettext:c-format */ 3789 msg = _("%pB: speculation fixup to dynamic symbol %s"); 3790 else 3791 /* xgettext:c-format */ 3792 msg = _("%pB: @pcrel relocation against dynamic symbol %s"); 3793 _bfd_error_handler (msg, input_bfd, 3794 h ? h->root.root.string 3795 : bfd_elf_sym_name (input_bfd, 3796 symtab_hdr, 3797 sym, 3798 sym_sec)); 3799 ret_val = false; 3800 continue; 3801 } 3802 goto finish_pcrel; 3803 3804 finish_pcrel: 3805 /* Make pc-relative. */ 3806 value -= (input_section->output_section->vma 3807 + input_section->output_offset 3808 + rel->r_offset) & ~ (bfd_vma) 0x3; 3809 r = ia64_elf_install_value (hit_addr, value, r_type); 3810 break; 3811 3812 case R_IA64_SEGREL32MSB: 3813 case R_IA64_SEGREL32LSB: 3814 case R_IA64_SEGREL64MSB: 3815 case R_IA64_SEGREL64LSB: 3816 { 3817 /* Find the segment that contains the output_section. */ 3818 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section 3819 (output_bfd, sym_sec->output_section); 3820 3821 if (p == NULL) 3822 { 3823 r = bfd_reloc_notsupported; 3824 } 3825 else 3826 { 3827 /* The VMA of the segment is the vaddr of the associated 3828 program header. */ 3829 if (value > p->p_vaddr) 3830 value -= p->p_vaddr; 3831 else 3832 value = 0; 3833 r = ia64_elf_install_value (hit_addr, value, r_type); 3834 } 3835 break; 3836 } 3837 3838 case R_IA64_SECREL32MSB: 3839 case R_IA64_SECREL32LSB: 3840 case R_IA64_SECREL64MSB: 3841 case R_IA64_SECREL64LSB: 3842 /* Make output-section relative to section where the symbol 3843 is defined. PR 475 */ 3844 if (sym_sec) 3845 value -= sym_sec->output_section->vma; 3846 r = ia64_elf_install_value (hit_addr, value, r_type); 3847 break; 3848 3849 case R_IA64_IPLTMSB: 3850 case R_IA64_IPLTLSB: 3851 /* Install a dynamic relocation for this reloc. */ 3852 if ((dynamic_symbol_p || bfd_link_pic (info)) 3853 && (input_section->flags & SEC_ALLOC) != 0) 3854 { 3855 /* VMS: FIXFD ?? */ 3856 abort (); 3857 } 3858 3859 if (r_type == R_IA64_IPLTMSB) 3860 r_type = R_IA64_DIR64MSB; 3861 else 3862 r_type = R_IA64_DIR64LSB; 3863 ia64_elf_install_value (hit_addr, value, r_type); 3864 r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type); 3865 break; 3866 3867 case R_IA64_TPREL14: 3868 case R_IA64_TPREL22: 3869 case R_IA64_TPREL64I: 3870 r = bfd_reloc_notsupported; 3871 break; 3872 3873 case R_IA64_DTPREL14: 3874 case R_IA64_DTPREL22: 3875 case R_IA64_DTPREL64I: 3876 case R_IA64_DTPREL32LSB: 3877 case R_IA64_DTPREL32MSB: 3878 case R_IA64_DTPREL64LSB: 3879 case R_IA64_DTPREL64MSB: 3880 r = bfd_reloc_notsupported; 3881 break; 3882 3883 case R_IA64_LTOFF_TPREL22: 3884 case R_IA64_LTOFF_DTPMOD22: 3885 case R_IA64_LTOFF_DTPREL22: 3886 r = bfd_reloc_notsupported; 3887 break; 3888 3889 default: 3890 r = bfd_reloc_notsupported; 3891 break; 3892 } 3893 3894 switch (r) 3895 { 3896 case bfd_reloc_ok: 3897 break; 3898 3899 case bfd_reloc_undefined: 3900 /* This can happen for global table relative relocs if 3901 __gp is undefined. This is a panic situation so we 3902 don't try to continue. */ 3903 (*info->callbacks->undefined_symbol) 3904 (info, "__gp", input_bfd, input_section, rel->r_offset, 1); 3905 return false; 3906 3907 case bfd_reloc_notsupported: 3908 { 3909 const char *name; 3910 3911 if (h) 3912 name = h->root.root.string; 3913 else 3914 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3915 sym_sec); 3916 (*info->callbacks->warning) (info, _("unsupported reloc"), 3917 name, input_bfd, 3918 input_section, rel->r_offset); 3919 ret_val = false; 3920 } 3921 break; 3922 3923 case bfd_reloc_dangerous: 3924 case bfd_reloc_outofrange: 3925 case bfd_reloc_overflow: 3926 default: 3927 { 3928 const char *name; 3929 3930 if (h) 3931 name = h->root.root.string; 3932 else 3933 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3934 sym_sec); 3935 3936 switch (r_type) 3937 { 3938 case R_IA64_TPREL14: 3939 case R_IA64_TPREL22: 3940 case R_IA64_TPREL64I: 3941 case R_IA64_DTPREL14: 3942 case R_IA64_DTPREL22: 3943 case R_IA64_DTPREL64I: 3944 case R_IA64_DTPREL32LSB: 3945 case R_IA64_DTPREL32MSB: 3946 case R_IA64_DTPREL64LSB: 3947 case R_IA64_DTPREL64MSB: 3948 case R_IA64_LTOFF_TPREL22: 3949 case R_IA64_LTOFF_DTPMOD22: 3950 case R_IA64_LTOFF_DTPREL22: 3951 _bfd_error_handler 3952 /* xgettext:c-format */ 3953 (_("%pB: missing TLS section for relocation %s against `%s'" 3954 " at %#" PRIx64 " in section `%pA'."), 3955 input_bfd, howto->name, name, 3956 (uint64_t) rel->r_offset, input_section); 3957 break; 3958 3959 case R_IA64_PCREL21B: 3960 case R_IA64_PCREL21BI: 3961 case R_IA64_PCREL21M: 3962 case R_IA64_PCREL21F: 3963 if (is_elf_hash_table (info->hash)) 3964 { 3965 /* Relaxtion is always performed for ELF output. 3966 Overflow failures for those relocations mean 3967 that the section is too big to relax. */ 3968 _bfd_error_handler 3969 /* xgettext:c-format */ 3970 (_("%pB: Can't relax br (%s) to `%s' " 3971 "at %#" PRIx64 " in section `%pA' " 3972 "with size %#" PRIx64 " (> 0x1000000)."), 3973 input_bfd, howto->name, name, (uint64_t) rel->r_offset, 3974 input_section, (uint64_t) input_section->size); 3975 break; 3976 } 3977 /* Fall through. */ 3978 default: 3979 (*info->callbacks->reloc_overflow) (info, 3980 &h->root, 3981 name, 3982 howto->name, 3983 (bfd_vma) 0, 3984 input_bfd, 3985 input_section, 3986 rel->r_offset); 3987 break; 3988 } 3989 3990 ret_val = false; 3991 } 3992 break; 3993 } 3994 } 3995 3996 return ret_val; 3997 } 3998 3999 static bool 4000 elf64_ia64_finish_dynamic_symbol (bfd *output_bfd, 4001 struct bfd_link_info *info, 4002 struct elf_link_hash_entry *h, 4003 Elf_Internal_Sym *sym) 4004 { 4005 struct elf64_ia64_link_hash_table *ia64_info; 4006 struct elf64_ia64_dyn_sym_info *dyn_i; 4007 4008 ia64_info = elf64_ia64_hash_table (info); 4009 4010 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 4011 4012 /* Fill in the PLT data, if required. */ 4013 if (dyn_i && dyn_i->want_plt) 4014 { 4015 bfd_byte *loc; 4016 asection *plt_sec; 4017 bfd_vma plt_addr, pltoff_addr, gp_val; 4018 4019 gp_val = _bfd_get_gp_value (output_bfd); 4020 4021 plt_sec = ia64_info->root.splt; 4022 plt_addr = 0; /* Not used as overriden by FIXUPs. */ 4023 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true); 4024 4025 /* Initialize the FULL PLT entry, if needed. */ 4026 if (dyn_i->want_plt2) 4027 { 4028 loc = plt_sec->contents + dyn_i->plt2_offset; 4029 4030 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE); 4031 ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22); 4032 4033 /* Mark the symbol as undefined, rather than as defined in the 4034 plt section. Leave the value alone. */ 4035 /* ??? We didn't redefine it in adjust_dynamic_symbol in the 4036 first place. But perhaps elflink.c did some for us. */ 4037 if (!h->def_regular) 4038 sym->st_shndx = SHN_UNDEF; 4039 } 4040 4041 /* VMS: FIXFD. */ 4042 elf64_ia64_install_fixup 4043 (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, ia64_info->pltoff_sec, 4044 pltoff_addr - (ia64_info->pltoff_sec->output_section->vma 4045 + ia64_info->pltoff_sec->output_offset), 0); 4046 } 4047 4048 /* Mark some specially defined symbols as absolute. */ 4049 if (h == ia64_info->root.hdynamic 4050 || h == ia64_info->root.hgot 4051 || h == ia64_info->root.hplt) 4052 sym->st_shndx = SHN_ABS; 4053 4054 return true; 4055 } 4056 4057 static bool 4058 elf64_ia64_finish_dynamic_sections (bfd *abfd, 4059 struct bfd_link_info *info) 4060 { 4061 struct elf64_ia64_link_hash_table *ia64_info; 4062 bfd *dynobj; 4063 4064 ia64_info = elf64_ia64_hash_table (info); 4065 if (ia64_info == NULL) 4066 return false; 4067 4068 dynobj = ia64_info->root.dynobj; 4069 4070 if (elf_hash_table (info)->dynamic_sections_created) 4071 { 4072 Elf64_External_Dyn *dyncon, *dynconend; 4073 asection *sdyn; 4074 asection *unwind_sec; 4075 bfd_vma gp_val; 4076 unsigned int gp_seg; 4077 bfd_vma gp_off; 4078 Elf_Internal_Phdr *phdr; 4079 Elf_Internal_Phdr *base_phdr; 4080 unsigned int unwind_seg = 0; 4081 unsigned int code_seg = 0; 4082 4083 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 4084 BFD_ASSERT (sdyn != NULL); 4085 dyncon = (Elf64_External_Dyn *) sdyn->contents; 4086 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 4087 4088 gp_val = _bfd_get_gp_value (abfd); 4089 phdr = _bfd_elf_find_segment_containing_section 4090 (info->output_bfd, ia64_info->pltoff_sec->output_section); 4091 BFD_ASSERT (phdr != NULL); 4092 base_phdr = elf_tdata (info->output_bfd)->phdr; 4093 gp_seg = phdr - base_phdr; 4094 gp_off = gp_val - phdr->p_vaddr; 4095 4096 unwind_sec = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); 4097 if (unwind_sec != NULL) 4098 { 4099 asection *code_sec; 4100 4101 phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec); 4102 BFD_ASSERT (phdr != NULL); 4103 unwind_seg = phdr - base_phdr; 4104 4105 code_sec = bfd_get_section_by_name (abfd, "$CODE$"); 4106 phdr = _bfd_elf_find_segment_containing_section (abfd, code_sec); 4107 BFD_ASSERT (phdr != NULL); 4108 code_seg = phdr - base_phdr; 4109 } 4110 4111 for (; dyncon < dynconend; dyncon++) 4112 { 4113 Elf_Internal_Dyn dyn; 4114 4115 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 4116 4117 switch (dyn.d_tag) 4118 { 4119 case DT_IA_64_VMS_FIXUP_RELA_OFF: 4120 dyn.d_un.d_val += 4121 (ia64_info->fixups_sec->output_section->vma 4122 + ia64_info->fixups_sec->output_offset) 4123 - (sdyn->output_section->vma + sdyn->output_offset); 4124 break; 4125 4126 case DT_IA_64_VMS_PLTGOT_OFFSET: 4127 dyn.d_un.d_val = gp_off; 4128 break; 4129 4130 case DT_IA_64_VMS_PLTGOT_SEG: 4131 dyn.d_un.d_val = gp_seg; 4132 break; 4133 4134 case DT_IA_64_VMS_UNWINDSZ: 4135 if (unwind_sec == NULL) 4136 { 4137 dyn.d_tag = DT_NULL; 4138 dyn.d_un.d_val = 0xdead; 4139 } 4140 else 4141 dyn.d_un.d_val = unwind_sec->size; 4142 break; 4143 4144 case DT_IA_64_VMS_UNWIND_CODSEG: 4145 dyn.d_un.d_val = code_seg; 4146 break; 4147 4148 case DT_IA_64_VMS_UNWIND_INFOSEG: 4149 case DT_IA_64_VMS_UNWIND_SEG: 4150 dyn.d_un.d_val = unwind_seg; 4151 break; 4152 4153 case DT_IA_64_VMS_UNWIND_OFFSET: 4154 break; 4155 4156 default: 4157 /* No need to rewrite the entry. */ 4158 continue; 4159 } 4160 4161 bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon); 4162 } 4163 } 4164 4165 /* Handle transfer addresses. */ 4166 { 4167 asection *tfr_sec = ia64_info->transfer_sec; 4168 struct elf64_vms_transfer *tfr; 4169 struct elf_link_hash_entry *tfr3; 4170 4171 tfr = (struct elf64_vms_transfer *)tfr_sec->contents; 4172 bfd_putl32 (6 * 8, tfr->size); 4173 bfd_putl64 (tfr_sec->output_section->vma 4174 + tfr_sec->output_offset 4175 + 6 * 8, tfr->tfradr3); 4176 4177 tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", false, 4178 false, false); 4179 4180 if (tfr3 4181 && (tfr3->root.type == bfd_link_hash_defined 4182 || tfr3->root.type == bfd_link_hash_defweak)) 4183 { 4184 asection *tfr3_sec = tfr3->root.u.def.section; 4185 bfd_vma tfr3_val; 4186 4187 tfr3_val = (tfr3->root.u.def.value 4188 + tfr3_sec->output_section->vma 4189 + tfr3_sec->output_offset); 4190 4191 bfd_putl64 (tfr3_val, tfr->tfr3_func); 4192 bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp); 4193 } 4194 4195 /* FIXME: set linker flags, 4196 handle lib$initialize. */ 4197 } 4198 4199 return true; 4200 } 4201 4202 /* ELF file flag handling: */ 4203 4204 /* Function to keep IA-64 specific file flags. */ 4205 static bool 4206 elf64_ia64_set_private_flags (bfd *abfd, flagword flags) 4207 { 4208 BFD_ASSERT (!elf_flags_init (abfd) 4209 || elf_elfheader (abfd)->e_flags == flags); 4210 4211 elf_elfheader (abfd)->e_flags = flags; 4212 elf_flags_init (abfd) = true; 4213 return true; 4214 } 4215 4216 /* Merge backend specific data from an object file to the output 4217 object file when linking. */ 4218 static bool 4219 elf64_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 4220 { 4221 bfd *obfd = info->output_bfd; 4222 flagword out_flags; 4223 flagword in_flags; 4224 bool ok = true; 4225 4226 /* FIXME: What should be checked when linking shared libraries? */ 4227 if ((ibfd->flags & DYNAMIC) != 0) 4228 return true; 4229 4230 /* Don't even pretend to support mixed-format linking. */ 4231 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4232 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4233 return false; 4234 4235 in_flags = elf_elfheader (ibfd)->e_flags; 4236 out_flags = elf_elfheader (obfd)->e_flags; 4237 4238 if (! elf_flags_init (obfd)) 4239 { 4240 elf_flags_init (obfd) = true; 4241 elf_elfheader (obfd)->e_flags = in_flags; 4242 4243 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4244 && bfd_get_arch_info (obfd)->the_default) 4245 { 4246 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 4247 bfd_get_mach (ibfd)); 4248 } 4249 4250 return true; 4251 } 4252 4253 /* Check flag compatibility. */ 4254 if (in_flags == out_flags) 4255 return true; 4256 4257 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */ 4258 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP)) 4259 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP; 4260 4261 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL)) 4262 { 4263 _bfd_error_handler 4264 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"), 4265 ibfd); 4266 4267 bfd_set_error (bfd_error_bad_value); 4268 ok = false; 4269 } 4270 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE)) 4271 { 4272 _bfd_error_handler 4273 (_("%pB: linking big-endian files with little-endian files"), 4274 ibfd); 4275 4276 bfd_set_error (bfd_error_bad_value); 4277 ok = false; 4278 } 4279 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64)) 4280 { 4281 _bfd_error_handler 4282 (_("%pB: linking 64-bit files with 32-bit files"), 4283 ibfd); 4284 4285 bfd_set_error (bfd_error_bad_value); 4286 ok = false; 4287 } 4288 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP)) 4289 { 4290 _bfd_error_handler 4291 (_("%pB: linking constant-gp files with non-constant-gp files"), 4292 ibfd); 4293 4294 bfd_set_error (bfd_error_bad_value); 4295 ok = false; 4296 } 4297 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP) 4298 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) 4299 { 4300 _bfd_error_handler 4301 (_("%pB: linking auto-pic files with non-auto-pic files"), 4302 ibfd); 4303 4304 bfd_set_error (bfd_error_bad_value); 4305 ok = false; 4306 } 4307 4308 return ok; 4309 } 4310 4311 static bool 4312 elf64_ia64_print_private_bfd_data (bfd *abfd, void * ptr) 4313 { 4314 FILE *file = (FILE *) ptr; 4315 flagword flags = elf_elfheader (abfd)->e_flags; 4316 4317 BFD_ASSERT (abfd != NULL && ptr != NULL); 4318 4319 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n", 4320 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "", 4321 (flags & EF_IA_64_EXT) ? "EXT, " : "", 4322 (flags & EF_IA_64_BE) ? "BE, " : "LE, ", 4323 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "", 4324 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "", 4325 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "", 4326 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "", 4327 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32"); 4328 4329 _bfd_elf_print_private_bfd_data (abfd, ptr); 4330 return true; 4331 } 4332 4333 static enum elf_reloc_type_class 4334 elf64_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 4335 const asection *rel_sec ATTRIBUTE_UNUSED, 4336 const Elf_Internal_Rela *rela) 4337 { 4338 switch ((int) ELF64_R_TYPE (rela->r_info)) 4339 { 4340 case R_IA64_REL32MSB: 4341 case R_IA64_REL32LSB: 4342 case R_IA64_REL64MSB: 4343 case R_IA64_REL64LSB: 4344 return reloc_class_relative; 4345 case R_IA64_IPLTMSB: 4346 case R_IA64_IPLTLSB: 4347 return reloc_class_plt; 4348 case R_IA64_COPY: 4349 return reloc_class_copy; 4350 default: 4351 return reloc_class_normal; 4352 } 4353 } 4354 4355 static const struct bfd_elf_special_section elf64_ia64_special_sections[] = 4356 { 4357 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, 4358 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, 4359 { NULL, 0, 0, 0, 0 } 4360 }; 4361 4362 static bool 4363 elf64_ia64_object_p (bfd *abfd) 4364 { 4365 asection *sec; 4366 asection *group, *unwi, *unw; 4367 flagword flags; 4368 const char *name; 4369 char *unwi_name, *unw_name; 4370 size_t amt; 4371 4372 if (abfd->flags & DYNAMIC) 4373 return true; 4374 4375 /* Flags for fake group section. */ 4376 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE 4377 | SEC_EXCLUDE); 4378 4379 /* We add a fake section group for each .gnu.linkonce.t.* section, 4380 which isn't in a section group, and its unwind sections. */ 4381 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4382 { 4383 if (elf_sec_group (sec) == NULL 4384 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP)) 4385 == (SEC_LINK_ONCE | SEC_CODE)) 4386 && startswith (sec->name, ".gnu.linkonce.t.")) 4387 { 4388 name = sec->name + 16; 4389 4390 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi."); 4391 unwi_name = bfd_alloc (abfd, amt); 4392 if (!unwi_name) 4393 return false; 4394 4395 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name); 4396 unwi = bfd_get_section_by_name (abfd, unwi_name); 4397 4398 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw."); 4399 unw_name = bfd_alloc (abfd, amt); 4400 if (!unw_name) 4401 return false; 4402 4403 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name); 4404 unw = bfd_get_section_by_name (abfd, unw_name); 4405 4406 /* We need to create a fake group section for it and its 4407 unwind sections. */ 4408 group = bfd_make_section_anyway_with_flags (abfd, name, 4409 flags); 4410 if (group == NULL) 4411 return false; 4412 4413 /* Move the fake group section to the beginning. */ 4414 bfd_section_list_remove (abfd, group); 4415 bfd_section_list_prepend (abfd, group); 4416 4417 elf_next_in_group (group) = sec; 4418 4419 elf_group_name (sec) = name; 4420 elf_next_in_group (sec) = sec; 4421 elf_sec_group (sec) = group; 4422 4423 if (unwi) 4424 { 4425 elf_group_name (unwi) = name; 4426 elf_next_in_group (unwi) = sec; 4427 elf_next_in_group (sec) = unwi; 4428 elf_sec_group (unwi) = group; 4429 } 4430 4431 if (unw) 4432 { 4433 elf_group_name (unw) = name; 4434 if (unwi) 4435 { 4436 elf_next_in_group (unw) = elf_next_in_group (unwi); 4437 elf_next_in_group (unwi) = unw; 4438 } 4439 else 4440 { 4441 elf_next_in_group (unw) = sec; 4442 elf_next_in_group (sec) = unw; 4443 } 4444 elf_sec_group (unw) = group; 4445 } 4446 4447 /* Fake SHT_GROUP section header. */ 4448 elf_section_data (group)->this_hdr.bfd_section = group; 4449 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP; 4450 } 4451 } 4452 return true; 4453 } 4454 4455 /* Handle an IA-64 specific section when reading an object file. This 4456 is called when bfd_section_from_shdr finds a section with an unknown 4457 type. */ 4458 4459 static bool 4460 elf64_vms_section_from_shdr (bfd *abfd, 4461 Elf_Internal_Shdr *hdr, 4462 const char *name, 4463 int shindex) 4464 { 4465 flagword secflags = 0; 4466 4467 switch (hdr->sh_type) 4468 { 4469 case SHT_IA_64_VMS_TRACE: 4470 case SHT_IA_64_VMS_DEBUG: 4471 case SHT_IA_64_VMS_DEBUG_STR: 4472 secflags = SEC_DEBUGGING; 4473 break; 4474 4475 case SHT_IA_64_UNWIND: 4476 case SHT_IA_64_HP_OPT_ANOT: 4477 break; 4478 4479 case SHT_IA_64_EXT: 4480 if (strcmp (name, ELF_STRING_ia64_archext) != 0) 4481 return false; 4482 break; 4483 4484 default: 4485 return false; 4486 } 4487 4488 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 4489 return false; 4490 4491 if (secflags != 0) 4492 { 4493 asection *newsect = hdr->bfd_section; 4494 4495 if (!bfd_set_section_flags (newsect, 4496 bfd_section_flags (newsect) | secflags)) 4497 return false; 4498 } 4499 4500 return true; 4501 } 4502 4503 static bool 4504 elf64_vms_object_p (bfd *abfd) 4505 { 4506 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); 4507 Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr; 4508 unsigned int i; 4509 unsigned int num_text = 0; 4510 unsigned int num_data = 0; 4511 unsigned int num_rodata = 0; 4512 char name[16]; 4513 4514 if (!elf64_ia64_object_p (abfd)) 4515 return false; 4516 4517 /* Many VMS compilers do not generate sections for the corresponding 4518 segment. This is boring as binutils tools won't be able to disassemble 4519 the code. So we simply create all the missing sections. */ 4520 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++) 4521 { 4522 /* Is there a section for this segment? */ 4523 bfd_vma base_vma = i_phdr->p_vaddr; 4524 bfd_vma limit_vma = base_vma + i_phdr->p_filesz; 4525 4526 if (i_phdr->p_type != PT_LOAD) 4527 continue; 4528 4529 /* We need to cover from base_vms to limit_vma. */ 4530 again: 4531 while (base_vma < limit_vma) 4532 { 4533 bfd_vma next_vma = limit_vma; 4534 asection *nsec; 4535 asection *sec; 4536 flagword flags; 4537 char *nname = NULL; 4538 4539 /* Find a section covering [base_vma;limit_vma) */ 4540 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4541 { 4542 /* Skip uninteresting sections (either not in memory or 4543 below base_vma. */ 4544 if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0 4545 || sec->vma + sec->size <= base_vma) 4546 continue; 4547 if (sec->vma <= base_vma) 4548 { 4549 /* This section covers (maybe partially) the beginning 4550 of the range. */ 4551 base_vma = sec->vma + sec->size; 4552 goto again; 4553 } 4554 if (sec->vma < next_vma) 4555 { 4556 /* This section partially covers the end of the range. 4557 Used to compute the size of the hole. */ 4558 next_vma = sec->vma; 4559 } 4560 } 4561 4562 /* No section covering [base_vma; next_vma). Create a fake one. */ 4563 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS; 4564 if (i_phdr->p_flags & PF_X) 4565 { 4566 flags |= SEC_CODE; 4567 if (num_text++ == 0) 4568 nname = ".text"; 4569 else 4570 sprintf (name, ".text$%u", num_text); 4571 } 4572 else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R) 4573 { 4574 flags |= SEC_READONLY; 4575 sprintf (name, ".rodata$%u", num_rodata++); 4576 } 4577 else 4578 { 4579 flags |= SEC_DATA; 4580 sprintf (name, ".data$%u", num_data++); 4581 } 4582 4583 /* Allocate name. */ 4584 if (nname == NULL) 4585 { 4586 size_t name_len = strlen (name) + 1; 4587 nname = bfd_alloc (abfd, name_len); 4588 if (nname == NULL) 4589 return false; 4590 memcpy (nname, name, name_len); 4591 } 4592 4593 /* Create and fill new section. */ 4594 nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags); 4595 if (nsec == NULL) 4596 return false; 4597 nsec->vma = base_vma; 4598 nsec->size = next_vma - base_vma; 4599 nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr); 4600 4601 base_vma = next_vma; 4602 } 4603 } 4604 return true; 4605 } 4606 4607 static bool 4608 elf64_vms_init_file_header (bfd *abfd, struct bfd_link_info *info) 4609 { 4610 Elf_Internal_Ehdr *i_ehdrp; 4611 4612 if (!_bfd_elf_init_file_header (abfd, info)) 4613 return false; 4614 4615 i_ehdrp = elf_elfheader (abfd); 4616 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS; 4617 i_ehdrp->e_ident[EI_ABIVERSION] = 2; 4618 return true; 4619 } 4620 4621 static bool 4622 elf64_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED, 4623 Elf_Internal_Shdr *hdr) 4624 { 4625 if (hdr->bfd_section != NULL) 4626 { 4627 const char *name = bfd_section_name (hdr->bfd_section); 4628 4629 if (strcmp (name, ".text") == 0) 4630 hdr->sh_flags |= SHF_IA_64_VMS_SHARED; 4631 else if ((strcmp (name, ".debug") == 0) 4632 || (strcmp (name, ".debug_abbrev") == 0) 4633 || (strcmp (name, ".debug_aranges") == 0) 4634 || (strcmp (name, ".debug_frame") == 0) 4635 || (strcmp (name, ".debug_info") == 0) 4636 || (strcmp (name, ".debug_loc") == 0) 4637 || (strcmp (name, ".debug_macinfo") == 0) 4638 || (strcmp (name, ".debug_pubnames") == 0) 4639 || (strcmp (name, ".debug_pubtypes") == 0)) 4640 hdr->sh_type = SHT_IA_64_VMS_DEBUG; 4641 else if ((strcmp (name, ".debug_line") == 0) 4642 || (strcmp (name, ".debug_ranges") == 0) 4643 || (strcmp (name, ".trace_info") == 0) 4644 || (strcmp (name, ".trace_abbrev") == 0) 4645 || (strcmp (name, ".trace_aranges") == 0)) 4646 hdr->sh_type = SHT_IA_64_VMS_TRACE; 4647 else if (strcmp (name, ".debug_str") == 0) 4648 hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR; 4649 } 4650 4651 return true; 4652 } 4653 4654 /* The final processing done just before writing out a VMS IA-64 ELF 4655 object file. */ 4656 4657 static bool 4658 elf64_vms_final_write_processing (bfd *abfd) 4659 { 4660 Elf_Internal_Shdr *hdr; 4661 asection *s; 4662 int unwind_info_sect_idx = 0; 4663 4664 for (s = abfd->sections; s; s = s->next) 4665 { 4666 hdr = &elf_section_data (s)->this_hdr; 4667 4668 if (strcmp (bfd_section_name (hdr->bfd_section), 4669 ".IA_64.unwind_info") == 0) 4670 unwind_info_sect_idx = elf_section_data (s)->this_idx; 4671 4672 switch (hdr->sh_type) 4673 { 4674 case SHT_IA_64_UNWIND: 4675 /* VMS requires sh_info to point to the unwind info section. */ 4676 hdr->sh_info = unwind_info_sect_idx; 4677 break; 4678 } 4679 } 4680 4681 if (! elf_flags_init (abfd)) 4682 { 4683 unsigned long flags = 0; 4684 4685 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG) 4686 flags |= EF_IA_64_BE; 4687 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64) 4688 flags |= EF_IA_64_ABI64; 4689 4690 elf_elfheader (abfd)->e_flags = flags; 4691 elf_flags_init (abfd) = true; 4692 } 4693 return _bfd_elf_final_write_processing (abfd); 4694 } 4695 4696 static bool 4697 elf64_vms_write_shdrs_and_ehdr (bfd *abfd) 4698 { 4699 unsigned char needed_count[8]; 4700 4701 if (!bfd_elf64_write_shdrs_and_ehdr (abfd)) 4702 return false; 4703 4704 bfd_putl64 (elf_ia64_vms_tdata (abfd)->needed_count, needed_count); 4705 4706 if (bfd_seek (abfd, sizeof (Elf64_External_Ehdr), SEEK_SET) != 0 4707 || bfd_write (needed_count, 8, abfd) != 8) 4708 return false; 4709 4710 return true; 4711 } 4712 4713 static bool 4714 elf64_vms_close_and_cleanup (bfd *abfd) 4715 { 4716 bool ret = true; 4717 if (bfd_get_format (abfd) == bfd_object 4718 && bfd_write_p (abfd)) 4719 { 4720 long isize; 4721 4722 /* Pad to 8 byte boundary for IPF/VMS. */ 4723 isize = bfd_get_size (abfd); 4724 if ((isize & 7) != 0) 4725 { 4726 unsigned int ishort = 8 - (isize & 7); 4727 uint64_t pad = 0; 4728 4729 if (bfd_seek (abfd, isize, SEEK_SET) != 0 4730 || bfd_write (&pad, ishort, abfd) != ishort) 4731 ret = false; 4732 } 4733 } 4734 4735 return _bfd_generic_close_and_cleanup (abfd) && ret; 4736 } 4737 4738 /* Add symbols from an ELF object file to the linker hash table. */ 4739 4740 static bool 4741 elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 4742 { 4743 Elf_Internal_Shdr *hdr; 4744 bfd_size_type symcount; 4745 bfd_size_type extsymcount; 4746 bfd_size_type extsymoff; 4747 struct elf_link_hash_entry **sym_hash; 4748 bool dynamic; 4749 Elf_Internal_Sym *isymbuf = NULL; 4750 Elf_Internal_Sym *isym; 4751 Elf_Internal_Sym *isymend; 4752 const struct elf_backend_data *bed; 4753 struct elf_link_hash_table *htab; 4754 bfd_size_type amt; 4755 4756 htab = elf_hash_table (info); 4757 bed = get_elf_backend_data (abfd); 4758 4759 if ((abfd->flags & DYNAMIC) == 0) 4760 dynamic = false; 4761 else 4762 { 4763 dynamic = true; 4764 4765 /* You can't use -r against a dynamic object. Also, there's no 4766 hope of using a dynamic object which does not exactly match 4767 the format of the output file. */ 4768 if (bfd_link_relocatable (info) 4769 || !is_elf_hash_table (&htab->root) 4770 || info->output_bfd->xvec != abfd->xvec) 4771 { 4772 if (bfd_link_relocatable (info)) 4773 bfd_set_error (bfd_error_invalid_operation); 4774 else 4775 bfd_set_error (bfd_error_wrong_format); 4776 goto error_return; 4777 } 4778 } 4779 4780 if (! dynamic) 4781 { 4782 /* If we are creating a shared library, create all the dynamic 4783 sections immediately. We need to attach them to something, 4784 so we attach them to this BFD, provided it is the right 4785 format. FIXME: If there are no input BFD's of the same 4786 format as the output, we can't make a shared library. */ 4787 if (bfd_link_pic (info) 4788 && is_elf_hash_table (&htab->root) 4789 && info->output_bfd->xvec == abfd->xvec 4790 && !htab->dynamic_sections_created) 4791 { 4792 if (! elf64_ia64_create_dynamic_sections (abfd, info)) 4793 goto error_return; 4794 } 4795 } 4796 else if (!is_elf_hash_table (&htab->root)) 4797 goto error_return; 4798 else 4799 { 4800 asection *s; 4801 bfd_byte *dynbuf; 4802 bfd_byte *extdyn; 4803 4804 /* ld --just-symbols and dynamic objects don't mix very well. 4805 ld shouldn't allow it. */ 4806 if ((s = abfd->sections) != NULL 4807 && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 4808 abort (); 4809 4810 /* Be sure there are dynamic sections. */ 4811 if (! elf64_ia64_create_dynamic_sections (htab->dynobj, info)) 4812 goto error_return; 4813 4814 s = bfd_get_section_by_name (abfd, ".dynamic"); 4815 if (s == NULL) 4816 { 4817 /* VMS libraries do not have dynamic sections. Create one from 4818 the segment. */ 4819 Elf_Internal_Phdr *phdr; 4820 unsigned int i, phnum; 4821 4822 phdr = elf_tdata (abfd)->phdr; 4823 if (phdr == NULL) 4824 goto error_return; 4825 phnum = elf_elfheader (abfd)->e_phnum; 4826 for (i = 0; i < phnum; phdr++) 4827 if (phdr->p_type == PT_DYNAMIC) 4828 { 4829 s = bfd_make_section (abfd, ".dynamic"); 4830 if (s == NULL) 4831 goto error_return; 4832 s->vma = phdr->p_vaddr; 4833 s->lma = phdr->p_paddr; 4834 s->size = phdr->p_filesz; 4835 s->filepos = phdr->p_offset; 4836 s->flags |= SEC_HAS_CONTENTS; 4837 s->alignment_power = bfd_log2 (phdr->p_align); 4838 break; 4839 } 4840 if (s == NULL) 4841 goto error_return; 4842 } 4843 4844 /* Extract IDENT. */ 4845 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 4846 { 4847 error_free_dyn: 4848 free (dynbuf); 4849 goto error_return; 4850 } 4851 4852 for (extdyn = dynbuf; 4853 (size_t) (dynbuf + s->size - extdyn) >= bed->s->sizeof_dyn; 4854 extdyn += bed->s->sizeof_dyn) 4855 { 4856 Elf_Internal_Dyn dyn; 4857 4858 bed->s->swap_dyn_in (abfd, extdyn, &dyn); 4859 if (dyn.d_tag == DT_IA_64_VMS_IDENT) 4860 { 4861 uint64_t tagv = dyn.d_un.d_val; 4862 elf_ia64_vms_ident (abfd) = tagv; 4863 break; 4864 } 4865 } 4866 if (extdyn >= dynbuf + s->size) 4867 { 4868 /* Ident not found. */ 4869 goto error_free_dyn; 4870 } 4871 free (dynbuf); 4872 4873 /* We do not want to include any of the sections in a dynamic 4874 object in the output file. We hack by simply clobbering the 4875 list of sections in the BFD. This could be handled more 4876 cleanly by, say, a new section flag; the existing 4877 SEC_NEVER_LOAD flag is not the one we want, because that one 4878 still implies that the section takes up space in the output 4879 file. */ 4880 bfd_section_list_clear (abfd); 4881 4882 /* FIXME: should we detect if this library is already included ? 4883 This should be harmless and shouldn't happen in practice. */ 4884 } 4885 4886 hdr = &elf_tdata (abfd)->symtab_hdr; 4887 symcount = hdr->sh_size / bed->s->sizeof_sym; 4888 4889 /* The sh_info field of the symtab header tells us where the 4890 external symbols start. We don't care about the local symbols at 4891 this point. */ 4892 extsymcount = symcount - hdr->sh_info; 4893 extsymoff = hdr->sh_info; 4894 4895 sym_hash = NULL; 4896 if (extsymcount != 0) 4897 { 4898 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, 4899 NULL, NULL, NULL); 4900 if (isymbuf == NULL) 4901 goto error_return; 4902 4903 /* We store a pointer to the hash table entry for each external 4904 symbol. */ 4905 amt = extsymcount * sizeof (struct elf_link_hash_entry *); 4906 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt); 4907 if (sym_hash == NULL) 4908 goto error_free_sym; 4909 elf_sym_hashes (abfd) = sym_hash; 4910 } 4911 4912 for (isym = isymbuf, isymend = isymbuf + extsymcount; 4913 isym < isymend; 4914 isym++, sym_hash++) 4915 { 4916 int bind; 4917 bfd_vma value; 4918 asection *sec, *new_sec; 4919 flagword flags; 4920 const char *name; 4921 struct elf_link_hash_entry *h; 4922 bool definition; 4923 bool size_change_ok; 4924 bool type_change_ok; 4925 bool common; 4926 unsigned int old_alignment; 4927 bfd *old_bfd; 4928 4929 flags = BSF_NO_FLAGS; 4930 sec = NULL; 4931 value = isym->st_value; 4932 *sym_hash = NULL; 4933 common = bed->common_definition (isym); 4934 4935 bind = ELF_ST_BIND (isym->st_info); 4936 switch (bind) 4937 { 4938 case STB_LOCAL: 4939 /* This should be impossible, since ELF requires that all 4940 global symbols follow all local symbols, and that sh_info 4941 point to the first global symbol. Unfortunately, Irix 5 4942 screws this up. */ 4943 continue; 4944 4945 case STB_GLOBAL: 4946 if (isym->st_shndx != SHN_UNDEF && !common) 4947 flags = BSF_GLOBAL; 4948 break; 4949 4950 case STB_WEAK: 4951 flags = BSF_WEAK; 4952 break; 4953 4954 case STB_GNU_UNIQUE: 4955 flags = BSF_GNU_UNIQUE; 4956 break; 4957 4958 default: 4959 /* Leave it up to the processor backend. */ 4960 break; 4961 } 4962 4963 if (isym->st_shndx == SHN_UNDEF) 4964 sec = bfd_und_section_ptr; 4965 else if (isym->st_shndx == SHN_ABS) 4966 sec = bfd_abs_section_ptr; 4967 else if (isym->st_shndx == SHN_COMMON) 4968 { 4969 sec = bfd_com_section_ptr; 4970 /* What ELF calls the size we call the value. What ELF 4971 calls the value we call the alignment. */ 4972 value = isym->st_size; 4973 } 4974 else 4975 { 4976 sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 4977 if (sec == NULL) 4978 sec = bfd_abs_section_ptr; 4979 else if (sec->kept_section) 4980 { 4981 /* Symbols from discarded section are undefined. We keep 4982 its visibility. */ 4983 sec = bfd_und_section_ptr; 4984 isym->st_shndx = SHN_UNDEF; 4985 } 4986 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 4987 value -= sec->vma; 4988 } 4989 4990 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 4991 isym->st_name); 4992 if (name == NULL) 4993 goto error_free_vers; 4994 4995 if (bed->elf_add_symbol_hook) 4996 { 4997 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags, 4998 &sec, &value)) 4999 goto error_free_vers; 5000 5001 /* The hook function sets the name to NULL if this symbol 5002 should be skipped for some reason. */ 5003 if (name == NULL) 5004 continue; 5005 } 5006 5007 /* Sanity check that all possibilities were handled. */ 5008 if (sec == NULL) 5009 { 5010 bfd_set_error (bfd_error_bad_value); 5011 goto error_free_vers; 5012 } 5013 5014 if (bfd_is_und_section (sec) 5015 || bfd_is_com_section (sec)) 5016 definition = false; 5017 else 5018 definition = true; 5019 5020 size_change_ok = false; 5021 type_change_ok = bed->type_change_ok; 5022 old_alignment = 0; 5023 old_bfd = NULL; 5024 new_sec = sec; 5025 5026 if (! bfd_is_und_section (sec)) 5027 h = elf_link_hash_lookup (htab, name, true, false, false); 5028 else 5029 h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup 5030 (abfd, info, name, true, false, false)); 5031 if (h == NULL) 5032 goto error_free_sym; 5033 5034 *sym_hash = h; 5035 5036 if (is_elf_hash_table (&htab->root)) 5037 { 5038 while (h->root.type == bfd_link_hash_indirect 5039 || h->root.type == bfd_link_hash_warning) 5040 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5041 5042 /* Remember the old alignment if this is a common symbol, so 5043 that we don't reduce the alignment later on. We can't 5044 check later, because _bfd_generic_link_add_one_symbol 5045 will set a default for the alignment which we want to 5046 override. We also remember the old bfd where the existing 5047 definition comes from. */ 5048 switch (h->root.type) 5049 { 5050 default: 5051 break; 5052 5053 case bfd_link_hash_defined: 5054 if (abfd->selective_search) 5055 continue; 5056 /* Fall-through. */ 5057 case bfd_link_hash_defweak: 5058 old_bfd = h->root.u.def.section->owner; 5059 break; 5060 5061 case bfd_link_hash_common: 5062 old_bfd = h->root.u.c.p->section->owner; 5063 old_alignment = h->root.u.c.p->alignment_power; 5064 break; 5065 } 5066 } 5067 5068 if (! (_bfd_generic_link_add_one_symbol 5069 (info, abfd, name, flags, sec, value, NULL, false, bed->collect, 5070 (struct bfd_link_hash_entry **) sym_hash))) 5071 goto error_free_vers; 5072 5073 h = *sym_hash; 5074 while (h->root.type == bfd_link_hash_indirect 5075 || h->root.type == bfd_link_hash_warning) 5076 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5077 5078 *sym_hash = h; 5079 if (definition) 5080 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0; 5081 5082 /* Set the alignment of a common symbol. */ 5083 if ((common || bfd_is_com_section (sec)) 5084 && h->root.type == bfd_link_hash_common) 5085 { 5086 unsigned int align; 5087 5088 if (common) 5089 align = bfd_log2 (isym->st_value); 5090 else 5091 { 5092 /* The new symbol is a common symbol in a shared object. 5093 We need to get the alignment from the section. */ 5094 align = new_sec->alignment_power; 5095 } 5096 if (align > old_alignment 5097 /* Permit an alignment power of zero if an alignment of one 5098 is specified and no other alignments have been specified. */ 5099 || (isym->st_value == 1 && old_alignment == 0)) 5100 h->root.u.c.p->alignment_power = align; 5101 else 5102 h->root.u.c.p->alignment_power = old_alignment; 5103 } 5104 5105 if (is_elf_hash_table (&htab->root)) 5106 { 5107 /* Check the alignment when a common symbol is involved. This 5108 can change when a common symbol is overridden by a normal 5109 definition or a common symbol is ignored due to the old 5110 normal definition. We need to make sure the maximum 5111 alignment is maintained. */ 5112 if ((old_alignment || common) 5113 && h->root.type != bfd_link_hash_common) 5114 { 5115 unsigned int common_align; 5116 unsigned int normal_align; 5117 unsigned int symbol_align; 5118 bfd *normal_bfd; 5119 bfd *common_bfd; 5120 5121 symbol_align = ffs (h->root.u.def.value) - 1; 5122 if (h->root.u.def.section->owner != NULL 5123 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0) 5124 { 5125 normal_align = h->root.u.def.section->alignment_power; 5126 if (normal_align > symbol_align) 5127 normal_align = symbol_align; 5128 } 5129 else 5130 normal_align = symbol_align; 5131 5132 if (old_alignment) 5133 { 5134 common_align = old_alignment; 5135 common_bfd = old_bfd; 5136 normal_bfd = abfd; 5137 } 5138 else 5139 { 5140 common_align = bfd_log2 (isym->st_value); 5141 common_bfd = abfd; 5142 normal_bfd = old_bfd; 5143 } 5144 5145 if (normal_align < common_align) 5146 { 5147 /* PR binutils/2735 */ 5148 if (normal_bfd == NULL) 5149 _bfd_error_handler 5150 /* xgettext:c-format */ 5151 (_("warning: alignment %u of common symbol `%s' in %pB" 5152 " is greater than the alignment (%u) of its section %pA"), 5153 1 << common_align, name, common_bfd, 5154 1 << normal_align, h->root.u.def.section); 5155 else 5156 _bfd_error_handler 5157 /* xgettext:c-format */ 5158 (_("warning: alignment %u of symbol `%s' in %pB" 5159 " is smaller than %u in %pB"), 5160 1 << normal_align, name, normal_bfd, 5161 1 << common_align, common_bfd); 5162 } 5163 } 5164 5165 /* Remember the symbol size if it isn't undefined. */ 5166 if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF) 5167 && (definition || h->size == 0)) 5168 { 5169 if (h->size != 0 5170 && h->size != isym->st_size 5171 && ! size_change_ok) 5172 _bfd_error_handler 5173 /* xgettext:c-format */ 5174 (_("warning: size of symbol `%s' changed" 5175 " from %" PRIu64 " in %pB to %" PRIu64 " in %pB"), 5176 name, (uint64_t) h->size, old_bfd, 5177 (uint64_t) isym->st_size, abfd); 5178 5179 h->size = isym->st_size; 5180 } 5181 5182 /* If this is a common symbol, then we always want H->SIZE 5183 to be the size of the common symbol. The code just above 5184 won't fix the size if a common symbol becomes larger. We 5185 don't warn about a size change here, because that is 5186 covered by --warn-common. Allow changed between different 5187 function types. */ 5188 if (h->root.type == bfd_link_hash_common) 5189 h->size = h->root.u.c.size; 5190 5191 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE 5192 && (definition || h->type == STT_NOTYPE)) 5193 { 5194 unsigned int type = ELF_ST_TYPE (isym->st_info); 5195 5196 if (h->type != type) 5197 { 5198 if (h->type != STT_NOTYPE && ! type_change_ok) 5199 _bfd_error_handler 5200 /* xgettext:c-format */ 5201 (_("warning: type of symbol `%s' changed" 5202 " from %d to %d in %pB"), 5203 name, h->type, type, abfd); 5204 5205 h->type = type; 5206 } 5207 } 5208 5209 /* Set a flag in the hash table entry indicating the type of 5210 reference or definition we just found. Keep a count of 5211 the number of dynamic symbols we find. A dynamic symbol 5212 is one which is referenced or defined by both a regular 5213 object and a shared object. */ 5214 if (! dynamic) 5215 { 5216 if (! definition) 5217 { 5218 h->ref_regular = 1; 5219 if (bind != STB_WEAK) 5220 h->ref_regular_nonweak = 1; 5221 } 5222 else 5223 { 5224 BFD_ASSERT (!h->def_dynamic); 5225 h->def_regular = 1; 5226 } 5227 } 5228 else 5229 { 5230 BFD_ASSERT (definition); 5231 h->def_dynamic = 1; 5232 h->dynindx = -2; 5233 ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd; 5234 } 5235 } 5236 } 5237 5238 free (isymbuf); 5239 isymbuf = NULL; 5240 5241 /* If this object is the same format as the output object, and it is 5242 not a shared library, then let the backend look through the 5243 relocs. 5244 5245 This is required to build global offset table entries and to 5246 arrange for dynamic relocs. It is not required for the 5247 particular common case of linking non PIC code, even when linking 5248 against shared libraries, but unfortunately there is no way of 5249 knowing whether an object file has been compiled PIC or not. 5250 Looking through the relocs is not particularly time consuming. 5251 The problem is that we must either (1) keep the relocs in memory, 5252 which causes the linker to require additional runtime memory or 5253 (2) read the relocs twice from the input file, which wastes time. 5254 This would be a good case for using mmap. 5255 5256 I have no idea how to handle linking PIC code into a file of a 5257 different format. It probably can't be done. */ 5258 if (! dynamic 5259 && is_elf_hash_table (&htab->root) 5260 && bed->check_relocs != NULL 5261 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec)) 5262 { 5263 asection *o; 5264 5265 for (o = abfd->sections; o != NULL; o = o->next) 5266 { 5267 Elf_Internal_Rela *internal_relocs; 5268 bool ok; 5269 5270 if ((o->flags & SEC_RELOC) == 0 5271 || o->reloc_count == 0 5272 || ((info->strip == strip_all || info->strip == strip_debugger) 5273 && (o->flags & SEC_DEBUGGING) != 0) 5274 || bfd_is_abs_section (o->output_section)) 5275 continue; 5276 5277 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 5278 info->keep_memory); 5279 if (internal_relocs == NULL) 5280 goto error_return; 5281 5282 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs); 5283 5284 if (elf_section_data (o)->relocs != internal_relocs) 5285 free (internal_relocs); 5286 5287 if (! ok) 5288 goto error_return; 5289 } 5290 } 5291 5292 return true; 5293 5294 error_free_vers: 5295 error_free_sym: 5296 free (isymbuf); 5297 error_return: 5298 return false; 5299 } 5300 5301 static bool 5302 elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 5303 { 5304 int pass; 5305 struct bfd_link_hash_entry **pundef; 5306 struct bfd_link_hash_entry **next_pundef; 5307 5308 /* We only accept VMS libraries. */ 5309 if (info->output_bfd->xvec != abfd->xvec) 5310 { 5311 bfd_set_error (bfd_error_wrong_format); 5312 return false; 5313 } 5314 5315 /* The archive_pass field in the archive itself is used to 5316 initialize PASS, since we may search the same archive multiple 5317 times. */ 5318 pass = ++abfd->archive_pass; 5319 5320 /* Look through the list of undefined symbols. */ 5321 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef) 5322 { 5323 struct bfd_link_hash_entry *h; 5324 symindex symidx; 5325 bfd *element; 5326 bfd *orig_element; 5327 5328 h = *pundef; 5329 next_pundef = &(*pundef)->u.undef.next; 5330 5331 /* When a symbol is defined, it is not necessarily removed from 5332 the list. */ 5333 if (h->type != bfd_link_hash_undefined 5334 && h->type != bfd_link_hash_common) 5335 { 5336 /* Remove this entry from the list, for general cleanliness 5337 and because we are going to look through the list again 5338 if we search any more libraries. We can't remove the 5339 entry if it is the tail, because that would lose any 5340 entries we add to the list later on. */ 5341 if (*pundef != info->hash->undefs_tail) 5342 { 5343 *pundef = *next_pundef; 5344 next_pundef = pundef; 5345 } 5346 continue; 5347 } 5348 5349 /* Look for this symbol in the archive hash table. */ 5350 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string); 5351 if (symidx == BFD_NO_MORE_SYMBOLS) 5352 { 5353 /* Nothing in this slot. */ 5354 continue; 5355 } 5356 5357 element = bfd_get_elt_at_index (abfd, symidx); 5358 if (element == NULL) 5359 return false; 5360 5361 if (element->archive_pass == -1 || element->archive_pass == pass) 5362 { 5363 /* Next symbol if this archive is wrong or already handled. */ 5364 continue; 5365 } 5366 5367 orig_element = element; 5368 if (bfd_is_thin_archive (abfd)) 5369 { 5370 element = _bfd_vms_lib_get_imagelib_file (element); 5371 if (element == NULL || !bfd_check_format (element, bfd_object)) 5372 { 5373 orig_element->archive_pass = -1; 5374 return false; 5375 } 5376 } 5377 else if (! bfd_check_format (element, bfd_object)) 5378 { 5379 element->archive_pass = -1; 5380 return false; 5381 } 5382 5383 /* Unlike the generic linker, we know that this element provides 5384 a definition for an undefined symbol and we know that we want 5385 to include it. We don't need to check anything. */ 5386 if (! (*info->callbacks->add_archive_element) (info, element, 5387 h->root.string, &element)) 5388 continue; 5389 if (! elf64_vms_link_add_object_symbols (element, info)) 5390 return false; 5391 5392 orig_element->archive_pass = pass; 5393 } 5394 5395 return true; 5396 } 5397 5398 static bool 5399 elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 5400 { 5401 switch (bfd_get_format (abfd)) 5402 { 5403 case bfd_object: 5404 return elf64_vms_link_add_object_symbols (abfd, info); 5405 break; 5406 case bfd_archive: 5407 return elf64_vms_link_add_archive_symbols (abfd, info); 5408 break; 5409 default: 5410 bfd_set_error (bfd_error_wrong_format); 5411 return false; 5412 } 5413 } 5414 5415 static bool 5416 elf64_ia64_vms_mkobject (bfd *abfd) 5417 { 5418 return bfd_elf_allocate_object (abfd, 5419 sizeof (struct elf64_ia64_vms_obj_tdata)); 5420 } 5421 5422 5423 /* Size-dependent data and functions. */ 5424 static const struct elf_size_info elf64_ia64_vms_size_info = { 5425 sizeof (Elf64_External_VMS_Ehdr), 5426 sizeof (Elf64_External_Phdr), 5427 sizeof (Elf64_External_Shdr), 5428 sizeof (Elf64_External_Rel), 5429 sizeof (Elf64_External_Rela), 5430 sizeof (Elf64_External_Sym), 5431 sizeof (Elf64_External_Dyn), 5432 sizeof (Elf_External_Note), 5433 4, 5434 1, 5435 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */ 5436 ELFCLASS64, EV_CURRENT, 5437 bfd_elf64_write_out_phdrs, 5438 elf64_vms_write_shdrs_and_ehdr, 5439 bfd_elf64_checksum_contents, 5440 bfd_elf64_write_relocs, 5441 bfd_elf64_swap_symbol_in, 5442 bfd_elf64_swap_symbol_out, 5443 bfd_elf64_slurp_reloc_table, 5444 bfd_elf64_slurp_symbol_table, 5445 bfd_elf64_swap_dyn_in, 5446 bfd_elf64_swap_dyn_out, 5447 bfd_elf64_swap_reloc_in, 5448 bfd_elf64_swap_reloc_out, 5449 bfd_elf64_swap_reloca_in, 5450 bfd_elf64_swap_reloca_out 5451 }; 5452 5453 #define ELF_ARCH bfd_arch_ia64 5454 #define ELF_TARGET_ID IA64_ELF_DATA 5455 #define ELF_MACHINE_CODE EM_IA_64 5456 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */ 5457 #define ELF_COMMONPAGESIZE 0x200 /* 16KB */ 5458 5459 #define elf_backend_section_from_shdr \ 5460 elf64_ia64_section_from_shdr 5461 #define elf_backend_section_flags \ 5462 elf64_ia64_section_flags 5463 #define elf_backend_fake_sections \ 5464 elf64_ia64_fake_sections 5465 #define elf_backend_final_write_processing \ 5466 elf64_ia64_final_write_processing 5467 #define elf_backend_add_symbol_hook \ 5468 elf64_ia64_add_symbol_hook 5469 #define elf_info_to_howto \ 5470 elf64_ia64_info_to_howto 5471 5472 #define bfd_elf64_bfd_reloc_type_lookup \ 5473 ia64_elf_reloc_type_lookup 5474 #define bfd_elf64_bfd_reloc_name_lookup \ 5475 ia64_elf_reloc_name_lookup 5476 #define bfd_elf64_bfd_is_local_label_name \ 5477 elf64_ia64_is_local_label_name 5478 #define bfd_elf64_bfd_relax_section \ 5479 elf64_ia64_relax_section 5480 5481 #define elf_backend_object_p \ 5482 elf64_ia64_object_p 5483 5484 /* Stuff for the BFD linker: */ 5485 #define bfd_elf64_bfd_link_hash_table_create \ 5486 elf64_ia64_hash_table_create 5487 #define elf_backend_create_dynamic_sections \ 5488 elf64_ia64_create_dynamic_sections 5489 #define elf_backend_check_relocs \ 5490 elf64_ia64_check_relocs 5491 #define elf_backend_adjust_dynamic_symbol \ 5492 elf64_ia64_adjust_dynamic_symbol 5493 #define elf_backend_late_size_sections \ 5494 elf64_ia64_late_size_sections 5495 #define elf_backend_omit_section_dynsym \ 5496 _bfd_elf_omit_section_dynsym_all 5497 #define elf_backend_relocate_section \ 5498 elf64_ia64_relocate_section 5499 #define elf_backend_finish_dynamic_symbol \ 5500 elf64_ia64_finish_dynamic_symbol 5501 #define elf_backend_finish_dynamic_sections \ 5502 elf64_ia64_finish_dynamic_sections 5503 #define bfd_elf64_bfd_final_link \ 5504 elf64_ia64_final_link 5505 5506 #define bfd_elf64_bfd_merge_private_bfd_data \ 5507 elf64_ia64_merge_private_bfd_data 5508 #define bfd_elf64_bfd_set_private_flags \ 5509 elf64_ia64_set_private_flags 5510 #define bfd_elf64_bfd_print_private_bfd_data \ 5511 elf64_ia64_print_private_bfd_data 5512 5513 #define elf_backend_plt_readonly 1 5514 #define elf_backend_want_plt_sym 0 5515 #define elf_backend_plt_alignment 5 5516 #define elf_backend_got_header_size 0 5517 #define elf_backend_want_got_plt 1 5518 #define elf_backend_may_use_rel_p 1 5519 #define elf_backend_may_use_rela_p 1 5520 #define elf_backend_default_use_rela_p 1 5521 #define elf_backend_want_dynbss 0 5522 #define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol 5523 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol 5524 #define elf_backend_reloc_type_class elf64_ia64_reloc_type_class 5525 #define elf_backend_rela_normal 1 5526 #define elf_backend_special_sections elf64_ia64_special_sections 5527 #define elf_backend_default_execstack 0 5528 5529 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with 5530 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields. 5531 We don't want to flood users with so many error messages. We turn 5532 off the warning for now. It will be turned on later when the Intel 5533 compiler is fixed. */ 5534 #define elf_backend_link_order_error_handler NULL 5535 5536 /* VMS-specific vectors. */ 5537 5538 #undef TARGET_LITTLE_SYM 5539 #define TARGET_LITTLE_SYM ia64_elf64_vms_vec 5540 #undef TARGET_LITTLE_NAME 5541 #define TARGET_LITTLE_NAME "elf64-ia64-vms" 5542 #undef TARGET_BIG_SYM 5543 #undef TARGET_BIG_NAME 5544 5545 /* These are VMS specific functions. */ 5546 5547 #undef elf_backend_object_p 5548 #define elf_backend_object_p elf64_vms_object_p 5549 5550 #undef elf_backend_section_from_shdr 5551 #define elf_backend_section_from_shdr elf64_vms_section_from_shdr 5552 5553 #undef elf_backend_init_file_header 5554 #define elf_backend_init_file_header elf64_vms_init_file_header 5555 5556 #undef elf_backend_section_processing 5557 #define elf_backend_section_processing elf64_vms_section_processing 5558 5559 #undef elf_backend_final_write_processing 5560 #define elf_backend_final_write_processing elf64_vms_final_write_processing 5561 5562 #undef bfd_elf64_close_and_cleanup 5563 #define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup 5564 5565 #undef elf_backend_section_from_bfd_section 5566 5567 #undef elf_backend_symbol_processing 5568 5569 #undef elf_backend_want_p_paddr_set_to_zero 5570 5571 #undef ELF_OSABI 5572 #define ELF_OSABI ELFOSABI_OPENVMS 5573 5574 #undef ELF_MAXPAGESIZE 5575 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */ 5576 5577 #undef elf64_bed 5578 #define elf64_bed elf64_ia64_vms_bed 5579 5580 #define elf_backend_size_info elf64_ia64_vms_size_info 5581 5582 /* Use VMS-style archives (in particular, don't use the standard coff 5583 archive format). */ 5584 #define bfd_elf64_archive_functions 5585 5586 #undef bfd_elf64_archive_p 5587 #define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p 5588 #undef bfd_elf64_write_archive_contents 5589 #define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents 5590 #undef bfd_elf64_mkarchive 5591 #define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive 5592 5593 #define bfd_elf64_archive_slurp_armap \ 5594 _bfd_vms_lib_slurp_armap 5595 #define bfd_elf64_archive_slurp_extended_name_table \ 5596 _bfd_vms_lib_slurp_extended_name_table 5597 #define bfd_elf64_archive_construct_extended_name_table \ 5598 _bfd_vms_lib_construct_extended_name_table 5599 #define bfd_elf64_archive_truncate_arname \ 5600 _bfd_vms_lib_truncate_arname 5601 #define bfd_elf64_archive_write_armap \ 5602 _bfd_vms_lib_write_armap 5603 #define bfd_elf64_archive_read_ar_hdr \ 5604 _bfd_vms_lib_read_ar_hdr 5605 #define bfd_elf64_archive_write_ar_hdr \ 5606 _bfd_vms_lib_write_ar_hdr 5607 #define bfd_elf64_archive_openr_next_archived_file \ 5608 _bfd_vms_lib_openr_next_archived_file 5609 #define bfd_elf64_archive_get_elt_at_index \ 5610 _bfd_vms_lib_get_elt_at_index 5611 #define bfd_elf64_archive_generic_stat_arch_elt \ 5612 _bfd_vms_lib_generic_stat_arch_elt 5613 #define bfd_elf64_archive_update_armap_timestamp \ 5614 _bfd_vms_lib_update_armap_timestamp 5615 5616 /* VMS link methods. */ 5617 #undef bfd_elf64_bfd_link_add_symbols 5618 #define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols 5619 5620 #undef elf_backend_want_got_sym 5621 #define elf_backend_want_got_sym 0 5622 5623 #undef bfd_elf64_mkobject 5624 #define bfd_elf64_mkobject elf64_ia64_vms_mkobject 5625 5626 /* Redefine to align segments on block size. */ 5627 #undef ELF_MAXPAGESIZE 5628 #define ELF_MAXPAGESIZE 0x200 /* 512B */ 5629 5630 #undef elf_backend_want_got_plt 5631 #define elf_backend_want_got_plt 0 5632 5633 #include "elf64-target.h" 5634
Indexes created Thu Mar 26 00:23:24 UTC 2026