1 /* Support for HPPA 64-bit ELF 2 Copyright (C) 1999-2018 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "alloca-conf.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/hppa.h" 27 #include "libhppa.h" 28 #include "elf64-hppa.h" 29 #include "libiberty.h" 30 31 #define ARCH_SIZE 64 32 33 #define PLT_ENTRY_SIZE 0x10 34 #define DLT_ENTRY_SIZE 0x8 35 #define OPD_ENTRY_SIZE 0x20 36 37 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl" 38 39 /* The stub is supposed to load the target address and target's DP 40 value out of the PLT, then do an external branch to the target 41 address. 42 43 LDD PLTOFF(%r27),%r1 44 BVE (%r1) 45 LDD PLTOFF+8(%r27),%r27 46 47 Note that we must use the LDD with a 14 bit displacement, not the one 48 with a 5 bit displacement. */ 49 static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00, 50 0x53, 0x7b, 0x00, 0x00 }; 51 52 struct elf64_hppa_link_hash_entry 53 { 54 struct elf_link_hash_entry eh; 55 56 /* Offsets for this symbol in various linker sections. */ 57 bfd_vma dlt_offset; 58 bfd_vma plt_offset; 59 bfd_vma opd_offset; 60 bfd_vma stub_offset; 61 62 /* The index of the (possibly local) symbol in the input bfd and its 63 associated BFD. Needed so that we can have relocs against local 64 symbols in shared libraries. */ 65 long sym_indx; 66 bfd *owner; 67 68 /* Dynamic symbols may need to have two different values. One for 69 the dynamic symbol table, one for the normal symbol table. 70 71 In such cases we store the symbol's real value and section 72 index here so we can restore the real value before we write 73 the normal symbol table. */ 74 bfd_vma st_value; 75 int st_shndx; 76 77 /* Used to count non-got, non-plt relocations for delayed sizing 78 of relocation sections. */ 79 struct elf64_hppa_dyn_reloc_entry 80 { 81 /* Next relocation in the chain. */ 82 struct elf64_hppa_dyn_reloc_entry *next; 83 84 /* The type of the relocation. */ 85 int type; 86 87 /* The input section of the relocation. */ 88 asection *sec; 89 90 /* Number of relocs copied in this section. */ 91 bfd_size_type count; 92 93 /* The index of the section symbol for the input section of 94 the relocation. Only needed when building shared libraries. */ 95 int sec_symndx; 96 97 /* The offset within the input section of the relocation. */ 98 bfd_vma offset; 99 100 /* The addend for the relocation. */ 101 bfd_vma addend; 102 103 } *reloc_entries; 104 105 /* Nonzero if this symbol needs an entry in one of the linker 106 sections. */ 107 unsigned want_dlt; 108 unsigned want_plt; 109 unsigned want_opd; 110 unsigned want_stub; 111 }; 112 113 struct elf64_hppa_link_hash_table 114 { 115 struct elf_link_hash_table root; 116 117 /* Shortcuts to get to the various linker defined sections. */ 118 asection *dlt_sec; 119 asection *dlt_rel_sec; 120 asection *plt_sec; 121 asection *plt_rel_sec; 122 asection *opd_sec; 123 asection *opd_rel_sec; 124 asection *other_rel_sec; 125 126 /* Offset of __gp within .plt section. When the PLT gets large we want 127 to slide __gp into the PLT section so that we can continue to use 128 single DP relative instructions to load values out of the PLT. */ 129 bfd_vma gp_offset; 130 131 /* Note this is not strictly correct. We should create a stub section for 132 each input section with calls. The stub section should be placed before 133 the section with the call. */ 134 asection *stub_sec; 135 136 bfd_vma text_segment_base; 137 bfd_vma data_segment_base; 138 139 /* We build tables to map from an input section back to its 140 symbol index. This is the BFD for which we currently have 141 a map. */ 142 bfd *section_syms_bfd; 143 144 /* Array of symbol numbers for each input section attached to the 145 current BFD. */ 146 int *section_syms; 147 }; 148 149 #define hppa_link_hash_table(p) \ 150 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 151 == HPPA64_ELF_DATA ? ((struct elf64_hppa_link_hash_table *) ((p)->hash)) : NULL) 152 153 #define hppa_elf_hash_entry(ent) \ 154 ((struct elf64_hppa_link_hash_entry *)(ent)) 155 156 #define eh_name(eh) \ 157 (eh ? eh->root.root.string : "<undef>") 158 159 typedef struct bfd_hash_entry *(*new_hash_entry_func) 160 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); 161 162 static struct bfd_link_hash_table *elf64_hppa_hash_table_create 163 (bfd *abfd); 164 165 /* This must follow the definitions of the various derived linker 166 hash tables and shared functions. */ 167 #include "elf-hppa.h" 168 169 static bfd_boolean elf64_hppa_object_p 170 (bfd *); 171 172 static void elf64_hppa_post_process_headers 173 (bfd *, struct bfd_link_info *); 174 175 static bfd_boolean elf64_hppa_create_dynamic_sections 176 (bfd *, struct bfd_link_info *); 177 178 static bfd_boolean elf64_hppa_adjust_dynamic_symbol 179 (struct bfd_link_info *, struct elf_link_hash_entry *); 180 181 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions 182 (struct elf_link_hash_entry *, void *); 183 184 static bfd_boolean elf64_hppa_size_dynamic_sections 185 (bfd *, struct bfd_link_info *); 186 187 static int elf64_hppa_link_output_symbol_hook 188 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, 189 asection *, struct elf_link_hash_entry *); 190 191 static bfd_boolean elf64_hppa_finish_dynamic_symbol 192 (bfd *, struct bfd_link_info *, 193 struct elf_link_hash_entry *, Elf_Internal_Sym *); 194 195 static bfd_boolean elf64_hppa_finish_dynamic_sections 196 (bfd *, struct bfd_link_info *); 197 198 static bfd_boolean elf64_hppa_check_relocs 199 (bfd *, struct bfd_link_info *, 200 asection *, const Elf_Internal_Rela *); 201 202 static bfd_boolean elf64_hppa_dynamic_symbol_p 203 (struct elf_link_hash_entry *, struct bfd_link_info *); 204 205 static bfd_boolean elf64_hppa_mark_exported_functions 206 (struct elf_link_hash_entry *, void *); 207 208 static bfd_boolean elf64_hppa_finalize_opd 209 (struct elf_link_hash_entry *, void *); 210 211 static bfd_boolean elf64_hppa_finalize_dlt 212 (struct elf_link_hash_entry *, void *); 213 214 static bfd_boolean allocate_global_data_dlt 215 (struct elf_link_hash_entry *, void *); 216 217 static bfd_boolean allocate_global_data_plt 218 (struct elf_link_hash_entry *, void *); 219 220 static bfd_boolean allocate_global_data_stub 221 (struct elf_link_hash_entry *, void *); 222 223 static bfd_boolean allocate_global_data_opd 224 (struct elf_link_hash_entry *, void *); 225 226 static bfd_boolean get_reloc_section 227 (bfd *, struct elf64_hppa_link_hash_table *, asection *); 228 229 static bfd_boolean count_dyn_reloc 230 (bfd *, struct elf64_hppa_link_hash_entry *, 231 int, asection *, int, bfd_vma, bfd_vma); 232 233 static bfd_boolean allocate_dynrel_entries 234 (struct elf_link_hash_entry *, void *); 235 236 static bfd_boolean elf64_hppa_finalize_dynreloc 237 (struct elf_link_hash_entry *, void *); 238 239 static bfd_boolean get_opd 240 (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *); 241 242 static bfd_boolean get_plt 243 (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *); 244 245 static bfd_boolean get_dlt 246 (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *); 247 248 static bfd_boolean get_stub 249 (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *); 250 251 static int elf64_hppa_elf_get_symbol_type 252 (Elf_Internal_Sym *, int); 253 254 /* Initialize an entry in the link hash table. */ 255 256 static struct bfd_hash_entry * 257 hppa64_link_hash_newfunc (struct bfd_hash_entry *entry, 258 struct bfd_hash_table *table, 259 const char *string) 260 { 261 /* Allocate the structure if it has not already been allocated by a 262 subclass. */ 263 if (entry == NULL) 264 { 265 entry = bfd_hash_allocate (table, 266 sizeof (struct elf64_hppa_link_hash_entry)); 267 if (entry == NULL) 268 return entry; 269 } 270 271 /* Call the allocation method of the superclass. */ 272 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 273 if (entry != NULL) 274 { 275 struct elf64_hppa_link_hash_entry *hh; 276 277 /* Initialize our local data. All zeros. */ 278 hh = hppa_elf_hash_entry (entry); 279 memset (&hh->dlt_offset, 0, 280 (sizeof (struct elf64_hppa_link_hash_entry) 281 - offsetof (struct elf64_hppa_link_hash_entry, dlt_offset))); 282 } 283 284 return entry; 285 } 286 287 /* Create the derived linker hash table. The PA64 ELF port uses this 288 derived hash table to keep information specific to the PA ElF 289 linker (without using static variables). */ 290 291 static struct bfd_link_hash_table* 292 elf64_hppa_hash_table_create (bfd *abfd) 293 { 294 struct elf64_hppa_link_hash_table *htab; 295 bfd_size_type amt = sizeof (*htab); 296 297 htab = bfd_zmalloc (amt); 298 if (htab == NULL) 299 return NULL; 300 301 if (!_bfd_elf_link_hash_table_init (&htab->root, abfd, 302 hppa64_link_hash_newfunc, 303 sizeof (struct elf64_hppa_link_hash_entry), 304 HPPA64_ELF_DATA)) 305 { 306 free (htab); 307 return NULL; 308 } 309 310 htab->text_segment_base = (bfd_vma) -1; 311 htab->data_segment_base = (bfd_vma) -1; 312 313 return &htab->root.root; 314 } 315 316 /* Return nonzero if ABFD represents a PA2.0 ELF64 file. 317 318 Additionally we set the default architecture and machine. */ 319 static bfd_boolean 320 elf64_hppa_object_p (bfd *abfd) 321 { 322 Elf_Internal_Ehdr * i_ehdrp; 323 unsigned int flags; 324 325 i_ehdrp = elf_elfheader (abfd); 326 if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0) 327 { 328 /* GCC on hppa-linux produces binaries with OSABI=GNU, 329 but the kernel produces corefiles with OSABI=SysV. */ 330 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU 331 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 332 return FALSE; 333 } 334 else 335 { 336 /* HPUX produces binaries with OSABI=HPUX, 337 but the kernel produces corefiles with OSABI=SysV. */ 338 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX 339 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 340 return FALSE; 341 } 342 343 flags = i_ehdrp->e_flags; 344 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE)) 345 { 346 case EFA_PARISC_1_0: 347 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10); 348 case EFA_PARISC_1_1: 349 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11); 350 case EFA_PARISC_2_0: 351 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64) 352 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25); 353 else 354 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20); 355 case EFA_PARISC_2_0 | EF_PARISC_WIDE: 356 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25); 357 } 358 /* Don't be fussy. */ 359 return TRUE; 360 } 361 362 /* Given section type (hdr->sh_type), return a boolean indicating 363 whether or not the section is an elf64-hppa specific section. */ 364 static bfd_boolean 365 elf64_hppa_section_from_shdr (bfd *abfd, 366 Elf_Internal_Shdr *hdr, 367 const char *name, 368 int shindex) 369 { 370 switch (hdr->sh_type) 371 { 372 case SHT_PARISC_EXT: 373 if (strcmp (name, ".PARISC.archext") != 0) 374 return FALSE; 375 break; 376 case SHT_PARISC_UNWIND: 377 if (strcmp (name, ".PARISC.unwind") != 0) 378 return FALSE; 379 break; 380 case SHT_PARISC_DOC: 381 case SHT_PARISC_ANNOT: 382 default: 383 return FALSE; 384 } 385 386 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 387 return FALSE; 388 389 return TRUE; 390 } 391 392 /* SEC is a section containing relocs for an input BFD when linking; return 393 a suitable section for holding relocs in the output BFD for a link. */ 394 395 static bfd_boolean 396 get_reloc_section (bfd *abfd, 397 struct elf64_hppa_link_hash_table *hppa_info, 398 asection *sec) 399 { 400 const char *srel_name; 401 asection *srel; 402 bfd *dynobj; 403 404 srel_name = (bfd_elf_string_from_elf_section 405 (abfd, elf_elfheader(abfd)->e_shstrndx, 406 _bfd_elf_single_rel_hdr(sec)->sh_name)); 407 if (srel_name == NULL) 408 return FALSE; 409 410 dynobj = hppa_info->root.dynobj; 411 if (!dynobj) 412 hppa_info->root.dynobj = dynobj = abfd; 413 414 srel = bfd_get_linker_section (dynobj, srel_name); 415 if (srel == NULL) 416 { 417 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name, 418 (SEC_ALLOC 419 | SEC_LOAD 420 | SEC_HAS_CONTENTS 421 | SEC_IN_MEMORY 422 | SEC_LINKER_CREATED 423 | SEC_READONLY)); 424 if (srel == NULL 425 || !bfd_set_section_alignment (dynobj, srel, 3)) 426 return FALSE; 427 } 428 429 hppa_info->other_rel_sec = srel; 430 return TRUE; 431 } 432 433 /* Add a new entry to the list of dynamic relocations against DYN_H. 434 435 We use this to keep a record of all the FPTR relocations against a 436 particular symbol so that we can create FPTR relocations in the 437 output file. */ 438 439 static bfd_boolean 440 count_dyn_reloc (bfd *abfd, 441 struct elf64_hppa_link_hash_entry *hh, 442 int type, 443 asection *sec, 444 int sec_symndx, 445 bfd_vma offset, 446 bfd_vma addend) 447 { 448 struct elf64_hppa_dyn_reloc_entry *rent; 449 450 rent = (struct elf64_hppa_dyn_reloc_entry *) 451 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)); 452 if (!rent) 453 return FALSE; 454 455 rent->next = hh->reloc_entries; 456 rent->type = type; 457 rent->sec = sec; 458 rent->sec_symndx = sec_symndx; 459 rent->offset = offset; 460 rent->addend = addend; 461 hh->reloc_entries = rent; 462 463 return TRUE; 464 } 465 466 /* Return a pointer to the local DLT, PLT and OPD reference counts 467 for ABFD. Returns NULL if the storage allocation fails. */ 468 469 static bfd_signed_vma * 470 hppa64_elf_local_refcounts (bfd *abfd) 471 { 472 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 473 bfd_signed_vma *local_refcounts; 474 475 local_refcounts = elf_local_got_refcounts (abfd); 476 if (local_refcounts == NULL) 477 { 478 bfd_size_type size; 479 480 /* Allocate space for local DLT, PLT and OPD reference 481 counts. Done this way to save polluting elf_obj_tdata 482 with another target specific pointer. */ 483 size = symtab_hdr->sh_info; 484 size *= 3 * sizeof (bfd_signed_vma); 485 local_refcounts = bfd_zalloc (abfd, size); 486 elf_local_got_refcounts (abfd) = local_refcounts; 487 } 488 return local_refcounts; 489 } 490 491 /* Scan the RELOCS and record the type of dynamic entries that each 492 referenced symbol needs. */ 493 494 static bfd_boolean 495 elf64_hppa_check_relocs (bfd *abfd, 496 struct bfd_link_info *info, 497 asection *sec, 498 const Elf_Internal_Rela *relocs) 499 { 500 struct elf64_hppa_link_hash_table *hppa_info; 501 const Elf_Internal_Rela *relend; 502 Elf_Internal_Shdr *symtab_hdr; 503 const Elf_Internal_Rela *rel; 504 unsigned int sec_symndx; 505 506 if (bfd_link_relocatable (info)) 507 return TRUE; 508 509 /* If this is the first dynamic object found in the link, create 510 the special sections required for dynamic linking. */ 511 if (! elf_hash_table (info)->dynamic_sections_created) 512 { 513 if (! _bfd_elf_link_create_dynamic_sections (abfd, info)) 514 return FALSE; 515 } 516 517 hppa_info = hppa_link_hash_table (info); 518 if (hppa_info == NULL) 519 return FALSE; 520 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 521 522 /* If necessary, build a new table holding section symbols indices 523 for this BFD. */ 524 525 if (bfd_link_pic (info) && hppa_info->section_syms_bfd != abfd) 526 { 527 unsigned long i; 528 unsigned int highest_shndx; 529 Elf_Internal_Sym *local_syms = NULL; 530 Elf_Internal_Sym *isym, *isymend; 531 bfd_size_type amt; 532 533 /* We're done with the old cache of section index to section symbol 534 index information. Free it. 535 536 ?!? Note we leak the last section_syms array. Presumably we 537 could free it in one of the later routines in this file. */ 538 if (hppa_info->section_syms) 539 free (hppa_info->section_syms); 540 541 /* Read this BFD's local symbols. */ 542 if (symtab_hdr->sh_info != 0) 543 { 544 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 545 if (local_syms == NULL) 546 local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr, 547 symtab_hdr->sh_info, 0, 548 NULL, NULL, NULL); 549 if (local_syms == NULL) 550 return FALSE; 551 } 552 553 /* Record the highest section index referenced by the local symbols. */ 554 highest_shndx = 0; 555 isymend = local_syms + symtab_hdr->sh_info; 556 for (isym = local_syms; isym < isymend; isym++) 557 { 558 if (isym->st_shndx > highest_shndx 559 && isym->st_shndx < SHN_LORESERVE) 560 highest_shndx = isym->st_shndx; 561 } 562 563 /* Allocate an array to hold the section index to section symbol index 564 mapping. Bump by one since we start counting at zero. */ 565 highest_shndx++; 566 amt = highest_shndx; 567 amt *= sizeof (int); 568 hppa_info->section_syms = (int *) bfd_malloc (amt); 569 570 /* Now walk the local symbols again. If we find a section symbol, 571 record the index of the symbol into the section_syms array. */ 572 for (i = 0, isym = local_syms; isym < isymend; i++, isym++) 573 { 574 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 575 hppa_info->section_syms[isym->st_shndx] = i; 576 } 577 578 /* We are finished with the local symbols. */ 579 if (local_syms != NULL 580 && symtab_hdr->contents != (unsigned char *) local_syms) 581 { 582 if (! info->keep_memory) 583 free (local_syms); 584 else 585 { 586 /* Cache the symbols for elf_link_input_bfd. */ 587 symtab_hdr->contents = (unsigned char *) local_syms; 588 } 589 } 590 591 /* Record which BFD we built the section_syms mapping for. */ 592 hppa_info->section_syms_bfd = abfd; 593 } 594 595 /* Record the symbol index for this input section. We may need it for 596 relocations when building shared libraries. When not building shared 597 libraries this value is never really used, but assign it to zero to 598 prevent out of bounds memory accesses in other routines. */ 599 if (bfd_link_pic (info)) 600 { 601 sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec); 602 603 /* If we did not find a section symbol for this section, then 604 something went terribly wrong above. */ 605 if (sec_symndx == SHN_BAD) 606 return FALSE; 607 608 if (sec_symndx < SHN_LORESERVE) 609 sec_symndx = hppa_info->section_syms[sec_symndx]; 610 else 611 sec_symndx = 0; 612 } 613 else 614 sec_symndx = 0; 615 616 relend = relocs + sec->reloc_count; 617 for (rel = relocs; rel < relend; ++rel) 618 { 619 enum 620 { 621 NEED_DLT = 1, 622 NEED_PLT = 2, 623 NEED_STUB = 4, 624 NEED_OPD = 8, 625 NEED_DYNREL = 16, 626 }; 627 628 unsigned long r_symndx = ELF64_R_SYM (rel->r_info); 629 struct elf64_hppa_link_hash_entry *hh; 630 int need_entry; 631 bfd_boolean maybe_dynamic; 632 int dynrel_type = R_PARISC_NONE; 633 static reloc_howto_type *howto; 634 635 if (r_symndx >= symtab_hdr->sh_info) 636 { 637 /* We're dealing with a global symbol -- find its hash entry 638 and mark it as being referenced. */ 639 long indx = r_symndx - symtab_hdr->sh_info; 640 hh = hppa_elf_hash_entry (elf_sym_hashes (abfd)[indx]); 641 while (hh->eh.root.type == bfd_link_hash_indirect 642 || hh->eh.root.type == bfd_link_hash_warning) 643 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 644 645 /* PR15323, ref flags aren't set for references in the same 646 object. */ 647 hh->eh.ref_regular = 1; 648 } 649 else 650 hh = NULL; 651 652 /* We can only get preliminary data on whether a symbol is 653 locally or externally defined, as not all of the input files 654 have yet been processed. Do something with what we know, as 655 this may help reduce memory usage and processing time later. */ 656 maybe_dynamic = FALSE; 657 if (hh && ((bfd_link_pic (info) 658 && (!info->symbolic 659 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 660 || !hh->eh.def_regular 661 || hh->eh.root.type == bfd_link_hash_defweak)) 662 maybe_dynamic = TRUE; 663 664 howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info); 665 need_entry = 0; 666 switch (howto->type) 667 { 668 /* These are simple indirect references to symbols through the 669 DLT. We need to create a DLT entry for any symbols which 670 appears in a DLTIND relocation. */ 671 case R_PARISC_DLTIND21L: 672 case R_PARISC_DLTIND14R: 673 case R_PARISC_DLTIND14F: 674 case R_PARISC_DLTIND14WR: 675 case R_PARISC_DLTIND14DR: 676 need_entry = NEED_DLT; 677 break; 678 679 /* ?!? These need a DLT entry. But I have no idea what to do with 680 the "link time TP value. */ 681 case R_PARISC_LTOFF_TP21L: 682 case R_PARISC_LTOFF_TP14R: 683 case R_PARISC_LTOFF_TP14F: 684 case R_PARISC_LTOFF_TP64: 685 case R_PARISC_LTOFF_TP14WR: 686 case R_PARISC_LTOFF_TP14DR: 687 case R_PARISC_LTOFF_TP16F: 688 case R_PARISC_LTOFF_TP16WF: 689 case R_PARISC_LTOFF_TP16DF: 690 need_entry = NEED_DLT; 691 break; 692 693 /* These are function calls. Depending on their precise target we 694 may need to make a stub for them. The stub uses the PLT, so we 695 need to create PLT entries for these symbols too. */ 696 case R_PARISC_PCREL12F: 697 case R_PARISC_PCREL17F: 698 case R_PARISC_PCREL22F: 699 case R_PARISC_PCREL32: 700 case R_PARISC_PCREL64: 701 case R_PARISC_PCREL21L: 702 case R_PARISC_PCREL17R: 703 case R_PARISC_PCREL17C: 704 case R_PARISC_PCREL14R: 705 case R_PARISC_PCREL14F: 706 case R_PARISC_PCREL22C: 707 case R_PARISC_PCREL14WR: 708 case R_PARISC_PCREL14DR: 709 case R_PARISC_PCREL16F: 710 case R_PARISC_PCREL16WF: 711 case R_PARISC_PCREL16DF: 712 /* Function calls might need to go through the .plt, and 713 might need a long branch stub. */ 714 if (hh != NULL && hh->eh.type != STT_PARISC_MILLI) 715 need_entry = (NEED_PLT | NEED_STUB); 716 else 717 need_entry = 0; 718 break; 719 720 case R_PARISC_PLTOFF21L: 721 case R_PARISC_PLTOFF14R: 722 case R_PARISC_PLTOFF14F: 723 case R_PARISC_PLTOFF14WR: 724 case R_PARISC_PLTOFF14DR: 725 case R_PARISC_PLTOFF16F: 726 case R_PARISC_PLTOFF16WF: 727 case R_PARISC_PLTOFF16DF: 728 need_entry = (NEED_PLT); 729 break; 730 731 case R_PARISC_DIR64: 732 if (bfd_link_pic (info) || maybe_dynamic) 733 need_entry = (NEED_DYNREL); 734 dynrel_type = R_PARISC_DIR64; 735 break; 736 737 /* This is an indirect reference through the DLT to get the address 738 of a OPD descriptor. Thus we need to make a DLT entry that points 739 to an OPD entry. */ 740 case R_PARISC_LTOFF_FPTR21L: 741 case R_PARISC_LTOFF_FPTR14R: 742 case R_PARISC_LTOFF_FPTR14WR: 743 case R_PARISC_LTOFF_FPTR14DR: 744 case R_PARISC_LTOFF_FPTR32: 745 case R_PARISC_LTOFF_FPTR64: 746 case R_PARISC_LTOFF_FPTR16F: 747 case R_PARISC_LTOFF_FPTR16WF: 748 case R_PARISC_LTOFF_FPTR16DF: 749 if (bfd_link_pic (info) || maybe_dynamic) 750 need_entry = (NEED_DLT | NEED_OPD | NEED_PLT); 751 else 752 need_entry = (NEED_DLT | NEED_OPD | NEED_PLT); 753 dynrel_type = R_PARISC_FPTR64; 754 break; 755 756 /* This is a simple OPD entry. */ 757 case R_PARISC_FPTR64: 758 if (bfd_link_pic (info) || maybe_dynamic) 759 need_entry = (NEED_OPD | NEED_PLT | NEED_DYNREL); 760 else 761 need_entry = (NEED_OPD | NEED_PLT); 762 dynrel_type = R_PARISC_FPTR64; 763 break; 764 765 /* Add more cases as needed. */ 766 } 767 768 if (!need_entry) 769 continue; 770 771 if (hh) 772 { 773 /* Stash away enough information to be able to find this symbol 774 regardless of whether or not it is local or global. */ 775 hh->owner = abfd; 776 hh->sym_indx = r_symndx; 777 } 778 779 /* Create what's needed. */ 780 if (need_entry & NEED_DLT) 781 { 782 /* Allocate space for a DLT entry, as well as a dynamic 783 relocation for this entry. */ 784 if (! hppa_info->dlt_sec 785 && ! get_dlt (abfd, info, hppa_info)) 786 goto err_out; 787 788 if (hh != NULL) 789 { 790 hh->want_dlt = 1; 791 hh->eh.got.refcount += 1; 792 } 793 else 794 { 795 bfd_signed_vma *local_dlt_refcounts; 796 797 /* This is a DLT entry for a local symbol. */ 798 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd); 799 if (local_dlt_refcounts == NULL) 800 return FALSE; 801 local_dlt_refcounts[r_symndx] += 1; 802 } 803 } 804 805 if (need_entry & NEED_PLT) 806 { 807 if (! hppa_info->plt_sec 808 && ! get_plt (abfd, info, hppa_info)) 809 goto err_out; 810 811 if (hh != NULL) 812 { 813 hh->want_plt = 1; 814 hh->eh.needs_plt = 1; 815 hh->eh.plt.refcount += 1; 816 } 817 else 818 { 819 bfd_signed_vma *local_dlt_refcounts; 820 bfd_signed_vma *local_plt_refcounts; 821 822 /* This is a PLT entry for a local symbol. */ 823 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd); 824 if (local_dlt_refcounts == NULL) 825 return FALSE; 826 local_plt_refcounts = local_dlt_refcounts + symtab_hdr->sh_info; 827 local_plt_refcounts[r_symndx] += 1; 828 } 829 } 830 831 if (need_entry & NEED_STUB) 832 { 833 if (! hppa_info->stub_sec 834 && ! get_stub (abfd, info, hppa_info)) 835 goto err_out; 836 if (hh) 837 hh->want_stub = 1; 838 } 839 840 if (need_entry & NEED_OPD) 841 { 842 if (! hppa_info->opd_sec 843 && ! get_opd (abfd, info, hppa_info)) 844 goto err_out; 845 846 /* FPTRs are not allocated by the dynamic linker for PA64, 847 though it is possible that will change in the future. */ 848 849 if (hh != NULL) 850 hh->want_opd = 1; 851 else 852 { 853 bfd_signed_vma *local_dlt_refcounts; 854 bfd_signed_vma *local_opd_refcounts; 855 856 /* This is a OPD for a local symbol. */ 857 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd); 858 if (local_dlt_refcounts == NULL) 859 return FALSE; 860 local_opd_refcounts = (local_dlt_refcounts 861 + 2 * symtab_hdr->sh_info); 862 local_opd_refcounts[r_symndx] += 1; 863 } 864 } 865 866 /* Add a new dynamic relocation to the chain of dynamic 867 relocations for this symbol. */ 868 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) 869 { 870 if (! hppa_info->other_rel_sec 871 && ! get_reloc_section (abfd, hppa_info, sec)) 872 goto err_out; 873 874 /* Count dynamic relocations against global symbols. */ 875 if (hh != NULL 876 && !count_dyn_reloc (abfd, hh, dynrel_type, sec, 877 sec_symndx, rel->r_offset, rel->r_addend)) 878 goto err_out; 879 880 /* If we are building a shared library and we just recorded 881 a dynamic R_PARISC_FPTR64 relocation, then make sure the 882 section symbol for this section ends up in the dynamic 883 symbol table. */ 884 if (bfd_link_pic (info) && dynrel_type == R_PARISC_FPTR64 885 && ! (bfd_elf_link_record_local_dynamic_symbol 886 (info, abfd, sec_symndx))) 887 return FALSE; 888 } 889 } 890 891 return TRUE; 892 893 err_out: 894 return FALSE; 895 } 896 897 struct elf64_hppa_allocate_data 898 { 899 struct bfd_link_info *info; 900 bfd_size_type ofs; 901 }; 902 903 /* Should we do dynamic things to this symbol? */ 904 905 static bfd_boolean 906 elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry *eh, 907 struct bfd_link_info *info) 908 { 909 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols 910 and relocations that retrieve a function descriptor? Assume the 911 worst for now. */ 912 if (_bfd_elf_dynamic_symbol_p (eh, info, 1)) 913 { 914 /* ??? Why is this here and not elsewhere is_local_label_name. */ 915 if (eh->root.root.string[0] == '$' && eh->root.root.string[1] == '$') 916 return FALSE; 917 918 return TRUE; 919 } 920 else 921 return FALSE; 922 } 923 924 /* Mark all functions exported by this file so that we can later allocate 925 entries in .opd for them. */ 926 927 static bfd_boolean 928 elf64_hppa_mark_exported_functions (struct elf_link_hash_entry *eh, void *data) 929 { 930 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 931 struct bfd_link_info *info = (struct bfd_link_info *)data; 932 struct elf64_hppa_link_hash_table *hppa_info; 933 934 hppa_info = hppa_link_hash_table (info); 935 if (hppa_info == NULL) 936 return FALSE; 937 938 if (eh 939 && (eh->root.type == bfd_link_hash_defined 940 || eh->root.type == bfd_link_hash_defweak) 941 && eh->root.u.def.section->output_section != NULL 942 && eh->type == STT_FUNC) 943 { 944 if (! hppa_info->opd_sec 945 && ! get_opd (hppa_info->root.dynobj, info, hppa_info)) 946 return FALSE; 947 948 hh->want_opd = 1; 949 950 /* Put a flag here for output_symbol_hook. */ 951 hh->st_shndx = -1; 952 eh->needs_plt = 1; 953 } 954 955 return TRUE; 956 } 957 958 /* Allocate space for a DLT entry. */ 959 960 static bfd_boolean 961 allocate_global_data_dlt (struct elf_link_hash_entry *eh, void *data) 962 { 963 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 964 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 965 966 if (hh->want_dlt) 967 { 968 if (bfd_link_pic (x->info)) 969 { 970 /* Possibly add the symbol to the local dynamic symbol 971 table since we might need to create a dynamic relocation 972 against it. */ 973 if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI) 974 { 975 bfd *owner = eh->root.u.def.section->owner; 976 977 if (! (bfd_elf_link_record_local_dynamic_symbol 978 (x->info, owner, hh->sym_indx))) 979 return FALSE; 980 } 981 } 982 983 hh->dlt_offset = x->ofs; 984 x->ofs += DLT_ENTRY_SIZE; 985 } 986 return TRUE; 987 } 988 989 /* Allocate space for a DLT.PLT entry. */ 990 991 static bfd_boolean 992 allocate_global_data_plt (struct elf_link_hash_entry *eh, void *data) 993 { 994 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 995 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *) data; 996 997 if (hh->want_plt 998 && elf64_hppa_dynamic_symbol_p (eh, x->info) 999 && !((eh->root.type == bfd_link_hash_defined 1000 || eh->root.type == bfd_link_hash_defweak) 1001 && eh->root.u.def.section->output_section != NULL)) 1002 { 1003 hh->plt_offset = x->ofs; 1004 x->ofs += PLT_ENTRY_SIZE; 1005 if (hh->plt_offset < 0x2000) 1006 { 1007 struct elf64_hppa_link_hash_table *hppa_info; 1008 1009 hppa_info = hppa_link_hash_table (x->info); 1010 if (hppa_info == NULL) 1011 return FALSE; 1012 1013 hppa_info->gp_offset = hh->plt_offset; 1014 } 1015 } 1016 else 1017 hh->want_plt = 0; 1018 1019 return TRUE; 1020 } 1021 1022 /* Allocate space for a STUB entry. */ 1023 1024 static bfd_boolean 1025 allocate_global_data_stub (struct elf_link_hash_entry *eh, void *data) 1026 { 1027 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 1028 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1029 1030 if (hh->want_stub 1031 && elf64_hppa_dynamic_symbol_p (eh, x->info) 1032 && !((eh->root.type == bfd_link_hash_defined 1033 || eh->root.type == bfd_link_hash_defweak) 1034 && eh->root.u.def.section->output_section != NULL)) 1035 { 1036 hh->stub_offset = x->ofs; 1037 x->ofs += sizeof (plt_stub); 1038 } 1039 else 1040 hh->want_stub = 0; 1041 return TRUE; 1042 } 1043 1044 /* Allocate space for a FPTR entry. */ 1045 1046 static bfd_boolean 1047 allocate_global_data_opd (struct elf_link_hash_entry *eh, void *data) 1048 { 1049 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 1050 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1051 1052 if (hh && hh->want_opd) 1053 { 1054 /* We never need an opd entry for a symbol which is not 1055 defined by this output file. */ 1056 if (hh && (hh->eh.root.type == bfd_link_hash_undefined 1057 || hh->eh.root.type == bfd_link_hash_undefweak 1058 || hh->eh.root.u.def.section->output_section == NULL)) 1059 hh->want_opd = 0; 1060 1061 /* If we are creating a shared library, took the address of a local 1062 function or might export this function from this object file, then 1063 we have to create an opd descriptor. */ 1064 else if (bfd_link_pic (x->info) 1065 || hh == NULL 1066 || (hh->eh.dynindx == -1 && hh->eh.type != STT_PARISC_MILLI) 1067 || (hh->eh.root.type == bfd_link_hash_defined 1068 || hh->eh.root.type == bfd_link_hash_defweak)) 1069 { 1070 /* If we are creating a shared library, then we will have to 1071 create a runtime relocation for the symbol to properly 1072 initialize the .opd entry. Make sure the symbol gets 1073 added to the dynamic symbol table. */ 1074 if (bfd_link_pic (x->info) 1075 && (hh == NULL || (hh->eh.dynindx == -1))) 1076 { 1077 bfd *owner; 1078 /* PR 6511: Default to using the dynamic symbol table. */ 1079 owner = (hh->owner ? hh->owner: eh->root.u.def.section->owner); 1080 1081 if (!bfd_elf_link_record_local_dynamic_symbol 1082 (x->info, owner, hh->sym_indx)) 1083 return FALSE; 1084 } 1085 1086 /* This may not be necessary or desirable anymore now that 1087 we have some support for dealing with section symbols 1088 in dynamic relocs. But name munging does make the result 1089 much easier to debug. ie, the EPLT reloc will reference 1090 a symbol like .foobar, instead of .text + offset. */ 1091 if (bfd_link_pic (x->info) && eh) 1092 { 1093 char *new_name; 1094 struct elf_link_hash_entry *nh; 1095 1096 new_name = concat (".", eh->root.root.string, NULL); 1097 1098 nh = elf_link_hash_lookup (elf_hash_table (x->info), 1099 new_name, TRUE, TRUE, TRUE); 1100 1101 free (new_name); 1102 nh->root.type = eh->root.type; 1103 nh->root.u.def.value = eh->root.u.def.value; 1104 nh->root.u.def.section = eh->root.u.def.section; 1105 1106 if (! bfd_elf_link_record_dynamic_symbol (x->info, nh)) 1107 return FALSE; 1108 } 1109 hh->opd_offset = x->ofs; 1110 x->ofs += OPD_ENTRY_SIZE; 1111 } 1112 1113 /* Otherwise we do not need an opd entry. */ 1114 else 1115 hh->want_opd = 0; 1116 } 1117 return TRUE; 1118 } 1119 1120 /* HP requires the EI_OSABI field to be filled in. The assignment to 1121 EI_ABIVERSION may not be strictly necessary. */ 1122 1123 static void 1124 elf64_hppa_post_process_headers (bfd *abfd, 1125 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 1126 { 1127 Elf_Internal_Ehdr * i_ehdrp; 1128 1129 i_ehdrp = elf_elfheader (abfd); 1130 1131 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; 1132 i_ehdrp->e_ident[EI_ABIVERSION] = 1; 1133 } 1134 1135 /* Create function descriptor section (.opd). This section is called .opd 1136 because it contains "official procedure descriptors". The "official" 1137 refers to the fact that these descriptors are used when taking the address 1138 of a procedure, thus ensuring a unique address for each procedure. */ 1139 1140 static bfd_boolean 1141 get_opd (bfd *abfd, 1142 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1143 struct elf64_hppa_link_hash_table *hppa_info) 1144 { 1145 asection *opd; 1146 bfd *dynobj; 1147 1148 opd = hppa_info->opd_sec; 1149 if (!opd) 1150 { 1151 dynobj = hppa_info->root.dynobj; 1152 if (!dynobj) 1153 hppa_info->root.dynobj = dynobj = abfd; 1154 1155 opd = bfd_make_section_anyway_with_flags (dynobj, ".opd", 1156 (SEC_ALLOC 1157 | SEC_LOAD 1158 | SEC_HAS_CONTENTS 1159 | SEC_IN_MEMORY 1160 | SEC_LINKER_CREATED)); 1161 if (!opd 1162 || !bfd_set_section_alignment (abfd, opd, 3)) 1163 { 1164 BFD_ASSERT (0); 1165 return FALSE; 1166 } 1167 1168 hppa_info->opd_sec = opd; 1169 } 1170 1171 return TRUE; 1172 } 1173 1174 /* Create the PLT section. */ 1175 1176 static bfd_boolean 1177 get_plt (bfd *abfd, 1178 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1179 struct elf64_hppa_link_hash_table *hppa_info) 1180 { 1181 asection *plt; 1182 bfd *dynobj; 1183 1184 plt = hppa_info->plt_sec; 1185 if (!plt) 1186 { 1187 dynobj = hppa_info->root.dynobj; 1188 if (!dynobj) 1189 hppa_info->root.dynobj = dynobj = abfd; 1190 1191 plt = bfd_make_section_anyway_with_flags (dynobj, ".plt", 1192 (SEC_ALLOC 1193 | SEC_LOAD 1194 | SEC_HAS_CONTENTS 1195 | SEC_IN_MEMORY 1196 | SEC_LINKER_CREATED)); 1197 if (!plt 1198 || !bfd_set_section_alignment (abfd, plt, 3)) 1199 { 1200 BFD_ASSERT (0); 1201 return FALSE; 1202 } 1203 1204 hppa_info->plt_sec = plt; 1205 } 1206 1207 return TRUE; 1208 } 1209 1210 /* Create the DLT section. */ 1211 1212 static bfd_boolean 1213 get_dlt (bfd *abfd, 1214 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1215 struct elf64_hppa_link_hash_table *hppa_info) 1216 { 1217 asection *dlt; 1218 bfd *dynobj; 1219 1220 dlt = hppa_info->dlt_sec; 1221 if (!dlt) 1222 { 1223 dynobj = hppa_info->root.dynobj; 1224 if (!dynobj) 1225 hppa_info->root.dynobj = dynobj = abfd; 1226 1227 dlt = bfd_make_section_anyway_with_flags (dynobj, ".dlt", 1228 (SEC_ALLOC 1229 | SEC_LOAD 1230 | SEC_HAS_CONTENTS 1231 | SEC_IN_MEMORY 1232 | SEC_LINKER_CREATED)); 1233 if (!dlt 1234 || !bfd_set_section_alignment (abfd, dlt, 3)) 1235 { 1236 BFD_ASSERT (0); 1237 return FALSE; 1238 } 1239 1240 hppa_info->dlt_sec = dlt; 1241 } 1242 1243 return TRUE; 1244 } 1245 1246 /* Create the stubs section. */ 1247 1248 static bfd_boolean 1249 get_stub (bfd *abfd, 1250 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1251 struct elf64_hppa_link_hash_table *hppa_info) 1252 { 1253 asection *stub; 1254 bfd *dynobj; 1255 1256 stub = hppa_info->stub_sec; 1257 if (!stub) 1258 { 1259 dynobj = hppa_info->root.dynobj; 1260 if (!dynobj) 1261 hppa_info->root.dynobj = dynobj = abfd; 1262 1263 stub = bfd_make_section_anyway_with_flags (dynobj, ".stub", 1264 (SEC_ALLOC | SEC_LOAD 1265 | SEC_HAS_CONTENTS 1266 | SEC_IN_MEMORY 1267 | SEC_READONLY 1268 | SEC_LINKER_CREATED)); 1269 if (!stub 1270 || !bfd_set_section_alignment (abfd, stub, 3)) 1271 { 1272 BFD_ASSERT (0); 1273 return FALSE; 1274 } 1275 1276 hppa_info->stub_sec = stub; 1277 } 1278 1279 return TRUE; 1280 } 1281 1282 /* Create sections necessary for dynamic linking. This is only a rough 1283 cut and will likely change as we learn more about the somewhat 1284 unusual dynamic linking scheme HP uses. 1285 1286 .stub: 1287 Contains code to implement cross-space calls. The first time one 1288 of the stubs is used it will call into the dynamic linker, later 1289 calls will go straight to the target. 1290 1291 The only stub we support right now looks like 1292 1293 ldd OFFSET(%dp),%r1 1294 bve %r0(%r1) 1295 ldd OFFSET+8(%dp),%dp 1296 1297 Other stubs may be needed in the future. We may want the remove 1298 the break/nop instruction. It is only used right now to keep the 1299 offset of a .plt entry and a .stub entry in sync. 1300 1301 .dlt: 1302 This is what most people call the .got. HP used a different name. 1303 Losers. 1304 1305 .rela.dlt: 1306 Relocations for the DLT. 1307 1308 .plt: 1309 Function pointers as address,gp pairs. 1310 1311 .rela.plt: 1312 Should contain dynamic IPLT (and EPLT?) relocations. 1313 1314 .opd: 1315 FPTRS 1316 1317 .rela.opd: 1318 EPLT relocations for symbols exported from shared libraries. */ 1319 1320 static bfd_boolean 1321 elf64_hppa_create_dynamic_sections (bfd *abfd, 1322 struct bfd_link_info *info) 1323 { 1324 asection *s; 1325 struct elf64_hppa_link_hash_table *hppa_info; 1326 1327 hppa_info = hppa_link_hash_table (info); 1328 if (hppa_info == NULL) 1329 return FALSE; 1330 1331 if (! get_stub (abfd, info, hppa_info)) 1332 return FALSE; 1333 1334 if (! get_dlt (abfd, info, hppa_info)) 1335 return FALSE; 1336 1337 if (! get_plt (abfd, info, hppa_info)) 1338 return FALSE; 1339 1340 if (! get_opd (abfd, info, hppa_info)) 1341 return FALSE; 1342 1343 s = bfd_make_section_anyway_with_flags (abfd, ".rela.dlt", 1344 (SEC_ALLOC | SEC_LOAD 1345 | SEC_HAS_CONTENTS 1346 | SEC_IN_MEMORY 1347 | SEC_READONLY 1348 | SEC_LINKER_CREATED)); 1349 if (s == NULL 1350 || !bfd_set_section_alignment (abfd, s, 3)) 1351 return FALSE; 1352 hppa_info->dlt_rel_sec = s; 1353 1354 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", 1355 (SEC_ALLOC | SEC_LOAD 1356 | SEC_HAS_CONTENTS 1357 | SEC_IN_MEMORY 1358 | SEC_READONLY 1359 | SEC_LINKER_CREATED)); 1360 if (s == NULL 1361 || !bfd_set_section_alignment (abfd, s, 3)) 1362 return FALSE; 1363 hppa_info->plt_rel_sec = s; 1364 1365 s = bfd_make_section_anyway_with_flags (abfd, ".rela.data", 1366 (SEC_ALLOC | SEC_LOAD 1367 | SEC_HAS_CONTENTS 1368 | SEC_IN_MEMORY 1369 | SEC_READONLY 1370 | SEC_LINKER_CREATED)); 1371 if (s == NULL 1372 || !bfd_set_section_alignment (abfd, s, 3)) 1373 return FALSE; 1374 hppa_info->other_rel_sec = s; 1375 1376 s = bfd_make_section_anyway_with_flags (abfd, ".rela.opd", 1377 (SEC_ALLOC | SEC_LOAD 1378 | SEC_HAS_CONTENTS 1379 | SEC_IN_MEMORY 1380 | SEC_READONLY 1381 | SEC_LINKER_CREATED)); 1382 if (s == NULL 1383 || !bfd_set_section_alignment (abfd, s, 3)) 1384 return FALSE; 1385 hppa_info->opd_rel_sec = s; 1386 1387 return TRUE; 1388 } 1389 1390 /* Allocate dynamic relocations for those symbols that turned out 1391 to be dynamic. */ 1392 1393 static bfd_boolean 1394 allocate_dynrel_entries (struct elf_link_hash_entry *eh, void *data) 1395 { 1396 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 1397 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1398 struct elf64_hppa_link_hash_table *hppa_info; 1399 struct elf64_hppa_dyn_reloc_entry *rent; 1400 bfd_boolean dynamic_symbol, shared; 1401 1402 hppa_info = hppa_link_hash_table (x->info); 1403 if (hppa_info == NULL) 1404 return FALSE; 1405 1406 dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info); 1407 shared = bfd_link_pic (x->info); 1408 1409 /* We may need to allocate relocations for a non-dynamic symbol 1410 when creating a shared library. */ 1411 if (!dynamic_symbol && !shared) 1412 return TRUE; 1413 1414 /* Take care of the normal data relocations. */ 1415 1416 for (rent = hh->reloc_entries; rent; rent = rent->next) 1417 { 1418 /* Allocate one iff we are building a shared library, the relocation 1419 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */ 1420 if (!shared && rent->type == R_PARISC_FPTR64 && hh->want_opd) 1421 continue; 1422 1423 hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela); 1424 1425 /* Make sure this symbol gets into the dynamic symbol table if it is 1426 not already recorded. ?!? This should not be in the loop since 1427 the symbol need only be added once. */ 1428 if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI) 1429 if (!bfd_elf_link_record_local_dynamic_symbol 1430 (x->info, rent->sec->owner, hh->sym_indx)) 1431 return FALSE; 1432 } 1433 1434 /* Take care of the GOT and PLT relocations. */ 1435 1436 if ((dynamic_symbol || shared) && hh->want_dlt) 1437 hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela); 1438 1439 /* If we are building a shared library, then every symbol that has an 1440 opd entry will need an EPLT relocation to relocate the symbol's address 1441 and __gp value based on the runtime load address. */ 1442 if (shared && hh->want_opd) 1443 hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela); 1444 1445 if (hh->want_plt && dynamic_symbol) 1446 { 1447 bfd_size_type t = 0; 1448 1449 /* Dynamic symbols get one IPLT relocation. Local symbols in 1450 shared libraries get two REL relocations. Local symbols in 1451 main applications get nothing. */ 1452 if (dynamic_symbol) 1453 t = sizeof (Elf64_External_Rela); 1454 else if (shared) 1455 t = 2 * sizeof (Elf64_External_Rela); 1456 1457 hppa_info->plt_rel_sec->size += t; 1458 } 1459 1460 return TRUE; 1461 } 1462 1463 /* Adjust a symbol defined by a dynamic object and referenced by a 1464 regular object. */ 1465 1466 static bfd_boolean 1467 elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, 1468 struct elf_link_hash_entry *eh) 1469 { 1470 /* ??? Undefined symbols with PLT entries should be re-defined 1471 to be the PLT entry. */ 1472 1473 /* If this is a weak symbol, and there is a real definition, the 1474 processor independent code will have arranged for us to see the 1475 real definition first, and we can just use the same value. */ 1476 if (eh->is_weakalias) 1477 { 1478 struct elf_link_hash_entry *def = weakdef (eh); 1479 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 1480 eh->root.u.def.section = def->root.u.def.section; 1481 eh->root.u.def.value = def->root.u.def.value; 1482 return TRUE; 1483 } 1484 1485 /* If this is a reference to a symbol defined by a dynamic object which 1486 is not a function, we might allocate the symbol in our .dynbss section 1487 and allocate a COPY dynamic relocation. 1488 1489 But PA64 code is canonically PIC, so as a rule we can avoid this sort 1490 of hackery. */ 1491 1492 return TRUE; 1493 } 1494 1495 /* This function is called via elf_link_hash_traverse to mark millicode 1496 symbols with a dynindx of -1 and to remove the string table reference 1497 from the dynamic symbol table. If the symbol is not a millicode symbol, 1498 elf64_hppa_mark_exported_functions is called. */ 1499 1500 static bfd_boolean 1501 elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh, 1502 void *data) 1503 { 1504 struct bfd_link_info *info = (struct bfd_link_info *) data; 1505 1506 if (eh->type == STT_PARISC_MILLI) 1507 { 1508 if (eh->dynindx != -1) 1509 { 1510 eh->dynindx = -1; 1511 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1512 eh->dynstr_index); 1513 } 1514 return TRUE; 1515 } 1516 1517 return elf64_hppa_mark_exported_functions (eh, data); 1518 } 1519 1520 /* Set the final sizes of the dynamic sections and allocate memory for 1521 the contents of our special sections. */ 1522 1523 static bfd_boolean 1524 elf64_hppa_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 1525 { 1526 struct elf64_hppa_link_hash_table *hppa_info; 1527 struct elf64_hppa_allocate_data data; 1528 bfd *dynobj; 1529 bfd *ibfd; 1530 asection *sec; 1531 bfd_boolean plt; 1532 bfd_boolean relocs; 1533 bfd_boolean reltext; 1534 1535 hppa_info = hppa_link_hash_table (info); 1536 if (hppa_info == NULL) 1537 return FALSE; 1538 1539 dynobj = hppa_info->root.dynobj; 1540 BFD_ASSERT (dynobj != NULL); 1541 1542 /* Mark each function this program exports so that we will allocate 1543 space in the .opd section for each function's FPTR. If we are 1544 creating dynamic sections, change the dynamic index of millicode 1545 symbols to -1 and remove them from the string table for .dynstr. 1546 1547 We have to traverse the main linker hash table since we have to 1548 find functions which may not have been mentioned in any relocs. */ 1549 elf_link_hash_traverse (&hppa_info->root, 1550 (hppa_info->root.dynamic_sections_created 1551 ? elf64_hppa_mark_milli_and_exported_functions 1552 : elf64_hppa_mark_exported_functions), 1553 info); 1554 1555 if (hppa_info->root.dynamic_sections_created) 1556 { 1557 /* Set the contents of the .interp section to the interpreter. */ 1558 if (bfd_link_executable (info) && !info->nointerp) 1559 { 1560 sec = bfd_get_linker_section (dynobj, ".interp"); 1561 BFD_ASSERT (sec != NULL); 1562 sec->size = sizeof ELF_DYNAMIC_INTERPRETER; 1563 sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1564 } 1565 } 1566 else 1567 { 1568 /* We may have created entries in the .rela.got section. 1569 However, if we are not creating the dynamic sections, we will 1570 not actually use these entries. Reset the size of .rela.dlt, 1571 which will cause it to get stripped from the output file 1572 below. */ 1573 sec = hppa_info->dlt_rel_sec; 1574 if (sec != NULL) 1575 sec->size = 0; 1576 } 1577 1578 /* Set up DLT, PLT and OPD offsets for local syms, and space for local 1579 dynamic relocs. */ 1580 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 1581 { 1582 bfd_signed_vma *local_dlt; 1583 bfd_signed_vma *end_local_dlt; 1584 bfd_signed_vma *local_plt; 1585 bfd_signed_vma *end_local_plt; 1586 bfd_signed_vma *local_opd; 1587 bfd_signed_vma *end_local_opd; 1588 bfd_size_type locsymcount; 1589 Elf_Internal_Shdr *symtab_hdr; 1590 asection *srel; 1591 1592 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 1593 continue; 1594 1595 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 1596 { 1597 struct elf64_hppa_dyn_reloc_entry *hdh_p; 1598 1599 for (hdh_p = ((struct elf64_hppa_dyn_reloc_entry *) 1600 elf_section_data (sec)->local_dynrel); 1601 hdh_p != NULL; 1602 hdh_p = hdh_p->next) 1603 { 1604 if (!bfd_is_abs_section (hdh_p->sec) 1605 && bfd_is_abs_section (hdh_p->sec->output_section)) 1606 { 1607 /* Input section has been discarded, either because 1608 it is a copy of a linkonce section or due to 1609 linker script /DISCARD/, so we'll be discarding 1610 the relocs too. */ 1611 } 1612 else if (hdh_p->count != 0) 1613 { 1614 srel = elf_section_data (hdh_p->sec)->sreloc; 1615 srel->size += hdh_p->count * sizeof (Elf64_External_Rela); 1616 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0) 1617 info->flags |= DF_TEXTREL; 1618 } 1619 } 1620 } 1621 1622 local_dlt = elf_local_got_refcounts (ibfd); 1623 if (!local_dlt) 1624 continue; 1625 1626 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1627 locsymcount = symtab_hdr->sh_info; 1628 end_local_dlt = local_dlt + locsymcount; 1629 sec = hppa_info->dlt_sec; 1630 srel = hppa_info->dlt_rel_sec; 1631 for (; local_dlt < end_local_dlt; ++local_dlt) 1632 { 1633 if (*local_dlt > 0) 1634 { 1635 *local_dlt = sec->size; 1636 sec->size += DLT_ENTRY_SIZE; 1637 if (bfd_link_pic (info)) 1638 { 1639 srel->size += sizeof (Elf64_External_Rela); 1640 } 1641 } 1642 else 1643 *local_dlt = (bfd_vma) -1; 1644 } 1645 1646 local_plt = end_local_dlt; 1647 end_local_plt = local_plt + locsymcount; 1648 if (! hppa_info->root.dynamic_sections_created) 1649 { 1650 /* Won't be used, but be safe. */ 1651 for (; local_plt < end_local_plt; ++local_plt) 1652 *local_plt = (bfd_vma) -1; 1653 } 1654 else 1655 { 1656 sec = hppa_info->plt_sec; 1657 srel = hppa_info->plt_rel_sec; 1658 for (; local_plt < end_local_plt; ++local_plt) 1659 { 1660 if (*local_plt > 0) 1661 { 1662 *local_plt = sec->size; 1663 sec->size += PLT_ENTRY_SIZE; 1664 if (bfd_link_pic (info)) 1665 srel->size += sizeof (Elf64_External_Rela); 1666 } 1667 else 1668 *local_plt = (bfd_vma) -1; 1669 } 1670 } 1671 1672 local_opd = end_local_plt; 1673 end_local_opd = local_opd + locsymcount; 1674 if (! hppa_info->root.dynamic_sections_created) 1675 { 1676 /* Won't be used, but be safe. */ 1677 for (; local_opd < end_local_opd; ++local_opd) 1678 *local_opd = (bfd_vma) -1; 1679 } 1680 else 1681 { 1682 sec = hppa_info->opd_sec; 1683 srel = hppa_info->opd_rel_sec; 1684 for (; local_opd < end_local_opd; ++local_opd) 1685 { 1686 if (*local_opd > 0) 1687 { 1688 *local_opd = sec->size; 1689 sec->size += OPD_ENTRY_SIZE; 1690 if (bfd_link_pic (info)) 1691 srel->size += sizeof (Elf64_External_Rela); 1692 } 1693 else 1694 *local_opd = (bfd_vma) -1; 1695 } 1696 } 1697 } 1698 1699 /* Allocate the GOT entries. */ 1700 1701 data.info = info; 1702 if (hppa_info->dlt_sec) 1703 { 1704 data.ofs = hppa_info->dlt_sec->size; 1705 elf_link_hash_traverse (&hppa_info->root, 1706 allocate_global_data_dlt, &data); 1707 hppa_info->dlt_sec->size = data.ofs; 1708 } 1709 1710 if (hppa_info->plt_sec) 1711 { 1712 data.ofs = hppa_info->plt_sec->size; 1713 elf_link_hash_traverse (&hppa_info->root, 1714 allocate_global_data_plt, &data); 1715 hppa_info->plt_sec->size = data.ofs; 1716 } 1717 1718 if (hppa_info->stub_sec) 1719 { 1720 data.ofs = 0x0; 1721 elf_link_hash_traverse (&hppa_info->root, 1722 allocate_global_data_stub, &data); 1723 hppa_info->stub_sec->size = data.ofs; 1724 } 1725 1726 /* Allocate space for entries in the .opd section. */ 1727 if (hppa_info->opd_sec) 1728 { 1729 data.ofs = hppa_info->opd_sec->size; 1730 elf_link_hash_traverse (&hppa_info->root, 1731 allocate_global_data_opd, &data); 1732 hppa_info->opd_sec->size = data.ofs; 1733 } 1734 1735 /* Now allocate space for dynamic relocations, if necessary. */ 1736 if (hppa_info->root.dynamic_sections_created) 1737 elf_link_hash_traverse (&hppa_info->root, 1738 allocate_dynrel_entries, &data); 1739 1740 /* The sizes of all the sections are set. Allocate memory for them. */ 1741 plt = FALSE; 1742 relocs = FALSE; 1743 reltext = FALSE; 1744 for (sec = dynobj->sections; sec != NULL; sec = sec->next) 1745 { 1746 const char *name; 1747 1748 if ((sec->flags & SEC_LINKER_CREATED) == 0) 1749 continue; 1750 1751 /* It's OK to base decisions on the section name, because none 1752 of the dynobj section names depend upon the input files. */ 1753 name = bfd_get_section_name (dynobj, sec); 1754 1755 if (strcmp (name, ".plt") == 0) 1756 { 1757 /* Remember whether there is a PLT. */ 1758 plt = sec->size != 0; 1759 } 1760 else if (strcmp (name, ".opd") == 0 1761 || CONST_STRNEQ (name, ".dlt") 1762 || strcmp (name, ".stub") == 0 1763 || strcmp (name, ".got") == 0) 1764 { 1765 /* Strip this section if we don't need it; see the comment below. */ 1766 } 1767 else if (CONST_STRNEQ (name, ".rela")) 1768 { 1769 if (sec->size != 0) 1770 { 1771 asection *target; 1772 1773 /* Remember whether there are any reloc sections other 1774 than .rela.plt. */ 1775 if (strcmp (name, ".rela.plt") != 0) 1776 { 1777 const char *outname; 1778 1779 relocs = TRUE; 1780 1781 /* If this relocation section applies to a read only 1782 section, then we probably need a DT_TEXTREL 1783 entry. The entries in the .rela.plt section 1784 really apply to the .got section, which we 1785 created ourselves and so know is not readonly. */ 1786 outname = bfd_get_section_name (output_bfd, 1787 sec->output_section); 1788 target = bfd_get_section_by_name (output_bfd, outname + 4); 1789 if (target != NULL 1790 && (target->flags & SEC_READONLY) != 0 1791 && (target->flags & SEC_ALLOC) != 0) 1792 reltext = TRUE; 1793 } 1794 1795 /* We use the reloc_count field as a counter if we need 1796 to copy relocs into the output file. */ 1797 sec->reloc_count = 0; 1798 } 1799 } 1800 else 1801 { 1802 /* It's not one of our sections, so don't allocate space. */ 1803 continue; 1804 } 1805 1806 if (sec->size == 0) 1807 { 1808 /* If we don't need this section, strip it from the 1809 output file. This is mostly to handle .rela.bss and 1810 .rela.plt. We must create both sections in 1811 create_dynamic_sections, because they must be created 1812 before the linker maps input sections to output 1813 sections. The linker does that before 1814 adjust_dynamic_symbol is called, and it is that 1815 function which decides whether anything needs to go 1816 into these sections. */ 1817 sec->flags |= SEC_EXCLUDE; 1818 continue; 1819 } 1820 1821 if ((sec->flags & SEC_HAS_CONTENTS) == 0) 1822 continue; 1823 1824 /* Allocate memory for the section contents if it has not 1825 been allocated already. We use bfd_zalloc here in case 1826 unused entries are not reclaimed before the section's 1827 contents are written out. This should not happen, but this 1828 way if it does, we get a R_PARISC_NONE reloc instead of 1829 garbage. */ 1830 if (sec->contents == NULL) 1831 { 1832 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size); 1833 if (sec->contents == NULL) 1834 return FALSE; 1835 } 1836 } 1837 1838 if (hppa_info->root.dynamic_sections_created) 1839 { 1840 /* Always create a DT_PLTGOT. It actually has nothing to do with 1841 the PLT, it is how we communicate the __gp value of a load 1842 module to the dynamic linker. */ 1843 #define add_dynamic_entry(TAG, VAL) \ 1844 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1845 1846 if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0) 1847 || !add_dynamic_entry (DT_PLTGOT, 0)) 1848 return FALSE; 1849 1850 /* Add some entries to the .dynamic section. We fill in the 1851 values later, in elf64_hppa_finish_dynamic_sections, but we 1852 must add the entries now so that we get the correct size for 1853 the .dynamic section. The DT_DEBUG entry is filled in by the 1854 dynamic linker and used by the debugger. */ 1855 if (! bfd_link_pic (info)) 1856 { 1857 if (!add_dynamic_entry (DT_DEBUG, 0) 1858 || !add_dynamic_entry (DT_HP_DLD_HOOK, 0) 1859 || !add_dynamic_entry (DT_HP_LOAD_MAP, 0)) 1860 return FALSE; 1861 } 1862 1863 /* Force DT_FLAGS to always be set. 1864 Required by HPUX 11.00 patch PHSS_26559. */ 1865 if (!add_dynamic_entry (DT_FLAGS, (info)->flags)) 1866 return FALSE; 1867 1868 if (plt) 1869 { 1870 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 1871 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1872 || !add_dynamic_entry (DT_JMPREL, 0)) 1873 return FALSE; 1874 } 1875 1876 if (relocs) 1877 { 1878 if (!add_dynamic_entry (DT_RELA, 0) 1879 || !add_dynamic_entry (DT_RELASZ, 0) 1880 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 1881 return FALSE; 1882 } 1883 1884 if (reltext) 1885 { 1886 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1887 return FALSE; 1888 info->flags |= DF_TEXTREL; 1889 } 1890 } 1891 #undef add_dynamic_entry 1892 1893 return TRUE; 1894 } 1895 1896 /* Called after we have output the symbol into the dynamic symbol 1897 table, but before we output the symbol into the normal symbol 1898 table. 1899 1900 For some symbols we had to change their address when outputting 1901 the dynamic symbol table. We undo that change here so that 1902 the symbols have their expected value in the normal symbol 1903 table. Ick. */ 1904 1905 static int 1906 elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED, 1907 const char *name, 1908 Elf_Internal_Sym *sym, 1909 asection *input_sec ATTRIBUTE_UNUSED, 1910 struct elf_link_hash_entry *eh) 1911 { 1912 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 1913 1914 /* We may be called with the file symbol or section symbols. 1915 They never need munging, so it is safe to ignore them. */ 1916 if (!name || !eh) 1917 return 1; 1918 1919 /* Function symbols for which we created .opd entries *may* have been 1920 munged by finish_dynamic_symbol and have to be un-munged here. 1921 1922 Note that finish_dynamic_symbol sometimes turns dynamic symbols 1923 into non-dynamic ones, so we initialize st_shndx to -1 in 1924 mark_exported_functions and check to see if it was overwritten 1925 here instead of just checking eh->dynindx. */ 1926 if (hh->want_opd && hh->st_shndx != -1) 1927 { 1928 /* Restore the saved value and section index. */ 1929 sym->st_value = hh->st_value; 1930 sym->st_shndx = hh->st_shndx; 1931 } 1932 1933 return 1; 1934 } 1935 1936 /* Finish up dynamic symbol handling. We set the contents of various 1937 dynamic sections here. */ 1938 1939 static bfd_boolean 1940 elf64_hppa_finish_dynamic_symbol (bfd *output_bfd, 1941 struct bfd_link_info *info, 1942 struct elf_link_hash_entry *eh, 1943 Elf_Internal_Sym *sym) 1944 { 1945 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 1946 asection *stub, *splt, *sopd, *spltrel; 1947 struct elf64_hppa_link_hash_table *hppa_info; 1948 1949 hppa_info = hppa_link_hash_table (info); 1950 if (hppa_info == NULL) 1951 return FALSE; 1952 1953 stub = hppa_info->stub_sec; 1954 splt = hppa_info->plt_sec; 1955 sopd = hppa_info->opd_sec; 1956 spltrel = hppa_info->plt_rel_sec; 1957 1958 /* Incredible. It is actually necessary to NOT use the symbol's real 1959 value when building the dynamic symbol table for a shared library. 1960 At least for symbols that refer to functions. 1961 1962 We will store a new value and section index into the symbol long 1963 enough to output it into the dynamic symbol table, then we restore 1964 the original values (in elf64_hppa_link_output_symbol_hook). */ 1965 if (hh->want_opd) 1966 { 1967 BFD_ASSERT (sopd != NULL); 1968 1969 /* Save away the original value and section index so that we 1970 can restore them later. */ 1971 hh->st_value = sym->st_value; 1972 hh->st_shndx = sym->st_shndx; 1973 1974 /* For the dynamic symbol table entry, we want the value to be 1975 address of this symbol's entry within the .opd section. */ 1976 sym->st_value = (hh->opd_offset 1977 + sopd->output_offset 1978 + sopd->output_section->vma); 1979 sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 1980 sopd->output_section); 1981 } 1982 1983 /* Initialize a .plt entry if requested. */ 1984 if (hh->want_plt 1985 && elf64_hppa_dynamic_symbol_p (eh, info)) 1986 { 1987 bfd_vma value; 1988 Elf_Internal_Rela rel; 1989 bfd_byte *loc; 1990 1991 BFD_ASSERT (splt != NULL && spltrel != NULL); 1992 1993 /* We do not actually care about the value in the PLT entry 1994 if we are creating a shared library and the symbol is 1995 still undefined, we create a dynamic relocation to fill 1996 in the correct value. */ 1997 if (bfd_link_pic (info) && eh->root.type == bfd_link_hash_undefined) 1998 value = 0; 1999 else 2000 value = (eh->root.u.def.value + eh->root.u.def.section->vma); 2001 2002 /* Fill in the entry in the procedure linkage table. 2003 2004 The format of a plt entry is 2005 <funcaddr> <__gp>. 2006 2007 plt_offset is the offset within the PLT section at which to 2008 install the PLT entry. 2009 2010 We are modifying the in-memory PLT contents here, so we do not add 2011 in the output_offset of the PLT section. */ 2012 2013 bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset); 2014 value = _bfd_get_gp_value (splt->output_section->owner); 2015 bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset + 0x8); 2016 2017 /* Create a dynamic IPLT relocation for this entry. 2018 2019 We are creating a relocation in the output file's PLT section, 2020 which is included within the DLT secton. So we do need to include 2021 the PLT's output_offset in the computation of the relocation's 2022 address. */ 2023 rel.r_offset = (hh->plt_offset + splt->output_offset 2024 + splt->output_section->vma); 2025 rel.r_info = ELF64_R_INFO (hh->eh.dynindx, R_PARISC_IPLT); 2026 rel.r_addend = 0; 2027 2028 loc = spltrel->contents; 2029 loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela); 2030 bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc); 2031 } 2032 2033 /* Initialize an external call stub entry if requested. */ 2034 if (hh->want_stub 2035 && elf64_hppa_dynamic_symbol_p (eh, info)) 2036 { 2037 bfd_vma value; 2038 int insn; 2039 unsigned int max_offset; 2040 2041 BFD_ASSERT (stub != NULL); 2042 2043 /* Install the generic stub template. 2044 2045 We are modifying the contents of the stub section, so we do not 2046 need to include the stub section's output_offset here. */ 2047 memcpy (stub->contents + hh->stub_offset, plt_stub, sizeof (plt_stub)); 2048 2049 /* Fix up the first ldd instruction. 2050 2051 We are modifying the contents of the STUB section in memory, 2052 so we do not need to include its output offset in this computation. 2053 2054 Note the plt_offset value is the value of the PLT entry relative to 2055 the start of the PLT section. These instructions will reference 2056 data relative to the value of __gp, which may not necessarily have 2057 the same address as the start of the PLT section. 2058 2059 gp_offset contains the offset of __gp within the PLT section. */ 2060 value = hh->plt_offset - hppa_info->gp_offset; 2061 2062 insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset); 2063 if (output_bfd->arch_info->mach >= 25) 2064 { 2065 /* Wide mode allows 16 bit offsets. */ 2066 max_offset = 32768; 2067 insn &= ~ 0xfff1; 2068 insn |= re_assemble_16 ((int) value); 2069 } 2070 else 2071 { 2072 max_offset = 8192; 2073 insn &= ~ 0x3ff1; 2074 insn |= re_assemble_14 ((int) value); 2075 } 2076 2077 if ((value & 7) || value + max_offset >= 2*max_offset - 8) 2078 { 2079 _bfd_error_handler 2080 /* xgettext:c-format */ 2081 (_("stub entry for %s cannot load .plt, dp offset = %" PRId64), 2082 hh->eh.root.root.string, (int64_t) value); 2083 return FALSE; 2084 } 2085 2086 bfd_put_32 (stub->owner, (bfd_vma) insn, 2087 stub->contents + hh->stub_offset); 2088 2089 /* Fix up the second ldd instruction. */ 2090 value += 8; 2091 insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset + 8); 2092 if (output_bfd->arch_info->mach >= 25) 2093 { 2094 insn &= ~ 0xfff1; 2095 insn |= re_assemble_16 ((int) value); 2096 } 2097 else 2098 { 2099 insn &= ~ 0x3ff1; 2100 insn |= re_assemble_14 ((int) value); 2101 } 2102 bfd_put_32 (stub->owner, (bfd_vma) insn, 2103 stub->contents + hh->stub_offset + 8); 2104 } 2105 2106 return TRUE; 2107 } 2108 2109 /* The .opd section contains FPTRs for each function this file 2110 exports. Initialize the FPTR entries. */ 2111 2112 static bfd_boolean 2113 elf64_hppa_finalize_opd (struct elf_link_hash_entry *eh, void *data) 2114 { 2115 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 2116 struct bfd_link_info *info = (struct bfd_link_info *)data; 2117 struct elf64_hppa_link_hash_table *hppa_info; 2118 asection *sopd; 2119 asection *sopdrel; 2120 2121 hppa_info = hppa_link_hash_table (info); 2122 if (hppa_info == NULL) 2123 return FALSE; 2124 2125 sopd = hppa_info->opd_sec; 2126 sopdrel = hppa_info->opd_rel_sec; 2127 2128 if (hh->want_opd) 2129 { 2130 bfd_vma value; 2131 2132 /* The first two words of an .opd entry are zero. 2133 2134 We are modifying the contents of the OPD section in memory, so we 2135 do not need to include its output offset in this computation. */ 2136 memset (sopd->contents + hh->opd_offset, 0, 16); 2137 2138 value = (eh->root.u.def.value 2139 + eh->root.u.def.section->output_section->vma 2140 + eh->root.u.def.section->output_offset); 2141 2142 /* The next word is the address of the function. */ 2143 bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 16); 2144 2145 /* The last word is our local __gp value. */ 2146 value = _bfd_get_gp_value (sopd->output_section->owner); 2147 bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 24); 2148 } 2149 2150 /* If we are generating a shared library, we must generate EPLT relocations 2151 for each entry in the .opd, even for static functions (they may have 2152 had their address taken). */ 2153 if (bfd_link_pic (info) && hh->want_opd) 2154 { 2155 Elf_Internal_Rela rel; 2156 bfd_byte *loc; 2157 int dynindx; 2158 2159 /* We may need to do a relocation against a local symbol, in 2160 which case we have to look up it's dynamic symbol index off 2161 the local symbol hash table. */ 2162 if (eh->dynindx != -1) 2163 dynindx = eh->dynindx; 2164 else 2165 dynindx 2166 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner, 2167 hh->sym_indx); 2168 2169 /* The offset of this relocation is the absolute address of the 2170 .opd entry for this symbol. */ 2171 rel.r_offset = (hh->opd_offset + sopd->output_offset 2172 + sopd->output_section->vma); 2173 2174 /* If H is non-null, then we have an external symbol. 2175 2176 It is imperative that we use a different dynamic symbol for the 2177 EPLT relocation if the symbol has global scope. 2178 2179 In the dynamic symbol table, the function symbol will have a value 2180 which is address of the function's .opd entry. 2181 2182 Thus, we can not use that dynamic symbol for the EPLT relocation 2183 (if we did, the data in the .opd would reference itself rather 2184 than the actual address of the function). Instead we have to use 2185 a new dynamic symbol which has the same value as the original global 2186 function symbol. 2187 2188 We prefix the original symbol with a "." and use the new symbol in 2189 the EPLT relocation. This new symbol has already been recorded in 2190 the symbol table, we just have to look it up and use it. 2191 2192 We do not have such problems with static functions because we do 2193 not make their addresses in the dynamic symbol table point to 2194 the .opd entry. Ultimately this should be safe since a static 2195 function can not be directly referenced outside of its shared 2196 library. 2197 2198 We do have to play similar games for FPTR relocations in shared 2199 libraries, including those for static symbols. See the FPTR 2200 handling in elf64_hppa_finalize_dynreloc. */ 2201 if (eh) 2202 { 2203 char *new_name; 2204 struct elf_link_hash_entry *nh; 2205 2206 new_name = concat (".", eh->root.root.string, NULL); 2207 2208 nh = elf_link_hash_lookup (elf_hash_table (info), 2209 new_name, TRUE, TRUE, FALSE); 2210 2211 /* All we really want from the new symbol is its dynamic 2212 symbol index. */ 2213 if (nh) 2214 dynindx = nh->dynindx; 2215 free (new_name); 2216 } 2217 2218 rel.r_addend = 0; 2219 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT); 2220 2221 loc = sopdrel->contents; 2222 loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela); 2223 bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc); 2224 } 2225 return TRUE; 2226 } 2227 2228 /* The .dlt section contains addresses for items referenced through the 2229 dlt. Note that we can have a DLTIND relocation for a local symbol, thus 2230 we can not depend on finish_dynamic_symbol to initialize the .dlt. */ 2231 2232 static bfd_boolean 2233 elf64_hppa_finalize_dlt (struct elf_link_hash_entry *eh, void *data) 2234 { 2235 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 2236 struct bfd_link_info *info = (struct bfd_link_info *)data; 2237 struct elf64_hppa_link_hash_table *hppa_info; 2238 asection *sdlt, *sdltrel; 2239 2240 hppa_info = hppa_link_hash_table (info); 2241 if (hppa_info == NULL) 2242 return FALSE; 2243 2244 sdlt = hppa_info->dlt_sec; 2245 sdltrel = hppa_info->dlt_rel_sec; 2246 2247 /* H/DYN_H may refer to a local variable and we know it's 2248 address, so there is no need to create a relocation. Just install 2249 the proper value into the DLT, note this shortcut can not be 2250 skipped when building a shared library. */ 2251 if (! bfd_link_pic (info) && hh && hh->want_dlt) 2252 { 2253 bfd_vma value; 2254 2255 /* If we had an LTOFF_FPTR style relocation we want the DLT entry 2256 to point to the FPTR entry in the .opd section. 2257 2258 We include the OPD's output offset in this computation as 2259 we are referring to an absolute address in the resulting 2260 object file. */ 2261 if (hh->want_opd) 2262 { 2263 value = (hh->opd_offset 2264 + hppa_info->opd_sec->output_offset 2265 + hppa_info->opd_sec->output_section->vma); 2266 } 2267 else if ((eh->root.type == bfd_link_hash_defined 2268 || eh->root.type == bfd_link_hash_defweak) 2269 && eh->root.u.def.section) 2270 { 2271 value = eh->root.u.def.value + eh->root.u.def.section->output_offset; 2272 if (eh->root.u.def.section->output_section) 2273 value += eh->root.u.def.section->output_section->vma; 2274 else 2275 value += eh->root.u.def.section->vma; 2276 } 2277 else 2278 /* We have an undefined function reference. */ 2279 value = 0; 2280 2281 /* We do not need to include the output offset of the DLT section 2282 here because we are modifying the in-memory contents. */ 2283 bfd_put_64 (sdlt->owner, value, sdlt->contents + hh->dlt_offset); 2284 } 2285 2286 /* Create a relocation for the DLT entry associated with this symbol. 2287 When building a shared library the symbol does not have to be dynamic. */ 2288 if (hh->want_dlt 2289 && (elf64_hppa_dynamic_symbol_p (eh, info) || bfd_link_pic (info))) 2290 { 2291 Elf_Internal_Rela rel; 2292 bfd_byte *loc; 2293 int dynindx; 2294 2295 /* We may need to do a relocation against a local symbol, in 2296 which case we have to look up it's dynamic symbol index off 2297 the local symbol hash table. */ 2298 if (eh && eh->dynindx != -1) 2299 dynindx = eh->dynindx; 2300 else 2301 dynindx 2302 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner, 2303 hh->sym_indx); 2304 2305 /* Create a dynamic relocation for this entry. Do include the output 2306 offset of the DLT entry since we need an absolute address in the 2307 resulting object file. */ 2308 rel.r_offset = (hh->dlt_offset + sdlt->output_offset 2309 + sdlt->output_section->vma); 2310 if (eh && eh->type == STT_FUNC) 2311 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64); 2312 else 2313 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64); 2314 rel.r_addend = 0; 2315 2316 loc = sdltrel->contents; 2317 loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela); 2318 bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc); 2319 } 2320 return TRUE; 2321 } 2322 2323 /* Finalize the dynamic relocations. Specifically the FPTR relocations 2324 for dynamic functions used to initialize static data. */ 2325 2326 static bfd_boolean 2327 elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry *eh, 2328 void *data) 2329 { 2330 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 2331 struct bfd_link_info *info = (struct bfd_link_info *)data; 2332 struct elf64_hppa_link_hash_table *hppa_info; 2333 int dynamic_symbol; 2334 2335 dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, info); 2336 2337 if (!dynamic_symbol && !bfd_link_pic (info)) 2338 return TRUE; 2339 2340 if (hh->reloc_entries) 2341 { 2342 struct elf64_hppa_dyn_reloc_entry *rent; 2343 int dynindx; 2344 2345 hppa_info = hppa_link_hash_table (info); 2346 if (hppa_info == NULL) 2347 return FALSE; 2348 2349 /* We may need to do a relocation against a local symbol, in 2350 which case we have to look up it's dynamic symbol index off 2351 the local symbol hash table. */ 2352 if (eh->dynindx != -1) 2353 dynindx = eh->dynindx; 2354 else 2355 dynindx 2356 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner, 2357 hh->sym_indx); 2358 2359 for (rent = hh->reloc_entries; rent; rent = rent->next) 2360 { 2361 Elf_Internal_Rela rel; 2362 bfd_byte *loc; 2363 2364 /* Allocate one iff we are building a shared library, the relocation 2365 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */ 2366 if (!bfd_link_pic (info) 2367 && rent->type == R_PARISC_FPTR64 && hh->want_opd) 2368 continue; 2369 2370 /* Create a dynamic relocation for this entry. 2371 2372 We need the output offset for the reloc's section because 2373 we are creating an absolute address in the resulting object 2374 file. */ 2375 rel.r_offset = (rent->offset + rent->sec->output_offset 2376 + rent->sec->output_section->vma); 2377 2378 /* An FPTR64 relocation implies that we took the address of 2379 a function and that the function has an entry in the .opd 2380 section. We want the FPTR64 relocation to reference the 2381 entry in .opd. 2382 2383 We could munge the symbol value in the dynamic symbol table 2384 (in fact we already do for functions with global scope) to point 2385 to the .opd entry. Then we could use that dynamic symbol in 2386 this relocation. 2387 2388 Or we could do something sensible, not munge the symbol's 2389 address and instead just use a different symbol to reference 2390 the .opd entry. At least that seems sensible until you 2391 realize there's no local dynamic symbols we can use for that 2392 purpose. Thus the hair in the check_relocs routine. 2393 2394 We use a section symbol recorded by check_relocs as the 2395 base symbol for the relocation. The addend is the difference 2396 between the section symbol and the address of the .opd entry. */ 2397 if (bfd_link_pic (info) 2398 && rent->type == R_PARISC_FPTR64 && hh->want_opd) 2399 { 2400 bfd_vma value, value2; 2401 2402 /* First compute the address of the opd entry for this symbol. */ 2403 value = (hh->opd_offset 2404 + hppa_info->opd_sec->output_section->vma 2405 + hppa_info->opd_sec->output_offset); 2406 2407 /* Compute the value of the start of the section with 2408 the relocation. */ 2409 value2 = (rent->sec->output_section->vma 2410 + rent->sec->output_offset); 2411 2412 /* Compute the difference between the start of the section 2413 with the relocation and the opd entry. */ 2414 value -= value2; 2415 2416 /* The result becomes the addend of the relocation. */ 2417 rel.r_addend = value; 2418 2419 /* The section symbol becomes the symbol for the dynamic 2420 relocation. */ 2421 dynindx 2422 = _bfd_elf_link_lookup_local_dynindx (info, 2423 rent->sec->owner, 2424 rent->sec_symndx); 2425 } 2426 else 2427 rel.r_addend = rent->addend; 2428 2429 rel.r_info = ELF64_R_INFO (dynindx, rent->type); 2430 2431 loc = hppa_info->other_rel_sec->contents; 2432 loc += (hppa_info->other_rel_sec->reloc_count++ 2433 * sizeof (Elf64_External_Rela)); 2434 bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner, 2435 &rel, loc); 2436 } 2437 } 2438 2439 return TRUE; 2440 } 2441 2442 /* Used to decide how to sort relocs in an optimal manner for the 2443 dynamic linker, before writing them out. */ 2444 2445 static enum elf_reloc_type_class 2446 elf64_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2447 const asection *rel_sec ATTRIBUTE_UNUSED, 2448 const Elf_Internal_Rela *rela) 2449 { 2450 if (ELF64_R_SYM (rela->r_info) == STN_UNDEF) 2451 return reloc_class_relative; 2452 2453 switch ((int) ELF64_R_TYPE (rela->r_info)) 2454 { 2455 case R_PARISC_IPLT: 2456 return reloc_class_plt; 2457 case R_PARISC_COPY: 2458 return reloc_class_copy; 2459 default: 2460 return reloc_class_normal; 2461 } 2462 } 2463 2464 /* Finish up the dynamic sections. */ 2465 2466 static bfd_boolean 2467 elf64_hppa_finish_dynamic_sections (bfd *output_bfd, 2468 struct bfd_link_info *info) 2469 { 2470 bfd *dynobj; 2471 asection *sdyn; 2472 struct elf64_hppa_link_hash_table *hppa_info; 2473 2474 hppa_info = hppa_link_hash_table (info); 2475 if (hppa_info == NULL) 2476 return FALSE; 2477 2478 /* Finalize the contents of the .opd section. */ 2479 elf_link_hash_traverse (elf_hash_table (info), 2480 elf64_hppa_finalize_opd, 2481 info); 2482 2483 elf_link_hash_traverse (elf_hash_table (info), 2484 elf64_hppa_finalize_dynreloc, 2485 info); 2486 2487 /* Finalize the contents of the .dlt section. */ 2488 dynobj = elf_hash_table (info)->dynobj; 2489 /* Finalize the contents of the .dlt section. */ 2490 elf_link_hash_traverse (elf_hash_table (info), 2491 elf64_hppa_finalize_dlt, 2492 info); 2493 2494 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 2495 2496 if (elf_hash_table (info)->dynamic_sections_created) 2497 { 2498 Elf64_External_Dyn *dyncon, *dynconend; 2499 2500 BFD_ASSERT (sdyn != NULL); 2501 2502 dyncon = (Elf64_External_Dyn *) sdyn->contents; 2503 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 2504 for (; dyncon < dynconend; dyncon++) 2505 { 2506 Elf_Internal_Dyn dyn; 2507 asection *s; 2508 2509 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 2510 2511 switch (dyn.d_tag) 2512 { 2513 default: 2514 break; 2515 2516 case DT_HP_LOAD_MAP: 2517 /* Compute the absolute address of 16byte scratchpad area 2518 for the dynamic linker. 2519 2520 By convention the linker script will allocate the scratchpad 2521 area at the start of the .data section. So all we have to 2522 to is find the start of the .data section. */ 2523 s = bfd_get_section_by_name (output_bfd, ".data"); 2524 if (!s) 2525 return FALSE; 2526 dyn.d_un.d_ptr = s->vma; 2527 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2528 break; 2529 2530 case DT_PLTGOT: 2531 /* HP's use PLTGOT to set the GOT register. */ 2532 dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd); 2533 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2534 break; 2535 2536 case DT_JMPREL: 2537 s = hppa_info->plt_rel_sec; 2538 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2539 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2540 break; 2541 2542 case DT_PLTRELSZ: 2543 s = hppa_info->plt_rel_sec; 2544 dyn.d_un.d_val = s->size; 2545 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2546 break; 2547 2548 case DT_RELA: 2549 s = hppa_info->other_rel_sec; 2550 if (! s || ! s->size) 2551 s = hppa_info->dlt_rel_sec; 2552 if (! s || ! s->size) 2553 s = hppa_info->opd_rel_sec; 2554 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2555 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2556 break; 2557 2558 case DT_RELASZ: 2559 s = hppa_info->other_rel_sec; 2560 dyn.d_un.d_val = s->size; 2561 s = hppa_info->dlt_rel_sec; 2562 dyn.d_un.d_val += s->size; 2563 s = hppa_info->opd_rel_sec; 2564 dyn.d_un.d_val += s->size; 2565 /* There is some question about whether or not the size of 2566 the PLT relocs should be included here. HP's tools do 2567 it, so we'll emulate them. */ 2568 s = hppa_info->plt_rel_sec; 2569 dyn.d_un.d_val += s->size; 2570 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2571 break; 2572 2573 } 2574 } 2575 } 2576 2577 return TRUE; 2578 } 2579 2580 /* Support for core dump NOTE sections. */ 2581 2582 static bfd_boolean 2583 elf64_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2584 { 2585 int offset; 2586 size_t size; 2587 2588 switch (note->descsz) 2589 { 2590 default: 2591 return FALSE; 2592 2593 case 760: /* Linux/hppa */ 2594 /* pr_cursig */ 2595 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 2596 2597 /* pr_pid */ 2598 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32); 2599 2600 /* pr_reg */ 2601 offset = 112; 2602 size = 640; 2603 2604 break; 2605 } 2606 2607 /* Make a ".reg/999" section. */ 2608 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2609 size, note->descpos + offset); 2610 } 2611 2612 static bfd_boolean 2613 elf64_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 2614 { 2615 char * command; 2616 int n; 2617 2618 switch (note->descsz) 2619 { 2620 default: 2621 return FALSE; 2622 2623 case 136: /* Linux/hppa elf_prpsinfo. */ 2624 elf_tdata (abfd)->core->program 2625 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 2626 elf_tdata (abfd)->core->command 2627 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 2628 } 2629 2630 /* Note that for some reason, a spurious space is tacked 2631 onto the end of the args in some (at least one anyway) 2632 implementations, so strip it off if it exists. */ 2633 command = elf_tdata (abfd)->core->command; 2634 n = strlen (command); 2635 2636 if (0 < n && command[n - 1] == ' ') 2637 command[n - 1] = '\0'; 2638 2639 return TRUE; 2640 } 2641 2642 /* Return the number of additional phdrs we will need. 2643 2644 The generic ELF code only creates PT_PHDRs for executables. The HP 2645 dynamic linker requires PT_PHDRs for dynamic libraries too. 2646 2647 This routine indicates that the backend needs one additional program 2648 header for that case. 2649 2650 Note we do not have access to the link info structure here, so we have 2651 to guess whether or not we are building a shared library based on the 2652 existence of a .interp section. */ 2653 2654 static int 2655 elf64_hppa_additional_program_headers (bfd *abfd, 2656 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2657 { 2658 asection *s; 2659 2660 /* If we are creating a shared library, then we have to create a 2661 PT_PHDR segment. HP's dynamic linker chokes without it. */ 2662 s = bfd_get_section_by_name (abfd, ".interp"); 2663 if (! s) 2664 return 1; 2665 return 0; 2666 } 2667 2668 static bfd_boolean 2669 elf64_hppa_allow_non_load_phdr (bfd *abfd ATTRIBUTE_UNUSED, 2670 const Elf_Internal_Phdr *phdr ATTRIBUTE_UNUSED, 2671 unsigned int count ATTRIBUTE_UNUSED) 2672 { 2673 return TRUE; 2674 } 2675 2676 /* Allocate and initialize any program headers required by this 2677 specific backend. 2678 2679 The generic ELF code only creates PT_PHDRs for executables. The HP 2680 dynamic linker requires PT_PHDRs for dynamic libraries too. 2681 2682 This allocates the PT_PHDR and initializes it in a manner suitable 2683 for the HP linker. 2684 2685 Note we do not have access to the link info structure here, so we have 2686 to guess whether or not we are building a shared library based on the 2687 existence of a .interp section. */ 2688 2689 static bfd_boolean 2690 elf64_hppa_modify_segment_map (bfd *abfd, struct bfd_link_info *info) 2691 { 2692 struct elf_segment_map *m; 2693 2694 m = elf_seg_map (abfd); 2695 if (info != NULL && !info->user_phdrs && m != NULL && m->p_type != PT_PHDR) 2696 { 2697 m = ((struct elf_segment_map *) 2698 bfd_zalloc (abfd, (bfd_size_type) sizeof *m)); 2699 if (m == NULL) 2700 return FALSE; 2701 2702 m->p_type = PT_PHDR; 2703 m->p_flags = PF_R | PF_X; 2704 m->p_flags_valid = 1; 2705 m->p_paddr_valid = 1; 2706 m->includes_phdrs = 1; 2707 2708 m->next = elf_seg_map (abfd); 2709 elf_seg_map (abfd) = m; 2710 } 2711 2712 for (m = elf_seg_map (abfd) ; m != NULL; m = m->next) 2713 if (m->p_type == PT_LOAD) 2714 { 2715 unsigned int i; 2716 2717 for (i = 0; i < m->count; i++) 2718 { 2719 /* The code "hint" is not really a hint. It is a requirement 2720 for certain versions of the HP dynamic linker. Worse yet, 2721 it must be set even if the shared library does not have 2722 any code in its "text" segment (thus the check for .hash 2723 to catch this situation). */ 2724 if (m->sections[i]->flags & SEC_CODE 2725 || (strcmp (m->sections[i]->name, ".hash") == 0)) 2726 m->p_flags |= (PF_X | PF_HP_CODE); 2727 } 2728 } 2729 2730 return TRUE; 2731 } 2732 2733 /* Called when writing out an object file to decide the type of a 2734 symbol. */ 2735 static int 2736 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, 2737 int type) 2738 { 2739 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI) 2740 return STT_PARISC_MILLI; 2741 else 2742 return type; 2743 } 2744 2745 /* Support HP specific sections for core files. */ 2746 2747 static bfd_boolean 2748 elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int sec_index, 2749 const char *typename) 2750 { 2751 if (hdr->p_type == PT_HP_CORE_KERNEL) 2752 { 2753 asection *sect; 2754 2755 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename)) 2756 return FALSE; 2757 2758 sect = bfd_make_section_anyway (abfd, ".kernel"); 2759 if (sect == NULL) 2760 return FALSE; 2761 sect->size = hdr->p_filesz; 2762 sect->filepos = hdr->p_offset; 2763 sect->flags = SEC_HAS_CONTENTS | SEC_READONLY; 2764 return TRUE; 2765 } 2766 2767 if (hdr->p_type == PT_HP_CORE_PROC) 2768 { 2769 int sig; 2770 2771 if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0) 2772 return FALSE; 2773 if (bfd_bread (&sig, 4, abfd) != 4) 2774 return FALSE; 2775 2776 elf_tdata (abfd)->core->signal = sig; 2777 2778 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename)) 2779 return FALSE; 2780 2781 /* GDB uses the ".reg" section to read register contents. */ 2782 return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz, 2783 hdr->p_offset); 2784 } 2785 2786 if (hdr->p_type == PT_HP_CORE_LOADABLE 2787 || hdr->p_type == PT_HP_CORE_STACK 2788 || hdr->p_type == PT_HP_CORE_MMF) 2789 hdr->p_type = PT_LOAD; 2790 2791 return _bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename); 2792 } 2793 2794 /* Hook called by the linker routine which adds symbols from an object 2795 file. HP's libraries define symbols with HP specific section 2796 indices, which we have to handle. */ 2797 2798 static bfd_boolean 2799 elf_hppa_add_symbol_hook (bfd *abfd, 2800 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2801 Elf_Internal_Sym *sym, 2802 const char **namep ATTRIBUTE_UNUSED, 2803 flagword *flagsp ATTRIBUTE_UNUSED, 2804 asection **secp, 2805 bfd_vma *valp) 2806 { 2807 unsigned int sec_index = sym->st_shndx; 2808 2809 switch (sec_index) 2810 { 2811 case SHN_PARISC_ANSI_COMMON: 2812 *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common"); 2813 (*secp)->flags |= SEC_IS_COMMON; 2814 *valp = sym->st_size; 2815 break; 2816 2817 case SHN_PARISC_HUGE_COMMON: 2818 *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common"); 2819 (*secp)->flags |= SEC_IS_COMMON; 2820 *valp = sym->st_size; 2821 break; 2822 } 2823 2824 return TRUE; 2825 } 2826 2827 static bfd_boolean 2828 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h, 2829 void *data) 2830 { 2831 struct bfd_link_info *info = data; 2832 2833 /* If we are not creating a shared library, and this symbol is 2834 referenced by a shared library but is not defined anywhere, then 2835 the generic code will warn that it is undefined. 2836 2837 This behavior is undesirable on HPs since the standard shared 2838 libraries contain references to undefined symbols. 2839 2840 So we twiddle the flags associated with such symbols so that they 2841 will not trigger the warning. ?!? FIXME. This is horribly fragile. 2842 2843 Ultimately we should have better controls over the generic ELF BFD 2844 linker code. */ 2845 if (! bfd_link_relocatable (info) 2846 && info->unresolved_syms_in_shared_libs != RM_IGNORE 2847 && h->root.type == bfd_link_hash_undefined 2848 && h->ref_dynamic 2849 && !h->ref_regular) 2850 { 2851 h->ref_dynamic = 0; 2852 h->pointer_equality_needed = 1; 2853 } 2854 2855 return TRUE; 2856 } 2857 2858 static bfd_boolean 2859 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h, 2860 void *data) 2861 { 2862 struct bfd_link_info *info = data; 2863 2864 /* If we are not creating a shared library, and this symbol is 2865 referenced by a shared library but is not defined anywhere, then 2866 the generic code will warn that it is undefined. 2867 2868 This behavior is undesirable on HPs since the standard shared 2869 libraries contain references to undefined symbols. 2870 2871 So we twiddle the flags associated with such symbols so that they 2872 will not trigger the warning. ?!? FIXME. This is horribly fragile. 2873 2874 Ultimately we should have better controls over the generic ELF BFD 2875 linker code. */ 2876 if (! bfd_link_relocatable (info) 2877 && info->unresolved_syms_in_shared_libs != RM_IGNORE 2878 && h->root.type == bfd_link_hash_undefined 2879 && !h->ref_dynamic 2880 && !h->ref_regular 2881 && h->pointer_equality_needed) 2882 { 2883 h->ref_dynamic = 1; 2884 h->pointer_equality_needed = 0; 2885 } 2886 2887 return TRUE; 2888 } 2889 2890 static bfd_boolean 2891 elf_hppa_is_dynamic_loader_symbol (const char *name) 2892 { 2893 return (! strcmp (name, "__CPU_REVISION") 2894 || ! strcmp (name, "__CPU_KEYBITS_1") 2895 || ! strcmp (name, "__SYSTEM_ID_D") 2896 || ! strcmp (name, "__FPU_MODEL") 2897 || ! strcmp (name, "__FPU_REVISION") 2898 || ! strcmp (name, "__ARGC") 2899 || ! strcmp (name, "__ARGV") 2900 || ! strcmp (name, "__ENVP") 2901 || ! strcmp (name, "__TLS_SIZE_D") 2902 || ! strcmp (name, "__LOAD_INFO") 2903 || ! strcmp (name, "__systab")); 2904 } 2905 2906 /* Record the lowest address for the data and text segments. */ 2907 static void 2908 elf_hppa_record_segment_addrs (bfd *abfd, 2909 asection *section, 2910 void *data) 2911 { 2912 struct elf64_hppa_link_hash_table *hppa_info = data; 2913 2914 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 2915 { 2916 bfd_vma value; 2917 Elf_Internal_Phdr *p; 2918 2919 p = _bfd_elf_find_segment_containing_section (abfd, section->output_section); 2920 BFD_ASSERT (p != NULL); 2921 value = p->p_vaddr; 2922 2923 if (section->flags & SEC_READONLY) 2924 { 2925 if (value < hppa_info->text_segment_base) 2926 hppa_info->text_segment_base = value; 2927 } 2928 else 2929 { 2930 if (value < hppa_info->data_segment_base) 2931 hppa_info->data_segment_base = value; 2932 } 2933 } 2934 } 2935 2936 /* Called after we have seen all the input files/sections, but before 2937 final symbol resolution and section placement has been determined. 2938 2939 We use this hook to (possibly) provide a value for __gp, then we 2940 fall back to the generic ELF final link routine. */ 2941 2942 static bfd_boolean 2943 elf_hppa_final_link (bfd *abfd, struct bfd_link_info *info) 2944 { 2945 struct stat buf; 2946 struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info); 2947 2948 if (hppa_info == NULL) 2949 return FALSE; 2950 2951 if (! bfd_link_relocatable (info)) 2952 { 2953 struct elf_link_hash_entry *gp; 2954 bfd_vma gp_val; 2955 2956 /* The linker script defines a value for __gp iff it was referenced 2957 by one of the objects being linked. First try to find the symbol 2958 in the hash table. If that fails, just compute the value __gp 2959 should have had. */ 2960 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE, 2961 FALSE, FALSE); 2962 2963 if (gp) 2964 { 2965 2966 /* Adjust the value of __gp as we may want to slide it into the 2967 .plt section so that the stubs can access PLT entries without 2968 using an addil sequence. */ 2969 gp->root.u.def.value += hppa_info->gp_offset; 2970 2971 gp_val = (gp->root.u.def.section->output_section->vma 2972 + gp->root.u.def.section->output_offset 2973 + gp->root.u.def.value); 2974 } 2975 else 2976 { 2977 asection *sec; 2978 2979 /* First look for a .plt section. If found, then __gp is the 2980 address of the .plt + gp_offset. 2981 2982 If no .plt is found, then look for .dlt, .opd and .data (in 2983 that order) and set __gp to the base address of whichever 2984 section is found first. */ 2985 2986 sec = hppa_info->plt_sec; 2987 if (sec && ! (sec->flags & SEC_EXCLUDE)) 2988 gp_val = (sec->output_offset 2989 + sec->output_section->vma 2990 + hppa_info->gp_offset); 2991 else 2992 { 2993 sec = hppa_info->dlt_sec; 2994 if (!sec || (sec->flags & SEC_EXCLUDE)) 2995 sec = hppa_info->opd_sec; 2996 if (!sec || (sec->flags & SEC_EXCLUDE)) 2997 sec = bfd_get_section_by_name (abfd, ".data"); 2998 if (!sec || (sec->flags & SEC_EXCLUDE)) 2999 gp_val = 0; 3000 else 3001 gp_val = sec->output_offset + sec->output_section->vma; 3002 } 3003 } 3004 3005 /* Install whatever value we found/computed for __gp. */ 3006 _bfd_set_gp_value (abfd, gp_val); 3007 } 3008 3009 /* We need to know the base of the text and data segments so that we 3010 can perform SEGREL relocations. We will record the base addresses 3011 when we encounter the first SEGREL relocation. */ 3012 hppa_info->text_segment_base = (bfd_vma)-1; 3013 hppa_info->data_segment_base = (bfd_vma)-1; 3014 3015 /* HP's shared libraries have references to symbols that are not 3016 defined anywhere. The generic ELF BFD linker code will complain 3017 about such symbols. 3018 3019 So we detect the losing case and arrange for the flags on the symbol 3020 to indicate that it was never referenced. This keeps the generic 3021 ELF BFD link code happy and appears to not create any secondary 3022 problems. Ultimately we need a way to control the behavior of the 3023 generic ELF BFD link code better. */ 3024 elf_link_hash_traverse (elf_hash_table (info), 3025 elf_hppa_unmark_useless_dynamic_symbols, 3026 info); 3027 3028 /* Invoke the regular ELF backend linker to do all the work. */ 3029 if (!bfd_elf_final_link (abfd, info)) 3030 return FALSE; 3031 3032 elf_link_hash_traverse (elf_hash_table (info), 3033 elf_hppa_remark_useless_dynamic_symbols, 3034 info); 3035 3036 /* If we're producing a final executable, sort the contents of the 3037 unwind section. */ 3038 if (bfd_link_relocatable (info)) 3039 return TRUE; 3040 3041 /* Do not attempt to sort non-regular files. This is here 3042 especially for configure scripts and kernel builds which run 3043 tests with "ld [...] -o /dev/null". */ 3044 if (stat (abfd->filename, &buf) != 0 3045 || !S_ISREG(buf.st_mode)) 3046 return TRUE; 3047 3048 return elf_hppa_sort_unwind (abfd); 3049 } 3050 3051 /* Relocate the given INSN. VALUE should be the actual value we want 3052 to insert into the instruction, ie by this point we should not be 3053 concerned with computing an offset relative to the DLT, PC, etc. 3054 Instead this routine is meant to handle the bit manipulations needed 3055 to insert the relocation into the given instruction. */ 3056 3057 static int 3058 elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type) 3059 { 3060 switch (r_type) 3061 { 3062 /* This is any 22 bit branch. In PA2.0 syntax it corresponds to 3063 the "B" instruction. */ 3064 case R_PARISC_PCREL22F: 3065 case R_PARISC_PCREL22C: 3066 return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value); 3067 3068 /* This is any 12 bit branch. */ 3069 case R_PARISC_PCREL12F: 3070 return (insn & ~0x1ffd) | re_assemble_12 (sym_value); 3071 3072 /* This is any 17 bit branch. In PA2.0 syntax it also corresponds 3073 to the "B" instruction as well as BE. */ 3074 case R_PARISC_PCREL17F: 3075 case R_PARISC_DIR17F: 3076 case R_PARISC_DIR17R: 3077 case R_PARISC_PCREL17C: 3078 case R_PARISC_PCREL17R: 3079 return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value); 3080 3081 /* ADDIL or LDIL instructions. */ 3082 case R_PARISC_DLTREL21L: 3083 case R_PARISC_DLTIND21L: 3084 case R_PARISC_LTOFF_FPTR21L: 3085 case R_PARISC_PCREL21L: 3086 case R_PARISC_LTOFF_TP21L: 3087 case R_PARISC_DPREL21L: 3088 case R_PARISC_PLTOFF21L: 3089 case R_PARISC_DIR21L: 3090 return (insn & ~0x1fffff) | re_assemble_21 (sym_value); 3091 3092 /* LDO and integer loads/stores with 14 bit displacements. */ 3093 case R_PARISC_DLTREL14R: 3094 case R_PARISC_DLTREL14F: 3095 case R_PARISC_DLTIND14R: 3096 case R_PARISC_DLTIND14F: 3097 case R_PARISC_LTOFF_FPTR14R: 3098 case R_PARISC_PCREL14R: 3099 case R_PARISC_PCREL14F: 3100 case R_PARISC_LTOFF_TP14R: 3101 case R_PARISC_LTOFF_TP14F: 3102 case R_PARISC_DPREL14R: 3103 case R_PARISC_DPREL14F: 3104 case R_PARISC_PLTOFF14R: 3105 case R_PARISC_PLTOFF14F: 3106 case R_PARISC_DIR14R: 3107 case R_PARISC_DIR14F: 3108 return (insn & ~0x3fff) | low_sign_unext (sym_value, 14); 3109 3110 /* PA2.0W LDO and integer loads/stores with 16 bit displacements. */ 3111 case R_PARISC_LTOFF_FPTR16F: 3112 case R_PARISC_PCREL16F: 3113 case R_PARISC_LTOFF_TP16F: 3114 case R_PARISC_GPREL16F: 3115 case R_PARISC_PLTOFF16F: 3116 case R_PARISC_DIR16F: 3117 case R_PARISC_LTOFF16F: 3118 return (insn & ~0xffff) | re_assemble_16 (sym_value); 3119 3120 /* Doubleword loads and stores with a 14 bit displacement. */ 3121 case R_PARISC_DLTREL14DR: 3122 case R_PARISC_DLTIND14DR: 3123 case R_PARISC_LTOFF_FPTR14DR: 3124 case R_PARISC_LTOFF_FPTR16DF: 3125 case R_PARISC_PCREL14DR: 3126 case R_PARISC_PCREL16DF: 3127 case R_PARISC_LTOFF_TP14DR: 3128 case R_PARISC_LTOFF_TP16DF: 3129 case R_PARISC_DPREL14DR: 3130 case R_PARISC_GPREL16DF: 3131 case R_PARISC_PLTOFF14DR: 3132 case R_PARISC_PLTOFF16DF: 3133 case R_PARISC_DIR14DR: 3134 case R_PARISC_DIR16DF: 3135 case R_PARISC_LTOFF16DF: 3136 return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13) 3137 | ((sym_value & 0x1ff8) << 1)); 3138 3139 /* Floating point single word load/store instructions. */ 3140 case R_PARISC_DLTREL14WR: 3141 case R_PARISC_DLTIND14WR: 3142 case R_PARISC_LTOFF_FPTR14WR: 3143 case R_PARISC_LTOFF_FPTR16WF: 3144 case R_PARISC_PCREL14WR: 3145 case R_PARISC_PCREL16WF: 3146 case R_PARISC_LTOFF_TP14WR: 3147 case R_PARISC_LTOFF_TP16WF: 3148 case R_PARISC_DPREL14WR: 3149 case R_PARISC_GPREL16WF: 3150 case R_PARISC_PLTOFF14WR: 3151 case R_PARISC_PLTOFF16WF: 3152 case R_PARISC_DIR16WF: 3153 case R_PARISC_DIR14WR: 3154 case R_PARISC_LTOFF16WF: 3155 return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13) 3156 | ((sym_value & 0x1ffc) << 1)); 3157 3158 default: 3159 return insn; 3160 } 3161 } 3162 3163 /* Compute the value for a relocation (REL) during a final link stage, 3164 then insert the value into the proper location in CONTENTS. 3165 3166 VALUE is a tentative value for the relocation and may be overridden 3167 and modified here based on the specific relocation to be performed. 3168 3169 For example we do conversions for PC-relative branches in this routine 3170 or redirection of calls to external routines to stubs. 3171 3172 The work of actually applying the relocation is left to a helper 3173 routine in an attempt to reduce the complexity and size of this 3174 function. */ 3175 3176 static bfd_reloc_status_type 3177 elf_hppa_final_link_relocate (Elf_Internal_Rela *rel, 3178 bfd *input_bfd, 3179 bfd *output_bfd, 3180 asection *input_section, 3181 bfd_byte *contents, 3182 bfd_vma value, 3183 struct bfd_link_info *info, 3184 asection *sym_sec, 3185 struct elf_link_hash_entry *eh) 3186 { 3187 struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info); 3188 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh); 3189 bfd_vma *local_offsets; 3190 Elf_Internal_Shdr *symtab_hdr; 3191 int insn; 3192 bfd_vma max_branch_offset = 0; 3193 bfd_vma offset = rel->r_offset; 3194 bfd_signed_vma addend = rel->r_addend; 3195 reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info); 3196 unsigned int r_symndx = ELF_R_SYM (rel->r_info); 3197 unsigned int r_type = howto->type; 3198 bfd_byte *hit_data = contents + offset; 3199 3200 if (hppa_info == NULL) 3201 return bfd_reloc_notsupported; 3202 3203 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3204 local_offsets = elf_local_got_offsets (input_bfd); 3205 insn = bfd_get_32 (input_bfd, hit_data); 3206 3207 switch (r_type) 3208 { 3209 case R_PARISC_NONE: 3210 break; 3211 3212 /* Basic function call support. 3213 3214 Note for a call to a function defined in another dynamic library 3215 we want to redirect the call to a stub. */ 3216 3217 /* PC relative relocs without an implicit offset. */ 3218 case R_PARISC_PCREL21L: 3219 case R_PARISC_PCREL14R: 3220 case R_PARISC_PCREL14F: 3221 case R_PARISC_PCREL14WR: 3222 case R_PARISC_PCREL14DR: 3223 case R_PARISC_PCREL16F: 3224 case R_PARISC_PCREL16WF: 3225 case R_PARISC_PCREL16DF: 3226 { 3227 /* If this is a call to a function defined in another dynamic 3228 library, then redirect the call to the local stub for this 3229 function. */ 3230 if (sym_sec == NULL || sym_sec->output_section == NULL) 3231 value = (hh->stub_offset + hppa_info->stub_sec->output_offset 3232 + hppa_info->stub_sec->output_section->vma); 3233 3234 /* Turn VALUE into a proper PC relative address. */ 3235 value -= (offset + input_section->output_offset 3236 + input_section->output_section->vma); 3237 3238 /* Adjust for any field selectors. */ 3239 if (r_type == R_PARISC_PCREL21L) 3240 value = hppa_field_adjust (value, -8 + addend, e_lsel); 3241 else if (r_type == R_PARISC_PCREL14F 3242 || r_type == R_PARISC_PCREL16F 3243 || r_type == R_PARISC_PCREL16WF 3244 || r_type == R_PARISC_PCREL16DF) 3245 value = hppa_field_adjust (value, -8 + addend, e_fsel); 3246 else 3247 value = hppa_field_adjust (value, -8 + addend, e_rsel); 3248 3249 /* Apply the relocation to the given instruction. */ 3250 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3251 break; 3252 } 3253 3254 case R_PARISC_PCREL12F: 3255 case R_PARISC_PCREL22F: 3256 case R_PARISC_PCREL17F: 3257 case R_PARISC_PCREL22C: 3258 case R_PARISC_PCREL17C: 3259 case R_PARISC_PCREL17R: 3260 { 3261 /* If this is a call to a function defined in another dynamic 3262 library, then redirect the call to the local stub for this 3263 function. */ 3264 if (sym_sec == NULL || sym_sec->output_section == NULL) 3265 value = (hh->stub_offset + hppa_info->stub_sec->output_offset 3266 + hppa_info->stub_sec->output_section->vma); 3267 3268 /* Turn VALUE into a proper PC relative address. */ 3269 value -= (offset + input_section->output_offset 3270 + input_section->output_section->vma); 3271 addend -= 8; 3272 3273 if (r_type == (unsigned int) R_PARISC_PCREL22F) 3274 max_branch_offset = (1 << (22-1)) << 2; 3275 else if (r_type == (unsigned int) R_PARISC_PCREL17F) 3276 max_branch_offset = (1 << (17-1)) << 2; 3277 else if (r_type == (unsigned int) R_PARISC_PCREL12F) 3278 max_branch_offset = (1 << (12-1)) << 2; 3279 3280 /* Make sure we can reach the branch target. */ 3281 if (max_branch_offset != 0 3282 && value + addend + max_branch_offset >= 2*max_branch_offset) 3283 { 3284 _bfd_error_handler 3285 /* xgettext:c-format */ 3286 (_("%pB(%pA+%#" PRIx64 "): cannot reach %s"), 3287 input_bfd, 3288 input_section, 3289 (uint64_t) offset, 3290 eh ? eh->root.root.string : "unknown"); 3291 bfd_set_error (bfd_error_bad_value); 3292 return bfd_reloc_overflow; 3293 } 3294 3295 /* Adjust for any field selectors. */ 3296 if (r_type == R_PARISC_PCREL17R) 3297 value = hppa_field_adjust (value, addend, e_rsel); 3298 else 3299 value = hppa_field_adjust (value, addend, e_fsel); 3300 3301 /* All branches are implicitly shifted by 2 places. */ 3302 value >>= 2; 3303 3304 /* Apply the relocation to the given instruction. */ 3305 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3306 break; 3307 } 3308 3309 /* Indirect references to data through the DLT. */ 3310 case R_PARISC_DLTIND14R: 3311 case R_PARISC_DLTIND14F: 3312 case R_PARISC_DLTIND14DR: 3313 case R_PARISC_DLTIND14WR: 3314 case R_PARISC_DLTIND21L: 3315 case R_PARISC_LTOFF_FPTR14R: 3316 case R_PARISC_LTOFF_FPTR14DR: 3317 case R_PARISC_LTOFF_FPTR14WR: 3318 case R_PARISC_LTOFF_FPTR21L: 3319 case R_PARISC_LTOFF_FPTR16F: 3320 case R_PARISC_LTOFF_FPTR16WF: 3321 case R_PARISC_LTOFF_FPTR16DF: 3322 case R_PARISC_LTOFF_TP21L: 3323 case R_PARISC_LTOFF_TP14R: 3324 case R_PARISC_LTOFF_TP14F: 3325 case R_PARISC_LTOFF_TP14WR: 3326 case R_PARISC_LTOFF_TP14DR: 3327 case R_PARISC_LTOFF_TP16F: 3328 case R_PARISC_LTOFF_TP16WF: 3329 case R_PARISC_LTOFF_TP16DF: 3330 case R_PARISC_LTOFF16F: 3331 case R_PARISC_LTOFF16WF: 3332 case R_PARISC_LTOFF16DF: 3333 { 3334 bfd_vma off; 3335 3336 /* If this relocation was against a local symbol, then we still 3337 have not set up the DLT entry (it's not convenient to do so 3338 in the "finalize_dlt" routine because it is difficult to get 3339 to the local symbol's value). 3340 3341 So, if this is a local symbol (h == NULL), then we need to 3342 fill in its DLT entry. 3343 3344 Similarly we may still need to set up an entry in .opd for 3345 a local function which had its address taken. */ 3346 if (hh == NULL) 3347 { 3348 bfd_vma *local_opd_offsets, *local_dlt_offsets; 3349 3350 if (local_offsets == NULL) 3351 abort (); 3352 3353 /* Now do .opd creation if needed. */ 3354 if (r_type == R_PARISC_LTOFF_FPTR14R 3355 || r_type == R_PARISC_LTOFF_FPTR14DR 3356 || r_type == R_PARISC_LTOFF_FPTR14WR 3357 || r_type == R_PARISC_LTOFF_FPTR21L 3358 || r_type == R_PARISC_LTOFF_FPTR16F 3359 || r_type == R_PARISC_LTOFF_FPTR16WF 3360 || r_type == R_PARISC_LTOFF_FPTR16DF) 3361 { 3362 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info; 3363 off = local_opd_offsets[r_symndx]; 3364 3365 /* The last bit records whether we've already initialised 3366 this local .opd entry. */ 3367 if ((off & 1) != 0) 3368 { 3369 BFD_ASSERT (off != (bfd_vma) -1); 3370 off &= ~1; 3371 } 3372 else 3373 { 3374 local_opd_offsets[r_symndx] |= 1; 3375 3376 /* The first two words of an .opd entry are zero. */ 3377 memset (hppa_info->opd_sec->contents + off, 0, 16); 3378 3379 /* The next word is the address of the function. */ 3380 bfd_put_64 (hppa_info->opd_sec->owner, value + addend, 3381 (hppa_info->opd_sec->contents + off + 16)); 3382 3383 /* The last word is our local __gp value. */ 3384 value = _bfd_get_gp_value 3385 (hppa_info->opd_sec->output_section->owner); 3386 bfd_put_64 (hppa_info->opd_sec->owner, value, 3387 (hppa_info->opd_sec->contents + off + 24)); 3388 } 3389 3390 /* The DLT value is the address of the .opd entry. */ 3391 value = (off 3392 + hppa_info->opd_sec->output_offset 3393 + hppa_info->opd_sec->output_section->vma); 3394 addend = 0; 3395 } 3396 3397 local_dlt_offsets = local_offsets; 3398 off = local_dlt_offsets[r_symndx]; 3399 3400 if ((off & 1) != 0) 3401 { 3402 BFD_ASSERT (off != (bfd_vma) -1); 3403 off &= ~1; 3404 } 3405 else 3406 { 3407 local_dlt_offsets[r_symndx] |= 1; 3408 bfd_put_64 (hppa_info->dlt_sec->owner, 3409 value + addend, 3410 hppa_info->dlt_sec->contents + off); 3411 } 3412 } 3413 else 3414 off = hh->dlt_offset; 3415 3416 /* We want the value of the DLT offset for this symbol, not 3417 the symbol's actual address. Note that __gp may not point 3418 to the start of the DLT, so we have to compute the absolute 3419 address, then subtract out the value of __gp. */ 3420 value = (off 3421 + hppa_info->dlt_sec->output_offset 3422 + hppa_info->dlt_sec->output_section->vma); 3423 value -= _bfd_get_gp_value (output_bfd); 3424 3425 /* All DLTIND relocations are basically the same at this point, 3426 except that we need different field selectors for the 21bit 3427 version vs the 14bit versions. */ 3428 if (r_type == R_PARISC_DLTIND21L 3429 || r_type == R_PARISC_LTOFF_FPTR21L 3430 || r_type == R_PARISC_LTOFF_TP21L) 3431 value = hppa_field_adjust (value, 0, e_lsel); 3432 else if (r_type == R_PARISC_DLTIND14F 3433 || r_type == R_PARISC_LTOFF_FPTR16F 3434 || r_type == R_PARISC_LTOFF_FPTR16WF 3435 || r_type == R_PARISC_LTOFF_FPTR16DF 3436 || r_type == R_PARISC_LTOFF16F 3437 || r_type == R_PARISC_LTOFF16DF 3438 || r_type == R_PARISC_LTOFF16WF 3439 || r_type == R_PARISC_LTOFF_TP16F 3440 || r_type == R_PARISC_LTOFF_TP16WF 3441 || r_type == R_PARISC_LTOFF_TP16DF) 3442 value = hppa_field_adjust (value, 0, e_fsel); 3443 else 3444 value = hppa_field_adjust (value, 0, e_rsel); 3445 3446 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3447 break; 3448 } 3449 3450 case R_PARISC_DLTREL14R: 3451 case R_PARISC_DLTREL14F: 3452 case R_PARISC_DLTREL14DR: 3453 case R_PARISC_DLTREL14WR: 3454 case R_PARISC_DLTREL21L: 3455 case R_PARISC_DPREL21L: 3456 case R_PARISC_DPREL14WR: 3457 case R_PARISC_DPREL14DR: 3458 case R_PARISC_DPREL14R: 3459 case R_PARISC_DPREL14F: 3460 case R_PARISC_GPREL16F: 3461 case R_PARISC_GPREL16WF: 3462 case R_PARISC_GPREL16DF: 3463 { 3464 /* Subtract out the global pointer value to make value a DLT 3465 relative address. */ 3466 value -= _bfd_get_gp_value (output_bfd); 3467 3468 /* All DLTREL relocations are basically the same at this point, 3469 except that we need different field selectors for the 21bit 3470 version vs the 14bit versions. */ 3471 if (r_type == R_PARISC_DLTREL21L 3472 || r_type == R_PARISC_DPREL21L) 3473 value = hppa_field_adjust (value, addend, e_lrsel); 3474 else if (r_type == R_PARISC_DLTREL14F 3475 || r_type == R_PARISC_DPREL14F 3476 || r_type == R_PARISC_GPREL16F 3477 || r_type == R_PARISC_GPREL16WF 3478 || r_type == R_PARISC_GPREL16DF) 3479 value = hppa_field_adjust (value, addend, e_fsel); 3480 else 3481 value = hppa_field_adjust (value, addend, e_rrsel); 3482 3483 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3484 break; 3485 } 3486 3487 case R_PARISC_DIR21L: 3488 case R_PARISC_DIR17R: 3489 case R_PARISC_DIR17F: 3490 case R_PARISC_DIR14R: 3491 case R_PARISC_DIR14F: 3492 case R_PARISC_DIR14WR: 3493 case R_PARISC_DIR14DR: 3494 case R_PARISC_DIR16F: 3495 case R_PARISC_DIR16WF: 3496 case R_PARISC_DIR16DF: 3497 { 3498 /* All DIR relocations are basically the same at this point, 3499 except that branch offsets need to be divided by four, and 3500 we need different field selectors. Note that we don't 3501 redirect absolute calls to local stubs. */ 3502 3503 if (r_type == R_PARISC_DIR21L) 3504 value = hppa_field_adjust (value, addend, e_lrsel); 3505 else if (r_type == R_PARISC_DIR17F 3506 || r_type == R_PARISC_DIR16F 3507 || r_type == R_PARISC_DIR16WF 3508 || r_type == R_PARISC_DIR16DF 3509 || r_type == R_PARISC_DIR14F) 3510 value = hppa_field_adjust (value, addend, e_fsel); 3511 else 3512 value = hppa_field_adjust (value, addend, e_rrsel); 3513 3514 if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F) 3515 /* All branches are implicitly shifted by 2 places. */ 3516 value >>= 2; 3517 3518 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3519 break; 3520 } 3521 3522 case R_PARISC_PLTOFF21L: 3523 case R_PARISC_PLTOFF14R: 3524 case R_PARISC_PLTOFF14F: 3525 case R_PARISC_PLTOFF14WR: 3526 case R_PARISC_PLTOFF14DR: 3527 case R_PARISC_PLTOFF16F: 3528 case R_PARISC_PLTOFF16WF: 3529 case R_PARISC_PLTOFF16DF: 3530 { 3531 /* We want the value of the PLT offset for this symbol, not 3532 the symbol's actual address. Note that __gp may not point 3533 to the start of the DLT, so we have to compute the absolute 3534 address, then subtract out the value of __gp. */ 3535 value = (hh->plt_offset 3536 + hppa_info->plt_sec->output_offset 3537 + hppa_info->plt_sec->output_section->vma); 3538 value -= _bfd_get_gp_value (output_bfd); 3539 3540 /* All PLTOFF relocations are basically the same at this point, 3541 except that we need different field selectors for the 21bit 3542 version vs the 14bit versions. */ 3543 if (r_type == R_PARISC_PLTOFF21L) 3544 value = hppa_field_adjust (value, addend, e_lrsel); 3545 else if (r_type == R_PARISC_PLTOFF14F 3546 || r_type == R_PARISC_PLTOFF16F 3547 || r_type == R_PARISC_PLTOFF16WF 3548 || r_type == R_PARISC_PLTOFF16DF) 3549 value = hppa_field_adjust (value, addend, e_fsel); 3550 else 3551 value = hppa_field_adjust (value, addend, e_rrsel); 3552 3553 insn = elf_hppa_relocate_insn (insn, (int) value, r_type); 3554 break; 3555 } 3556 3557 case R_PARISC_LTOFF_FPTR32: 3558 { 3559 /* We may still need to create the FPTR itself if it was for 3560 a local symbol. */ 3561 if (hh == NULL) 3562 { 3563 /* The first two words of an .opd entry are zero. */ 3564 memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16); 3565 3566 /* The next word is the address of the function. */ 3567 bfd_put_64 (hppa_info->opd_sec->owner, value + addend, 3568 (hppa_info->opd_sec->contents 3569 + hh->opd_offset + 16)); 3570 3571 /* The last word is our local __gp value. */ 3572 value = _bfd_get_gp_value 3573 (hppa_info->opd_sec->output_section->owner); 3574 bfd_put_64 (hppa_info->opd_sec->owner, value, 3575 hppa_info->opd_sec->contents + hh->opd_offset + 24); 3576 3577 /* The DLT value is the address of the .opd entry. */ 3578 value = (hh->opd_offset 3579 + hppa_info->opd_sec->output_offset 3580 + hppa_info->opd_sec->output_section->vma); 3581 3582 bfd_put_64 (hppa_info->dlt_sec->owner, 3583 value, 3584 hppa_info->dlt_sec->contents + hh->dlt_offset); 3585 } 3586 3587 /* We want the value of the DLT offset for this symbol, not 3588 the symbol's actual address. Note that __gp may not point 3589 to the start of the DLT, so we have to compute the absolute 3590 address, then subtract out the value of __gp. */ 3591 value = (hh->dlt_offset 3592 + hppa_info->dlt_sec->output_offset 3593 + hppa_info->dlt_sec->output_section->vma); 3594 value -= _bfd_get_gp_value (output_bfd); 3595 bfd_put_32 (input_bfd, value, hit_data); 3596 return bfd_reloc_ok; 3597 } 3598 3599 case R_PARISC_LTOFF_FPTR64: 3600 case R_PARISC_LTOFF_TP64: 3601 { 3602 /* We may still need to create the FPTR itself if it was for 3603 a local symbol. */ 3604 if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64) 3605 { 3606 /* The first two words of an .opd entry are zero. */ 3607 memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16); 3608 3609 /* The next word is the address of the function. */ 3610 bfd_put_64 (hppa_info->opd_sec->owner, value + addend, 3611 (hppa_info->opd_sec->contents 3612 + hh->opd_offset + 16)); 3613 3614 /* The last word is our local __gp value. */ 3615 value = _bfd_get_gp_value 3616 (hppa_info->opd_sec->output_section->owner); 3617 bfd_put_64 (hppa_info->opd_sec->owner, value, 3618 hppa_info->opd_sec->contents + hh->opd_offset + 24); 3619 3620 /* The DLT value is the address of the .opd entry. */ 3621 value = (hh->opd_offset 3622 + hppa_info->opd_sec->output_offset 3623 + hppa_info->opd_sec->output_section->vma); 3624 3625 bfd_put_64 (hppa_info->dlt_sec->owner, 3626 value, 3627 hppa_info->dlt_sec->contents + hh->dlt_offset); 3628 } 3629 3630 /* We want the value of the DLT offset for this symbol, not 3631 the symbol's actual address. Note that __gp may not point 3632 to the start of the DLT, so we have to compute the absolute 3633 address, then subtract out the value of __gp. */ 3634 value = (hh->dlt_offset 3635 + hppa_info->dlt_sec->output_offset 3636 + hppa_info->dlt_sec->output_section->vma); 3637 value -= _bfd_get_gp_value (output_bfd); 3638 bfd_put_64 (input_bfd, value, hit_data); 3639 return bfd_reloc_ok; 3640 } 3641 3642 case R_PARISC_DIR32: 3643 bfd_put_32 (input_bfd, value + addend, hit_data); 3644 return bfd_reloc_ok; 3645 3646 case R_PARISC_DIR64: 3647 bfd_put_64 (input_bfd, value + addend, hit_data); 3648 return bfd_reloc_ok; 3649 3650 case R_PARISC_GPREL64: 3651 /* Subtract out the global pointer value to make value a DLT 3652 relative address. */ 3653 value -= _bfd_get_gp_value (output_bfd); 3654 3655 bfd_put_64 (input_bfd, value + addend, hit_data); 3656 return bfd_reloc_ok; 3657 3658 case R_PARISC_LTOFF64: 3659 /* We want the value of the DLT offset for this symbol, not 3660 the symbol's actual address. Note that __gp may not point 3661 to the start of the DLT, so we have to compute the absolute 3662 address, then subtract out the value of __gp. */ 3663 value = (hh->dlt_offset 3664 + hppa_info->dlt_sec->output_offset 3665 + hppa_info->dlt_sec->output_section->vma); 3666 value -= _bfd_get_gp_value (output_bfd); 3667 3668 bfd_put_64 (input_bfd, value + addend, hit_data); 3669 return bfd_reloc_ok; 3670 3671 case R_PARISC_PCREL32: 3672 { 3673 /* If this is a call to a function defined in another dynamic 3674 library, then redirect the call to the local stub for this 3675 function. */ 3676 if (sym_sec == NULL || sym_sec->output_section == NULL) 3677 value = (hh->stub_offset + hppa_info->stub_sec->output_offset 3678 + hppa_info->stub_sec->output_section->vma); 3679 3680 /* Turn VALUE into a proper PC relative address. */ 3681 value -= (offset + input_section->output_offset 3682 + input_section->output_section->vma); 3683 3684 value += addend; 3685 value -= 8; 3686 bfd_put_32 (input_bfd, value, hit_data); 3687 return bfd_reloc_ok; 3688 } 3689 3690 case R_PARISC_PCREL64: 3691 { 3692 /* If this is a call to a function defined in another dynamic 3693 library, then redirect the call to the local stub for this 3694 function. */ 3695 if (sym_sec == NULL || sym_sec->output_section == NULL) 3696 value = (hh->stub_offset + hppa_info->stub_sec->output_offset 3697 + hppa_info->stub_sec->output_section->vma); 3698 3699 /* Turn VALUE into a proper PC relative address. */ 3700 value -= (offset + input_section->output_offset 3701 + input_section->output_section->vma); 3702 3703 value += addend; 3704 value -= 8; 3705 bfd_put_64 (input_bfd, value, hit_data); 3706 return bfd_reloc_ok; 3707 } 3708 3709 case R_PARISC_FPTR64: 3710 { 3711 bfd_vma off; 3712 3713 /* We may still need to create the FPTR itself if it was for 3714 a local symbol. */ 3715 if (hh == NULL) 3716 { 3717 bfd_vma *local_opd_offsets; 3718 3719 if (local_offsets == NULL) 3720 abort (); 3721 3722 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info; 3723 off = local_opd_offsets[r_symndx]; 3724 3725 /* The last bit records whether we've already initialised 3726 this local .opd entry. */ 3727 if ((off & 1) != 0) 3728 { 3729 BFD_ASSERT (off != (bfd_vma) -1); 3730 off &= ~1; 3731 } 3732 else 3733 { 3734 /* The first two words of an .opd entry are zero. */ 3735 memset (hppa_info->opd_sec->contents + off, 0, 16); 3736 3737 /* The next word is the address of the function. */ 3738 bfd_put_64 (hppa_info->opd_sec->owner, value + addend, 3739 (hppa_info->opd_sec->contents + off + 16)); 3740 3741 /* The last word is our local __gp value. */ 3742 value = _bfd_get_gp_value 3743 (hppa_info->opd_sec->output_section->owner); 3744 bfd_put_64 (hppa_info->opd_sec->owner, value, 3745 hppa_info->opd_sec->contents + off + 24); 3746 } 3747 } 3748 else 3749 off = hh->opd_offset; 3750 3751 if (hh == NULL || hh->want_opd) 3752 /* We want the value of the OPD offset for this symbol. */ 3753 value = (off 3754 + hppa_info->opd_sec->output_offset 3755 + hppa_info->opd_sec->output_section->vma); 3756 else 3757 /* We want the address of the symbol. */ 3758 value += addend; 3759 3760 bfd_put_64 (input_bfd, value, hit_data); 3761 return bfd_reloc_ok; 3762 } 3763 3764 case R_PARISC_SECREL32: 3765 if (sym_sec) 3766 value -= sym_sec->output_section->vma; 3767 bfd_put_32 (input_bfd, value + addend, hit_data); 3768 return bfd_reloc_ok; 3769 3770 case R_PARISC_SEGREL32: 3771 case R_PARISC_SEGREL64: 3772 { 3773 /* If this is the first SEGREL relocation, then initialize 3774 the segment base values. */ 3775 if (hppa_info->text_segment_base == (bfd_vma) -1) 3776 bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs, 3777 hppa_info); 3778 3779 /* VALUE holds the absolute address. We want to include the 3780 addend, then turn it into a segment relative address. 3781 3782 The segment is derived from SYM_SEC. We assume that there are 3783 only two segments of note in the resulting executable/shlib. 3784 A readonly segment (.text) and a readwrite segment (.data). */ 3785 value += addend; 3786 3787 if (sym_sec->flags & SEC_CODE) 3788 value -= hppa_info->text_segment_base; 3789 else 3790 value -= hppa_info->data_segment_base; 3791 3792 if (r_type == R_PARISC_SEGREL32) 3793 bfd_put_32 (input_bfd, value, hit_data); 3794 else 3795 bfd_put_64 (input_bfd, value, hit_data); 3796 return bfd_reloc_ok; 3797 } 3798 3799 /* Something we don't know how to handle. */ 3800 default: 3801 return bfd_reloc_notsupported; 3802 } 3803 3804 /* Update the instruction word. */ 3805 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data); 3806 return bfd_reloc_ok; 3807 } 3808 3809 /* Relocate an HPPA ELF section. */ 3810 3811 static bfd_boolean 3812 elf64_hppa_relocate_section (bfd *output_bfd, 3813 struct bfd_link_info *info, 3814 bfd *input_bfd, 3815 asection *input_section, 3816 bfd_byte *contents, 3817 Elf_Internal_Rela *relocs, 3818 Elf_Internal_Sym *local_syms, 3819 asection **local_sections) 3820 { 3821 Elf_Internal_Shdr *symtab_hdr; 3822 Elf_Internal_Rela *rel; 3823 Elf_Internal_Rela *relend; 3824 struct elf64_hppa_link_hash_table *hppa_info; 3825 3826 hppa_info = hppa_link_hash_table (info); 3827 if (hppa_info == NULL) 3828 return FALSE; 3829 3830 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3831 3832 rel = relocs; 3833 relend = relocs + input_section->reloc_count; 3834 for (; rel < relend; rel++) 3835 { 3836 int r_type; 3837 reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info); 3838 unsigned long r_symndx; 3839 struct elf_link_hash_entry *eh; 3840 Elf_Internal_Sym *sym; 3841 asection *sym_sec; 3842 bfd_vma relocation; 3843 bfd_reloc_status_type r; 3844 3845 r_type = ELF_R_TYPE (rel->r_info); 3846 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED) 3847 { 3848 bfd_set_error (bfd_error_bad_value); 3849 return FALSE; 3850 } 3851 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY 3852 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT) 3853 continue; 3854 3855 /* This is a final link. */ 3856 r_symndx = ELF_R_SYM (rel->r_info); 3857 eh = NULL; 3858 sym = NULL; 3859 sym_sec = NULL; 3860 if (r_symndx < symtab_hdr->sh_info) 3861 { 3862 /* This is a local symbol, hh defaults to NULL. */ 3863 sym = local_syms + r_symndx; 3864 sym_sec = local_sections[r_symndx]; 3865 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel); 3866 } 3867 else 3868 { 3869 /* This is not a local symbol. */ 3870 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 3871 3872 /* It seems this can happen with erroneous or unsupported 3873 input (mixing a.out and elf in an archive, for example.) */ 3874 if (sym_hashes == NULL) 3875 return FALSE; 3876 3877 eh = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3878 3879 if (info->wrap_hash != NULL 3880 && (input_section->flags & SEC_DEBUGGING) != 0) 3881 eh = ((struct elf_link_hash_entry *) 3882 unwrap_hash_lookup (info, input_bfd, &eh->root)); 3883 3884 while (eh->root.type == bfd_link_hash_indirect 3885 || eh->root.type == bfd_link_hash_warning) 3886 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 3887 3888 relocation = 0; 3889 if (eh->root.type == bfd_link_hash_defined 3890 || eh->root.type == bfd_link_hash_defweak) 3891 { 3892 sym_sec = eh->root.u.def.section; 3893 if (sym_sec != NULL 3894 && sym_sec->output_section != NULL) 3895 relocation = (eh->root.u.def.value 3896 + sym_sec->output_section->vma 3897 + sym_sec->output_offset); 3898 } 3899 else if (eh->root.type == bfd_link_hash_undefweak) 3900 ; 3901 else if (info->unresolved_syms_in_objects == RM_IGNORE 3902 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT) 3903 ; 3904 else if (!bfd_link_relocatable (info) 3905 && elf_hppa_is_dynamic_loader_symbol (eh->root.root.string)) 3906 continue; 3907 else if (!bfd_link_relocatable (info)) 3908 { 3909 bfd_boolean err; 3910 err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR 3911 || ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT); 3912 (*info->callbacks->undefined_symbol) (info, 3913 eh->root.root.string, 3914 input_bfd, 3915 input_section, 3916 rel->r_offset, err); 3917 } 3918 3919 if (!bfd_link_relocatable (info) 3920 && relocation == 0 3921 && eh->root.type != bfd_link_hash_defined 3922 && eh->root.type != bfd_link_hash_defweak 3923 && eh->root.type != bfd_link_hash_undefweak) 3924 { 3925 if (info->unresolved_syms_in_objects == RM_IGNORE 3926 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT 3927 && eh->type == STT_PARISC_MILLI) 3928 (*info->callbacks->undefined_symbol) 3929 (info, eh_name (eh), input_bfd, 3930 input_section, rel->r_offset, FALSE); 3931 } 3932 } 3933 3934 if (sym_sec != NULL && discarded_section (sym_sec)) 3935 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3936 rel, 1, relend, howto, 0, contents); 3937 3938 if (bfd_link_relocatable (info)) 3939 continue; 3940 3941 r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd, 3942 input_section, contents, 3943 relocation, info, sym_sec, 3944 eh); 3945 3946 if (r != bfd_reloc_ok) 3947 { 3948 switch (r) 3949 { 3950 default: 3951 abort (); 3952 case bfd_reloc_overflow: 3953 { 3954 const char *sym_name; 3955 3956 if (eh != NULL) 3957 sym_name = NULL; 3958 else 3959 { 3960 sym_name = bfd_elf_string_from_elf_section (input_bfd, 3961 symtab_hdr->sh_link, 3962 sym->st_name); 3963 if (sym_name == NULL) 3964 return FALSE; 3965 if (*sym_name == '\0') 3966 sym_name = bfd_section_name (input_bfd, sym_sec); 3967 } 3968 3969 (*info->callbacks->reloc_overflow) 3970 (info, (eh ? &eh->root : NULL), sym_name, howto->name, 3971 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 3972 } 3973 break; 3974 } 3975 } 3976 } 3977 return TRUE; 3978 } 3979 3980 static const struct bfd_elf_special_section elf64_hppa_special_sections[] = 3981 { 3982 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3983 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3984 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 3985 { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 3986 { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 3987 { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 3988 { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS }, 3989 { NULL, 0, 0, 0, 0 } 3990 }; 3991 3992 /* The hash bucket size is the standard one, namely 4. */ 3993 3994 const struct elf_size_info hppa64_elf_size_info = 3995 { 3996 sizeof (Elf64_External_Ehdr), 3997 sizeof (Elf64_External_Phdr), 3998 sizeof (Elf64_External_Shdr), 3999 sizeof (Elf64_External_Rel), 4000 sizeof (Elf64_External_Rela), 4001 sizeof (Elf64_External_Sym), 4002 sizeof (Elf64_External_Dyn), 4003 sizeof (Elf_External_Note), 4004 4, 4005 1, 4006 64, 3, 4007 ELFCLASS64, EV_CURRENT, 4008 bfd_elf64_write_out_phdrs, 4009 bfd_elf64_write_shdrs_and_ehdr, 4010 bfd_elf64_checksum_contents, 4011 bfd_elf64_write_relocs, 4012 bfd_elf64_swap_symbol_in, 4013 bfd_elf64_swap_symbol_out, 4014 bfd_elf64_slurp_reloc_table, 4015 bfd_elf64_slurp_symbol_table, 4016 bfd_elf64_swap_dyn_in, 4017 bfd_elf64_swap_dyn_out, 4018 bfd_elf64_swap_reloc_in, 4019 bfd_elf64_swap_reloc_out, 4020 bfd_elf64_swap_reloca_in, 4021 bfd_elf64_swap_reloca_out 4022 }; 4023 4024 #define TARGET_BIG_SYM hppa_elf64_vec 4025 #define TARGET_BIG_NAME "elf64-hppa" 4026 #define ELF_ARCH bfd_arch_hppa 4027 #define ELF_TARGET_ID HPPA64_ELF_DATA 4028 #define ELF_MACHINE_CODE EM_PARISC 4029 /* This is not strictly correct. The maximum page size for PA2.0 is 4030 64M. But everything still uses 4k. */ 4031 #define ELF_MAXPAGESIZE 0x1000 4032 #define ELF_OSABI ELFOSABI_HPUX 4033 4034 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup 4035 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup 4036 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name 4037 #define elf_info_to_howto elf_hppa_info_to_howto 4038 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel 4039 4040 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr 4041 #define elf_backend_object_p elf64_hppa_object_p 4042 #define elf_backend_final_write_processing \ 4043 elf_hppa_final_write_processing 4044 #define elf_backend_fake_sections elf_hppa_fake_sections 4045 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook 4046 4047 #define elf_backend_relocate_section elf_hppa_relocate_section 4048 4049 #define bfd_elf64_bfd_final_link elf_hppa_final_link 4050 4051 #define elf_backend_create_dynamic_sections \ 4052 elf64_hppa_create_dynamic_sections 4053 #define elf_backend_post_process_headers elf64_hppa_post_process_headers 4054 4055 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all 4056 4057 #define elf_backend_adjust_dynamic_symbol \ 4058 elf64_hppa_adjust_dynamic_symbol 4059 4060 #define elf_backend_size_dynamic_sections \ 4061 elf64_hppa_size_dynamic_sections 4062 4063 #define elf_backend_finish_dynamic_symbol \ 4064 elf64_hppa_finish_dynamic_symbol 4065 #define elf_backend_finish_dynamic_sections \ 4066 elf64_hppa_finish_dynamic_sections 4067 #define elf_backend_grok_prstatus elf64_hppa_grok_prstatus 4068 #define elf_backend_grok_psinfo elf64_hppa_grok_psinfo 4069 4070 /* Stuff for the BFD linker: */ 4071 #define bfd_elf64_bfd_link_hash_table_create \ 4072 elf64_hppa_hash_table_create 4073 4074 #define elf_backend_check_relocs \ 4075 elf64_hppa_check_relocs 4076 4077 #define elf_backend_size_info \ 4078 hppa64_elf_size_info 4079 4080 #define elf_backend_additional_program_headers \ 4081 elf64_hppa_additional_program_headers 4082 4083 #define elf_backend_modify_segment_map \ 4084 elf64_hppa_modify_segment_map 4085 4086 #define elf_backend_allow_non_load_phdr \ 4087 elf64_hppa_allow_non_load_phdr 4088 4089 #define elf_backend_link_output_symbol_hook \ 4090 elf64_hppa_link_output_symbol_hook 4091 4092 #define elf_backend_want_got_plt 0 4093 #define elf_backend_plt_readonly 0 4094 #define elf_backend_want_plt_sym 0 4095 #define elf_backend_got_header_size 0 4096 #define elf_backend_type_change_ok TRUE 4097 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type 4098 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class 4099 #define elf_backend_rela_normal 1 4100 #define elf_backend_special_sections elf64_hppa_special_sections 4101 #define elf_backend_action_discarded elf_hppa_action_discarded 4102 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr 4103 4104 #define elf64_bed elf64_hppa_hpux_bed 4105 4106 #include "elf64-target.h" 4107 4108 #undef TARGET_BIG_SYM 4109 #define TARGET_BIG_SYM hppa_elf64_linux_vec 4110 #undef TARGET_BIG_NAME 4111 #define TARGET_BIG_NAME "elf64-hppa-linux" 4112 #undef ELF_OSABI 4113 #define ELF_OSABI ELFOSABI_GNU 4114 #undef elf64_bed 4115 #define elf64_bed elf64_hppa_linux_bed 4116 4117 #include "elf64-target.h" 4118