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, 2011, 2012 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=GNU, 954 but the kernel produces corefiles with OSABI=SysV. */ 955 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU && 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_linker_section (abfd, ".plt"); 1009 htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt"); 1010 1011 htab->sgot = bfd_get_linker_section (abfd, ".got"); 1012 htab->srelgot = bfd_get_linker_section (abfd, ".rela.got"); 1013 1014 htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss"); 1015 htab->srelbss = bfd_get_linker_section (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 /* STT_GNU_IFUNC symbol must go through PLT. */ 1793 if (! hppa_elf_hash_entry (eh)->plabel 1794 && eh->type != STT_GNU_IFUNC) 1795 { 1796 eh->needs_plt = 0; 1797 eh->plt = elf_hash_table (info)->init_plt_offset; 1798 } 1799 } 1800 1801 /* Adjust a symbol defined by a dynamic object and referenced by a 1802 regular object. The current definition is in some section of the 1803 dynamic object, but we're not including those sections. We have to 1804 change the definition to something the rest of the link can 1805 understand. */ 1806 1807 static bfd_boolean 1808 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, 1809 struct elf_link_hash_entry *eh) 1810 { 1811 struct elf32_hppa_link_hash_table *htab; 1812 asection *sec; 1813 1814 /* If this is a function, put it in the procedure linkage table. We 1815 will fill in the contents of the procedure linkage table later. */ 1816 if (eh->type == STT_FUNC 1817 || eh->needs_plt) 1818 { 1819 /* If the symbol is used by a plabel, we must allocate a PLT slot. 1820 The refcounts are not reliable when it has been hidden since 1821 hide_symbol can be called before the plabel flag is set. */ 1822 if (hppa_elf_hash_entry (eh)->plabel 1823 && eh->plt.refcount <= 0) 1824 eh->plt.refcount = 1; 1825 1826 if (eh->plt.refcount <= 0 1827 || (eh->def_regular 1828 && eh->root.type != bfd_link_hash_defweak 1829 && ! hppa_elf_hash_entry (eh)->plabel 1830 && (!info->shared || info->symbolic))) 1831 { 1832 /* The .plt entry is not needed when: 1833 a) Garbage collection has removed all references to the 1834 symbol, or 1835 b) We know for certain the symbol is defined in this 1836 object, and it's not a weak definition, nor is the symbol 1837 used by a plabel relocation. Either this object is the 1838 application or we are doing a shared symbolic link. */ 1839 1840 eh->plt.offset = (bfd_vma) -1; 1841 eh->needs_plt = 0; 1842 } 1843 1844 return TRUE; 1845 } 1846 else 1847 eh->plt.offset = (bfd_vma) -1; 1848 1849 /* If this is a weak symbol, and there is a real definition, the 1850 processor independent code will have arranged for us to see the 1851 real definition first, and we can just use the same value. */ 1852 if (eh->u.weakdef != NULL) 1853 { 1854 if (eh->u.weakdef->root.type != bfd_link_hash_defined 1855 && eh->u.weakdef->root.type != bfd_link_hash_defweak) 1856 abort (); 1857 eh->root.u.def.section = eh->u.weakdef->root.u.def.section; 1858 eh->root.u.def.value = eh->u.weakdef->root.u.def.value; 1859 if (ELIMINATE_COPY_RELOCS) 1860 eh->non_got_ref = eh->u.weakdef->non_got_ref; 1861 return TRUE; 1862 } 1863 1864 /* This is a reference to a symbol defined by a dynamic object which 1865 is not a function. */ 1866 1867 /* If we are creating a shared library, we must presume that the 1868 only references to the symbol are via the global offset table. 1869 For such cases we need not do anything here; the relocations will 1870 be handled correctly by relocate_section. */ 1871 if (info->shared) 1872 return TRUE; 1873 1874 /* If there are no references to this symbol that do not use the 1875 GOT, we don't need to generate a copy reloc. */ 1876 if (!eh->non_got_ref) 1877 return TRUE; 1878 1879 if (ELIMINATE_COPY_RELOCS) 1880 { 1881 struct elf32_hppa_link_hash_entry *hh; 1882 struct elf32_hppa_dyn_reloc_entry *hdh_p; 1883 1884 hh = hppa_elf_hash_entry (eh); 1885 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 1886 { 1887 sec = hdh_p->sec->output_section; 1888 if (sec != NULL && (sec->flags & SEC_READONLY) != 0) 1889 break; 1890 } 1891 1892 /* If we didn't find any dynamic relocs in read-only sections, then 1893 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1894 if (hdh_p == NULL) 1895 { 1896 eh->non_got_ref = 0; 1897 return TRUE; 1898 } 1899 } 1900 1901 /* We must allocate the symbol in our .dynbss section, which will 1902 become part of the .bss section of the executable. There will be 1903 an entry for this symbol in the .dynsym section. The dynamic 1904 object will contain position independent code, so all references 1905 from the dynamic object to this symbol will go through the global 1906 offset table. The dynamic linker will use the .dynsym entry to 1907 determine the address it must put in the global offset table, so 1908 both the dynamic object and the regular object will refer to the 1909 same memory location for the variable. */ 1910 1911 htab = hppa_link_hash_table (info); 1912 if (htab == NULL) 1913 return FALSE; 1914 1915 /* We must generate a COPY reloc to tell the dynamic linker to 1916 copy the initial value out of the dynamic object and into the 1917 runtime process image. */ 1918 if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0) 1919 { 1920 htab->srelbss->size += sizeof (Elf32_External_Rela); 1921 eh->needs_copy = 1; 1922 } 1923 1924 sec = htab->sdynbss; 1925 1926 return _bfd_elf_adjust_dynamic_copy (eh, sec); 1927 } 1928 1929 /* Allocate space in the .plt for entries that won't have relocations. 1930 ie. plabel entries. */ 1931 1932 static bfd_boolean 1933 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf) 1934 { 1935 struct bfd_link_info *info; 1936 struct elf32_hppa_link_hash_table *htab; 1937 struct elf32_hppa_link_hash_entry *hh; 1938 asection *sec; 1939 1940 if (eh->root.type == bfd_link_hash_indirect) 1941 return TRUE; 1942 1943 info = (struct bfd_link_info *) inf; 1944 hh = hppa_elf_hash_entry (eh); 1945 htab = hppa_link_hash_table (info); 1946 if (htab == NULL) 1947 return FALSE; 1948 1949 if (htab->etab.dynamic_sections_created 1950 && eh->plt.refcount > 0) 1951 { 1952 /* Make sure this symbol is output as a dynamic symbol. 1953 Undefined weak syms won't yet be marked as dynamic. */ 1954 if (eh->dynindx == -1 1955 && !eh->forced_local 1956 && eh->type != STT_PARISC_MILLI) 1957 { 1958 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 1959 return FALSE; 1960 } 1961 1962 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, eh)) 1963 { 1964 /* Allocate these later. From this point on, h->plabel 1965 means that the plt entry is only used by a plabel. 1966 We'll be using a normal plt entry for this symbol, so 1967 clear the plabel indicator. */ 1968 1969 hh->plabel = 0; 1970 } 1971 else if (hh->plabel) 1972 { 1973 /* Make an entry in the .plt section for plabel references 1974 that won't have a .plt entry for other reasons. */ 1975 sec = htab->splt; 1976 eh->plt.offset = sec->size; 1977 sec->size += PLT_ENTRY_SIZE; 1978 } 1979 else 1980 { 1981 /* No .plt entry needed. */ 1982 eh->plt.offset = (bfd_vma) -1; 1983 eh->needs_plt = 0; 1984 } 1985 } 1986 else 1987 { 1988 eh->plt.offset = (bfd_vma) -1; 1989 eh->needs_plt = 0; 1990 } 1991 1992 return TRUE; 1993 } 1994 1995 /* Allocate space in .plt, .got and associated reloc sections for 1996 global syms. */ 1997 1998 static bfd_boolean 1999 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf) 2000 { 2001 struct bfd_link_info *info; 2002 struct elf32_hppa_link_hash_table *htab; 2003 asection *sec; 2004 struct elf32_hppa_link_hash_entry *hh; 2005 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2006 2007 if (eh->root.type == bfd_link_hash_indirect) 2008 return TRUE; 2009 2010 info = inf; 2011 htab = hppa_link_hash_table (info); 2012 if (htab == NULL) 2013 return FALSE; 2014 2015 hh = hppa_elf_hash_entry (eh); 2016 2017 if (htab->etab.dynamic_sections_created 2018 && eh->plt.offset != (bfd_vma) -1 2019 && !hh->plabel 2020 && eh->plt.refcount > 0) 2021 { 2022 /* Make an entry in the .plt section. */ 2023 sec = htab->splt; 2024 eh->plt.offset = sec->size; 2025 sec->size += PLT_ENTRY_SIZE; 2026 2027 /* We also need to make an entry in the .rela.plt section. */ 2028 htab->srelplt->size += sizeof (Elf32_External_Rela); 2029 htab->need_plt_stub = 1; 2030 } 2031 2032 if (eh->got.refcount > 0) 2033 { 2034 /* Make sure this symbol is output as a dynamic symbol. 2035 Undefined weak syms won't yet be marked as dynamic. */ 2036 if (eh->dynindx == -1 2037 && !eh->forced_local 2038 && eh->type != STT_PARISC_MILLI) 2039 { 2040 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2041 return FALSE; 2042 } 2043 2044 sec = htab->sgot; 2045 eh->got.offset = sec->size; 2046 sec->size += GOT_ENTRY_SIZE; 2047 /* R_PARISC_TLS_GD* needs two GOT entries */ 2048 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2049 sec->size += GOT_ENTRY_SIZE * 2; 2050 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2051 sec->size += GOT_ENTRY_SIZE; 2052 if (htab->etab.dynamic_sections_created 2053 && (info->shared 2054 || (eh->dynindx != -1 2055 && !eh->forced_local))) 2056 { 2057 htab->srelgot->size += sizeof (Elf32_External_Rela); 2058 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2059 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela); 2060 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2061 htab->srelgot->size += sizeof (Elf32_External_Rela); 2062 } 2063 } 2064 else 2065 eh->got.offset = (bfd_vma) -1; 2066 2067 if (hh->dyn_relocs == NULL) 2068 return TRUE; 2069 2070 /* If this is a -Bsymbolic shared link, then we need to discard all 2071 space allocated for dynamic pc-relative relocs against symbols 2072 defined in a regular object. For the normal shared case, discard 2073 space for relocs that have become local due to symbol visibility 2074 changes. */ 2075 if (info->shared) 2076 { 2077 #if RELATIVE_DYNRELOCS 2078 if (SYMBOL_CALLS_LOCAL (info, eh)) 2079 { 2080 struct elf32_hppa_dyn_reloc_entry **hdh_pp; 2081 2082 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; ) 2083 { 2084 hdh_p->count -= hdh_p->relative_count; 2085 hdh_p->relative_count = 0; 2086 if (hdh_p->count == 0) 2087 *hdh_pp = hdh_p->hdh_next; 2088 else 2089 hdh_pp = &hdh_p->hdh_next; 2090 } 2091 } 2092 #endif 2093 2094 /* Also discard relocs on undefined weak syms with non-default 2095 visibility. */ 2096 if (hh->dyn_relocs != NULL 2097 && eh->root.type == bfd_link_hash_undefweak) 2098 { 2099 if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT) 2100 hh->dyn_relocs = NULL; 2101 2102 /* Make sure undefined weak symbols are output as a dynamic 2103 symbol in PIEs. */ 2104 else if (eh->dynindx == -1 2105 && !eh->forced_local) 2106 { 2107 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2108 return FALSE; 2109 } 2110 } 2111 } 2112 else 2113 { 2114 /* For the non-shared case, discard space for relocs against 2115 symbols which turn out to need copy relocs or are not 2116 dynamic. */ 2117 2118 if (!eh->non_got_ref 2119 && ((ELIMINATE_COPY_RELOCS 2120 && eh->def_dynamic 2121 && !eh->def_regular) 2122 || (htab->etab.dynamic_sections_created 2123 && (eh->root.type == bfd_link_hash_undefweak 2124 || eh->root.type == bfd_link_hash_undefined)))) 2125 { 2126 /* Make sure this symbol is output as a dynamic symbol. 2127 Undefined weak syms won't yet be marked as dynamic. */ 2128 if (eh->dynindx == -1 2129 && !eh->forced_local 2130 && eh->type != STT_PARISC_MILLI) 2131 { 2132 if (! bfd_elf_link_record_dynamic_symbol (info, eh)) 2133 return FALSE; 2134 } 2135 2136 /* If that succeeded, we know we'll be keeping all the 2137 relocs. */ 2138 if (eh->dynindx != -1) 2139 goto keep; 2140 } 2141 2142 hh->dyn_relocs = NULL; 2143 return TRUE; 2144 2145 keep: ; 2146 } 2147 2148 /* Finally, allocate space. */ 2149 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 2150 { 2151 asection *sreloc = elf_section_data (hdh_p->sec)->sreloc; 2152 sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela); 2153 } 2154 2155 return TRUE; 2156 } 2157 2158 /* This function is called via elf_link_hash_traverse to force 2159 millicode symbols local so they do not end up as globals in the 2160 dynamic symbol table. We ought to be able to do this in 2161 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called 2162 for all dynamic symbols. Arguably, this is a bug in 2163 elf_adjust_dynamic_symbol. */ 2164 2165 static bfd_boolean 2166 clobber_millicode_symbols (struct elf_link_hash_entry *eh, 2167 struct bfd_link_info *info) 2168 { 2169 if (eh->type == STT_PARISC_MILLI 2170 && !eh->forced_local) 2171 { 2172 elf32_hppa_hide_symbol (info, eh, TRUE); 2173 } 2174 return TRUE; 2175 } 2176 2177 /* Find any dynamic relocs that apply to read-only sections. */ 2178 2179 static bfd_boolean 2180 readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf) 2181 { 2182 struct elf32_hppa_link_hash_entry *hh; 2183 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2184 2185 hh = hppa_elf_hash_entry (eh); 2186 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next) 2187 { 2188 asection *sec = hdh_p->sec->output_section; 2189 2190 if (sec != NULL && (sec->flags & SEC_READONLY) != 0) 2191 { 2192 struct bfd_link_info *info = inf; 2193 2194 if (info->warn_shared_textrel) 2195 (*_bfd_error_handler) 2196 (_("warning: dynamic relocation in readonly section `%s'"), 2197 eh->root.root.string); 2198 info->flags |= DF_TEXTREL; 2199 2200 /* Not an error, just cut short the traversal. */ 2201 return FALSE; 2202 } 2203 } 2204 return TRUE; 2205 } 2206 2207 /* Set the sizes of the dynamic sections. */ 2208 2209 static bfd_boolean 2210 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2211 struct bfd_link_info *info) 2212 { 2213 struct elf32_hppa_link_hash_table *htab; 2214 bfd *dynobj; 2215 bfd *ibfd; 2216 asection *sec; 2217 bfd_boolean relocs; 2218 2219 htab = hppa_link_hash_table (info); 2220 if (htab == NULL) 2221 return FALSE; 2222 2223 dynobj = htab->etab.dynobj; 2224 if (dynobj == NULL) 2225 abort (); 2226 2227 if (htab->etab.dynamic_sections_created) 2228 { 2229 /* Set the contents of the .interp section to the interpreter. */ 2230 if (info->executable) 2231 { 2232 sec = bfd_get_linker_section (dynobj, ".interp"); 2233 if (sec == NULL) 2234 abort (); 2235 sec->size = sizeof ELF_DYNAMIC_INTERPRETER; 2236 sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2237 } 2238 2239 /* Force millicode symbols local. */ 2240 elf_link_hash_traverse (&htab->etab, 2241 clobber_millicode_symbols, 2242 info); 2243 } 2244 2245 /* Set up .got and .plt offsets for local syms, and space for local 2246 dynamic relocs. */ 2247 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 2248 { 2249 bfd_signed_vma *local_got; 2250 bfd_signed_vma *end_local_got; 2251 bfd_signed_vma *local_plt; 2252 bfd_signed_vma *end_local_plt; 2253 bfd_size_type locsymcount; 2254 Elf_Internal_Shdr *symtab_hdr; 2255 asection *srel; 2256 char *local_tls_type; 2257 2258 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 2259 continue; 2260 2261 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 2262 { 2263 struct elf32_hppa_dyn_reloc_entry *hdh_p; 2264 2265 for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *) 2266 elf_section_data (sec)->local_dynrel); 2267 hdh_p != NULL; 2268 hdh_p = hdh_p->hdh_next) 2269 { 2270 if (!bfd_is_abs_section (hdh_p->sec) 2271 && bfd_is_abs_section (hdh_p->sec->output_section)) 2272 { 2273 /* Input section has been discarded, either because 2274 it is a copy of a linkonce section or due to 2275 linker script /DISCARD/, so we'll be discarding 2276 the relocs too. */ 2277 } 2278 else if (hdh_p->count != 0) 2279 { 2280 srel = elf_section_data (hdh_p->sec)->sreloc; 2281 srel->size += hdh_p->count * sizeof (Elf32_External_Rela); 2282 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0) 2283 info->flags |= DF_TEXTREL; 2284 } 2285 } 2286 } 2287 2288 local_got = elf_local_got_refcounts (ibfd); 2289 if (!local_got) 2290 continue; 2291 2292 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2293 locsymcount = symtab_hdr->sh_info; 2294 end_local_got = local_got + locsymcount; 2295 local_tls_type = hppa_elf_local_got_tls_type (ibfd); 2296 sec = htab->sgot; 2297 srel = htab->srelgot; 2298 for (; local_got < end_local_got; ++local_got) 2299 { 2300 if (*local_got > 0) 2301 { 2302 *local_got = sec->size; 2303 sec->size += GOT_ENTRY_SIZE; 2304 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2305 sec->size += 2 * GOT_ENTRY_SIZE; 2306 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2307 sec->size += GOT_ENTRY_SIZE; 2308 if (info->shared) 2309 { 2310 srel->size += sizeof (Elf32_External_Rela); 2311 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE)) 2312 srel->size += 2 * sizeof (Elf32_External_Rela); 2313 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD) 2314 srel->size += sizeof (Elf32_External_Rela); 2315 } 2316 } 2317 else 2318 *local_got = (bfd_vma) -1; 2319 2320 ++local_tls_type; 2321 } 2322 2323 local_plt = end_local_got; 2324 end_local_plt = local_plt + locsymcount; 2325 if (! htab->etab.dynamic_sections_created) 2326 { 2327 /* Won't be used, but be safe. */ 2328 for (; local_plt < end_local_plt; ++local_plt) 2329 *local_plt = (bfd_vma) -1; 2330 } 2331 else 2332 { 2333 sec = htab->splt; 2334 srel = htab->srelplt; 2335 for (; local_plt < end_local_plt; ++local_plt) 2336 { 2337 if (*local_plt > 0) 2338 { 2339 *local_plt = sec->size; 2340 sec->size += PLT_ENTRY_SIZE; 2341 if (info->shared) 2342 srel->size += sizeof (Elf32_External_Rela); 2343 } 2344 else 2345 *local_plt = (bfd_vma) -1; 2346 } 2347 } 2348 } 2349 2350 if (htab->tls_ldm_got.refcount > 0) 2351 { 2352 /* Allocate 2 got entries and 1 dynamic reloc for 2353 R_PARISC_TLS_DTPMOD32 relocs. */ 2354 htab->tls_ldm_got.offset = htab->sgot->size; 2355 htab->sgot->size += (GOT_ENTRY_SIZE * 2); 2356 htab->srelgot->size += sizeof (Elf32_External_Rela); 2357 } 2358 else 2359 htab->tls_ldm_got.offset = -1; 2360 2361 /* Do all the .plt entries without relocs first. The dynamic linker 2362 uses the last .plt reloc to find the end of the .plt (and hence 2363 the start of the .got) for lazy linking. */ 2364 elf_link_hash_traverse (&htab->etab, allocate_plt_static, info); 2365 2366 /* Allocate global sym .plt and .got entries, and space for global 2367 sym dynamic relocs. */ 2368 elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info); 2369 2370 /* The check_relocs and adjust_dynamic_symbol entry points have 2371 determined the sizes of the various dynamic sections. Allocate 2372 memory for them. */ 2373 relocs = FALSE; 2374 for (sec = dynobj->sections; sec != NULL; sec = sec->next) 2375 { 2376 if ((sec->flags & SEC_LINKER_CREATED) == 0) 2377 continue; 2378 2379 if (sec == htab->splt) 2380 { 2381 if (htab->need_plt_stub) 2382 { 2383 /* Make space for the plt stub at the end of the .plt 2384 section. We want this stub right at the end, up 2385 against the .got section. */ 2386 int gotalign = bfd_section_alignment (dynobj, htab->sgot); 2387 int pltalign = bfd_section_alignment (dynobj, sec); 2388 bfd_size_type mask; 2389 2390 if (gotalign > pltalign) 2391 bfd_set_section_alignment (dynobj, sec, gotalign); 2392 mask = ((bfd_size_type) 1 << gotalign) - 1; 2393 sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask; 2394 } 2395 } 2396 else if (sec == htab->sgot 2397 || sec == htab->sdynbss) 2398 ; 2399 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela")) 2400 { 2401 if (sec->size != 0) 2402 { 2403 /* Remember whether there are any reloc sections other 2404 than .rela.plt. */ 2405 if (sec != htab->srelplt) 2406 relocs = TRUE; 2407 2408 /* We use the reloc_count field as a counter if we need 2409 to copy relocs into the output file. */ 2410 sec->reloc_count = 0; 2411 } 2412 } 2413 else 2414 { 2415 /* It's not one of our sections, so don't allocate space. */ 2416 continue; 2417 } 2418 2419 if (sec->size == 0) 2420 { 2421 /* If we don't need this section, strip it from the 2422 output file. This is mostly to handle .rela.bss and 2423 .rela.plt. We must create both sections in 2424 create_dynamic_sections, because they must be created 2425 before the linker maps input sections to output 2426 sections. The linker does that before 2427 adjust_dynamic_symbol is called, and it is that 2428 function which decides whether anything needs to go 2429 into these sections. */ 2430 sec->flags |= SEC_EXCLUDE; 2431 continue; 2432 } 2433 2434 if ((sec->flags & SEC_HAS_CONTENTS) == 0) 2435 continue; 2436 2437 /* Allocate memory for the section contents. Zero it, because 2438 we may not fill in all the reloc sections. */ 2439 sec->contents = bfd_zalloc (dynobj, sec->size); 2440 if (sec->contents == NULL) 2441 return FALSE; 2442 } 2443 2444 if (htab->etab.dynamic_sections_created) 2445 { 2446 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It 2447 actually has nothing to do with the PLT, it is how we 2448 communicate the LTP value of a load module to the dynamic 2449 linker. */ 2450 #define add_dynamic_entry(TAG, VAL) \ 2451 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2452 2453 if (!add_dynamic_entry (DT_PLTGOT, 0)) 2454 return FALSE; 2455 2456 /* Add some entries to the .dynamic section. We fill in the 2457 values later, in elf32_hppa_finish_dynamic_sections, but we 2458 must add the entries now so that we get the correct size for 2459 the .dynamic section. The DT_DEBUG entry is filled in by the 2460 dynamic linker and used by the debugger. */ 2461 if (info->executable) 2462 { 2463 if (!add_dynamic_entry (DT_DEBUG, 0)) 2464 return FALSE; 2465 } 2466 2467 if (htab->srelplt->size != 0) 2468 { 2469 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 2470 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2471 || !add_dynamic_entry (DT_JMPREL, 0)) 2472 return FALSE; 2473 } 2474 2475 if (relocs) 2476 { 2477 if (!add_dynamic_entry (DT_RELA, 0) 2478 || !add_dynamic_entry (DT_RELASZ, 0) 2479 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 2480 return FALSE; 2481 2482 /* If any dynamic relocs apply to a read-only section, 2483 then we need a DT_TEXTREL entry. */ 2484 if ((info->flags & DF_TEXTREL) == 0) 2485 elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info); 2486 2487 if ((info->flags & DF_TEXTREL) != 0) 2488 { 2489 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2490 return FALSE; 2491 } 2492 } 2493 } 2494 #undef add_dynamic_entry 2495 2496 return TRUE; 2497 } 2498 2499 /* External entry points for sizing and building linker stubs. */ 2500 2501 /* Set up various things so that we can make a list of input sections 2502 for each output section included in the link. Returns -1 on error, 2503 0 when no stubs will be needed, and 1 on success. */ 2504 2505 int 2506 elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info) 2507 { 2508 bfd *input_bfd; 2509 unsigned int bfd_count; 2510 int top_id, top_index; 2511 asection *section; 2512 asection **input_list, **list; 2513 bfd_size_type amt; 2514 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2515 2516 if (htab == NULL) 2517 return -1; 2518 2519 /* Count the number of input BFDs and find the top input section id. */ 2520 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0; 2521 input_bfd != NULL; 2522 input_bfd = input_bfd->link_next) 2523 { 2524 bfd_count += 1; 2525 for (section = input_bfd->sections; 2526 section != NULL; 2527 section = section->next) 2528 { 2529 if (top_id < section->id) 2530 top_id = section->id; 2531 } 2532 } 2533 htab->bfd_count = bfd_count; 2534 2535 amt = sizeof (struct map_stub) * (top_id + 1); 2536 htab->stub_group = bfd_zmalloc (amt); 2537 if (htab->stub_group == NULL) 2538 return -1; 2539 2540 /* We can't use output_bfd->section_count here to find the top output 2541 section index as some sections may have been removed, and 2542 strip_excluded_output_sections doesn't renumber the indices. */ 2543 for (section = output_bfd->sections, top_index = 0; 2544 section != NULL; 2545 section = section->next) 2546 { 2547 if (top_index < section->index) 2548 top_index = section->index; 2549 } 2550 2551 htab->top_index = top_index; 2552 amt = sizeof (asection *) * (top_index + 1); 2553 input_list = bfd_malloc (amt); 2554 htab->input_list = input_list; 2555 if (input_list == NULL) 2556 return -1; 2557 2558 /* For sections we aren't interested in, mark their entries with a 2559 value we can check later. */ 2560 list = input_list + top_index; 2561 do 2562 *list = bfd_abs_section_ptr; 2563 while (list-- != input_list); 2564 2565 for (section = output_bfd->sections; 2566 section != NULL; 2567 section = section->next) 2568 { 2569 if ((section->flags & SEC_CODE) != 0) 2570 input_list[section->index] = NULL; 2571 } 2572 2573 return 1; 2574 } 2575 2576 /* The linker repeatedly calls this function for each input section, 2577 in the order that input sections are linked into output sections. 2578 Build lists of input sections to determine groupings between which 2579 we may insert linker stubs. */ 2580 2581 void 2582 elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec) 2583 { 2584 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2585 2586 if (htab == NULL) 2587 return; 2588 2589 if (isec->output_section->index <= htab->top_index) 2590 { 2591 asection **list = htab->input_list + isec->output_section->index; 2592 if (*list != bfd_abs_section_ptr) 2593 { 2594 /* Steal the link_sec pointer for our list. */ 2595 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec) 2596 /* This happens to make the list in reverse order, 2597 which is what we want. */ 2598 PREV_SEC (isec) = *list; 2599 *list = isec; 2600 } 2601 } 2602 } 2603 2604 /* See whether we can group stub sections together. Grouping stub 2605 sections may result in fewer stubs. More importantly, we need to 2606 put all .init* and .fini* stubs at the beginning of the .init or 2607 .fini output sections respectively, because glibc splits the 2608 _init and _fini functions into multiple parts. Putting a stub in 2609 the middle of a function is not a good idea. */ 2610 2611 static void 2612 group_sections (struct elf32_hppa_link_hash_table *htab, 2613 bfd_size_type stub_group_size, 2614 bfd_boolean stubs_always_before_branch) 2615 { 2616 asection **list = htab->input_list + htab->top_index; 2617 do 2618 { 2619 asection *tail = *list; 2620 if (tail == bfd_abs_section_ptr) 2621 continue; 2622 while (tail != NULL) 2623 { 2624 asection *curr; 2625 asection *prev; 2626 bfd_size_type total; 2627 bfd_boolean big_sec; 2628 2629 curr = tail; 2630 total = tail->size; 2631 big_sec = total >= stub_group_size; 2632 2633 while ((prev = PREV_SEC (curr)) != NULL 2634 && ((total += curr->output_offset - prev->output_offset) 2635 < stub_group_size)) 2636 curr = prev; 2637 2638 /* OK, the size from the start of CURR to the end is less 2639 than 240000 bytes and thus can be handled by one stub 2640 section. (or the tail section is itself larger than 2641 240000 bytes, in which case we may be toast.) 2642 We should really be keeping track of the total size of 2643 stubs added here, as stubs contribute to the final output 2644 section size. That's a little tricky, and this way will 2645 only break if stubs added total more than 22144 bytes, or 2646 2768 long branch stubs. It seems unlikely for more than 2647 2768 different functions to be called, especially from 2648 code only 240000 bytes long. This limit used to be 2649 250000, but c++ code tends to generate lots of little 2650 functions, and sometimes violated the assumption. */ 2651 do 2652 { 2653 prev = PREV_SEC (tail); 2654 /* Set up this stub group. */ 2655 htab->stub_group[tail->id].link_sec = curr; 2656 } 2657 while (tail != curr && (tail = prev) != NULL); 2658 2659 /* But wait, there's more! Input sections up to 240000 2660 bytes before the stub section can be handled by it too. 2661 Don't do this if we have a really large section after the 2662 stubs, as adding more stubs increases the chance that 2663 branches may not reach into the stub section. */ 2664 if (!stubs_always_before_branch && !big_sec) 2665 { 2666 total = 0; 2667 while (prev != NULL 2668 && ((total += tail->output_offset - prev->output_offset) 2669 < stub_group_size)) 2670 { 2671 tail = prev; 2672 prev = PREV_SEC (tail); 2673 htab->stub_group[tail->id].link_sec = curr; 2674 } 2675 } 2676 tail = prev; 2677 } 2678 } 2679 while (list-- != htab->input_list); 2680 free (htab->input_list); 2681 #undef PREV_SEC 2682 } 2683 2684 /* Read in all local syms for all input bfds, and create hash entries 2685 for export stubs if we are building a multi-subspace shared lib. 2686 Returns -1 on error, 1 if export stubs created, 0 otherwise. */ 2687 2688 static int 2689 get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info) 2690 { 2691 unsigned int bfd_indx; 2692 Elf_Internal_Sym *local_syms, **all_local_syms; 2693 int stub_changed = 0; 2694 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2695 2696 if (htab == NULL) 2697 return -1; 2698 2699 /* We want to read in symbol extension records only once. To do this 2700 we need to read in the local symbols in parallel and save them for 2701 later use; so hold pointers to the local symbols in an array. */ 2702 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count; 2703 all_local_syms = bfd_zmalloc (amt); 2704 htab->all_local_syms = all_local_syms; 2705 if (all_local_syms == NULL) 2706 return -1; 2707 2708 /* Walk over all the input BFDs, swapping in local symbols. 2709 If we are creating a shared library, create hash entries for the 2710 export stubs. */ 2711 for (bfd_indx = 0; 2712 input_bfd != NULL; 2713 input_bfd = input_bfd->link_next, bfd_indx++) 2714 { 2715 Elf_Internal_Shdr *symtab_hdr; 2716 2717 /* We'll need the symbol table in a second. */ 2718 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2719 if (symtab_hdr->sh_info == 0) 2720 continue; 2721 2722 /* We need an array of the local symbols attached to the input bfd. */ 2723 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 2724 if (local_syms == NULL) 2725 { 2726 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 2727 symtab_hdr->sh_info, 0, 2728 NULL, NULL, NULL); 2729 /* Cache them for elf_link_input_bfd. */ 2730 symtab_hdr->contents = (unsigned char *) local_syms; 2731 } 2732 if (local_syms == NULL) 2733 return -1; 2734 2735 all_local_syms[bfd_indx] = local_syms; 2736 2737 if (info->shared && htab->multi_subspace) 2738 { 2739 struct elf_link_hash_entry **eh_syms; 2740 struct elf_link_hash_entry **eh_symend; 2741 unsigned int symcount; 2742 2743 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2744 - symtab_hdr->sh_info); 2745 eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd); 2746 eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount); 2747 2748 /* Look through the global syms for functions; We need to 2749 build export stubs for all globally visible functions. */ 2750 for (; eh_syms < eh_symend; eh_syms++) 2751 { 2752 struct elf32_hppa_link_hash_entry *hh; 2753 2754 hh = hppa_elf_hash_entry (*eh_syms); 2755 2756 while (hh->eh.root.type == bfd_link_hash_indirect 2757 || hh->eh.root.type == bfd_link_hash_warning) 2758 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 2759 2760 /* At this point in the link, undefined syms have been 2761 resolved, so we need to check that the symbol was 2762 defined in this BFD. */ 2763 if ((hh->eh.root.type == bfd_link_hash_defined 2764 || hh->eh.root.type == bfd_link_hash_defweak) 2765 && hh->eh.type == STT_FUNC 2766 && hh->eh.root.u.def.section->output_section != NULL 2767 && (hh->eh.root.u.def.section->output_section->owner 2768 == output_bfd) 2769 && hh->eh.root.u.def.section->owner == input_bfd 2770 && hh->eh.def_regular 2771 && !hh->eh.forced_local 2772 && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT) 2773 { 2774 asection *sec; 2775 const char *stub_name; 2776 struct elf32_hppa_stub_hash_entry *hsh; 2777 2778 sec = hh->eh.root.u.def.section; 2779 stub_name = hh_name (hh); 2780 hsh = hppa_stub_hash_lookup (&htab->bstab, 2781 stub_name, 2782 FALSE, FALSE); 2783 if (hsh == NULL) 2784 { 2785 hsh = hppa_add_stub (stub_name, sec, htab); 2786 if (!hsh) 2787 return -1; 2788 2789 hsh->target_value = hh->eh.root.u.def.value; 2790 hsh->target_section = hh->eh.root.u.def.section; 2791 hsh->stub_type = hppa_stub_export; 2792 hsh->hh = hh; 2793 stub_changed = 1; 2794 } 2795 else 2796 { 2797 (*_bfd_error_handler) (_("%B: duplicate export stub %s"), 2798 input_bfd, 2799 stub_name); 2800 } 2801 } 2802 } 2803 } 2804 } 2805 2806 return stub_changed; 2807 } 2808 2809 /* Determine and set the size of the stub section for a final link. 2810 2811 The basic idea here is to examine all the relocations looking for 2812 PC-relative calls to a target that is unreachable with a "bl" 2813 instruction. */ 2814 2815 bfd_boolean 2816 elf32_hppa_size_stubs 2817 (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info, 2818 bfd_boolean multi_subspace, bfd_signed_vma group_size, 2819 asection * (*add_stub_section) (const char *, asection *), 2820 void (*layout_sections_again) (void)) 2821 { 2822 bfd_size_type stub_group_size; 2823 bfd_boolean stubs_always_before_branch; 2824 bfd_boolean stub_changed; 2825 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info); 2826 2827 if (htab == NULL) 2828 return FALSE; 2829 2830 /* Stash our params away. */ 2831 htab->stub_bfd = stub_bfd; 2832 htab->multi_subspace = multi_subspace; 2833 htab->add_stub_section = add_stub_section; 2834 htab->layout_sections_again = layout_sections_again; 2835 stubs_always_before_branch = group_size < 0; 2836 if (group_size < 0) 2837 stub_group_size = -group_size; 2838 else 2839 stub_group_size = group_size; 2840 if (stub_group_size == 1) 2841 { 2842 /* Default values. */ 2843 if (stubs_always_before_branch) 2844 { 2845 stub_group_size = 7680000; 2846 if (htab->has_17bit_branch || htab->multi_subspace) 2847 stub_group_size = 240000; 2848 if (htab->has_12bit_branch) 2849 stub_group_size = 7500; 2850 } 2851 else 2852 { 2853 stub_group_size = 6971392; 2854 if (htab->has_17bit_branch || htab->multi_subspace) 2855 stub_group_size = 217856; 2856 if (htab->has_12bit_branch) 2857 stub_group_size = 6808; 2858 } 2859 } 2860 2861 group_sections (htab, stub_group_size, stubs_always_before_branch); 2862 2863 switch (get_local_syms (output_bfd, info->input_bfds, info)) 2864 { 2865 default: 2866 if (htab->all_local_syms) 2867 goto error_ret_free_local; 2868 return FALSE; 2869 2870 case 0: 2871 stub_changed = FALSE; 2872 break; 2873 2874 case 1: 2875 stub_changed = TRUE; 2876 break; 2877 } 2878 2879 while (1) 2880 { 2881 bfd *input_bfd; 2882 unsigned int bfd_indx; 2883 asection *stub_sec; 2884 2885 for (input_bfd = info->input_bfds, bfd_indx = 0; 2886 input_bfd != NULL; 2887 input_bfd = input_bfd->link_next, bfd_indx++) 2888 { 2889 Elf_Internal_Shdr *symtab_hdr; 2890 asection *section; 2891 Elf_Internal_Sym *local_syms; 2892 2893 /* We'll need the symbol table in a second. */ 2894 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2895 if (symtab_hdr->sh_info == 0) 2896 continue; 2897 2898 local_syms = htab->all_local_syms[bfd_indx]; 2899 2900 /* Walk over each section attached to the input bfd. */ 2901 for (section = input_bfd->sections; 2902 section != NULL; 2903 section = section->next) 2904 { 2905 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 2906 2907 /* If there aren't any relocs, then there's nothing more 2908 to do. */ 2909 if ((section->flags & SEC_RELOC) == 0 2910 || section->reloc_count == 0) 2911 continue; 2912 2913 /* If this section is a link-once section that will be 2914 discarded, then don't create any stubs. */ 2915 if (section->output_section == NULL 2916 || section->output_section->owner != output_bfd) 2917 continue; 2918 2919 /* Get the relocs. */ 2920 internal_relocs 2921 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL, 2922 info->keep_memory); 2923 if (internal_relocs == NULL) 2924 goto error_ret_free_local; 2925 2926 /* Now examine each relocation. */ 2927 irela = internal_relocs; 2928 irelaend = irela + section->reloc_count; 2929 for (; irela < irelaend; irela++) 2930 { 2931 unsigned int r_type, r_indx; 2932 enum elf32_hppa_stub_type stub_type; 2933 struct elf32_hppa_stub_hash_entry *hsh; 2934 asection *sym_sec; 2935 bfd_vma sym_value; 2936 bfd_vma destination; 2937 struct elf32_hppa_link_hash_entry *hh; 2938 char *stub_name; 2939 const asection *id_sec; 2940 2941 r_type = ELF32_R_TYPE (irela->r_info); 2942 r_indx = ELF32_R_SYM (irela->r_info); 2943 2944 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED) 2945 { 2946 bfd_set_error (bfd_error_bad_value); 2947 error_ret_free_internal: 2948 if (elf_section_data (section)->relocs == NULL) 2949 free (internal_relocs); 2950 goto error_ret_free_local; 2951 } 2952 2953 /* Only look for stubs on call instructions. */ 2954 if (r_type != (unsigned int) R_PARISC_PCREL12F 2955 && r_type != (unsigned int) R_PARISC_PCREL17F 2956 && r_type != (unsigned int) R_PARISC_PCREL22F) 2957 continue; 2958 2959 /* Now determine the call target, its name, value, 2960 section. */ 2961 sym_sec = NULL; 2962 sym_value = 0; 2963 destination = 0; 2964 hh = NULL; 2965 if (r_indx < symtab_hdr->sh_info) 2966 { 2967 /* It's a local symbol. */ 2968 Elf_Internal_Sym *sym; 2969 Elf_Internal_Shdr *hdr; 2970 unsigned int shndx; 2971 2972 sym = local_syms + r_indx; 2973 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION) 2974 sym_value = sym->st_value; 2975 shndx = sym->st_shndx; 2976 if (shndx < elf_numsections (input_bfd)) 2977 { 2978 hdr = elf_elfsections (input_bfd)[shndx]; 2979 sym_sec = hdr->bfd_section; 2980 destination = (sym_value + irela->r_addend 2981 + sym_sec->output_offset 2982 + sym_sec->output_section->vma); 2983 } 2984 } 2985 else 2986 { 2987 /* It's an external symbol. */ 2988 int e_indx; 2989 2990 e_indx = r_indx - symtab_hdr->sh_info; 2991 hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]); 2992 2993 while (hh->eh.root.type == bfd_link_hash_indirect 2994 || hh->eh.root.type == bfd_link_hash_warning) 2995 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link); 2996 2997 if (hh->eh.root.type == bfd_link_hash_defined 2998 || hh->eh.root.type == bfd_link_hash_defweak) 2999 { 3000 sym_sec = hh->eh.root.u.def.section; 3001 sym_value = hh->eh.root.u.def.value; 3002 if (sym_sec->output_section != NULL) 3003 destination = (sym_value + irela->r_addend 3004 + sym_sec->output_offset 3005 + sym_sec->output_section->vma); 3006 } 3007 else if (hh->eh.root.type == bfd_link_hash_undefweak) 3008 { 3009 if (! info->shared) 3010 continue; 3011 } 3012 else if (hh->eh.root.type == bfd_link_hash_undefined) 3013 { 3014 if (! (info->unresolved_syms_in_objects == RM_IGNORE 3015 && (ELF_ST_VISIBILITY (hh->eh.other) 3016 == STV_DEFAULT) 3017 && hh->eh.type != STT_PARISC_MILLI)) 3018 continue; 3019 } 3020 else 3021 { 3022 bfd_set_error (bfd_error_bad_value); 3023 goto error_ret_free_internal; 3024 } 3025 } 3026 3027 /* Determine what (if any) linker stub is needed. */ 3028 stub_type = hppa_type_of_stub (section, irela, hh, 3029 destination, info); 3030 if (stub_type == hppa_stub_none) 3031 continue; 3032 3033 /* Support for grouping stub sections. */ 3034 id_sec = htab->stub_group[section->id].link_sec; 3035 3036 /* Get the name of this stub. */ 3037 stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela); 3038 if (!stub_name) 3039 goto error_ret_free_internal; 3040 3041 hsh = hppa_stub_hash_lookup (&htab->bstab, 3042 stub_name, 3043 FALSE, FALSE); 3044 if (hsh != NULL) 3045 { 3046 /* The proper stub has already been created. */ 3047 free (stub_name); 3048 continue; 3049 } 3050 3051 hsh = hppa_add_stub (stub_name, section, htab); 3052 if (hsh == NULL) 3053 { 3054 free (stub_name); 3055 goto error_ret_free_internal; 3056 } 3057 3058 hsh->target_value = sym_value; 3059 hsh->target_section = sym_sec; 3060 hsh->stub_type = stub_type; 3061 if (info->shared) 3062 { 3063 if (stub_type == hppa_stub_import) 3064 hsh->stub_type = hppa_stub_import_shared; 3065 else if (stub_type == hppa_stub_long_branch) 3066 hsh->stub_type = hppa_stub_long_branch_shared; 3067 } 3068 hsh->hh = hh; 3069 stub_changed = TRUE; 3070 } 3071 3072 /* We're done with the internal relocs, free them. */ 3073 if (elf_section_data (section)->relocs == NULL) 3074 free (internal_relocs); 3075 } 3076 } 3077 3078 if (!stub_changed) 3079 break; 3080 3081 /* OK, we've added some stubs. Find out the new size of the 3082 stub sections. */ 3083 for (stub_sec = htab->stub_bfd->sections; 3084 stub_sec != NULL; 3085 stub_sec = stub_sec->next) 3086 stub_sec->size = 0; 3087 3088 bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab); 3089 3090 /* Ask the linker to do its stuff. */ 3091 (*htab->layout_sections_again) (); 3092 stub_changed = FALSE; 3093 } 3094 3095 free (htab->all_local_syms); 3096 return TRUE; 3097 3098 error_ret_free_local: 3099 free (htab->all_local_syms); 3100 return FALSE; 3101 } 3102 3103 /* For a final link, this function is called after we have sized the 3104 stubs to provide a value for __gp. */ 3105 3106 bfd_boolean 3107 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info) 3108 { 3109 struct bfd_link_hash_entry *h; 3110 asection *sec = NULL; 3111 bfd_vma gp_val = 0; 3112 struct elf32_hppa_link_hash_table *htab; 3113 3114 htab = hppa_link_hash_table (info); 3115 if (htab == NULL) 3116 return FALSE; 3117 3118 h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE); 3119 3120 if (h != NULL 3121 && (h->type == bfd_link_hash_defined 3122 || h->type == bfd_link_hash_defweak)) 3123 { 3124 gp_val = h->u.def.value; 3125 sec = h->u.def.section; 3126 } 3127 else 3128 { 3129 asection *splt = bfd_get_section_by_name (abfd, ".plt"); 3130 asection *sgot = bfd_get_section_by_name (abfd, ".got"); 3131 3132 /* Choose to point our LTP at, in this order, one of .plt, .got, 3133 or .data, if these sections exist. In the case of choosing 3134 .plt try to make the LTP ideal for addressing anywhere in the 3135 .plt or .got with a 14 bit signed offset. Typically, the end 3136 of the .plt is the start of the .got, so choose .plt + 0x2000 3137 if either the .plt or .got is larger than 0x2000. If both 3138 the .plt and .got are smaller than 0x2000, choose the end of 3139 the .plt section. */ 3140 sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0 3141 ? NULL : splt; 3142 if (sec != NULL) 3143 { 3144 gp_val = sec->size; 3145 if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000)) 3146 { 3147 gp_val = 0x2000; 3148 } 3149 } 3150 else 3151 { 3152 sec = sgot; 3153 if (sec != NULL) 3154 { 3155 if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0) 3156 { 3157 /* We know we don't have a .plt. If .got is large, 3158 offset our LTP. */ 3159 if (sec->size > 0x2000) 3160 gp_val = 0x2000; 3161 } 3162 } 3163 else 3164 { 3165 /* No .plt or .got. Who cares what the LTP is? */ 3166 sec = bfd_get_section_by_name (abfd, ".data"); 3167 } 3168 } 3169 3170 if (h != NULL) 3171 { 3172 h->type = bfd_link_hash_defined; 3173 h->u.def.value = gp_val; 3174 if (sec != NULL) 3175 h->u.def.section = sec; 3176 else 3177 h->u.def.section = bfd_abs_section_ptr; 3178 } 3179 } 3180 3181 if (sec != NULL && sec->output_section != NULL) 3182 gp_val += sec->output_section->vma + sec->output_offset; 3183 3184 elf_gp (abfd) = gp_val; 3185 return TRUE; 3186 } 3187 3188 /* Build all the stubs associated with the current output file. The 3189 stubs are kept in a hash table attached to the main linker hash 3190 table. We also set up the .plt entries for statically linked PIC 3191 functions here. This function is called via hppaelf_finish in the 3192 linker. */ 3193 3194 bfd_boolean 3195 elf32_hppa_build_stubs (struct bfd_link_info *info) 3196 { 3197 asection *stub_sec; 3198 struct bfd_hash_table *table; 3199 struct elf32_hppa_link_hash_table *htab; 3200 3201 htab = hppa_link_hash_table (info); 3202 if (htab == NULL) 3203 return FALSE; 3204 3205 for (stub_sec = htab->stub_bfd->sections; 3206 stub_sec != NULL; 3207 stub_sec = stub_sec->next) 3208 { 3209 bfd_size_type size; 3210 3211 /* Allocate memory to hold the linker stubs. */ 3212 size = stub_sec->size; 3213 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size); 3214 if (stub_sec->contents == NULL && size != 0) 3215 return FALSE; 3216 stub_sec->size = 0; 3217 } 3218 3219 /* Build the stubs as directed by the stub hash table. */ 3220 table = &htab->bstab; 3221 bfd_hash_traverse (table, hppa_build_one_stub, info); 3222 3223 return TRUE; 3224 } 3225 3226 /* Return the base vma address which should be subtracted from the real 3227 address when resolving a dtpoff relocation. 3228 This is PT_TLS segment p_vaddr. */ 3229 3230 static bfd_vma 3231 dtpoff_base (struct bfd_link_info *info) 3232 { 3233 /* If tls_sec is NULL, we should have signalled an error already. */ 3234 if (elf_hash_table (info)->tls_sec == NULL) 3235 return 0; 3236 return elf_hash_table (info)->tls_sec->vma; 3237 } 3238 3239 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */ 3240 3241 static bfd_vma 3242 tpoff (struct bfd_link_info *info, bfd_vma address) 3243 { 3244 struct elf_link_hash_table *htab = elf_hash_table (info); 3245 3246 /* If tls_sec is NULL, we should have signalled an error already. */ 3247 if (htab->tls_sec == NULL) 3248 return 0; 3249 /* hppa TLS ABI is variant I and static TLS block start just after 3250 tcbhead structure which has 2 pointer fields. */ 3251 return (address - htab->tls_sec->vma 3252 + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power)); 3253 } 3254 3255 /* Perform a final link. */ 3256 3257 static bfd_boolean 3258 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info) 3259 { 3260 /* Invoke the regular ELF linker to do all the work. */ 3261 if (!bfd_elf_final_link (abfd, info)) 3262 return FALSE; 3263 3264 /* If we're producing a final executable, sort the contents of the 3265 unwind section. */ 3266 if (info->relocatable) 3267 return TRUE; 3268 3269 return elf_hppa_sort_unwind (abfd); 3270 } 3271 3272 /* Record the lowest address for the data and text segments. */ 3273 3274 static void 3275 hppa_record_segment_addr (bfd *abfd, asection *section, void *data) 3276 { 3277 struct elf32_hppa_link_hash_table *htab; 3278 3279 htab = (struct elf32_hppa_link_hash_table*) data; 3280 if (htab == NULL) 3281 return; 3282 3283 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3284 { 3285 bfd_vma value; 3286 Elf_Internal_Phdr *p; 3287 3288 p = _bfd_elf_find_segment_containing_section (abfd, section->output_section); 3289 BFD_ASSERT (p != NULL); 3290 value = p->p_vaddr; 3291 3292 if ((section->flags & SEC_READONLY) != 0) 3293 { 3294 if (value < htab->text_segment_base) 3295 htab->text_segment_base = value; 3296 } 3297 else 3298 { 3299 if (value < htab->data_segment_base) 3300 htab->data_segment_base = value; 3301 } 3302 } 3303 } 3304 3305 /* Perform a relocation as part of a final link. */ 3306 3307 static bfd_reloc_status_type 3308 final_link_relocate (asection *input_section, 3309 bfd_byte *contents, 3310 const Elf_Internal_Rela *rela, 3311 bfd_vma value, 3312 struct elf32_hppa_link_hash_table *htab, 3313 asection *sym_sec, 3314 struct elf32_hppa_link_hash_entry *hh, 3315 struct bfd_link_info *info) 3316 { 3317 int insn; 3318 unsigned int r_type = ELF32_R_TYPE (rela->r_info); 3319 unsigned int orig_r_type = r_type; 3320 reloc_howto_type *howto = elf_hppa_howto_table + r_type; 3321 int r_format = howto->bitsize; 3322 enum hppa_reloc_field_selector_type_alt r_field; 3323 bfd *input_bfd = input_section->owner; 3324 bfd_vma offset = rela->r_offset; 3325 bfd_vma max_branch_offset = 0; 3326 bfd_byte *hit_data = contents + offset; 3327 bfd_signed_vma addend = rela->r_addend; 3328 bfd_vma location; 3329 struct elf32_hppa_stub_hash_entry *hsh = NULL; 3330 int val; 3331 3332 if (r_type == R_PARISC_NONE) 3333 return bfd_reloc_ok; 3334 3335 insn = bfd_get_32 (input_bfd, hit_data); 3336 3337 /* Find out where we are and where we're going. */ 3338 location = (offset + 3339 input_section->output_offset + 3340 input_section->output_section->vma); 3341 3342 /* If we are not building a shared library, convert DLTIND relocs to 3343 DPREL relocs. */ 3344 if (!info->shared) 3345 { 3346 switch (r_type) 3347 { 3348 case R_PARISC_DLTIND21L: 3349 case R_PARISC_TLS_GD21L: 3350 case R_PARISC_TLS_LDM21L: 3351 case R_PARISC_TLS_IE21L: 3352 r_type = R_PARISC_DPREL21L; 3353 break; 3354 3355 case R_PARISC_DLTIND14R: 3356 case R_PARISC_TLS_GD14R: 3357 case R_PARISC_TLS_LDM14R: 3358 case R_PARISC_TLS_IE14R: 3359 r_type = R_PARISC_DPREL14R; 3360 break; 3361 3362 case R_PARISC_DLTIND14F: 3363 r_type = R_PARISC_DPREL14F; 3364 break; 3365 } 3366 } 3367 3368 switch (r_type) 3369 { 3370 case R_PARISC_PCREL12F: 3371 case R_PARISC_PCREL17F: 3372 case R_PARISC_PCREL22F: 3373 /* If this call should go via the plt, find the import stub in 3374 the stub hash. */ 3375 if (sym_sec == NULL 3376 || sym_sec->output_section == NULL 3377 || (hh != NULL 3378 && hh->eh.plt.offset != (bfd_vma) -1 3379 && hh->eh.dynindx != -1 3380 && !hh->plabel 3381 && (info->shared 3382 || !hh->eh.def_regular 3383 || hh->eh.root.type == bfd_link_hash_defweak))) 3384 { 3385 hsh = hppa_get_stub_entry (input_section, sym_sec, 3386 hh, rela, htab); 3387 if (hsh != NULL) 3388 { 3389 value = (hsh->stub_offset 3390 + hsh->stub_sec->output_offset 3391 + hsh->stub_sec->output_section->vma); 3392 addend = 0; 3393 } 3394 else if (sym_sec == NULL && hh != NULL 3395 && hh->eh.root.type == bfd_link_hash_undefweak) 3396 { 3397 /* It's OK if undefined weak. Calls to undefined weak 3398 symbols behave as if the "called" function 3399 immediately returns. We can thus call to a weak 3400 function without first checking whether the function 3401 is defined. */ 3402 value = location; 3403 addend = 8; 3404 } 3405 else 3406 return bfd_reloc_undefined; 3407 } 3408 /* Fall thru. */ 3409 3410 case R_PARISC_PCREL21L: 3411 case R_PARISC_PCREL17C: 3412 case R_PARISC_PCREL17R: 3413 case R_PARISC_PCREL14R: 3414 case R_PARISC_PCREL14F: 3415 case R_PARISC_PCREL32: 3416 /* Make it a pc relative offset. */ 3417 value -= location; 3418 addend -= 8; 3419 break; 3420 3421 case R_PARISC_DPREL21L: 3422 case R_PARISC_DPREL14R: 3423 case R_PARISC_DPREL14F: 3424 /* Convert instructions that use the linkage table pointer (r19) to 3425 instructions that use the global data pointer (dp). This is the 3426 most efficient way of using PIC code in an incomplete executable, 3427 but the user must follow the standard runtime conventions for 3428 accessing data for this to work. */ 3429 if (orig_r_type != r_type) 3430 { 3431 if (r_type == R_PARISC_DPREL21L) 3432 { 3433 /* GCC sometimes uses a register other than r19 for the 3434 operation, so we must convert any addil instruction 3435 that uses this relocation. */ 3436 if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26)) 3437 insn = ADDIL_DP; 3438 else 3439 /* We must have a ldil instruction. It's too hard to find 3440 and convert the associated add instruction, so issue an 3441 error. */ 3442 (*_bfd_error_handler) 3443 (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"), 3444 input_bfd, 3445 input_section, 3446 (long) offset, 3447 howto->name, 3448 insn); 3449 } 3450 else if (r_type == R_PARISC_DPREL14F) 3451 { 3452 /* This must be a format 1 load/store. Change the base 3453 register to dp. */ 3454 insn = (insn & 0xfc1ffff) | (27 << 21); 3455 } 3456 } 3457 3458 /* For all the DP relative relocations, we need to examine the symbol's 3459 section. If it has no section or if it's a code section, then 3460 "data pointer relative" makes no sense. In that case we don't 3461 adjust the "value", and for 21 bit addil instructions, we change the 3462 source addend register from %dp to %r0. This situation commonly 3463 arises for undefined weak symbols and when a variable's "constness" 3464 is declared differently from the way the variable is defined. For 3465 instance: "extern int foo" with foo defined as "const int foo". */ 3466 if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0) 3467 { 3468 if ((insn & ((0x3f << 26) | (0x1f << 21))) 3469 == (((int) OP_ADDIL << 26) | (27 << 21))) 3470 { 3471 insn &= ~ (0x1f << 21); 3472 } 3473 /* Now try to make things easy for the dynamic linker. */ 3474 3475 break; 3476 } 3477 /* Fall thru. */ 3478 3479 case R_PARISC_DLTIND21L: 3480 case R_PARISC_DLTIND14R: 3481 case R_PARISC_DLTIND14F: 3482 case R_PARISC_TLS_GD21L: 3483 case R_PARISC_TLS_LDM21L: 3484 case R_PARISC_TLS_IE21L: 3485 case R_PARISC_TLS_GD14R: 3486 case R_PARISC_TLS_LDM14R: 3487 case R_PARISC_TLS_IE14R: 3488 value -= elf_gp (input_section->output_section->owner); 3489 break; 3490 3491 case R_PARISC_SEGREL32: 3492 if ((sym_sec->flags & SEC_CODE) != 0) 3493 value -= htab->text_segment_base; 3494 else 3495 value -= htab->data_segment_base; 3496 break; 3497 3498 default: 3499 break; 3500 } 3501 3502 switch (r_type) 3503 { 3504 case R_PARISC_DIR32: 3505 case R_PARISC_DIR14F: 3506 case R_PARISC_DIR17F: 3507 case R_PARISC_PCREL17C: 3508 case R_PARISC_PCREL14F: 3509 case R_PARISC_PCREL32: 3510 case R_PARISC_DPREL14F: 3511 case R_PARISC_PLABEL32: 3512 case R_PARISC_DLTIND14F: 3513 case R_PARISC_SEGBASE: 3514 case R_PARISC_SEGREL32: 3515 case R_PARISC_TLS_DTPMOD32: 3516 case R_PARISC_TLS_DTPOFF32: 3517 case R_PARISC_TLS_TPREL32: 3518 r_field = e_fsel; 3519 break; 3520 3521 case R_PARISC_DLTIND21L: 3522 case R_PARISC_PCREL21L: 3523 case R_PARISC_PLABEL21L: 3524 r_field = e_lsel; 3525 break; 3526 3527 case R_PARISC_DIR21L: 3528 case R_PARISC_DPREL21L: 3529 case R_PARISC_TLS_GD21L: 3530 case R_PARISC_TLS_LDM21L: 3531 case R_PARISC_TLS_LDO21L: 3532 case R_PARISC_TLS_IE21L: 3533 case R_PARISC_TLS_LE21L: 3534 r_field = e_lrsel; 3535 break; 3536 3537 case R_PARISC_PCREL17R: 3538 case R_PARISC_PCREL14R: 3539 case R_PARISC_PLABEL14R: 3540 case R_PARISC_DLTIND14R: 3541 r_field = e_rsel; 3542 break; 3543 3544 case R_PARISC_DIR17R: 3545 case R_PARISC_DIR14R: 3546 case R_PARISC_DPREL14R: 3547 case R_PARISC_TLS_GD14R: 3548 case R_PARISC_TLS_LDM14R: 3549 case R_PARISC_TLS_LDO14R: 3550 case R_PARISC_TLS_IE14R: 3551 case R_PARISC_TLS_LE14R: 3552 r_field = e_rrsel; 3553 break; 3554 3555 case R_PARISC_PCREL12F: 3556 case R_PARISC_PCREL17F: 3557 case R_PARISC_PCREL22F: 3558 r_field = e_fsel; 3559 3560 if (r_type == (unsigned int) R_PARISC_PCREL17F) 3561 { 3562 max_branch_offset = (1 << (17-1)) << 2; 3563 } 3564 else if (r_type == (unsigned int) R_PARISC_PCREL12F) 3565 { 3566 max_branch_offset = (1 << (12-1)) << 2; 3567 } 3568 else 3569 { 3570 max_branch_offset = (1 << (22-1)) << 2; 3571 } 3572 3573 /* sym_sec is NULL on undefined weak syms or when shared on 3574 undefined syms. We've already checked for a stub for the 3575 shared undefined case. */ 3576 if (sym_sec == NULL) 3577 break; 3578 3579 /* If the branch is out of reach, then redirect the 3580 call to the local stub for this function. */ 3581 if (value + addend + max_branch_offset >= 2*max_branch_offset) 3582 { 3583 hsh = hppa_get_stub_entry (input_section, sym_sec, 3584 hh, rela, htab); 3585 if (hsh == NULL) 3586 return bfd_reloc_undefined; 3587 3588 /* Munge up the value and addend so that we call the stub 3589 rather than the procedure directly. */ 3590 value = (hsh->stub_offset 3591 + hsh->stub_sec->output_offset 3592 + hsh->stub_sec->output_section->vma 3593 - location); 3594 addend = -8; 3595 } 3596 break; 3597 3598 /* Something we don't know how to handle. */ 3599 default: 3600 return bfd_reloc_notsupported; 3601 } 3602 3603 /* Make sure we can reach the stub. */ 3604 if (max_branch_offset != 0 3605 && value + addend + max_branch_offset >= 2*max_branch_offset) 3606 { 3607 (*_bfd_error_handler) 3608 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"), 3609 input_bfd, 3610 input_section, 3611 (long) offset, 3612 hsh->bh_root.string); 3613 bfd_set_error (bfd_error_bad_value); 3614 return bfd_reloc_notsupported; 3615 } 3616 3617 val = hppa_field_adjust (value, addend, r_field); 3618 3619 switch (r_type) 3620 { 3621 case R_PARISC_PCREL12F: 3622 case R_PARISC_PCREL17C: 3623 case R_PARISC_PCREL17F: 3624 case R_PARISC_PCREL17R: 3625 case R_PARISC_PCREL22F: 3626 case R_PARISC_DIR17F: 3627 case R_PARISC_DIR17R: 3628 /* This is a branch. Divide the offset by four. 3629 Note that we need to decide whether it's a branch or 3630 otherwise by inspecting the reloc. Inspecting insn won't 3631 work as insn might be from a .word directive. */ 3632 val >>= 2; 3633 break; 3634 3635 default: 3636 break; 3637 } 3638 3639 insn = hppa_rebuild_insn (insn, val, r_format); 3640 3641 /* Update the instruction word. */ 3642 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data); 3643 return bfd_reloc_ok; 3644 } 3645 3646 /* Relocate an HPPA ELF section. */ 3647 3648 static bfd_boolean 3649 elf32_hppa_relocate_section (bfd *output_bfd, 3650 struct bfd_link_info *info, 3651 bfd *input_bfd, 3652 asection *input_section, 3653 bfd_byte *contents, 3654 Elf_Internal_Rela *relocs, 3655 Elf_Internal_Sym *local_syms, 3656 asection **local_sections) 3657 { 3658 bfd_vma *local_got_offsets; 3659 struct elf32_hppa_link_hash_table *htab; 3660 Elf_Internal_Shdr *symtab_hdr; 3661 Elf_Internal_Rela *rela; 3662 Elf_Internal_Rela *relend; 3663 3664 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3665 3666 htab = hppa_link_hash_table (info); 3667 if (htab == NULL) 3668 return FALSE; 3669 3670 local_got_offsets = elf_local_got_offsets (input_bfd); 3671 3672 rela = relocs; 3673 relend = relocs + input_section->reloc_count; 3674 for (; rela < relend; rela++) 3675 { 3676 unsigned int r_type; 3677 reloc_howto_type *howto; 3678 unsigned int r_symndx; 3679 struct elf32_hppa_link_hash_entry *hh; 3680 Elf_Internal_Sym *sym; 3681 asection *sym_sec; 3682 bfd_vma relocation; 3683 bfd_reloc_status_type rstatus; 3684 const char *sym_name; 3685 bfd_boolean plabel; 3686 bfd_boolean warned_undef; 3687 3688 r_type = ELF32_R_TYPE (rela->r_info); 3689 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED) 3690 { 3691 bfd_set_error (bfd_error_bad_value); 3692 return FALSE; 3693 } 3694 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY 3695 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT) 3696 continue; 3697 3698 r_symndx = ELF32_R_SYM (rela->r_info); 3699 hh = NULL; 3700 sym = NULL; 3701 sym_sec = NULL; 3702 warned_undef = FALSE; 3703 if (r_symndx < symtab_hdr->sh_info) 3704 { 3705 /* This is a local symbol, h defaults to NULL. */ 3706 sym = local_syms + r_symndx; 3707 sym_sec = local_sections[r_symndx]; 3708 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela); 3709 } 3710 else 3711 { 3712 struct elf_link_hash_entry *eh; 3713 bfd_boolean unresolved_reloc; 3714 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 3715 3716 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela, 3717 r_symndx, symtab_hdr, sym_hashes, 3718 eh, sym_sec, relocation, 3719 unresolved_reloc, warned_undef); 3720 3721 if (!info->relocatable 3722 && relocation == 0 3723 && eh->root.type != bfd_link_hash_defined 3724 && eh->root.type != bfd_link_hash_defweak 3725 && eh->root.type != bfd_link_hash_undefweak) 3726 { 3727 if (info->unresolved_syms_in_objects == RM_IGNORE 3728 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT 3729 && eh->type == STT_PARISC_MILLI) 3730 { 3731 if (! info->callbacks->undefined_symbol 3732 (info, eh_name (eh), input_bfd, 3733 input_section, rela->r_offset, FALSE)) 3734 return FALSE; 3735 warned_undef = TRUE; 3736 } 3737 } 3738 hh = hppa_elf_hash_entry (eh); 3739 } 3740 3741 if (sym_sec != NULL && discarded_section (sym_sec)) 3742 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3743 rela, 1, relend, 3744 elf_hppa_howto_table + r_type, 0, 3745 contents); 3746 3747 if (info->relocatable) 3748 continue; 3749 3750 /* Do any required modifications to the relocation value, and 3751 determine what types of dynamic info we need to output, if 3752 any. */ 3753 plabel = 0; 3754 switch (r_type) 3755 { 3756 case R_PARISC_DLTIND14F: 3757 case R_PARISC_DLTIND14R: 3758 case R_PARISC_DLTIND21L: 3759 { 3760 bfd_vma off; 3761 bfd_boolean do_got = 0; 3762 3763 /* Relocation is to the entry for this symbol in the 3764 global offset table. */ 3765 if (hh != NULL) 3766 { 3767 bfd_boolean dyn; 3768 3769 off = hh->eh.got.offset; 3770 dyn = htab->etab.dynamic_sections_created; 3771 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, 3772 &hh->eh)) 3773 { 3774 /* If we aren't going to call finish_dynamic_symbol, 3775 then we need to handle initialisation of the .got 3776 entry and create needed relocs here. Since the 3777 offset must always be a multiple of 4, we use the 3778 least significant bit to record whether we have 3779 initialised it already. */ 3780 if ((off & 1) != 0) 3781 off &= ~1; 3782 else 3783 { 3784 hh->eh.got.offset |= 1; 3785 do_got = 1; 3786 } 3787 } 3788 } 3789 else 3790 { 3791 /* Local symbol case. */ 3792 if (local_got_offsets == NULL) 3793 abort (); 3794 3795 off = local_got_offsets[r_symndx]; 3796 3797 /* The offset must always be a multiple of 4. We use 3798 the least significant bit to record whether we have 3799 already generated the necessary reloc. */ 3800 if ((off & 1) != 0) 3801 off &= ~1; 3802 else 3803 { 3804 local_got_offsets[r_symndx] |= 1; 3805 do_got = 1; 3806 } 3807 } 3808 3809 if (do_got) 3810 { 3811 if (info->shared) 3812 { 3813 /* Output a dynamic relocation for this GOT entry. 3814 In this case it is relative to the base of the 3815 object because the symbol index is zero. */ 3816 Elf_Internal_Rela outrel; 3817 bfd_byte *loc; 3818 asection *sec = htab->srelgot; 3819 3820 outrel.r_offset = (off 3821 + htab->sgot->output_offset 3822 + htab->sgot->output_section->vma); 3823 outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32); 3824 outrel.r_addend = relocation; 3825 loc = sec->contents; 3826 loc += sec->reloc_count++ * sizeof (Elf32_External_Rela); 3827 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 3828 } 3829 else 3830 bfd_put_32 (output_bfd, relocation, 3831 htab->sgot->contents + off); 3832 } 3833 3834 if (off >= (bfd_vma) -2) 3835 abort (); 3836 3837 /* Add the base of the GOT to the relocation value. */ 3838 relocation = (off 3839 + htab->sgot->output_offset 3840 + htab->sgot->output_section->vma); 3841 } 3842 break; 3843 3844 case R_PARISC_SEGREL32: 3845 /* If this is the first SEGREL relocation, then initialize 3846 the segment base values. */ 3847 if (htab->text_segment_base == (bfd_vma) -1) 3848 bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab); 3849 break; 3850 3851 case R_PARISC_PLABEL14R: 3852 case R_PARISC_PLABEL21L: 3853 case R_PARISC_PLABEL32: 3854 if (htab->etab.dynamic_sections_created) 3855 { 3856 bfd_vma off; 3857 bfd_boolean do_plt = 0; 3858 /* If we have a global symbol with a PLT slot, then 3859 redirect this relocation to it. */ 3860 if (hh != NULL) 3861 { 3862 off = hh->eh.plt.offset; 3863 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, 3864 &hh->eh)) 3865 { 3866 /* In a non-shared link, adjust_dynamic_symbols 3867 isn't called for symbols forced local. We 3868 need to write out the plt entry here. */ 3869 if ((off & 1) != 0) 3870 off &= ~1; 3871 else 3872 { 3873 hh->eh.plt.offset |= 1; 3874 do_plt = 1; 3875 } 3876 } 3877 } 3878 else 3879 { 3880 bfd_vma *local_plt_offsets; 3881 3882 if (local_got_offsets == NULL) 3883 abort (); 3884 3885 local_plt_offsets = local_got_offsets + symtab_hdr->sh_info; 3886 off = local_plt_offsets[r_symndx]; 3887 3888 /* As for the local .got entry case, we use the last 3889 bit to record whether we've already initialised 3890 this local .plt entry. */ 3891 if ((off & 1) != 0) 3892 off &= ~1; 3893 else 3894 { 3895 local_plt_offsets[r_symndx] |= 1; 3896 do_plt = 1; 3897 } 3898 } 3899 3900 if (do_plt) 3901 { 3902 if (info->shared) 3903 { 3904 /* Output a dynamic IPLT relocation for this 3905 PLT entry. */ 3906 Elf_Internal_Rela outrel; 3907 bfd_byte *loc; 3908 asection *s = htab->srelplt; 3909 3910 outrel.r_offset = (off 3911 + htab->splt->output_offset 3912 + htab->splt->output_section->vma); 3913 outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT); 3914 outrel.r_addend = relocation; 3915 loc = s->contents; 3916 loc += s->reloc_count++ * sizeof (Elf32_External_Rela); 3917 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 3918 } 3919 else 3920 { 3921 bfd_put_32 (output_bfd, 3922 relocation, 3923 htab->splt->contents + off); 3924 bfd_put_32 (output_bfd, 3925 elf_gp (htab->splt->output_section->owner), 3926 htab->splt->contents + off + 4); 3927 } 3928 } 3929 3930 if (off >= (bfd_vma) -2) 3931 abort (); 3932 3933 /* PLABELs contain function pointers. Relocation is to 3934 the entry for the function in the .plt. The magic +2 3935 offset signals to $$dyncall that the function pointer 3936 is in the .plt and thus has a gp pointer too. 3937 Exception: Undefined PLABELs should have a value of 3938 zero. */ 3939 if (hh == NULL 3940 || (hh->eh.root.type != bfd_link_hash_undefweak 3941 && hh->eh.root.type != bfd_link_hash_undefined)) 3942 { 3943 relocation = (off 3944 + htab->splt->output_offset 3945 + htab->splt->output_section->vma 3946 + 2); 3947 } 3948 plabel = 1; 3949 } 3950 /* Fall through and possibly emit a dynamic relocation. */ 3951 3952 case R_PARISC_DIR17F: 3953 case R_PARISC_DIR17R: 3954 case R_PARISC_DIR14F: 3955 case R_PARISC_DIR14R: 3956 case R_PARISC_DIR21L: 3957 case R_PARISC_DPREL14F: 3958 case R_PARISC_DPREL14R: 3959 case R_PARISC_DPREL21L: 3960 case R_PARISC_DIR32: 3961 if ((input_section->flags & SEC_ALLOC) == 0) 3962 break; 3963 3964 /* The reloc types handled here and this conditional 3965 expression must match the code in ..check_relocs and 3966 allocate_dynrelocs. ie. We need exactly the same condition 3967 as in ..check_relocs, with some extra conditions (dynindx 3968 test in this case) to cater for relocs removed by 3969 allocate_dynrelocs. If you squint, the non-shared test 3970 here does indeed match the one in ..check_relocs, the 3971 difference being that here we test DEF_DYNAMIC as well as 3972 !DEF_REGULAR. All common syms end up with !DEF_REGULAR, 3973 which is why we can't use just that test here. 3974 Conversely, DEF_DYNAMIC can't be used in check_relocs as 3975 there all files have not been loaded. */ 3976 if ((info->shared 3977 && (hh == NULL 3978 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT 3979 || hh->eh.root.type != bfd_link_hash_undefweak) 3980 && (IS_ABSOLUTE_RELOC (r_type) 3981 || !SYMBOL_CALLS_LOCAL (info, &hh->eh))) 3982 || (!info->shared 3983 && hh != NULL 3984 && hh->eh.dynindx != -1 3985 && !hh->eh.non_got_ref 3986 && ((ELIMINATE_COPY_RELOCS 3987 && hh->eh.def_dynamic 3988 && !hh->eh.def_regular) 3989 || hh->eh.root.type == bfd_link_hash_undefweak 3990 || hh->eh.root.type == bfd_link_hash_undefined))) 3991 { 3992 Elf_Internal_Rela outrel; 3993 bfd_boolean skip; 3994 asection *sreloc; 3995 bfd_byte *loc; 3996 3997 /* When generating a shared object, these relocations 3998 are copied into the output file to be resolved at run 3999 time. */ 4000 4001 outrel.r_addend = rela->r_addend; 4002 outrel.r_offset = 4003 _bfd_elf_section_offset (output_bfd, info, input_section, 4004 rela->r_offset); 4005 skip = (outrel.r_offset == (bfd_vma) -1 4006 || outrel.r_offset == (bfd_vma) -2); 4007 outrel.r_offset += (input_section->output_offset 4008 + input_section->output_section->vma); 4009 4010 if (skip) 4011 { 4012 memset (&outrel, 0, sizeof (outrel)); 4013 } 4014 else if (hh != NULL 4015 && hh->eh.dynindx != -1 4016 && (plabel 4017 || !IS_ABSOLUTE_RELOC (r_type) 4018 || !info->shared 4019 || !info->symbolic 4020 || !hh->eh.def_regular)) 4021 { 4022 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type); 4023 } 4024 else /* It's a local symbol, or one marked to become local. */ 4025 { 4026 int indx = 0; 4027 4028 /* Add the absolute offset of the symbol. */ 4029 outrel.r_addend += relocation; 4030 4031 /* Global plabels need to be processed by the 4032 dynamic linker so that functions have at most one 4033 fptr. For this reason, we need to differentiate 4034 between global and local plabels, which we do by 4035 providing the function symbol for a global plabel 4036 reloc, and no symbol for local plabels. */ 4037 if (! plabel 4038 && sym_sec != NULL 4039 && sym_sec->output_section != NULL 4040 && ! bfd_is_abs_section (sym_sec)) 4041 { 4042 asection *osec; 4043 4044 osec = sym_sec->output_section; 4045 indx = elf_section_data (osec)->dynindx; 4046 if (indx == 0) 4047 { 4048 osec = htab->etab.text_index_section; 4049 indx = elf_section_data (osec)->dynindx; 4050 } 4051 BFD_ASSERT (indx != 0); 4052 4053 /* We are turning this relocation into one 4054 against a section symbol, so subtract out the 4055 output section's address but not the offset 4056 of the input section in the output section. */ 4057 outrel.r_addend -= osec->vma; 4058 } 4059 4060 outrel.r_info = ELF32_R_INFO (indx, r_type); 4061 } 4062 sreloc = elf_section_data (input_section)->sreloc; 4063 if (sreloc == NULL) 4064 abort (); 4065 4066 loc = sreloc->contents; 4067 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 4068 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4069 } 4070 break; 4071 4072 case R_PARISC_TLS_LDM21L: 4073 case R_PARISC_TLS_LDM14R: 4074 { 4075 bfd_vma off; 4076 4077 off = htab->tls_ldm_got.offset; 4078 if (off & 1) 4079 off &= ~1; 4080 else 4081 { 4082 Elf_Internal_Rela outrel; 4083 bfd_byte *loc; 4084 4085 outrel.r_offset = (off 4086 + htab->sgot->output_section->vma 4087 + htab->sgot->output_offset); 4088 outrel.r_addend = 0; 4089 outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32); 4090 loc = htab->srelgot->contents; 4091 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4092 4093 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4094 htab->tls_ldm_got.offset |= 1; 4095 } 4096 4097 /* Add the base of the GOT to the relocation value. */ 4098 relocation = (off 4099 + htab->sgot->output_offset 4100 + htab->sgot->output_section->vma); 4101 4102 break; 4103 } 4104 4105 case R_PARISC_TLS_LDO21L: 4106 case R_PARISC_TLS_LDO14R: 4107 relocation -= dtpoff_base (info); 4108 break; 4109 4110 case R_PARISC_TLS_GD21L: 4111 case R_PARISC_TLS_GD14R: 4112 case R_PARISC_TLS_IE21L: 4113 case R_PARISC_TLS_IE14R: 4114 { 4115 bfd_vma off; 4116 int indx; 4117 char tls_type; 4118 4119 indx = 0; 4120 if (hh != NULL) 4121 { 4122 bfd_boolean dyn; 4123 dyn = htab->etab.dynamic_sections_created; 4124 4125 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &hh->eh) 4126 && (!info->shared 4127 || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))) 4128 { 4129 indx = hh->eh.dynindx; 4130 } 4131 off = hh->eh.got.offset; 4132 tls_type = hh->tls_type; 4133 } 4134 else 4135 { 4136 off = local_got_offsets[r_symndx]; 4137 tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx]; 4138 } 4139 4140 if (tls_type == GOT_UNKNOWN) 4141 abort (); 4142 4143 if ((off & 1) != 0) 4144 off &= ~1; 4145 else 4146 { 4147 bfd_boolean need_relocs = FALSE; 4148 Elf_Internal_Rela outrel; 4149 bfd_byte *loc = NULL; 4150 int cur_off = off; 4151 4152 /* The GOT entries have not been initialized yet. Do it 4153 now, and emit any relocations. If both an IE GOT and a 4154 GD GOT are necessary, we emit the GD first. */ 4155 4156 if ((info->shared || indx != 0) 4157 && (hh == NULL 4158 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT 4159 || hh->eh.root.type != bfd_link_hash_undefweak)) 4160 { 4161 need_relocs = TRUE; 4162 loc = htab->srelgot->contents; 4163 /* FIXME (CAO): Should this be reloc_count++ ? */ 4164 loc += htab->srelgot->reloc_count * sizeof (Elf32_External_Rela); 4165 } 4166 4167 if (tls_type & GOT_TLS_GD) 4168 { 4169 if (need_relocs) 4170 { 4171 outrel.r_offset = (cur_off 4172 + htab->sgot->output_section->vma 4173 + htab->sgot->output_offset); 4174 outrel.r_info = ELF32_R_INFO (indx,R_PARISC_TLS_DTPMOD32); 4175 outrel.r_addend = 0; 4176 bfd_put_32 (output_bfd, 0, htab->sgot->contents + cur_off); 4177 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4178 htab->srelgot->reloc_count++; 4179 loc += sizeof (Elf32_External_Rela); 4180 4181 if (indx == 0) 4182 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 4183 htab->sgot->contents + cur_off + 4); 4184 else 4185 { 4186 bfd_put_32 (output_bfd, 0, 4187 htab->sgot->contents + cur_off + 4); 4188 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32); 4189 outrel.r_offset += 4; 4190 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); 4191 htab->srelgot->reloc_count++; 4192 loc += sizeof (Elf32_External_Rela); 4193 } 4194 } 4195 else 4196 { 4197 /* If we are not emitting relocations for a 4198 general dynamic reference, then we must be in a 4199 static link or an executable link with the 4200 symbol binding locally. Mark it as belonging 4201 to module 1, the executable. */ 4202 bfd_put_32 (output_bfd, 1, 4203 htab->sgot->contents + cur_off); 4204 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 4205 htab->sgot->contents + cur_off + 4); 4206 } 4207 4208 4209 cur_off += 8; 4210 } 4211 4212 if (tls_type & GOT_TLS_IE) 4213 { 4214 if (need_relocs) 4215 { 4216 outrel.r_offset = (cur_off 4217 + htab->sgot->output_section->vma 4218 + htab->sgot->output_offset); 4219 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_TPREL32); 4220 4221 if (indx == 0) 4222 outrel.r_addend = relocation - dtpoff_base (info); 4223 else 4224 outrel.r_addend = 0; 4225 4226 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4227 htab->srelgot->reloc_count++; 4228 loc += sizeof (Elf32_External_Rela); 4229 } 4230 else 4231 bfd_put_32 (output_bfd, tpoff (info, relocation), 4232 htab->sgot->contents + cur_off); 4233 4234 cur_off += 4; 4235 } 4236 4237 if (hh != NULL) 4238 hh->eh.got.offset |= 1; 4239 else 4240 local_got_offsets[r_symndx] |= 1; 4241 } 4242 4243 if ((tls_type & GOT_TLS_GD) 4244 && r_type != R_PARISC_TLS_GD21L 4245 && r_type != R_PARISC_TLS_GD14R) 4246 off += 2 * GOT_ENTRY_SIZE; 4247 4248 /* Add the base of the GOT to the relocation value. */ 4249 relocation = (off 4250 + htab->sgot->output_offset 4251 + htab->sgot->output_section->vma); 4252 4253 break; 4254 } 4255 4256 case R_PARISC_TLS_LE21L: 4257 case R_PARISC_TLS_LE14R: 4258 { 4259 relocation = tpoff (info, relocation); 4260 break; 4261 } 4262 break; 4263 4264 default: 4265 break; 4266 } 4267 4268 rstatus = final_link_relocate (input_section, contents, rela, relocation, 4269 htab, sym_sec, hh, info); 4270 4271 if (rstatus == bfd_reloc_ok) 4272 continue; 4273 4274 if (hh != NULL) 4275 sym_name = hh_name (hh); 4276 else 4277 { 4278 sym_name = bfd_elf_string_from_elf_section (input_bfd, 4279 symtab_hdr->sh_link, 4280 sym->st_name); 4281 if (sym_name == NULL) 4282 return FALSE; 4283 if (*sym_name == '\0') 4284 sym_name = bfd_section_name (input_bfd, sym_sec); 4285 } 4286 4287 howto = elf_hppa_howto_table + r_type; 4288 4289 if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported) 4290 { 4291 if (rstatus == bfd_reloc_notsupported || !warned_undef) 4292 { 4293 (*_bfd_error_handler) 4294 (_("%B(%A+0x%lx): cannot handle %s for %s"), 4295 input_bfd, 4296 input_section, 4297 (long) rela->r_offset, 4298 howto->name, 4299 sym_name); 4300 bfd_set_error (bfd_error_bad_value); 4301 return FALSE; 4302 } 4303 } 4304 else 4305 { 4306 if (!((*info->callbacks->reloc_overflow) 4307 (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name, 4308 (bfd_vma) 0, input_bfd, input_section, rela->r_offset))) 4309 return FALSE; 4310 } 4311 } 4312 4313 return TRUE; 4314 } 4315 4316 /* Finish up dynamic symbol handling. We set the contents of various 4317 dynamic sections here. */ 4318 4319 static bfd_boolean 4320 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd, 4321 struct bfd_link_info *info, 4322 struct elf_link_hash_entry *eh, 4323 Elf_Internal_Sym *sym) 4324 { 4325 struct elf32_hppa_link_hash_table *htab; 4326 Elf_Internal_Rela rela; 4327 bfd_byte *loc; 4328 4329 htab = hppa_link_hash_table (info); 4330 if (htab == NULL) 4331 return FALSE; 4332 4333 if (eh->plt.offset != (bfd_vma) -1) 4334 { 4335 bfd_vma value; 4336 4337 if (eh->plt.offset & 1) 4338 abort (); 4339 4340 /* This symbol has an entry in the procedure linkage table. Set 4341 it up. 4342 4343 The format of a plt entry is 4344 <funcaddr> 4345 <__gp> 4346 */ 4347 value = 0; 4348 if (eh->root.type == bfd_link_hash_defined 4349 || eh->root.type == bfd_link_hash_defweak) 4350 { 4351 value = eh->root.u.def.value; 4352 if (eh->root.u.def.section->output_section != NULL) 4353 value += (eh->root.u.def.section->output_offset 4354 + eh->root.u.def.section->output_section->vma); 4355 } 4356 4357 /* Create a dynamic IPLT relocation for this entry. */ 4358 rela.r_offset = (eh->plt.offset 4359 + htab->splt->output_offset 4360 + htab->splt->output_section->vma); 4361 if (eh->dynindx != -1) 4362 { 4363 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT); 4364 rela.r_addend = 0; 4365 } 4366 else 4367 { 4368 /* This symbol has been marked to become local, and is 4369 used by a plabel so must be kept in the .plt. */ 4370 rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT); 4371 rela.r_addend = value; 4372 } 4373 4374 loc = htab->srelplt->contents; 4375 loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela); 4376 bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rela, loc); 4377 4378 if (!eh->def_regular) 4379 { 4380 /* Mark the symbol as undefined, rather than as defined in 4381 the .plt section. Leave the value alone. */ 4382 sym->st_shndx = SHN_UNDEF; 4383 } 4384 } 4385 4386 if (eh->got.offset != (bfd_vma) -1 4387 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0 4388 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0) 4389 { 4390 /* This symbol has an entry in the global offset table. Set it 4391 up. */ 4392 4393 rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1) 4394 + htab->sgot->output_offset 4395 + htab->sgot->output_section->vma); 4396 4397 /* If this is a -Bsymbolic link and the symbol is defined 4398 locally or was forced to be local because of a version file, 4399 we just want to emit a RELATIVE reloc. The entry in the 4400 global offset table will already have been initialized in the 4401 relocate_section function. */ 4402 if (info->shared 4403 && (info->symbolic || eh->dynindx == -1) 4404 && eh->def_regular) 4405 { 4406 rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32); 4407 rela.r_addend = (eh->root.u.def.value 4408 + eh->root.u.def.section->output_offset 4409 + eh->root.u.def.section->output_section->vma); 4410 } 4411 else 4412 { 4413 if ((eh->got.offset & 1) != 0) 4414 abort (); 4415 4416 bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1)); 4417 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32); 4418 rela.r_addend = 0; 4419 } 4420 4421 loc = htab->srelgot->contents; 4422 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4423 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4424 } 4425 4426 if (eh->needs_copy) 4427 { 4428 asection *sec; 4429 4430 /* This symbol needs a copy reloc. Set it up. */ 4431 4432 if (! (eh->dynindx != -1 4433 && (eh->root.type == bfd_link_hash_defined 4434 || eh->root.type == bfd_link_hash_defweak))) 4435 abort (); 4436 4437 sec = htab->srelbss; 4438 4439 rela.r_offset = (eh->root.u.def.value 4440 + eh->root.u.def.section->output_offset 4441 + eh->root.u.def.section->output_section->vma); 4442 rela.r_addend = 0; 4443 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY); 4444 loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela); 4445 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4446 } 4447 4448 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 4449 if (eh_name (eh)[0] == '_' 4450 && (strcmp (eh_name (eh), "_DYNAMIC") == 0 4451 || eh == htab->etab.hgot)) 4452 { 4453 sym->st_shndx = SHN_ABS; 4454 } 4455 4456 return TRUE; 4457 } 4458 4459 /* Used to decide how to sort relocs in an optimal manner for the 4460 dynamic linker, before writing them out. */ 4461 4462 static enum elf_reloc_type_class 4463 elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela) 4464 { 4465 /* Handle TLS relocs first; we don't want them to be marked 4466 relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)" 4467 check below. */ 4468 switch ((int) ELF32_R_TYPE (rela->r_info)) 4469 { 4470 case R_PARISC_TLS_DTPMOD32: 4471 case R_PARISC_TLS_DTPOFF32: 4472 case R_PARISC_TLS_TPREL32: 4473 return reloc_class_normal; 4474 } 4475 4476 if (ELF32_R_SYM (rela->r_info) == STN_UNDEF) 4477 return reloc_class_relative; 4478 4479 switch ((int) ELF32_R_TYPE (rela->r_info)) 4480 { 4481 case R_PARISC_IPLT: 4482 return reloc_class_plt; 4483 case R_PARISC_COPY: 4484 return reloc_class_copy; 4485 default: 4486 return reloc_class_normal; 4487 } 4488 } 4489 4490 /* Finish up the dynamic sections. */ 4491 4492 static bfd_boolean 4493 elf32_hppa_finish_dynamic_sections (bfd *output_bfd, 4494 struct bfd_link_info *info) 4495 { 4496 bfd *dynobj; 4497 struct elf32_hppa_link_hash_table *htab; 4498 asection *sdyn; 4499 asection * sgot; 4500 4501 htab = hppa_link_hash_table (info); 4502 if (htab == NULL) 4503 return FALSE; 4504 4505 dynobj = htab->etab.dynobj; 4506 4507 sgot = htab->sgot; 4508 /* A broken linker script might have discarded the dynamic sections. 4509 Catch this here so that we do not seg-fault later on. */ 4510 if (sgot != NULL && bfd_is_abs_section (sgot->output_section)) 4511 return FALSE; 4512 4513 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 4514 4515 if (htab->etab.dynamic_sections_created) 4516 { 4517 Elf32_External_Dyn *dyncon, *dynconend; 4518 4519 if (sdyn == NULL) 4520 abort (); 4521 4522 dyncon = (Elf32_External_Dyn *) sdyn->contents; 4523 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 4524 for (; dyncon < dynconend; dyncon++) 4525 { 4526 Elf_Internal_Dyn dyn; 4527 asection *s; 4528 4529 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 4530 4531 switch (dyn.d_tag) 4532 { 4533 default: 4534 continue; 4535 4536 case DT_PLTGOT: 4537 /* Use PLTGOT to set the GOT register. */ 4538 dyn.d_un.d_ptr = elf_gp (output_bfd); 4539 break; 4540 4541 case DT_JMPREL: 4542 s = htab->srelplt; 4543 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 4544 break; 4545 4546 case DT_PLTRELSZ: 4547 s = htab->srelplt; 4548 dyn.d_un.d_val = s->size; 4549 break; 4550 4551 case DT_RELASZ: 4552 /* Don't count procedure linkage table relocs in the 4553 overall reloc count. */ 4554 s = htab->srelplt; 4555 if (s == NULL) 4556 continue; 4557 dyn.d_un.d_val -= s->size; 4558 break; 4559 4560 case DT_RELA: 4561 /* We may not be using the standard ELF linker script. 4562 If .rela.plt is the first .rela section, we adjust 4563 DT_RELA to not include it. */ 4564 s = htab->srelplt; 4565 if (s == NULL) 4566 continue; 4567 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset) 4568 continue; 4569 dyn.d_un.d_ptr += s->size; 4570 break; 4571 } 4572 4573 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4574 } 4575 } 4576 4577 if (sgot != NULL && sgot->size != 0) 4578 { 4579 /* Fill in the first entry in the global offset table. 4580 We use it to point to our dynamic section, if we have one. */ 4581 bfd_put_32 (output_bfd, 4582 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0, 4583 sgot->contents); 4584 4585 /* The second entry is reserved for use by the dynamic linker. */ 4586 memset (sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE); 4587 4588 /* Set .got entry size. */ 4589 elf_section_data (sgot->output_section) 4590 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 4591 } 4592 4593 if (htab->splt != NULL && htab->splt->size != 0) 4594 { 4595 /* Set plt entry size. */ 4596 elf_section_data (htab->splt->output_section) 4597 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE; 4598 4599 if (htab->need_plt_stub) 4600 { 4601 /* Set up the .plt stub. */ 4602 memcpy (htab->splt->contents 4603 + htab->splt->size - sizeof (plt_stub), 4604 plt_stub, sizeof (plt_stub)); 4605 4606 if ((htab->splt->output_offset 4607 + htab->splt->output_section->vma 4608 + htab->splt->size) 4609 != (sgot->output_offset 4610 + sgot->output_section->vma)) 4611 { 4612 (*_bfd_error_handler) 4613 (_(".got section not immediately after .plt section")); 4614 return FALSE; 4615 } 4616 } 4617 } 4618 4619 return TRUE; 4620 } 4621 4622 /* Called when writing out an object file to decide the type of a 4623 symbol. */ 4624 static int 4625 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type) 4626 { 4627 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI) 4628 return STT_PARISC_MILLI; 4629 else 4630 return type; 4631 } 4632 4633 /* Misc BFD support code. */ 4634 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name 4635 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup 4636 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup 4637 #define elf_info_to_howto elf_hppa_info_to_howto 4638 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel 4639 4640 /* Stuff for the BFD linker. */ 4641 #define bfd_elf32_bfd_final_link elf32_hppa_final_link 4642 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create 4643 #define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free 4644 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol 4645 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol 4646 #define elf_backend_check_relocs elf32_hppa_check_relocs 4647 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections 4648 #define elf_backend_fake_sections elf_hppa_fake_sections 4649 #define elf_backend_relocate_section elf32_hppa_relocate_section 4650 #define elf_backend_hide_symbol elf32_hppa_hide_symbol 4651 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol 4652 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections 4653 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections 4654 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 4655 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook 4656 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook 4657 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus 4658 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo 4659 #define elf_backend_object_p elf32_hppa_object_p 4660 #define elf_backend_final_write_processing elf_hppa_final_write_processing 4661 #define elf_backend_post_process_headers _bfd_elf_set_osabi 4662 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type 4663 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class 4664 #define elf_backend_action_discarded elf_hppa_action_discarded 4665 4666 #define elf_backend_can_gc_sections 1 4667 #define elf_backend_can_refcount 1 4668 #define elf_backend_plt_alignment 2 4669 #define elf_backend_want_got_plt 0 4670 #define elf_backend_plt_readonly 0 4671 #define elf_backend_want_plt_sym 0 4672 #define elf_backend_got_header_size 8 4673 #define elf_backend_rela_normal 1 4674 4675 #define TARGET_BIG_SYM bfd_elf32_hppa_vec 4676 #define TARGET_BIG_NAME "elf32-hppa" 4677 #define ELF_ARCH bfd_arch_hppa 4678 #define ELF_TARGET_ID HPPA32_ELF_DATA 4679 #define ELF_MACHINE_CODE EM_PARISC 4680 #define ELF_MAXPAGESIZE 0x1000 4681 #define ELF_OSABI ELFOSABI_HPUX 4682 #define elf32_bed elf32_hppa_hpux_bed 4683 4684 #include "elf32-target.h" 4685 4686 #undef TARGET_BIG_SYM 4687 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec 4688 #undef TARGET_BIG_NAME 4689 #define TARGET_BIG_NAME "elf32-hppa-linux" 4690 #undef ELF_OSABI 4691 #define ELF_OSABI ELFOSABI_GNU 4692 #undef elf32_bed 4693 #define elf32_bed elf32_hppa_linux_bed 4694 4695 #include "elf32-target.h" 4696 4697 #undef TARGET_BIG_SYM 4698 #define TARGET_BIG_SYM bfd_elf32_hppa_nbsd_vec 4699 #undef TARGET_BIG_NAME 4700 #define TARGET_BIG_NAME "elf32-hppa-netbsd" 4701 #undef ELF_OSABI 4702 #define ELF_OSABI ELFOSABI_NETBSD 4703 #undef elf32_bed 4704 #define elf32_bed elf32_hppa_netbsd_bed 4705 4706 #include "elf32-target.h" 4707