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