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