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