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