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