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