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