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