elfnn-ia64.c revision 1.1.1.9
1 /* IA-64 support for 64-bit ELF 2 Copyright (C) 1998-2025 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->fatal 368 (_("%P: --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 { 1470 free (ret); 1471 return NULL; 1472 } 1473 1474 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash, 1475 elfNN_ia64_local_htab_eq, NULL); 1476 ret->loc_hash_memory = objalloc_create (); 1477 if (!ret->loc_hash_table || !ret->loc_hash_memory) 1478 { 1479 elfNN_ia64_link_hash_table_free (abfd); 1480 return NULL; 1481 } 1482 ret->root.root.hash_table_free = elfNN_ia64_link_hash_table_free; 1483 ret->root.dt_pltgot_required = true; 1484 1485 return &ret->root.root; 1486 } 1487 1488 /* Traverse both local and global hash tables. */ 1489 1490 struct elfNN_ia64_dyn_sym_traverse_data 1491 { 1492 bool (*func) (struct elfNN_ia64_dyn_sym_info *, void *); 1493 void * data; 1494 }; 1495 1496 static bool 1497 elfNN_ia64_global_dyn_sym_thunk (struct elf_link_hash_entry *xentry, 1498 void * xdata) 1499 { 1500 struct elfNN_ia64_link_hash_entry *entry 1501 = (struct elfNN_ia64_link_hash_entry *) xentry; 1502 struct elfNN_ia64_dyn_sym_traverse_data *data 1503 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata; 1504 struct elfNN_ia64_dyn_sym_info *dyn_i; 1505 unsigned int count; 1506 1507 for (count = entry->count, dyn_i = entry->info; 1508 count != 0; 1509 count--, dyn_i++) 1510 if (! (*data->func) (dyn_i, data->data)) 1511 return false; 1512 return true; 1513 } 1514 1515 static int 1516 elfNN_ia64_local_dyn_sym_thunk (void **slot, void * xdata) 1517 { 1518 struct elfNN_ia64_local_hash_entry *entry 1519 = (struct elfNN_ia64_local_hash_entry *) *slot; 1520 struct elfNN_ia64_dyn_sym_traverse_data *data 1521 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata; 1522 struct elfNN_ia64_dyn_sym_info *dyn_i; 1523 unsigned int count; 1524 1525 for (count = entry->count, dyn_i = entry->info; 1526 count != 0; 1527 count--, dyn_i++) 1528 if (! (*data->func) (dyn_i, data->data)) 1529 return false; 1530 return true; 1531 } 1532 1533 static void 1534 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table *ia64_info, 1535 bool (*func) (struct elfNN_ia64_dyn_sym_info *, 1536 void *), 1537 void * data) 1538 { 1539 struct elfNN_ia64_dyn_sym_traverse_data xdata; 1540 1541 xdata.func = func; 1542 xdata.data = data; 1543 1544 elf_link_hash_traverse (&ia64_info->root, 1545 elfNN_ia64_global_dyn_sym_thunk, &xdata); 1546 htab_traverse (ia64_info->loc_hash_table, 1547 elfNN_ia64_local_dyn_sym_thunk, &xdata); 1548 } 1549 1550 static bool 1552 elfNN_ia64_create_dynamic_sections (bfd *abfd, 1553 struct bfd_link_info *info) 1554 { 1555 struct elfNN_ia64_link_hash_table *ia64_info; 1556 asection *s; 1557 1558 if (! _bfd_elf_create_dynamic_sections (abfd, info)) 1559 return false; 1560 1561 ia64_info = elfNN_ia64_hash_table (info); 1562 if (ia64_info == NULL) 1563 return false; 1564 1565 { 1566 flagword flags = bfd_section_flags (ia64_info->root.sgot); 1567 bfd_set_section_flags (ia64_info->root.sgot, SEC_SMALL_DATA | flags); 1568 /* The .got section is always aligned at 8 bytes. */ 1569 if (!bfd_set_section_alignment (ia64_info->root.sgot, 3)) 1570 return false; 1571 } 1572 1573 if (!get_pltoff (abfd, info, ia64_info)) 1574 return false; 1575 1576 s = bfd_make_section_anyway_with_flags (abfd, ".rela.IA_64.pltoff", 1577 (SEC_ALLOC | SEC_LOAD 1578 | SEC_HAS_CONTENTS 1579 | SEC_IN_MEMORY 1580 | SEC_LINKER_CREATED 1581 | SEC_READONLY)); 1582 if (s == NULL 1583 || !bfd_set_section_alignment (s, LOG_SECTION_ALIGN)) 1584 return false; 1585 ia64_info->rel_pltoff_sec = s; 1586 1587 return true; 1588 } 1589 1590 /* Find and/or create a hash entry for local symbol. */ 1591 static struct elfNN_ia64_local_hash_entry * 1592 get_local_sym_hash (struct elfNN_ia64_link_hash_table *ia64_info, 1593 bfd *abfd, const Elf_Internal_Rela *rel, 1594 bool create) 1595 { 1596 struct elfNN_ia64_local_hash_entry e, *ret; 1597 asection *sec = abfd->sections; 1598 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, 1599 ELFNN_R_SYM (rel->r_info)); 1600 void **slot; 1601 1602 e.id = sec->id; 1603 e.r_sym = ELFNN_R_SYM (rel->r_info); 1604 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h, 1605 create ? INSERT : NO_INSERT); 1606 1607 if (!slot) 1608 return NULL; 1609 1610 if (*slot) 1611 return (struct elfNN_ia64_local_hash_entry *) *slot; 1612 1613 ret = (struct elfNN_ia64_local_hash_entry *) 1614 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory, 1615 sizeof (struct elfNN_ia64_local_hash_entry)); 1616 if (ret) 1617 { 1618 memset (ret, 0, sizeof (*ret)); 1619 ret->id = sec->id; 1620 ret->r_sym = ELFNN_R_SYM (rel->r_info); 1621 *slot = ret; 1622 } 1623 return ret; 1624 } 1625 1626 /* Used to sort elfNN_ia64_dyn_sym_info array. */ 1627 1628 static int 1629 addend_compare (const void *xp, const void *yp) 1630 { 1631 const struct elfNN_ia64_dyn_sym_info *x 1632 = (const struct elfNN_ia64_dyn_sym_info *) xp; 1633 const struct elfNN_ia64_dyn_sym_info *y 1634 = (const struct elfNN_ia64_dyn_sym_info *) yp; 1635 1636 return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0; 1637 } 1638 1639 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */ 1640 1641 static unsigned int 1642 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info, 1643 unsigned int count) 1644 { 1645 bfd_vma curr, prev, got_offset; 1646 unsigned int i, kept, dupes, diff, dest, src, len; 1647 1648 qsort (info, count, sizeof (*info), addend_compare); 1649 1650 /* Find the first duplicate. */ 1651 prev = info [0].addend; 1652 got_offset = info [0].got_offset; 1653 for (i = 1; i < count; i++) 1654 { 1655 curr = info [i].addend; 1656 if (curr == prev) 1657 { 1658 /* For duplicates, make sure that GOT_OFFSET is valid. */ 1659 if (got_offset == (bfd_vma) -1) 1660 got_offset = info [i].got_offset; 1661 break; 1662 } 1663 got_offset = info [i].got_offset; 1664 prev = curr; 1665 } 1666 1667 /* We may move a block of elements to here. */ 1668 dest = i++; 1669 1670 /* Remove duplicates. */ 1671 if (i < count) 1672 { 1673 while (i < count) 1674 { 1675 /* For duplicates, make sure that the kept one has a valid 1676 got_offset. */ 1677 kept = dest - 1; 1678 if (got_offset != (bfd_vma) -1) 1679 info [kept].got_offset = got_offset; 1680 1681 curr = info [i].addend; 1682 got_offset = info [i].got_offset; 1683 1684 /* Move a block of elements whose first one is different from 1685 the previous. */ 1686 if (curr == prev) 1687 { 1688 for (src = i + 1; src < count; src++) 1689 { 1690 if (info [src].addend != curr) 1691 break; 1692 /* For duplicates, make sure that GOT_OFFSET is 1693 valid. */ 1694 if (got_offset == (bfd_vma) -1) 1695 got_offset = info [src].got_offset; 1696 } 1697 1698 /* Make sure that the kept one has a valid got_offset. */ 1699 if (got_offset != (bfd_vma) -1) 1700 info [kept].got_offset = got_offset; 1701 } 1702 else 1703 src = i; 1704 1705 if (src >= count) 1706 break; 1707 1708 /* Find the next duplicate. SRC will be kept. */ 1709 prev = info [src].addend; 1710 got_offset = info [src].got_offset; 1711 for (dupes = src + 1; dupes < count; dupes ++) 1712 { 1713 curr = info [dupes].addend; 1714 if (curr == prev) 1715 { 1716 /* Make sure that got_offset is valid. */ 1717 if (got_offset == (bfd_vma) -1) 1718 got_offset = info [dupes].got_offset; 1719 1720 /* For duplicates, make sure that the kept one has 1721 a valid got_offset. */ 1722 if (got_offset != (bfd_vma) -1) 1723 info [dupes - 1].got_offset = got_offset; 1724 break; 1725 } 1726 got_offset = info [dupes].got_offset; 1727 prev = curr; 1728 } 1729 1730 /* How much to move. */ 1731 len = dupes - src; 1732 i = dupes + 1; 1733 1734 if (len == 1 && dupes < count) 1735 { 1736 /* If we only move 1 element, we combine it with the next 1737 one. There must be at least a duplicate. Find the 1738 next different one. */ 1739 for (diff = dupes + 1, src++; diff < count; diff++, src++) 1740 { 1741 if (info [diff].addend != curr) 1742 break; 1743 /* Make sure that got_offset is valid. */ 1744 if (got_offset == (bfd_vma) -1) 1745 got_offset = info [diff].got_offset; 1746 } 1747 1748 /* Makre sure that the last duplicated one has an valid 1749 offset. */ 1750 BFD_ASSERT (curr == prev); 1751 if (got_offset != (bfd_vma) -1) 1752 info [diff - 1].got_offset = got_offset; 1753 1754 if (diff < count) 1755 { 1756 /* Find the next duplicate. Track the current valid 1757 offset. */ 1758 prev = info [diff].addend; 1759 got_offset = info [diff].got_offset; 1760 for (dupes = diff + 1; dupes < count; dupes ++) 1761 { 1762 curr = info [dupes].addend; 1763 if (curr == prev) 1764 { 1765 /* For duplicates, make sure that GOT_OFFSET 1766 is valid. */ 1767 if (got_offset == (bfd_vma) -1) 1768 got_offset = info [dupes].got_offset; 1769 break; 1770 } 1771 got_offset = info [dupes].got_offset; 1772 prev = curr; 1773 diff++; 1774 } 1775 1776 len = diff - src + 1; 1777 i = diff + 1; 1778 } 1779 } 1780 1781 memmove (&info [dest], &info [src], len * sizeof (*info)); 1782 1783 dest += len; 1784 } 1785 1786 count = dest; 1787 } 1788 else 1789 { 1790 /* When we get here, either there is no duplicate at all or 1791 the only duplicate is the last element. */ 1792 if (dest < count) 1793 { 1794 /* If the last element is a duplicate, make sure that the 1795 kept one has a valid got_offset. We also update count. */ 1796 if (got_offset != (bfd_vma) -1) 1797 info [dest - 1].got_offset = got_offset; 1798 count = dest; 1799 } 1800 } 1801 1802 return count; 1803 } 1804 1805 /* Find and/or create a descriptor for dynamic symbol info. This will 1806 vary based on global or local symbol, and the addend to the reloc. 1807 1808 We don't sort when inserting. Also, we sort and eliminate 1809 duplicates if there is an unsorted section. Typically, this will 1810 only happen once, because we do all insertions before lookups. We 1811 then use bsearch to do a lookup. This also allows lookups to be 1812 fast. So we have fast insertion (O(log N) due to duplicate check), 1813 fast lookup (O(log N)) and one sort (O(N log N) expected time). 1814 Previously, all lookups were O(N) because of the use of the linked 1815 list and also all insertions were O(N) because of the check for 1816 duplicates. There are some complications here because the array 1817 size grows occasionally, which may add an O(N) factor, but this 1818 should be rare. Also, we free the excess array allocation, which 1819 requires a copy which is O(N), but this only happens once. */ 1820 1821 static struct elfNN_ia64_dyn_sym_info * 1822 get_dyn_sym_info (struct elfNN_ia64_link_hash_table *ia64_info, 1823 struct elf_link_hash_entry *h, bfd *abfd, 1824 const Elf_Internal_Rela *rel, bool create) 1825 { 1826 struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key; 1827 unsigned int *count_p, *sorted_count_p, *size_p; 1828 unsigned int count, sorted_count, size; 1829 bfd_vma addend = rel ? rel->r_addend : 0; 1830 bfd_size_type amt; 1831 1832 if (h) 1833 { 1834 struct elfNN_ia64_link_hash_entry *global_h; 1835 1836 global_h = (struct elfNN_ia64_link_hash_entry *) h; 1837 info_p = &global_h->info; 1838 count_p = &global_h->count; 1839 sorted_count_p = &global_h->sorted_count; 1840 size_p = &global_h->size; 1841 } 1842 else 1843 { 1844 struct elfNN_ia64_local_hash_entry *loc_h; 1845 1846 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create); 1847 if (!loc_h) 1848 { 1849 BFD_ASSERT (!create); 1850 return NULL; 1851 } 1852 1853 info_p = &loc_h->info; 1854 count_p = &loc_h->count; 1855 sorted_count_p = &loc_h->sorted_count; 1856 size_p = &loc_h->size; 1857 } 1858 1859 count = *count_p; 1860 sorted_count = *sorted_count_p; 1861 size = *size_p; 1862 info = *info_p; 1863 if (create) 1864 { 1865 /* When we create the array, we don't check for duplicates, 1866 except in the previously sorted section if one exists, and 1867 against the last inserted entry. This allows insertions to 1868 be fast. */ 1869 if (info) 1870 { 1871 if (sorted_count) 1872 { 1873 /* Try bsearch first on the sorted section. */ 1874 key.addend = addend; 1875 dyn_i = bsearch (&key, info, sorted_count, 1876 sizeof (*info), addend_compare); 1877 if (dyn_i) 1878 return dyn_i; 1879 } 1880 1881 if (count != 0) 1882 { 1883 /* Do a quick check for the last inserted entry. */ 1884 dyn_i = info + count - 1; 1885 if (dyn_i->addend == addend) 1886 return dyn_i; 1887 } 1888 } 1889 1890 if (size == 0) 1891 { 1892 /* It is the very first element. We create the array of size 1893 1. */ 1894 size = 1; 1895 amt = size * sizeof (*info); 1896 info = bfd_malloc (amt); 1897 } 1898 else if (size <= count) 1899 { 1900 /* We double the array size every time when we reach the 1901 size limit. */ 1902 size += size; 1903 amt = size * sizeof (*info); 1904 info = bfd_realloc (info, amt); 1905 } 1906 else 1907 goto has_space; 1908 1909 if (info == NULL) 1910 return NULL; 1911 *size_p = size; 1912 *info_p = info; 1913 1914 has_space: 1915 /* Append the new one to the array. */ 1916 dyn_i = info + count; 1917 memset (dyn_i, 0, sizeof (*dyn_i)); 1918 dyn_i->got_offset = (bfd_vma) -1; 1919 dyn_i->addend = addend; 1920 1921 /* We increment count only since the new ones are unsorted and 1922 may have duplicate. */ 1923 (*count_p)++; 1924 } 1925 else 1926 { 1927 /* It is a lookup without insertion. Sort array if part of the 1928 array isn't sorted. */ 1929 if (count != sorted_count) 1930 { 1931 count = sort_dyn_sym_info (info, count); 1932 *count_p = count; 1933 *sorted_count_p = count; 1934 } 1935 1936 /* Free unused memory. */ 1937 if (size != count) 1938 { 1939 amt = count * sizeof (*info); 1940 info = bfd_realloc (info, amt); 1941 *size_p = count; 1942 if (info == NULL && count != 0) 1943 /* realloc should never fail since we are reducing size here, 1944 but if it does use the old array. */ 1945 info = *info_p; 1946 else 1947 *info_p = info; 1948 } 1949 1950 if (count == 0) 1951 dyn_i = NULL; 1952 else 1953 { 1954 key.addend = addend; 1955 dyn_i = bsearch (&key, info, count, sizeof (*info), addend_compare); 1956 } 1957 } 1958 1959 return dyn_i; 1960 } 1961 1962 static asection * 1963 get_got (bfd *abfd, struct bfd_link_info *info, 1964 struct elfNN_ia64_link_hash_table *ia64_info) 1965 { 1966 asection *got; 1967 bfd *dynobj; 1968 1969 got = ia64_info->root.sgot; 1970 if (!got) 1971 { 1972 flagword flags; 1973 1974 dynobj = ia64_info->root.dynobj; 1975 if (!dynobj) 1976 ia64_info->root.dynobj = dynobj = abfd; 1977 if (!_bfd_elf_create_got_section (dynobj, info)) 1978 return NULL; 1979 1980 got = ia64_info->root.sgot; 1981 1982 /* The .got section is always aligned at 8 bytes. */ 1983 if (!bfd_set_section_alignment (got, 3)) 1984 return NULL; 1985 1986 flags = bfd_section_flags (got); 1987 if (!bfd_set_section_flags (got, SEC_SMALL_DATA | flags)) 1988 return NULL; 1989 } 1990 1991 return got; 1992 } 1993 1994 /* Create function descriptor section (.opd). This section is called .opd 1995 because it contains "official procedure descriptors". The "official" 1996 refers to the fact that these descriptors are used when taking the address 1997 of a procedure, thus ensuring a unique address for each procedure. */ 1998 1999 static asection * 2000 get_fptr (bfd *abfd, struct bfd_link_info *info, 2001 struct elfNN_ia64_link_hash_table *ia64_info) 2002 { 2003 asection *fptr; 2004 bfd *dynobj; 2005 2006 fptr = ia64_info->fptr_sec; 2007 if (!fptr) 2008 { 2009 dynobj = ia64_info->root.dynobj; 2010 if (!dynobj) 2011 ia64_info->root.dynobj = dynobj = abfd; 2012 2013 fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd", 2014 (SEC_ALLOC 2015 | SEC_LOAD 2016 | SEC_HAS_CONTENTS 2017 | SEC_IN_MEMORY 2018 | (bfd_link_pie (info) 2019 ? 0 : SEC_READONLY) 2020 | SEC_LINKER_CREATED)); 2021 if (!fptr 2022 || !bfd_set_section_alignment (fptr, 4)) 2023 { 2024 BFD_ASSERT (0); 2025 return NULL; 2026 } 2027 2028 ia64_info->fptr_sec = fptr; 2029 2030 if (bfd_link_pie (info)) 2031 { 2032 asection *fptr_rel; 2033 fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd", 2034 (SEC_ALLOC | SEC_LOAD 2035 | SEC_HAS_CONTENTS 2036 | SEC_IN_MEMORY 2037 | SEC_LINKER_CREATED 2038 | SEC_READONLY)); 2039 if (fptr_rel == NULL 2040 || !bfd_set_section_alignment (fptr_rel, LOG_SECTION_ALIGN)) 2041 { 2042 BFD_ASSERT (0); 2043 return NULL; 2044 } 2045 2046 ia64_info->rel_fptr_sec = fptr_rel; 2047 } 2048 } 2049 2050 return fptr; 2051 } 2052 2053 static asection * 2054 get_pltoff (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED, 2055 struct elfNN_ia64_link_hash_table *ia64_info) 2056 { 2057 asection *pltoff; 2058 bfd *dynobj; 2059 2060 pltoff = ia64_info->pltoff_sec; 2061 if (!pltoff) 2062 { 2063 dynobj = ia64_info->root.dynobj; 2064 if (!dynobj) 2065 ia64_info->root.dynobj = dynobj = abfd; 2066 2067 pltoff = bfd_make_section_anyway_with_flags (dynobj, 2068 ELF_STRING_ia64_pltoff, 2069 (SEC_ALLOC 2070 | SEC_LOAD 2071 | SEC_HAS_CONTENTS 2072 | SEC_IN_MEMORY 2073 | SEC_SMALL_DATA 2074 | SEC_LINKER_CREATED)); 2075 if (!pltoff 2076 || !bfd_set_section_alignment (pltoff, 4)) 2077 { 2078 BFD_ASSERT (0); 2079 return NULL; 2080 } 2081 2082 ia64_info->pltoff_sec = pltoff; 2083 } 2084 2085 return pltoff; 2086 } 2087 2088 static asection * 2089 get_reloc_section (bfd *abfd, 2090 struct elfNN_ia64_link_hash_table *ia64_info, 2091 asection *sec, bool create) 2092 { 2093 const char *srel_name; 2094 asection *srel; 2095 bfd *dynobj; 2096 2097 srel_name = (bfd_elf_string_from_elf_section 2098 (abfd, elf_elfheader(abfd)->e_shstrndx, 2099 _bfd_elf_single_rel_hdr (sec)->sh_name)); 2100 if (srel_name == NULL) 2101 return NULL; 2102 2103 dynobj = ia64_info->root.dynobj; 2104 if (!dynobj) 2105 ia64_info->root.dynobj = dynobj = abfd; 2106 2107 srel = bfd_get_linker_section (dynobj, srel_name); 2108 if (srel == NULL && create) 2109 { 2110 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name, 2111 (SEC_ALLOC | SEC_LOAD 2112 | SEC_HAS_CONTENTS 2113 | SEC_IN_MEMORY 2114 | SEC_LINKER_CREATED 2115 | SEC_READONLY)); 2116 if (srel == NULL 2117 || !bfd_set_section_alignment (srel, LOG_SECTION_ALIGN)) 2118 return NULL; 2119 } 2120 2121 return srel; 2122 } 2123 2124 static bool 2125 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i, 2126 asection *srel, int type, bool reltext) 2127 { 2128 struct elfNN_ia64_dyn_reloc_entry *rent; 2129 2130 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 2131 if (rent->srel == srel && rent->type == type) 2132 break; 2133 2134 if (!rent) 2135 { 2136 rent = ((struct elfNN_ia64_dyn_reloc_entry *) 2137 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent))); 2138 if (!rent) 2139 return false; 2140 2141 rent->next = dyn_i->reloc_entries; 2142 rent->srel = srel; 2143 rent->type = type; 2144 rent->count = 0; 2145 dyn_i->reloc_entries = rent; 2146 } 2147 rent->reltext = reltext; 2148 rent->count++; 2149 2150 return true; 2151 } 2152 2153 static bool 2154 elfNN_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info, 2155 asection *sec, 2156 const Elf_Internal_Rela *relocs) 2157 { 2158 struct elfNN_ia64_link_hash_table *ia64_info; 2159 const Elf_Internal_Rela *relend; 2160 Elf_Internal_Shdr *symtab_hdr; 2161 const Elf_Internal_Rela *rel; 2162 asection *got, *fptr, *srel, *pltoff; 2163 enum { 2164 NEED_GOT = 1, 2165 NEED_GOTX = 2, 2166 NEED_FPTR = 4, 2167 NEED_PLTOFF = 8, 2168 NEED_MIN_PLT = 16, 2169 NEED_FULL_PLT = 32, 2170 NEED_DYNREL = 64, 2171 NEED_LTOFF_FPTR = 128, 2172 NEED_TPREL = 256, 2173 NEED_DTPMOD = 512, 2174 NEED_DTPREL = 1024 2175 }; 2176 int need_entry; 2177 struct elf_link_hash_entry *h; 2178 unsigned long r_symndx; 2179 bool maybe_dynamic; 2180 2181 if (bfd_link_relocatable (info)) 2182 return true; 2183 2184 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2185 ia64_info = elfNN_ia64_hash_table (info); 2186 if (ia64_info == NULL) 2187 return false; 2188 2189 got = fptr = srel = pltoff = NULL; 2190 2191 relend = relocs + sec->reloc_count; 2192 2193 /* We scan relocations first to create dynamic relocation arrays. We 2194 modified get_dyn_sym_info to allow fast insertion and support fast 2195 lookup in the next loop. */ 2196 for (rel = relocs; rel < relend; ++rel) 2197 { 2198 r_symndx = ELFNN_R_SYM (rel->r_info); 2199 if (r_symndx >= symtab_hdr->sh_info) 2200 { 2201 long indx = r_symndx - symtab_hdr->sh_info; 2202 h = elf_sym_hashes (abfd)[indx]; 2203 while (h->root.type == bfd_link_hash_indirect 2204 || h->root.type == bfd_link_hash_warning) 2205 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2206 } 2207 else 2208 h = NULL; 2209 2210 /* We can only get preliminary data on whether a symbol is 2211 locally or externally defined, as not all of the input files 2212 have yet been processed. Do something with what we know, as 2213 this may help reduce memory usage and processing time later. */ 2214 maybe_dynamic = (h && ((!bfd_link_executable (info) 2215 && (!SYMBOLIC_BIND (info, h) 2216 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 2217 || !h->def_regular 2218 || h->root.type == bfd_link_hash_defweak)); 2219 2220 need_entry = 0; 2221 switch (ELFNN_R_TYPE (rel->r_info)) 2222 { 2223 case R_IA64_TPREL64MSB: 2224 case R_IA64_TPREL64LSB: 2225 if (bfd_link_pic (info) || maybe_dynamic) 2226 need_entry = NEED_DYNREL; 2227 break; 2228 2229 case R_IA64_LTOFF_TPREL22: 2230 need_entry = NEED_TPREL; 2231 if (bfd_link_pic (info)) 2232 info->flags |= DF_STATIC_TLS; 2233 break; 2234 2235 case R_IA64_DTPREL32MSB: 2236 case R_IA64_DTPREL32LSB: 2237 case R_IA64_DTPREL64MSB: 2238 case R_IA64_DTPREL64LSB: 2239 if (bfd_link_pic (info) || maybe_dynamic) 2240 need_entry = NEED_DYNREL; 2241 break; 2242 2243 case R_IA64_LTOFF_DTPREL22: 2244 need_entry = NEED_DTPREL; 2245 break; 2246 2247 case R_IA64_DTPMOD64MSB: 2248 case R_IA64_DTPMOD64LSB: 2249 if (bfd_link_pic (info) || maybe_dynamic) 2250 need_entry = NEED_DYNREL; 2251 break; 2252 2253 case R_IA64_LTOFF_DTPMOD22: 2254 need_entry = NEED_DTPMOD; 2255 break; 2256 2257 case R_IA64_LTOFF_FPTR22: 2258 case R_IA64_LTOFF_FPTR64I: 2259 case R_IA64_LTOFF_FPTR32MSB: 2260 case R_IA64_LTOFF_FPTR32LSB: 2261 case R_IA64_LTOFF_FPTR64MSB: 2262 case R_IA64_LTOFF_FPTR64LSB: 2263 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; 2264 break; 2265 2266 case R_IA64_FPTR64I: 2267 case R_IA64_FPTR32MSB: 2268 case R_IA64_FPTR32LSB: 2269 case R_IA64_FPTR64MSB: 2270 case R_IA64_FPTR64LSB: 2271 if (bfd_link_pic (info) || h) 2272 need_entry = NEED_FPTR | NEED_DYNREL; 2273 else 2274 need_entry = NEED_FPTR; 2275 break; 2276 2277 case R_IA64_LTOFF22: 2278 case R_IA64_LTOFF64I: 2279 need_entry = NEED_GOT; 2280 break; 2281 2282 case R_IA64_LTOFF22X: 2283 need_entry = NEED_GOTX; 2284 break; 2285 2286 case R_IA64_PLTOFF22: 2287 case R_IA64_PLTOFF64I: 2288 case R_IA64_PLTOFF64MSB: 2289 case R_IA64_PLTOFF64LSB: 2290 need_entry = NEED_PLTOFF; 2291 if (h) 2292 { 2293 if (maybe_dynamic) 2294 need_entry |= NEED_MIN_PLT; 2295 } 2296 else 2297 { 2298 (*info->callbacks->warning) 2299 (info, _("@pltoff reloc against local symbol"), 0, 2300 abfd, 0, (bfd_vma) 0); 2301 } 2302 break; 2303 2304 case R_IA64_PCREL21B: 2305 case R_IA64_PCREL60B: 2306 /* Depending on where this symbol is defined, we may or may not 2307 need a full plt entry. Only skip if we know we'll not need 2308 the entry -- static or symbolic, and the symbol definition 2309 has already been seen. */ 2310 if (maybe_dynamic && rel->r_addend == 0) 2311 need_entry = NEED_FULL_PLT; 2312 break; 2313 2314 case R_IA64_IMM14: 2315 case R_IA64_IMM22: 2316 case R_IA64_IMM64: 2317 case R_IA64_DIR32MSB: 2318 case R_IA64_DIR32LSB: 2319 case R_IA64_DIR64MSB: 2320 case R_IA64_DIR64LSB: 2321 /* Shared objects will always need at least a REL relocation. */ 2322 if (bfd_link_pic (info) || maybe_dynamic) 2323 need_entry = NEED_DYNREL; 2324 break; 2325 2326 case R_IA64_IPLTMSB: 2327 case R_IA64_IPLTLSB: 2328 /* Shared objects will always need at least a REL relocation. */ 2329 if (bfd_link_pic (info) || maybe_dynamic) 2330 need_entry = NEED_DYNREL; 2331 break; 2332 2333 case R_IA64_PCREL22: 2334 case R_IA64_PCREL64I: 2335 case R_IA64_PCREL32MSB: 2336 case R_IA64_PCREL32LSB: 2337 case R_IA64_PCREL64MSB: 2338 case R_IA64_PCREL64LSB: 2339 if (maybe_dynamic) 2340 need_entry = NEED_DYNREL; 2341 break; 2342 } 2343 2344 if (!need_entry) 2345 continue; 2346 2347 if ((need_entry & NEED_FPTR) != 0 2348 && rel->r_addend) 2349 { 2350 (*info->callbacks->warning) 2351 (info, _("non-zero addend in @fptr reloc"), 0, 2352 abfd, 0, (bfd_vma) 0); 2353 } 2354 2355 if (get_dyn_sym_info (ia64_info, h, abfd, rel, true) == NULL) 2356 return false; 2357 } 2358 2359 /* Now, we only do lookup without insertion, which is very fast 2360 with the modified get_dyn_sym_info. */ 2361 for (rel = relocs; rel < relend; ++rel) 2362 { 2363 struct elfNN_ia64_dyn_sym_info *dyn_i; 2364 int dynrel_type = R_IA64_NONE; 2365 2366 r_symndx = ELFNN_R_SYM (rel->r_info); 2367 if (r_symndx >= symtab_hdr->sh_info) 2368 { 2369 /* We're dealing with a global symbol -- find its hash entry 2370 and mark it as being referenced. */ 2371 long indx = r_symndx - symtab_hdr->sh_info; 2372 h = elf_sym_hashes (abfd)[indx]; 2373 while (h->root.type == bfd_link_hash_indirect 2374 || h->root.type == bfd_link_hash_warning) 2375 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2376 2377 /* PR15323, ref flags aren't set for references in the same 2378 object. */ 2379 h->ref_regular = 1; 2380 } 2381 else 2382 h = NULL; 2383 2384 /* We can only get preliminary data on whether a symbol is 2385 locally or externally defined, as not all of the input files 2386 have yet been processed. Do something with what we know, as 2387 this may help reduce memory usage and processing time later. */ 2388 maybe_dynamic = (h && ((!bfd_link_executable (info) 2389 && (!SYMBOLIC_BIND (info, h) 2390 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 2391 || !h->def_regular 2392 || h->root.type == bfd_link_hash_defweak)); 2393 2394 need_entry = 0; 2395 switch (ELFNN_R_TYPE (rel->r_info)) 2396 { 2397 case R_IA64_TPREL64MSB: 2398 case R_IA64_TPREL64LSB: 2399 if (bfd_link_pic (info) || maybe_dynamic) 2400 need_entry = NEED_DYNREL; 2401 dynrel_type = R_IA64_TPREL64LSB; 2402 if (bfd_link_pic (info)) 2403 info->flags |= DF_STATIC_TLS; 2404 break; 2405 2406 case R_IA64_LTOFF_TPREL22: 2407 need_entry = NEED_TPREL; 2408 if (bfd_link_pic (info)) 2409 info->flags |= DF_STATIC_TLS; 2410 break; 2411 2412 case R_IA64_DTPREL32MSB: 2413 case R_IA64_DTPREL32LSB: 2414 case R_IA64_DTPREL64MSB: 2415 case R_IA64_DTPREL64LSB: 2416 if (bfd_link_pic (info) || maybe_dynamic) 2417 need_entry = NEED_DYNREL; 2418 dynrel_type = R_IA64_DTPRELNNLSB; 2419 break; 2420 2421 case R_IA64_LTOFF_DTPREL22: 2422 need_entry = NEED_DTPREL; 2423 break; 2424 2425 case R_IA64_DTPMOD64MSB: 2426 case R_IA64_DTPMOD64LSB: 2427 if (bfd_link_pic (info) || maybe_dynamic) 2428 need_entry = NEED_DYNREL; 2429 dynrel_type = R_IA64_DTPMOD64LSB; 2430 break; 2431 2432 case R_IA64_LTOFF_DTPMOD22: 2433 need_entry = NEED_DTPMOD; 2434 break; 2435 2436 case R_IA64_LTOFF_FPTR22: 2437 case R_IA64_LTOFF_FPTR64I: 2438 case R_IA64_LTOFF_FPTR32MSB: 2439 case R_IA64_LTOFF_FPTR32LSB: 2440 case R_IA64_LTOFF_FPTR64MSB: 2441 case R_IA64_LTOFF_FPTR64LSB: 2442 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; 2443 break; 2444 2445 case R_IA64_FPTR64I: 2446 case R_IA64_FPTR32MSB: 2447 case R_IA64_FPTR32LSB: 2448 case R_IA64_FPTR64MSB: 2449 case R_IA64_FPTR64LSB: 2450 if (bfd_link_pic (info) || h) 2451 need_entry = NEED_FPTR | NEED_DYNREL; 2452 else 2453 need_entry = NEED_FPTR; 2454 dynrel_type = R_IA64_FPTRNNLSB; 2455 break; 2456 2457 case R_IA64_LTOFF22: 2458 case R_IA64_LTOFF64I: 2459 need_entry = NEED_GOT; 2460 break; 2461 2462 case R_IA64_LTOFF22X: 2463 need_entry = NEED_GOTX; 2464 break; 2465 2466 case R_IA64_PLTOFF22: 2467 case R_IA64_PLTOFF64I: 2468 case R_IA64_PLTOFF64MSB: 2469 case R_IA64_PLTOFF64LSB: 2470 need_entry = NEED_PLTOFF; 2471 if (h) 2472 { 2473 if (maybe_dynamic) 2474 need_entry |= NEED_MIN_PLT; 2475 } 2476 break; 2477 2478 case R_IA64_PCREL21B: 2479 case R_IA64_PCREL60B: 2480 /* Depending on where this symbol is defined, we may or may not 2481 need a full plt entry. Only skip if we know we'll not need 2482 the entry -- static or symbolic, and the symbol definition 2483 has already been seen. */ 2484 if (maybe_dynamic && rel->r_addend == 0) 2485 need_entry = NEED_FULL_PLT; 2486 break; 2487 2488 case R_IA64_IMM14: 2489 case R_IA64_IMM22: 2490 case R_IA64_IMM64: 2491 case R_IA64_DIR32MSB: 2492 case R_IA64_DIR32LSB: 2493 case R_IA64_DIR64MSB: 2494 case R_IA64_DIR64LSB: 2495 /* Shared objects will always need at least a REL relocation. */ 2496 if (bfd_link_pic (info) || maybe_dynamic) 2497 need_entry = NEED_DYNREL; 2498 dynrel_type = R_IA64_DIRNNLSB; 2499 break; 2500 2501 case R_IA64_IPLTMSB: 2502 case R_IA64_IPLTLSB: 2503 /* Shared objects will always need at least a REL relocation. */ 2504 if (bfd_link_pic (info) || maybe_dynamic) 2505 need_entry = NEED_DYNREL; 2506 dynrel_type = R_IA64_IPLTLSB; 2507 break; 2508 2509 case R_IA64_PCREL22: 2510 case R_IA64_PCREL64I: 2511 case R_IA64_PCREL32MSB: 2512 case R_IA64_PCREL32LSB: 2513 case R_IA64_PCREL64MSB: 2514 case R_IA64_PCREL64LSB: 2515 if (maybe_dynamic) 2516 need_entry = NEED_DYNREL; 2517 dynrel_type = R_IA64_PCRELNNLSB; 2518 break; 2519 } 2520 2521 if (!need_entry) 2522 continue; 2523 2524 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, false); 2525 2526 /* Record whether or not this is a local symbol. */ 2527 dyn_i->h = h; 2528 2529 /* Create what's needed. */ 2530 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL 2531 | NEED_DTPMOD | NEED_DTPREL)) 2532 { 2533 if (!got) 2534 { 2535 got = get_got (abfd, info, ia64_info); 2536 if (!got) 2537 return false; 2538 } 2539 if (need_entry & NEED_GOT) 2540 dyn_i->want_got = 1; 2541 if (need_entry & NEED_GOTX) 2542 dyn_i->want_gotx = 1; 2543 if (need_entry & NEED_TPREL) 2544 dyn_i->want_tprel = 1; 2545 if (need_entry & NEED_DTPMOD) 2546 dyn_i->want_dtpmod = 1; 2547 if (need_entry & NEED_DTPREL) 2548 dyn_i->want_dtprel = 1; 2549 } 2550 if (need_entry & NEED_FPTR) 2551 { 2552 if (!fptr) 2553 { 2554 fptr = get_fptr (abfd, info, ia64_info); 2555 if (!fptr) 2556 return false; 2557 } 2558 2559 /* FPTRs for shared libraries are allocated by the dynamic 2560 linker. Make sure this local symbol will appear in the 2561 dynamic symbol table. */ 2562 if (!h && bfd_link_pic (info)) 2563 { 2564 if (! (bfd_elf_link_record_local_dynamic_symbol 2565 (info, abfd, (long) r_symndx))) 2566 return false; 2567 } 2568 2569 dyn_i->want_fptr = 1; 2570 } 2571 if (need_entry & NEED_LTOFF_FPTR) 2572 dyn_i->want_ltoff_fptr = 1; 2573 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT)) 2574 { 2575 if (!ia64_info->root.dynobj) 2576 ia64_info->root.dynobj = abfd; 2577 h->needs_plt = 1; 2578 dyn_i->want_plt = 1; 2579 } 2580 if (need_entry & NEED_FULL_PLT) 2581 dyn_i->want_plt2 = 1; 2582 if (need_entry & NEED_PLTOFF) 2583 { 2584 /* This is needed here, in case @pltoff is used in a non-shared 2585 link. */ 2586 if (!pltoff) 2587 { 2588 pltoff = get_pltoff (abfd, info, ia64_info); 2589 if (!pltoff) 2590 return false; 2591 } 2592 2593 dyn_i->want_pltoff = 1; 2594 } 2595 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) 2596 { 2597 if (!srel) 2598 { 2599 srel = get_reloc_section (abfd, ia64_info, sec, true); 2600 if (!srel) 2601 return false; 2602 } 2603 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type, 2604 (sec->flags & SEC_READONLY) != 0)) 2605 return false; 2606 } 2607 } 2608 2609 return true; 2610 } 2611 2612 /* For cleanliness, and potentially faster dynamic loading, allocate 2613 external GOT entries first. */ 2614 2615 static bool 2616 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info *dyn_i, 2617 void * data) 2618 { 2619 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2620 2621 if ((dyn_i->want_got || dyn_i->want_gotx) 2622 && ! dyn_i->want_fptr 2623 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0)) 2624 { 2625 dyn_i->got_offset = x->ofs; 2626 x->ofs += 8; 2627 } 2628 if (dyn_i->want_tprel) 2629 { 2630 dyn_i->tprel_offset = x->ofs; 2631 x->ofs += 8; 2632 } 2633 if (dyn_i->want_dtpmod) 2634 { 2635 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0)) 2636 { 2637 dyn_i->dtpmod_offset = x->ofs; 2638 x->ofs += 8; 2639 } 2640 else 2641 { 2642 struct elfNN_ia64_link_hash_table *ia64_info; 2643 2644 ia64_info = elfNN_ia64_hash_table (x->info); 2645 if (ia64_info == NULL) 2646 return false; 2647 2648 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1) 2649 { 2650 ia64_info->self_dtpmod_offset = x->ofs; 2651 x->ofs += 8; 2652 } 2653 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset; 2654 } 2655 } 2656 if (dyn_i->want_dtprel) 2657 { 2658 dyn_i->dtprel_offset = x->ofs; 2659 x->ofs += 8; 2660 } 2661 return true; 2662 } 2663 2664 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */ 2665 2666 static bool 2667 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info *dyn_i, 2668 void * data) 2669 { 2670 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2671 2672 if (dyn_i->want_got 2673 && dyn_i->want_fptr 2674 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB)) 2675 { 2676 dyn_i->got_offset = x->ofs; 2677 x->ofs += 8; 2678 } 2679 return true; 2680 } 2681 2682 /* Lastly, allocate all the GOT entries for local data. */ 2683 2684 static bool 2685 allocate_local_got (struct elfNN_ia64_dyn_sym_info *dyn_i, 2686 void * data) 2687 { 2688 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2689 2690 if ((dyn_i->want_got || dyn_i->want_gotx) 2691 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0)) 2692 { 2693 dyn_i->got_offset = x->ofs; 2694 x->ofs += 8; 2695 } 2696 return true; 2697 } 2698 2699 /* Search for the index of a global symbol in it's defining object file. */ 2700 2701 static long 2702 global_sym_index (struct elf_link_hash_entry *h) 2703 { 2704 struct elf_link_hash_entry **p; 2705 bfd *obj; 2706 2707 BFD_ASSERT (h->root.type == bfd_link_hash_defined 2708 || h->root.type == bfd_link_hash_defweak); 2709 2710 obj = h->root.u.def.section->owner; 2711 for (p = elf_sym_hashes (obj); *p != h; ++p) 2712 continue; 2713 2714 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info; 2715 } 2716 2717 /* Allocate function descriptors. We can do these for every function 2718 in a main executable that is not exported. */ 2719 2720 static bool 2721 allocate_fptr (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data) 2722 { 2723 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2724 2725 if (dyn_i->want_fptr) 2726 { 2727 struct elf_link_hash_entry *h = dyn_i->h; 2728 2729 if (h) 2730 while (h->root.type == bfd_link_hash_indirect 2731 || h->root.type == bfd_link_hash_warning) 2732 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2733 2734 if (!bfd_link_executable (x->info) 2735 && (!h 2736 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2737 || (h->root.type != bfd_link_hash_undefweak 2738 && h->root.type != bfd_link_hash_undefined))) 2739 { 2740 if (h && h->dynindx == -1) 2741 { 2742 BFD_ASSERT ((h->root.type == bfd_link_hash_defined) 2743 || (h->root.type == bfd_link_hash_defweak)); 2744 2745 if (!bfd_elf_link_record_local_dynamic_symbol 2746 (x->info, h->root.u.def.section->owner, 2747 global_sym_index (h))) 2748 return false; 2749 } 2750 2751 dyn_i->want_fptr = 0; 2752 } 2753 else if (h == NULL || h->dynindx == -1) 2754 { 2755 dyn_i->fptr_offset = x->ofs; 2756 x->ofs += 16; 2757 } 2758 else 2759 dyn_i->want_fptr = 0; 2760 } 2761 return true; 2762 } 2763 2764 /* Allocate all the minimal PLT entries. */ 2765 2766 static bool 2767 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info *dyn_i, 2768 void * data) 2769 { 2770 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2771 2772 if (dyn_i->want_plt) 2773 { 2774 struct elf_link_hash_entry *h = dyn_i->h; 2775 2776 if (h) 2777 while (h->root.type == bfd_link_hash_indirect 2778 || h->root.type == bfd_link_hash_warning) 2779 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2780 2781 /* ??? Versioned symbols seem to lose NEEDS_PLT. */ 2782 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0)) 2783 { 2784 bfd_size_type offset = x->ofs; 2785 if (offset == 0) 2786 offset = PLT_HEADER_SIZE; 2787 dyn_i->plt_offset = offset; 2788 x->ofs = offset + PLT_MIN_ENTRY_SIZE; 2789 2790 dyn_i->want_pltoff = 1; 2791 } 2792 else 2793 { 2794 dyn_i->want_plt = 0; 2795 dyn_i->want_plt2 = 0; 2796 } 2797 } 2798 return true; 2799 } 2800 2801 /* Allocate all the full PLT entries. */ 2802 2803 static bool 2804 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info *dyn_i, 2805 void * data) 2806 { 2807 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2808 2809 if (dyn_i->want_plt2) 2810 { 2811 struct elf_link_hash_entry *h = dyn_i->h; 2812 bfd_size_type ofs = x->ofs; 2813 2814 dyn_i->plt2_offset = ofs; 2815 x->ofs = ofs + PLT_FULL_ENTRY_SIZE; 2816 2817 while (h->root.type == bfd_link_hash_indirect 2818 || h->root.type == bfd_link_hash_warning) 2819 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2820 dyn_i->h->plt.offset = ofs; 2821 } 2822 return true; 2823 } 2824 2825 /* Allocate all the PLTOFF entries requested by relocations and 2826 plt entries. We can't share space with allocated FPTR entries, 2827 because the latter are not necessarily addressable by the GP. 2828 ??? Relaxation might be able to determine that they are. */ 2829 2830 static bool 2831 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info *dyn_i, 2832 void * data) 2833 { 2834 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2835 2836 if (dyn_i->want_pltoff) 2837 { 2838 dyn_i->pltoff_offset = x->ofs; 2839 x->ofs += 16; 2840 } 2841 return true; 2842 } 2843 2844 /* Allocate dynamic relocations for those symbols that turned out 2845 to be dynamic. */ 2846 2847 static bool 2848 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info *dyn_i, 2849 void * data) 2850 { 2851 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2852 struct elfNN_ia64_link_hash_table *ia64_info; 2853 struct elfNN_ia64_dyn_reloc_entry *rent; 2854 bool dynamic_symbol, shared, resolved_zero; 2855 2856 ia64_info = elfNN_ia64_hash_table (x->info); 2857 if (ia64_info == NULL) 2858 return false; 2859 2860 /* Note that this can't be used in relation to FPTR relocs below. */ 2861 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0); 2862 2863 shared = bfd_link_pic (x->info); 2864 resolved_zero = (dyn_i->h 2865 && ELF_ST_VISIBILITY (dyn_i->h->other) 2866 && dyn_i->h->root.type == bfd_link_hash_undefweak); 2867 2868 /* Take care of the GOT and PLT relocations. */ 2869 2870 if ((!resolved_zero 2871 && (dynamic_symbol || shared) 2872 && (dyn_i->want_got || dyn_i->want_gotx)) 2873 || (dyn_i->want_ltoff_fptr 2874 && dyn_i->h 2875 && dyn_i->h->dynindx != -1)) 2876 { 2877 if (!dyn_i->want_ltoff_fptr 2878 || !bfd_link_pie (x->info) 2879 || dyn_i->h == NULL 2880 || dyn_i->h->root.type != bfd_link_hash_undefweak) 2881 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela); 2882 } 2883 if ((dynamic_symbol || shared) && dyn_i->want_tprel) 2884 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela); 2885 if (dynamic_symbol && dyn_i->want_dtpmod) 2886 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela); 2887 if (dynamic_symbol && dyn_i->want_dtprel) 2888 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela); 2889 2890 if (x->only_got) 2891 return true; 2892 2893 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr) 2894 { 2895 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak) 2896 ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela); 2897 } 2898 2899 if (!resolved_zero && dyn_i->want_pltoff) 2900 { 2901 bfd_size_type t = 0; 2902 2903 /* Dynamic symbols get one IPLT relocation. Local symbols in 2904 shared libraries get two REL relocations. Local symbols in 2905 main applications get nothing. */ 2906 if (dynamic_symbol) 2907 t = sizeof (ElfNN_External_Rela); 2908 else if (shared) 2909 t = 2 * sizeof (ElfNN_External_Rela); 2910 2911 ia64_info->rel_pltoff_sec->size += t; 2912 } 2913 2914 /* Take care of the normal data relocations. */ 2915 2916 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 2917 { 2918 int count = rent->count; 2919 2920 switch (rent->type) 2921 { 2922 case R_IA64_FPTR32LSB: 2923 case R_IA64_FPTR64LSB: 2924 /* Allocate one iff !want_fptr and not PIE, which by this point 2925 will be true only if we're actually allocating one statically 2926 in the main executable. Position independent executables 2927 need a relative reloc. */ 2928 if (dyn_i->want_fptr && !bfd_link_pie (x->info)) 2929 continue; 2930 break; 2931 case R_IA64_PCREL32LSB: 2932 case R_IA64_PCREL64LSB: 2933 if (!dynamic_symbol) 2934 continue; 2935 break; 2936 case R_IA64_DIR32LSB: 2937 case R_IA64_DIR64LSB: 2938 if (!dynamic_symbol && !shared) 2939 continue; 2940 break; 2941 case R_IA64_IPLTLSB: 2942 if (!dynamic_symbol && !shared) 2943 continue; 2944 /* Use two REL relocations for IPLT relocations 2945 against local symbols. */ 2946 if (!dynamic_symbol) 2947 count *= 2; 2948 break; 2949 case R_IA64_DTPREL32LSB: 2950 case R_IA64_TPREL64LSB: 2951 case R_IA64_DTPREL64LSB: 2952 case R_IA64_DTPMOD64LSB: 2953 break; 2954 default: 2955 abort (); 2956 } 2957 if (rent->reltext) 2958 x->info->flags |= DF_TEXTREL; 2959 rent->srel->size += sizeof (ElfNN_External_Rela) * count; 2960 } 2961 2962 return true; 2963 } 2964 2965 static bool 2966 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, 2967 struct elf_link_hash_entry *h) 2968 { 2969 /* ??? Undefined symbols with PLT entries should be re-defined 2970 to be the PLT entry. */ 2971 2972 /* If this is a weak symbol, and there is a real definition, the 2973 processor independent code will have arranged for us to see the 2974 real definition first, and we can just use the same value. */ 2975 if (h->is_weakalias) 2976 { 2977 struct elf_link_hash_entry *def = weakdef (h); 2978 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2979 h->root.u.def.section = def->root.u.def.section; 2980 h->root.u.def.value = def->root.u.def.value; 2981 return true; 2982 } 2983 2984 /* If this is a reference to a symbol defined by a dynamic object which 2985 is not a function, we might allocate the symbol in our .dynbss section 2986 and allocate a COPY dynamic relocation. 2987 2988 But IA-64 code is canonically PIC, so as a rule we can avoid this sort 2989 of hackery. */ 2990 2991 return true; 2992 } 2993 2994 static bool 2995 elfNN_ia64_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2996 struct bfd_link_info *info) 2997 { 2998 struct elfNN_ia64_allocate_data data; 2999 struct elfNN_ia64_link_hash_table *ia64_info; 3000 asection *sec; 3001 bfd *dynobj; 3002 3003 ia64_info = elfNN_ia64_hash_table (info); 3004 if (ia64_info == NULL) 3005 return false; 3006 dynobj = ia64_info->root.dynobj; 3007 if (dynobj == NULL) 3008 return true; 3009 ia64_info->self_dtpmod_offset = (bfd_vma) -1; 3010 data.info = info; 3011 3012 /* Set the contents of the .interp section to the interpreter. */ 3013 if (ia64_info->root.dynamic_sections_created 3014 && bfd_link_executable (info) && !info->nointerp) 3015 { 3016 sec = bfd_get_linker_section (dynobj, ".interp"); 3017 BFD_ASSERT (sec != NULL); 3018 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER; 3019 sec->alloced = 1; 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 sec->alloced = 1; 3195 } 3196 } 3197 3198 if (ia64_info->root.dynamic_sections_created) 3199 { 3200 /* Add some entries to the .dynamic section. We fill in the values 3201 later (in finish_dynamic_sections) but we must add the entries now 3202 so that we get the correct size for the .dynamic section. */ 3203 3204 #define add_dynamic_entry(TAG, VAL) \ 3205 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 3206 3207 if (!_bfd_elf_add_dynamic_tags (output_bfd, info, true)) 3208 return false; 3209 3210 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0)) 3211 return false; 3212 } 3213 3214 /* ??? Perhaps force __gp local. */ 3215 3216 return true; 3217 } 3218 3219 static void 3220 elfNN_ia64_install_dyn_reloc (bfd *abfd, struct bfd_link_info *info, 3221 asection *sec, asection *srel, 3222 bfd_vma offset, unsigned int type, 3223 long dynindx, bfd_vma addend) 3224 { 3225 Elf_Internal_Rela outrel; 3226 bfd_byte *loc; 3227 3228 BFD_ASSERT (dynindx != -1); 3229 outrel.r_info = ELFNN_R_INFO (dynindx, type); 3230 outrel.r_addend = addend; 3231 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset); 3232 if (outrel.r_offset >= (bfd_vma) -2) 3233 { 3234 /* Run for the hills. We shouldn't be outputting a relocation 3235 for this. So do what everyone else does and output a no-op. */ 3236 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE); 3237 outrel.r_addend = 0; 3238 outrel.r_offset = 0; 3239 } 3240 else 3241 outrel.r_offset += sec->output_section->vma + sec->output_offset; 3242 3243 loc = srel->contents; 3244 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela); 3245 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc); 3246 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size); 3247 } 3248 3249 /* Store an entry for target address TARGET_ADDR in the linkage table 3250 and return the gp-relative address of the linkage table entry. */ 3251 3252 static bfd_vma 3253 set_got_entry (bfd *abfd, struct bfd_link_info *info, 3254 struct elfNN_ia64_dyn_sym_info *dyn_i, 3255 long dynindx, bfd_vma addend, bfd_vma value, 3256 unsigned int dyn_r_type) 3257 { 3258 struct elfNN_ia64_link_hash_table *ia64_info; 3259 asection *got_sec; 3260 bool done; 3261 bfd_vma got_offset; 3262 3263 ia64_info = elfNN_ia64_hash_table (info); 3264 if (ia64_info == NULL) 3265 return 0; 3266 3267 got_sec = ia64_info->root.sgot; 3268 3269 switch (dyn_r_type) 3270 { 3271 case R_IA64_TPREL64LSB: 3272 done = dyn_i->tprel_done; 3273 dyn_i->tprel_done = true; 3274 got_offset = dyn_i->tprel_offset; 3275 break; 3276 case R_IA64_DTPMOD64LSB: 3277 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset) 3278 { 3279 done = dyn_i->dtpmod_done; 3280 dyn_i->dtpmod_done = true; 3281 } 3282 else 3283 { 3284 done = ia64_info->self_dtpmod_done; 3285 ia64_info->self_dtpmod_done = true; 3286 dynindx = 0; 3287 } 3288 got_offset = dyn_i->dtpmod_offset; 3289 break; 3290 case R_IA64_DTPREL32LSB: 3291 case R_IA64_DTPREL64LSB: 3292 done = dyn_i->dtprel_done; 3293 dyn_i->dtprel_done = true; 3294 got_offset = dyn_i->dtprel_offset; 3295 break; 3296 default: 3297 done = dyn_i->got_done; 3298 dyn_i->got_done = true; 3299 got_offset = dyn_i->got_offset; 3300 break; 3301 } 3302 3303 BFD_ASSERT ((got_offset & 7) == 0); 3304 3305 if (! done) 3306 { 3307 /* Store the target address in the linkage table entry. */ 3308 bfd_put_64 (abfd, value, got_sec->contents + got_offset); 3309 3310 /* Install a dynamic relocation if needed. */ 3311 if (((bfd_link_pic (info) 3312 && (!dyn_i->h 3313 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT 3314 || dyn_i->h->root.type != bfd_link_hash_undefweak) 3315 && dyn_r_type != R_IA64_DTPREL32LSB 3316 && dyn_r_type != R_IA64_DTPREL64LSB) 3317 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type) 3318 || (dynindx != -1 3319 && (dyn_r_type == R_IA64_FPTR32LSB 3320 || dyn_r_type == R_IA64_FPTR64LSB))) 3321 && (!dyn_i->want_ltoff_fptr 3322 || !bfd_link_pie (info) 3323 || !dyn_i->h 3324 || dyn_i->h->root.type != bfd_link_hash_undefweak)) 3325 { 3326 if (dynindx == -1 3327 && dyn_r_type != R_IA64_TPREL64LSB 3328 && dyn_r_type != R_IA64_DTPMOD64LSB 3329 && dyn_r_type != R_IA64_DTPREL32LSB 3330 && dyn_r_type != R_IA64_DTPREL64LSB) 3331 { 3332 dyn_r_type = R_IA64_RELNNLSB; 3333 dynindx = 0; 3334 addend = value; 3335 } 3336 3337 if (bfd_big_endian (abfd)) 3338 { 3339 switch (dyn_r_type) 3340 { 3341 case R_IA64_REL32LSB: 3342 dyn_r_type = R_IA64_REL32MSB; 3343 break; 3344 case R_IA64_DIR32LSB: 3345 dyn_r_type = R_IA64_DIR32MSB; 3346 break; 3347 case R_IA64_FPTR32LSB: 3348 dyn_r_type = R_IA64_FPTR32MSB; 3349 break; 3350 case R_IA64_DTPREL32LSB: 3351 dyn_r_type = R_IA64_DTPREL32MSB; 3352 break; 3353 case R_IA64_REL64LSB: 3354 dyn_r_type = R_IA64_REL64MSB; 3355 break; 3356 case R_IA64_DIR64LSB: 3357 dyn_r_type = R_IA64_DIR64MSB; 3358 break; 3359 case R_IA64_FPTR64LSB: 3360 dyn_r_type = R_IA64_FPTR64MSB; 3361 break; 3362 case R_IA64_TPREL64LSB: 3363 dyn_r_type = R_IA64_TPREL64MSB; 3364 break; 3365 case R_IA64_DTPMOD64LSB: 3366 dyn_r_type = R_IA64_DTPMOD64MSB; 3367 break; 3368 case R_IA64_DTPREL64LSB: 3369 dyn_r_type = R_IA64_DTPREL64MSB; 3370 break; 3371 default: 3372 BFD_ASSERT (false); 3373 break; 3374 } 3375 } 3376 3377 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec, 3378 ia64_info->root.srelgot, 3379 got_offset, dyn_r_type, 3380 dynindx, addend); 3381 } 3382 } 3383 3384 /* Return the address of the linkage table entry. */ 3385 value = (got_sec->output_section->vma 3386 + got_sec->output_offset 3387 + got_offset); 3388 3389 return value; 3390 } 3391 3392 /* Fill in a function descriptor consisting of the function's code 3393 address and its global pointer. Return the descriptor's address. */ 3394 3395 static bfd_vma 3396 set_fptr_entry (bfd *abfd, struct bfd_link_info *info, 3397 struct elfNN_ia64_dyn_sym_info *dyn_i, 3398 bfd_vma value) 3399 { 3400 struct elfNN_ia64_link_hash_table *ia64_info; 3401 asection *fptr_sec; 3402 3403 ia64_info = elfNN_ia64_hash_table (info); 3404 if (ia64_info == NULL) 3405 return 0; 3406 3407 fptr_sec = ia64_info->fptr_sec; 3408 3409 if (!dyn_i->fptr_done) 3410 { 3411 dyn_i->fptr_done = 1; 3412 3413 /* Fill in the function descriptor. */ 3414 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset); 3415 bfd_put_64 (abfd, _bfd_get_gp_value (abfd), 3416 fptr_sec->contents + dyn_i->fptr_offset + 8); 3417 if (ia64_info->rel_fptr_sec) 3418 { 3419 Elf_Internal_Rela outrel; 3420 bfd_byte *loc; 3421 3422 if (bfd_little_endian (abfd)) 3423 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB); 3424 else 3425 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB); 3426 outrel.r_addend = value; 3427 outrel.r_offset = (fptr_sec->output_section->vma 3428 + fptr_sec->output_offset 3429 + dyn_i->fptr_offset); 3430 loc = ia64_info->rel_fptr_sec->contents; 3431 loc += ia64_info->rel_fptr_sec->reloc_count++ 3432 * sizeof (ElfNN_External_Rela); 3433 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc); 3434 } 3435 } 3436 3437 /* Return the descriptor's address. */ 3438 value = (fptr_sec->output_section->vma 3439 + fptr_sec->output_offset 3440 + dyn_i->fptr_offset); 3441 3442 return value; 3443 } 3444 3445 /* Fill in a PLTOFF entry consisting of the function's code address 3446 and its global pointer. Return the descriptor's address. */ 3447 3448 static bfd_vma 3449 set_pltoff_entry (bfd *abfd, struct bfd_link_info *info, 3450 struct elfNN_ia64_dyn_sym_info *dyn_i, 3451 bfd_vma value, bool is_plt) 3452 { 3453 struct elfNN_ia64_link_hash_table *ia64_info; 3454 asection *pltoff_sec; 3455 3456 ia64_info = elfNN_ia64_hash_table (info); 3457 if (ia64_info == NULL) 3458 return 0; 3459 3460 pltoff_sec = ia64_info->pltoff_sec; 3461 3462 /* Don't do anything if this symbol uses a real PLT entry. In 3463 that case, we'll fill this in during finish_dynamic_symbol. */ 3464 if ((! dyn_i->want_plt || is_plt) 3465 && !dyn_i->pltoff_done) 3466 { 3467 bfd_vma gp = _bfd_get_gp_value (abfd); 3468 3469 /* Fill in the function descriptor. */ 3470 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset); 3471 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8); 3472 3473 /* Install dynamic relocations if needed. */ 3474 if (!is_plt 3475 && bfd_link_pic (info) 3476 && (!dyn_i->h 3477 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT 3478 || dyn_i->h->root.type != bfd_link_hash_undefweak)) 3479 { 3480 unsigned int dyn_r_type; 3481 3482 if (bfd_big_endian (abfd)) 3483 dyn_r_type = R_IA64_RELNNMSB; 3484 else 3485 dyn_r_type = R_IA64_RELNNLSB; 3486 3487 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec, 3488 ia64_info->rel_pltoff_sec, 3489 dyn_i->pltoff_offset, 3490 dyn_r_type, 0, value); 3491 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec, 3492 ia64_info->rel_pltoff_sec, 3493 dyn_i->pltoff_offset + ARCH_SIZE / 8, 3494 dyn_r_type, 0, gp); 3495 } 3496 3497 dyn_i->pltoff_done = 1; 3498 } 3499 3500 /* Return the descriptor's address. */ 3501 value = (pltoff_sec->output_section->vma 3502 + pltoff_sec->output_offset 3503 + dyn_i->pltoff_offset); 3504 3505 return value; 3506 } 3507 3508 /* Return the base VMA address which should be subtracted from real addresses 3509 when resolving @tprel() relocation. 3510 Main program TLS (whose template starts at PT_TLS p_vaddr) 3511 is assigned offset round(2 * size of pointer, PT_TLS p_align). */ 3512 3513 static bfd_vma 3514 elfNN_ia64_tprel_base (struct bfd_link_info *info) 3515 { 3516 asection *tls_sec = elf_hash_table (info)->tls_sec; 3517 return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4, 3518 tls_sec->alignment_power); 3519 } 3520 3521 /* Return the base VMA address which should be subtracted from real addresses 3522 when resolving @dtprel() relocation. 3523 This is PT_TLS segment p_vaddr. */ 3524 3525 static bfd_vma 3526 elfNN_ia64_dtprel_base (struct bfd_link_info *info) 3527 { 3528 return elf_hash_table (info)->tls_sec->vma; 3529 } 3530 3531 /* Called through qsort to sort the .IA_64.unwind section during a 3532 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd 3533 to the output bfd so we can do proper endianness frobbing. */ 3534 3535 static bfd *elfNN_ia64_unwind_entry_compare_bfd; 3536 3537 static int 3538 elfNN_ia64_unwind_entry_compare (const void * a, const void * b) 3539 { 3540 bfd_vma av, bv; 3541 3542 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a); 3543 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b); 3544 3545 return (av < bv ? -1 : av > bv ? 1 : 0); 3546 } 3547 3548 /* Make sure we've got ourselves a nice fat __gp value. */ 3549 static bool 3550 elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bool final) 3551 { 3552 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0; 3553 bfd_vma min_short_vma = min_vma, max_short_vma = 0; 3554 struct elf_link_hash_entry *gp; 3555 bfd_vma gp_val; 3556 asection *os; 3557 struct elfNN_ia64_link_hash_table *ia64_info; 3558 3559 ia64_info = elfNN_ia64_hash_table (info); 3560 if (ia64_info == NULL) 3561 return false; 3562 3563 /* Find the min and max vma of all sections marked short. Also collect 3564 min and max vma of any type, for use in selecting a nice gp. */ 3565 for (os = abfd->sections; os ; os = os->next) 3566 { 3567 bfd_vma lo, hi; 3568 3569 if ((os->flags & SEC_ALLOC) == 0) 3570 continue; 3571 3572 lo = os->vma; 3573 /* When this function is called from elfNN_ia64_final_link 3574 the correct value to use is os->size. When called from 3575 elfNN_ia64_relax_section we are in the middle of section 3576 sizing; some sections will already have os->size set, others 3577 will have os->size zero and os->rawsize the previous size. */ 3578 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size); 3579 if (hi < lo) 3580 hi = (bfd_vma) -1; 3581 3582 if (min_vma > lo) 3583 min_vma = lo; 3584 if (max_vma < hi) 3585 max_vma = hi; 3586 if (os->flags & SEC_SMALL_DATA) 3587 { 3588 if (min_short_vma > lo) 3589 min_short_vma = lo; 3590 if (max_short_vma < hi) 3591 max_short_vma = hi; 3592 } 3593 } 3594 3595 if (ia64_info->min_short_sec) 3596 { 3597 if (min_short_vma 3598 > (ia64_info->min_short_sec->vma 3599 + ia64_info->min_short_offset)) 3600 min_short_vma = (ia64_info->min_short_sec->vma 3601 + ia64_info->min_short_offset); 3602 if (max_short_vma 3603 < (ia64_info->max_short_sec->vma 3604 + ia64_info->max_short_offset)) 3605 max_short_vma = (ia64_info->max_short_sec->vma 3606 + ia64_info->max_short_offset); 3607 } 3608 3609 /* See if the user wants to force a value. */ 3610 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false, 3611 false, false); 3612 3613 if (gp 3614 && (gp->root.type == bfd_link_hash_defined 3615 || gp->root.type == bfd_link_hash_defweak)) 3616 { 3617 asection *gp_sec = gp->root.u.def.section; 3618 gp_val = (gp->root.u.def.value 3619 + gp_sec->output_section->vma 3620 + gp_sec->output_offset); 3621 } 3622 else 3623 { 3624 /* Pick a sensible value. */ 3625 3626 if (ia64_info->min_short_sec) 3627 { 3628 bfd_vma short_range = max_short_vma - min_short_vma; 3629 3630 /* If min_short_sec is set, pick one in the middle bewteen 3631 min_short_vma and max_short_vma. */ 3632 if (short_range >= 0x400000) 3633 goto overflow; 3634 gp_val = min_short_vma + short_range / 2; 3635 } 3636 else 3637 { 3638 asection *got_sec = ia64_info->root.sgot; 3639 3640 /* Start with just the address of the .got. */ 3641 if (got_sec) 3642 gp_val = got_sec->output_section->vma; 3643 else if (max_short_vma != 0) 3644 gp_val = min_short_vma; 3645 else if (max_vma - min_vma < 0x200000) 3646 gp_val = min_vma; 3647 else 3648 gp_val = max_vma - 0x200000 + 8; 3649 } 3650 3651 /* If it is possible to address the entire image, but we 3652 don't with the choice above, adjust. */ 3653 if (max_vma - min_vma < 0x400000 3654 && (max_vma - gp_val >= 0x200000 3655 || gp_val - min_vma > 0x200000)) 3656 gp_val = min_vma + 0x200000; 3657 else if (max_short_vma != 0) 3658 { 3659 /* If we don't cover all the short data, adjust. */ 3660 if (max_short_vma - gp_val >= 0x200000) 3661 gp_val = min_short_vma + 0x200000; 3662 3663 /* If we're addressing stuff past the end, adjust back. */ 3664 if (gp_val > max_vma) 3665 gp_val = max_vma - 0x200000 + 8; 3666 } 3667 } 3668 3669 /* Validate whether all SHF_IA_64_SHORT sections are within 3670 range of the chosen GP. */ 3671 3672 if (max_short_vma != 0) 3673 { 3674 if (max_short_vma - min_short_vma >= 0x400000) 3675 { 3676 overflow: 3677 _bfd_error_handler 3678 /* xgettext:c-format */ 3679 (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"), 3680 abfd, (uint64_t) (max_short_vma - min_short_vma)); 3681 return false; 3682 } 3683 else if ((gp_val > min_short_vma 3684 && gp_val - min_short_vma > 0x200000) 3685 || (gp_val < max_short_vma 3686 && max_short_vma - gp_val >= 0x200000)) 3687 { 3688 _bfd_error_handler 3689 (_("%pB: __gp does not cover short data segment"), abfd); 3690 return false; 3691 } 3692 } 3693 3694 _bfd_set_gp_value (abfd, gp_val); 3695 3696 return true; 3697 } 3698 3699 static bool 3700 elfNN_ia64_final_link (bfd *abfd, struct bfd_link_info *info) 3701 { 3702 struct elfNN_ia64_link_hash_table *ia64_info; 3703 asection *unwind_output_sec; 3704 3705 ia64_info = elfNN_ia64_hash_table (info); 3706 if (ia64_info == NULL) 3707 return false; 3708 3709 /* Make sure we've got ourselves a nice fat __gp value. */ 3710 if (!bfd_link_relocatable (info)) 3711 { 3712 bfd_vma gp_val; 3713 struct elf_link_hash_entry *gp; 3714 3715 /* We assume after gp is set, section size will only decrease. We 3716 need to adjust gp for it. */ 3717 _bfd_set_gp_value (abfd, 0); 3718 if (! elfNN_ia64_choose_gp (abfd, info, true)) 3719 return false; 3720 gp_val = _bfd_get_gp_value (abfd); 3721 3722 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false, 3723 false, false); 3724 if (gp) 3725 { 3726 gp->root.type = bfd_link_hash_defined; 3727 gp->root.u.def.value = gp_val; 3728 gp->root.u.def.section = bfd_abs_section_ptr; 3729 } 3730 } 3731 3732 /* If we're producing a final executable, we need to sort the contents 3733 of the .IA_64.unwind section. Force this section to be relocated 3734 into memory rather than written immediately to the output file. */ 3735 unwind_output_sec = NULL; 3736 if (!bfd_link_relocatable (info)) 3737 { 3738 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); 3739 if (s) 3740 { 3741 unwind_output_sec = s->output_section; 3742 unwind_output_sec->contents 3743 = bfd_malloc (unwind_output_sec->size); 3744 if (unwind_output_sec->contents == NULL) 3745 return false; 3746 } 3747 } 3748 3749 /* Invoke the regular ELF backend linker to do all the work. */ 3750 if (!bfd_elf_final_link (abfd, info)) 3751 return false; 3752 3753 if (unwind_output_sec) 3754 { 3755 elfNN_ia64_unwind_entry_compare_bfd = abfd; 3756 qsort (unwind_output_sec->contents, 3757 (size_t) (unwind_output_sec->size / 24), 3758 24, 3759 elfNN_ia64_unwind_entry_compare); 3760 3761 if (! bfd_set_section_contents (abfd, unwind_output_sec, 3762 unwind_output_sec->contents, (bfd_vma) 0, 3763 unwind_output_sec->size)) 3764 return false; 3765 } 3766 3767 return true; 3768 } 3769 3770 static int 3771 elfNN_ia64_relocate_section (bfd *output_bfd, 3772 struct bfd_link_info *info, 3773 bfd *input_bfd, 3774 asection *input_section, 3775 bfd_byte *contents, 3776 Elf_Internal_Rela *relocs, 3777 Elf_Internal_Sym *local_syms, 3778 asection **local_sections) 3779 { 3780 struct elfNN_ia64_link_hash_table *ia64_info; 3781 Elf_Internal_Shdr *symtab_hdr; 3782 Elf_Internal_Rela *rel; 3783 Elf_Internal_Rela *relend; 3784 asection *srel; 3785 bool ret_val = true; /* for non-fatal errors */ 3786 bfd_vma gp_val; 3787 3788 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3789 ia64_info = elfNN_ia64_hash_table (info); 3790 if (ia64_info == NULL) 3791 return false; 3792 3793 /* Infect various flags from the input section to the output section. */ 3794 if (bfd_link_relocatable (info)) 3795 { 3796 bfd_vma flags; 3797 3798 flags = elf_section_data(input_section)->this_hdr.sh_flags; 3799 flags &= SHF_IA_64_NORECOV; 3800 3801 elf_section_data(input_section->output_section) 3802 ->this_hdr.sh_flags |= flags; 3803 } 3804 3805 gp_val = _bfd_get_gp_value (output_bfd); 3806 srel = get_reloc_section (input_bfd, ia64_info, input_section, false); 3807 3808 rel = relocs; 3809 relend = relocs + input_section->reloc_count; 3810 for (; rel < relend; ++rel) 3811 { 3812 struct elf_link_hash_entry *h; 3813 struct elfNN_ia64_dyn_sym_info *dyn_i; 3814 bfd_reloc_status_type r; 3815 reloc_howto_type *howto; 3816 unsigned long r_symndx; 3817 Elf_Internal_Sym *sym; 3818 unsigned int r_type; 3819 bfd_vma value; 3820 asection *sym_sec; 3821 bfd_byte *hit_addr; 3822 bool dynamic_symbol_p; 3823 bool undef_weak_ref; 3824 3825 r_type = ELFNN_R_TYPE (rel->r_info); 3826 if (r_type > R_IA64_MAX_RELOC_CODE) 3827 { 3828 /* xgettext:c-format */ 3829 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 3830 input_bfd, (int) r_type); 3831 bfd_set_error (bfd_error_bad_value); 3832 ret_val = false; 3833 continue; 3834 } 3835 3836 howto = ia64_elf_lookup_howto (r_type); 3837 if (howto == NULL) 3838 { 3839 ret_val = false; 3840 continue; 3841 } 3842 3843 r_symndx = ELFNN_R_SYM (rel->r_info); 3844 h = NULL; 3845 sym = NULL; 3846 sym_sec = NULL; 3847 undef_weak_ref = false; 3848 3849 if (r_symndx < symtab_hdr->sh_info) 3850 { 3851 /* Reloc against local symbol. */ 3852 asection *msec; 3853 sym = local_syms + r_symndx; 3854 sym_sec = local_sections[r_symndx]; 3855 msec = sym_sec; 3856 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel); 3857 if (!bfd_link_relocatable (info) 3858 && (sym_sec->flags & SEC_MERGE) != 0 3859 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 3860 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE) 3861 { 3862 struct elfNN_ia64_local_hash_entry *loc_h; 3863 3864 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false); 3865 if (loc_h && ! loc_h->sec_merge_done) 3866 { 3867 struct elfNN_ia64_dyn_sym_info *dynent; 3868 unsigned int count; 3869 3870 for (count = loc_h->count, dynent = loc_h->info; 3871 count != 0; 3872 count--, dynent++) 3873 { 3874 msec = sym_sec; 3875 dynent->addend = 3876 _bfd_merged_section_offset (output_bfd, &msec, 3877 elf_section_data (msec)-> 3878 sec_info, 3879 sym->st_value 3880 + dynent->addend); 3881 dynent->addend -= sym->st_value; 3882 dynent->addend += msec->output_section->vma 3883 + msec->output_offset 3884 - sym_sec->output_section->vma 3885 - sym_sec->output_offset; 3886 } 3887 3888 /* We may have introduced duplicated entries. We need 3889 to remove them properly. */ 3890 count = sort_dyn_sym_info (loc_h->info, loc_h->count); 3891 if (count != loc_h->count) 3892 { 3893 loc_h->count = count; 3894 loc_h->sorted_count = count; 3895 } 3896 3897 loc_h->sec_merge_done = 1; 3898 } 3899 } 3900 } 3901 else 3902 { 3903 bool unresolved_reloc; 3904 bool warned, ignored; 3905 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 3906 3907 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 3908 r_symndx, symtab_hdr, sym_hashes, 3909 h, sym_sec, value, 3910 unresolved_reloc, warned, ignored); 3911 3912 if (h->root.type == bfd_link_hash_undefweak) 3913 undef_weak_ref = true; 3914 else if (warned || (ignored && bfd_link_executable (info))) 3915 continue; 3916 } 3917 3918 if (sym_sec != NULL && discarded_section (sym_sec)) 3919 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3920 rel, 1, relend, howto, 0, contents); 3921 3922 if (bfd_link_relocatable (info)) 3923 continue; 3924 3925 hit_addr = contents + rel->r_offset; 3926 value += rel->r_addend; 3927 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type); 3928 3929 switch (r_type) 3930 { 3931 case R_IA64_NONE: 3932 case R_IA64_LDXMOV: 3933 continue; 3934 3935 case R_IA64_IMM14: 3936 case R_IA64_IMM22: 3937 case R_IA64_IMM64: 3938 case R_IA64_DIR32MSB: 3939 case R_IA64_DIR32LSB: 3940 case R_IA64_DIR64MSB: 3941 case R_IA64_DIR64LSB: 3942 /* Install a dynamic relocation for this reloc. */ 3943 if ((dynamic_symbol_p || bfd_link_pic (info)) 3944 && r_symndx != STN_UNDEF 3945 && (input_section->flags & SEC_ALLOC) != 0) 3946 { 3947 unsigned int dyn_r_type; 3948 long dynindx; 3949 bfd_vma addend; 3950 3951 BFD_ASSERT (srel != NULL); 3952 3953 switch (r_type) 3954 { 3955 case R_IA64_IMM14: 3956 case R_IA64_IMM22: 3957 case R_IA64_IMM64: 3958 /* ??? People shouldn't be doing non-pic code in 3959 shared libraries nor dynamic executables. */ 3960 _bfd_error_handler 3961 /* xgettext:c-format */ 3962 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"), 3963 input_bfd, 3964 h ? h->root.root.string 3965 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3966 sym_sec)); 3967 ret_val = false; 3968 continue; 3969 3970 default: 3971 break; 3972 } 3973 3974 /* If we don't need dynamic symbol lookup, find a 3975 matching RELATIVE relocation. */ 3976 dyn_r_type = r_type; 3977 if (dynamic_symbol_p) 3978 { 3979 dynindx = h->dynindx; 3980 addend = rel->r_addend; 3981 value = 0; 3982 } 3983 else 3984 { 3985 switch (r_type) 3986 { 3987 case R_IA64_DIR32MSB: 3988 dyn_r_type = R_IA64_REL32MSB; 3989 break; 3990 case R_IA64_DIR32LSB: 3991 dyn_r_type = R_IA64_REL32LSB; 3992 break; 3993 case R_IA64_DIR64MSB: 3994 dyn_r_type = R_IA64_REL64MSB; 3995 break; 3996 case R_IA64_DIR64LSB: 3997 dyn_r_type = R_IA64_REL64LSB; 3998 break; 3999 4000 default: 4001 break; 4002 } 4003 dynindx = 0; 4004 addend = value; 4005 } 4006 4007 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 4008 srel, rel->r_offset, dyn_r_type, 4009 dynindx, addend); 4010 } 4011 /* Fall through. */ 4012 4013 case R_IA64_LTV32MSB: 4014 case R_IA64_LTV32LSB: 4015 case R_IA64_LTV64MSB: 4016 case R_IA64_LTV64LSB: 4017 r = ia64_elf_install_value (hit_addr, value, r_type); 4018 break; 4019 4020 case R_IA64_GPREL22: 4021 case R_IA64_GPREL64I: 4022 case R_IA64_GPREL32MSB: 4023 case R_IA64_GPREL32LSB: 4024 case R_IA64_GPREL64MSB: 4025 case R_IA64_GPREL64LSB: 4026 if (dynamic_symbol_p) 4027 { 4028 _bfd_error_handler 4029 /* xgettext:c-format */ 4030 (_("%pB: @gprel relocation against dynamic symbol %s"), 4031 input_bfd, 4032 h ? h->root.root.string 4033 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 4034 sym_sec)); 4035 ret_val = false; 4036 continue; 4037 } 4038 value -= gp_val; 4039 r = ia64_elf_install_value (hit_addr, value, r_type); 4040 break; 4041 4042 case R_IA64_LTOFF22: 4043 case R_IA64_LTOFF22X: 4044 case R_IA64_LTOFF64I: 4045 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 4046 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1), 4047 rel->r_addend, value, R_IA64_DIRNNLSB); 4048 value -= gp_val; 4049 r = ia64_elf_install_value (hit_addr, value, r_type); 4050 break; 4051 4052 case R_IA64_PLTOFF22: 4053 case R_IA64_PLTOFF64I: 4054 case R_IA64_PLTOFF64MSB: 4055 case R_IA64_PLTOFF64LSB: 4056 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 4057 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false); 4058 value -= gp_val; 4059 r = ia64_elf_install_value (hit_addr, value, r_type); 4060 break; 4061 4062 case R_IA64_FPTR64I: 4063 case R_IA64_FPTR32MSB: 4064 case R_IA64_FPTR32LSB: 4065 case R_IA64_FPTR64MSB: 4066 case R_IA64_FPTR64LSB: 4067 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 4068 if (dyn_i->want_fptr) 4069 { 4070 if (!undef_weak_ref) 4071 value = set_fptr_entry (output_bfd, info, dyn_i, value); 4072 } 4073 if (!dyn_i->want_fptr || bfd_link_pie (info)) 4074 { 4075 long dynindx; 4076 unsigned int dyn_r_type = r_type; 4077 bfd_vma addend = rel->r_addend; 4078 4079 /* Otherwise, we expect the dynamic linker to create 4080 the entry. */ 4081 4082 if (dyn_i->want_fptr) 4083 { 4084 if (r_type == R_IA64_FPTR64I) 4085 { 4086 /* We can't represent this without a dynamic symbol. 4087 Adjust the relocation to be against an output 4088 section symbol, which are always present in the 4089 dynamic symbol table. */ 4090 /* ??? People shouldn't be doing non-pic code in 4091 shared libraries. Hork. */ 4092 _bfd_error_handler 4093 (_("%pB: linking non-pic code in a position independent executable"), 4094 input_bfd); 4095 ret_val = false; 4096 continue; 4097 } 4098 dynindx = 0; 4099 addend = value; 4100 dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB; 4101 } 4102 else if (h) 4103 { 4104 if (h->dynindx != -1) 4105 dynindx = h->dynindx; 4106 else 4107 dynindx = (_bfd_elf_link_lookup_local_dynindx 4108 (info, h->root.u.def.section->owner, 4109 global_sym_index (h))); 4110 value = 0; 4111 } 4112 else 4113 { 4114 dynindx = (_bfd_elf_link_lookup_local_dynindx 4115 (info, input_bfd, (long) r_symndx)); 4116 value = 0; 4117 } 4118 4119 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 4120 srel, rel->r_offset, dyn_r_type, 4121 dynindx, addend); 4122 } 4123 4124 r = ia64_elf_install_value (hit_addr, value, r_type); 4125 break; 4126 4127 case R_IA64_LTOFF_FPTR22: 4128 case R_IA64_LTOFF_FPTR64I: 4129 case R_IA64_LTOFF_FPTR32MSB: 4130 case R_IA64_LTOFF_FPTR32LSB: 4131 case R_IA64_LTOFF_FPTR64MSB: 4132 case R_IA64_LTOFF_FPTR64LSB: 4133 { 4134 long dynindx; 4135 4136 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 4137 if (dyn_i->want_fptr) 4138 { 4139 BFD_ASSERT (h == NULL || h->dynindx == -1); 4140 if (!undef_weak_ref) 4141 value = set_fptr_entry (output_bfd, info, dyn_i, value); 4142 dynindx = -1; 4143 } 4144 else 4145 { 4146 /* Otherwise, we expect the dynamic linker to create 4147 the entry. */ 4148 if (h) 4149 { 4150 if (h->dynindx != -1) 4151 dynindx = h->dynindx; 4152 else 4153 dynindx = (_bfd_elf_link_lookup_local_dynindx 4154 (info, h->root.u.def.section->owner, 4155 global_sym_index (h))); 4156 } 4157 else 4158 dynindx = (_bfd_elf_link_lookup_local_dynindx 4159 (info, input_bfd, (long) r_symndx)); 4160 value = 0; 4161 } 4162 4163 value = set_got_entry (output_bfd, info, dyn_i, dynindx, 4164 rel->r_addend, value, R_IA64_FPTRNNLSB); 4165 value -= gp_val; 4166 r = ia64_elf_install_value (hit_addr, value, r_type); 4167 } 4168 break; 4169 4170 case R_IA64_PCREL32MSB: 4171 case R_IA64_PCREL32LSB: 4172 case R_IA64_PCREL64MSB: 4173 case R_IA64_PCREL64LSB: 4174 /* Install a dynamic relocation for this reloc. */ 4175 if (dynamic_symbol_p && r_symndx != STN_UNDEF) 4176 { 4177 BFD_ASSERT (srel != NULL); 4178 4179 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 4180 srel, rel->r_offset, r_type, 4181 h->dynindx, rel->r_addend); 4182 } 4183 goto finish_pcrel; 4184 4185 case R_IA64_PCREL21B: 4186 case R_IA64_PCREL60B: 4187 /* We should have created a PLT entry for any dynamic symbol. */ 4188 dyn_i = NULL; 4189 if (h) 4190 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 4191 4192 if (dyn_i && dyn_i->want_plt2) 4193 { 4194 /* Should have caught this earlier. */ 4195 BFD_ASSERT (rel->r_addend == 0); 4196 4197 value = (ia64_info->root.splt->output_section->vma 4198 + ia64_info->root.splt->output_offset 4199 + dyn_i->plt2_offset); 4200 } 4201 else 4202 { 4203 /* Since there's no PLT entry, Validate that this is 4204 locally defined. */ 4205 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL); 4206 4207 /* If the symbol is undef_weak, we shouldn't be trying 4208 to call it. There's every chance that we'd wind up 4209 with an out-of-range fixup here. Don't bother setting 4210 any value at all. */ 4211 if (undef_weak_ref) 4212 continue; 4213 } 4214 goto finish_pcrel; 4215 4216 case R_IA64_PCREL21BI: 4217 case R_IA64_PCREL21F: 4218 case R_IA64_PCREL21M: 4219 case R_IA64_PCREL22: 4220 case R_IA64_PCREL64I: 4221 /* The PCREL21BI reloc is specifically not intended for use with 4222 dynamic relocs. PCREL21F and PCREL21M are used for speculation 4223 fixup code, and thus probably ought not be dynamic. The 4224 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */ 4225 if (dynamic_symbol_p) 4226 { 4227 const char *msg; 4228 4229 if (r_type == R_IA64_PCREL21BI) 4230 /* xgettext:c-format */ 4231 msg = _("%pB: @internal branch to dynamic symbol %s"); 4232 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M) 4233 /* xgettext:c-format */ 4234 msg = _("%pB: speculation fixup to dynamic symbol %s"); 4235 else 4236 /* xgettext:c-format */ 4237 msg = _("%pB: @pcrel relocation against dynamic symbol %s"); 4238 _bfd_error_handler (msg, input_bfd, 4239 h ? h->root.root.string 4240 : bfd_elf_sym_name (input_bfd, 4241 symtab_hdr, 4242 sym, 4243 sym_sec)); 4244 ret_val = false; 4245 continue; 4246 } 4247 goto finish_pcrel; 4248 4249 finish_pcrel: 4250 /* Make pc-relative. */ 4251 value -= (input_section->output_section->vma 4252 + input_section->output_offset 4253 + rel->r_offset) & ~ (bfd_vma) 0x3; 4254 r = ia64_elf_install_value (hit_addr, value, r_type); 4255 break; 4256 4257 case R_IA64_SEGREL32MSB: 4258 case R_IA64_SEGREL32LSB: 4259 case R_IA64_SEGREL64MSB: 4260 case R_IA64_SEGREL64LSB: 4261 { 4262 /* Find the segment that contains the output_section. */ 4263 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section 4264 (output_bfd, input_section->output_section); 4265 4266 if (p == NULL) 4267 { 4268 r = bfd_reloc_notsupported; 4269 } 4270 else 4271 { 4272 /* The VMA of the segment is the vaddr of the associated 4273 program header. */ 4274 if (value > p->p_vaddr) 4275 value -= p->p_vaddr; 4276 else 4277 value = 0; 4278 r = ia64_elf_install_value (hit_addr, value, r_type); 4279 } 4280 break; 4281 } 4282 4283 case R_IA64_SECREL32MSB: 4284 case R_IA64_SECREL32LSB: 4285 case R_IA64_SECREL64MSB: 4286 case R_IA64_SECREL64LSB: 4287 /* Make output-section relative to section where the symbol 4288 is defined. PR 475 */ 4289 if (sym_sec) 4290 value -= sym_sec->output_section->vma; 4291 r = ia64_elf_install_value (hit_addr, value, r_type); 4292 break; 4293 4294 case R_IA64_IPLTMSB: 4295 case R_IA64_IPLTLSB: 4296 /* Install a dynamic relocation for this reloc. */ 4297 if ((dynamic_symbol_p || bfd_link_pic (info)) 4298 && (input_section->flags & SEC_ALLOC) != 0) 4299 { 4300 BFD_ASSERT (srel != NULL); 4301 4302 /* If we don't need dynamic symbol lookup, install two 4303 RELATIVE relocations. */ 4304 if (!dynamic_symbol_p) 4305 { 4306 unsigned int dyn_r_type; 4307 4308 if (r_type == R_IA64_IPLTMSB) 4309 dyn_r_type = R_IA64_REL64MSB; 4310 else 4311 dyn_r_type = R_IA64_REL64LSB; 4312 4313 elfNN_ia64_install_dyn_reloc (output_bfd, info, 4314 input_section, 4315 srel, rel->r_offset, 4316 dyn_r_type, 0, value); 4317 elfNN_ia64_install_dyn_reloc (output_bfd, info, 4318 input_section, 4319 srel, rel->r_offset + 8, 4320 dyn_r_type, 0, gp_val); 4321 } 4322 else 4323 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 4324 srel, rel->r_offset, r_type, 4325 h->dynindx, rel->r_addend); 4326 } 4327 4328 if (r_type == R_IA64_IPLTMSB) 4329 r_type = R_IA64_DIR64MSB; 4330 else 4331 r_type = R_IA64_DIR64LSB; 4332 ia64_elf_install_value (hit_addr, value, r_type); 4333 r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type); 4334 break; 4335 4336 case R_IA64_TPREL14: 4337 case R_IA64_TPREL22: 4338 case R_IA64_TPREL64I: 4339 if (elf_hash_table (info)->tls_sec == NULL) 4340 goto missing_tls_sec; 4341 value -= elfNN_ia64_tprel_base (info); 4342 r = ia64_elf_install_value (hit_addr, value, r_type); 4343 break; 4344 4345 case R_IA64_DTPREL14: 4346 case R_IA64_DTPREL22: 4347 case R_IA64_DTPREL64I: 4348 case R_IA64_DTPREL32LSB: 4349 case R_IA64_DTPREL32MSB: 4350 case R_IA64_DTPREL64LSB: 4351 case R_IA64_DTPREL64MSB: 4352 if (elf_hash_table (info)->tls_sec == NULL) 4353 goto missing_tls_sec; 4354 value -= elfNN_ia64_dtprel_base (info); 4355 r = ia64_elf_install_value (hit_addr, value, r_type); 4356 break; 4357 4358 case R_IA64_LTOFF_TPREL22: 4359 case R_IA64_LTOFF_DTPMOD22: 4360 case R_IA64_LTOFF_DTPREL22: 4361 { 4362 int got_r_type; 4363 long dynindx = h ? h->dynindx : -1; 4364 bfd_vma r_addend = rel->r_addend; 4365 4366 switch (r_type) 4367 { 4368 default: 4369 case R_IA64_LTOFF_TPREL22: 4370 if (!dynamic_symbol_p) 4371 { 4372 if (elf_hash_table (info)->tls_sec == NULL) 4373 goto missing_tls_sec; 4374 if (!bfd_link_pic (info)) 4375 value -= elfNN_ia64_tprel_base (info); 4376 else 4377 { 4378 r_addend += value - elfNN_ia64_dtprel_base (info); 4379 dynindx = 0; 4380 } 4381 } 4382 got_r_type = R_IA64_TPREL64LSB; 4383 break; 4384 case R_IA64_LTOFF_DTPMOD22: 4385 if (!dynamic_symbol_p && !bfd_link_pic (info)) 4386 value = 1; 4387 got_r_type = R_IA64_DTPMOD64LSB; 4388 break; 4389 case R_IA64_LTOFF_DTPREL22: 4390 if (!dynamic_symbol_p) 4391 { 4392 if (elf_hash_table (info)->tls_sec == NULL) 4393 goto missing_tls_sec; 4394 value -= elfNN_ia64_dtprel_base (info); 4395 } 4396 got_r_type = R_IA64_DTPRELNNLSB; 4397 break; 4398 } 4399 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 4400 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend, 4401 value, got_r_type); 4402 value -= gp_val; 4403 r = ia64_elf_install_value (hit_addr, value, r_type); 4404 } 4405 break; 4406 4407 default: 4408 r = bfd_reloc_notsupported; 4409 break; 4410 } 4411 4412 switch (r) 4413 { 4414 case bfd_reloc_ok: 4415 break; 4416 4417 case bfd_reloc_undefined: 4418 /* This can happen for global table relative relocs if 4419 __gp is undefined. This is a panic situation so we 4420 don't try to continue. */ 4421 (*info->callbacks->undefined_symbol) 4422 (info, "__gp", input_bfd, input_section, rel->r_offset, 1); 4423 return false; 4424 4425 case bfd_reloc_notsupported: 4426 { 4427 const char *name; 4428 4429 if (h) 4430 name = h->root.root.string; 4431 else 4432 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 4433 sym_sec); 4434 (*info->callbacks->warning) (info, _("unsupported reloc"), 4435 name, input_bfd, 4436 input_section, rel->r_offset); 4437 ret_val = false; 4438 } 4439 break; 4440 4441 case bfd_reloc_dangerous: 4442 case bfd_reloc_outofrange: 4443 case bfd_reloc_overflow: 4444 default: 4445 missing_tls_sec: 4446 { 4447 const char *name; 4448 4449 if (h) 4450 name = h->root.root.string; 4451 else 4452 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 4453 sym_sec); 4454 4455 switch (r_type) 4456 { 4457 case R_IA64_TPREL14: 4458 case R_IA64_TPREL22: 4459 case R_IA64_TPREL64I: 4460 case R_IA64_DTPREL14: 4461 case R_IA64_DTPREL22: 4462 case R_IA64_DTPREL64I: 4463 case R_IA64_DTPREL32LSB: 4464 case R_IA64_DTPREL32MSB: 4465 case R_IA64_DTPREL64LSB: 4466 case R_IA64_DTPREL64MSB: 4467 case R_IA64_LTOFF_TPREL22: 4468 case R_IA64_LTOFF_DTPMOD22: 4469 case R_IA64_LTOFF_DTPREL22: 4470 _bfd_error_handler 4471 /* xgettext:c-format */ 4472 (_("%pB: missing TLS section for relocation %s against `%s'" 4473 " at %#" PRIx64 " in section `%pA'."), 4474 input_bfd, howto->name, name, 4475 (uint64_t) rel->r_offset, input_section); 4476 break; 4477 4478 case R_IA64_PCREL21B: 4479 case R_IA64_PCREL21BI: 4480 case R_IA64_PCREL21M: 4481 case R_IA64_PCREL21F: 4482 if (is_elf_hash_table (info->hash)) 4483 { 4484 /* Relaxtion is always performed for ELF output. 4485 Overflow failures for those relocations mean 4486 that the section is too big to relax. */ 4487 _bfd_error_handler 4488 /* xgettext:c-format */ 4489 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64 4490 " in section `%pA' with size %#" PRIx64 4491 " (> 0x1000000)."), 4492 input_bfd, howto->name, name, (uint64_t) rel->r_offset, 4493 input_section, (uint64_t) input_section->size); 4494 break; 4495 } 4496 /* Fall through. */ 4497 default: 4498 (*info->callbacks->reloc_overflow) (info, 4499 &h->root, 4500 name, 4501 howto->name, 4502 (bfd_vma) 0, 4503 input_bfd, 4504 input_section, 4505 rel->r_offset); 4506 break; 4507 } 4508 4509 ret_val = false; 4510 } 4511 break; 4512 } 4513 } 4514 4515 return ret_val; 4516 } 4517 4518 static bool 4519 elfNN_ia64_finish_dynamic_symbol (bfd *output_bfd, 4520 struct bfd_link_info *info, 4521 struct elf_link_hash_entry *h, 4522 Elf_Internal_Sym *sym) 4523 { 4524 struct elfNN_ia64_link_hash_table *ia64_info; 4525 struct elfNN_ia64_dyn_sym_info *dyn_i; 4526 4527 ia64_info = elfNN_ia64_hash_table (info); 4528 4529 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 4530 4531 /* Fill in the PLT data, if required. */ 4532 if (dyn_i && dyn_i->want_plt) 4533 { 4534 Elf_Internal_Rela outrel; 4535 bfd_byte *loc; 4536 asection *plt_sec; 4537 bfd_vma plt_addr, pltoff_addr, gp_val, plt_index; 4538 4539 gp_val = _bfd_get_gp_value (output_bfd); 4540 4541 /* Initialize the minimal PLT entry. */ 4542 4543 plt_index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE; 4544 plt_sec = ia64_info->root.splt; 4545 loc = plt_sec->contents + dyn_i->plt_offset; 4546 4547 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE); 4548 ia64_elf_install_value (loc, plt_index, R_IA64_IMM22); 4549 ia64_elf_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B); 4550 4551 plt_addr = (plt_sec->output_section->vma 4552 + plt_sec->output_offset 4553 + dyn_i->plt_offset); 4554 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true); 4555 4556 /* Initialize the FULL PLT entry, if needed. */ 4557 if (dyn_i->want_plt2) 4558 { 4559 loc = plt_sec->contents + dyn_i->plt2_offset; 4560 4561 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE); 4562 ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22); 4563 4564 /* Mark the symbol as undefined, rather than as defined in the 4565 plt section. Leave the value alone. */ 4566 /* ??? We didn't redefine it in adjust_dynamic_symbol in the 4567 first place. But perhaps elflink.c did some for us. */ 4568 if (!h->def_regular) 4569 sym->st_shndx = SHN_UNDEF; 4570 } 4571 4572 /* Create the dynamic relocation. */ 4573 outrel.r_offset = pltoff_addr; 4574 if (bfd_little_endian (output_bfd)) 4575 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB); 4576 else 4577 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB); 4578 outrel.r_addend = 0; 4579 4580 /* This is fun. In the .IA_64.pltoff section, we've got entries 4581 that correspond both to real PLT entries, and those that 4582 happened to resolve to local symbols but need to be created 4583 to satisfy @pltoff relocations. The .rela.IA_64.pltoff 4584 relocations for the real PLT should come at the end of the 4585 section, so that they can be indexed by plt entry at runtime. 4586 4587 We emitted all of the relocations for the non-PLT @pltoff 4588 entries during relocate_section. So we can consider the 4589 existing sec->reloc_count to be the base of the array of 4590 PLT relocations. */ 4591 4592 loc = ia64_info->rel_pltoff_sec->contents; 4593 loc += ((ia64_info->rel_pltoff_sec->reloc_count + plt_index) 4594 * sizeof (ElfNN_External_Rela)); 4595 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc); 4596 } 4597 4598 /* Mark some specially defined symbols as absolute. */ 4599 if (h == ia64_info->root.hdynamic 4600 || h == ia64_info->root.hgot 4601 || h == ia64_info->root.hplt) 4602 sym->st_shndx = SHN_ABS; 4603 4604 return true; 4605 } 4606 4607 static bool 4608 elfNN_ia64_finish_dynamic_sections (bfd *abfd, 4609 struct bfd_link_info *info) 4610 { 4611 struct elfNN_ia64_link_hash_table *ia64_info; 4612 bfd *dynobj; 4613 4614 ia64_info = elfNN_ia64_hash_table (info); 4615 if (ia64_info == NULL) 4616 return false; 4617 4618 dynobj = ia64_info->root.dynobj; 4619 4620 if (ia64_info->root.dynamic_sections_created) 4621 { 4622 ElfNN_External_Dyn *dyncon, *dynconend; 4623 asection *sdyn, *sgotplt; 4624 bfd_vma gp_val; 4625 4626 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 4627 sgotplt = ia64_info->root.sgotplt; 4628 BFD_ASSERT (sdyn != NULL); 4629 dyncon = (ElfNN_External_Dyn *) sdyn->contents; 4630 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size); 4631 4632 gp_val = _bfd_get_gp_value (abfd); 4633 4634 for (; dyncon < dynconend; dyncon++) 4635 { 4636 Elf_Internal_Dyn dyn; 4637 4638 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn); 4639 4640 switch (dyn.d_tag) 4641 { 4642 case DT_PLTGOT: 4643 dyn.d_un.d_ptr = gp_val; 4644 break; 4645 4646 case DT_PLTRELSZ: 4647 dyn.d_un.d_val = (ia64_info->minplt_entries 4648 * sizeof (ElfNN_External_Rela)); 4649 break; 4650 4651 case DT_JMPREL: 4652 /* See the comment above in finish_dynamic_symbol. */ 4653 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma 4654 + ia64_info->rel_pltoff_sec->output_offset 4655 + (ia64_info->rel_pltoff_sec->reloc_count 4656 * sizeof (ElfNN_External_Rela))); 4657 break; 4658 4659 case DT_IA_64_PLT_RESERVE: 4660 dyn.d_un.d_ptr = (sgotplt->output_section->vma 4661 + sgotplt->output_offset); 4662 break; 4663 } 4664 4665 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon); 4666 } 4667 4668 /* Initialize the PLT0 entry. */ 4669 if (ia64_info->root.splt) 4670 { 4671 bfd_byte *loc = ia64_info->root.splt->contents; 4672 bfd_vma pltres; 4673 4674 memcpy (loc, plt_header, PLT_HEADER_SIZE); 4675 4676 pltres = (sgotplt->output_section->vma 4677 + sgotplt->output_offset 4678 - gp_val); 4679 4680 ia64_elf_install_value (loc+1, pltres, R_IA64_GPREL22); 4681 } 4682 } 4683 4684 return true; 4685 } 4686 4687 /* ELF file flag handling: */ 4689 4690 /* Function to keep IA-64 specific file flags. */ 4691 static bool 4692 elfNN_ia64_set_private_flags (bfd *abfd, flagword flags) 4693 { 4694 BFD_ASSERT (!elf_flags_init (abfd) 4695 || elf_elfheader (abfd)->e_flags == flags); 4696 4697 elf_elfheader (abfd)->e_flags = flags; 4698 elf_flags_init (abfd) = true; 4699 return true; 4700 } 4701 4702 /* Merge backend specific data from an object file to the output 4703 object file when linking. */ 4704 4705 static bool 4706 elfNN_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 4707 { 4708 bfd *obfd = info->output_bfd; 4709 flagword out_flags; 4710 flagword in_flags; 4711 bool ok = true; 4712 4713 /* FIXME: What should be checked when linking shared libraries? */ 4714 if ((ibfd->flags & DYNAMIC) != 0) 4715 return true; 4716 4717 if (!is_ia64_elf (ibfd) || !is_ia64_elf (obfd)) 4718 return true; 4719 4720 in_flags = elf_elfheader (ibfd)->e_flags; 4721 out_flags = elf_elfheader (obfd)->e_flags; 4722 4723 if (! elf_flags_init (obfd)) 4724 { 4725 elf_flags_init (obfd) = true; 4726 elf_elfheader (obfd)->e_flags = in_flags; 4727 4728 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4729 && bfd_get_arch_info (obfd)->the_default) 4730 { 4731 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 4732 bfd_get_mach (ibfd)); 4733 } 4734 4735 return true; 4736 } 4737 4738 /* Check flag compatibility. */ 4739 if (in_flags == out_flags) 4740 return true; 4741 4742 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */ 4743 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP)) 4744 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP; 4745 4746 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL)) 4747 { 4748 _bfd_error_handler 4749 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"), 4750 ibfd); 4751 4752 bfd_set_error (bfd_error_bad_value); 4753 ok = false; 4754 } 4755 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE)) 4756 { 4757 _bfd_error_handler 4758 (_("%pB: linking big-endian files with little-endian files"), 4759 ibfd); 4760 4761 bfd_set_error (bfd_error_bad_value); 4762 ok = false; 4763 } 4764 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64)) 4765 { 4766 _bfd_error_handler 4767 (_("%pB: linking 64-bit files with 32-bit files"), 4768 ibfd); 4769 4770 bfd_set_error (bfd_error_bad_value); 4771 ok = false; 4772 } 4773 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP)) 4774 { 4775 _bfd_error_handler 4776 (_("%pB: linking constant-gp files with non-constant-gp files"), 4777 ibfd); 4778 4779 bfd_set_error (bfd_error_bad_value); 4780 ok = false; 4781 } 4782 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP) 4783 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) 4784 { 4785 _bfd_error_handler 4786 (_("%pB: linking auto-pic files with non-auto-pic files"), 4787 ibfd); 4788 4789 bfd_set_error (bfd_error_bad_value); 4790 ok = false; 4791 } 4792 4793 return ok; 4794 } 4795 4796 static bool 4797 elfNN_ia64_print_private_bfd_data (bfd *abfd, void * ptr) 4798 { 4799 FILE *file = (FILE *) ptr; 4800 flagword flags = elf_elfheader (abfd)->e_flags; 4801 4802 BFD_ASSERT (abfd != NULL && ptr != NULL); 4803 4804 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n", 4805 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "", 4806 (flags & EF_IA_64_EXT) ? "EXT, " : "", 4807 (flags & EF_IA_64_BE) ? "BE, " : "LE, ", 4808 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "", 4809 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "", 4810 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "", 4811 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "", 4812 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32"); 4813 4814 _bfd_elf_print_private_bfd_data (abfd, ptr); 4815 return true; 4816 } 4817 4818 static enum elf_reloc_type_class 4819 elfNN_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 4820 const asection *rel_sec ATTRIBUTE_UNUSED, 4821 const Elf_Internal_Rela *rela) 4822 { 4823 switch ((int) ELFNN_R_TYPE (rela->r_info)) 4824 { 4825 case R_IA64_REL32MSB: 4826 case R_IA64_REL32LSB: 4827 case R_IA64_REL64MSB: 4828 case R_IA64_REL64LSB: 4829 return reloc_class_relative; 4830 case R_IA64_IPLTMSB: 4831 case R_IA64_IPLTLSB: 4832 return reloc_class_plt; 4833 case R_IA64_COPY: 4834 return reloc_class_copy; 4835 default: 4836 return reloc_class_normal; 4837 } 4838 } 4839 4840 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] = 4841 { 4842 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, 4843 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, 4844 { NULL, 0, 0, 0, 0 } 4845 }; 4846 4847 static bool 4848 elfNN_ia64_object_p (bfd *abfd) 4849 { 4850 asection *sec; 4851 asection *group, *unwi, *unw; 4852 flagword flags; 4853 const char *name; 4854 char *unwi_name, *unw_name; 4855 size_t amt; 4856 4857 if (abfd->flags & DYNAMIC) 4858 return true; 4859 4860 /* Flags for fake group section. */ 4861 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE 4862 | SEC_EXCLUDE); 4863 4864 /* We add a fake section group for each .gnu.linkonce.t.* section, 4865 which isn't in a section group, and its unwind sections. */ 4866 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4867 { 4868 if (elf_sec_group (sec) == NULL 4869 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP)) 4870 == (SEC_LINK_ONCE | SEC_CODE)) 4871 && startswith (sec->name, ".gnu.linkonce.t.")) 4872 { 4873 name = sec->name + 16; 4874 4875 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi."); 4876 unwi_name = bfd_alloc (abfd, amt); 4877 if (!unwi_name) 4878 return false; 4879 4880 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name); 4881 unwi = bfd_get_section_by_name (abfd, unwi_name); 4882 4883 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw."); 4884 unw_name = bfd_alloc (abfd, amt); 4885 if (!unw_name) 4886 return false; 4887 4888 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name); 4889 unw = bfd_get_section_by_name (abfd, unw_name); 4890 4891 /* We need to create a fake group section for it and its 4892 unwind sections. */ 4893 group = bfd_make_section_anyway_with_flags (abfd, name, 4894 flags); 4895 if (group == NULL) 4896 return false; 4897 4898 /* Move the fake group section to the beginning. */ 4899 bfd_section_list_remove (abfd, group); 4900 bfd_section_list_prepend (abfd, group); 4901 4902 elf_next_in_group (group) = sec; 4903 4904 elf_group_name (sec) = name; 4905 elf_next_in_group (sec) = sec; 4906 elf_sec_group (sec) = group; 4907 4908 if (unwi) 4909 { 4910 elf_group_name (unwi) = name; 4911 elf_next_in_group (unwi) = sec; 4912 elf_next_in_group (sec) = unwi; 4913 elf_sec_group (unwi) = group; 4914 } 4915 4916 if (unw) 4917 { 4918 elf_group_name (unw) = name; 4919 if (unwi) 4920 { 4921 elf_next_in_group (unw) = elf_next_in_group (unwi); 4922 elf_next_in_group (unwi) = unw; 4923 } 4924 else 4925 { 4926 elf_next_in_group (unw) = sec; 4927 elf_next_in_group (sec) = unw; 4928 } 4929 elf_sec_group (unw) = group; 4930 } 4931 4932 /* Fake SHT_GROUP section header. */ 4933 elf_section_data (group)->this_hdr.bfd_section = group; 4934 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP; 4935 } 4936 } 4937 return true; 4938 } 4939 4940 static bool 4941 elfNN_ia64_hpux_vec (const bfd_target *vec) 4942 { 4943 extern const bfd_target ia64_elfNN_hpux_be_vec; 4944 return (vec == &ia64_elfNN_hpux_be_vec); 4945 } 4946 4947 static bool 4948 elfNN_hpux_init_file_header (bfd *abfd, struct bfd_link_info *info) 4949 { 4950 Elf_Internal_Ehdr *i_ehdrp; 4951 4952 if (!_bfd_elf_init_file_header (abfd, info)) 4953 return false; 4954 4955 i_ehdrp = elf_elfheader (abfd); 4956 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; 4957 i_ehdrp->e_ident[EI_ABIVERSION] = 1; 4958 return true; 4959 } 4960 4961 static bool 4962 elfNN_hpux_backend_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 4963 asection *sec, int *retval) 4964 { 4965 if (bfd_is_com_section (sec)) 4966 { 4967 *retval = SHN_IA_64_ANSI_COMMON; 4968 return true; 4969 } 4970 return false; 4971 } 4972 4973 static void 4974 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, 4975 asymbol *asym) 4976 { 4977 elf_symbol_type *elfsym = (elf_symbol_type *) asym; 4978 4979 switch (elfsym->internal_elf_sym.st_shndx) 4980 { 4981 case SHN_IA_64_ANSI_COMMON: 4982 asym->section = bfd_com_section_ptr; 4983 asym->value = elfsym->internal_elf_sym.st_size; 4984 asym->flags &= ~BSF_GLOBAL; 4985 break; 4986 } 4987 } 4988 4989 static void 4990 ignore_errors (const char *fmt ATTRIBUTE_UNUSED, ...) 4991 { 4992 } 4993 4994 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec 4996 #define TARGET_LITTLE_NAME "elfNN-ia64-little" 4997 #define TARGET_BIG_SYM ia64_elfNN_be_vec 4998 #define TARGET_BIG_NAME "elfNN-ia64-big" 4999 #define ELF_ARCH bfd_arch_ia64 5000 #define ELF_TARGET_ID IA64_ELF_DATA 5001 #define ELF_MACHINE_CODE EM_IA_64 5002 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */ 5003 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */ 5004 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */ 5005 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */ 5006 5007 #define elf_backend_section_from_shdr \ 5008 elfNN_ia64_section_from_shdr 5009 #define elf_backend_section_flags \ 5010 elfNN_ia64_section_flags 5011 #define elf_backend_fake_sections \ 5012 elfNN_ia64_fake_sections 5013 #define elf_backend_final_write_processing \ 5014 elfNN_ia64_final_write_processing 5015 #define elf_backend_add_symbol_hook \ 5016 elfNN_ia64_add_symbol_hook 5017 #define elf_backend_additional_program_headers \ 5018 elfNN_ia64_additional_program_headers 5019 #define elf_backend_modify_segment_map \ 5020 elfNN_ia64_modify_segment_map 5021 #define elf_backend_modify_headers \ 5022 elfNN_ia64_modify_headers 5023 #define elf_info_to_howto \ 5024 elfNN_ia64_info_to_howto 5025 5026 #define bfd_elfNN_bfd_reloc_type_lookup \ 5027 ia64_elf_reloc_type_lookup 5028 #define bfd_elfNN_bfd_reloc_name_lookup \ 5029 ia64_elf_reloc_name_lookup 5030 #define bfd_elfNN_bfd_is_local_label_name \ 5031 elfNN_ia64_is_local_label_name 5032 #define bfd_elfNN_bfd_relax_section \ 5033 elfNN_ia64_relax_section 5034 5035 #define elf_backend_object_p \ 5036 elfNN_ia64_object_p 5037 5038 /* Stuff for the BFD linker: */ 5039 #define bfd_elfNN_bfd_link_hash_table_create \ 5040 elfNN_ia64_hash_table_create 5041 #define elf_backend_create_dynamic_sections \ 5042 elfNN_ia64_create_dynamic_sections 5043 #define elf_backend_check_relocs \ 5044 elfNN_ia64_check_relocs 5045 #define elf_backend_adjust_dynamic_symbol \ 5046 elfNN_ia64_adjust_dynamic_symbol 5047 #define elf_backend_late_size_sections \ 5048 elfNN_ia64_late_size_sections 5049 #define elf_backend_omit_section_dynsym \ 5050 _bfd_elf_omit_section_dynsym_all 5051 #define elf_backend_relocate_section \ 5052 elfNN_ia64_relocate_section 5053 #define elf_backend_finish_dynamic_symbol \ 5054 elfNN_ia64_finish_dynamic_symbol 5055 #define elf_backend_finish_dynamic_sections \ 5056 elfNN_ia64_finish_dynamic_sections 5057 #define bfd_elfNN_bfd_final_link \ 5058 elfNN_ia64_final_link 5059 5060 #define bfd_elfNN_bfd_merge_private_bfd_data \ 5061 elfNN_ia64_merge_private_bfd_data 5062 #define bfd_elfNN_bfd_set_private_flags \ 5063 elfNN_ia64_set_private_flags 5064 #define bfd_elfNN_bfd_print_private_bfd_data \ 5065 elfNN_ia64_print_private_bfd_data 5066 5067 #define elf_backend_plt_readonly 1 5068 #define elf_backend_can_gc_sections 1 5069 #define elf_backend_want_plt_sym 0 5070 #define elf_backend_plt_alignment 5 5071 #define elf_backend_got_header_size 0 5072 #define elf_backend_want_got_plt 1 5073 #define elf_backend_may_use_rel_p 1 5074 #define elf_backend_may_use_rela_p 1 5075 #define elf_backend_default_use_rela_p 1 5076 #define elf_backend_want_dynbss 0 5077 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect 5078 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol 5079 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol 5080 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class 5081 #define elf_backend_rela_normal 1 5082 #define elf_backend_dtrel_excludes_plt 1 5083 #define elf_backend_special_sections elfNN_ia64_special_sections 5084 #define elf_backend_default_execstack 0 5085 5086 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with 5087 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields. 5088 We don't want to flood users with so many error messages. We turn 5089 off the warning for now. It will be turned on later when the Intel 5090 compiler is fixed. */ 5091 #define elf_backend_link_order_error_handler ignore_errors 5092 5093 #include "elfNN-target.h" 5094 5095 /* HPUX-specific vectors. */ 5096 5097 #undef TARGET_LITTLE_SYM 5098 #undef TARGET_LITTLE_NAME 5099 #undef TARGET_BIG_SYM 5100 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec 5101 #undef TARGET_BIG_NAME 5102 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big" 5103 5104 /* These are HP-UX specific functions. */ 5105 5106 #undef elf_backend_init_file_header 5107 #define elf_backend_init_file_header elfNN_hpux_init_file_header 5108 5109 #undef elf_backend_section_from_bfd_section 5110 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section 5111 5112 #undef elf_backend_symbol_processing 5113 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing 5114 5115 #undef elf_backend_want_p_paddr_set_to_zero 5116 #define elf_backend_want_p_paddr_set_to_zero 1 5117 5118 #undef ELF_COMMONPAGESIZE 5119 #undef ELF_OSABI 5120 #define ELF_OSABI ELFOSABI_HPUX 5121 5122 #undef elfNN_bed 5123 #define elfNN_bed elfNN_ia64_hpux_bed 5124 5125 #include "elfNN-target.h" 5126
Indexes created Fri Mar 27 00:22:57 UTC 2026