1/* Support for HPPA 64-bit ELF 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21#include "alloca-conf.h" 22#include "bfd.h" 23#include "sysdep.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#define ARCH_SIZE 64 30 31#define PLT_ENTRY_SIZE 0x10 32#define DLT_ENTRY_SIZE 0x8 33#define OPD_ENTRY_SIZE 0x20 34 35#define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl" 36 37/* The stub is supposed to load the target address and target's DP 38 value out of the PLT, then do an external branch to the target 39 address. 40 41 LDD PLTOFF(%r27),%r1 42 BVE (%r1) 43 LDD PLTOFF+8(%r27),%r27 44 45 Note that we must use the LDD with a 14 bit displacement, not the one 46 with a 5 bit displacement. */ 47static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00, 48 0x53, 0x7b, 0x00, 0x00 }; 49 50struct elf64_hppa_dyn_hash_entry 51{ 52 struct bfd_hash_entry root; 53 54 /* Offsets for this symbol in various linker sections. */ 55 bfd_vma dlt_offset; 56 bfd_vma plt_offset; 57 bfd_vma opd_offset; 58 bfd_vma stub_offset; 59 60 /* The symbol table entry, if any, that this was derived from. */ 61 struct elf_link_hash_entry *h; 62 63 /* The index of the (possibly local) symbol in the input bfd and its 64 associated BFD. Needed so that we can have relocs against local 65 symbols in shared libraries. */ 66 long sym_indx; 67 bfd *owner; 68 69 /* Dynamic symbols may need to have two different values. One for 70 the dynamic symbol table, one for the normal symbol table. 71 72 In such cases we store the symbol's real value and section 73 index here so we can restore the real value before we write 74 the normal symbol table. */ 75 bfd_vma st_value; 76 int st_shndx; 77 78 /* Used to count non-got, non-plt relocations for delayed sizing 79 of relocation sections. */ 80 struct elf64_hppa_dyn_reloc_entry 81 { 82 /* Next relocation in the chain. */ 83 struct elf64_hppa_dyn_reloc_entry *next; 84 85 /* The type of the relocation. */ 86 int type; 87 88 /* The input section of the relocation. */ 89 asection *sec; 90 91 /* The index of the section symbol for the input section of 92 the relocation. Only needed when building shared libraries. */ 93 int sec_symndx; 94 95 /* The offset within the input section of the relocation. */ 96 bfd_vma offset; 97 98 /* The addend for the relocation. */ 99 bfd_vma addend; 100 101 } *reloc_entries; 102 103 /* Nonzero if this symbol needs an entry in one of the linker 104 sections. */ 105 unsigned want_dlt; 106 unsigned want_plt; 107 unsigned want_opd; 108 unsigned want_stub; 109}; 110 111struct elf64_hppa_dyn_hash_table 112{ 113 struct bfd_hash_table root; 114}; 115 116struct elf64_hppa_link_hash_table 117{ 118 struct elf_link_hash_table root; 119 120 /* Shortcuts to get to the various linker defined sections. */ 121 asection *dlt_sec; 122 asection *dlt_rel_sec; 123 asection *plt_sec; 124 asection *plt_rel_sec; 125 asection *opd_sec; 126 asection *opd_rel_sec; 127 asection *other_rel_sec; 128 129 /* Offset of __gp within .plt section. When the PLT gets large we want 130 to slide __gp into the PLT section so that we can continue to use 131 single DP relative instructions to load values out of the PLT. */ 132 bfd_vma gp_offset; 133 134 /* Note this is not strictly correct. We should create a stub section for 135 each input section with calls. The stub section should be placed before 136 the section with the call. */ 137 asection *stub_sec; 138 139 bfd_vma text_segment_base; 140 bfd_vma data_segment_base; 141 142 struct elf64_hppa_dyn_hash_table dyn_hash_table; 143 144 /* We build tables to map from an input section back to its 145 symbol index. This is the BFD for which we currently have 146 a map. */ 147 bfd *section_syms_bfd; 148 149 /* Array of symbol numbers for each input section attached to the 150 current BFD. */ 151 int *section_syms; 152}; 153 154#define elf64_hppa_hash_table(p) \ 155 ((struct elf64_hppa_link_hash_table *) ((p)->hash)) 156 157typedef struct bfd_hash_entry *(*new_hash_entry_func) 158 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 159 160static struct bfd_hash_entry *elf64_hppa_new_dyn_hash_entry 161 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table, 162 const char *string)); 163static struct bfd_link_hash_table *elf64_hppa_hash_table_create 164 PARAMS ((bfd *abfd)); 165static struct elf64_hppa_dyn_hash_entry *elf64_hppa_dyn_hash_lookup 166 PARAMS ((struct elf64_hppa_dyn_hash_table *table, const char *string, 167 bfd_boolean create, bfd_boolean copy)); 168static void elf64_hppa_dyn_hash_traverse 169 PARAMS ((struct elf64_hppa_dyn_hash_table *table, 170 bfd_boolean (*func) (struct elf64_hppa_dyn_hash_entry *, PTR), 171 PTR info)); 172 173static const char *get_dyn_name 174 PARAMS ((bfd *, struct elf_link_hash_entry *, 175 const Elf_Internal_Rela *, char **, size_t *)); 176 177/* This must follow the definitions of the various derived linker 178 hash tables and shared functions. */ 179#include "elf-hppa.h" 180 181static bfd_boolean elf64_hppa_object_p 182 PARAMS ((bfd *)); 183 184static void elf64_hppa_post_process_headers 185 PARAMS ((bfd *, struct bfd_link_info *)); 186 187static bfd_boolean elf64_hppa_create_dynamic_sections 188 PARAMS ((bfd *, struct bfd_link_info *)); 189 190static bfd_boolean elf64_hppa_adjust_dynamic_symbol 191 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 192 193static bfd_boolean elf64_hppa_mark_milli_and_exported_functions 194 PARAMS ((struct elf_link_hash_entry *, PTR)); 195 196static bfd_boolean elf64_hppa_size_dynamic_sections 197 PARAMS ((bfd *, struct bfd_link_info *)); 198 199static bfd_boolean elf64_hppa_link_output_symbol_hook 200 PARAMS ((struct bfd_link_info *, const char *, Elf_Internal_Sym *, 201 asection *, struct elf_link_hash_entry *)); 202 203static bfd_boolean elf64_hppa_finish_dynamic_symbol 204 PARAMS ((bfd *, struct bfd_link_info *, 205 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 206 207static enum elf_reloc_type_class elf64_hppa_reloc_type_class 208 PARAMS ((const Elf_Internal_Rela *)); 209 210static bfd_boolean elf64_hppa_finish_dynamic_sections 211 PARAMS ((bfd *, struct bfd_link_info *)); 212 213static bfd_boolean elf64_hppa_check_relocs 214 PARAMS ((bfd *, struct bfd_link_info *, 215 asection *, const Elf_Internal_Rela *)); 216 217static bfd_boolean elf64_hppa_dynamic_symbol_p 218 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *)); 219 220static bfd_boolean elf64_hppa_mark_exported_functions 221 PARAMS ((struct elf_link_hash_entry *, PTR)); 222 223static bfd_boolean elf64_hppa_finalize_opd 224 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 225 226static bfd_boolean elf64_hppa_finalize_dlt 227 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 228 229static bfd_boolean allocate_global_data_dlt 230 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 231 232static bfd_boolean allocate_global_data_plt 233 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 234 235static bfd_boolean allocate_global_data_stub 236 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 237 238static bfd_boolean allocate_global_data_opd 239 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 240 241static bfd_boolean get_reloc_section 242 PARAMS ((bfd *, struct elf64_hppa_link_hash_table *, asection *)); 243 244static bfd_boolean count_dyn_reloc 245 PARAMS ((bfd *, struct elf64_hppa_dyn_hash_entry *, 246 int, asection *, int, bfd_vma, bfd_vma)); 247 248static bfd_boolean allocate_dynrel_entries 249 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 250 251static bfd_boolean elf64_hppa_finalize_dynreloc 252 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 253 254static bfd_boolean get_opd 255 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *)); 256 257static bfd_boolean get_plt 258 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *)); 259 260static bfd_boolean get_dlt 261 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *)); 262 263static bfd_boolean get_stub 264 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *)); 265 266static int elf64_hppa_elf_get_symbol_type 267 PARAMS ((Elf_Internal_Sym *, int)); 268 269static bfd_boolean 270elf64_hppa_dyn_hash_table_init (struct elf64_hppa_dyn_hash_table *ht, 271 bfd *abfd ATTRIBUTE_UNUSED, 272 new_hash_entry_func new, 273 unsigned int entsize) 274{ 275 memset (ht, 0, sizeof (*ht)); 276 return bfd_hash_table_init (&ht->root, new, entsize); 277} 278 279static struct bfd_hash_entry* 280elf64_hppa_new_dyn_hash_entry (entry, table, string) 281 struct bfd_hash_entry *entry; 282 struct bfd_hash_table *table; 283 const char *string; 284{ 285 struct elf64_hppa_dyn_hash_entry *ret; 286 ret = (struct elf64_hppa_dyn_hash_entry *) entry; 287 288 /* Allocate the structure if it has not already been allocated by a 289 subclass. */ 290 if (!ret) 291 ret = bfd_hash_allocate (table, sizeof (*ret)); 292 293 if (!ret) 294 return 0; 295 296 /* Call the allocation method of the superclass. */ 297 ret = ((struct elf64_hppa_dyn_hash_entry *) 298 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 299 300 /* Initialize our local data. All zeros. */ 301 memset (&ret->dlt_offset, 0, 302 (sizeof (struct elf64_hppa_dyn_hash_entry) 303 - offsetof (struct elf64_hppa_dyn_hash_entry, dlt_offset))); 304 305 return &ret->root; 306} 307 308/* Create the derived linker hash table. The PA64 ELF port uses this 309 derived hash table to keep information specific to the PA ElF 310 linker (without using static variables). */ 311 312static struct bfd_link_hash_table* 313elf64_hppa_hash_table_create (abfd) 314 bfd *abfd; 315{ 316 struct elf64_hppa_link_hash_table *ret; 317 318 ret = bfd_zalloc (abfd, (bfd_size_type) sizeof (*ret)); 319 if (!ret) 320 return 0; 321 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 322 _bfd_elf_link_hash_newfunc, 323 sizeof (struct elf_link_hash_entry))) 324 { 325 bfd_release (abfd, ret); 326 return 0; 327 } 328 329 if (!elf64_hppa_dyn_hash_table_init (&ret->dyn_hash_table, abfd, 330 elf64_hppa_new_dyn_hash_entry, 331 sizeof (struct elf64_hppa_dyn_hash_entry))) 332 return 0; 333 return &ret->root.root; 334} 335 336/* Look up an entry in a PA64 ELF linker hash table. */ 337 338static struct elf64_hppa_dyn_hash_entry * 339elf64_hppa_dyn_hash_lookup(table, string, create, copy) 340 struct elf64_hppa_dyn_hash_table *table; 341 const char *string; 342 bfd_boolean create, copy; 343{ 344 return ((struct elf64_hppa_dyn_hash_entry *) 345 bfd_hash_lookup (&table->root, string, create, copy)); 346} 347 348/* Traverse a PA64 ELF linker hash table. */ 349 350static void 351elf64_hppa_dyn_hash_traverse (table, func, info) 352 struct elf64_hppa_dyn_hash_table *table; 353 bfd_boolean (*func) PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR)); 354 PTR info; 355{ 356 (bfd_hash_traverse 357 (&table->root, 358 (bfd_boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) func, 359 info)); 360} 361 362/* Return nonzero if ABFD represents a PA2.0 ELF64 file. 363 364 Additionally we set the default architecture and machine. */ 365static bfd_boolean 366elf64_hppa_object_p (abfd) 367 bfd *abfd; 368{ 369 Elf_Internal_Ehdr * i_ehdrp; 370 unsigned int flags; 371 372 i_ehdrp = elf_elfheader (abfd); 373 if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0) 374 { 375 /* GCC on hppa-linux produces binaries with OSABI=Linux, 376 but the kernel produces corefiles with OSABI=SysV. */ 377 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX 378 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 379 return FALSE; 380 } 381 else 382 { 383 /* HPUX produces binaries with OSABI=HPUX, 384 but the kernel produces corefiles with OSABI=SysV. */ 385 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX 386 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 387 return FALSE; 388 } 389 390 flags = i_ehdrp->e_flags; 391 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE)) 392 { 393 case EFA_PARISC_1_0: 394 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10); 395 case EFA_PARISC_1_1: 396 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11); 397 case EFA_PARISC_2_0: 398 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64) 399 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25); 400 else 401 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20); 402 case EFA_PARISC_2_0 | EF_PARISC_WIDE: 403 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25); 404 } 405 /* Don't be fussy. */ 406 return TRUE; 407} 408 409/* Given section type (hdr->sh_type), return a boolean indicating 410 whether or not the section is an elf64-hppa specific section. */ 411static bfd_boolean 412elf64_hppa_section_from_shdr (bfd *abfd, 413 Elf_Internal_Shdr *hdr, 414 const char *name, 415 int shindex) 416{ 417 asection *newsect; 418 419 switch (hdr->sh_type) 420 { 421 case SHT_PARISC_EXT: 422 if (strcmp (name, ".PARISC.archext") != 0) 423 return FALSE; 424 break; 425 case SHT_PARISC_UNWIND: 426 if (strcmp (name, ".PARISC.unwind") != 0) 427 return FALSE; 428 break; 429 case SHT_PARISC_DOC: 430 case SHT_PARISC_ANNOT: 431 default: 432 return FALSE; 433 } 434 435 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 436 return FALSE; 437 newsect = hdr->bfd_section; 438 439 return TRUE; 440} 441 442/* Construct a string for use in the elf64_hppa_dyn_hash_table. The 443 name describes what was once potentially anonymous memory. We 444 allocate memory as necessary, possibly reusing PBUF/PLEN. */ 445 446static const char * 447get_dyn_name (abfd, h, rel, pbuf, plen) 448 bfd *abfd; 449 struct elf_link_hash_entry *h; 450 const Elf_Internal_Rela *rel; 451 char **pbuf; 452 size_t *plen; 453{ 454 asection *sec = abfd->sections; 455 size_t nlen, tlen; 456 char *buf; 457 size_t len; 458 459 if (h && rel->r_addend == 0) 460 return h->root.root.string; 461 462 if (h) 463 nlen = strlen (h->root.root.string); 464 else 465 nlen = 8 + 1 + sizeof (rel->r_info) * 2 - 8; 466 tlen = nlen + 1 + sizeof (rel->r_addend) * 2 + 1; 467 468 len = *plen; 469 buf = *pbuf; 470 if (len < tlen) 471 { 472 if (buf) 473 free (buf); 474 *pbuf = buf = malloc (tlen); 475 *plen = len = tlen; 476 if (!buf) 477 return NULL; 478 } 479 480 if (h) 481 { 482 memcpy (buf, h->root.root.string, nlen); 483 buf[nlen++] = '+'; 484 sprintf_vma (buf + nlen, rel->r_addend); 485 } 486 else 487 { 488 nlen = sprintf (buf, "%x:%lx", 489 sec->id & 0xffffffff, 490 (long) ELF64_R_SYM (rel->r_info)); 491 if (rel->r_addend) 492 { 493 buf[nlen++] = '+'; 494 sprintf_vma (buf + nlen, rel->r_addend); 495 } 496 } 497 498 return buf; 499} 500 501/* SEC is a section containing relocs for an input BFD when linking; return 502 a suitable section for holding relocs in the output BFD for a link. */ 503 504static bfd_boolean 505get_reloc_section (abfd, hppa_info, sec) 506 bfd *abfd; 507 struct elf64_hppa_link_hash_table *hppa_info; 508 asection *sec; 509{ 510 const char *srel_name; 511 asection *srel; 512 bfd *dynobj; 513 514 srel_name = (bfd_elf_string_from_elf_section 515 (abfd, elf_elfheader(abfd)->e_shstrndx, 516 elf_section_data(sec)->rel_hdr.sh_name)); 517 if (srel_name == NULL) 518 return FALSE; 519 520 BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela") 521 && strcmp (bfd_get_section_name (abfd, sec), 522 srel_name + 5) == 0) 523 || (CONST_STRNEQ (srel_name, ".rel") 524 && strcmp (bfd_get_section_name (abfd, sec), 525 srel_name + 4) == 0)); 526 527 dynobj = hppa_info->root.dynobj; 528 if (!dynobj) 529 hppa_info->root.dynobj = dynobj = abfd; 530 531 srel = bfd_get_section_by_name (dynobj, srel_name); 532 if (srel == NULL) 533 { 534 srel = bfd_make_section_with_flags (dynobj, srel_name, 535 (SEC_ALLOC 536 | SEC_LOAD 537 | SEC_HAS_CONTENTS 538 | SEC_IN_MEMORY 539 | SEC_LINKER_CREATED 540 | SEC_READONLY)); 541 if (srel == NULL 542 || !bfd_set_section_alignment (dynobj, srel, 3)) 543 return FALSE; 544 } 545 546 hppa_info->other_rel_sec = srel; 547 return TRUE; 548} 549 550/* Add a new entry to the list of dynamic relocations against DYN_H. 551 552 We use this to keep a record of all the FPTR relocations against a 553 particular symbol so that we can create FPTR relocations in the 554 output file. */ 555 556static bfd_boolean 557count_dyn_reloc (abfd, dyn_h, type, sec, sec_symndx, offset, addend) 558 bfd *abfd; 559 struct elf64_hppa_dyn_hash_entry *dyn_h; 560 int type; 561 asection *sec; 562 int sec_symndx; 563 bfd_vma offset; 564 bfd_vma addend; 565{ 566 struct elf64_hppa_dyn_reloc_entry *rent; 567 568 rent = (struct elf64_hppa_dyn_reloc_entry *) 569 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)); 570 if (!rent) 571 return FALSE; 572 573 rent->next = dyn_h->reloc_entries; 574 rent->type = type; 575 rent->sec = sec; 576 rent->sec_symndx = sec_symndx; 577 rent->offset = offset; 578 rent->addend = addend; 579 dyn_h->reloc_entries = rent; 580 581 return TRUE; 582} 583 584/* Scan the RELOCS and record the type of dynamic entries that each 585 referenced symbol needs. */ 586 587static bfd_boolean 588elf64_hppa_check_relocs (abfd, info, sec, relocs) 589 bfd *abfd; 590 struct bfd_link_info *info; 591 asection *sec; 592 const Elf_Internal_Rela *relocs; 593{ 594 struct elf64_hppa_link_hash_table *hppa_info; 595 const Elf_Internal_Rela *relend; 596 Elf_Internal_Shdr *symtab_hdr; 597 const Elf_Internal_Rela *rel; 598 asection *dlt, *plt, *stubs; 599 char *buf; 600 size_t buf_len; 601 int sec_symndx; 602 603 if (info->relocatable) 604 return TRUE; 605 606 /* If this is the first dynamic object found in the link, create 607 the special sections required for dynamic linking. */ 608 if (! elf_hash_table (info)->dynamic_sections_created) 609 { 610 if (! _bfd_elf_link_create_dynamic_sections (abfd, info)) 611 return FALSE; 612 } 613 614 hppa_info = elf64_hppa_hash_table (info); 615 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 616 617 /* If necessary, build a new table holding section symbols indices 618 for this BFD. */ 619 620 if (info->shared && hppa_info->section_syms_bfd != abfd) 621 { 622 unsigned long i; 623 unsigned int highest_shndx; 624 Elf_Internal_Sym *local_syms = NULL; 625 Elf_Internal_Sym *isym, *isymend; 626 bfd_size_type amt; 627 628 /* We're done with the old cache of section index to section symbol 629 index information. Free it. 630 631 ?!? Note we leak the last section_syms array. Presumably we 632 could free it in one of the later routines in this file. */ 633 if (hppa_info->section_syms) 634 free (hppa_info->section_syms); 635 636 /* Read this BFD's local symbols. */ 637 if (symtab_hdr->sh_info != 0) 638 { 639 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 640 if (local_syms == NULL) 641 local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr, 642 symtab_hdr->sh_info, 0, 643 NULL, NULL, NULL); 644 if (local_syms == NULL) 645 return FALSE; 646 } 647 648 /* Record the highest section index referenced by the local symbols. */ 649 highest_shndx = 0; 650 isymend = local_syms + symtab_hdr->sh_info; 651 for (isym = local_syms; isym < isymend; isym++) 652 { 653 if (isym->st_shndx > highest_shndx) 654 highest_shndx = isym->st_shndx; 655 } 656 657 /* Allocate an array to hold the section index to section symbol index 658 mapping. Bump by one since we start counting at zero. */ 659 highest_shndx++; 660 amt = highest_shndx; 661 amt *= sizeof (int); 662 hppa_info->section_syms = (int *) bfd_malloc (amt); 663 664 /* Now walk the local symbols again. If we find a section symbol, 665 record the index of the symbol into the section_syms array. */ 666 for (i = 0, isym = local_syms; isym < isymend; i++, isym++) 667 { 668 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 669 hppa_info->section_syms[isym->st_shndx] = i; 670 } 671 672 /* We are finished with the local symbols. */ 673 if (local_syms != NULL 674 && symtab_hdr->contents != (unsigned char *) local_syms) 675 { 676 if (! info->keep_memory) 677 free (local_syms); 678 else 679 { 680 /* Cache the symbols for elf_link_input_bfd. */ 681 symtab_hdr->contents = (unsigned char *) local_syms; 682 } 683 } 684 685 /* Record which BFD we built the section_syms mapping for. */ 686 hppa_info->section_syms_bfd = abfd; 687 } 688 689 /* Record the symbol index for this input section. We may need it for 690 relocations when building shared libraries. When not building shared 691 libraries this value is never really used, but assign it to zero to 692 prevent out of bounds memory accesses in other routines. */ 693 if (info->shared) 694 { 695 sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec); 696 697 /* If we did not find a section symbol for this section, then 698 something went terribly wrong above. */ 699 if (sec_symndx == -1) 700 return FALSE; 701 702 sec_symndx = hppa_info->section_syms[sec_symndx]; 703 } 704 else 705 sec_symndx = 0; 706 707 dlt = plt = stubs = NULL; 708 buf = NULL; 709 buf_len = 0; 710 711 relend = relocs + sec->reloc_count; 712 for (rel = relocs; rel < relend; ++rel) 713 { 714 enum 715 { 716 NEED_DLT = 1, 717 NEED_PLT = 2, 718 NEED_STUB = 4, 719 NEED_OPD = 8, 720 NEED_DYNREL = 16, 721 }; 722 723 struct elf_link_hash_entry *h = NULL; 724 unsigned long r_symndx = ELF64_R_SYM (rel->r_info); 725 struct elf64_hppa_dyn_hash_entry *dyn_h; 726 int need_entry; 727 const char *addr_name; 728 bfd_boolean maybe_dynamic; 729 int dynrel_type = R_PARISC_NONE; 730 static reloc_howto_type *howto; 731 732 if (r_symndx >= symtab_hdr->sh_info) 733 { 734 /* We're dealing with a global symbol -- find its hash entry 735 and mark it as being referenced. */ 736 long indx = r_symndx - symtab_hdr->sh_info; 737 h = elf_sym_hashes (abfd)[indx]; 738 while (h->root.type == bfd_link_hash_indirect 739 || h->root.type == bfd_link_hash_warning) 740 h = (struct elf_link_hash_entry *) h->root.u.i.link; 741 742 h->ref_regular = 1; 743 } 744 745 /* We can only get preliminary data on whether a symbol is 746 locally or externally defined, as not all of the input files 747 have yet been processed. Do something with what we know, as 748 this may help reduce memory usage and processing time later. */ 749 maybe_dynamic = FALSE; 750 if (h && ((info->shared 751 && (!info->symbolic 752 || info->unresolved_syms_in_shared_libs == RM_IGNORE)) 753 || !h->def_regular 754 || h->root.type == bfd_link_hash_defweak)) 755 maybe_dynamic = TRUE; 756 757 howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info); 758 need_entry = 0; 759 switch (howto->type) 760 { 761 /* These are simple indirect references to symbols through the 762 DLT. We need to create a DLT entry for any symbols which 763 appears in a DLTIND relocation. */ 764 case R_PARISC_DLTIND21L: 765 case R_PARISC_DLTIND14R: 766 case R_PARISC_DLTIND14F: 767 case R_PARISC_DLTIND14WR: 768 case R_PARISC_DLTIND14DR: 769 need_entry = NEED_DLT; 770 break; 771 772 /* ?!? These need a DLT entry. But I have no idea what to do with 773 the "link time TP value. */ 774 case R_PARISC_LTOFF_TP21L: 775 case R_PARISC_LTOFF_TP14R: 776 case R_PARISC_LTOFF_TP14F: 777 case R_PARISC_LTOFF_TP64: 778 case R_PARISC_LTOFF_TP14WR: 779 case R_PARISC_LTOFF_TP14DR: 780 case R_PARISC_LTOFF_TP16F: 781 case R_PARISC_LTOFF_TP16WF: 782 case R_PARISC_LTOFF_TP16DF: 783 need_entry = NEED_DLT; 784 break; 785 786 /* These are function calls. Depending on their precise target we 787 may need to make a stub for them. The stub uses the PLT, so we 788 need to create PLT entries for these symbols too. */ 789 case R_PARISC_PCREL12F: 790 case R_PARISC_PCREL17F: 791 case R_PARISC_PCREL22F: 792 case R_PARISC_PCREL32: 793 case R_PARISC_PCREL64: 794 case R_PARISC_PCREL21L: 795 case R_PARISC_PCREL17R: 796 case R_PARISC_PCREL17C: 797 case R_PARISC_PCREL14R: 798 case R_PARISC_PCREL14F: 799 case R_PARISC_PCREL22C: 800 case R_PARISC_PCREL14WR: 801 case R_PARISC_PCREL14DR: 802 case R_PARISC_PCREL16F: 803 case R_PARISC_PCREL16WF: 804 case R_PARISC_PCREL16DF: 805 need_entry = (NEED_PLT | NEED_STUB); 806 break; 807 808 case R_PARISC_PLTOFF21L: 809 case R_PARISC_PLTOFF14R: 810 case R_PARISC_PLTOFF14F: 811 case R_PARISC_PLTOFF14WR: 812 case R_PARISC_PLTOFF14DR: 813 case R_PARISC_PLTOFF16F: 814 case R_PARISC_PLTOFF16WF: 815 case R_PARISC_PLTOFF16DF: 816 need_entry = (NEED_PLT); 817 break; 818 819 case R_PARISC_DIR64: 820 if (info->shared || maybe_dynamic) 821 need_entry = (NEED_DYNREL); 822 dynrel_type = R_PARISC_DIR64; 823 break; 824 825 /* This is an indirect reference through the DLT to get the address 826 of a OPD descriptor. Thus we need to make a DLT entry that points 827 to an OPD entry. */ 828 case R_PARISC_LTOFF_FPTR21L: 829 case R_PARISC_LTOFF_FPTR14R: 830 case R_PARISC_LTOFF_FPTR14WR: 831 case R_PARISC_LTOFF_FPTR14DR: 832 case R_PARISC_LTOFF_FPTR32: 833 case R_PARISC_LTOFF_FPTR64: 834 case R_PARISC_LTOFF_FPTR16F: 835 case R_PARISC_LTOFF_FPTR16WF: 836 case R_PARISC_LTOFF_FPTR16DF: 837 if (info->shared || maybe_dynamic) 838 need_entry = (NEED_DLT | NEED_OPD); 839 else 840 need_entry = (NEED_DLT | NEED_OPD); 841 dynrel_type = R_PARISC_FPTR64; 842 break; 843 844 /* This is a simple OPD entry. */ 845 case R_PARISC_FPTR64: 846 if (info->shared || maybe_dynamic) 847 need_entry = (NEED_OPD | NEED_DYNREL); 848 else 849 need_entry = (NEED_OPD); 850 dynrel_type = R_PARISC_FPTR64; 851 break; 852 853 /* Add more cases as needed. */ 854 } 855 856 if (!need_entry) 857 continue; 858 859 /* Collect a canonical name for this address. */ 860 addr_name = get_dyn_name (abfd, h, rel, &buf, &buf_len); 861 862 /* Collect the canonical entry data for this address. */ 863 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table, 864 addr_name, TRUE, TRUE); 865 BFD_ASSERT (dyn_h); 866 867 /* Stash away enough information to be able to find this symbol 868 regardless of whether or not it is local or global. */ 869 dyn_h->h = h; 870 dyn_h->owner = abfd; 871 dyn_h->sym_indx = r_symndx; 872 873 /* ?!? We may need to do some error checking in here. */ 874 /* Create what's needed. */ 875 if (need_entry & NEED_DLT) 876 { 877 if (! hppa_info->dlt_sec 878 && ! get_dlt (abfd, info, hppa_info)) 879 goto err_out; 880 dyn_h->want_dlt = 1; 881 } 882 883 if (need_entry & NEED_PLT) 884 { 885 if (! hppa_info->plt_sec 886 && ! get_plt (abfd, info, hppa_info)) 887 goto err_out; 888 dyn_h->want_plt = 1; 889 } 890 891 if (need_entry & NEED_STUB) 892 { 893 if (! hppa_info->stub_sec 894 && ! get_stub (abfd, info, hppa_info)) 895 goto err_out; 896 dyn_h->want_stub = 1; 897 } 898 899 if (need_entry & NEED_OPD) 900 { 901 if (! hppa_info->opd_sec 902 && ! get_opd (abfd, info, hppa_info)) 903 goto err_out; 904 905 dyn_h->want_opd = 1; 906 907 /* FPTRs are not allocated by the dynamic linker for PA64, though 908 it is possible that will change in the future. */ 909 910 /* This could be a local function that had its address taken, in 911 which case H will be NULL. */ 912 if (h) 913 h->needs_plt = 1; 914 } 915 916 /* Add a new dynamic relocation to the chain of dynamic 917 relocations for this symbol. */ 918 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) 919 { 920 if (! hppa_info->other_rel_sec 921 && ! get_reloc_section (abfd, hppa_info, sec)) 922 goto err_out; 923 924 if (!count_dyn_reloc (abfd, dyn_h, dynrel_type, sec, 925 sec_symndx, rel->r_offset, rel->r_addend)) 926 goto err_out; 927 928 /* If we are building a shared library and we just recorded 929 a dynamic R_PARISC_FPTR64 relocation, then make sure the 930 section symbol for this section ends up in the dynamic 931 symbol table. */ 932 if (info->shared && dynrel_type == R_PARISC_FPTR64 933 && ! (bfd_elf_link_record_local_dynamic_symbol 934 (info, abfd, sec_symndx))) 935 return FALSE; 936 } 937 } 938 939 if (buf) 940 free (buf); 941 return TRUE; 942 943 err_out: 944 if (buf) 945 free (buf); 946 return FALSE; 947} 948 949struct elf64_hppa_allocate_data 950{ 951 struct bfd_link_info *info; 952 bfd_size_type ofs; 953}; 954 955/* Should we do dynamic things to this symbol? */ 956 957static bfd_boolean 958elf64_hppa_dynamic_symbol_p (h, info) 959 struct elf_link_hash_entry *h; 960 struct bfd_link_info *info; 961{ 962 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols 963 and relocations that retrieve a function descriptor? Assume the 964 worst for now. */ 965 if (_bfd_elf_dynamic_symbol_p (h, info, 1)) 966 { 967 /* ??? Why is this here and not elsewhere is_local_label_name. */ 968 if (h->root.root.string[0] == '$' && h->root.root.string[1] == '$') 969 return FALSE; 970 971 return TRUE; 972 } 973 else 974 return FALSE; 975} 976 977/* Mark all functions exported by this file so that we can later allocate 978 entries in .opd for them. */ 979 980static bfd_boolean 981elf64_hppa_mark_exported_functions (h, data) 982 struct elf_link_hash_entry *h; 983 PTR data; 984{ 985 struct bfd_link_info *info = (struct bfd_link_info *)data; 986 struct elf64_hppa_link_hash_table *hppa_info; 987 988 hppa_info = elf64_hppa_hash_table (info); 989 990 if (h->root.type == bfd_link_hash_warning) 991 h = (struct elf_link_hash_entry *) h->root.u.i.link; 992 993 if (h 994 && (h->root.type == bfd_link_hash_defined 995 || h->root.type == bfd_link_hash_defweak) 996 && h->root.u.def.section->output_section != NULL 997 && h->type == STT_FUNC) 998 { 999 struct elf64_hppa_dyn_hash_entry *dyn_h; 1000 1001 /* Add this symbol to the PA64 linker hash table. */ 1002 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table, 1003 h->root.root.string, TRUE, TRUE); 1004 BFD_ASSERT (dyn_h); 1005 dyn_h->h = h; 1006 1007 if (! hppa_info->opd_sec 1008 && ! get_opd (hppa_info->root.dynobj, info, hppa_info)) 1009 return FALSE; 1010 1011 dyn_h->want_opd = 1; 1012 /* Put a flag here for output_symbol_hook. */ 1013 dyn_h->st_shndx = -1; 1014 h->needs_plt = 1; 1015 } 1016 1017 return TRUE; 1018} 1019 1020/* Allocate space for a DLT entry. */ 1021 1022static bfd_boolean 1023allocate_global_data_dlt (dyn_h, data) 1024 struct elf64_hppa_dyn_hash_entry *dyn_h; 1025 PTR data; 1026{ 1027 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1028 1029 if (dyn_h->want_dlt) 1030 { 1031 struct elf_link_hash_entry *h = dyn_h->h; 1032 1033 if (x->info->shared) 1034 { 1035 /* Possibly add the symbol to the local dynamic symbol 1036 table since we might need to create a dynamic relocation 1037 against it. */ 1038 if (! h 1039 || (h->dynindx == -1 && h->type != STT_PARISC_MILLI)) 1040 { 1041 bfd *owner; 1042 owner = (h ? h->root.u.def.section->owner : dyn_h->owner); 1043 1044 if (! (bfd_elf_link_record_local_dynamic_symbol 1045 (x->info, owner, dyn_h->sym_indx))) 1046 return FALSE; 1047 } 1048 } 1049 1050 dyn_h->dlt_offset = x->ofs; 1051 x->ofs += DLT_ENTRY_SIZE; 1052 } 1053 return TRUE; 1054} 1055 1056/* Allocate space for a DLT.PLT entry. */ 1057 1058static bfd_boolean 1059allocate_global_data_plt (dyn_h, data) 1060 struct elf64_hppa_dyn_hash_entry *dyn_h; 1061 PTR data; 1062{ 1063 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1064 1065 if (dyn_h->want_plt 1066 && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info) 1067 && !((dyn_h->h->root.type == bfd_link_hash_defined 1068 || dyn_h->h->root.type == bfd_link_hash_defweak) 1069 && dyn_h->h->root.u.def.section->output_section != NULL)) 1070 { 1071 dyn_h->plt_offset = x->ofs; 1072 x->ofs += PLT_ENTRY_SIZE; 1073 if (dyn_h->plt_offset < 0x2000) 1074 elf64_hppa_hash_table (x->info)->gp_offset = dyn_h->plt_offset; 1075 } 1076 else 1077 dyn_h->want_plt = 0; 1078 1079 return TRUE; 1080} 1081 1082/* Allocate space for a STUB entry. */ 1083 1084static bfd_boolean 1085allocate_global_data_stub (dyn_h, data) 1086 struct elf64_hppa_dyn_hash_entry *dyn_h; 1087 PTR data; 1088{ 1089 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1090 1091 if (dyn_h->want_stub 1092 && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info) 1093 && !((dyn_h->h->root.type == bfd_link_hash_defined 1094 || dyn_h->h->root.type == bfd_link_hash_defweak) 1095 && dyn_h->h->root.u.def.section->output_section != NULL)) 1096 { 1097 dyn_h->stub_offset = x->ofs; 1098 x->ofs += sizeof (plt_stub); 1099 } 1100 else 1101 dyn_h->want_stub = 0; 1102 return TRUE; 1103} 1104 1105/* Allocate space for a FPTR entry. */ 1106 1107static bfd_boolean 1108allocate_global_data_opd (dyn_h, data) 1109 struct elf64_hppa_dyn_hash_entry *dyn_h; 1110 PTR data; 1111{ 1112 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1113 1114 if (dyn_h->want_opd) 1115 { 1116 struct elf_link_hash_entry *h = dyn_h->h; 1117 1118 if (h) 1119 while (h->root.type == bfd_link_hash_indirect 1120 || h->root.type == bfd_link_hash_warning) 1121 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1122 1123 /* We never need an opd entry for a symbol which is not 1124 defined by this output file. */ 1125 if (h && (h->root.type == bfd_link_hash_undefined 1126 || h->root.type == bfd_link_hash_undefweak 1127 || h->root.u.def.section->output_section == NULL)) 1128 dyn_h->want_opd = 0; 1129 1130 /* If we are creating a shared library, took the address of a local 1131 function or might export this function from this object file, then 1132 we have to create an opd descriptor. */ 1133 else if (x->info->shared 1134 || h == NULL 1135 || (h->dynindx == -1 && h->type != STT_PARISC_MILLI) 1136 || (h->root.type == bfd_link_hash_defined 1137 || h->root.type == bfd_link_hash_defweak)) 1138 { 1139 /* If we are creating a shared library, then we will have to 1140 create a runtime relocation for the symbol to properly 1141 initialize the .opd entry. Make sure the symbol gets 1142 added to the dynamic symbol table. */ 1143 if (x->info->shared 1144 && (h == NULL || (h->dynindx == -1))) 1145 { 1146 bfd *owner; 1147 owner = (h ? h->root.u.def.section->owner : dyn_h->owner); 1148 1149 if (!bfd_elf_link_record_local_dynamic_symbol 1150 (x->info, owner, dyn_h->sym_indx)) 1151 return FALSE; 1152 } 1153 1154 /* This may not be necessary or desirable anymore now that 1155 we have some support for dealing with section symbols 1156 in dynamic relocs. But name munging does make the result 1157 much easier to debug. ie, the EPLT reloc will reference 1158 a symbol like .foobar, instead of .text + offset. */ 1159 if (x->info->shared && h) 1160 { 1161 char *new_name; 1162 struct elf_link_hash_entry *nh; 1163 1164 new_name = alloca (strlen (h->root.root.string) + 2); 1165 new_name[0] = '.'; 1166 strcpy (new_name + 1, h->root.root.string); 1167 1168 nh = elf_link_hash_lookup (elf_hash_table (x->info), 1169 new_name, TRUE, TRUE, TRUE); 1170 1171 nh->root.type = h->root.type; 1172 nh->root.u.def.value = h->root.u.def.value; 1173 nh->root.u.def.section = h->root.u.def.section; 1174 1175 if (! bfd_elf_link_record_dynamic_symbol (x->info, nh)) 1176 return FALSE; 1177 1178 } 1179 dyn_h->opd_offset = x->ofs; 1180 x->ofs += OPD_ENTRY_SIZE; 1181 } 1182 1183 /* Otherwise we do not need an opd entry. */ 1184 else 1185 dyn_h->want_opd = 0; 1186 } 1187 return TRUE; 1188} 1189 1190/* HP requires the EI_OSABI field to be filled in. The assignment to 1191 EI_ABIVERSION may not be strictly necessary. */ 1192 1193static void 1194elf64_hppa_post_process_headers (abfd, link_info) 1195 bfd * abfd; 1196 struct bfd_link_info * link_info ATTRIBUTE_UNUSED; 1197{ 1198 Elf_Internal_Ehdr * i_ehdrp; 1199 1200 i_ehdrp = elf_elfheader (abfd); 1201 1202 if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0) 1203 { 1204 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX; 1205 } 1206 else 1207 { 1208 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX; 1209 i_ehdrp->e_ident[EI_ABIVERSION] = 1; 1210 } 1211} 1212 1213/* Create function descriptor section (.opd). This section is called .opd 1214 because it contains "official procedure descriptors". The "official" 1215 refers to the fact that these descriptors are used when taking the address 1216 of a procedure, thus ensuring a unique address for each procedure. */ 1217 1218static bfd_boolean 1219get_opd (abfd, info, hppa_info) 1220 bfd *abfd; 1221 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1222 struct elf64_hppa_link_hash_table *hppa_info; 1223{ 1224 asection *opd; 1225 bfd *dynobj; 1226 1227 opd = hppa_info->opd_sec; 1228 if (!opd) 1229 { 1230 dynobj = hppa_info->root.dynobj; 1231 if (!dynobj) 1232 hppa_info->root.dynobj = dynobj = abfd; 1233 1234 opd = bfd_make_section_with_flags (dynobj, ".opd", 1235 (SEC_ALLOC 1236 | SEC_LOAD 1237 | SEC_HAS_CONTENTS 1238 | SEC_IN_MEMORY 1239 | SEC_LINKER_CREATED)); 1240 if (!opd 1241 || !bfd_set_section_alignment (abfd, opd, 3)) 1242 { 1243 BFD_ASSERT (0); 1244 return FALSE; 1245 } 1246 1247 hppa_info->opd_sec = opd; 1248 } 1249 1250 return TRUE; 1251} 1252 1253/* Create the PLT section. */ 1254 1255static bfd_boolean 1256get_plt (abfd, info, hppa_info) 1257 bfd *abfd; 1258 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1259 struct elf64_hppa_link_hash_table *hppa_info; 1260{ 1261 asection *plt; 1262 bfd *dynobj; 1263 1264 plt = hppa_info->plt_sec; 1265 if (!plt) 1266 { 1267 dynobj = hppa_info->root.dynobj; 1268 if (!dynobj) 1269 hppa_info->root.dynobj = dynobj = abfd; 1270 1271 plt = bfd_make_section_with_flags (dynobj, ".plt", 1272 (SEC_ALLOC 1273 | SEC_LOAD 1274 | SEC_HAS_CONTENTS 1275 | SEC_IN_MEMORY 1276 | SEC_LINKER_CREATED)); 1277 if (!plt 1278 || !bfd_set_section_alignment (abfd, plt, 3)) 1279 { 1280 BFD_ASSERT (0); 1281 return FALSE; 1282 } 1283 1284 hppa_info->plt_sec = plt; 1285 } 1286 1287 return TRUE; 1288} 1289 1290/* Create the DLT section. */ 1291 1292static bfd_boolean 1293get_dlt (abfd, info, hppa_info) 1294 bfd *abfd; 1295 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1296 struct elf64_hppa_link_hash_table *hppa_info; 1297{ 1298 asection *dlt; 1299 bfd *dynobj; 1300 1301 dlt = hppa_info->dlt_sec; 1302 if (!dlt) 1303 { 1304 dynobj = hppa_info->root.dynobj; 1305 if (!dynobj) 1306 hppa_info->root.dynobj = dynobj = abfd; 1307 1308 dlt = bfd_make_section_with_flags (dynobj, ".dlt", 1309 (SEC_ALLOC 1310 | SEC_LOAD 1311 | SEC_HAS_CONTENTS 1312 | SEC_IN_MEMORY 1313 | SEC_LINKER_CREATED)); 1314 if (!dlt 1315 || !bfd_set_section_alignment (abfd, dlt, 3)) 1316 { 1317 BFD_ASSERT (0); 1318 return FALSE; 1319 } 1320 1321 hppa_info->dlt_sec = dlt; 1322 } 1323 1324 return TRUE; 1325} 1326 1327/* Create the stubs section. */ 1328 1329static bfd_boolean 1330get_stub (abfd, info, hppa_info) 1331 bfd *abfd; 1332 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1333 struct elf64_hppa_link_hash_table *hppa_info; 1334{ 1335 asection *stub; 1336 bfd *dynobj; 1337 1338 stub = hppa_info->stub_sec; 1339 if (!stub) 1340 { 1341 dynobj = hppa_info->root.dynobj; 1342 if (!dynobj) 1343 hppa_info->root.dynobj = dynobj = abfd; 1344 1345 stub = bfd_make_section_with_flags (dynobj, ".stub", 1346 (SEC_ALLOC | SEC_LOAD 1347 | SEC_HAS_CONTENTS 1348 | SEC_IN_MEMORY 1349 | SEC_READONLY 1350 | SEC_LINKER_CREATED)); 1351 if (!stub 1352 || !bfd_set_section_alignment (abfd, stub, 3)) 1353 { 1354 BFD_ASSERT (0); 1355 return FALSE; 1356 } 1357 1358 hppa_info->stub_sec = stub; 1359 } 1360 1361 return TRUE; 1362} 1363 1364/* Create sections necessary for dynamic linking. This is only a rough 1365 cut and will likely change as we learn more about the somewhat 1366 unusual dynamic linking scheme HP uses. 1367 1368 .stub: 1369 Contains code to implement cross-space calls. The first time one 1370 of the stubs is used it will call into the dynamic linker, later 1371 calls will go straight to the target. 1372 1373 The only stub we support right now looks like 1374 1375 ldd OFFSET(%dp),%r1 1376 bve %r0(%r1) 1377 ldd OFFSET+8(%dp),%dp 1378 1379 Other stubs may be needed in the future. We may want the remove 1380 the break/nop instruction. It is only used right now to keep the 1381 offset of a .plt entry and a .stub entry in sync. 1382 1383 .dlt: 1384 This is what most people call the .got. HP used a different name. 1385 Losers. 1386 1387 .rela.dlt: 1388 Relocations for the DLT. 1389 1390 .plt: 1391 Function pointers as address,gp pairs. 1392 1393 .rela.plt: 1394 Should contain dynamic IPLT (and EPLT?) relocations. 1395 1396 .opd: 1397 FPTRS 1398 1399 .rela.opd: 1400 EPLT relocations for symbols exported from shared libraries. */ 1401 1402static bfd_boolean 1403elf64_hppa_create_dynamic_sections (abfd, info) 1404 bfd *abfd; 1405 struct bfd_link_info *info; 1406{ 1407 asection *s; 1408 1409 if (! get_stub (abfd, info, elf64_hppa_hash_table (info))) 1410 return FALSE; 1411 1412 if (! get_dlt (abfd, info, elf64_hppa_hash_table (info))) 1413 return FALSE; 1414 1415 if (! get_plt (abfd, info, elf64_hppa_hash_table (info))) 1416 return FALSE; 1417 1418 if (! get_opd (abfd, info, elf64_hppa_hash_table (info))) 1419 return FALSE; 1420 1421 s = bfd_make_section_with_flags (abfd, ".rela.dlt", 1422 (SEC_ALLOC | SEC_LOAD 1423 | SEC_HAS_CONTENTS 1424 | SEC_IN_MEMORY 1425 | SEC_READONLY 1426 | SEC_LINKER_CREATED)); 1427 if (s == NULL 1428 || !bfd_set_section_alignment (abfd, s, 3)) 1429 return FALSE; 1430 elf64_hppa_hash_table (info)->dlt_rel_sec = s; 1431 1432 s = bfd_make_section_with_flags (abfd, ".rela.plt", 1433 (SEC_ALLOC | SEC_LOAD 1434 | SEC_HAS_CONTENTS 1435 | SEC_IN_MEMORY 1436 | SEC_READONLY 1437 | SEC_LINKER_CREATED)); 1438 if (s == NULL 1439 || !bfd_set_section_alignment (abfd, s, 3)) 1440 return FALSE; 1441 elf64_hppa_hash_table (info)->plt_rel_sec = s; 1442 1443 s = bfd_make_section_with_flags (abfd, ".rela.data", 1444 (SEC_ALLOC | SEC_LOAD 1445 | SEC_HAS_CONTENTS 1446 | SEC_IN_MEMORY 1447 | SEC_READONLY 1448 | SEC_LINKER_CREATED)); 1449 if (s == NULL 1450 || !bfd_set_section_alignment (abfd, s, 3)) 1451 return FALSE; 1452 elf64_hppa_hash_table (info)->other_rel_sec = s; 1453 1454 s = bfd_make_section_with_flags (abfd, ".rela.opd", 1455 (SEC_ALLOC | SEC_LOAD 1456 | SEC_HAS_CONTENTS 1457 | SEC_IN_MEMORY 1458 | SEC_READONLY 1459 | SEC_LINKER_CREATED)); 1460 if (s == NULL 1461 || !bfd_set_section_alignment (abfd, s, 3)) 1462 return FALSE; 1463 elf64_hppa_hash_table (info)->opd_rel_sec = s; 1464 1465 return TRUE; 1466} 1467 1468/* Allocate dynamic relocations for those symbols that turned out 1469 to be dynamic. */ 1470 1471static bfd_boolean 1472allocate_dynrel_entries (dyn_h, data) 1473 struct elf64_hppa_dyn_hash_entry *dyn_h; 1474 PTR data; 1475{ 1476 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data; 1477 struct elf64_hppa_link_hash_table *hppa_info; 1478 struct elf64_hppa_dyn_reloc_entry *rent; 1479 bfd_boolean dynamic_symbol, shared; 1480 1481 hppa_info = elf64_hppa_hash_table (x->info); 1482 dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info); 1483 shared = x->info->shared; 1484 1485 /* We may need to allocate relocations for a non-dynamic symbol 1486 when creating a shared library. */ 1487 if (!dynamic_symbol && !shared) 1488 return TRUE; 1489 1490 /* Take care of the normal data relocations. */ 1491 1492 for (rent = dyn_h->reloc_entries; rent; rent = rent->next) 1493 { 1494 /* Allocate one iff we are building a shared library, the relocation 1495 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */ 1496 if (!shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd) 1497 continue; 1498 1499 hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela); 1500 1501 /* Make sure this symbol gets into the dynamic symbol table if it is 1502 not already recorded. ?!? This should not be in the loop since 1503 the symbol need only be added once. */ 1504 if (dyn_h->h == 0 1505 || (dyn_h->h->dynindx == -1 && dyn_h->h->type != STT_PARISC_MILLI)) 1506 if (!bfd_elf_link_record_local_dynamic_symbol 1507 (x->info, rent->sec->owner, dyn_h->sym_indx)) 1508 return FALSE; 1509 } 1510 1511 /* Take care of the GOT and PLT relocations. */ 1512 1513 if ((dynamic_symbol || shared) && dyn_h->want_dlt) 1514 hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela); 1515 1516 /* If we are building a shared library, then every symbol that has an 1517 opd entry will need an EPLT relocation to relocate the symbol's address 1518 and __gp value based on the runtime load address. */ 1519 if (shared && dyn_h->want_opd) 1520 hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela); 1521 1522 if (dyn_h->want_plt && dynamic_symbol) 1523 { 1524 bfd_size_type t = 0; 1525 1526 /* Dynamic symbols get one IPLT relocation. Local symbols in 1527 shared libraries get two REL relocations. Local symbols in 1528 main applications get nothing. */ 1529 if (dynamic_symbol) 1530 t = sizeof (Elf64_External_Rela); 1531 else if (shared) 1532 t = 2 * sizeof (Elf64_External_Rela); 1533 1534 hppa_info->plt_rel_sec->size += t; 1535 } 1536 1537 return TRUE; 1538} 1539 1540/* Adjust a symbol defined by a dynamic object and referenced by a 1541 regular object. */ 1542 1543static bfd_boolean 1544elf64_hppa_adjust_dynamic_symbol (info, h) 1545 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1546 struct elf_link_hash_entry *h; 1547{ 1548 /* ??? Undefined symbols with PLT entries should be re-defined 1549 to be the PLT entry. */ 1550 1551 /* If this is a weak symbol, and there is a real definition, the 1552 processor independent code will have arranged for us to see the 1553 real definition first, and we can just use the same value. */ 1554 if (h->u.weakdef != NULL) 1555 { 1556 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1557 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1558 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1559 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1560 return TRUE; 1561 } 1562 1563 /* If this is a reference to a symbol defined by a dynamic object which 1564 is not a function, we might allocate the symbol in our .dynbss section 1565 and allocate a COPY dynamic relocation. 1566 1567 But PA64 code is canonically PIC, so as a rule we can avoid this sort 1568 of hackery. */ 1569 1570 return TRUE; 1571} 1572 1573/* This function is called via elf_link_hash_traverse to mark millicode 1574 symbols with a dynindx of -1 and to remove the string table reference 1575 from the dynamic symbol table. If the symbol is not a millicode symbol, 1576 elf64_hppa_mark_exported_functions is called. */ 1577 1578static bfd_boolean 1579elf64_hppa_mark_milli_and_exported_functions (h, data) 1580 struct elf_link_hash_entry *h; 1581 PTR data; 1582{ 1583 struct bfd_link_info *info = (struct bfd_link_info *)data; 1584 struct elf_link_hash_entry *elf = h; 1585 1586 if (elf->root.type == bfd_link_hash_warning) 1587 elf = (struct elf_link_hash_entry *) elf->root.u.i.link; 1588 1589 if (elf->type == STT_PARISC_MILLI) 1590 { 1591 if (elf->dynindx != -1) 1592 { 1593 elf->dynindx = -1; 1594 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1595 elf->dynstr_index); 1596 } 1597 return TRUE; 1598 } 1599 1600 return elf64_hppa_mark_exported_functions (h, data); 1601} 1602 1603/* Set the final sizes of the dynamic sections and allocate memory for 1604 the contents of our special sections. */ 1605 1606static bfd_boolean 1607elf64_hppa_size_dynamic_sections (output_bfd, info) 1608 bfd *output_bfd; 1609 struct bfd_link_info *info; 1610{ 1611 bfd *dynobj; 1612 asection *s; 1613 bfd_boolean plt; 1614 bfd_boolean relocs; 1615 bfd_boolean reltext; 1616 struct elf64_hppa_allocate_data data; 1617 struct elf64_hppa_link_hash_table *hppa_info; 1618 1619 hppa_info = elf64_hppa_hash_table (info); 1620 1621 dynobj = elf_hash_table (info)->dynobj; 1622 BFD_ASSERT (dynobj != NULL); 1623 1624 /* Mark each function this program exports so that we will allocate 1625 space in the .opd section for each function's FPTR. If we are 1626 creating dynamic sections, change the dynamic index of millicode 1627 symbols to -1 and remove them from the string table for .dynstr. 1628 1629 We have to traverse the main linker hash table since we have to 1630 find functions which may not have been mentioned in any relocs. */ 1631 elf_link_hash_traverse (elf_hash_table (info), 1632 (elf_hash_table (info)->dynamic_sections_created 1633 ? elf64_hppa_mark_milli_and_exported_functions 1634 : elf64_hppa_mark_exported_functions), 1635 info); 1636 1637 if (elf_hash_table (info)->dynamic_sections_created) 1638 { 1639 /* Set the contents of the .interp section to the interpreter. */ 1640 if (info->executable) 1641 { 1642 s = bfd_get_section_by_name (dynobj, ".interp"); 1643 BFD_ASSERT (s != NULL); 1644 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 1645 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1646 } 1647 } 1648 else 1649 { 1650 /* We may have created entries in the .rela.got section. 1651 However, if we are not creating the dynamic sections, we will 1652 not actually use these entries. Reset the size of .rela.dlt, 1653 which will cause it to get stripped from the output file 1654 below. */ 1655 s = bfd_get_section_by_name (dynobj, ".rela.dlt"); 1656 if (s != NULL) 1657 s->size = 0; 1658 } 1659 1660 /* Allocate the GOT entries. */ 1661 1662 data.info = info; 1663 if (elf64_hppa_hash_table (info)->dlt_sec) 1664 { 1665 data.ofs = 0x0; 1666 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 1667 allocate_global_data_dlt, &data); 1668 hppa_info->dlt_sec->size = data.ofs; 1669 1670 data.ofs = 0x0; 1671 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 1672 allocate_global_data_plt, &data); 1673 hppa_info->plt_sec->size = data.ofs; 1674 1675 data.ofs = 0x0; 1676 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 1677 allocate_global_data_stub, &data); 1678 hppa_info->stub_sec->size = data.ofs; 1679 } 1680 1681 /* Allocate space for entries in the .opd section. */ 1682 if (elf64_hppa_hash_table (info)->opd_sec) 1683 { 1684 data.ofs = 0; 1685 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 1686 allocate_global_data_opd, &data); 1687 hppa_info->opd_sec->size = data.ofs; 1688 } 1689 1690 /* Now allocate space for dynamic relocations, if necessary. */ 1691 if (hppa_info->root.dynamic_sections_created) 1692 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 1693 allocate_dynrel_entries, &data); 1694 1695 /* The sizes of all the sections are set. Allocate memory for them. */ 1696 plt = FALSE; 1697 relocs = FALSE; 1698 reltext = FALSE; 1699 for (s = dynobj->sections; s != NULL; s = s->next) 1700 { 1701 const char *name; 1702 1703 if ((s->flags & SEC_LINKER_CREATED) == 0) 1704 continue; 1705 1706 /* It's OK to base decisions on the section name, because none 1707 of the dynobj section names depend upon the input files. */ 1708 name = bfd_get_section_name (dynobj, s); 1709 1710 if (strcmp (name, ".plt") == 0) 1711 { 1712 /* Remember whether there is a PLT. */ 1713 plt = s->size != 0; 1714 } 1715 else if (strcmp (name, ".opd") == 0 1716 || CONST_STRNEQ (name, ".dlt") 1717 || strcmp (name, ".stub") == 0 1718 || strcmp (name, ".got") == 0) 1719 { 1720 /* Strip this section if we don't need it; see the comment below. */ 1721 } 1722 else if (CONST_STRNEQ (name, ".rela")) 1723 { 1724 if (s->size != 0) 1725 { 1726 asection *target; 1727 1728 /* Remember whether there are any reloc sections other 1729 than .rela.plt. */ 1730 if (strcmp (name, ".rela.plt") != 0) 1731 { 1732 const char *outname; 1733 1734 relocs = TRUE; 1735 1736 /* If this relocation section applies to a read only 1737 section, then we probably need a DT_TEXTREL 1738 entry. The entries in the .rela.plt section 1739 really apply to the .got section, which we 1740 created ourselves and so know is not readonly. */ 1741 outname = bfd_get_section_name (output_bfd, 1742 s->output_section); 1743 target = bfd_get_section_by_name (output_bfd, outname + 4); 1744 if (target != NULL 1745 && (target->flags & SEC_READONLY) != 0 1746 && (target->flags & SEC_ALLOC) != 0) 1747 reltext = TRUE; 1748 } 1749 1750 /* We use the reloc_count field as a counter if we need 1751 to copy relocs into the output file. */ 1752 s->reloc_count = 0; 1753 } 1754 } 1755 else 1756 { 1757 /* It's not one of our sections, so don't allocate space. */ 1758 continue; 1759 } 1760 1761 if (s->size == 0) 1762 { 1763 /* If we don't need this section, strip it from the 1764 output file. This is mostly to handle .rela.bss and 1765 .rela.plt. We must create both sections in 1766 create_dynamic_sections, because they must be created 1767 before the linker maps input sections to output 1768 sections. The linker does that before 1769 adjust_dynamic_symbol is called, and it is that 1770 function which decides whether anything needs to go 1771 into these sections. */ 1772 s->flags |= SEC_EXCLUDE; 1773 continue; 1774 } 1775 1776 if ((s->flags & SEC_HAS_CONTENTS) == 0) 1777 continue; 1778 1779 /* Allocate memory for the section contents if it has not 1780 been allocated already. We use bfd_zalloc here in case 1781 unused entries are not reclaimed before the section's 1782 contents are written out. This should not happen, but this 1783 way if it does, we get a R_PARISC_NONE reloc instead of 1784 garbage. */ 1785 if (s->contents == NULL) 1786 { 1787 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 1788 if (s->contents == NULL) 1789 return FALSE; 1790 } 1791 } 1792 1793 if (elf_hash_table (info)->dynamic_sections_created) 1794 { 1795 /* Always create a DT_PLTGOT. It actually has nothing to do with 1796 the PLT, it is how we communicate the __gp value of a load 1797 module to the dynamic linker. */ 1798#define add_dynamic_entry(TAG, VAL) \ 1799 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1800 1801 if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0) 1802 || !add_dynamic_entry (DT_PLTGOT, 0)) 1803 return FALSE; 1804 1805 /* Add some entries to the .dynamic section. We fill in the 1806 values later, in elf64_hppa_finish_dynamic_sections, but we 1807 must add the entries now so that we get the correct size for 1808 the .dynamic section. The DT_DEBUG entry is filled in by the 1809 dynamic linker and used by the debugger. */ 1810 if (! info->shared) 1811 { 1812 if (!add_dynamic_entry (DT_DEBUG, 0) 1813 || !add_dynamic_entry (DT_HP_DLD_HOOK, 0) 1814 || !add_dynamic_entry (DT_HP_LOAD_MAP, 0)) 1815 return FALSE; 1816 } 1817 1818 /* Force DT_FLAGS to always be set. 1819 Required by HPUX 11.00 patch PHSS_26559. */ 1820 if (!add_dynamic_entry (DT_FLAGS, (info)->flags)) 1821 return FALSE; 1822 1823 if (plt) 1824 { 1825 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 1826 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1827 || !add_dynamic_entry (DT_JMPREL, 0)) 1828 return FALSE; 1829 } 1830 1831 if (relocs) 1832 { 1833 if (!add_dynamic_entry (DT_RELA, 0) 1834 || !add_dynamic_entry (DT_RELASZ, 0) 1835 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 1836 return FALSE; 1837 } 1838 1839 if (reltext) 1840 { 1841 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1842 return FALSE; 1843 info->flags |= DF_TEXTREL; 1844 } 1845 } 1846#undef add_dynamic_entry 1847 1848 return TRUE; 1849} 1850 1851/* Called after we have output the symbol into the dynamic symbol 1852 table, but before we output the symbol into the normal symbol 1853 table. 1854 1855 For some symbols we had to change their address when outputting 1856 the dynamic symbol table. We undo that change here so that 1857 the symbols have their expected value in the normal symbol 1858 table. Ick. */ 1859 1860static bfd_boolean 1861elf64_hppa_link_output_symbol_hook (info, name, sym, input_sec, h) 1862 struct bfd_link_info *info; 1863 const char *name; 1864 Elf_Internal_Sym *sym; 1865 asection *input_sec ATTRIBUTE_UNUSED; 1866 struct elf_link_hash_entry *h; 1867{ 1868 struct elf64_hppa_link_hash_table *hppa_info; 1869 struct elf64_hppa_dyn_hash_entry *dyn_h; 1870 1871 /* We may be called with the file symbol or section symbols. 1872 They never need munging, so it is safe to ignore them. */ 1873 if (!name) 1874 return TRUE; 1875 1876 /* Get the PA dyn_symbol (if any) associated with NAME. */ 1877 hppa_info = elf64_hppa_hash_table (info); 1878 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table, 1879 name, FALSE, FALSE); 1880 if (!dyn_h || dyn_h->h != h) 1881 return TRUE; 1882 1883 /* Function symbols for which we created .opd entries *may* have been 1884 munged by finish_dynamic_symbol and have to be un-munged here. 1885 1886 Note that finish_dynamic_symbol sometimes turns dynamic symbols 1887 into non-dynamic ones, so we initialize st_shndx to -1 in 1888 mark_exported_functions and check to see if it was overwritten 1889 here instead of just checking dyn_h->h->dynindx. */ 1890 if (dyn_h->want_opd && dyn_h->st_shndx != -1) 1891 { 1892 /* Restore the saved value and section index. */ 1893 sym->st_value = dyn_h->st_value; 1894 sym->st_shndx = dyn_h->st_shndx; 1895 } 1896 1897 return TRUE; 1898} 1899 1900/* Finish up dynamic symbol handling. We set the contents of various 1901 dynamic sections here. */ 1902 1903static bfd_boolean 1904elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym) 1905 bfd *output_bfd; 1906 struct bfd_link_info *info; 1907 struct elf_link_hash_entry *h; 1908 Elf_Internal_Sym *sym; 1909{ 1910 asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel; 1911 struct elf64_hppa_link_hash_table *hppa_info; 1912 struct elf64_hppa_dyn_hash_entry *dyn_h; 1913 1914 hppa_info = elf64_hppa_hash_table (info); 1915 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table, 1916 h->root.root.string, FALSE, FALSE); 1917 1918 stub = hppa_info->stub_sec; 1919 splt = hppa_info->plt_sec; 1920 sdlt = hppa_info->dlt_sec; 1921 sopd = hppa_info->opd_sec; 1922 spltrel = hppa_info->plt_rel_sec; 1923 sdltrel = hppa_info->dlt_rel_sec; 1924 1925 /* Incredible. It is actually necessary to NOT use the symbol's real 1926 value when building the dynamic symbol table for a shared library. 1927 At least for symbols that refer to functions. 1928 1929 We will store a new value and section index into the symbol long 1930 enough to output it into the dynamic symbol table, then we restore 1931 the original values (in elf64_hppa_link_output_symbol_hook). */ 1932 if (dyn_h && dyn_h->want_opd) 1933 { 1934 BFD_ASSERT (sopd != NULL); 1935 1936 /* Save away the original value and section index so that we 1937 can restore them later. */ 1938 dyn_h->st_value = sym->st_value; 1939 dyn_h->st_shndx = sym->st_shndx; 1940 1941 /* For the dynamic symbol table entry, we want the value to be 1942 address of this symbol's entry within the .opd section. */ 1943 sym->st_value = (dyn_h->opd_offset 1944 + sopd->output_offset 1945 + sopd->output_section->vma); 1946 sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 1947 sopd->output_section); 1948 } 1949 1950 /* Initialize a .plt entry if requested. */ 1951 if (dyn_h && dyn_h->want_plt 1952 && elf64_hppa_dynamic_symbol_p (dyn_h->h, info)) 1953 { 1954 bfd_vma value; 1955 Elf_Internal_Rela rel; 1956 bfd_byte *loc; 1957 1958 BFD_ASSERT (splt != NULL && spltrel != NULL); 1959 1960 /* We do not actually care about the value in the PLT entry 1961 if we are creating a shared library and the symbol is 1962 still undefined, we create a dynamic relocation to fill 1963 in the correct value. */ 1964 if (info->shared && h->root.type == bfd_link_hash_undefined) 1965 value = 0; 1966 else 1967 value = (h->root.u.def.value + h->root.u.def.section->vma); 1968 1969 /* Fill in the entry in the procedure linkage table. 1970 1971 The format of a plt entry is 1972 <funcaddr> <__gp>. 1973 1974 plt_offset is the offset within the PLT section at which to 1975 install the PLT entry. 1976 1977 We are modifying the in-memory PLT contents here, so we do not add 1978 in the output_offset of the PLT section. */ 1979 1980 bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset); 1981 value = _bfd_get_gp_value (splt->output_section->owner); 1982 bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset + 0x8); 1983 1984 /* Create a dynamic IPLT relocation for this entry. 1985 1986 We are creating a relocation in the output file's PLT section, 1987 which is included within the DLT secton. So we do need to include 1988 the PLT's output_offset in the computation of the relocation's 1989 address. */ 1990 rel.r_offset = (dyn_h->plt_offset + splt->output_offset 1991 + splt->output_section->vma); 1992 rel.r_info = ELF64_R_INFO (h->dynindx, R_PARISC_IPLT); 1993 rel.r_addend = 0; 1994 1995 loc = spltrel->contents; 1996 loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela); 1997 bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc); 1998 } 1999 2000 /* Initialize an external call stub entry if requested. */ 2001 if (dyn_h && dyn_h->want_stub 2002 && elf64_hppa_dynamic_symbol_p (dyn_h->h, info)) 2003 { 2004 bfd_vma value; 2005 int insn; 2006 unsigned int max_offset; 2007 2008 BFD_ASSERT (stub != NULL); 2009 2010 /* Install the generic stub template. 2011 2012 We are modifying the contents of the stub section, so we do not 2013 need to include the stub section's output_offset here. */ 2014 memcpy (stub->contents + dyn_h->stub_offset, plt_stub, sizeof (plt_stub)); 2015 2016 /* Fix up the first ldd instruction. 2017 2018 We are modifying the contents of the STUB section in memory, 2019 so we do not need to include its output offset in this computation. 2020 2021 Note the plt_offset value is the value of the PLT entry relative to 2022 the start of the PLT section. These instructions will reference 2023 data relative to the value of __gp, which may not necessarily have 2024 the same address as the start of the PLT section. 2025 2026 gp_offset contains the offset of __gp within the PLT section. */ 2027 value = dyn_h->plt_offset - hppa_info->gp_offset; 2028 2029 insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset); 2030 if (output_bfd->arch_info->mach >= 25) 2031 { 2032 /* Wide mode allows 16 bit offsets. */ 2033 max_offset = 32768; 2034 insn &= ~ 0xfff1; 2035 insn |= re_assemble_16 ((int) value); 2036 } 2037 else 2038 { 2039 max_offset = 8192; 2040 insn &= ~ 0x3ff1; 2041 insn |= re_assemble_14 ((int) value); 2042 } 2043 2044 if ((value & 7) || value + max_offset >= 2*max_offset - 8) 2045 { 2046 (*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"), 2047 dyn_h->root.string, 2048 (long) value); 2049 return FALSE; 2050 } 2051 2052 bfd_put_32 (stub->owner, (bfd_vma) insn, 2053 stub->contents + dyn_h->stub_offset); 2054 2055 /* Fix up the second ldd instruction. */ 2056 value += 8; 2057 insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8); 2058 if (output_bfd->arch_info->mach >= 25) 2059 { 2060 insn &= ~ 0xfff1; 2061 insn |= re_assemble_16 ((int) value); 2062 } 2063 else 2064 { 2065 insn &= ~ 0x3ff1; 2066 insn |= re_assemble_14 ((int) value); 2067 } 2068 bfd_put_32 (stub->owner, (bfd_vma) insn, 2069 stub->contents + dyn_h->stub_offset + 8); 2070 } 2071 2072 return TRUE; 2073} 2074 2075/* The .opd section contains FPTRs for each function this file 2076 exports. Initialize the FPTR entries. */ 2077 2078static bfd_boolean 2079elf64_hppa_finalize_opd (dyn_h, data) 2080 struct elf64_hppa_dyn_hash_entry *dyn_h; 2081 PTR data; 2082{ 2083 struct bfd_link_info *info = (struct bfd_link_info *)data; 2084 struct elf64_hppa_link_hash_table *hppa_info; 2085 struct elf_link_hash_entry *h = dyn_h ? dyn_h->h : NULL; 2086 asection *sopd; 2087 asection *sopdrel; 2088 2089 hppa_info = elf64_hppa_hash_table (info); 2090 sopd = hppa_info->opd_sec; 2091 sopdrel = hppa_info->opd_rel_sec; 2092 2093 if (h && dyn_h->want_opd) 2094 { 2095 bfd_vma value; 2096 2097 /* The first two words of an .opd entry are zero. 2098 2099 We are modifying the contents of the OPD section in memory, so we 2100 do not need to include its output offset in this computation. */ 2101 memset (sopd->contents + dyn_h->opd_offset, 0, 16); 2102 2103 value = (h->root.u.def.value 2104 + h->root.u.def.section->output_section->vma 2105 + h->root.u.def.section->output_offset); 2106 2107 /* The next word is the address of the function. */ 2108 bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 16); 2109 2110 /* The last word is our local __gp value. */ 2111 value = _bfd_get_gp_value (sopd->output_section->owner); 2112 bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 24); 2113 } 2114 2115 /* If we are generating a shared library, we must generate EPLT relocations 2116 for each entry in the .opd, even for static functions (they may have 2117 had their address taken). */ 2118 if (info->shared && dyn_h && dyn_h->want_opd) 2119 { 2120 Elf_Internal_Rela rel; 2121 bfd_byte *loc; 2122 int dynindx; 2123 2124 /* We may need to do a relocation against a local symbol, in 2125 which case we have to look up it's dynamic symbol index off 2126 the local symbol hash table. */ 2127 if (h && h->dynindx != -1) 2128 dynindx = h->dynindx; 2129 else 2130 dynindx 2131 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner, 2132 dyn_h->sym_indx); 2133 2134 /* The offset of this relocation is the absolute address of the 2135 .opd entry for this symbol. */ 2136 rel.r_offset = (dyn_h->opd_offset + sopd->output_offset 2137 + sopd->output_section->vma); 2138 2139 /* If H is non-null, then we have an external symbol. 2140 2141 It is imperative that we use a different dynamic symbol for the 2142 EPLT relocation if the symbol has global scope. 2143 2144 In the dynamic symbol table, the function symbol will have a value 2145 which is address of the function's .opd entry. 2146 2147 Thus, we can not use that dynamic symbol for the EPLT relocation 2148 (if we did, the data in the .opd would reference itself rather 2149 than the actual address of the function). Instead we have to use 2150 a new dynamic symbol which has the same value as the original global 2151 function symbol. 2152 2153 We prefix the original symbol with a "." and use the new symbol in 2154 the EPLT relocation. This new symbol has already been recorded in 2155 the symbol table, we just have to look it up and use it. 2156 2157 We do not have such problems with static functions because we do 2158 not make their addresses in the dynamic symbol table point to 2159 the .opd entry. Ultimately this should be safe since a static 2160 function can not be directly referenced outside of its shared 2161 library. 2162 2163 We do have to play similar games for FPTR relocations in shared 2164 libraries, including those for static symbols. See the FPTR 2165 handling in elf64_hppa_finalize_dynreloc. */ 2166 if (h) 2167 { 2168 char *new_name; 2169 struct elf_link_hash_entry *nh; 2170 2171 new_name = alloca (strlen (h->root.root.string) + 2); 2172 new_name[0] = '.'; 2173 strcpy (new_name + 1, h->root.root.string); 2174 2175 nh = elf_link_hash_lookup (elf_hash_table (info), 2176 new_name, FALSE, FALSE, FALSE); 2177 2178 /* All we really want from the new symbol is its dynamic 2179 symbol index. */ 2180 dynindx = nh->dynindx; 2181 } 2182 2183 rel.r_addend = 0; 2184 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT); 2185 2186 loc = sopdrel->contents; 2187 loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela); 2188 bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc); 2189 } 2190 return TRUE; 2191} 2192 2193/* The .dlt section contains addresses for items referenced through the 2194 dlt. Note that we can have a DLTIND relocation for a local symbol, thus 2195 we can not depend on finish_dynamic_symbol to initialize the .dlt. */ 2196 2197static bfd_boolean 2198elf64_hppa_finalize_dlt (dyn_h, data) 2199 struct elf64_hppa_dyn_hash_entry *dyn_h; 2200 PTR data; 2201{ 2202 struct bfd_link_info *info = (struct bfd_link_info *)data; 2203 struct elf64_hppa_link_hash_table *hppa_info; 2204 asection *sdlt, *sdltrel; 2205 struct elf_link_hash_entry *h = dyn_h ? dyn_h->h : NULL; 2206 2207 hppa_info = elf64_hppa_hash_table (info); 2208 2209 sdlt = hppa_info->dlt_sec; 2210 sdltrel = hppa_info->dlt_rel_sec; 2211 2212 /* H/DYN_H may refer to a local variable and we know it's 2213 address, so there is no need to create a relocation. Just install 2214 the proper value into the DLT, note this shortcut can not be 2215 skipped when building a shared library. */ 2216 if (! info->shared && h && dyn_h->want_dlt) 2217 { 2218 bfd_vma value; 2219 2220 /* If we had an LTOFF_FPTR style relocation we want the DLT entry 2221 to point to the FPTR entry in the .opd section. 2222 2223 We include the OPD's output offset in this computation as 2224 we are referring to an absolute address in the resulting 2225 object file. */ 2226 if (dyn_h->want_opd) 2227 { 2228 value = (dyn_h->opd_offset 2229 + hppa_info->opd_sec->output_offset 2230 + hppa_info->opd_sec->output_section->vma); 2231 } 2232 else if ((h->root.type == bfd_link_hash_defined 2233 || h->root.type == bfd_link_hash_defweak) 2234 && h->root.u.def.section) 2235 { 2236 value = h->root.u.def.value + h->root.u.def.section->output_offset; 2237 if (h->root.u.def.section->output_section) 2238 value += h->root.u.def.section->output_section->vma; 2239 else 2240 value += h->root.u.def.section->vma; 2241 } 2242 else 2243 /* We have an undefined function reference. */ 2244 value = 0; 2245 2246 /* We do not need to include the output offset of the DLT section 2247 here because we are modifying the in-memory contents. */ 2248 bfd_put_64 (sdlt->owner, value, sdlt->contents + dyn_h->dlt_offset); 2249 } 2250 2251 /* Create a relocation for the DLT entry associated with this symbol. 2252 When building a shared library the symbol does not have to be dynamic. */ 2253 if (dyn_h->want_dlt 2254 && (elf64_hppa_dynamic_symbol_p (dyn_h->h, info) || info->shared)) 2255 { 2256 Elf_Internal_Rela rel; 2257 bfd_byte *loc; 2258 int dynindx; 2259 2260 /* We may need to do a relocation against a local symbol, in 2261 which case we have to look up it's dynamic symbol index off 2262 the local symbol hash table. */ 2263 if (h && h->dynindx != -1) 2264 dynindx = h->dynindx; 2265 else 2266 dynindx 2267 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner, 2268 dyn_h->sym_indx); 2269 2270 /* Create a dynamic relocation for this entry. Do include the output 2271 offset of the DLT entry since we need an absolute address in the 2272 resulting object file. */ 2273 rel.r_offset = (dyn_h->dlt_offset + sdlt->output_offset 2274 + sdlt->output_section->vma); 2275 if (h && h->type == STT_FUNC) 2276 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64); 2277 else 2278 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64); 2279 rel.r_addend = 0; 2280 2281 loc = sdltrel->contents; 2282 loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela); 2283 bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc); 2284 } 2285 return TRUE; 2286} 2287 2288/* Finalize the dynamic relocations. Specifically the FPTR relocations 2289 for dynamic functions used to initialize static data. */ 2290 2291static bfd_boolean 2292elf64_hppa_finalize_dynreloc (dyn_h, data) 2293 struct elf64_hppa_dyn_hash_entry *dyn_h; 2294 PTR data; 2295{ 2296 struct bfd_link_info *info = (struct bfd_link_info *)data; 2297 struct elf64_hppa_link_hash_table *hppa_info; 2298 struct elf_link_hash_entry *h; 2299 int dynamic_symbol; 2300 2301 dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, info); 2302 2303 if (!dynamic_symbol && !info->shared) 2304 return TRUE; 2305 2306 if (dyn_h->reloc_entries) 2307 { 2308 struct elf64_hppa_dyn_reloc_entry *rent; 2309 int dynindx; 2310 2311 hppa_info = elf64_hppa_hash_table (info); 2312 h = dyn_h->h; 2313 2314 /* We may need to do a relocation against a local symbol, in 2315 which case we have to look up it's dynamic symbol index off 2316 the local symbol hash table. */ 2317 if (h && h->dynindx != -1) 2318 dynindx = h->dynindx; 2319 else 2320 dynindx 2321 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner, 2322 dyn_h->sym_indx); 2323 2324 for (rent = dyn_h->reloc_entries; rent; rent = rent->next) 2325 { 2326 Elf_Internal_Rela rel; 2327 bfd_byte *loc; 2328 2329 /* Allocate one iff we are building a shared library, the relocation 2330 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */ 2331 if (!info->shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd) 2332 continue; 2333 2334 /* Create a dynamic relocation for this entry. 2335 2336 We need the output offset for the reloc's section because 2337 we are creating an absolute address in the resulting object 2338 file. */ 2339 rel.r_offset = (rent->offset + rent->sec->output_offset 2340 + rent->sec->output_section->vma); 2341 2342 /* An FPTR64 relocation implies that we took the address of 2343 a function and that the function has an entry in the .opd 2344 section. We want the FPTR64 relocation to reference the 2345 entry in .opd. 2346 2347 We could munge the symbol value in the dynamic symbol table 2348 (in fact we already do for functions with global scope) to point 2349 to the .opd entry. Then we could use that dynamic symbol in 2350 this relocation. 2351 2352 Or we could do something sensible, not munge the symbol's 2353 address and instead just use a different symbol to reference 2354 the .opd entry. At least that seems sensible until you 2355 realize there's no local dynamic symbols we can use for that 2356 purpose. Thus the hair in the check_relocs routine. 2357 2358 We use a section symbol recorded by check_relocs as the 2359 base symbol for the relocation. The addend is the difference 2360 between the section symbol and the address of the .opd entry. */ 2361 if (info->shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd) 2362 { 2363 bfd_vma value, value2; 2364 2365 /* First compute the address of the opd entry for this symbol. */ 2366 value = (dyn_h->opd_offset 2367 + hppa_info->opd_sec->output_section->vma 2368 + hppa_info->opd_sec->output_offset); 2369 2370 /* Compute the value of the start of the section with 2371 the relocation. */ 2372 value2 = (rent->sec->output_section->vma 2373 + rent->sec->output_offset); 2374 2375 /* Compute the difference between the start of the section 2376 with the relocation and the opd entry. */ 2377 value -= value2; 2378 2379 /* The result becomes the addend of the relocation. */ 2380 rel.r_addend = value; 2381 2382 /* The section symbol becomes the symbol for the dynamic 2383 relocation. */ 2384 dynindx 2385 = _bfd_elf_link_lookup_local_dynindx (info, 2386 rent->sec->owner, 2387 rent->sec_symndx); 2388 } 2389 else 2390 rel.r_addend = rent->addend; 2391 2392 rel.r_info = ELF64_R_INFO (dynindx, rent->type); 2393 2394 loc = hppa_info->other_rel_sec->contents; 2395 loc += (hppa_info->other_rel_sec->reloc_count++ 2396 * sizeof (Elf64_External_Rela)); 2397 bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner, 2398 &rel, loc); 2399 } 2400 } 2401 2402 return TRUE; 2403} 2404 2405/* Used to decide how to sort relocs in an optimal manner for the 2406 dynamic linker, before writing them out. */ 2407 2408static enum elf_reloc_type_class 2409elf64_hppa_reloc_type_class (rela) 2410 const Elf_Internal_Rela *rela; 2411{ 2412 if (ELF64_R_SYM (rela->r_info) == 0) 2413 return reloc_class_relative; 2414 2415 switch ((int) ELF64_R_TYPE (rela->r_info)) 2416 { 2417 case R_PARISC_IPLT: 2418 return reloc_class_plt; 2419 case R_PARISC_COPY: 2420 return reloc_class_copy; 2421 default: 2422 return reloc_class_normal; 2423 } 2424} 2425 2426/* Finish up the dynamic sections. */ 2427 2428static bfd_boolean 2429elf64_hppa_finish_dynamic_sections (output_bfd, info) 2430 bfd *output_bfd; 2431 struct bfd_link_info *info; 2432{ 2433 bfd *dynobj; 2434 asection *sdyn; 2435 struct elf64_hppa_link_hash_table *hppa_info; 2436 2437 hppa_info = elf64_hppa_hash_table (info); 2438 2439 /* Finalize the contents of the .opd section. */ 2440 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 2441 elf64_hppa_finalize_opd, 2442 info); 2443 2444 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 2445 elf64_hppa_finalize_dynreloc, 2446 info); 2447 2448 /* Finalize the contents of the .dlt section. */ 2449 dynobj = elf_hash_table (info)->dynobj; 2450 /* Finalize the contents of the .dlt section. */ 2451 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table, 2452 elf64_hppa_finalize_dlt, 2453 info); 2454 2455 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2456 2457 if (elf_hash_table (info)->dynamic_sections_created) 2458 { 2459 Elf64_External_Dyn *dyncon, *dynconend; 2460 2461 BFD_ASSERT (sdyn != NULL); 2462 2463 dyncon = (Elf64_External_Dyn *) sdyn->contents; 2464 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 2465 for (; dyncon < dynconend; dyncon++) 2466 { 2467 Elf_Internal_Dyn dyn; 2468 asection *s; 2469 2470 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 2471 2472 switch (dyn.d_tag) 2473 { 2474 default: 2475 break; 2476 2477 case DT_HP_LOAD_MAP: 2478 /* Compute the absolute address of 16byte scratchpad area 2479 for the dynamic linker. 2480 2481 By convention the linker script will allocate the scratchpad 2482 area at the start of the .data section. So all we have to 2483 to is find the start of the .data section. */ 2484 s = bfd_get_section_by_name (output_bfd, ".data"); 2485 dyn.d_un.d_ptr = s->vma; 2486 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2487 break; 2488 2489 case DT_PLTGOT: 2490 /* HP's use PLTGOT to set the GOT register. */ 2491 dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd); 2492 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2493 break; 2494 2495 case DT_JMPREL: 2496 s = hppa_info->plt_rel_sec; 2497 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2498 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2499 break; 2500 2501 case DT_PLTRELSZ: 2502 s = hppa_info->plt_rel_sec; 2503 dyn.d_un.d_val = s->size; 2504 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2505 break; 2506 2507 case DT_RELA: 2508 s = hppa_info->other_rel_sec; 2509 if (! s || ! s->size) 2510 s = hppa_info->dlt_rel_sec; 2511 if (! s || ! s->size) 2512 s = hppa_info->opd_rel_sec; 2513 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2514 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2515 break; 2516 2517 case DT_RELASZ: 2518 s = hppa_info->other_rel_sec; 2519 dyn.d_un.d_val = s->size; 2520 s = hppa_info->dlt_rel_sec; 2521 dyn.d_un.d_val += s->size; 2522 s = hppa_info->opd_rel_sec; 2523 dyn.d_un.d_val += s->size; 2524 /* There is some question about whether or not the size of 2525 the PLT relocs should be included here. HP's tools do 2526 it, so we'll emulate them. */ 2527 s = hppa_info->plt_rel_sec; 2528 dyn.d_un.d_val += s->size; 2529 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2530 break; 2531 2532 } 2533 } 2534 } 2535 2536 return TRUE; 2537} 2538 2539/* Support for core dump NOTE sections. */ 2540 2541static bfd_boolean 2542elf64_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2543{ 2544 int offset; 2545 size_t size; 2546 2547 switch (note->descsz) 2548 { 2549 default: 2550 return FALSE; 2551 2552 case 760: /* Linux/hppa */ 2553 /* pr_cursig */ 2554 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 2555 2556 /* pr_pid */ 2557 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32); 2558 2559 /* pr_reg */ 2560 offset = 112; 2561 size = 640; 2562 2563 break; 2564 } 2565 2566 /* Make a ".reg/999" section. */ 2567 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2568 size, note->descpos + offset); 2569} 2570 2571static bfd_boolean 2572elf64_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 2573{ 2574 char * command; 2575 int n; 2576 2577 switch (note->descsz) 2578 { 2579 default: 2580 return FALSE; 2581 2582 case 136: /* Linux/hppa elf_prpsinfo. */ 2583 elf_tdata (abfd)->core_program 2584 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 2585 elf_tdata (abfd)->core_command 2586 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 2587 } 2588 2589 /* Note that for some reason, a spurious space is tacked 2590 onto the end of the args in some (at least one anyway) 2591 implementations, so strip it off if it exists. */ 2592 command = elf_tdata (abfd)->core_command; 2593 n = strlen (command); 2594 2595 if (0 < n && command[n - 1] == ' ') 2596 command[n - 1] = '\0'; 2597 2598 return TRUE; 2599} 2600 2601/* Return the number of additional phdrs we will need. 2602 2603 The generic ELF code only creates PT_PHDRs for executables. The HP 2604 dynamic linker requires PT_PHDRs for dynamic libraries too. 2605 2606 This routine indicates that the backend needs one additional program 2607 header for that case. 2608 2609 Note we do not have access to the link info structure here, so we have 2610 to guess whether or not we are building a shared library based on the 2611 existence of a .interp section. */ 2612 2613static int 2614elf64_hppa_additional_program_headers (bfd *abfd, 2615 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2616{ 2617 asection *s; 2618 2619 /* If we are creating a shared library, then we have to create a 2620 PT_PHDR segment. HP's dynamic linker chokes without it. */ 2621 s = bfd_get_section_by_name (abfd, ".interp"); 2622 if (! s) 2623 return 1; 2624 return 0; 2625} 2626 2627/* Allocate and initialize any program headers required by this 2628 specific backend. 2629 2630 The generic ELF code only creates PT_PHDRs for executables. The HP 2631 dynamic linker requires PT_PHDRs for dynamic libraries too. 2632 2633 This allocates the PT_PHDR and initializes it in a manner suitable 2634 for the HP linker. 2635 2636 Note we do not have access to the link info structure here, so we have 2637 to guess whether or not we are building a shared library based on the 2638 existence of a .interp section. */ 2639 2640static bfd_boolean 2641elf64_hppa_modify_segment_map (bfd *abfd, 2642 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2643{ 2644 struct elf_segment_map *m; 2645 asection *s; 2646 2647 s = bfd_get_section_by_name (abfd, ".interp"); 2648 if (! s) 2649 { 2650 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 2651 if (m->p_type == PT_PHDR) 2652 break; 2653 if (m == NULL) 2654 { 2655 m = ((struct elf_segment_map *) 2656 bfd_zalloc (abfd, (bfd_size_type) sizeof *m)); 2657 if (m == NULL) 2658 return FALSE; 2659 2660 m->p_type = PT_PHDR; 2661 m->p_flags = PF_R | PF_X; 2662 m->p_flags_valid = 1; 2663 m->p_paddr_valid = 1; 2664 m->includes_phdrs = 1; 2665 2666 m->next = elf_tdata (abfd)->segment_map; 2667 elf_tdata (abfd)->segment_map = m; 2668 } 2669 } 2670 2671 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 2672 if (m->p_type == PT_LOAD) 2673 { 2674 unsigned int i; 2675 2676 for (i = 0; i < m->count; i++) 2677 { 2678 /* The code "hint" is not really a hint. It is a requirement 2679 for certain versions of the HP dynamic linker. Worse yet, 2680 it must be set even if the shared library does not have 2681 any code in its "text" segment (thus the check for .hash 2682 to catch this situation). */ 2683 if (m->sections[i]->flags & SEC_CODE 2684 || (strcmp (m->sections[i]->name, ".hash") == 0)) 2685 m->p_flags |= (PF_X | PF_HP_CODE); 2686 } 2687 } 2688 2689 return TRUE; 2690} 2691 2692/* Called when writing out an object file to decide the type of a 2693 symbol. */ 2694static int 2695elf64_hppa_elf_get_symbol_type (elf_sym, type) 2696 Elf_Internal_Sym *elf_sym; 2697 int type; 2698{ 2699 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI) 2700 return STT_PARISC_MILLI; 2701 else 2702 return type; 2703} 2704 2705/* Support HP specific sections for core files. */ 2706static bfd_boolean 2707elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index, 2708 const char *typename) 2709{ 2710 if (hdr->p_type == PT_HP_CORE_KERNEL) 2711 { 2712 asection *sect; 2713 2714 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)) 2715 return FALSE; 2716 2717 sect = bfd_make_section_anyway (abfd, ".kernel"); 2718 if (sect == NULL) 2719 return FALSE; 2720 sect->size = hdr->p_filesz; 2721 sect->filepos = hdr->p_offset; 2722 sect->flags = SEC_HAS_CONTENTS | SEC_READONLY; 2723 return TRUE; 2724 } 2725 2726 if (hdr->p_type == PT_HP_CORE_PROC) 2727 { 2728 int sig; 2729 2730 if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0) 2731 return FALSE; 2732 if (bfd_bread (&sig, 4, abfd) != 4) 2733 return FALSE; 2734 2735 elf_tdata (abfd)->core_signal = sig; 2736 2737 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)) 2738 return FALSE; 2739 2740 /* GDB uses the ".reg" section to read register contents. */ 2741 return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz, 2742 hdr->p_offset); 2743 } 2744 2745 if (hdr->p_type == PT_HP_CORE_LOADABLE 2746 || hdr->p_type == PT_HP_CORE_STACK 2747 || hdr->p_type == PT_HP_CORE_MMF) 2748 hdr->p_type = PT_LOAD; 2749 2750 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename); 2751} 2752 2753static const struct bfd_elf_special_section elf64_hppa_special_sections[] = 2754{ 2755 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2756 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2757 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 2758 { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 2759 { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 2760 { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT }, 2761 { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS }, 2762 { NULL, 0, 0, 0, 0 } 2763}; 2764 2765/* The hash bucket size is the standard one, namely 4. */ 2766 2767const struct elf_size_info hppa64_elf_size_info = 2768{ 2769 sizeof (Elf64_External_Ehdr), 2770 sizeof (Elf64_External_Phdr), 2771 sizeof (Elf64_External_Shdr), 2772 sizeof (Elf64_External_Rel), 2773 sizeof (Elf64_External_Rela), 2774 sizeof (Elf64_External_Sym), 2775 sizeof (Elf64_External_Dyn), 2776 sizeof (Elf_External_Note), 2777 4, 2778 1, 2779 64, 3, 2780 ELFCLASS64, EV_CURRENT, 2781 bfd_elf64_write_out_phdrs, 2782 bfd_elf64_write_shdrs_and_ehdr, 2783 bfd_elf64_write_relocs, 2784 bfd_elf64_swap_symbol_in, 2785 bfd_elf64_swap_symbol_out, 2786 bfd_elf64_slurp_reloc_table, 2787 bfd_elf64_slurp_symbol_table, 2788 bfd_elf64_swap_dyn_in, 2789 bfd_elf64_swap_dyn_out, 2790 bfd_elf64_swap_reloc_in, 2791 bfd_elf64_swap_reloc_out, 2792 bfd_elf64_swap_reloca_in, 2793 bfd_elf64_swap_reloca_out 2794}; 2795 2796#define TARGET_BIG_SYM bfd_elf64_hppa_vec 2797#define TARGET_BIG_NAME "elf64-hppa" 2798#define ELF_ARCH bfd_arch_hppa 2799#define ELF_MACHINE_CODE EM_PARISC 2800/* This is not strictly correct. The maximum page size for PA2.0 is 2801 64M. But everything still uses 4k. */ 2802#define ELF_MAXPAGESIZE 0x1000 2803#define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup 2804#define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name 2805#define elf_info_to_howto elf_hppa_info_to_howto 2806#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel 2807 2808#define elf_backend_section_from_shdr elf64_hppa_section_from_shdr 2809#define elf_backend_object_p elf64_hppa_object_p 2810#define elf_backend_final_write_processing \ 2811 elf_hppa_final_write_processing 2812#define elf_backend_fake_sections elf_hppa_fake_sections 2813#define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook 2814 2815#define elf_backend_relocate_section elf_hppa_relocate_section 2816 2817#define bfd_elf64_bfd_final_link elf_hppa_final_link 2818 2819#define elf_backend_create_dynamic_sections \ 2820 elf64_hppa_create_dynamic_sections 2821#define elf_backend_post_process_headers elf64_hppa_post_process_headers 2822 2823#define elf_backend_omit_section_dynsym \ 2824 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 2825#define elf_backend_adjust_dynamic_symbol \ 2826 elf64_hppa_adjust_dynamic_symbol 2827 2828#define elf_backend_size_dynamic_sections \ 2829 elf64_hppa_size_dynamic_sections 2830 2831#define elf_backend_finish_dynamic_symbol \ 2832 elf64_hppa_finish_dynamic_symbol 2833#define elf_backend_finish_dynamic_sections \ 2834 elf64_hppa_finish_dynamic_sections 2835#define elf_backend_grok_prstatus elf64_hppa_grok_prstatus 2836#define elf_backend_grok_psinfo elf64_hppa_grok_psinfo 2837 2838/* Stuff for the BFD linker: */ 2839#define bfd_elf64_bfd_link_hash_table_create \ 2840 elf64_hppa_hash_table_create 2841 2842#define elf_backend_check_relocs \ 2843 elf64_hppa_check_relocs 2844 2845#define elf_backend_size_info \ 2846 hppa64_elf_size_info 2847 2848#define elf_backend_additional_program_headers \ 2849 elf64_hppa_additional_program_headers 2850 2851#define elf_backend_modify_segment_map \ 2852 elf64_hppa_modify_segment_map 2853 2854#define elf_backend_link_output_symbol_hook \ 2855 elf64_hppa_link_output_symbol_hook 2856 2857#define elf_backend_want_got_plt 0 2858#define elf_backend_plt_readonly 0 2859#define elf_backend_want_plt_sym 0 2860#define elf_backend_got_header_size 0 2861#define elf_backend_type_change_ok TRUE 2862#define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type 2863#define elf_backend_reloc_type_class elf64_hppa_reloc_type_class 2864#define elf_backend_rela_normal 1 2865#define elf_backend_special_sections elf64_hppa_special_sections 2866#define elf_backend_action_discarded elf_hppa_action_discarded 2867#define elf_backend_section_from_phdr elf64_hppa_section_from_phdr 2868 2869#define elf64_bed elf64_hppa_hpux_bed 2870 2871#include "elf64-target.h" 2872 2873#undef TARGET_BIG_SYM 2874#define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec 2875#undef TARGET_BIG_NAME 2876#define TARGET_BIG_NAME "elf64-hppa-linux" 2877#undef elf64_bed 2878#define elf64_bed elf64_hppa_linux_bed 2879 2880#include "elf64-target.h" 2881