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