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