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