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