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