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