1 /* BFD back-end for HP PA-RISC ELF files. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001, 3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6 Original code by 7 Center for Software Science 8 Department of Computer Science 9 University of Utah 10 Largely rewritten by Alan Modra <alan@linuxcare.com.au> 11 Naming cleanup by Carlos O'Donell <carlos@systemhalted.org> 12 TLS support written by Randolph Chung <tausq@debian.org> 13 14 This file is part of BFD, the Binary File Descriptor library. 15 16 This program is free software; you can redistribute it and/or modify 17 it under the terms of the GNU General Public License as published by 18 the Free Software Foundation; either version 3 of the License, or 19 (at your option) any later version. 20 21 This program is distributed in the hope that it will be useful, 22 but WITHOUT ANY WARRANTY; without even the implied warranty of 23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 GNU General Public License for more details. 25 26 You should have received a copy of the GNU General Public License 27 along with this program; if not, write to the Free Software 28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 29 MA 02110-1301, USA. */ 30 31 #include "sysdep.h" 32 #include "bfd.h" 33 #include "libbfd.h" 34 #include "elf-bfd.h" 35 #include "elf/hppa.h" 36 #include "libhppa.h" 37 #include "elf32-hppa.h" 38 #define ARCH_SIZE 32 39 #include "elf32-hppa.h" 40 #include "elf-hppa.h" 41 42 /* In order to gain some understanding of code in this file without 43 knowing all the intricate details of the linker, note the 44 following: 45 46 Functions named elf32_hppa_* are called by external routines, other 47 functions are only called locally. elf32_hppa_* functions appear 48 in this file more or less in the order in which they are called 49 from external routines. eg. elf32_hppa_check_relocs is called 50 early in the link process, elf32_hppa_finish_dynamic_sections is 51 one of the last functions. */ 52 53 /* We use two hash tables to hold information for linking PA ELF objects. 54 55 The first is the elf32_hppa_link_hash_table which is derived 56 from the standard ELF linker hash table. We use this as a place to 57 attach other hash tables and static information. 58 59 The second is the stub hash table which is derived from the 60 base BFD hash table. The stub hash table holds the information 61 necessary to build the linker stubs during a link. 62 63 There are a number of different stubs generated by the linker. 64 65 Long branch stub: 66 : ldil LR'X,%r1 67 : be,n RR'X(%sr4,%r1) 68 69 PIC long branch stub: 70 : b,l .+8,%r1 71 : addil LR'X - ($PIC_pcrel$0 - 4),%r1 72 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1) 73 74 Import stub to call shared library routine from normal object file 75 (single sub-space version) 76 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point 77 : ldw RR'lt_ptr+ltoff(%r1),%r21 78 : bv %r0(%r21) 79 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value. 80 81 Import stub to call shared library routine from shared library 82 (single sub-space version) 83 : addil LR'ltoff,%r19 ; get procedure entry point 84 : ldw RR'ltoff(%r1),%r21 85 : bv %r0(%r21) 86 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value. 87 88 Import stub to call shared library routine from normal object file 89 (multiple sub-space support) 90 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point 91 : ldw RR'lt_ptr+ltoff(%r1),%r21 92 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value. 93 : ldsid (%r21),%r1 94 : mtsp %r1,%sr0 95 : be 0(%sr0,%r21) ; branch to target 96 : stw %rp,-24(%sp) ; save rp 97 98 Import stub to call shared library routine from shared library 99 (multiple sub-space support) 100 : addil LR'ltoff,%r19 ; get procedure entry point 101 : ldw RR'ltoff(%r1),%r21 102 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value. 103 : ldsid (%r21),%r1 104 : mtsp %r1,%sr0 105 : be 0(%sr0,%r21) ; branch to target 106 : stw %rp,-24(%sp) ; save rp 107 108 Export stub to return from shared lib routine (multiple sub-space support) 109 One of these is created for each exported procedure in a shared 110 library (and stored in the shared lib). Shared lib routines are 111 called via the first instruction in the export stub so that we can 112 do an inter-space return. Not required for single sub-space. 113 : bl,n X,%rp ; trap the return 114 : nop 115 : ldw -24(%sp),%rp ; restore the original rp 116 : ldsid (%rp),%r1 117 : mtsp %r1,%sr0 118 : be,n 0(%sr0,%rp) ; inter-space return. */ 119 120 121 /* Variable names follow a coding style. 122 Please follow this (Apps Hungarian) style: 123 124 Structure/Variable Prefix 125 elf_link_hash_table "etab" 126 elf_link_hash_entry "eh" 127 128 elf32_hppa_link_hash_table "htab" 129 elf32_hppa_link_hash_entry "hh" 130 131 bfd_hash_table "btab" 132 bfd_hash_entry "bh" 133 134 bfd_hash_table containing stubs "bstab" 135 elf32_hppa_stub_hash_entry "hsh" 136 137 elf32_hppa_dyn_reloc_entry "hdh" 138 139 Always remember to use GNU Coding Style. */ 140 141 #define PLT_ENTRY_SIZE 8 142 #define GOT_ENTRY_SIZE 4 143 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 144 145 static const bfd_byte plt_stub[] = 146 { 147 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */ 148 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */ 149 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */ 150 #define PLT_STUB_ENTRY (3*4) 151 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */ 152 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */ 153 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */ 154 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */ 155 }; 156 157 /* Section name for stubs is the associated section name plus this 158 string. */ 159 #define STUB_SUFFIX ".stub" 160 161 /* We don't need to copy certain PC- or GP-relative dynamic relocs 162 into a shared object's dynamic section. All the relocs of the 163 limited class we are interested in, are absolute. */ 164 #ifndef RELATIVE_DYNRELOCS 165 #define RELATIVE_DYNRELOCS 0 166 #define IS_ABSOLUTE_RELOC(r_type) 1 167 #endif 168 169 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 170 copying dynamic variables from a shared lib into an app's dynbss 171 section, and instead use a dynamic relocation to point into the 172 shared lib. */ 173 #define ELIMINATE_COPY_RELOCS 1 174 175 enum elf32_hppa_stub_type 176 { 177 hppa_stub_long_branch, 178 hppa_stub_long_branch_shared, 179 hppa_stub_import, 180 hppa_stub_import_shared, 181 hppa_stub_export, 182 hppa_stub_none 183 }; 184 185 struct elf32_hppa_stub_hash_entry 186 { 187 /* Base hash table entry structure. */ 188 struct bfd_hash_entry bh_root; 189 190 /* The stub section. */ 191 asection *stub_sec; 192 193 /* Offset within stub_sec of the beginning of this stub. */ 194 bfd_vma stub_offset; 195 196 /* Given the symbol's value and its section we can determine its final 197 value when building the stubs (so the stub knows where to jump. */ 198 bfd_vma target_value; 199 asection *target_section; 200 201 enum elf32_hppa_stub_type stub_type; 202 203 /* The symbol table entry, if any, that this was derived from. */ 204 struct elf32_hppa_link_hash_entry *hh; 205 206 /* Where this stub is being called from, or, in the case of combined 207 stub sections, the first input section in the group. */ 208 asection *id_sec; 209 }; 210 211 struct elf32_hppa_link_hash_entry 212 { 213 struct elf_link_hash_entry eh; 214 215 /* A pointer to the most recently used stub hash entry against this 216 symbol. */ 217 struct elf32_hppa_stub_hash_entry *hsh_cache; 218 219 /* Used to count relocations for delayed sizing of relocation 220 sections. */ 221 struct elf32_hppa_dyn_reloc_entry 222 { 223 /* Next relocation in the chain. */ 224 struct elf32_hppa_dyn_reloc_entry *hdh_next; 225 226 /* The input section of the reloc. */ 227 asection *sec; 228 229 /* Number of relocs copied in this section. */ 230 bfd_size_type count; 231 232 #if RELATIVE_DYNRELOCS 233 /* Number of relative relocs copied for the input section. */ 234 bfd_size_type relative_count; 235 #endif 236 } *dyn_relocs; 237 238 enum 239 { 240 GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_GD = 2, GOT_TLS_LDM = 4, GOT_TLS_IE = 8 241 } tls_type; 242 243 /* Set if this symbol is used by a plabel reloc. */ 244 unsigned int plabel:1; 245 }; 246 247 struct elf32_hppa_link_hash_table 248 { 249 /* The main hash table. */ 250 struct elf_link_hash_table etab; 251 252 /* The stub hash table. */ 253 struct bfd_hash_table bstab; 254 255 /* Linker stub bfd. */ 256 bfd *stub_bfd; 257 258 /* Linker call-backs. */ 259 asection * (*add_stub_section) (const char *, asection *); 260 void (*layout_sections_again) (void); 261 262 /* Array to keep track of which stub sections have been created, and 263 information on stub grouping. */ 264 struct map_stub 265 { 266 /* This is the section to which stubs in the group will be 267 attached. */ 268 asection *link_sec; 269 /* The stub section. */ 270 asection *stub_sec; 271 } *stub_group; 272 273 /* Assorted information used by elf32_hppa_size_stubs. */ 274 unsigned int bfd_count; 275 int top_index; 276 asection **input_list; 277 Elf_Internal_Sym **all_local_syms; 278 279 /* Short-cuts to get to dynamic linker sections. */ 280 asection *sgot; 281 asection *srelgot; 282 asection *splt; 283 asection *srelplt; 284 asection *sdynbss; 285 asection *srelbss; 286 287 /* Used during a final link to store the base of the text and data 288 segments so that we can perform SEGREL relocations. */ 289 bfd_vma text_segment_base; 290 bfd_vma data_segment_base; 291 292 /* Whether we support multiple sub-spaces for shared libs. */ 293 unsigned int multi_subspace:1; 294 295 /* Flags set when various size branches are detected. Used to 296 select suitable defaults for the stub group size. */ 297 unsigned int has_12bit_branch:1; 298 unsigned int has_17bit_branch:1; 299 unsigned int has_22bit_branch:1; 300 301 /* Set if we need a .plt stub to support lazy dynamic linking. */ 302 unsigned int need_plt_stub:1; 303 304 /* Small local sym cache. */ 305 struct sym_cache sym_cache; 306 307 /* Data for LDM relocations. */ 308 union 309 { 310 bfd_signed_vma refcount; 311 bfd_vma offset; 312 } tls_ldm_got; 313 }; 314 315 /* Various hash macros and functions. */ 316 #define hppa_link_hash_table(p) \ 317 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 318 == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL) 319 320 #define hppa_elf_hash_entry(ent) \ 321 ((struct elf32_hppa_link_hash_entry *)(ent)) 322 323 #define hppa_stub_hash_entry(ent) \ 324 ((struct elf32_hppa_stub_hash_entry *)(ent)) 325 326 #define hppa_stub_hash_lookup(table, string, create, copy) \ 327 ((struct elf32_hppa_stub_hash_entry *) \ 328 bfd_hash_lookup ((table), (string), (create), (copy))) 329 330 #define hppa_elf_local_got_tls_type(abfd) \ 331 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2))) 332 333 #define hh_name(hh) \ 334 (hh ? hh->eh.root.root.string : "<undef>") 335 336 #define eh_name(eh) \ 337 (eh ? eh->root.root.string : "<undef>") 338 339 /* Assorted hash table functions. */ 340 341 /* Initialize an entry in the stub hash table. */ 342 343 static struct bfd_hash_entry * 344 stub_hash_newfunc (struct bfd_hash_entry *entry, 345 struct bfd_hash_table *table, 346 const char *string) 347 { 348 /* Allocate the structure if it has not already been allocated by a 349 subclass. */ 350 if (entry == NULL) 351 { 352 entry = bfd_hash_allocate (table, 353 sizeof (struct elf32_hppa_stub_hash_entry)); 354 if (entry == NULL) 355 return entry; 356 } 357 358 /* Call the allocation method of the superclass. */ 359 entry = bfd_hash_newfunc (entry, table, string); 360 if (entry != NULL) 361 { 362 struct elf32_hppa_stub_hash_entry *hsh; 363 364 /* Initialize the local fields. */ 365 hsh = hppa_stub_hash_entry (entry); 366 hsh->stub_sec = NULL; 367 hsh->stub_offset = 0; 368 hsh->target_value = 0; 369 hsh->target_section = NULL; 370 hsh->stub_type = hppa_stub_long_branch; 371 hsh->hh = NULL; 372 hsh->id_sec = NULL; 373 } 374 375 return entry; 376 } 377 378 /* Initialize an entry in the link hash table. */ 379 380 static struct bfd_hash_entry * 381 hppa_link_hash_newfunc (struct bfd_hash_entry *entry, 382 struct bfd_hash_table *table, 383 const char *string) 384 { 385 /* Allocate the structure if it has not already been allocated by a 386 subclass. */ 387 if (entry == NULL) 388 { 389 entry = bfd_hash_allocate (table, 390 sizeof (struct elf32_hppa_link_hash_entry)); 391 if (entry == NULL) 392 return entry; 393 } 394 395 /* Call the allocation method of the superclass. */ 396 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 397 if (entry != NULL) 398 { 399 struct elf32_hppa_link_hash_entry *hh; 400 401 /* Initialize the local fields. */ 402 hh = hppa_elf_hash_entry (entry); 403 hh->hsh_cache = NULL; 404 hh->dyn_relocs = NULL; 405 hh->plabel = 0; 406 hh->tls_type = GOT_UNKNOWN; 407 } 408 409 return entry; 410 } 411 412 /* Create the derived linker hash table. The PA ELF port uses the derived 413 hash table to keep information specific to the PA ELF linker (without 414 using static variables). */ 415 416 static struct bfd_link_hash_table * 417 elf32_hppa_link_hash_table_create (bfd *abfd) 418 { 419 struct elf32_hppa_link_hash_table *htab; 420 bfd_size_type amt = sizeof (*htab); 421 422 htab = bfd_malloc (amt); 423 if (htab == NULL) 424 return NULL; 425 426 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc, 427 sizeof (struct elf32_hppa_link_hash_entry), 428 HPPA32_ELF_DATA)) 429 { 430 free (htab); 431 return NULL; 432 } 433 434 /* Init the stub hash table too. */ 435 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc, 436 sizeof (struct elf32_hppa_stub_hash_entry))) 437 return NULL; 438 439 htab->stub_bfd = NULL; 440 htab->add_stub_section = NULL; 441 htab->layout_sections_again = NULL; 442 htab->stub_group = NULL; 443 htab->sgot = NULL; 444 htab->srelgot = NULL; 445 htab->splt = NULL; 446 htab->srelplt = NULL; 447 htab->sdynbss = NULL; 448 htab->srelbss = NULL; 449 htab->text_segment_base = (bfd_vma) -1; 450 htab->data_segment_base = (bfd_vma) -1; 451 htab->multi_subspace = 0; 452 htab->has_12bit_branch = 0; 453 htab->has_17bit_branch = 0; 454 htab->has_22bit_branch = 0; 455 htab->need_plt_stub = 0; 456 htab->sym_cache.abfd = NULL; 457 htab->tls_ldm_got.refcount = 0; 458 459 return &htab->etab.root; 460 } 461 462 /* Free the derived linker hash table. */ 463 464 static void 465 elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *btab) 466 { 467 struct elf32_hppa_link_hash_table *htab 468 = (struct elf32_hppa_link_hash_table *) btab; 469 470 bfd_hash_table_free (&htab->bstab); 471 _bfd_generic_link_hash_table_free (btab); 472 } 473 474 /* Build a name for an entry in the stub hash table. */ 475 476 static char * 477 hppa_stub_name (const asection *input_section, 478 const asection *sym_sec, 479 const struct elf32_hppa_link_hash_entry *hh, 480 const Elf_Internal_Rela *rela) 481 { 482 char *stub_name; 483 bfd_size_type len; 484 485 if (hh) 486 { 487 len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1; 488 stub_name = bfd_malloc (len); 489 if (stub_name != NULL) 490 sprintf (stub_name, "%08x_%s+%x", 491 input_section->id & 0xffffffff, 492 hh_name (hh), 493 (int) rela->r_addend & 0xffffffff); 494 } 495 else 496 { 497 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1; 498 stub_name = bfd_malloc (len); 499 if (stub_name != NULL) 500 sprintf (stub_name, "%08x_%x:%x+%x", 501 input_section->id & 0xffffffff, 502 sym_sec->id & 0xffffffff, 503 (int) ELF32_R_SYM (rela->r_info) & 0xffffffff, 504 (int) rela->r_addend & 0xffffffff); 505 } 506 return stub_name; 507 } 508 509 /* Look up an entry in the stub hash. Stub entries are cached because 510 creating the stub name takes a bit of time. */ 511 512 static struct elf32_hppa_stub_hash_entry * 513 hppa_get_stub_entry (const asection *input_section, 514 const asection *sym_sec, 515 struct elf32_hppa_link_hash_entry *hh, 516 const Elf_Internal_Rela *rela, 517 struct elf32_hppa_link_hash_table *htab) 518 { 519 struct elf32_hppa_stub_hash_entry *hsh_entry; 520 const asection *id_sec; 521 522 /* If this input section is part of a group of sections sharing one 523 stub section, then use the id of the first section in the group. 524 Stub names need to include a section id, as there may well be 525 more than one stub used to reach say, printf, and we need to 526 distinguish between them. */ 527 id_sec = htab->stub_group[input_section->id].link_sec; 528 529 if (hh != NULL && hh->hsh_cache != NULL 530 && hh->hsh_cache->hh == hh 531 && hh->hsh_cache->id_sec == id_sec) 532 { 533 hsh_entry = hh->hsh_cache; 534 } 535 else 536 { 537 char *stub_name; 538 539 stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela); 540 if (stub_name == NULL) 541 return NULL; 542 543 hsh_entry = hppa_stub_hash_lookup (&htab->bstab, 544 stub_name, FALSE, FALSE); 545 if (hh != NULL) 546 hh->hsh_cache = hsh_entry; 547 548 free (stub_name); 549 } 550 551 return hsh_entry; 552 } 553 554 /* Add a new stub entry to the stub hash. Not all fields of the new 555 stub entry are initialised. */ 556 557 static struct elf32_hppa_stub_hash_entry * 558 hppa_add_stub (const char *stub_name, 559 asection *section, 560 struct elf32_hppa_link_hash_table *htab) 561 { 562 asection *link_sec; 563 asection *stub_sec; 564 struct elf32_hppa_stub_hash_entry *hsh; 565 566 link_sec = htab->stub_group[section->id].link_sec; 567 stub_sec = htab->stub_group[section->id].stub_sec; 568 if (stub_sec == NULL) 569 { 570 stub_sec = htab->stub_group[link_sec->id].stub_sec; 571 if (stub_sec == NULL) 572 { 573 size_t namelen; 574 bfd_size_type len; 575 char *s_name; 576 577 namelen = strlen (link_sec->name); 578 len = namelen + sizeof (STUB_SUFFIX); 579 s_name = bfd_alloc (htab->stub_bfd, len); 580 if (s_name == NULL) 581 return NULL; 582 583 memcpy (s_name, link_sec->name, namelen); 584 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX)); 585 stub_sec = (*htab->add_stub_section) (s_name, link_sec); 586 if (stub_sec == NULL) 587 return NULL; 588 htab->stub_group[link_sec->id].stub_sec = stub_sec; 589 } 590 htab->stub_group[section->id].stub_sec = stub_sec; 591 } 592 593 /* Enter this entry into the linker stub hash table. */ 594 hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name, 595 TRUE, FALSE); 596 if (hsh == NULL) 597 { 598 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"), 599 section->owner, 600 stub_name); 601 return NULL; 602 } 603 604 hsh->stub_sec = stub_sec; 605 hsh->stub_offset = 0; 606 hsh->id_sec = link_sec; 607 return hsh; 608 } 609 610 /* Determine the type of stub needed, if any, for a call. */ 611 612 static enum elf32_hppa_stub_type 613 hppa_type_of_stub (asection *input_sec, 614 const Elf_Internal_Rela *rela, 615 struct elf32_hppa_link_hash_entry *hh, 616 bfd_vma destination, 617 struct bfd_link_info *info) 618 { 619 bfd_vma location; 620 bfd_vma branch_offset; 621 bfd_vma max_branch_offset; 622 unsigned int r_type; 623 624 if (hh != NULL 625 && hh->eh.plt.offset != (bfd_vma) -1 626 && hh->eh.dynindx != -1 627 && !hh->plabel 628 && (info->shared 629 || !hh->eh.def_regular 630 || hh->eh.root.type == bfd_link_hash_defweak)) 631 { 632 /* We need an import stub. Decide between hppa_stub_import 633 and hppa_stub_import_shared later. */ 634 return hppa_stub_import; 635 } 636 637 /* Determine where the call point is. */ 638 location = (input_sec->output_offset 639 + input_sec->output_section->vma 640 + rela->r_offset); 641 642 branch_offset = destination - location - 8; 643 r_type = ELF32_R_TYPE (rela->r_info); 644 645 /* Determine if a long branch stub is needed. parisc branch offsets 646 are relative to the second instruction past the branch, ie. +8 647 bytes on from the branch instruction location. The offset is 648 signed and counts in units of 4 bytes. */ 649 if (r_type == (unsigned int) R_PARISC_PCREL17F) 650 max_branch_offset = (1 << (17 - 1)) << 2; 651 652 else if (r_type == (unsigned int) R_PARISC_PCREL12F) 653 max_branch_offset = (1 << (12 - 1)) << 2; 654 655 else /* R_PARISC_PCREL22F. */ 656 max_branch_offset = (1 << (22 - 1)) << 2; 657 658 if (branch_offset + max_branch_offset >= 2*max_branch_offset) 659 return hppa_stub_long_branch; 660 661 return hppa_stub_none; 662 } 663 664 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY. 665 IN_ARG contains the link info pointer. */ 666 667 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */ 668 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */ 669 670 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */ 671 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */ 672 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */ 673 674 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */ 675 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */ 676 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */ 677 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */ 678 679 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */ 680 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */ 681 682 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */ 683 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */ 684 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */ 685 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */ 686 687 #define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */ 688 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */ 689 #define NOP 0x08000240 /* nop */ 690 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */ 691 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */ 692 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */ 693 694 #ifndef R19_STUBS 695 #define R19_STUBS 1 696 #endif 697 698 #if R19_STUBS 699 #define LDW_R1_DLT LDW_R1_R19 700 #else 701 #define LDW_R1_DLT LDW_R1_DP 702 #endif 703 704 static bfd_boolean 705 hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg) 706 { 707 struct elf32_hppa_stub_hash_entry *hsh; 708 struct bfd_link_info *info; 709 struct elf32_hppa_link_hash_table *htab; 710 asection *stub_sec; 711 bfd *stub_bfd; 712 bfd_byte *loc; 713 bfd_vma sym_value; 714 bfd_vma insn; 715 bfd_vma off; 716 int val; 717 int size; 718 719 /* Massage our args to the form they really have. */ 720 hsh = hppa_stub_hash_entry (bh); 721 info = (struct bfd_link_info *)in_arg; 722 723 htab = hppa_link_hash_table (info); 724 if (htab == NULL) 725 return FALSE; 726 727 stub_sec = hsh->stub_sec; 728 729 /* Make a note of the offset within the stubs for this entry. */ 730 hsh->stub_offset = stub_sec->size; 731 loc = stub_sec->contents + hsh->stub_offset; 732 733 stub_bfd = stub_sec->owner; 734 735 switch (hsh->stub_type) 736 { 737 case hppa_stub_long_branch: 738 /* Create the long branch. A long branch is formed with "ldil" 739 loading the upper bits of the target address into a register, 740 then branching with "be" which adds in the lower bits. 741 The "be" has its delay slot nullified. */ 742 sym_value = (hsh->target_value 743 + hsh->target_section->output_offset 744 + hsh->target_section->output_section->vma); 745 746 val = hppa_field_adjust (sym_value, 0, e_lrsel); 747 insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21); 748 bfd_put_32 (stub_bfd, insn, loc); 749 750 val = hppa_field_adjust (sym_value, 0, e_rrsel) >> 2; 751 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17); 752 bfd_put_32 (stub_bfd, insn, loc + 4); 753 754 size = 8; 755 break; 756 757 case hppa_stub_long_branch_shared: 758 /* Branches are relative. This is where we are going to. */ 759 sym_value = (hsh->target_value 760 + hsh->target_section->output_offset 761 + hsh->target_section->output_section->vma); 762 763 /* And this is where we are coming from, more or less. */ 764 sym_value -= (hsh->stub_offset 765 + stub_sec->output_offset 766 + stub_sec->output_section->vma); 767 768 bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc); 769 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel); 770 insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21); 771 bfd_put_32 (stub_bfd, insn, loc + 4); 772 773 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2; 774 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17); 775 bfd_put_32 (stub_bfd, insn, loc + 8); 776 size = 12; 777 break; 778 779 case hppa_stub_import: 780 case hppa_stub_import_shared: 781 off = hsh->hh->eh.plt.offset; 782 if (off >= (bfd_vma) -2) 783 abort (); 784 785 off &= ~ (bfd_vma) 1; 786 sym_value = (off 787 + htab->splt->output_offset 788 + htab->splt->output_section->vma 789 - elf_gp (htab->splt->output_section->owner)); 790 791 insn = ADDIL_DP; 792 #if R19_STUBS 793 if (hsh->stub_type == hppa_stub_import_shared) 794 insn = ADDIL_R19; 795 #endif 796 val = hppa_field_adjust (sym_value, 0, e_lrsel), 797 insn = hppa_rebuild_insn ((int) insn, val, 21); 798 bfd_put_32 (stub_bfd, insn, loc); 799 800 /* It is critical to use lrsel/rrsel here because we are using 801 two different offsets (+0 and +4) from sym_value. If we use 802 lsel/rsel then with unfortunate sym_values we will round 803 sym_value+4 up to the next 2k block leading to a mis-match 804 between the lsel and rsel value. */ 805 val = hppa_field_adjust (sym_value, 0, e_rrsel); 806 insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14); 807 bfd_put_32 (stub_bfd, insn, loc + 4); 808 809 if (htab->multi_subspace) 810 { 811 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel); 812 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14); 813 bfd_put_32 (stub_bfd, insn, loc + 8); 814 815 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12); 816 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16); 817 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 20); 818 bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 24); 819 820 size = 28; 821 } 822 else 823 { 824 bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8); 825 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel); 826 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14); 827 bfd_put_32 (stub_bfd, insn, loc + 12); 828 829 size = 16; 830 } 831 832 break; 833 834 case hppa_stub_export: 835 /* Branches are relative. This is where we are going to. */ 836 sym_value = (hsh->target_value 837 + hsh->target_section->output_offset 838 + hsh->target_section->output_section->vma); 839 840 /* And this is where we are coming from. */ 841 sym_value -= (hsh->stub_offset 842 + stub_sec->output_offset 843 + stub_sec->output_section->vma); 844 845 if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2)) 846 && (!htab->has_22bit_branch 847 || sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2)))) 848 { 849 (*_bfd_error_handler) 850 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"), 851 hsh->target_section->owner, 852 stub_sec, 853 (long) hsh->stub_offset, 854 hsh->bh_root.string); 855 bfd_set_error (bfd_error_bad_value); 856 return FALSE; 857 } 858 859 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2; 860 if (!htab->has_22bit_branch) 861 insn = hppa_rebuild_insn ((int) BL_RP, val, 17); 862 else 863 insn = hppa_rebuild_insn ((int) BL22_RP, val, 22); 864 bfd_put_32 (stub_bfd, insn, loc); 865 866 bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4); 867 bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8); 868 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12); 869 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16); 870 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP, loc + 20); 871 872 /* Point the function symbol at the stub. */ 873 hsh->hh->eh.root.u.def.section = stub_sec; 874 hsh->hh->eh.root.u.def.value = stub_sec->size; 875 876 size = 24; 877 break; 878 879 default: 880 BFD_FAIL (); 881 return FALSE; 882 } 883 884 stub_sec->size += size; 885 return TRUE; 886 } 887 888 #undef LDIL_R1 889 #undef BE_SR4_R1 890 #undef BL_R1 891 #undef ADDIL_R1 892 #undef DEPI_R1 893 #undef LDW_R1_R21 894 #undef LDW_R1_DLT 895 #undef LDW_R1_R19 896 #undef ADDIL_R19 897 #undef LDW_R1_DP 898 #undef LDSID_R21_R1 899 #undef MTSP_R1 900 #undef BE_SR0_R21 901 #undef STW_RP 902 #undef BV_R0_R21 903 #undef BL_RP 904 #undef NOP 905 #undef LDW_RP 906 #undef LDSID_RP_R1 907 #undef BE_SR0_RP 908 909 /* As above, but don't actually build the stub. Just bump offset so 910 we know stub section sizes. */ 911 912 static bfd_boolean 913 hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg) 914 { 915 struct elf32_hppa_stub_hash_entry *hsh; 916 struct elf32_hppa_link_hash_table *htab; 917 int size; 918 919 /* Massage our args to the form they really have. */ 920 hsh = hppa_stub_hash_entry (bh); 921 htab = in_arg; 922 923 if (hsh->stub_type == hppa_stub_long_branch) 924 size = 8; 925 else if (hsh->stub_type == hppa_stub_long_branch_shared) 926 size = 12; 927 else if (hsh->stub_type == hppa_stub_export) 928 size = 24; 929 else /* hppa_stub_import or hppa_stub_import_shared. */ 930 { 931 if (htab->multi_subspace) 932 size = 28; 933 else 934 size = 16; 935 } 936 937 hsh->stub_sec->size += size; 938 return TRUE; 939 } 940 941 /* Return nonzero if ABFD represents an HPPA ELF32 file. 942 Additionally we set the default architecture and machine. */ 943 944 static bfd_boolean 945 elf32_hppa_object_p (bfd *abfd) 946 { 947 Elf_Internal_Ehdr * i_ehdrp; 948 unsigned int flags; 949 950 i_ehdrp = elf_elfheader (abfd); 951 if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0) 952 { 953 /* GCC on hppa-linux produces binaries with OSABI=Linux, 954 but the kernel produces corefiles with OSABI=SysV. */ 955 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX && 956 i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 957 return FALSE; 958 } 959 else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0) 960 { 961 /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD, 962 but the kernel produces corefiles with OSABI=SysV. */ 963 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD && 964 i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */ 965 return FALSE; 966 } 967 else 968 { 969 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX) 970 return FALSE; 971 } 972 973 flags = i_ehdrp->e_flags; 974 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE)) 975 { 976 case EFA_PARISC_1_0: 977 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10); 978 case EFA_PARISC_1_1: 979 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11); 980 case EFA_PARISC_2_0: 981 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20); 982 case EFA_PARISC_2_0 | EF_PARISC_WIDE: 983 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25); 984 } 985 return TRUE; 986 } 987 988 /* Create the .plt and .got sections, and set up our hash table 989 short-cuts to various dynamic sections. */ 990 991 static bfd_boolean 992 elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 993 { 994 struct elf32_hppa_link_hash_table *htab; 995 struct elf_link_hash_entry *eh; 996 997 /* Don't try to create the .plt and .got twice. */ 998 htab = hppa_link_hash_table (info); 999 if (htab == NULL) 1000 return FALSE; 1001 if (htab->splt != NULL) 1002 return TRUE; 1003 1004 /* Call the generic code to do most of the work. */ 1005 if (! _bfd_elf_create_dynamic_sections (abfd, info)) 1006 return FALSE; 1007 1008 htab->splt = bfd_get_section_by_name (abfd, ".plt"); 1009 htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt"); 1010 1011 htab->sgot = bfd_get_section_by_name (abfd, ".got"); 1012 htab->srelgot = bfd_get_section_by_name (abfd, ".rela.got"); 1013 1014 htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss"); 1015 htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss"); 1016 1017 /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main 1018 application, because __canonicalize_funcptr_for_compare needs it. */ 1019 eh = elf_hash_table (info)->hgot; 1020 eh->forced_local = 0; 1021 eh->other = STV_DEFAULT; 1022 return bfd_elf_link_record_dynamic_symbol (info, eh); 1023 } 1024 1025 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1026 1027 static void 1028 elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info, 1029 struct elf_link_hash_entry *eh_dir, 1030 struct elf_link_hash_entry *eh_ind) 1031 { 1032 struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind; 1033 1034 hh_dir = hppa_elf_hash_entry (eh_dir); 1035 hh_ind = hppa_elf_hash_entry (eh_ind); 1036 1037 if (hh_ind->dyn_relocs != NULL) 1038 { 1039 if (hh_dir->dyn_relocs != NULL) 1040 { 1041 struct elf32_hppa_dyn_reloc_entry **hdh_pp; 1042 struct elf32_hppa_dyn_reloc_entry *hdh_p; 1043 1044 /* Add reloc counts against the indirect sym to the direct sym 1045 list. Merge any entries against the same section. */ 1046 for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; ) 1047 { 1048 struct elf32_hppa_dyn_reloc_entry *hdh_q; 1049 1050 for (hdh_q = hh_dir->dyn_relocs; 1051 hdh_q != NULL; 1052 hdh_q = hdh_q->hdh_next) 1053 if (hdh_q->sec == hdh_p->sec) 1054 { 1055 #if RELATIVE_DYNRELOCS 1056 hdh_q->relative_count += hdh_p->relative_count; 1057 #endif 1058 hdh_q->count += hdh_p->count; 1059 *hdh_pp = hdh_p->hdh_next; 1060 break; 1061 } 1062 if (hdh_q == NULL) 1063 hdh_pp = &hdh_p->hdh_next; 1064 } 1065 *hdh_pp = hh_dir->dyn_relocs; 1066 } 1067 1068 hh_dir->dyn_relocs = hh_ind->dyn_relocs; 1069 hh_ind->dyn_relocs = NULL; 1070 } 1071 1072 if (ELIMINATE_COPY_RELOCS 1073 && eh_ind->root.type != bfd_link_hash_indirect 1074 && eh_dir->dynamic_adjusted) 1075 { 1076 /* If called to transfer flags for a weakdef during processing 1077 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 1078 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 1079 eh_dir->ref_dynamic |= eh_ind->ref_dynamic; 1080 eh_dir->ref_regular |= eh_ind->ref_regular; 1081 eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak; 1082 eh_dir->needs_plt |= eh_ind->needs_plt; 1083 } 1084 else 1085 { 1086 if (eh_ind->root.type == bfd_link_hash_indirect 1087 && eh_dir->got.refcount <= 0) 1088 { 1089 hh_dir->tls_type = hh_ind->tls_type; 1090 hh_ind->tls_type = GOT_UNKNOWN; 1091 } 1092 1093 _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind); 1094 } 1095 } 1096 1097 static int 1098 elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED, 1099 int r_type, int is_local ATTRIBUTE_UNUSED) 1100 { 1101 /* For now we don't support linker optimizations. */ 1102 return r_type; 1103 } 1104 1105 /* Return a pointer to the local GOT, PLT and TLS reference counts 1106 for ABFD. Returns NULL if the storage allocation fails. */ 1107 1108 static bfd_signed_vma * 1109 hppa32_elf_local_refcounts (bfd *abfd) 1110 { 1111 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1112 bfd_signed_vma *local_refcounts; 1113 1114 local_refcounts = elf_local_got_refcounts (abfd); 1115 if (local_refcounts == NULL) 1116 { 1117 bfd_size_type size; 1118 1119 /* Allocate space for local GOT and PLT reference 1120 counts. Done this way to save polluting elf_obj_tdata 1121 with another target specific pointer. */ 1122 size = symtab_hdr->sh_info; 1123 size *= 2 * sizeof (bfd_signed_vma); 1124 /* Add in space to store the local GOT TLS types. */ 1125 size += symtab_hdr->sh_info; 1126 local_refcounts = bfd_zalloc (abfd, size); 1127 if (local_refcounts == NULL) 1128 return NULL; 1129 elf_local_got_refcounts (abfd) = local_refcounts; 1130 memset (hppa_elf_local_got_tls_type (abfd), GOT_UNKNOWN, 1131 symtab_hdr->sh_info); 1132 } 1133 return local_refcounts; 1134 } 1135 1136 1137 /* Look through the relocs for a section during the first phase, and 1138 calculate needed space in the global offset table, procedure linkage 1139 table, and dynamic reloc sections. At this point we haven't 1140 necessarily read all the input files. */ 1141 1142 static bfd_boolean 1143 elf32_hppa_check_relocs (bfd *abfd, 1144 struct bfd_link_info *info, 1145 asection *sec, 1146 const Elf_Internal_Rela *relocs) 1147 { 1148 Elf_Internal_Shdr *symtab_hdr; 1149 struct elf_link_hash_entry **eh_syms; 1150 const Elf_Internal_Rela *rela; 1151 const Elf_Internal_Rela *rela_end; 1152 struct elf32_hppa_link_hash_table *htab; 1153 asection *sreloc; 1154 int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN; 1155 1156 if (info->relocatable) 1157 return TRUE; 1158 1159 htab = hppa_link_hash_table (info); 1160 if (htab == NULL) 1161 return FALSE; 1162 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1163 eh_syms = elf_sym_hashes (abfd); 1164 sreloc = NULL; 1165 1166 rela_end = relocs + sec->reloc_count; 1167 for (rela = relocs; rela < rela_end; rela++) 1168 { 1169 enum { 1170 NEED_GOT = 1, 1171 NEED_PLT = 2, 1172 NEED_DYNREL = 4, 1173 PLT_PLABEL = 8 1174 }; 1175 1176 unsigned int r_symndx, r_type; 1177 struct elf32_hppa_link_hash_entry *hh; 1178 int need_entry = 0; 1179 1180 r_symndx = ELF32_R_SYM (rela->r_info); 1181 1182 if (r_symndx < symtab_hdr->sh_info) 1183 hh = NULL; 1184 else 1185 { 1186 hh = hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]); 1187 while (hh->eh.root.type == bfd_link_hash_indirect 1188 || hh->eh.root.type == bfd_link_hash_warning) 1189 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 1190 } 1191 1192 r_type = ELF32_R_TYPE (rela->r_info); 1193 r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL); 1194 1195 switch (r_type) 1196 { 1197 case R_PARISC_DLTIND14F: 1198 case R_PARISC_DLTIND14R: 1199 case R_PARISC_DLTIND21L: 1200 /* This symbol requires a global offset table entry. */ 1201 need_entry = NEED_GOT; 1202 break; 1203 1204 case R_PARISC_PLABEL14R: /* "Official" procedure labels. */ 1205 case R_PARISC_PLABEL21L: 1206 case R_PARISC_PLABEL32: 1207 /* If the addend is non-zero, we break badly. */ 1208 if (rela->r_addend != 0) 1209 abort (); 1210 1211 /* If we are creating a shared library, then we need to 1212 create a PLT entry for all PLABELs, because PLABELs with 1213 local symbols may be passed via a pointer to another 1214 object. Additionally, output a dynamic relocation 1215 pointing to the PLT entry. 1216 1217 For executables, the original 32-bit ABI allowed two 1218 different styles of PLABELs (function pointers): For 1219 global functions, the PLABEL word points into the .plt 1220 two bytes past a (function address, gp) pair, and for 1221 local functions the PLABEL points directly at the 1222 function. The magic +2 for the first type allows us to 1223 differentiate between the two. As you can imagine, this 1224 is a real pain when it comes to generating code to call 1225 functions indirectly or to compare function pointers. 1226 We avoid the mess by always pointing a PLABEL into the 1227 .plt, even for local functions. */ 1228 need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL; 1229 break; 1230 1231 case R_PARISC_PCREL12F: 1232 htab->has_12bit_branch = 1; 1233 goto branch_common; 1234 1235 case R_PARISC_PCREL17C: 1236 case R_PARISC_PCREL17F: 1237 htab->has_17bit_branch = 1; 1238 goto branch_common; 1239 1240 case R_PARISC_PCREL22F: 1241 htab->has_22bit_branch = 1; 1242 branch_common: 1243 /* Function calls might need to go through the .plt, and 1244 might require long branch stubs. */ 1245 if (hh == NULL) 1246 { 1247 /* We know local syms won't need a .plt entry, and if 1248 they need a long branch stub we can't guarantee that 1249 we can reach the stub. So just flag an error later 1250 if we're doing a shared link and find we need a long 1251 branch stub. */ 1252 continue; 1253 } 1254 else 1255 { 1256 /* Global symbols will need a .plt entry if they remain 1257 global, and in most cases won't need a long branch 1258 stub. Unfortunately, we have to cater for the case 1259 where a symbol is forced local by versioning, or due 1260 to symbolic linking, and we lose the .plt entry. */ 1261 need_entry = NEED_PLT; 1262 if (hh->eh.type == STT_PARISC_MILLI) 1263 need_entry = 0; 1264 } 1265 break; 1266 1267 case R_PARISC_SEGBASE: /* Used to set segment base. */ 1268 case R_PARISC_SEGREL32: /* Relative reloc, used for unwind. */ 1269 case R_PARISC_PCREL14F: /* PC relative load/store. */ 1270 case R_PARISC_PCREL14R: 1271 case R_PARISC_PCREL17R: /* External branches. */ 1272 case R_PARISC_PCREL21L: /* As above, and for load/store too. */ 1273 case R_PARISC_PCREL32: 1274 /* We don't need to propagate the relocation if linking a 1275 shared object since these are section relative. */ 1276 continue; 1277 1278 case R_PARISC_DPREL14F: /* Used for gp rel data load/store. */ 1279 case R_PARISC_DPREL14R: 1280 case R_PARISC_DPREL21L: 1281 if (info->shared) 1282 { 1283 (*_bfd_error_handler) 1284 (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"), 1285 abfd, 1286 elf_hppa_howto_table[r_type].name); 1287 bfd_set_error (bfd_error_bad_value); 1288 return FALSE; 1289 } 1290 /* Fall through. */ 1291 1292 case R_PARISC_DIR17F: /* Used for external branches. */ 1293 case R_PARISC_DIR17R: 1294 case R_PARISC_DIR14F: /* Used for load/store from absolute locn. */ 1295 case R_PARISC_DIR14R: 1296 case R_PARISC_DIR21L: /* As above, and for ext branches too. */ 1297 case R_PARISC_DIR32: /* .word relocs. */ 1298 /* We may want to output a dynamic relocation later. */ 1299 need_entry = NEED_DYNREL; 1300 break; 1301 1302 /* This relocation describes the C++ object vtable hierarchy. 1303 Reconstruct it for later use during GC. */ 1304 case R_PARISC_GNU_VTINHERIT: 1305 if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset)) 1306 return FALSE; 1307 continue; 1308 1309 /* This relocation describes which C++ vtable entries are actually 1310 used. Record for later use during GC. */ 1311 case R_PARISC_GNU_VTENTRY: 1312 BFD_ASSERT (hh != NULL); 1313 if (hh != NULL 1314 && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend)) 1315 return FALSE; 1316 continue; 1317 1318 case R_PARISC_TLS_GD21L: 1319 case R_PARISC_TLS_GD14R: 1320 case R_PARISC_TLS_LDM21L: 1321 case R_PARISC_TLS_LDM14R: 1322 need_entry = NEED_GOT; 1323 break; 1324 1325 case R_PARISC_TLS_IE21L: 1326 case R_PARISC_TLS_IE14R: 1327 if (info->shared) 1328 info->flags |= DF_STATIC_TLS; 1329 need_entry = NEED_GOT; 1330 break; 1331 1332 default: 1333 continue; 1334 } 1335 1336 /* Now carry out our orders. */ 1337 if (need_entry & NEED_GOT) 1338 { 1339 switch (r_type) 1340 { 1341 default: 1342 tls_type = GOT_NORMAL; 1343 break; 1344 case R_PARISC_TLS_GD21L: 1345 case R_PARISC_TLS_GD14R: 1346 tls_type |= GOT_TLS_GD; 1347 break; 1348 case R_PARISC_TLS_LDM21L: 1349 case R_PARISC_TLS_LDM14R: 1350 tls_type |= GOT_TLS_LDM; 1351 break; 1352 case R_PARISC_TLS_IE21L: 1353 case R_PARISC_TLS_IE14R: 1354 tls_type |= GOT_TLS_IE; 1355 break; 1356 } 1357 1358 /* Allocate space for a GOT entry, as well as a dynamic 1359 relocation for this entry. */ 1360 if (htab->sgot == NULL) 1361 { 1362 if (htab->etab.dynobj == NULL) 1363 htab->etab.dynobj = abfd; 1364 if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info)) 1365 return FALSE; 1366 } 1367 1368 if (r_type == R_PARISC_TLS_LDM21L 1369 || r_type == R_PARISC_TLS_LDM14R) 1370 htab->tls_ldm_got.refcount += 1; 1371 else 1372 { 1373 if (hh != NULL) 1374 { 1375 hh->eh.got.refcount += 1; 1376 old_tls_type = hh->tls_type; 1377 } 1378 else 1379 { 1380 bfd_signed_vma *local_got_refcounts; 1381 1382 /* This is a global offset table entry for a local symbol. */ 1383 local_got_refcounts = hppa32_elf_local_refcounts (abfd); 1384 if (local_got_refcounts == NULL) 1385 return FALSE; 1386 local_got_refcounts[r_symndx] += 1; 1387 1388 old_tls_type = hppa_elf_local_got_tls_type (abfd) [r_symndx]; 1389 } 1390 1391 tls_type |= old_tls_type; 1392 1393 if (old_tls_type != tls_type) 1394 { 1395 if (hh != NULL) 1396 hh->tls_type = tls_type; 1397 else 1398 hppa_elf_local_got_tls_type (abfd) [r_symndx] = tls_type; 1399 } 1400 1401 } 1402 } 1403 1404 if (need_entry & NEED_PLT) 1405 { 1406 /* If we are creating a shared library, and this is a reloc 1407 against a weak symbol or a global symbol in a dynamic 1408 object, then we will be creating an import stub and a 1409 .plt entry for the symbol. Similarly, on a normal link 1410 to symbols defined in a dynamic object we'll need the 1411 import stub and a .plt entry. We don't know yet whether 1412 the symbol is defined or not, so make an entry anyway and 1413 clean up later in adjust_dynamic_symbol. */ 1414 if ((sec->flags & SEC_ALLOC) != 0) 1415 { 1416 if (hh != NULL) 1417 { 1418 hh->eh.needs_plt = 1; 1419 hh->eh.plt.refcount += 1; 1420 1421 /* If this .plt entry is for a plabel, mark it so 1422 that adjust_dynamic_symbol will keep the entry 1423 even if it appears to be local. */ 1424 if (need_entry & PLT_PLABEL) 1425 hh->plabel = 1; 1426 } 1427 else if (need_entry & PLT_PLABEL) 1428 { 1429 bfd_signed_vma *local_got_refcounts; 1430 bfd_signed_vma *local_plt_refcounts; 1431 1432 local_got_refcounts = hppa32_elf_local_refcounts (abfd); 1433 if (local_got_refcounts == NULL) 1434 return FALSE; 1435 local_plt_refcounts = (local_got_refcounts 1436 + symtab_hdr->sh_info); 1437 local_plt_refcounts[r_symndx] += 1; 1438 } 1439 } 1440 } 1441 1442 if (need_entry & NEED_DYNREL) 1443 { 1444 /* Flag this symbol as having a non-got, non-plt reference 1445 so that we generate copy relocs if it turns out to be 1446 dynamic. */ 1447 if (hh != NULL && !info->shared) 1448 hh->eh.non_got_ref = 1; 1449 1450 /* If we are creating a shared library then we need to copy 1451 the reloc into the shared library. However, if we are 1452 linking with -Bsymbolic, we need only copy absolute 1453 relocs or relocs against symbols that are not defined in 1454 an object we are including in the link. PC- or DP- or 1455 DLT-relative relocs against any local sym or global sym 1456 with DEF_REGULAR set, can be discarded. At this point we 1457 have not seen all the input files, so it is possible that 1458 DEF_REGULAR is not set now but will be set later (it is 1459 never cleared). We account for that possibility below by 1460 storing information in the dyn_relocs field of the 1461 hash table entry. 1462 1463 A similar situation to the -Bsymbolic case occurs when 1464 creating shared libraries and symbol visibility changes 1465 render the symbol local. 1466 1467 As it turns out, all the relocs we will be creating here 1468 are absolute, so we cannot remove them on -Bsymbolic 1469 links or visibility changes anyway. A STUB_REL reloc 1470 is absolute too, as in that case it is the reloc in the 1471 stub we will be creating, rather than copying the PCREL 1472 reloc in the branch. 1473 1474 If on the other hand, we are creating an executable, we 1475 may need to keep relocations for symbols satisfied by a 1476 dynamic library if we manage to avoid copy relocs for the 1477 symbol. */ 1478 if ((info->shared 1479 && (sec->flags & SEC_ALLOC) != 0 1480 && (IS_ABSOLUTE_RELOC (r_type) 1481 || (hh != NULL 1482 && (!info->symbolic 1483 || hh->eh.root.type == bfd_link_hash_defweak 1484 || !hh->eh.def_regular)))) 1485 || (ELIMINATE_COPY_RELOCS 1486 && !info->shared 1487 && (sec->flags & SEC_ALLOC) != 0 1488 && hh != NULL 1489 && (hh->eh.root.type == bfd_link_hash_defweak 1490 || !hh->eh.def_regular))) 1491 { 1492 struct elf32_hppa_dyn_reloc_entry *hdh_p; 1493 struct elf32_hppa_dyn_reloc_entry **hdh_head; 1494 1495 /* Create a reloc section in dynobj and make room for 1496 this reloc. */ 1497 if (sreloc == NULL) 1498 { 1499 if (htab->etab.dynobj == NULL) 1500 htab->etab.dynobj = abfd; 1501 1502 sreloc = _bfd_elf_make_dynamic_reloc_section 1503 (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE); 1504 1505 if (sreloc == NULL) 1506 { 1507 bfd_set_error (bfd_error_bad_value); 1508 return FALSE; 1509 } 1510 } 1511 1512 /* If this is a global symbol, we count the number of 1513 relocations we need for this symbol. */ 1514 if (hh != NULL) 1515 { 1516 hdh_head = &hh->dyn_relocs; 1517 } 1518 else 1519 { 1520 /* Track dynamic relocs needed for local syms too. 1521 We really need local syms available to do this 1522 easily. Oh well. */ 1523 asection *sr; 1524 void *vpp; 1525 Elf_Internal_Sym *isym; 1526 1527 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 1528 abfd, r_symndx); 1529 if (isym == NULL) 1530 return FALSE; 1531 1532 sr = bfd_section_from_elf_index (abfd, isym->st_shndx); 1533 if (sr == NULL) 1534 sr = sec; 1535 1536 vpp = &elf_section_data (sr)->local_dynrel; 1537 hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp; 1538 } 1539 1540 hdh_p = *hdh_head; 1541 if (hdh_p == NULL || hdh_p->sec != sec) 1542 { 1543 hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p); 1544 if (hdh_p == NULL) 1545 return FALSE; 1546 hdh_p->hdh_next = *hdh_head; 1547 *hdh_head = hdh_p; 1548 hdh_p->sec = sec; 1549 hdh_p->count = 0; 1550 #if RELATIVE_DYNRELOCS 1551 hdh_p->relative_count = 0; 1552 #endif 1553 } 1554 1555 hdh_p->count += 1; 1556 #if RELATIVE_DYNRELOCS 1557 if (!IS_ABSOLUTE_RELOC (rtype)) 1558 hdh_p->relative_count += 1; 1559 #endif 1560 } 1561 } 1562 } 1563 1564 return TRUE; 1565 } 1566 1567 /* Return the section that should be marked against garbage collection 1568 for a given relocation. */ 1569 1570 static asection * 1571 elf32_hppa_gc_mark_hook (asection *sec, 1572 struct bfd_link_info *info, 1573 Elf_Internal_Rela *rela, 1574 struct elf_link_hash_entry *hh, 1575 Elf_Internal_Sym *sym) 1576 { 1577 if (hh != NULL) 1578 switch ((unsigned int) ELF32_R_TYPE (rela->r_info)) 1579 { 1580 case R_PARISC_GNU_VTINHERIT: 1581 case R_PARISC_GNU_VTENTRY: 1582 return NULL; 1583 } 1584 1585 return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym); 1586 } 1587 1588 /* Update the got and plt entry reference counts for the section being 1589 removed. */ 1590 1591 static bfd_boolean 1592 elf32_hppa_gc_sweep_hook (bfd *abfd, 1593 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1594 asection *sec, 1595 const Elf_Internal_Rela *relocs) 1596 { 1597 Elf_Internal_Shdr *symtab_hdr; 1598 struct elf_link_hash_entry **eh_syms; 1599 bfd_signed_vma *local_got_refcounts; 1600 bfd_signed_vma *local_plt_refcounts; 1601 const Elf_Internal_Rela *rela, *relend; 1602 struct elf32_hppa_link_hash_table *htab; 1603 1604 if (info->relocatable) 1605 return TRUE; 1606 1607 htab = hppa_link_hash_table (info); 1608 if (htab == NULL) 1609 return FALSE; 1610 1611 elf_section_data (sec)->local_dynrel = NULL; 1612 1613 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1614 eh_syms = elf_sym_hashes (abfd); 1615 local_got_refcounts = elf_local_got_refcounts (abfd); 1616 local_plt_refcounts = local_got_refcounts; 1617 if (local_plt_refcounts != NULL) 1618 local_plt_refcounts += symtab_hdr->sh_info; 1619 1620 relend = relocs + sec->reloc_count; 1621 for (rela = relocs; rela < relend; rela++) 1622 { 1623 unsigned long r_symndx; 1624 unsigned int r_type; 1625 struct elf_link_hash_entry *eh = NULL; 1626 1627 r_symndx = ELF32_R_SYM (rela->r_info); 1628 if (r_symndx >= symtab_hdr->sh_info) 1629 { 1630 struct elf32_hppa_link_hash_entry *hh; 1631 struct elf32_hppa_dyn_reloc_entry **hdh_pp; 1632 struct elf32_hppa_dyn_reloc_entry *hdh_p; 1633 1634 eh = eh_syms[r_symndx - symtab_hdr->sh_info]; 1635 while (eh->root.type == bfd_link_hash_indirect 1636 || eh->root.type == bfd_link_hash_warning) 1637 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 1638 hh = hppa_elf_hash_entry (eh); 1639 1640 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; hdh_pp = &hdh_p->hdh_next) 1641 if (hdh_p->sec == sec) 1642 { 1643 /* Everything must go for SEC. */ 1644 *hdh_pp = hdh_p->hdh_next; 1645 break; 1646 } 1647 } 1648 1649 r_type = ELF32_R_TYPE (rela->r_info); 1650 r_type = elf32_hppa_optimized_tls_reloc (info, r_type, eh != NULL); 1651 1652 switch (r_type) 1653 { 1654 case R_PARISC_DLTIND14F: 1655 case R_PARISC_DLTIND14R: 1656 case R_PARISC_DLTIND21L: 1657 case R_PARISC_TLS_GD21L: 1658 case R_PARISC_TLS_GD14R: 1659 case R_PARISC_TLS_IE21L: 1660 case R_PARISC_TLS_IE14R: 1661 if (eh != NULL) 1662 { 1663 if (eh->got.refcount > 0) 1664 eh->got.refcount -= 1; 1665 } 1666 else if (local_got_refcounts != NULL) 1667 { 1668 if (local_got_refcounts[r_symndx] > 0) 1669 local_got_refcounts[r_symndx] -= 1; 1670 } 1671 break; 1672 1673 case R_PARISC_TLS_LDM21L: 1674 case R_PARISC_TLS_LDM14R: 1675 htab->tls_ldm_got.refcount -= 1; 1676 break; 1677 1678 case R_PARISC_PCREL12F: 1679 case R_PARISC_PCREL17C: 1680 case R_PARISC_PCREL17F: 1681 case R_PARISC_PCREL22F: 1682 if (eh != NULL) 1683 { 1684 if (eh->plt.refcount > 0) 1685 eh->plt.refcount -= 1; 1686 } 1687 break; 1688 1689 case R_PARISC_PLABEL14R: 1690 case R_PARISC_PLABEL21L: 1691 case R_PARISC_PLABEL32: 1692 if (eh != NULL) 1693 { 1694 if (eh->plt.refcount > 0) 1695 eh->plt.refcount -= 1; 1696 } 1697 else if (local_plt_refcounts != NULL) 1698 { 1699 if (local_plt_refcounts[r_symndx] > 0) 1700 local_plt_refcounts[r_symndx] -= 1; 1701 } 1702 break; 1703 1704 default: 1705 break; 1706 } 1707 } 1708 1709 return TRUE; 1710 } 1711 1712 /* Support for core dump NOTE sections. */ 1713 1714 static bfd_boolean 1715 elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 1716 { 1717 int offset; 1718 size_t size; 1719 1720 switch (note->descsz) 1721 { 1722 default: 1723 return FALSE; 1724 1725 case 396: /* Linux/hppa */ 1726 /* pr_cursig */ 1727 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 1728 1729 /* pr_pid */ 1730 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24); 1731 1732 /* pr_reg */ 1733 offset = 72; 1734 size = 320; 1735 1736 break; 1737 } 1738 1739 /* Make a ".reg/999" section. */ 1740 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 1741 size, note->descpos + offset); 1742 } 1743 1744 static bfd_boolean 1745 elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 1746 { 1747 switch (note->descsz) 1748 { 1749 default: 1750 return FALSE; 1751 1752 case 124: /* Linux/hppa elf_prpsinfo. */ 1753 elf_tdata (abfd)->core_program 1754 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 1755 elf_tdata (abfd)->core_command 1756 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 1757 } 1758 1759 /* Note that for some reason, a spurious space is tacked 1760 onto the end of the args in some (at least one anyway) 1761 implementations, so strip it off if it exists. */ 1762 { 1763 char *command = elf_tdata (abfd)->core_command; 1764 int n = strlen (command); 1765 1766 if (0 < n && command[n - 1] == ' ') 1767 command[n - 1] = '\0'; 1768 } 1769 1770 return TRUE; 1771 } 1772 1773 /* Our own version of hide_symbol, so that we can keep plt entries for 1774 plabels. */ 1775 1776 static void 1777 elf32_hppa_hide_symbol (struct bfd_link_info *info, 1778 struct elf_link_hash_entry *eh, 1779 bfd_boolean force_local) 1780 { 1781 if (force_local) 1782 { 1783 eh->forced_local = 1; 1784 if (eh->dynindx != -1) 1785 { 1786 eh->dynindx = -1; 1787 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1788 eh->dynstr_index); 1789 } 1790 } 1791 1792 if (! hppa_elf_hash_entry (eh)->plabel) 1793 { 1794 eh->needs_plt = 0; 1795 eh->plt = elf_hash_table (info)->init_plt_refcount; 1796 } 1797 } 1798 1799 /* Adjust a symbol defined by a dynamic object and referenced by a 1800 regular object. The current definition is in some section of the 1801 dynamic object, but we're not including those sections. We have to 1802 change the definition to something the rest of the link can 1803 understand. */ 1804 1805 static bfd_boolean 1806 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, 1807 struct elf_link_hash_entry *eh) 1808 { 1809 struct elf32_hppa_link_hash_table *htab; 1810 asection *sec; 1811 1812 /* If this is a function, put it in the procedure linkage table. We 1813 will fill in the contents of the procedure linkage table later. */ 1814 if (eh->type == STT_FUNC 1815 || eh->needs_plt) 1816 { 1817 if (eh->plt.refcount <= 0 1818 || (eh->def_regular 1819 && eh->root.type != bfd_link_hash_defweak 1820 && ! hppa_elf_hash_entry (eh)->plabel 1821 && (!info->shared || info->symbolic))) 1822 { 1823 /* The .plt entry is not needed when: 1824 a) Garbage collection has removed all references to the 1825 symbol, or 1826 b) We know for certain the symbol is defined in this 1827 object, and it's not a weak definition, nor is the symbol 1828 used by a plabel relocation. Either this object is the 1829 application or we are doing a shared symbolic link. */ 1830 1831 eh->plt.offset = (bfd_vma) -1; 1832 eh->needs_plt = 0; 1833 } 1834 1835 return TRUE; 1836 } 1837 else 1838 eh->plt.offset = (bfd_vma) -1; 1839 1840 /* If this is a weak symbol, and there is a real definition, the 1841 processor independent code will have arranged for us to see the 1842 real definition first, and we can just use the same value. */ 1843 if (eh->u.weakdef != NULL) 1844 { 1845 if (eh->u.weakdef->root.type != bfd_link_hash_defined 1846 && eh->u.weakdef->root.type != bfd_link_hash_defweak) 1847 abort (); 1848 eh->root.u.def.section = eh->u.weakdef->root.u.def.section; 1849 eh->root.u.def.value = eh->u.weakdef->root.u.def.value; 1850 if (ELIMINATE_COPY_RELOCS) 1851 eh->non_got_ref = eh->u.weakdef->non_got_ref; 1852 return TRUE; 1853 } 1854 1855 /* This is a reference to a symbol defined by a dynamic object which 1856 is not a function. */ 1857 1858 /* If we are creating a shared library, we must presume that the 1859 only references to the symbol are via the global offset table. 1860 For such cases we need not do anything here; the relocations will 1861 be handled correctly by relocate_section. */ 1862 if (info->shared) 1863 return TRUE; 1864 1865 /* If there are no references to this symbol that do not use the 1866 GOT, we don't need to generate a copy reloc. */ 1867 if (!eh->non_got_ref) 1868 return TRUE; 1869 1870 if (ELIMINATE_COPY_RELOCS) 1871 { 1872 struct elf32_hppa_link_hash_entry *hh; 1873 struct elf32_hppa_dyn_reloc_entry *hdh_p; 1874 1875 hh = hppa_elf_hash_entry (eh); 1876 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 1877 { 1878 sec = hdh_p->sec->output_section; 1879 if (sec != NULL && (sec->flags & SEC_READONLY) != 0) 1880 break; 1881 } 1882 1883 /* If we didn't find any dynamic relocs in read-only sections, then 1884 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1885 if (hdh_p == NULL) 1886 { 1887 eh->non_got_ref = 0; 1888 return TRUE; 1889 } 1890 } 1891 1892 if (eh->size == 0) 1893 { 1894 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 1895 eh->root.root.string); 1896 return TRUE; 1897 } 1898 1899 /* We must allocate the symbol in our .dynbss section, which will 1900 become part of the .bss section of the executable. There will be 1901 an entry for this symbol in the .dynsym section. The dynamic 1902 object will contain position independent code, so all references 1903 from the dynamic object to this symbol will go through the global 1904 offset table. The dynamic linker will use the .dynsym entry to 1905 determine the address it must put in the global offset table, so 1906 both the dynamic object and the regular object will refer to the 1907 same memory location for the variable. */ 1908 1909 htab = hppa_link_hash_table (info); 1910 if (htab == NULL) 1911 return FALSE; 1912 1913 /* We must generate a COPY reloc to tell the dynamic linker to 1914 copy the initial value out of the dynamic object and into the 1915 runtime process image. */ 1916 if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0) 1917 { 1918 htab->srelbss->size += sizeof (Elf32_External_Rela); 1919 eh->needs_copy = 1; 1920 } 1921 1922 sec = htab->sdynbss; 1923 1924 return _bfd_elf_adjust_dynamic_copy (eh, sec); 1925 } 1926 1927 /* Allocate space in the .plt for entries that won't have relocations. 1928 ie. plabel entries. */ 1929 1930 static bfd_boolean 1931 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf) 1932 { 1933 struct bfd_link_info *info; 1934 struct elf32_hppa_link_hash_table *htab; 1935 struct elf32_hppa_link_hash_entry *hh; 1936 asection *sec; 1937 1938 if (eh->root.type == bfd_link_hash_indirect) 1939 return TRUE; 1940 1941 if (eh->root.type == bfd_link_hash_warning) 1942 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 1943 1944 info = (struct bfd_link_info *) inf; 1945 hh = hppa_elf_hash_entry (eh); 1946 htab = hppa_link_hash_table (info); 1947 if (htab == NULL) 1948 return FALSE; 1949 1950 if (htab->etab.dynamic_sections_created 1951 && eh->plt.refcount > 0) 1952 { 1953 /* Make sure this symbol is output as a dynamic symbol. 1954 Undefined weak syms won't yet be marked as dynamic. */ 1955 if (eh->dynindx == -1 1956 && !eh->forced_local 1957 && eh->type != STT_PARISC_MILLI) 1958 { 1959 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 1960 return FALSE; 1961 } 1962 1963 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, eh)) 1964 { 1965 /* Allocate these later. From this point on, h->plabel 1966 means that the plt entry is only used by a plabel. 1967 We'll be using a normal plt entry for this symbol, so 1968 clear the plabel indicator. */ 1969 1970 hh->plabel = 0; 1971 } 1972 else if (hh->plabel) 1973 { 1974 /* Make an entry in the .plt section for plabel references 1975 that won't have a .plt entry for other reasons. */ 1976 sec = htab->splt; 1977 eh->plt.offset = sec->size; 1978 sec->size += PLT_ENTRY_SIZE; 1979 } 1980 else 1981 { 1982 /* No .plt entry needed. */ 1983 eh->plt.offset = (bfd_vma) -1; 1984 eh->needs_plt = 0; 1985 } 1986 } 1987 else 1988 { 1989 eh->plt.offset = (bfd_vma) -1; 1990 eh->needs_plt = 0; 1991 } 1992 1993 return TRUE; 1994 } 1995 1996 /* Allocate space in .plt, .got and associated reloc sections for 1997 global syms. */ 1998 1999 static bfd_boolean 2000 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf) 2001 { 2002 struct bfd_link_info *info; 2003 struct elf32_hppa_link_hash_table *htab; 2004 asection *sec; 2005 struct elf32_hppa_link_hash_entry *hh; 2006 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2007 2008 if (eh->root.type == bfd_link_hash_indirect) 2009 return TRUE; 2010 2011 if (eh->root.type == bfd_link_hash_warning) 2012 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 2013 2014 info = inf; 2015 htab = hppa_link_hash_table (info); 2016 if (htab == NULL) 2017 return FALSE; 2018 2019 hh = hppa_elf_hash_entry (eh); 2020 2021 if (htab->etab.dynamic_sections_created 2022 && eh->plt.offset != (bfd_vma) -1 2023 && !hh->plabel 2024 && eh->plt.refcount > 0) 2025 { 2026 /* Make an entry in the .plt section. */ 2027 sec = htab->splt; 2028 eh->plt.offset = sec->size; 2029 sec->size += PLT_ENTRY_SIZE; 2030 2031 /* We also need to make an entry in the .rela.plt section. */ 2032 htab->srelplt->size += sizeof (Elf32_External_Rela); 2033 htab->need_plt_stub = 1; 2034 } 2035 2036 if (eh->got.refcount > 0) 2037 { 2038 /* Make sure this symbol is output as a dynamic symbol. 2039 Undefined weak syms won't yet be marked as dynamic. */ 2040 if (eh->dynindx == -1 2041 && !eh->forced_local 2042 && eh->type != STT_PARISC_MILLI) 2043 { 2044 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2045 return FALSE; 2046 } 2047 2048 sec = htab->sgot; 2049 eh->got.offset = sec->size; 2050 sec->size += GOT_ENTRY_SIZE; 2051 /* R_PARISC_TLS_GD* needs two GOT entries */ 2052 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2053 sec->size += GOT_ENTRY_SIZE * 2; 2054 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2055 sec->size += GOT_ENTRY_SIZE; 2056 if (htab->etab.dynamic_sections_created 2057 && (info->shared 2058 || (eh->dynindx != -1 2059 && !eh->forced_local))) 2060 { 2061 htab->srelgot->size += sizeof (Elf32_External_Rela); 2062 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2063 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela); 2064 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2065 htab->srelgot->size += sizeof (Elf32_External_Rela); 2066 } 2067 } 2068 else 2069 eh->got.offset = (bfd_vma) -1; 2070 2071 if (hh->dyn_relocs == NULL) 2072 return TRUE; 2073 2074 /* If this is a -Bsymbolic shared link, then we need to discard all 2075 space allocated for dynamic pc-relative relocs against symbols 2076 defined in a regular object. For the normal shared case, discard 2077 space for relocs that have become local due to symbol visibility 2078 changes. */ 2079 if (info->shared) 2080 { 2081 #if RELATIVE_DYNRELOCS 2082 if (SYMBOL_CALLS_LOCAL (info, eh)) 2083 { 2084 struct elf32_hppa_dyn_reloc_entry **hdh_pp; 2085 2086 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; ) 2087 { 2088 hdh_p->count -= hdh_p->relative_count; 2089 hdh_p->relative_count = 0; 2090 if (hdh_p->count == 0) 2091 *hdh_pp = hdh_p->hdh_next; 2092 else 2093 hdh_pp = &hdh_p->hdh_next; 2094 } 2095 } 2096 #endif 2097 2098 /* Also discard relocs on undefined weak syms with non-default 2099 visibility. */ 2100 if (hh->dyn_relocs != NULL 2101 && eh->root.type == bfd_link_hash_undefweak) 2102 { 2103 if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT) 2104 hh->dyn_relocs = NULL; 2105 2106 /* Make sure undefined weak symbols are output as a dynamic 2107 symbol in PIEs. */ 2108 else if (eh->dynindx == -1 2109 && !eh->forced_local) 2110 { 2111 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2112 return FALSE; 2113 } 2114 } 2115 } 2116 else 2117 { 2118 /* For the non-shared case, discard space for relocs against 2119 symbols which turn out to need copy relocs or are not 2120 dynamic. */ 2121 2122 if (!eh->non_got_ref 2123 && ((ELIMINATE_COPY_RELOCS 2124 && eh->def_dynamic 2125 && !eh->def_regular) 2126 || (htab->etab.dynamic_sections_created 2127 && (eh->root.type == bfd_link_hash_undefweak 2128 || eh->root.type == bfd_link_hash_undefined)))) 2129 { 2130 /* Make sure this symbol is output as a dynamic symbol. 2131 Undefined weak syms won't yet be marked as dynamic. */ 2132 if (eh->dynindx == -1 2133 && !eh->forced_local 2134 && eh->type != STT_PARISC_MILLI) 2135 { 2136 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2137 return FALSE; 2138 } 2139 2140 /* If that succeeded, we know we'll be keeping all the 2141 relocs. */ 2142 if (eh->dynindx != -1) 2143 goto keep; 2144 } 2145 2146 hh->dyn_relocs = NULL; 2147 return TRUE; 2148 2149 keep: ; 2150 } 2151 2152 /* Finally, allocate space. */ 2153 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 2154 { 2155 asection *sreloc = elf_section_data (hdh_p->sec)->sreloc; 2156 sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela); 2157 } 2158 2159 return TRUE; 2160 } 2161 2162 /* This function is called via elf_link_hash_traverse to force 2163 millicode symbols local so they do not end up as globals in the 2164 dynamic symbol table. We ought to be able to do this in 2165 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called 2166 for all dynamic symbols. Arguably, this is a bug in 2167 elf_adjust_dynamic_symbol. */ 2168 2169 static bfd_boolean 2170 clobber_millicode_symbols (struct elf_link_hash_entry *eh, 2171 struct bfd_link_info *info) 2172 { 2173 if (eh->root.type == bfd_link_hash_warning) 2174 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 2175 2176 if (eh->type == STT_PARISC_MILLI 2177 && !eh->forced_local) 2178 { 2179 elf32_hppa_hide_symbol (info, eh, TRUE); 2180 } 2181 return TRUE; 2182 } 2183 2184 /* Find any dynamic relocs that apply to read-only sections. */ 2185 2186 static bfd_boolean 2187 readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf) 2188 { 2189 struct elf32_hppa_link_hash_entry *hh; 2190 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2191 2192 if (eh->root.type == bfd_link_hash_warning) 2193 eh = (struct elf_link_hash_entry *) eh->root.u.i.link; 2194 2195 hh = hppa_elf_hash_entry (eh); 2196 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 2197 { 2198 asection *sec = hdh_p->sec->output_section; 2199 2200 if (sec != NULL && (sec->flags & SEC_READONLY) != 0) 2201 { 2202 struct bfd_link_info *info = inf; 2203 2204 if (info->warn_shared_textrel) 2205 (*_bfd_error_handler) 2206 (_("warning: dynamic relocation in readonly section `%s'"), 2207 eh->root.root.string); 2208 info->flags |= DF_TEXTREL; 2209 2210 /* Not an error, just cut short the traversal. */ 2211 return FALSE; 2212 } 2213 } 2214 return TRUE; 2215 } 2216 2217 /* Set the sizes of the dynamic sections. */ 2218 2219 static bfd_boolean 2220 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2221 struct bfd_link_info *info) 2222 { 2223 struct elf32_hppa_link_hash_table *htab; 2224 bfd *dynobj; 2225 bfd *ibfd; 2226 asection *sec; 2227 bfd_boolean relocs; 2228 2229 htab = hppa_link_hash_table (info); 2230 if (htab == NULL) 2231 return FALSE; 2232 2233 dynobj = htab->etab.dynobj; 2234 if (dynobj == NULL) 2235 abort (); 2236 2237 if (htab->etab.dynamic_sections_created) 2238 { 2239 /* Set the contents of the .interp section to the interpreter. */ 2240 if (info->executable) 2241 { 2242 sec = bfd_get_section_by_name (dynobj, ".interp"); 2243 if (sec == NULL) 2244 abort (); 2245 sec->size = sizeof ELF_DYNAMIC_INTERPRETER; 2246 sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2247 } 2248 2249 /* Force millicode symbols local. */ 2250 elf_link_hash_traverse (&htab->etab, 2251 clobber_millicode_symbols, 2252 info); 2253 } 2254 2255 /* Set up .got and .plt offsets for local syms, and space for local 2256 dynamic relocs. */ 2257 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 2258 { 2259 bfd_signed_vma *local_got; 2260 bfd_signed_vma *end_local_got; 2261 bfd_signed_vma *local_plt; 2262 bfd_signed_vma *end_local_plt; 2263 bfd_size_type locsymcount; 2264 Elf_Internal_Shdr *symtab_hdr; 2265 asection *srel; 2266 char *local_tls_type; 2267 2268 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 2269 continue; 2270 2271 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 2272 { 2273 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2274 2275 for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *) 2276 elf_section_data (sec)->local_dynrel); 2277 hdh_p != NULL; 2278 hdh_p = hdh_p->hdh_next) 2279 { 2280 if (!bfd_is_abs_section (hdh_p->sec) 2281 && bfd_is_abs_section (hdh_p->sec->output_section)) 2282 { 2283 /* Input section has been discarded, either because 2284 it is a copy of a linkonce section or due to 2285 linker script /DISCARD/, so we'll be discarding 2286 the relocs too. */ 2287 } 2288 else if (hdh_p->count != 0) 2289 { 2290 srel = elf_section_data (hdh_p->sec)->sreloc; 2291 srel->size += hdh_p->count * sizeof (Elf32_External_Rela); 2292 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0) 2293 info->flags |= DF_TEXTREL; 2294 } 2295 } 2296 } 2297 2298 local_got = elf_local_got_refcounts (ibfd); 2299 if (!local_got) 2300 continue; 2301 2302 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2303 locsymcount = symtab_hdr->sh_info; 2304 end_local_got = local_got + locsymcount; 2305 local_tls_type = hppa_elf_local_got_tls_type (ibfd); 2306 sec = htab->sgot; 2307 srel = htab->srelgot; 2308 for (; local_got < end_local_got; ++local_got) 2309 { 2310 if (*local_got > 0) 2311 { 2312 *local_got = sec->size; 2313 sec->size += GOT_ENTRY_SIZE; 2314 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2315 sec->size += 2 * GOT_ENTRY_SIZE; 2316 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2317 sec->size += GOT_ENTRY_SIZE; 2318 if (info->shared) 2319 { 2320 srel->size += sizeof (Elf32_External_Rela); 2321 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2322 srel->size += 2 * sizeof (Elf32_External_Rela); 2323 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2324 srel->size += sizeof (Elf32_External_Rela); 2325 } 2326 } 2327 else 2328 *local_got = (bfd_vma) -1; 2329 2330 ++local_tls_type; 2331 } 2332 2333 local_plt = end_local_got; 2334 end_local_plt = local_plt + locsymcount; 2335 if (! htab->etab.dynamic_sections_created) 2336 { 2337 /* Won't be used, but be safe. */ 2338 for (; local_plt < end_local_plt; ++local_plt) 2339 *local_plt = (bfd_vma) -1; 2340 } 2341 else 2342 { 2343 sec = htab->splt; 2344 srel = htab->srelplt; 2345 for (; local_plt < end_local_plt; ++local_plt) 2346 { 2347 if (*local_plt > 0) 2348 { 2349 *local_plt = sec->size; 2350 sec->size += PLT_ENTRY_SIZE; 2351 if (info->shared) 2352 srel->size += sizeof (Elf32_External_Rela); 2353 } 2354 else 2355 *local_plt = (bfd_vma) -1; 2356 } 2357 } 2358 } 2359 2360 if (htab->tls_ldm_got.refcount > 0) 2361 { 2362 /* Allocate 2 got entries and 1 dynamic reloc for 2363 R_PARISC_TLS_DTPMOD32 relocs. */ 2364 htab->tls_ldm_got.offset = htab->sgot->size; 2365 htab->sgot->size += (GOT_ENTRY_SIZE * 2); 2366 htab->srelgot->size += sizeof (Elf32_External_Rela); 2367 } 2368 else 2369 htab->tls_ldm_got.offset = -1; 2370 2371 /* Do all the .plt entries without relocs first. The dynamic linker 2372 uses the last .plt reloc to find the end of the .plt (and hence 2373 the start of the .got) for lazy linking. */ 2374 elf_link_hash_traverse (&htab->etab, allocate_plt_static, info); 2375 2376 /* Allocate global sym .plt and .got entries, and space for global 2377 sym dynamic relocs. */ 2378 elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info); 2379 2380 /* The check_relocs and adjust_dynamic_symbol entry points have 2381 determined the sizes of the various dynamic sections. Allocate 2382 memory for them. */ 2383 relocs = FALSE; 2384 for (sec = dynobj->sections; sec != NULL; sec = sec->next) 2385 { 2386 if ((sec->flags & SEC_LINKER_CREATED) == 0) 2387 continue; 2388 2389 if (sec == htab->splt) 2390 { 2391 if (htab->need_plt_stub) 2392 { 2393 /* Make space for the plt stub at the end of the .plt 2394 section. We want this stub right at the end, up 2395 against the .got section. */ 2396 int gotalign = bfd_section_alignment (dynobj, htab->sgot); 2397 int pltalign = bfd_section_alignment (dynobj, sec); 2398 bfd_size_type mask; 2399 2400 if (gotalign > pltalign) 2401 bfd_set_section_alignment (dynobj, sec, gotalign); 2402 mask = ((bfd_size_type) 1 << gotalign) - 1; 2403 sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask; 2404 } 2405 } 2406 else if (sec == htab->sgot 2407 || sec == htab->sdynbss) 2408 ; 2409 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela")) 2410 { 2411 if (sec->size != 0) 2412 { 2413 /* Remember whether there are any reloc sections other 2414 than .rela.plt. */ 2415 if (sec != htab->srelplt) 2416 relocs = TRUE; 2417 2418 /* We use the reloc_count field as a counter if we need 2419 to copy relocs into the output file. */ 2420 sec->reloc_count = 0; 2421 } 2422 } 2423 else 2424 { 2425 /* It's not one of our sections, so don't allocate space. */ 2426 continue; 2427 } 2428 2429 if (sec->size == 0) 2430 { 2431 /* If we don't need this section, strip it from the 2432 output file. This is mostly to handle .rela.bss and 2433 .rela.plt. We must create both sections in 2434 create_dynamic_sections, because they must be created 2435 before the linker maps input sections to output 2436 sections. The linker does that before 2437 adjust_dynamic_symbol is called, and it is that 2438 function which decides whether anything needs to go 2439 into these sections. */ 2440 sec->flags |= SEC_EXCLUDE; 2441 continue; 2442 } 2443 2444 if ((sec->flags & SEC_HAS_CONTENTS) == 0) 2445 continue; 2446 2447 /* Allocate memory for the section contents. Zero it, because 2448 we may not fill in all the reloc sections. */ 2449 sec->contents = bfd_zalloc (dynobj, sec->size); 2450 if (sec->contents == NULL) 2451 return FALSE; 2452 } 2453 2454 if (htab->etab.dynamic_sections_created) 2455 { 2456 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It 2457 actually has nothing to do with the PLT, it is how we 2458 communicate the LTP value of a load module to the dynamic 2459 linker. */ 2460 #define add_dynamic_entry(TAG, VAL) \ 2461 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2462 2463 if (!add_dynamic_entry (DT_PLTGOT, 0)) 2464 return FALSE; 2465 2466 /* Add some entries to the .dynamic section. We fill in the 2467 values later, in elf32_hppa_finish_dynamic_sections, but we 2468 must add the entries now so that we get the correct size for 2469 the .dynamic section. The DT_DEBUG entry is filled in by the 2470 dynamic linker and used by the debugger. */ 2471 if (info->executable) 2472 { 2473 if (!add_dynamic_entry (DT_DEBUG, 0)) 2474 return FALSE; 2475 } 2476 2477 if (htab->srelplt->size != 0) 2478 { 2479 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 2480 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2481 || !add_dynamic_entry (DT_JMPREL, 0)) 2482 return FALSE; 2483 } 2484 2485 if (relocs) 2486 { 2487 if (!add_dynamic_entry (DT_RELA, 0) 2488 || !add_dynamic_entry (DT_RELASZ, 0) 2489 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 2490 return FALSE; 2491 2492 /* If any dynamic relocs apply to a read-only section, 2493 then we need a DT_TEXTREL entry. */ 2494 if ((info->flags & DF_TEXTREL) == 0) 2495 elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info); 2496 2497 if ((info->flags & DF_TEXTREL) != 0) 2498 { 2499 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2500 return FALSE; 2501 } 2502 } 2503 } 2504 #undef add_dynamic_entry 2505 2506 return TRUE; 2507 } 2508 2509 /* External entry points for sizing and building linker stubs. */ 2510 2511 /* Set up various things so that we can make a list of input sections 2512 for each output section included in the link. Returns -1 on error, 2513 0 when no stubs will be needed, and 1 on success. */ 2514 2515 int 2516 elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info) 2517 { 2518 bfd *input_bfd; 2519 unsigned int bfd_count; 2520 int top_id, top_index; 2521 asection *section; 2522 asection **input_list, **list; 2523 bfd_size_type amt; 2524 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2525 2526 if (htab == NULL) 2527 return -1; 2528 2529 /* Count the number of input BFDs and find the top input section id. */ 2530 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0; 2531 input_bfd != NULL; 2532 input_bfd = input_bfd->link_next) 2533 { 2534 bfd_count += 1; 2535 for (section = input_bfd->sections; 2536 section != NULL; 2537 section = section->next) 2538 { 2539 if (top_id < section->id) 2540 top_id = section->id; 2541 } 2542 } 2543 htab->bfd_count = bfd_count; 2544 2545 amt = sizeof (struct map_stub) * (top_id + 1); 2546 htab->stub_group = bfd_zmalloc (amt); 2547 if (htab->stub_group == NULL) 2548 return -1; 2549 2550 /* We can't use output_bfd->section_count here to find the top output 2551 section index as some sections may have been removed, and 2552 strip_excluded_output_sections doesn't renumber the indices. */ 2553 for (section = output_bfd->sections, top_index = 0; 2554 section != NULL; 2555 section = section->next) 2556 { 2557 if (top_index < section->index) 2558 top_index = section->index; 2559 } 2560 2561 htab->top_index = top_index; 2562 amt = sizeof (asection *) * (top_index + 1); 2563 input_list = bfd_malloc (amt); 2564 htab->input_list = input_list; 2565 if (input_list == NULL) 2566 return -1; 2567 2568 /* For sections we aren't interested in, mark their entries with a 2569 value we can check later. */ 2570 list = input_list + top_index; 2571 do 2572 *list = bfd_abs_section_ptr; 2573 while (list-- != input_list); 2574 2575 for (section = output_bfd->sections; 2576 section != NULL; 2577 section = section->next) 2578 { 2579 if ((section->flags & SEC_CODE) != 0) 2580 input_list[section->index] = NULL; 2581 } 2582 2583 return 1; 2584 } 2585 2586 /* The linker repeatedly calls this function for each input section, 2587 in the order that input sections are linked into output sections. 2588 Build lists of input sections to determine groupings between which 2589 we may insert linker stubs. */ 2590 2591 void 2592 elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec) 2593 { 2594 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2595 2596 if (htab == NULL) 2597 return; 2598 2599 if (isec->output_section->index <= htab->top_index) 2600 { 2601 asection **list = htab->input_list + isec->output_section->index; 2602 if (*list != bfd_abs_section_ptr) 2603 { 2604 /* Steal the link_sec pointer for our list. */ 2605 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec) 2606 /* This happens to make the list in reverse order, 2607 which is what we want. */ 2608 PREV_SEC (isec) = *list; 2609 *list = isec; 2610 } 2611 } 2612 } 2613 2614 /* See whether we can group stub sections together. Grouping stub 2615 sections may result in fewer stubs. More importantly, we need to 2616 put all .init* and .fini* stubs at the beginning of the .init or 2617 .fini output sections respectively, because glibc splits the 2618 _init and _fini functions into multiple parts. Putting a stub in 2619 the middle of a function is not a good idea. */ 2620 2621 static void 2622 group_sections (struct elf32_hppa_link_hash_table *htab, 2623 bfd_size_type stub_group_size, 2624 bfd_boolean stubs_always_before_branch) 2625 { 2626 asection **list = htab->input_list + htab->top_index; 2627 do 2628 { 2629 asection *tail = *list; 2630 if (tail == bfd_abs_section_ptr) 2631 continue; 2632 while (tail != NULL) 2633 { 2634 asection *curr; 2635 asection *prev; 2636 bfd_size_type total; 2637 bfd_boolean big_sec; 2638 2639 curr = tail; 2640 total = tail->size; 2641 big_sec = total >= stub_group_size; 2642 2643 while ((prev = PREV_SEC (curr)) != NULL 2644 && ((total += curr->output_offset - prev->output_offset) 2645 < stub_group_size)) 2646 curr = prev; 2647 2648 /* OK, the size from the start of CURR to the end is less 2649 than 240000 bytes and thus can be handled by one stub 2650 section. (or the tail section is itself larger than 2651 240000 bytes, in which case we may be toast.) 2652 We should really be keeping track of the total size of 2653 stubs added here, as stubs contribute to the final output 2654 section size. That's a little tricky, and this way will 2655 only break if stubs added total more than 22144 bytes, or 2656 2768 long branch stubs. It seems unlikely for more than 2657 2768 different functions to be called, especially from 2658 code only 240000 bytes long. This limit used to be 2659 250000, but c++ code tends to generate lots of little 2660 functions, and sometimes violated the assumption. */ 2661 do 2662 { 2663 prev = PREV_SEC (tail); 2664 /* Set up this stub group. */ 2665 htab->stub_group[tail->id].link_sec = curr; 2666 } 2667 while (tail != curr && (tail = prev) != NULL); 2668 2669 /* But wait, there's more! Input sections up to 240000 2670 bytes before the stub section can be handled by it too. 2671 Don't do this if we have a really large section after the 2672 stubs, as adding more stubs increases the chance that 2673 branches may not reach into the stub section. */ 2674 if (!stubs_always_before_branch && !big_sec) 2675 { 2676 total = 0; 2677 while (prev != NULL 2678 && ((total += tail->output_offset - prev->output_offset) 2679 < stub_group_size)) 2680 { 2681 tail = prev; 2682 prev = PREV_SEC (tail); 2683 htab->stub_group[tail->id].link_sec = curr; 2684 } 2685 } 2686 tail = prev; 2687 } 2688 } 2689 while (list-- != htab->input_list); 2690 free (htab->input_list); 2691 #undef PREV_SEC 2692 } 2693 2694 /* Read in all local syms for all input bfds, and create hash entries 2695 for export stubs if we are building a multi-subspace shared lib. 2696 Returns -1 on error, 1 if export stubs created, 0 otherwise. */ 2697 2698 static int 2699 get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info) 2700 { 2701 unsigned int bfd_indx; 2702 Elf_Internal_Sym *local_syms, **all_local_syms; 2703 int stub_changed = 0; 2704 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2705 2706 if (htab == NULL) 2707 return -1; 2708 2709 /* We want to read in symbol extension records only once. To do this 2710 we need to read in the local symbols in parallel and save them for 2711 later use; so hold pointers to the local symbols in an array. */ 2712 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count; 2713 all_local_syms = bfd_zmalloc (amt); 2714 htab->all_local_syms = all_local_syms; 2715 if (all_local_syms == NULL) 2716 return -1; 2717 2718 /* Walk over all the input BFDs, swapping in local symbols. 2719 If we are creating a shared library, create hash entries for the 2720 export stubs. */ 2721 for (bfd_indx = 0; 2722 input_bfd != NULL; 2723 input_bfd = input_bfd->link_next, bfd_indx++) 2724 { 2725 Elf_Internal_Shdr *symtab_hdr; 2726 2727 /* We'll need the symbol table in a second. */ 2728 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2729 if (symtab_hdr->sh_info == 0) 2730 continue; 2731 2732 /* We need an array of the local symbols attached to the input bfd. */ 2733 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 2734 if (local_syms == NULL) 2735 { 2736 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 2737 symtab_hdr->sh_info, 0, 2738 NULL, NULL, NULL); 2739 /* Cache them for elf_link_input_bfd. */ 2740 symtab_hdr->contents = (unsigned char *) local_syms; 2741 } 2742 if (local_syms == NULL) 2743 return -1; 2744 2745 all_local_syms[bfd_indx] = local_syms; 2746 2747 if (info->shared && htab->multi_subspace) 2748 { 2749 struct elf_link_hash_entry **eh_syms; 2750 struct elf_link_hash_entry **eh_symend; 2751 unsigned int symcount; 2752 2753 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2754 - symtab_hdr->sh_info); 2755 eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd); 2756 eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount); 2757 2758 /* Look through the global syms for functions; We need to 2759 build export stubs for all globally visible functions. */ 2760 for (; eh_syms < eh_symend; eh_syms++) 2761 { 2762 struct elf32_hppa_link_hash_entry *hh; 2763 2764 hh = hppa_elf_hash_entry (*eh_syms); 2765 2766 while (hh->eh.root.type == bfd_link_hash_indirect 2767 || hh->eh.root.type == bfd_link_hash_warning) 2768 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 2769 2770 /* At this point in the link, undefined syms have been 2771 resolved, so we need to check that the symbol was 2772 defined in this BFD. */ 2773 if ((hh->eh.root.type == bfd_link_hash_defined 2774 || hh->eh.root.type == bfd_link_hash_defweak) 2775 && hh->eh.type == STT_FUNC 2776 && hh->eh.root.u.def.section->output_section != NULL 2777 && (hh->eh.root.u.def.section->output_section->owner 2778 == output_bfd) 2779 && hh->eh.root.u.def.section->owner == input_bfd 2780 && hh->eh.def_regular 2781 && !hh->eh.forced_local 2782 && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT) 2783 { 2784 asection *sec; 2785 const char *stub_name; 2786 struct elf32_hppa_stub_hash_entry *hsh; 2787 2788 sec = hh->eh.root.u.def.section; 2789 stub_name = hh_name (hh); 2790 hsh = hppa_stub_hash_lookup (&htab->bstab, 2791 stub_name, 2792 FALSE, FALSE); 2793 if (hsh == NULL) 2794 { 2795 hsh = hppa_add_stub (stub_name, sec, htab); 2796 if (!hsh) 2797 return -1; 2798 2799 hsh->target_value = hh->eh.root.u.def.value; 2800 hsh->target_section = hh->eh.root.u.def.section; 2801 hsh->stub_type = hppa_stub_export; 2802 hsh->hh = hh; 2803 stub_changed = 1; 2804 } 2805 else 2806 { 2807 (*_bfd_error_handler) (_("%B: duplicate export stub %s"), 2808 input_bfd, 2809 stub_name); 2810 } 2811 } 2812 } 2813 } 2814 } 2815 2816 return stub_changed; 2817 } 2818 2819 /* Determine and set the size of the stub section for a final link. 2820 2821 The basic idea here is to examine all the relocations looking for 2822 PC-relative calls to a target that is unreachable with a "bl" 2823 instruction. */ 2824 2825 bfd_boolean 2826 elf32_hppa_size_stubs 2827 (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info, 2828 bfd_boolean multi_subspace, bfd_signed_vma group_size, 2829 asection * (*add_stub_section) (const char *, asection *), 2830 void (*layout_sections_again) (void)) 2831 { 2832 bfd_size_type stub_group_size; 2833 bfd_boolean stubs_always_before_branch; 2834 bfd_boolean stub_changed; 2835 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2836 2837 if (htab == NULL) 2838 return FALSE; 2839 2840 /* Stash our params away. */ 2841 htab->stub_bfd = stub_bfd; 2842 htab->multi_subspace = multi_subspace; 2843 htab->add_stub_section = add_stub_section; 2844 htab->layout_sections_again = layout_sections_again; 2845 stubs_always_before_branch = group_size < 0; 2846 if (group_size < 0) 2847 stub_group_size = -group_size; 2848 else 2849 stub_group_size = group_size; 2850 if (stub_group_size == 1) 2851 { 2852 /* Default values. */ 2853 if (stubs_always_before_branch) 2854 { 2855 stub_group_size = 7680000; 2856 if (htab->has_17bit_branch || htab->multi_subspace) 2857 stub_group_size = 240000; 2858 if (htab->has_12bit_branch) 2859 stub_group_size = 7500; 2860 } 2861 else 2862 { 2863 stub_group_size = 6971392; 2864 if (htab->has_17bit_branch || htab->multi_subspace) 2865 stub_group_size = 217856; 2866 if (htab->has_12bit_branch) 2867 stub_group_size = 6808; 2868 } 2869 } 2870 2871 group_sections (htab, stub_group_size, stubs_always_before_branch); 2872 2873 switch (get_local_syms (output_bfd, info->input_bfds, info)) 2874 { 2875 default: 2876 if (htab->all_local_syms) 2877 goto error_ret_free_local; 2878 return FALSE; 2879 2880 case 0: 2881 stub_changed = FALSE; 2882 break; 2883 2884 case 1: 2885 stub_changed = TRUE; 2886 break; 2887 } 2888 2889 while (1) 2890 { 2891 bfd *input_bfd; 2892 unsigned int bfd_indx; 2893 asection *stub_sec; 2894 2895 for (input_bfd = info->input_bfds, bfd_indx = 0; 2896 input_bfd != NULL; 2897 input_bfd = input_bfd->link_next, bfd_indx++) 2898 { 2899 Elf_Internal_Shdr *symtab_hdr; 2900 asection *section; 2901 Elf_Internal_Sym *local_syms; 2902 2903 /* We'll need the symbol table in a second. */ 2904 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2905 if (symtab_hdr->sh_info == 0) 2906 continue; 2907 2908 local_syms = htab->all_local_syms[bfd_indx]; 2909 2910 /* Walk over each section attached to the input bfd. */ 2911 for (section = input_bfd->sections; 2912 section != NULL; 2913 section = section->next) 2914 { 2915 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 2916 2917 /* If there aren't any relocs, then there's nothing more 2918 to do. */ 2919 if ((section->flags & SEC_RELOC) == 0 2920 || section->reloc_count == 0) 2921 continue; 2922 2923 /* If this section is a link-once section that will be 2924 discarded, then don't create any stubs. */ 2925 if (section->output_section == NULL 2926 || section->output_section->owner != output_bfd) 2927 continue; 2928 2929 /* Get the relocs. */ 2930 internal_relocs 2931 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL, 2932 info->keep_memory); 2933 if (internal_relocs == NULL) 2934 goto error_ret_free_local; 2935 2936 /* Now examine each relocation. */ 2937 irela = internal_relocs; 2938 irelaend = irela + section->reloc_count; 2939 for (; irela < irelaend; irela++) 2940 { 2941 unsigned int r_type, r_indx; 2942 enum elf32_hppa_stub_type stub_type; 2943 struct elf32_hppa_stub_hash_entry *hsh; 2944 asection *sym_sec; 2945 bfd_vma sym_value; 2946 bfd_vma destination; 2947 struct elf32_hppa_link_hash_entry *hh; 2948 char *stub_name; 2949 const asection *id_sec; 2950 2951 r_type = ELF32_R_TYPE (irela->r_info); 2952 r_indx = ELF32_R_SYM (irela->r_info); 2953 2954 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED) 2955 { 2956 bfd_set_error (bfd_error_bad_value); 2957 error_ret_free_internal: 2958 if (elf_section_data (section)->relocs == NULL) 2959 free (internal_relocs); 2960 goto error_ret_free_local; 2961 } 2962 2963 /* Only look for stubs on call instructions. */ 2964 if (r_type != (unsigned int) R_PARISC_PCREL12F 2965 && r_type != (unsigned int) R_PARISC_PCREL17F 2966 && r_type != (unsigned int) R_PARISC_PCREL22F) 2967 continue; 2968 2969 /* Now determine the call target, its name, value, 2970 section. */ 2971 sym_sec = NULL; 2972 sym_value = 0; 2973 destination = 0; 2974 hh = NULL; 2975 if (r_indx < symtab_hdr->sh_info) 2976 { 2977 /* It's a local symbol. */ 2978 Elf_Internal_Sym *sym; 2979 Elf_Internal_Shdr *hdr; 2980 unsigned int shndx; 2981 2982 sym = local_syms + r_indx; 2983 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION) 2984 sym_value = sym->st_value; 2985 shndx = sym->st_shndx; 2986 if (shndx < elf_numsections (input_bfd)) 2987 { 2988 hdr = elf_elfsections (input_bfd)[shndx]; 2989 sym_sec = hdr->bfd_section; 2990 destination = (sym_value + irela->r_addend 2991 + sym_sec->output_offset 2992 + sym_sec->output_section->vma); 2993 } 2994 } 2995 else 2996 { 2997 /* It's an external symbol. */ 2998 int e_indx; 2999 3000 e_indx = r_indx - symtab_hdr->sh_info; 3001 hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]); 3002 3003 while (hh->eh.root.type == bfd_link_hash_indirect 3004 || hh->eh.root.type == bfd_link_hash_warning) 3005 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 3006 3007 if (hh->eh.root.type == bfd_link_hash_defined 3008 || hh->eh.root.type == bfd_link_hash_defweak) 3009 { 3010 sym_sec = hh->eh.root.u.def.section; 3011 sym_value = hh->eh.root.u.def.value; 3012 if (sym_sec->output_section != NULL) 3013 destination = (sym_value + irela->r_addend 3014 + sym_sec->output_offset 3015 + sym_sec->output_section->vma); 3016 } 3017 else if (hh->eh.root.type == bfd_link_hash_undefweak) 3018 { 3019 if (! info->shared) 3020 continue; 3021 } 3022 else if (hh->eh.root.type == bfd_link_hash_undefined) 3023 { 3024 if (! (info->unresolved_syms_in_objects == RM_IGNORE 3025 && (ELF_ST_VISIBILITY (hh->eh.other) 3026 == STV_DEFAULT) 3027 && hh->eh.type != STT_PARISC_MILLI)) 3028 continue; 3029 } 3030 else 3031 { 3032 bfd_set_error (bfd_error_bad_value); 3033 goto error_ret_free_internal; 3034 } 3035 } 3036 3037 /* Determine what (if any) linker stub is needed. */ 3038 stub_type = hppa_type_of_stub (section, irela, hh, 3039 destination, info); 3040 if (stub_type == hppa_stub_none) 3041 continue; 3042 3043 /* Support for grouping stub sections. */ 3044 id_sec = htab->stub_group[section->id].link_sec; 3045 3046 /* Get the name of this stub. */ 3047 stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela); 3048 if (!stub_name) 3049 goto error_ret_free_internal; 3050 3051 hsh = hppa_stub_hash_lookup (&htab->bstab, 3052 stub_name, 3053 FALSE, FALSE); 3054 if (hsh != NULL) 3055 { 3056 /* The proper stub has already been created. */ 3057 free (stub_name); 3058 continue; 3059 } 3060 3061 hsh = hppa_add_stub (stub_name, section, htab); 3062 if (hsh == NULL) 3063 { 3064 free (stub_name); 3065 goto error_ret_free_internal; 3066 } 3067 3068 hsh->target_value = sym_value; 3069 hsh->target_section = sym_sec; 3070 hsh->stub_type = stub_type; 3071 if (info->shared) 3072 { 3073 if (stub_type == hppa_stub_import) 3074 hsh->stub_type = hppa_stub_import_shared; 3075 else if (stub_type == hppa_stub_long_branch) 3076 hsh->stub_type = hppa_stub_long_branch_shared; 3077 } 3078 hsh->hh = hh; 3079 stub_changed = TRUE; 3080 } 3081 3082 /* We're done with the internal relocs, free them. */ 3083 if (elf_section_data (section)->relocs == NULL) 3084 free (internal_relocs); 3085 } 3086 } 3087 3088 if (!stub_changed) 3089 break; 3090 3091 /* OK, we've added some stubs. Find out the new size of the 3092 stub sections. */ 3093 for (stub_sec = htab->stub_bfd->sections; 3094 stub_sec != NULL; 3095 stub_sec = stub_sec->next) 3096 stub_sec->size = 0; 3097 3098 bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab); 3099 3100 /* Ask the linker to do its stuff. */ 3101 (*htab->layout_sections_again) (); 3102 stub_changed = FALSE; 3103 } 3104 3105 free (htab->all_local_syms); 3106 return TRUE; 3107 3108 error_ret_free_local: 3109 free (htab->all_local_syms); 3110 return FALSE; 3111 } 3112 3113 /* For a final link, this function is called after we have sized the 3114 stubs to provide a value for __gp. */ 3115 3116 bfd_boolean 3117 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info) 3118 { 3119 struct bfd_link_hash_entry *h; 3120 asection *sec = NULL; 3121 bfd_vma gp_val = 0; 3122 struct elf32_hppa_link_hash_table *htab; 3123 3124 htab = hppa_link_hash_table (info); 3125 if (htab == NULL) 3126 return FALSE; 3127 3128 h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE); 3129 3130 if (h != NULL 3131 && (h->type == bfd_link_hash_defined 3132 || h->type == bfd_link_hash_defweak)) 3133 { 3134 gp_val = h->u.def.value; 3135 sec = h->u.def.section; 3136 } 3137 else 3138 { 3139 asection *splt = bfd_get_section_by_name (abfd, ".plt"); 3140 asection *sgot = bfd_get_section_by_name (abfd, ".got"); 3141 3142 /* Choose to point our LTP at, in this order, one of .plt, .got, 3143 or .data, if these sections exist. In the case of choosing 3144 .plt try to make the LTP ideal for addressing anywhere in the 3145 .plt or .got with a 14 bit signed offset. Typically, the end 3146 of the .plt is the start of the .got, so choose .plt + 0x2000 3147 if either the .plt or .got is larger than 0x2000. If both 3148 the .plt and .got are smaller than 0x2000, choose the end of 3149 the .plt section. */ 3150 sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0 3151 ? NULL : splt; 3152 if (sec != NULL) 3153 { 3154 gp_val = sec->size; 3155 if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000)) 3156 { 3157 gp_val = 0x2000; 3158 } 3159 } 3160 else 3161 { 3162 sec = sgot; 3163 if (sec != NULL) 3164 { 3165 if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0) 3166 { 3167 /* We know we don't have a .plt. If .got is large, 3168 offset our LTP. */ 3169 if (sec->size > 0x2000) 3170 gp_val = 0x2000; 3171 } 3172 } 3173 else 3174 { 3175 /* No .plt or .got. Who cares what the LTP is? */ 3176 sec = bfd_get_section_by_name (abfd, ".data"); 3177 } 3178 } 3179 3180 if (h != NULL) 3181 { 3182 h->type = bfd_link_hash_defined; 3183 h->u.def.value = gp_val; 3184 if (sec != NULL) 3185 h->u.def.section = sec; 3186 else 3187 h->u.def.section = bfd_abs_section_ptr; 3188 } 3189 } 3190 3191 if (sec != NULL && sec->output_section != NULL) 3192 gp_val += sec->output_section->vma + sec->output_offset; 3193 3194 elf_gp (abfd) = gp_val; 3195 return TRUE; 3196 } 3197 3198 /* Build all the stubs associated with the current output file. The 3199 stubs are kept in a hash table attached to the main linker hash 3200 table. We also set up the .plt entries for statically linked PIC 3201 functions here. This function is called via hppaelf_finish in the 3202 linker. */ 3203 3204 bfd_boolean 3205 elf32_hppa_build_stubs (struct bfd_link_info *info) 3206 { 3207 asection *stub_sec; 3208 struct bfd_hash_table *table; 3209 struct elf32_hppa_link_hash_table *htab; 3210 3211 htab = hppa_link_hash_table (info); 3212 if (htab == NULL) 3213 return FALSE; 3214 3215 for (stub_sec = htab->stub_bfd->sections; 3216 stub_sec != NULL; 3217 stub_sec = stub_sec->next) 3218 { 3219 bfd_size_type size; 3220 3221 /* Allocate memory to hold the linker stubs. */ 3222 size = stub_sec->size; 3223 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size); 3224 if (stub_sec->contents == NULL && size != 0) 3225 return FALSE; 3226 stub_sec->size = 0; 3227 } 3228 3229 /* Build the stubs as directed by the stub hash table. */ 3230 table = &htab->bstab; 3231 bfd_hash_traverse (table, hppa_build_one_stub, info); 3232 3233 return TRUE; 3234 } 3235 3236 /* Return the base vma address which should be subtracted from the real 3237 address when resolving a dtpoff relocation. 3238 This is PT_TLS segment p_vaddr. */ 3239 3240 static bfd_vma 3241 dtpoff_base (struct bfd_link_info *info) 3242 { 3243 /* If tls_sec is NULL, we should have signalled an error already. */ 3244 if (elf_hash_table (info)->tls_sec == NULL) 3245 return 0; 3246 return elf_hash_table (info)->tls_sec->vma; 3247 } 3248 3249 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */ 3250 3251 static bfd_vma 3252 tpoff (struct bfd_link_info *info, bfd_vma address) 3253 { 3254 struct elf_link_hash_table *htab = elf_hash_table (info); 3255 3256 /* If tls_sec is NULL, we should have signalled an error already. */ 3257 if (htab->tls_sec == NULL) 3258 return 0; 3259 /* hppa TLS ABI is variant I and static TLS block start just after 3260 tcbhead structure which has 2 pointer fields. */ 3261 return (address - htab->tls_sec->vma 3262 + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power)); 3263 } 3264 3265 /* Perform a final link. */ 3266 3267 static bfd_boolean 3268 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info) 3269 { 3270 /* Invoke the regular ELF linker to do all the work. */ 3271 if (!bfd_elf_final_link (abfd, info)) 3272 return FALSE; 3273 3274 /* If we're producing a final executable, sort the contents of the 3275 unwind section. */ 3276 if (info->relocatable) 3277 return TRUE; 3278 3279 return elf_hppa_sort_unwind (abfd); 3280 } 3281 3282 /* Record the lowest address for the data and text segments. */ 3283 3284 static void 3285 hppa_record_segment_addr (bfd *abfd, asection *section, void *data) 3286 { 3287 struct elf32_hppa_link_hash_table *htab; 3288 3289 htab = (struct elf32_hppa_link_hash_table*) data; 3290 if (htab == NULL) 3291 return; 3292 3293 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3294 { 3295 bfd_vma value; 3296 Elf_Internal_Phdr *p; 3297 3298 p = _bfd_elf_find_segment_containing_section (abfd, section->output_section); 3299 BFD_ASSERT (p != NULL); 3300 value = p->p_vaddr; 3301 3302 if ((section->flags & SEC_READONLY) != 0) 3303 { 3304 if (value < htab->text_segment_base) 3305 htab->text_segment_base = value; 3306 } 3307 else 3308 { 3309 if (value < htab->data_segment_base) 3310 htab->data_segment_base = value; 3311 } 3312 } 3313 } 3314 3315 /* Perform a relocation as part of a final link. */ 3316 3317 static bfd_reloc_status_type 3318 final_link_relocate (asection *input_section, 3319 bfd_byte *contents, 3320 const Elf_Internal_Rela *rela, 3321 bfd_vma value, 3322 struct elf32_hppa_link_hash_table *htab, 3323 asection *sym_sec, 3324 struct elf32_hppa_link_hash_entry *hh, 3325 struct bfd_link_info *info) 3326 { 3327 int insn; 3328 unsigned int r_type = ELF32_R_TYPE (rela->r_info); 3329 unsigned int orig_r_type = r_type; 3330 reloc_howto_type *howto = elf_hppa_howto_table + r_type; 3331 int r_format = howto->bitsize; 3332 enum hppa_reloc_field_selector_type_alt r_field; 3333 bfd *input_bfd = input_section->owner; 3334 bfd_vma offset = rela->r_offset; 3335 bfd_vma max_branch_offset = 0; 3336 bfd_byte *hit_data = contents + offset; 3337 bfd_signed_vma addend = rela->r_addend; 3338 bfd_vma location; 3339 struct elf32_hppa_stub_hash_entry *hsh = NULL; 3340 int val; 3341 3342 if (r_type == R_PARISC_NONE) 3343 return bfd_reloc_ok; 3344 3345 insn = bfd_get_32 (input_bfd, hit_data); 3346 3347 /* Find out where we are and where we're going. */ 3348 location = (offset + 3349 input_section->output_offset + 3350 input_section->output_section->vma); 3351 3352 /* If we are not building a shared library, convert DLTIND relocs to 3353 DPREL relocs. */ 3354 if (!info->shared) 3355 { 3356 switch (r_type) 3357 { 3358 case R_PARISC_DLTIND21L: 3359 r_type = R_PARISC_DPREL21L; 3360 break; 3361 3362 case R_PARISC_DLTIND14R: 3363 r_type = R_PARISC_DPREL14R; 3364 break; 3365 3366 case R_PARISC_DLTIND14F: 3367 r_type = R_PARISC_DPREL14F; 3368 break; 3369 } 3370 } 3371 3372 switch (r_type) 3373 { 3374 case R_PARISC_PCREL12F: 3375 case R_PARISC_PCREL17F: 3376 case R_PARISC_PCREL22F: 3377 /* If this call should go via the plt, find the import stub in 3378 the stub hash. */ 3379 if (sym_sec == NULL 3380 || sym_sec->output_section == NULL 3381 || (hh != NULL 3382 && hh->eh.plt.offset != (bfd_vma) -1 3383 && hh->eh.dynindx != -1 3384 && !hh->plabel 3385 && (info->shared 3386 || !hh->eh.def_regular 3387 || hh->eh.root.type == bfd_link_hash_defweak))) 3388 { 3389 hsh = hppa_get_stub_entry (input_section, sym_sec, 3390 hh, rela, htab); 3391 if (hsh != NULL) 3392 { 3393 value = (hsh->stub_offset 3394 + hsh->stub_sec->output_offset 3395 + hsh->stub_sec->output_section->vma); 3396 addend = 0; 3397 } 3398 else if (sym_sec == NULL && hh != NULL 3399 && hh->eh.root.type == bfd_link_hash_undefweak) 3400 { 3401 /* It's OK if undefined weak. Calls to undefined weak 3402 symbols behave as if the "called" function 3403 immediately returns. We can thus call to a weak 3404 function without first checking whether the function 3405 is defined. */ 3406 value = location; 3407 addend = 8; 3408 } 3409 else 3410 return bfd_reloc_undefined; 3411 } 3412 /* Fall thru. */ 3413 3414 case R_PARISC_PCREL21L: 3415 case R_PARISC_PCREL17C: 3416 case R_PARISC_PCREL17R: 3417 case R_PARISC_PCREL14R: 3418 case R_PARISC_PCREL14F: 3419 case R_PARISC_PCREL32: 3420 /* Make it a pc relative offset. */ 3421 value -= location; 3422 addend -= 8; 3423 break; 3424 3425 case R_PARISC_DPREL21L: 3426 case R_PARISC_DPREL14R: 3427 case R_PARISC_DPREL14F: 3428 case R_PARISC_TLS_GD21L: 3429 case R_PARISC_TLS_LDM21L: 3430 case R_PARISC_TLS_IE21L: 3431 /* Convert instructions that use the linkage table pointer (r19) to 3432 instructions that use the global data pointer (dp). This is the 3433 most efficient way of using PIC code in an incomplete executable, 3434 but the user must follow the standard runtime conventions for 3435 accessing data for this to work. */ 3436 if (orig_r_type == R_PARISC_DLTIND21L 3437 || (!info->shared 3438 && (r_type == R_PARISC_TLS_GD21L 3439 || r_type == R_PARISC_TLS_LDM21L 3440 || r_type == R_PARISC_TLS_IE21L))) 3441 { 3442 /* Convert addil instructions if the original reloc was a 3443 DLTIND21L. GCC sometimes uses a register other than r19 for 3444 the operation, so we must convert any addil instruction 3445 that uses this relocation. */ 3446 if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26)) 3447 insn = ADDIL_DP; 3448 else 3449 /* We must have a ldil instruction. It's too hard to find 3450 and convert the associated add instruction, so issue an 3451 error. */ 3452 (*_bfd_error_handler) 3453 (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"), 3454 input_bfd, 3455 input_section, 3456 (long) offset, 3457 howto->name, 3458 insn); 3459 } 3460 else if (orig_r_type == R_PARISC_DLTIND14F) 3461 { 3462 /* This must be a format 1 load/store. Change the base 3463 register to dp. */ 3464 insn = (insn & 0xfc1ffff) | (27 << 21); 3465 } 3466 3467 /* For all the DP relative relocations, we need to examine the symbol's 3468 section. If it has no section or if it's a code section, then 3469 "data pointer relative" makes no sense. In that case we don't 3470 adjust the "value", and for 21 bit addil instructions, we change the 3471 source addend register from %dp to %r0. This situation commonly 3472 arises for undefined weak symbols and when a variable's "constness" 3473 is declared differently from the way the variable is defined. For 3474 instance: "extern int foo" with foo defined as "const int foo". */ 3475 if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0) 3476 { 3477 if ((insn & ((0x3f << 26) | (0x1f << 21))) 3478 == (((int) OP_ADDIL << 26) | (27 << 21))) 3479 { 3480 insn &= ~ (0x1f << 21); 3481 } 3482 /* Now try to make things easy for the dynamic linker. */ 3483 3484 break; 3485 } 3486 /* Fall thru. */ 3487 3488 case R_PARISC_DLTIND21L: 3489 case R_PARISC_DLTIND14R: 3490 case R_PARISC_DLTIND14F: 3491 case R_PARISC_TLS_GD14R: 3492 case R_PARISC_TLS_LDM14R: 3493 case R_PARISC_TLS_IE14R: 3494 value -= elf_gp (input_section->output_section->owner); 3495 break; 3496 3497 case R_PARISC_SEGREL32: 3498 if ((sym_sec->flags & SEC_CODE) != 0) 3499 value -= htab->text_segment_base; 3500 else 3501 value -= htab->data_segment_base; 3502 break; 3503 3504 default: 3505 break; 3506 } 3507 3508 switch (r_type) 3509 { 3510 case R_PARISC_DIR32: 3511 case R_PARISC_DIR14F: 3512 case R_PARISC_DIR17F: 3513 case R_PARISC_PCREL17C: 3514 case R_PARISC_PCREL14F: 3515 case R_PARISC_PCREL32: 3516 case R_PARISC_DPREL14F: 3517 case R_PARISC_PLABEL32: 3518 case R_PARISC_DLTIND14F: 3519 case R_PARISC_SEGBASE: 3520 case R_PARISC_SEGREL32: 3521 case R_PARISC_TLS_DTPMOD32: 3522 case R_PARISC_TLS_DTPOFF32: 3523 case R_PARISC_TLS_TPREL32: 3524 r_field = e_fsel; 3525 break; 3526 3527 case R_PARISC_DLTIND21L: 3528 case R_PARISC_PCREL21L: 3529 case R_PARISC_PLABEL21L: 3530 r_field = e_lsel; 3531 break; 3532 3533 case R_PARISC_DIR21L: 3534 case R_PARISC_DPREL21L: 3535 case R_PARISC_TLS_GD21L: 3536 case R_PARISC_TLS_LDM21L: 3537 case R_PARISC_TLS_LDO21L: 3538 case R_PARISC_TLS_IE21L: 3539 case R_PARISC_TLS_LE21L: 3540 r_field = e_lrsel; 3541 break; 3542 3543 case R_PARISC_PCREL17R: 3544 case R_PARISC_PCREL14R: 3545 case R_PARISC_PLABEL14R: 3546 case R_PARISC_DLTIND14R: 3547 r_field = e_rsel; 3548 break; 3549 3550 case R_PARISC_DIR17R: 3551 case R_PARISC_DIR14R: 3552 case R_PARISC_DPREL14R: 3553 case R_PARISC_TLS_GD14R: 3554 case R_PARISC_TLS_LDM14R: 3555 case R_PARISC_TLS_LDO14R: 3556 case R_PARISC_TLS_IE14R: 3557 case R_PARISC_TLS_LE14R: 3558 r_field = e_rrsel; 3559 break; 3560 3561 case R_PARISC_PCREL12F: 3562 case R_PARISC_PCREL17F: 3563 case R_PARISC_PCREL22F: 3564 r_field = e_fsel; 3565 3566 if (r_type == (unsigned int) R_PARISC_PCREL17F) 3567 { 3568 max_branch_offset = (1 << (17-1)) << 2; 3569 } 3570 else if (r_type == (unsigned int) R_PARISC_PCREL12F) 3571 { 3572 max_branch_offset = (1 << (12-1)) << 2; 3573 } 3574 else 3575 { 3576 max_branch_offset = (1 << (22-1)) << 2; 3577 } 3578 3579 /* sym_sec is NULL on undefined weak syms or when shared on 3580 undefined syms. We've already checked for a stub for the 3581 shared undefined case. */ 3582 if (sym_sec == NULL) 3583 break; 3584 3585 /* If the branch is out of reach, then redirect the 3586 call to the local stub for this function. */ 3587 if (value + addend + max_branch_offset >= 2*max_branch_offset) 3588 { 3589 hsh = hppa_get_stub_entry (input_section, sym_sec, 3590 hh, rela, htab); 3591 if (hsh == NULL) 3592 return bfd_reloc_undefined; 3593 3594 /* Munge up the value and addend so that we call the stub 3595 rather than the procedure directly. */ 3596 value = (hsh->stub_offset 3597 + hsh->stub_sec->output_offset 3598 + hsh->stub_sec->output_section->vma 3599 - location); 3600 addend = -8; 3601 } 3602 break; 3603 3604 /* Something we don't know how to handle. */ 3605 default: 3606 return bfd_reloc_notsupported; 3607 } 3608 3609 /* Make sure we can reach the stub. */ 3610 if (max_branch_offset != 0 3611 && value + addend + max_branch_offset >= 2*max_branch_offset) 3612 { 3613 (*_bfd_error_handler) 3614 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"), 3615 input_bfd, 3616 input_section, 3617 (long) offset, 3618 hsh->bh_root.string); 3619 bfd_set_error (bfd_error_bad_value); 3620 return bfd_reloc_notsupported; 3621 } 3622 3623 val = hppa_field_adjust (value, addend, r_field); 3624 3625 switch (r_type) 3626 { 3627 case R_PARISC_PCREL12F: 3628 case R_PARISC_PCREL17C: 3629 case R_PARISC_PCREL17F: 3630 case R_PARISC_PCREL17R: 3631 case R_PARISC_PCREL22F: 3632 case R_PARISC_DIR17F: 3633 case R_PARISC_DIR17R: 3634 /* This is a branch. Divide the offset by four. 3635 Note that we need to decide whether it's a branch or 3636 otherwise by inspecting the reloc. Inspecting insn won't 3637 work as insn might be from a .word directive. */ 3638 val >>= 2; 3639 break; 3640 3641 default: 3642 break; 3643 } 3644 3645 insn = hppa_rebuild_insn (insn, val, r_format); 3646 3647 /* Update the instruction word. */ 3648 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data); 3649 return bfd_reloc_ok; 3650 } 3651 3652 /* Relocate an HPPA ELF section. */ 3653 3654 static bfd_boolean 3655 elf32_hppa_relocate_section (bfd *output_bfd, 3656 struct bfd_link_info *info, 3657 bfd *input_bfd, 3658 asection *input_section, 3659 bfd_byte *contents, 3660 Elf_Internal_Rela *relocs, 3661 Elf_Internal_Sym *local_syms, 3662 asection **local_sections) 3663 { 3664 bfd_vma *local_got_offsets; 3665 struct elf32_hppa_link_hash_table *htab; 3666 Elf_Internal_Shdr *symtab_hdr; 3667 Elf_Internal_Rela *rela; 3668 Elf_Internal_Rela *relend; 3669 3670 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3671 3672 htab = hppa_link_hash_table (info); 3673 if (htab == NULL) 3674 return FALSE; 3675 3676 local_got_offsets = elf_local_got_offsets (input_bfd); 3677 3678 rela = relocs; 3679 relend = relocs + input_section->reloc_count; 3680 for (; rela < relend; rela++) 3681 { 3682 unsigned int r_type; 3683 reloc_howto_type *howto; 3684 unsigned int r_symndx; 3685 struct elf32_hppa_link_hash_entry *hh; 3686 Elf_Internal_Sym *sym; 3687 asection *sym_sec; 3688 bfd_vma relocation; 3689 bfd_reloc_status_type rstatus; 3690 const char *sym_name; 3691 bfd_boolean plabel; 3692 bfd_boolean warned_undef; 3693 3694 r_type = ELF32_R_TYPE (rela->r_info); 3695 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED) 3696 { 3697 bfd_set_error (bfd_error_bad_value); 3698 return FALSE; 3699 } 3700 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY 3701 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT) 3702 continue; 3703 3704 r_symndx = ELF32_R_SYM (rela->r_info); 3705 hh = NULL; 3706 sym = NULL; 3707 sym_sec = NULL; 3708 warned_undef = FALSE; 3709 if (r_symndx < symtab_hdr->sh_info) 3710 { 3711 /* This is a local symbol, h defaults to NULL. */ 3712 sym = local_syms + r_symndx; 3713 sym_sec = local_sections[r_symndx]; 3714 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela); 3715 } 3716 else 3717 { 3718 struct elf_link_hash_entry *eh; 3719 bfd_boolean unresolved_reloc; 3720 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 3721 3722 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela, 3723 r_symndx, symtab_hdr, sym_hashes, 3724 eh, sym_sec, relocation, 3725 unresolved_reloc, warned_undef); 3726 3727 if (!info->relocatable 3728 && relocation == 0 3729 && eh->root.type != bfd_link_hash_defined 3730 && eh->root.type != bfd_link_hash_defweak 3731 && eh->root.type != bfd_link_hash_undefweak) 3732 { 3733 if (info->unresolved_syms_in_objects == RM_IGNORE 3734 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT 3735 && eh->type == STT_PARISC_MILLI) 3736 { 3737 if (! info->callbacks->undefined_symbol 3738 (info, eh_name (eh), input_bfd, 3739 input_section, rela->r_offset, FALSE)) 3740 return FALSE; 3741 warned_undef = TRUE; 3742 } 3743 } 3744 hh = hppa_elf_hash_entry (eh); 3745 } 3746 3747 if (sym_sec != NULL && elf_discarded_section (sym_sec)) 3748 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3749 rela, relend, 3750 elf_hppa_howto_table + r_type, 3751 contents); 3752 3753 if (info->relocatable) 3754 continue; 3755 3756 /* Do any required modifications to the relocation value, and 3757 determine what types of dynamic info we need to output, if 3758 any. */ 3759 plabel = 0; 3760 switch (r_type) 3761 { 3762 case R_PARISC_DLTIND14F: 3763 case R_PARISC_DLTIND14R: 3764 case R_PARISC_DLTIND21L: 3765 { 3766 bfd_vma off; 3767 bfd_boolean do_got = 0; 3768 3769 /* Relocation is to the entry for this symbol in the 3770 global offset table. */ 3771 if (hh != NULL) 3772 { 3773 bfd_boolean dyn; 3774 3775 off = hh->eh.got.offset; 3776 dyn = htab->etab.dynamic_sections_created; 3777 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, 3778 &hh->eh)) 3779 { 3780 /* If we aren't going to call finish_dynamic_symbol, 3781 then we need to handle initialisation of the .got 3782 entry and create needed relocs here. Since the 3783 offset must always be a multiple of 4, we use the 3784 least significant bit to record whether we have 3785 initialised it already. */ 3786 if ((off & 1) != 0) 3787 off &= ~1; 3788 else 3789 { 3790 hh->eh.got.offset |= 1; 3791 do_got = 1; 3792 } 3793 } 3794 } 3795 else 3796 { 3797 /* Local symbol case. */ 3798 if (local_got_offsets == NULL) 3799 abort (); 3800 3801 off = local_got_offsets[r_symndx]; 3802 3803 /* The offset must always be a multiple of 4. We use 3804 the least significant bit to record whether we have 3805 already generated the necessary reloc. */ 3806 if ((off & 1) != 0) 3807 off &= ~1; 3808 else 3809 { 3810 local_got_offsets[r_symndx] |= 1; 3811 do_got = 1; 3812 } 3813 } 3814 3815 if (do_got) 3816 { 3817 if (info->shared) 3818 { 3819 /* Output a dynamic relocation for this GOT entry. 3820 In this case it is relative to the base of the 3821 object because the symbol index is zero. */ 3822 Elf_Internal_Rela outrel; 3823 bfd_byte *loc; 3824 asection *sec = htab->srelgot; 3825 3826 outrel.r_offset = (off 3827 + htab->sgot->output_offset 3828 + htab->sgot->output_section->vma); 3829 outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32); 3830 outrel.r_addend = relocation; 3831 loc = sec->contents; 3832 loc += sec->reloc_count++ * sizeof (Elf32_External_Rela); 3833 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 3834 } 3835 else 3836 bfd_put_32 (output_bfd, relocation, 3837 htab->sgot->contents + off); 3838 } 3839 3840 if (off >= (bfd_vma) -2) 3841 abort (); 3842 3843 /* Add the base of the GOT to the relocation value. */ 3844 relocation = (off 3845 + htab->sgot->output_offset 3846 + htab->sgot->output_section->vma); 3847 } 3848 break; 3849 3850 case R_PARISC_SEGREL32: 3851 /* If this is the first SEGREL relocation, then initialize 3852 the segment base values. */ 3853 if (htab->text_segment_base == (bfd_vma) -1) 3854 bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab); 3855 break; 3856 3857 case R_PARISC_PLABEL14R: 3858 case R_PARISC_PLABEL21L: 3859 case R_PARISC_PLABEL32: 3860 if (htab->etab.dynamic_sections_created) 3861 { 3862 bfd_vma off; 3863 bfd_boolean do_plt = 0; 3864 /* If we have a global symbol with a PLT slot, then 3865 redirect this relocation to it. */ 3866 if (hh != NULL) 3867 { 3868 off = hh->eh.plt.offset; 3869 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, 3870 &hh->eh)) 3871 { 3872 /* In a non-shared link, adjust_dynamic_symbols 3873 isn't called for symbols forced local. We 3874 need to write out the plt entry here. */ 3875 if ((off & 1) != 0) 3876 off &= ~1; 3877 else 3878 { 3879 hh->eh.plt.offset |= 1; 3880 do_plt = 1; 3881 } 3882 } 3883 } 3884 else 3885 { 3886 bfd_vma *local_plt_offsets; 3887 3888 if (local_got_offsets == NULL) 3889 abort (); 3890 3891 local_plt_offsets = local_got_offsets + symtab_hdr->sh_info; 3892 off = local_plt_offsets[r_symndx]; 3893 3894 /* As for the local .got entry case, we use the last 3895 bit to record whether we've already initialised 3896 this local .plt entry. */ 3897 if ((off & 1) != 0) 3898 off &= ~1; 3899 else 3900 { 3901 local_plt_offsets[r_symndx] |= 1; 3902 do_plt = 1; 3903 } 3904 } 3905 3906 if (do_plt) 3907 { 3908 if (info->shared) 3909 { 3910 /* Output a dynamic IPLT relocation for this 3911 PLT entry. */ 3912 Elf_Internal_Rela outrel; 3913 bfd_byte *loc; 3914 asection *s = htab->srelplt; 3915 3916 outrel.r_offset = (off 3917 + htab->splt->output_offset 3918 + htab->splt->output_section->vma); 3919 outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT); 3920 outrel.r_addend = relocation; 3921 loc = s->contents; 3922 loc += s->reloc_count++ * sizeof (Elf32_External_Rela); 3923 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 3924 } 3925 else 3926 { 3927 bfd_put_32 (output_bfd, 3928 relocation, 3929 htab->splt->contents + off); 3930 bfd_put_32 (output_bfd, 3931 elf_gp (htab->splt->output_section->owner), 3932 htab->splt->contents + off + 4); 3933 } 3934 } 3935 3936 if (off >= (bfd_vma) -2) 3937 abort (); 3938 3939 /* PLABELs contain function pointers. Relocation is to 3940 the entry for the function in the .plt. The magic +2 3941 offset signals to $$dyncall that the function pointer 3942 is in the .plt and thus has a gp pointer too. 3943 Exception: Undefined PLABELs should have a value of 3944 zero. */ 3945 if (hh == NULL 3946 || (hh->eh.root.type != bfd_link_hash_undefweak 3947 && hh->eh.root.type != bfd_link_hash_undefined)) 3948 { 3949 relocation = (off 3950 + htab->splt->output_offset 3951 + htab->splt->output_section->vma 3952 + 2); 3953 } 3954 plabel = 1; 3955 } 3956 /* Fall through and possibly emit a dynamic relocation. */ 3957 3958 case R_PARISC_DIR17F: 3959 case R_PARISC_DIR17R: 3960 case R_PARISC_DIR14F: 3961 case R_PARISC_DIR14R: 3962 case R_PARISC_DIR21L: 3963 case R_PARISC_DPREL14F: 3964 case R_PARISC_DPREL14R: 3965 case R_PARISC_DPREL21L: 3966 case R_PARISC_DIR32: 3967 if ((input_section->flags & SEC_ALLOC) == 0) 3968 break; 3969 3970 /* The reloc types handled here and this conditional 3971 expression must match the code in ..check_relocs and 3972 allocate_dynrelocs. ie. We need exactly the same condition 3973 as in ..check_relocs, with some extra conditions (dynindx 3974 test in this case) to cater for relocs removed by 3975 allocate_dynrelocs. If you squint, the non-shared test 3976 here does indeed match the one in ..check_relocs, the 3977 difference being that here we test DEF_DYNAMIC as well as 3978 !DEF_REGULAR. All common syms end up with !DEF_REGULAR, 3979 which is why we can't use just that test here. 3980 Conversely, DEF_DYNAMIC can't be used in check_relocs as 3981 there all files have not been loaded. */ 3982 if ((info->shared 3983 && (hh == NULL 3984 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT 3985 || hh->eh.root.type != bfd_link_hash_undefweak) 3986 && (IS_ABSOLUTE_RELOC (r_type) 3987 || !SYMBOL_CALLS_LOCAL (info, &hh->eh))) 3988 || (!info->shared 3989 && hh != NULL 3990 && hh->eh.dynindx != -1 3991 && !hh->eh.non_got_ref 3992 && ((ELIMINATE_COPY_RELOCS 3993 && hh->eh.def_dynamic 3994 && !hh->eh.def_regular) 3995 || hh->eh.root.type == bfd_link_hash_undefweak 3996 || hh->eh.root.type == bfd_link_hash_undefined))) 3997 { 3998 Elf_Internal_Rela outrel; 3999 bfd_boolean skip; 4000 asection *sreloc; 4001 bfd_byte *loc; 4002 4003 /* When generating a shared object, these relocations 4004 are copied into the output file to be resolved at run 4005 time. */ 4006 4007 outrel.r_addend = rela->r_addend; 4008 outrel.r_offset = 4009 _bfd_elf_section_offset (output_bfd, info, input_section, 4010 rela->r_offset); 4011 skip = (outrel.r_offset == (bfd_vma) -1 4012 || outrel.r_offset == (bfd_vma) -2); 4013 outrel.r_offset += (input_section->output_offset 4014 + input_section->output_section->vma); 4015 4016 if (skip) 4017 { 4018 memset (&outrel, 0, sizeof (outrel)); 4019 } 4020 else if (hh != NULL 4021 && hh->eh.dynindx != -1 4022 && (plabel 4023 || !IS_ABSOLUTE_RELOC (r_type) 4024 || !info->shared 4025 || !info->symbolic 4026 || !hh->eh.def_regular)) 4027 { 4028 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type); 4029 } 4030 else /* It's a local symbol, or one marked to become local. */ 4031 { 4032 int indx = 0; 4033 4034 /* Add the absolute offset of the symbol. */ 4035 outrel.r_addend += relocation; 4036 4037 /* Global plabels need to be processed by the 4038 dynamic linker so that functions have at most one 4039 fptr. For this reason, we need to differentiate 4040 between global and local plabels, which we do by 4041 providing the function symbol for a global plabel 4042 reloc, and no symbol for local plabels. */ 4043 if (! plabel 4044 && sym_sec != NULL 4045 && sym_sec->output_section != NULL 4046 && ! bfd_is_abs_section (sym_sec)) 4047 { 4048 asection *osec; 4049 4050 osec = sym_sec->output_section; 4051 indx = elf_section_data (osec)->dynindx; 4052 if (indx == 0) 4053 { 4054 osec = htab->etab.text_index_section; 4055 indx = elf_section_data (osec)->dynindx; 4056 } 4057 BFD_ASSERT (indx != 0); 4058 4059 /* We are turning this relocation into one 4060 against a section symbol, so subtract out the 4061 output section's address but not the offset 4062 of the input section in the output section. */ 4063 outrel.r_addend -= osec->vma; 4064 } 4065 4066 outrel.r_info = ELF32_R_INFO (indx, r_type); 4067 } 4068 sreloc = elf_section_data (input_section)->sreloc; 4069 if (sreloc == NULL) 4070 abort (); 4071 4072 loc = sreloc->contents; 4073 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 4074 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4075 } 4076 break; 4077 4078 case R_PARISC_TLS_LDM21L: 4079 case R_PARISC_TLS_LDM14R: 4080 { 4081 bfd_vma off; 4082 4083 off = htab->tls_ldm_got.offset; 4084 if (off & 1) 4085 off &= ~1; 4086 else 4087 { 4088 Elf_Internal_Rela outrel; 4089 bfd_byte *loc; 4090 4091 outrel.r_offset = (off 4092 + htab->sgot->output_section->vma 4093 + htab->sgot->output_offset); 4094 outrel.r_addend = 0; 4095 outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32); 4096 loc = htab->srelgot->contents; 4097 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4098 4099 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4100 htab->tls_ldm_got.offset |= 1; 4101 } 4102 4103 /* Add the base of the GOT to the relocation value. */ 4104 relocation = (off 4105 + htab->sgot->output_offset 4106 + htab->sgot->output_section->vma); 4107 4108 break; 4109 } 4110 4111 case R_PARISC_TLS_LDO21L: 4112 case R_PARISC_TLS_LDO14R: 4113 relocation -= dtpoff_base (info); 4114 break; 4115 4116 case R_PARISC_TLS_GD21L: 4117 case R_PARISC_TLS_GD14R: 4118 case R_PARISC_TLS_IE21L: 4119 case R_PARISC_TLS_IE14R: 4120 { 4121 bfd_vma off; 4122 int indx; 4123 char tls_type; 4124 4125 indx = 0; 4126 if (hh != NULL) 4127 { 4128 bfd_boolean dyn; 4129 dyn = htab->etab.dynamic_sections_created; 4130 4131 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &hh->eh) 4132 && (!info->shared 4133 || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))) 4134 { 4135 indx = hh->eh.dynindx; 4136 } 4137 off = hh->eh.got.offset; 4138 tls_type = hh->tls_type; 4139 } 4140 else 4141 { 4142 off = local_got_offsets[r_symndx]; 4143 tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx]; 4144 } 4145 4146 if (tls_type == GOT_UNKNOWN) 4147 abort (); 4148 4149 if ((off & 1) != 0) 4150 off &= ~1; 4151 else 4152 { 4153 bfd_boolean need_relocs = FALSE; 4154 Elf_Internal_Rela outrel; 4155 bfd_byte *loc = NULL; 4156 int cur_off = off; 4157 4158 /* The GOT entries have not been initialized yet. Do it 4159 now, and emit any relocations. If both an IE GOT and a 4160 GD GOT are necessary, we emit the GD first. */ 4161 4162 if ((info->shared || indx != 0) 4163 && (hh == NULL 4164 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT 4165 || hh->eh.root.type != bfd_link_hash_undefweak)) 4166 { 4167 need_relocs = TRUE; 4168 loc = htab->srelgot->contents; 4169 /* FIXME (CAO): Should this be reloc_count++ ? */ 4170 loc += htab->srelgot->reloc_count * sizeof (Elf32_External_Rela); 4171 } 4172 4173 if (tls_type & GOT_TLS_GD) 4174 { 4175 if (need_relocs) 4176 { 4177 outrel.r_offset = (cur_off 4178 + htab->sgot->output_section->vma 4179 + htab->sgot->output_offset); 4180 outrel.r_info = ELF32_R_INFO (indx,R_PARISC_TLS_DTPMOD32); 4181 outrel.r_addend = 0; 4182 bfd_put_32 (output_bfd, 0, htab->sgot->contents + cur_off); 4183 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4184 htab->srelgot->reloc_count++; 4185 loc += sizeof (Elf32_External_Rela); 4186 4187 if (indx == 0) 4188 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 4189 htab->sgot->contents + cur_off + 4); 4190 else 4191 { 4192 bfd_put_32 (output_bfd, 0, 4193 htab->sgot->contents + cur_off + 4); 4194 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32); 4195 outrel.r_offset += 4; 4196 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); 4197 htab->srelgot->reloc_count++; 4198 loc += sizeof (Elf32_External_Rela); 4199 } 4200 } 4201 else 4202 { 4203 /* If we are not emitting relocations for a 4204 general dynamic reference, then we must be in a 4205 static link or an executable link with the 4206 symbol binding locally. Mark it as belonging 4207 to module 1, the executable. */ 4208 bfd_put_32 (output_bfd, 1, 4209 htab->sgot->contents + cur_off); 4210 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 4211 htab->sgot->contents + cur_off + 4); 4212 } 4213 4214 4215 cur_off += 8; 4216 } 4217 4218 if (tls_type & GOT_TLS_IE) 4219 { 4220 if (need_relocs) 4221 { 4222 outrel.r_offset = (cur_off 4223 + htab->sgot->output_section->vma 4224 + htab->sgot->output_offset); 4225 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_TPREL32); 4226 4227 if (indx == 0) 4228 outrel.r_addend = relocation - dtpoff_base (info); 4229 else 4230 outrel.r_addend = 0; 4231 4232 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4233 htab->srelgot->reloc_count++; 4234 loc += sizeof (Elf32_External_Rela); 4235 } 4236 else 4237 bfd_put_32 (output_bfd, tpoff (info, relocation), 4238 htab->sgot->contents + cur_off); 4239 4240 cur_off += 4; 4241 } 4242 4243 if (hh != NULL) 4244 hh->eh.got.offset |= 1; 4245 else 4246 local_got_offsets[r_symndx] |= 1; 4247 } 4248 4249 if ((tls_type & GOT_TLS_GD) 4250 && r_type != R_PARISC_TLS_GD21L 4251 && r_type != R_PARISC_TLS_GD14R) 4252 off += 2 * GOT_ENTRY_SIZE; 4253 4254 /* Add the base of the GOT to the relocation value. */ 4255 relocation = (off 4256 + htab->sgot->output_offset 4257 + htab->sgot->output_section->vma); 4258 4259 break; 4260 } 4261 4262 case R_PARISC_TLS_LE21L: 4263 case R_PARISC_TLS_LE14R: 4264 { 4265 relocation = tpoff (info, relocation); 4266 break; 4267 } 4268 break; 4269 4270 default: 4271 break; 4272 } 4273 4274 rstatus = final_link_relocate (input_section, contents, rela, relocation, 4275 htab, sym_sec, hh, info); 4276 4277 if (rstatus == bfd_reloc_ok) 4278 continue; 4279 4280 if (hh != NULL) 4281 sym_name = hh_name (hh); 4282 else 4283 { 4284 sym_name = bfd_elf_string_from_elf_section (input_bfd, 4285 symtab_hdr->sh_link, 4286 sym->st_name); 4287 if (sym_name == NULL) 4288 return FALSE; 4289 if (*sym_name == '\0') 4290 sym_name = bfd_section_name (input_bfd, sym_sec); 4291 } 4292 4293 howto = elf_hppa_howto_table + r_type; 4294 4295 if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported) 4296 { 4297 if (rstatus == bfd_reloc_notsupported || !warned_undef) 4298 { 4299 (*_bfd_error_handler) 4300 (_("%B(%A+0x%lx): cannot handle %s for %s"), 4301 input_bfd, 4302 input_section, 4303 (long) rela->r_offset, 4304 howto->name, 4305 sym_name); 4306 bfd_set_error (bfd_error_bad_value); 4307 return FALSE; 4308 } 4309 } 4310 else 4311 { 4312 if (!((*info->callbacks->reloc_overflow) 4313 (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name, 4314 (bfd_vma) 0, input_bfd, input_section, rela->r_offset))) 4315 return FALSE; 4316 } 4317 } 4318 4319 return TRUE; 4320 } 4321 4322 /* Finish up dynamic symbol handling. We set the contents of various 4323 dynamic sections here. */ 4324 4325 static bfd_boolean 4326 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd, 4327 struct bfd_link_info *info, 4328 struct elf_link_hash_entry *eh, 4329 Elf_Internal_Sym *sym) 4330 { 4331 struct elf32_hppa_link_hash_table *htab; 4332 Elf_Internal_Rela rela; 4333 bfd_byte *loc; 4334 4335 htab = hppa_link_hash_table (info); 4336 if (htab == NULL) 4337 return FALSE; 4338 4339 if (eh->plt.offset != (bfd_vma) -1) 4340 { 4341 bfd_vma value; 4342 4343 if (eh->plt.offset & 1) 4344 abort (); 4345 4346 /* This symbol has an entry in the procedure linkage table. Set 4347 it up. 4348 4349 The format of a plt entry is 4350 <funcaddr> 4351 <__gp> 4352 */ 4353 value = 0; 4354 if (eh->root.type == bfd_link_hash_defined 4355 || eh->root.type == bfd_link_hash_defweak) 4356 { 4357 value = eh->root.u.def.value; 4358 if (eh->root.u.def.section->output_section != NULL) 4359 value += (eh->root.u.def.section->output_offset 4360 + eh->root.u.def.section->output_section->vma); 4361 } 4362 4363 /* Create a dynamic IPLT relocation for this entry. */ 4364 rela.r_offset = (eh->plt.offset 4365 + htab->splt->output_offset 4366 + htab->splt->output_section->vma); 4367 if (eh->dynindx != -1) 4368 { 4369 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT); 4370 rela.r_addend = 0; 4371 } 4372 else 4373 { 4374 /* This symbol has been marked to become local, and is 4375 used by a plabel so must be kept in the .plt. */ 4376 rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT); 4377 rela.r_addend = value; 4378 } 4379 4380 loc = htab->srelplt->contents; 4381 loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela); 4382 bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rela, loc); 4383 4384 if (!eh->def_regular) 4385 { 4386 /* Mark the symbol as undefined, rather than as defined in 4387 the .plt section. Leave the value alone. */ 4388 sym->st_shndx = SHN_UNDEF; 4389 } 4390 } 4391 4392 if (eh->got.offset != (bfd_vma) -1 4393 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0 4394 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0) 4395 { 4396 /* This symbol has an entry in the global offset table. Set it 4397 up. */ 4398 4399 rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1) 4400 + htab->sgot->output_offset 4401 + htab->sgot->output_section->vma); 4402 4403 /* If this is a -Bsymbolic link and the symbol is defined 4404 locally or was forced to be local because of a version file, 4405 we just want to emit a RELATIVE reloc. The entry in the 4406 global offset table will already have been initialized in the 4407 relocate_section function. */ 4408 if (info->shared 4409 && (info->symbolic || eh->dynindx == -1) 4410 && eh->def_regular) 4411 { 4412 rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32); 4413 rela.r_addend = (eh->root.u.def.value 4414 + eh->root.u.def.section->output_offset 4415 + eh->root.u.def.section->output_section->vma); 4416 } 4417 else 4418 { 4419 if ((eh->got.offset & 1) != 0) 4420 abort (); 4421 4422 bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1)); 4423 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32); 4424 rela.r_addend = 0; 4425 } 4426 4427 loc = htab->srelgot->contents; 4428 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4429 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4430 } 4431 4432 if (eh->needs_copy) 4433 { 4434 asection *sec; 4435 4436 /* This symbol needs a copy reloc. Set it up. */ 4437 4438 if (! (eh->dynindx != -1 4439 && (eh->root.type == bfd_link_hash_defined 4440 || eh->root.type == bfd_link_hash_defweak))) 4441 abort (); 4442 4443 sec = htab->srelbss; 4444 4445 rela.r_offset = (eh->root.u.def.value 4446 + eh->root.u.def.section->output_offset 4447 + eh->root.u.def.section->output_section->vma); 4448 rela.r_addend = 0; 4449 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY); 4450 loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela); 4451 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4452 } 4453 4454 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 4455 if (eh_name (eh)[0] == '_' 4456 && (strcmp (eh_name (eh), "_DYNAMIC") == 0 4457 || eh == htab->etab.hgot)) 4458 { 4459 sym->st_shndx = SHN_ABS; 4460 } 4461 4462 return TRUE; 4463 } 4464 4465 /* Used to decide how to sort relocs in an optimal manner for the 4466 dynamic linker, before writing them out. */ 4467 4468 static enum elf_reloc_type_class 4469 elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela) 4470 { 4471 /* Handle TLS relocs first; we don't want them to be marked 4472 relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)" 4473 check below. */ 4474 switch ((int) ELF32_R_TYPE (rela->r_info)) 4475 { 4476 case R_PARISC_TLS_DTPMOD32: 4477 case R_PARISC_TLS_DTPOFF32: 4478 case R_PARISC_TLS_TPREL32: 4479 return reloc_class_normal; 4480 } 4481 4482 if (ELF32_R_SYM (rela->r_info) == STN_UNDEF) 4483 return reloc_class_relative; 4484 4485 switch ((int) ELF32_R_TYPE (rela->r_info)) 4486 { 4487 case R_PARISC_IPLT: 4488 return reloc_class_plt; 4489 case R_PARISC_COPY: 4490 return reloc_class_copy; 4491 default: 4492 return reloc_class_normal; 4493 } 4494 } 4495 4496 /* Finish up the dynamic sections. */ 4497 4498 static bfd_boolean 4499 elf32_hppa_finish_dynamic_sections (bfd *output_bfd, 4500 struct bfd_link_info *info) 4501 { 4502 bfd *dynobj; 4503 struct elf32_hppa_link_hash_table *htab; 4504 asection *sdyn; 4505 4506 htab = hppa_link_hash_table (info); 4507 if (htab == NULL) 4508 return FALSE; 4509 4510 dynobj = htab->etab.dynobj; 4511 4512 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 4513 4514 if (htab->etab.dynamic_sections_created) 4515 { 4516 Elf32_External_Dyn *dyncon, *dynconend; 4517 4518 if (sdyn == NULL) 4519 abort (); 4520 4521 dyncon = (Elf32_External_Dyn *) sdyn->contents; 4522 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 4523 for (; dyncon < dynconend; dyncon++) 4524 { 4525 Elf_Internal_Dyn dyn; 4526 asection *s; 4527 4528 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 4529 4530 switch (dyn.d_tag) 4531 { 4532 default: 4533 continue; 4534 4535 case DT_PLTGOT: 4536 /* Use PLTGOT to set the GOT register. */ 4537 dyn.d_un.d_ptr = elf_gp (output_bfd); 4538 break; 4539 4540 case DT_JMPREL: 4541 s = htab->srelplt; 4542 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 4543 break; 4544 4545 case DT_PLTRELSZ: 4546 s = htab->srelplt; 4547 dyn.d_un.d_val = s->size; 4548 break; 4549 4550 case DT_RELASZ: 4551 /* Don't count procedure linkage table relocs in the 4552 overall reloc count. */ 4553 s = htab->srelplt; 4554 if (s == NULL) 4555 continue; 4556 dyn.d_un.d_val -= s->size; 4557 break; 4558 4559 case DT_RELA: 4560 /* We may not be using the standard ELF linker script. 4561 If .rela.plt is the first .rela section, we adjust 4562 DT_RELA to not include it. */ 4563 s = htab->srelplt; 4564 if (s == NULL) 4565 continue; 4566 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset) 4567 continue; 4568 dyn.d_un.d_ptr += s->size; 4569 break; 4570 } 4571 4572 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4573 } 4574 } 4575 4576 if (htab->sgot != NULL && htab->sgot->size != 0) 4577 { 4578 /* Fill in the first entry in the global offset table. 4579 We use it to point to our dynamic section, if we have one. */ 4580 bfd_put_32 (output_bfd, 4581 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0, 4582 htab->sgot->contents); 4583 4584 /* The second entry is reserved for use by the dynamic linker. */ 4585 memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE); 4586 4587 /* Set .got entry size. */ 4588 elf_section_data (htab->sgot->output_section) 4589 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 4590 } 4591 4592 if (htab->splt != NULL && htab->splt->size != 0) 4593 { 4594 /* Set plt entry size. */ 4595 elf_section_data (htab->splt->output_section) 4596 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE; 4597 4598 if (htab->need_plt_stub) 4599 { 4600 /* Set up the .plt stub. */ 4601 memcpy (htab->splt->contents 4602 + htab->splt->size - sizeof (plt_stub), 4603 plt_stub, sizeof (plt_stub)); 4604 4605 if ((htab->splt->output_offset 4606 + htab->splt->output_section->vma 4607 + htab->splt->size) 4608 != (htab->sgot->output_offset 4609 + htab->sgot->output_section->vma)) 4610 { 4611 (*_bfd_error_handler) 4612 (_(".got section not immediately after .plt section")); 4613 return FALSE; 4614 } 4615 } 4616 } 4617 4618 return TRUE; 4619 } 4620 4621 /* Called when writing out an object file to decide the type of a 4622 symbol. */ 4623 static int 4624 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type) 4625 { 4626 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI) 4627 return STT_PARISC_MILLI; 4628 else 4629 return type; 4630 } 4631 4632 /* Misc BFD support code. */ 4633 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name 4634 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup 4635 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup 4636 #define elf_info_to_howto elf_hppa_info_to_howto 4637 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel 4638 4639 /* Stuff for the BFD linker. */ 4640 #define bfd_elf32_bfd_final_link elf32_hppa_final_link 4641 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create 4642 #define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free 4643 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol 4644 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol 4645 #define elf_backend_check_relocs elf32_hppa_check_relocs 4646 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections 4647 #define elf_backend_fake_sections elf_hppa_fake_sections 4648 #define elf_backend_relocate_section elf32_hppa_relocate_section 4649 #define elf_backend_hide_symbol elf32_hppa_hide_symbol 4650 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol 4651 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections 4652 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections 4653 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 4654 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook 4655 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook 4656 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus 4657 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo 4658 #define elf_backend_object_p elf32_hppa_object_p 4659 #define elf_backend_final_write_processing elf_hppa_final_write_processing 4660 #define elf_backend_post_process_headers _bfd_elf_set_osabi 4661 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type 4662 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class 4663 #define elf_backend_action_discarded elf_hppa_action_discarded 4664 4665 #define elf_backend_can_gc_sections 1 4666 #define elf_backend_can_refcount 1 4667 #define elf_backend_plt_alignment 2 4668 #define elf_backend_want_got_plt 0 4669 #define elf_backend_plt_readonly 0 4670 #define elf_backend_want_plt_sym 0 4671 #define elf_backend_got_header_size 8 4672 #define elf_backend_rela_normal 1 4673 4674 #define TARGET_BIG_SYM bfd_elf32_hppa_vec 4675 #define TARGET_BIG_NAME "elf32-hppa" 4676 #define ELF_ARCH bfd_arch_hppa 4677 #define ELF_TARGET_ID HPPA32_ELF_DATA 4678 #define ELF_MACHINE_CODE EM_PARISC 4679 #define ELF_MAXPAGESIZE 0x1000 4680 #define ELF_OSABI ELFOSABI_HPUX 4681 #define elf32_bed elf32_hppa_hpux_bed 4682 4683 #include "elf32-target.h" 4684 4685 #undef TARGET_BIG_SYM 4686 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec 4687 #undef TARGET_BIG_NAME 4688 #define TARGET_BIG_NAME "elf32-hppa-linux" 4689 #undef ELF_OSABI 4690 #define ELF_OSABI ELFOSABI_LINUX 4691 #undef elf32_bed 4692 #define elf32_bed elf32_hppa_linux_bed 4693 4694 #include "elf32-target.h" 4695 4696 #undef TARGET_BIG_SYM 4697 #define TARGET_BIG_SYM bfd_elf32_hppa_nbsd_vec 4698 #undef TARGET_BIG_NAME 4699 #define TARGET_BIG_NAME "elf32-hppa-netbsd" 4700 #undef ELF_OSABI 4701 #define ELF_OSABI ELFOSABI_NETBSD 4702 #undef elf32_bed 4703 #define elf32_bed elf32_hppa_netbsd_bed 4704 4705 #include "elf32-target.h" 4706