1 /* POWER/PowerPC XCOFF linker support. 2 Copyright (C) 1995-2024 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor <ian@cygnus.com>, Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "bfdlink.h" 25 #include "libbfd.h" 26 #include "coff/internal.h" 27 #include "coff/xcoff.h" 28 #include "libcoff.h" 29 #include "libxcoff.h" 30 #include "libiberty.h" 31 #include "xcofflink.h" 32 33 /* This file holds the XCOFF linker code. */ 34 35 #undef STRING_SIZE_SIZE 36 #define STRING_SIZE_SIZE 4 37 38 /* The list of import files. */ 39 40 struct xcoff_import_file 41 { 42 /* The next entry in the list. */ 43 struct xcoff_import_file *next; 44 /* The path. */ 45 const char *path; 46 /* The file name. */ 47 const char *file; 48 /* The member name. */ 49 const char *member; 50 }; 51 52 /* Information we keep for each section in the output file during the 53 final link phase. */ 54 55 struct xcoff_link_section_info 56 { 57 /* The relocs to be output. */ 58 struct internal_reloc *relocs; 59 /* For each reloc against a global symbol whose index was not known 60 when the reloc was handled, the global hash table entry. */ 61 struct xcoff_link_hash_entry **rel_hashes; 62 /* If there is a TOC relative reloc against a global symbol, and the 63 index of the TOC symbol is not known when the reloc was handled, 64 an entry is added to this linked list. This is not an array, 65 like rel_hashes, because this case is quite uncommon. */ 66 struct xcoff_toc_rel_hash 67 { 68 struct xcoff_toc_rel_hash *next; 69 struct xcoff_link_hash_entry *h; 70 struct internal_reloc *rel; 71 } *toc_rel_hashes; 72 }; 73 74 /* Information that the XCOFF linker collects about an archive. */ 75 struct xcoff_archive_info 76 { 77 /* The archive described by this entry. */ 78 bfd *archive; 79 80 /* The import path and import filename to use when referring to 81 this archive in the .loader section. */ 82 const char *imppath; 83 const char *impfile; 84 85 /* True if the archive contains a dynamic object. */ 86 unsigned int contains_shared_object_p : 1; 87 88 /* True if the previous field is valid. */ 89 unsigned int know_contains_shared_object_p : 1; 90 }; 91 92 struct xcoff_link_hash_table 93 { 94 struct bfd_link_hash_table root; 95 96 /* The stub hash table. */ 97 struct bfd_hash_table stub_hash_table; 98 99 /* Info passed by the linker. */ 100 struct bfd_xcoff_link_params *params; 101 102 /* The .debug string hash table. We need to compute this while 103 reading the input files, so that we know how large the .debug 104 section will be before we assign section positions. */ 105 struct bfd_strtab_hash *debug_strtab; 106 107 /* The .debug section we will use for the final output. */ 108 asection *debug_section; 109 110 /* The .loader section we will use for the final output. */ 111 asection *loader_section; 112 113 /* The structure holding information about the .loader section. */ 114 struct xcoff_loader_info ldinfo; 115 116 /* The .loader section header. */ 117 struct internal_ldhdr ldhdr; 118 119 /* The .gl section we use to hold global linkage code. */ 120 asection *linkage_section; 121 122 /* The .tc section we use to hold toc entries we build for global 123 linkage code. */ 124 asection *toc_section; 125 126 /* The .ds section we use to hold function descriptors which we 127 create for exported symbols. */ 128 asection *descriptor_section; 129 130 /* The list of import files. */ 131 struct xcoff_import_file *imports; 132 133 /* Required alignment of sections within the output file. */ 134 unsigned long file_align; 135 136 /* Whether the .text section must be read-only. */ 137 bool textro; 138 139 /* Whether -brtl was specified. */ 140 bool rtld; 141 142 /* Whether garbage collection was done. */ 143 bool gc; 144 145 /* A linked list of symbols for which we have size information. */ 146 struct xcoff_link_size_list 147 { 148 struct xcoff_link_size_list *next; 149 struct xcoff_link_hash_entry *h; 150 bfd_size_type size; 151 } 152 *size_list; 153 154 /* Information about archives. */ 155 htab_t archive_info; 156 157 /* Magic sections: _text, _etext, _data, _edata, _end, end. */ 158 asection *special_sections[XCOFF_NUMBER_OF_SPECIAL_SECTIONS]; 159 }; 160 161 /* Information that we pass around while doing the final link step. */ 162 163 struct xcoff_final_link_info 164 { 165 /* General link information. */ 166 struct bfd_link_info *info; 167 /* Output BFD. */ 168 bfd *output_bfd; 169 /* Hash table for long symbol names. */ 170 struct bfd_strtab_hash *strtab; 171 /* Array of information kept for each output section, indexed by the 172 target_index field. */ 173 struct xcoff_link_section_info *section_info; 174 /* Symbol index of last C_FILE symbol (-1 if none). */ 175 long last_file_index; 176 /* Contents of last C_FILE symbol. */ 177 struct internal_syment last_file; 178 /* Symbol index of TOC symbol. */ 179 long toc_symindx; 180 /* Start of .loader symbols. */ 181 bfd_byte *ldsym; 182 /* Next .loader reloc to swap out. */ 183 bfd_byte *ldrel; 184 /* File position of start of line numbers. */ 185 file_ptr line_filepos; 186 /* Buffer large enough to hold swapped symbols of any input file. */ 187 struct internal_syment *internal_syms; 188 /* Buffer large enough to hold output indices of symbols of any 189 input file. */ 190 long *sym_indices; 191 /* Buffer large enough to hold output symbols for any input file. */ 192 bfd_byte *outsyms; 193 /* Buffer large enough to hold external line numbers for any input 194 section. */ 195 bfd_byte *linenos; 196 /* Buffer large enough to hold any input section. */ 197 bfd_byte *contents; 198 /* Buffer large enough to hold external relocs of any input section. */ 199 bfd_byte *external_relocs; 200 }; 201 202 #define xcoff_stub_hash_entry(ent) \ 203 ((struct xcoff_stub_hash_entry *)(ent)) 204 205 #define xcoff_stub_hash_lookup(table, string, create, copy) \ 206 ((struct xcoff_stub_hash_entry *) \ 207 bfd_hash_lookup ((table), (string), (create), (copy))) 208 209 static bool xcoff_mark (struct bfd_link_info *, asection *); 210 211 212 213 /* Routines to read XCOFF dynamic information. This don't really 214 belong here, but we already have the ldsym manipulation routines 215 here. */ 216 217 /* Read the contents of a section. */ 218 219 static bfd_byte * 220 xcoff_get_section_contents (bfd *abfd, asection *sec) 221 { 222 if (coff_section_data (abfd, sec) == NULL) 223 { 224 size_t amt = sizeof (struct coff_section_tdata); 225 226 sec->used_by_bfd = bfd_zalloc (abfd, amt); 227 if (sec->used_by_bfd == NULL) 228 return NULL; 229 } 230 231 bfd_byte *contents = coff_section_data (abfd, sec)->contents; 232 if (contents == NULL) 233 { 234 if (bfd_malloc_and_get_section (abfd, sec, &contents)) 235 coff_section_data (abfd, sec)->contents = contents; 236 else 237 { 238 free (contents); 239 contents = NULL; 240 } 241 } 242 243 return contents; 244 } 245 246 /* Get the size required to hold the dynamic symbols. */ 247 248 long 249 _bfd_xcoff_get_dynamic_symtab_upper_bound (bfd *abfd) 250 { 251 asection *lsec; 252 bfd_byte *contents; 253 struct internal_ldhdr ldhdr; 254 255 if ((abfd->flags & DYNAMIC) == 0) 256 { 257 bfd_set_error (bfd_error_invalid_operation); 258 return -1; 259 } 260 261 lsec = bfd_get_section_by_name (abfd, ".loader"); 262 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 263 { 264 bfd_set_error (bfd_error_no_symbols); 265 return -1; 266 } 267 268 contents = xcoff_get_section_contents (abfd, lsec); 269 if (!contents) 270 return -1; 271 272 bfd_xcoff_swap_ldhdr_in (abfd, (void *) contents, &ldhdr); 273 274 return (ldhdr.l_nsyms + 1) * sizeof (asymbol *); 275 } 276 277 /* Get the dynamic symbols. */ 278 279 long 280 _bfd_xcoff_canonicalize_dynamic_symtab (bfd *abfd, asymbol **psyms) 281 { 282 asection *lsec; 283 bfd_byte *contents; 284 struct internal_ldhdr ldhdr; 285 const char *strings; 286 bfd_byte *elsym, *elsymend; 287 coff_symbol_type *symbuf; 288 289 if ((abfd->flags & DYNAMIC) == 0) 290 { 291 bfd_set_error (bfd_error_invalid_operation); 292 return -1; 293 } 294 295 lsec = bfd_get_section_by_name (abfd, ".loader"); 296 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 297 { 298 bfd_set_error (bfd_error_no_symbols); 299 return -1; 300 } 301 302 contents = xcoff_get_section_contents (abfd, lsec); 303 if (!contents) 304 return -1; 305 306 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr); 307 308 strings = (char *) contents + ldhdr.l_stoff; 309 310 symbuf = bfd_zalloc (abfd, ldhdr.l_nsyms * sizeof (* symbuf)); 311 if (symbuf == NULL) 312 return -1; 313 314 elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr); 315 316 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd); 317 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd), symbuf++, psyms++) 318 { 319 struct internal_ldsym ldsym; 320 321 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym); 322 323 symbuf->symbol.the_bfd = abfd; 324 325 if (ldsym._l._l_l._l_zeroes == 0) 326 symbuf->symbol.name = strings + ldsym._l._l_l._l_offset; 327 else 328 { 329 char *c; 330 331 c = bfd_alloc (abfd, (bfd_size_type) SYMNMLEN + 1); 332 if (c == NULL) 333 return -1; 334 memcpy (c, ldsym._l._l_name, SYMNMLEN); 335 c[SYMNMLEN] = '\0'; 336 symbuf->symbol.name = c; 337 } 338 339 if (ldsym.l_smclas == XMC_XO) 340 symbuf->symbol.section = bfd_abs_section_ptr; 341 else 342 symbuf->symbol.section = coff_section_from_bfd_index (abfd, 343 ldsym.l_scnum); 344 symbuf->symbol.value = ldsym.l_value - symbuf->symbol.section->vma; 345 346 symbuf->symbol.flags = BSF_NO_FLAGS; 347 if ((ldsym.l_smtype & L_EXPORT) != 0) 348 { 349 if ((ldsym.l_smtype & L_WEAK) != 0) 350 symbuf->symbol.flags |= BSF_WEAK; 351 else 352 symbuf->symbol.flags |= BSF_GLOBAL; 353 } 354 355 /* FIXME: We have no way to record the other information stored 356 with the loader symbol. */ 357 *psyms = (asymbol *) symbuf; 358 } 359 360 *psyms = NULL; 361 362 return ldhdr.l_nsyms; 363 } 364 365 /* Get the size required to hold the dynamic relocs. */ 366 367 long 368 _bfd_xcoff_get_dynamic_reloc_upper_bound (bfd *abfd) 369 { 370 asection *lsec; 371 bfd_byte *contents; 372 struct internal_ldhdr ldhdr; 373 374 if ((abfd->flags & DYNAMIC) == 0) 375 { 376 bfd_set_error (bfd_error_invalid_operation); 377 return -1; 378 } 379 380 lsec = bfd_get_section_by_name (abfd, ".loader"); 381 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 382 { 383 bfd_set_error (bfd_error_no_symbols); 384 return -1; 385 } 386 387 contents = xcoff_get_section_contents (abfd, lsec); 388 if (!contents) 389 return -1; 390 391 bfd_xcoff_swap_ldhdr_in (abfd, (struct external_ldhdr *) contents, &ldhdr); 392 393 return (ldhdr.l_nreloc + 1) * sizeof (arelent *); 394 } 395 396 /* Get the dynamic relocs. */ 397 398 long 399 _bfd_xcoff_canonicalize_dynamic_reloc (bfd *abfd, 400 arelent **prelocs, 401 asymbol **syms) 402 { 403 asection *lsec; 404 bfd_byte *contents; 405 struct internal_ldhdr ldhdr; 406 arelent *relbuf; 407 bfd_byte *elrel, *elrelend; 408 409 if ((abfd->flags & DYNAMIC) == 0) 410 { 411 bfd_set_error (bfd_error_invalid_operation); 412 return -1; 413 } 414 415 lsec = bfd_get_section_by_name (abfd, ".loader"); 416 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 417 { 418 bfd_set_error (bfd_error_no_symbols); 419 return -1; 420 } 421 422 contents = xcoff_get_section_contents (abfd, lsec); 423 if (!contents) 424 return -1; 425 426 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr); 427 428 relbuf = bfd_alloc (abfd, ldhdr.l_nreloc * sizeof (arelent)); 429 if (relbuf == NULL) 430 return -1; 431 432 elrel = contents + bfd_xcoff_loader_reloc_offset(abfd, &ldhdr); 433 434 elrelend = elrel + ldhdr.l_nreloc * bfd_xcoff_ldrelsz(abfd); 435 for (; elrel < elrelend; elrel += bfd_xcoff_ldrelsz(abfd), relbuf++, 436 prelocs++) 437 { 438 struct internal_ldrel ldrel; 439 440 bfd_xcoff_swap_ldrel_in (abfd, elrel, &ldrel); 441 442 if (ldrel.l_symndx >= 3) 443 relbuf->sym_ptr_ptr = syms + (ldrel.l_symndx - 3); 444 else 445 { 446 const char *name; 447 asection *sec; 448 449 switch (ldrel.l_symndx) 450 { 451 case 0: 452 name = ".text"; 453 break; 454 case 1: 455 name = ".data"; 456 break; 457 case 2: 458 name = ".bss"; 459 break; 460 default: 461 abort (); 462 break; 463 } 464 465 sec = bfd_get_section_by_name (abfd, name); 466 if (sec == NULL) 467 { 468 bfd_set_error (bfd_error_bad_value); 469 return -1; 470 } 471 472 relbuf->sym_ptr_ptr = sec->symbol_ptr_ptr; 473 } 474 475 relbuf->address = ldrel.l_vaddr; 476 relbuf->addend = 0; 477 478 /* Most dynamic relocs have the same type. FIXME: This is only 479 correct if ldrel.l_rtype == 0. In other cases, we should use 480 a different howto. */ 481 relbuf->howto = bfd_xcoff_dynamic_reloc_howto(abfd); 482 483 /* FIXME: We have no way to record the l_rsecnm field. */ 484 485 *prelocs = relbuf; 486 } 487 488 *prelocs = NULL; 489 490 return ldhdr.l_nreloc; 491 } 492 493 /* Hash functions for xcoff_link_hash_table's archive_info. */ 494 495 static hashval_t 496 xcoff_archive_info_hash (const void *data) 497 { 498 const struct xcoff_archive_info *info; 499 500 info = (const struct xcoff_archive_info *) data; 501 return htab_hash_pointer (info->archive); 502 } 503 504 static int 505 xcoff_archive_info_eq (const void *data1, const void *data2) 506 { 507 const struct xcoff_archive_info *info1; 508 const struct xcoff_archive_info *info2; 509 510 info1 = (const struct xcoff_archive_info *) data1; 511 info2 = (const struct xcoff_archive_info *) data2; 512 return info1->archive == info2->archive; 513 } 514 515 /* Return information about archive ARCHIVE. Return NULL on error. */ 516 517 static struct xcoff_archive_info * 518 xcoff_get_archive_info (struct bfd_link_info *info, bfd *archive) 519 { 520 struct xcoff_link_hash_table *htab; 521 struct xcoff_archive_info *entryp, entry; 522 void **slot; 523 524 htab = xcoff_hash_table (info); 525 entry.archive = archive; 526 slot = htab_find_slot (htab->archive_info, &entry, INSERT); 527 if (!slot) 528 return NULL; 529 530 entryp = *slot; 531 if (!entryp) 532 { 533 entryp = bfd_zalloc (info->output_bfd, sizeof (entry)); 534 if (!entryp) 535 return NULL; 536 537 entryp->archive = archive; 538 *slot = entryp; 539 } 540 return entryp; 541 } 542 543 544 /* Initialize an entry in the stub hash table. */ 545 static struct bfd_hash_entry * 546 stub_hash_newfunc (struct bfd_hash_entry *entry, 547 struct bfd_hash_table *table, 548 const char *string) 549 { 550 /* Allocate the structure if it has not already been allocated by a 551 subclass. */ 552 if (entry == NULL) 553 { 554 entry = bfd_hash_allocate (table, 555 sizeof (struct xcoff_stub_hash_entry)); 556 if (entry == NULL) 557 return entry; 558 } 559 560 /* Call the allocation method of the superclass. */ 561 entry = bfd_hash_newfunc (entry, table, string); 562 if (entry != NULL) 563 { 564 struct xcoff_stub_hash_entry *hsh; 565 566 /* Initialize the local fields. */ 567 hsh = (struct xcoff_stub_hash_entry *) entry; 568 hsh->stub_type = xcoff_stub_none; 569 hsh->hcsect = NULL; 570 hsh->stub_offset = 0; 571 hsh->target_section = NULL; 572 hsh->htarget = NULL; 573 } 574 575 return entry; 576 } 577 578 /* Routine to create an entry in an XCOFF link hash table. */ 579 580 static struct bfd_hash_entry * 581 xcoff_link_hash_newfunc (struct bfd_hash_entry *entry, 582 struct bfd_hash_table *table, 583 const char *string) 584 { 585 struct xcoff_link_hash_entry *ret = (struct xcoff_link_hash_entry *) entry; 586 587 /* Allocate the structure if it has not already been allocated by a 588 subclass. */ 589 if (ret == NULL) 590 ret = bfd_hash_allocate (table, sizeof (* ret)); 591 if (ret == NULL) 592 return NULL; 593 594 /* Call the allocation method of the superclass. */ 595 ret = ((struct xcoff_link_hash_entry *) 596 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, 597 table, string)); 598 if (ret != NULL) 599 { 600 /* Set local fields. */ 601 ret->indx = -1; 602 ret->toc_section = NULL; 603 ret->u.toc_indx = -1; 604 ret->descriptor = NULL; 605 ret->ldsym = NULL; 606 ret->ldindx = -1; 607 ret->flags = 0; 608 ret->smclas = XMC_UA; 609 } 610 611 return (struct bfd_hash_entry *) ret; 612 } 613 614 /* Destroy an XCOFF link hash table. */ 615 616 static void 617 _bfd_xcoff_bfd_link_hash_table_free (bfd *obfd) 618 { 619 struct xcoff_link_hash_table *ret; 620 621 ret = (struct xcoff_link_hash_table *) obfd->link.hash; 622 if (ret->archive_info) 623 htab_delete (ret->archive_info); 624 if (ret->debug_strtab) 625 _bfd_stringtab_free (ret->debug_strtab); 626 627 bfd_hash_table_free (&ret->stub_hash_table); 628 _bfd_generic_link_hash_table_free (obfd); 629 } 630 631 /* Create an XCOFF link hash table. */ 632 633 struct bfd_link_hash_table * 634 _bfd_xcoff_bfd_link_hash_table_create (bfd *abfd) 635 { 636 struct xcoff_link_hash_table *ret; 637 bool isxcoff64 = false; 638 size_t amt = sizeof (* ret); 639 640 ret = bfd_zmalloc (amt); 641 if (ret == NULL) 642 return NULL; 643 if (!_bfd_link_hash_table_init (&ret->root, abfd, xcoff_link_hash_newfunc, 644 sizeof (struct xcoff_link_hash_entry))) 645 { 646 free (ret); 647 return NULL; 648 } 649 650 /* Init the stub hash table too. */ 651 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc, 652 sizeof (struct xcoff_stub_hash_entry))) 653 { 654 _bfd_xcoff_bfd_link_hash_table_free (abfd); 655 return NULL; 656 } 657 658 isxcoff64 = bfd_coff_debug_string_prefix_length (abfd) == 4; 659 660 ret->debug_strtab = _bfd_xcoff_stringtab_init (isxcoff64); 661 ret->archive_info = htab_create (37, xcoff_archive_info_hash, 662 xcoff_archive_info_eq, NULL); 663 if (!ret->debug_strtab || !ret->archive_info) 664 { 665 _bfd_xcoff_bfd_link_hash_table_free (abfd); 666 return NULL; 667 } 668 ret->root.hash_table_free = _bfd_xcoff_bfd_link_hash_table_free; 669 670 /* The linker will always generate a full a.out header. We need to 671 record that fact now, before the sizeof_headers routine could be 672 called. */ 673 xcoff_data (abfd)->full_aouthdr = true; 674 675 return &ret->root; 676 } 677 678 /* Read internal relocs for an XCOFF csect. This is a wrapper around 679 _bfd_coff_read_internal_relocs which tries to take advantage of any 680 relocs which may have been cached for the enclosing section. */ 681 682 static struct internal_reloc * 683 xcoff_read_internal_relocs (bfd *abfd, 684 asection *sec, 685 bool cache, 686 bfd_byte *external_relocs, 687 bool require_internal, 688 struct internal_reloc *internal_relocs) 689 { 690 if (coff_section_data (abfd, sec) != NULL 691 && coff_section_data (abfd, sec)->relocs == NULL 692 && xcoff_section_data (abfd, sec) != NULL) 693 { 694 asection *enclosing; 695 696 enclosing = xcoff_section_data (abfd, sec)->enclosing; 697 698 if (enclosing != NULL 699 && (coff_section_data (abfd, enclosing) == NULL 700 || coff_section_data (abfd, enclosing)->relocs == NULL) 701 && cache 702 && enclosing->reloc_count > 0) 703 { 704 if (_bfd_coff_read_internal_relocs (abfd, enclosing, true, 705 external_relocs, false, NULL) 706 == NULL) 707 return NULL; 708 } 709 710 if (enclosing != NULL 711 && coff_section_data (abfd, enclosing) != NULL 712 && coff_section_data (abfd, enclosing)->relocs != NULL) 713 { 714 size_t off; 715 716 off = ((sec->rel_filepos - enclosing->rel_filepos) 717 / bfd_coff_relsz (abfd)); 718 719 if (! require_internal) 720 return coff_section_data (abfd, enclosing)->relocs + off; 721 memcpy (internal_relocs, 722 coff_section_data (abfd, enclosing)->relocs + off, 723 sec->reloc_count * sizeof (struct internal_reloc)); 724 return internal_relocs; 725 } 726 } 727 728 return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, 729 require_internal, internal_relocs); 730 } 731 732 /* Split FILENAME into an import path and an import filename, 733 storing them in *IMPPATH and *IMPFILE respectively. */ 734 735 bool 736 bfd_xcoff_split_import_path (bfd *abfd, const char *filename, 737 const char **imppath, const char **impfile) 738 { 739 const char *base; 740 size_t length; 741 char *path; 742 743 base = lbasename (filename); 744 length = base - filename; 745 if (length == 0) 746 /* The filename has no directory component, so use an empty path. */ 747 *imppath = ""; 748 else if (length == 1) 749 /* The filename is in the root directory. */ 750 *imppath = "/"; 751 else 752 { 753 /* Extract the (non-empty) directory part. Note that we don't 754 need to strip duplicate directory separators from any part 755 of the string; the native linker doesn't do that either. */ 756 path = bfd_alloc (abfd, length); 757 if (path == NULL) 758 return false; 759 memcpy (path, filename, length - 1); 760 path[length - 1] = 0; 761 *imppath = path; 762 } 763 *impfile = base; 764 return true; 765 } 766 767 /* Set ARCHIVE's import path as though its filename had been given 768 as FILENAME. */ 769 770 bool 771 bfd_xcoff_set_archive_import_path (struct bfd_link_info *info, 772 bfd *archive, const char *filename) 773 { 774 struct xcoff_archive_info *archive_info; 775 776 archive_info = xcoff_get_archive_info (info, archive); 777 return (archive_info != NULL 778 && bfd_xcoff_split_import_path (archive, filename, 779 &archive_info->imppath, 780 &archive_info->impfile)); 781 } 782 783 /* H is an imported symbol. Set the import module's path, file and member 784 to IMPATH, IMPFILE and IMPMEMBER respectively. All three are null if 785 no specific import module is specified. */ 786 787 static bool 788 xcoff_set_import_path (struct bfd_link_info *info, 789 struct xcoff_link_hash_entry *h, 790 const char *imppath, const char *impfile, 791 const char *impmember) 792 { 793 unsigned int c; 794 struct xcoff_import_file **pp; 795 796 /* We overload the ldindx field to hold the l_ifile value for this 797 symbol. */ 798 BFD_ASSERT (h->ldsym == NULL); 799 BFD_ASSERT ((h->flags & XCOFF_BUILT_LDSYM) == 0); 800 if (imppath == NULL) 801 h->ldindx = -1; 802 else 803 { 804 /* We start c at 1 because the first entry in the import list is 805 reserved for the library search path. */ 806 for (pp = &xcoff_hash_table (info)->imports, c = 1; 807 *pp != NULL; 808 pp = &(*pp)->next, ++c) 809 { 810 if (filename_cmp ((*pp)->path, imppath) == 0 811 && filename_cmp ((*pp)->file, impfile) == 0 812 && filename_cmp ((*pp)->member, impmember) == 0) 813 break; 814 } 815 816 if (*pp == NULL) 817 { 818 struct xcoff_import_file *n; 819 size_t amt = sizeof (*n); 820 821 n = bfd_alloc (info->output_bfd, amt); 822 if (n == NULL) 823 return false; 824 n->next = NULL; 825 n->path = imppath; 826 n->file = impfile; 827 n->member = impmember; 828 *pp = n; 829 } 830 h->ldindx = c; 831 } 832 return true; 833 } 834 835 /* H is the bfd symbol associated with exported .loader symbol LDSYM. 836 Return true if LDSYM defines H. */ 837 838 static bool 839 xcoff_dynamic_definition_p (struct xcoff_link_hash_entry *h, 840 struct internal_ldsym *ldsym) 841 { 842 /* If we didn't know about H before processing LDSYM, LDSYM 843 definitely defines H. */ 844 if (h->root.type == bfd_link_hash_new) 845 return true; 846 847 /* If H is currently a weak dynamic symbol, and if LDSYM is a strong 848 dynamic symbol, LDSYM trumps the current definition of H. */ 849 if ((ldsym->l_smtype & L_WEAK) == 0 850 && (h->flags & XCOFF_DEF_DYNAMIC) != 0 851 && (h->flags & XCOFF_DEF_REGULAR) == 0 852 && (h->root.type == bfd_link_hash_defweak 853 || h->root.type == bfd_link_hash_undefweak)) 854 return true; 855 856 /* If H is currently undefined, LDSYM defines it. 857 However, if H has a hidden visibility, LDSYM must not 858 define it. */ 859 if ((h->flags & XCOFF_DEF_DYNAMIC) == 0 860 && (h->root.type == bfd_link_hash_undefined 861 || h->root.type == bfd_link_hash_undefweak) 862 && (h->visibility != SYM_V_HIDDEN 863 && h->visibility != SYM_V_INTERNAL)) 864 return true; 865 866 return false; 867 } 868 869 /* This function is used to add symbols from a dynamic object to the 870 global symbol table. */ 871 872 static bool 873 xcoff_link_add_dynamic_symbols (bfd *abfd, struct bfd_link_info *info) 874 { 875 asection *lsec; 876 bfd_byte *contents; 877 struct internal_ldhdr ldhdr; 878 const char *strings; 879 bfd_byte *elsym, *elsymend; 880 struct xcoff_import_file *n; 881 unsigned int c; 882 struct xcoff_import_file **pp; 883 884 /* We can only handle a dynamic object if we are generating an XCOFF 885 output file. */ 886 if (info->output_bfd->xvec != abfd->xvec) 887 { 888 _bfd_error_handler 889 (_("%pB: XCOFF shared object when not producing XCOFF output"), 890 abfd); 891 bfd_set_error (bfd_error_invalid_operation); 892 return false; 893 } 894 895 /* The symbols we use from a dynamic object are not the symbols in 896 the normal symbol table, but, rather, the symbols in the export 897 table. If there is a global symbol in a dynamic object which is 898 not in the export table, the loader will not be able to find it, 899 so we don't want to find it either. Also, on AIX 4.1.3, shr.o in 900 libc.a has symbols in the export table which are not in the 901 symbol table. */ 902 903 /* Read in the .loader section. FIXME: We should really use the 904 o_snloader field in the a.out header, rather than grabbing the 905 section by name. */ 906 lsec = bfd_get_section_by_name (abfd, ".loader"); 907 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 908 { 909 _bfd_error_handler 910 (_("%pB: dynamic object with no .loader section"), 911 abfd); 912 bfd_set_error (bfd_error_no_symbols); 913 return false; 914 } 915 916 contents = xcoff_get_section_contents (abfd, lsec); 917 if (!contents) 918 return false; 919 920 /* Remove the sections from this object, so that they do not get 921 included in the link. */ 922 bfd_section_list_clear (abfd); 923 924 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr); 925 926 strings = (char *) contents + ldhdr.l_stoff; 927 928 elsym = contents + bfd_xcoff_loader_symbol_offset(abfd, &ldhdr); 929 930 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz(abfd); 931 932 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz(abfd)) 933 { 934 struct internal_ldsym ldsym; 935 char nambuf[SYMNMLEN + 1]; 936 const char *name; 937 struct xcoff_link_hash_entry *h; 938 939 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym); 940 941 /* We are only interested in exported symbols. */ 942 if ((ldsym.l_smtype & L_EXPORT) == 0) 943 continue; 944 945 if (ldsym._l._l_l._l_zeroes == 0) 946 name = strings + ldsym._l._l_l._l_offset; 947 else 948 { 949 memcpy (nambuf, ldsym._l._l_name, SYMNMLEN); 950 nambuf[SYMNMLEN] = '\0'; 951 name = nambuf; 952 } 953 954 /* Normally we could not call xcoff_link_hash_lookup in an add 955 symbols routine, since we might not be using an XCOFF hash 956 table. However, we verified above that we are using an XCOFF 957 hash table. */ 958 959 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true, 960 true, true); 961 if (h == NULL) 962 return false; 963 964 if (!xcoff_dynamic_definition_p (h, &ldsym)) 965 continue; 966 967 h->flags |= XCOFF_DEF_DYNAMIC; 968 h->smclas = ldsym.l_smclas; 969 if (h->smclas == XMC_XO) 970 { 971 /* This symbol has an absolute value. */ 972 if ((ldsym.l_smtype & L_WEAK) != 0) 973 h->root.type = bfd_link_hash_defweak; 974 else 975 h->root.type = bfd_link_hash_defined; 976 h->root.u.def.section = bfd_abs_section_ptr; 977 h->root.u.def.value = ldsym.l_value; 978 } 979 else 980 { 981 /* Otherwise, we don't bother to actually define the symbol, 982 since we don't have a section to put it in anyhow. 983 We assume instead that an undefined XCOFF_DEF_DYNAMIC symbol 984 should be imported from the symbol's undef.abfd. */ 985 if ((ldsym.l_smtype & L_WEAK) != 0) 986 h->root.type = bfd_link_hash_undefweak; 987 else 988 h->root.type = bfd_link_hash_undefined; 989 h->root.u.undef.abfd = abfd; 990 } 991 992 /* If this symbol defines a function descriptor, then it 993 implicitly defines the function code as well. */ 994 if (h->smclas == XMC_DS 995 || (h->smclas == XMC_XO && name[0] != '.')) 996 h->flags |= XCOFF_DESCRIPTOR; 997 if ((h->flags & XCOFF_DESCRIPTOR) != 0) 998 { 999 struct xcoff_link_hash_entry *hds; 1000 1001 hds = h->descriptor; 1002 if (hds == NULL) 1003 { 1004 char *dsnm; 1005 1006 dsnm = bfd_malloc ((bfd_size_type) strlen (name) + 2); 1007 if (dsnm == NULL) 1008 return false; 1009 dsnm[0] = '.'; 1010 strcpy (dsnm + 1, name); 1011 hds = xcoff_link_hash_lookup (xcoff_hash_table (info), dsnm, 1012 true, true, true); 1013 free (dsnm); 1014 if (hds == NULL) 1015 return false; 1016 1017 hds->descriptor = h; 1018 h->descriptor = hds; 1019 } 1020 1021 if (xcoff_dynamic_definition_p (hds, &ldsym)) 1022 { 1023 hds->root.type = h->root.type; 1024 hds->flags |= XCOFF_DEF_DYNAMIC; 1025 if (h->smclas == XMC_XO) 1026 { 1027 /* An absolute symbol appears to actually define code, not a 1028 function descriptor. This is how some math functions are 1029 implemented on AIX 4.1. */ 1030 hds->smclas = XMC_XO; 1031 hds->root.u.def.section = bfd_abs_section_ptr; 1032 hds->root.u.def.value = ldsym.l_value; 1033 } 1034 else 1035 { 1036 hds->smclas = XMC_PR; 1037 hds->root.u.undef.abfd = abfd; 1038 /* We do not want to add this to the undefined 1039 symbol list. */ 1040 } 1041 } 1042 } 1043 } 1044 1045 free (contents); 1046 coff_section_data (abfd, lsec)->contents = NULL; 1047 1048 /* Record this file in the import files. */ 1049 n = bfd_alloc (abfd, (bfd_size_type) sizeof (struct xcoff_import_file)); 1050 if (n == NULL) 1051 return false; 1052 n->next = NULL; 1053 1054 if (abfd->my_archive == NULL || bfd_is_thin_archive (abfd->my_archive)) 1055 { 1056 if (!bfd_xcoff_split_import_path (abfd, bfd_get_filename (abfd), 1057 &n->path, &n->file)) 1058 return false; 1059 n->member = ""; 1060 } 1061 else 1062 { 1063 struct xcoff_archive_info *archive_info; 1064 1065 archive_info = xcoff_get_archive_info (info, abfd->my_archive); 1066 if (!archive_info->impfile) 1067 { 1068 if (!bfd_xcoff_split_import_path (archive_info->archive, 1069 bfd_get_filename (archive_info 1070 ->archive), 1071 &archive_info->imppath, 1072 &archive_info->impfile)) 1073 return false; 1074 } 1075 n->path = archive_info->imppath; 1076 n->file = archive_info->impfile; 1077 n->member = bfd_get_filename (abfd); 1078 } 1079 1080 /* We start c at 1 because the first import file number is reserved 1081 for LIBPATH. */ 1082 for (pp = &xcoff_hash_table (info)->imports, c = 1; 1083 *pp != NULL; 1084 pp = &(*pp)->next, ++c) 1085 ; 1086 *pp = n; 1087 1088 xcoff_data (abfd)->import_file_id = c; 1089 1090 return true; 1091 } 1092 1093 /* xcoff_link_create_extra_sections 1094 1095 Takes care of creating the .loader, .gl, .ds, .debug and sections. */ 1096 1097 static bool 1098 xcoff_link_create_extra_sections (bfd * abfd, struct bfd_link_info *info) 1099 { 1100 bool return_value = false; 1101 1102 if (info->output_bfd->xvec == abfd->xvec) 1103 { 1104 /* We need to build a .loader section, so we do it here. This 1105 won't work if we're producing an XCOFF output file with no 1106 XCOFF input files. FIXME. */ 1107 1108 if (!bfd_link_relocatable (info) 1109 && xcoff_hash_table (info)->loader_section == NULL) 1110 { 1111 asection *lsec; 1112 flagword flags = SEC_HAS_CONTENTS | SEC_IN_MEMORY; 1113 1114 lsec = bfd_make_section_anyway_with_flags (abfd, ".loader", flags); 1115 if (lsec == NULL) 1116 goto end_return; 1117 1118 xcoff_hash_table (info)->loader_section = lsec; 1119 } 1120 1121 /* Likewise for the linkage section. */ 1122 if (xcoff_hash_table (info)->linkage_section == NULL) 1123 { 1124 asection *lsec; 1125 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1126 | SEC_IN_MEMORY); 1127 1128 lsec = bfd_make_section_anyway_with_flags (abfd, ".gl", flags); 1129 if (lsec == NULL) 1130 goto end_return; 1131 1132 xcoff_hash_table (info)->linkage_section = lsec; 1133 lsec->alignment_power = 2; 1134 } 1135 1136 /* Likewise for the TOC section. */ 1137 if (xcoff_hash_table (info)->toc_section == NULL) 1138 { 1139 asection *tsec; 1140 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1141 | SEC_IN_MEMORY); 1142 1143 tsec = bfd_make_section_anyway_with_flags (abfd, ".tc", flags); 1144 if (tsec == NULL) 1145 goto end_return; 1146 1147 xcoff_hash_table (info)->toc_section = tsec; 1148 tsec->alignment_power = 2; 1149 } 1150 1151 /* Likewise for the descriptor section. */ 1152 if (xcoff_hash_table (info)->descriptor_section == NULL) 1153 { 1154 asection *dsec; 1155 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1156 | SEC_IN_MEMORY); 1157 1158 dsec = bfd_make_section_anyway_with_flags (abfd, ".ds", flags); 1159 if (dsec == NULL) 1160 goto end_return; 1161 1162 xcoff_hash_table (info)->descriptor_section = dsec; 1163 dsec->alignment_power = 2; 1164 } 1165 1166 /* Likewise for the .debug section. */ 1167 if (xcoff_hash_table (info)->debug_section == NULL 1168 && info->strip != strip_all) 1169 { 1170 asection *dsec; 1171 flagword flags = SEC_HAS_CONTENTS | SEC_IN_MEMORY; 1172 1173 dsec = bfd_make_section_anyway_with_flags (abfd, ".debug", flags); 1174 if (dsec == NULL) 1175 goto end_return; 1176 1177 xcoff_hash_table (info)->debug_section = dsec; 1178 } 1179 } 1180 1181 return_value = true; 1182 1183 end_return: 1184 1185 return return_value; 1186 } 1187 1188 /* Returns the index of reloc in RELOCS with the least address greater 1189 than or equal to ADDRESS. The relocs are sorted by address. */ 1190 1191 static bfd_size_type 1192 xcoff_find_reloc (struct internal_reloc *relocs, 1193 bfd_size_type count, 1194 bfd_vma address) 1195 { 1196 bfd_size_type min, max, this; 1197 1198 if (count < 2) 1199 { 1200 if (count == 1 && relocs[0].r_vaddr < address) 1201 return 1; 1202 else 1203 return 0; 1204 } 1205 1206 min = 0; 1207 max = count; 1208 1209 /* Do a binary search over (min,max]. */ 1210 while (min + 1 < max) 1211 { 1212 bfd_vma raddr; 1213 1214 this = (max + min) / 2; 1215 raddr = relocs[this].r_vaddr; 1216 if (raddr > address) 1217 max = this; 1218 else if (raddr < address) 1219 min = this; 1220 else 1221 { 1222 min = this; 1223 break; 1224 } 1225 } 1226 1227 if (relocs[min].r_vaddr < address) 1228 return min + 1; 1229 1230 while (min > 0 1231 && relocs[min - 1].r_vaddr == address) 1232 --min; 1233 1234 return min; 1235 } 1236 1237 /* Return true if the symbol has to be added to the linker hash 1238 table. */ 1239 static bool 1240 xcoff_link_add_symbols_to_hash_table (struct internal_syment sym, 1241 union internal_auxent aux) 1242 { 1243 /* External symbols must be added. */ 1244 if (EXTERN_SYM_P (sym.n_sclass)) 1245 return true; 1246 1247 /* Hidden TLS symbols must be added to verify TLS relocations 1248 in xcoff_reloc_type_tls. */ 1249 if (sym.n_sclass == C_HIDEXT 1250 && ((aux.x_csect.x_smclas == XMC_TL 1251 || aux.x_csect.x_smclas == XMC_UL))) 1252 return true; 1253 1254 return false; 1255 } 1256 1257 /* Add all the symbols from an object file to the hash table. 1258 1259 XCOFF is a weird format. A normal XCOFF .o files will have three 1260 COFF sections--.text, .data, and .bss--but each COFF section will 1261 contain many csects. These csects are described in the symbol 1262 table. From the linker's point of view, each csect must be 1263 considered a section in its own right. For example, a TOC entry is 1264 handled as a small XMC_TC csect. The linker must be able to merge 1265 different TOC entries together, which means that it must be able to 1266 extract the XMC_TC csects from the .data section of the input .o 1267 file. 1268 1269 From the point of view of our linker, this is, of course, a hideous 1270 nightmare. We cope by actually creating sections for each csect, 1271 and discarding the original sections. We then have to handle the 1272 relocation entries carefully, since the only way to tell which 1273 csect they belong to is to examine the address. */ 1274 1275 static bool 1276 xcoff_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 1277 { 1278 unsigned int n_tmask; 1279 unsigned int n_btshft; 1280 bool default_copy; 1281 bfd_size_type symcount; 1282 struct xcoff_link_hash_entry **sym_hash; 1283 asection **csect_cache; 1284 unsigned int *lineno_counts; 1285 bfd_size_type linesz; 1286 asection *o; 1287 asection *last_real; 1288 bool keep_syms; 1289 asection *csect; 1290 unsigned int csect_index; 1291 asection *first_csect; 1292 bfd_size_type symesz; 1293 bfd_byte *esym; 1294 bfd_byte *esym_end; 1295 struct reloc_info_struct 1296 { 1297 struct internal_reloc *relocs; 1298 asection **csects; 1299 bfd_byte *linenos; 1300 } *reloc_info = NULL; 1301 bfd_size_type amt; 1302 unsigned short visibility; 1303 1304 keep_syms = obj_coff_keep_syms (abfd); 1305 1306 if ((abfd->flags & DYNAMIC) != 0 1307 && ! info->static_link) 1308 { 1309 if (! xcoff_link_add_dynamic_symbols (abfd, info)) 1310 return false; 1311 } 1312 1313 /* Create the loader, toc, gl, ds and debug sections, if needed. */ 1314 if (! xcoff_link_create_extra_sections (abfd, info)) 1315 goto error_return; 1316 1317 if ((abfd->flags & DYNAMIC) != 0 1318 && ! info->static_link) 1319 return true; 1320 1321 n_tmask = coff_data (abfd)->local_n_tmask; 1322 n_btshft = coff_data (abfd)->local_n_btshft; 1323 1324 /* Define macros so that ISFCN, et. al., macros work correctly. */ 1325 #define N_TMASK n_tmask 1326 #define N_BTSHFT n_btshft 1327 1328 if (info->keep_memory) 1329 default_copy = false; 1330 else 1331 default_copy = true; 1332 1333 symcount = obj_raw_syment_count (abfd); 1334 1335 /* We keep a list of the linker hash table entries that correspond 1336 to each external symbol. */ 1337 amt = symcount * sizeof (struct xcoff_link_hash_entry *); 1338 sym_hash = bfd_zalloc (abfd, amt); 1339 if (sym_hash == NULL && symcount != 0) 1340 goto error_return; 1341 coff_data (abfd)->sym_hashes = (struct coff_link_hash_entry **) sym_hash; 1342 1343 /* Because of the weird stuff we are doing with XCOFF csects, we can 1344 not easily determine which section a symbol is in, so we store 1345 the information in the tdata for the input file. */ 1346 amt = symcount * sizeof (asection *); 1347 csect_cache = bfd_zalloc (abfd, amt); 1348 if (csect_cache == NULL && symcount != 0) 1349 goto error_return; 1350 xcoff_data (abfd)->csects = csect_cache; 1351 1352 /* We garbage-collect line-number information on a symbol-by-symbol 1353 basis, so we need to have quick access to the number of entries 1354 per symbol. */ 1355 amt = symcount * sizeof (unsigned int); 1356 lineno_counts = bfd_zalloc (abfd, amt); 1357 if (lineno_counts == NULL && symcount != 0) 1358 goto error_return; 1359 xcoff_data (abfd)->lineno_counts = lineno_counts; 1360 1361 /* While splitting sections into csects, we need to assign the 1362 relocs correctly. The relocs and the csects must both be in 1363 order by VMA within a given section, so we handle this by 1364 scanning along the relocs as we process the csects. We index 1365 into reloc_info using the section target_index. */ 1366 amt = abfd->section_count + 1; 1367 amt *= sizeof (struct reloc_info_struct); 1368 reloc_info = bfd_zmalloc (amt); 1369 if (reloc_info == NULL) 1370 goto error_return; 1371 1372 /* Read in the relocs and line numbers for each section. */ 1373 linesz = bfd_coff_linesz (abfd); 1374 last_real = NULL; 1375 for (o = abfd->sections; o != NULL; o = o->next) 1376 { 1377 last_real = o; 1378 1379 if ((o->flags & SEC_RELOC) != 0) 1380 { 1381 reloc_info[o->target_index].relocs = 1382 xcoff_read_internal_relocs (abfd, o, true, NULL, false, NULL); 1383 amt = o->reloc_count; 1384 amt *= sizeof (asection *); 1385 reloc_info[o->target_index].csects = bfd_zmalloc (amt); 1386 if (reloc_info[o->target_index].csects == NULL) 1387 goto error_return; 1388 } 1389 1390 if ((info->strip == strip_none || info->strip == strip_some) 1391 && o->lineno_count > 0) 1392 { 1393 bfd_byte *linenos; 1394 1395 if (bfd_seek (abfd, o->line_filepos, SEEK_SET) != 0) 1396 goto error_return; 1397 if (_bfd_mul_overflow (linesz, o->lineno_count, &amt)) 1398 { 1399 bfd_set_error (bfd_error_file_too_big); 1400 goto error_return; 1401 } 1402 linenos = _bfd_malloc_and_read (abfd, amt, amt); 1403 if (linenos == NULL) 1404 goto error_return; 1405 reloc_info[o->target_index].linenos = linenos; 1406 } 1407 } 1408 1409 /* Don't let the linker relocation routines discard the symbols. */ 1410 obj_coff_keep_syms (abfd) = true; 1411 1412 csect = NULL; 1413 csect_index = 0; 1414 first_csect = NULL; 1415 1416 symesz = bfd_coff_symesz (abfd); 1417 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd)); 1418 esym = (bfd_byte *) obj_coff_external_syms (abfd); 1419 esym_end = esym + symcount * symesz; 1420 1421 while (esym < esym_end) 1422 { 1423 struct internal_syment sym; 1424 union internal_auxent aux; 1425 const char *name; 1426 char buf[SYMNMLEN + 1]; 1427 int smtyp; 1428 asection *section; 1429 bfd_vma value; 1430 struct xcoff_link_hash_entry *set_toc; 1431 1432 bfd_coff_swap_sym_in (abfd, (void *) esym, (void *) &sym); 1433 1434 /* In this pass we are only interested in symbols with csect 1435 information. */ 1436 if (!CSECT_SYM_P (sym.n_sclass)) 1437 { 1438 /* Set csect_cache, 1439 Normally csect is a .pr, .rw etc. created in the loop 1440 If C_FILE or first time, handle special 1441 1442 Advance esym, sym_hash, csect_hash ptrs. */ 1443 if (sym.n_sclass == C_FILE || sym.n_sclass == C_DWARF) 1444 csect = NULL; 1445 if (csect != NULL) 1446 *csect_cache = csect; 1447 else if (first_csect == NULL 1448 || sym.n_sclass == C_FILE || sym.n_sclass == C_DWARF) 1449 *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum); 1450 else 1451 *csect_cache = NULL; 1452 esym += (sym.n_numaux + 1) * symesz; 1453 sym_hash += sym.n_numaux + 1; 1454 csect_cache += sym.n_numaux + 1; 1455 lineno_counts += sym.n_numaux + 1; 1456 1457 continue; 1458 } 1459 1460 name = _bfd_coff_internal_syment_name (abfd, &sym, buf); 1461 1462 if (name == NULL) 1463 goto error_return; 1464 1465 /* If this symbol has line number information attached to it, 1466 and we're not stripping it, count the number of entries and 1467 add them to the count for this csect. In the final link pass 1468 we are going to attach line number information by symbol, 1469 rather than by section, in order to more easily handle 1470 garbage collection. */ 1471 if ((info->strip == strip_none || info->strip == strip_some) 1472 && sym.n_numaux > 1 1473 && csect != NULL 1474 && ISFCN (sym.n_type)) 1475 { 1476 union internal_auxent auxlin; 1477 1478 bfd_coff_swap_aux_in (abfd, (void *) (esym + symesz), 1479 sym.n_type, sym.n_sclass, 1480 0, sym.n_numaux, (void *) &auxlin); 1481 1482 if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0) 1483 { 1484 asection *enclosing; 1485 bfd_signed_vma linoff; 1486 1487 enclosing = xcoff_section_data (abfd, csect)->enclosing; 1488 if (enclosing == NULL) 1489 { 1490 _bfd_error_handler 1491 /* xgettext:c-format */ 1492 (_("%pB: `%s' has line numbers but no enclosing section"), 1493 abfd, name); 1494 bfd_set_error (bfd_error_bad_value); 1495 goto error_return; 1496 } 1497 linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr 1498 - enclosing->line_filepos); 1499 /* Explicit cast to bfd_signed_vma for compiler. */ 1500 if (linoff < (bfd_signed_vma) (enclosing->lineno_count * linesz)) 1501 { 1502 struct internal_lineno lin; 1503 bfd_byte *linpstart; 1504 1505 linpstart = (reloc_info[enclosing->target_index].linenos 1506 + linoff); 1507 bfd_coff_swap_lineno_in (abfd, (void *) linpstart, (void *) &lin); 1508 if (lin.l_lnno == 0 1509 && ((bfd_size_type) lin.l_addr.l_symndx 1510 == ((esym 1511 - (bfd_byte *) obj_coff_external_syms (abfd)) 1512 / symesz))) 1513 { 1514 bfd_byte *linpend, *linp; 1515 1516 linpend = (reloc_info[enclosing->target_index].linenos 1517 + enclosing->lineno_count * linesz); 1518 for (linp = linpstart + linesz; 1519 linp < linpend; 1520 linp += linesz) 1521 { 1522 bfd_coff_swap_lineno_in (abfd, (void *) linp, 1523 (void *) &lin); 1524 if (lin.l_lnno == 0) 1525 break; 1526 } 1527 *lineno_counts = (linp - linpstart) / linesz; 1528 /* The setting of line_filepos will only be 1529 useful if all the line number entries for a 1530 csect are contiguous; this only matters for 1531 error reporting. */ 1532 if (csect->line_filepos == 0) 1533 csect->line_filepos = 1534 auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr; 1535 } 1536 } 1537 } 1538 } 1539 1540 /* Record visibility. */ 1541 visibility = sym.n_type & SYM_V_MASK; 1542 1543 /* Pick up the csect auxiliary information. */ 1544 if (sym.n_numaux == 0) 1545 { 1546 _bfd_error_handler 1547 /* xgettext:c-format */ 1548 (_("%pB: class %d symbol `%s' has no aux entries"), 1549 abfd, sym.n_sclass, name); 1550 bfd_set_error (bfd_error_bad_value); 1551 goto error_return; 1552 } 1553 1554 bfd_coff_swap_aux_in (abfd, 1555 (void *) (esym + symesz * sym.n_numaux), 1556 sym.n_type, sym.n_sclass, 1557 sym.n_numaux - 1, sym.n_numaux, 1558 (void *) &aux); 1559 1560 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp); 1561 1562 section = NULL; 1563 value = 0; 1564 set_toc = NULL; 1565 1566 switch (smtyp) 1567 { 1568 default: 1569 _bfd_error_handler 1570 /* xgettext:c-format */ 1571 (_("%pB: symbol `%s' has unrecognized csect type %d"), 1572 abfd, name, smtyp); 1573 bfd_set_error (bfd_error_bad_value); 1574 goto error_return; 1575 1576 case XTY_ER: 1577 /* This is an external reference. */ 1578 if (sym.n_sclass == C_HIDEXT 1579 || sym.n_scnum != N_UNDEF 1580 || aux.x_csect.x_scnlen.u64 != 0) 1581 { 1582 _bfd_error_handler 1583 /* xgettext:c-format */ 1584 (_("%pB: bad XTY_ER symbol `%s': class %d scnum %d " 1585 "scnlen %" PRId64), 1586 abfd, name, sym.n_sclass, sym.n_scnum, 1587 aux.x_csect.x_scnlen.u64); 1588 bfd_set_error (bfd_error_bad_value); 1589 goto error_return; 1590 } 1591 1592 /* An XMC_XO external reference is actually a reference to 1593 an absolute location. */ 1594 if (aux.x_csect.x_smclas != XMC_XO) 1595 section = bfd_und_section_ptr; 1596 else 1597 { 1598 section = bfd_abs_section_ptr; 1599 value = sym.n_value; 1600 } 1601 break; 1602 1603 case XTY_SD: 1604 csect = NULL; 1605 csect_index = -(unsigned) 1; 1606 1607 /* When we see a TOC anchor, we record the TOC value. */ 1608 if (aux.x_csect.x_smclas == XMC_TC0) 1609 { 1610 if (sym.n_sclass != C_HIDEXT 1611 || aux.x_csect.x_scnlen.u64 != 0) 1612 { 1613 _bfd_error_handler 1614 /* xgettext:c-format */ 1615 (_("%pB: XMC_TC0 symbol `%s' is class %d scnlen %" PRIu64), 1616 abfd, name, sym.n_sclass, aux.x_csect.x_scnlen.u64); 1617 bfd_set_error (bfd_error_bad_value); 1618 goto error_return; 1619 } 1620 xcoff_data (abfd)->toc = sym.n_value; 1621 } 1622 1623 /* We must merge TOC entries for the same symbol. We can 1624 merge two TOC entries if they are both C_HIDEXT, they 1625 both have the same name, they are both 4 or 8 bytes long, and 1626 they both have a relocation table entry for an external 1627 symbol with the same name. Unfortunately, this means 1628 that we must look through the relocations. Ick. 1629 1630 Logic for 32 bit vs 64 bit. 1631 32 bit has a csect length of 4 for TOC 1632 64 bit has a csect length of 8 for TOC 1633 1634 An exception is made for TOC entries with a R_TLSML 1635 relocation. This relocation is made for the loader. 1636 We must check that the referenced symbol is the TOC entry 1637 itself. 1638 1639 The conditions to get past the if-check are not that bad. 1640 They are what is used to create the TOC csects in the first 1641 place. */ 1642 if (aux.x_csect.x_smclas == XMC_TC 1643 && sym.n_sclass == C_HIDEXT 1644 && info->output_bfd->xvec == abfd->xvec 1645 && ((bfd_xcoff_is_xcoff32 (abfd) 1646 && aux.x_csect.x_scnlen.u64 == 4) 1647 || (bfd_xcoff_is_xcoff64 (abfd) 1648 && aux.x_csect.x_scnlen.u64 == 8))) 1649 { 1650 asection *enclosing; 1651 struct internal_reloc *relocs; 1652 bfd_size_type relindx; 1653 struct internal_reloc *rel; 1654 1655 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum); 1656 if (enclosing == NULL) 1657 goto error_return; 1658 1659 relocs = reloc_info[enclosing->target_index].relocs; 1660 amt = enclosing->reloc_count; 1661 relindx = xcoff_find_reloc (relocs, amt, sym.n_value); 1662 rel = relocs + relindx; 1663 1664 /* 32 bit R_POS r_size is 31 1665 64 bit R_POS r_size is 63 */ 1666 if (relindx < enclosing->reloc_count 1667 && rel->r_vaddr == (bfd_vma) sym.n_value 1668 && (rel->r_type == R_POS || 1669 rel->r_type == R_TLSML) 1670 && ((bfd_xcoff_is_xcoff32 (abfd) 1671 && rel->r_size == 31) 1672 || (bfd_xcoff_is_xcoff64 (abfd) 1673 && rel->r_size == 63))) 1674 { 1675 bfd_byte *erelsym; 1676 1677 struct internal_syment relsym; 1678 1679 erelsym = ((bfd_byte *) obj_coff_external_syms (abfd) 1680 + rel->r_symndx * symesz); 1681 bfd_coff_swap_sym_in (abfd, (void *) erelsym, (void *) &relsym); 1682 if (EXTERN_SYM_P (relsym.n_sclass)) 1683 { 1684 const char *relname; 1685 char relbuf[SYMNMLEN + 1]; 1686 bool copy; 1687 struct xcoff_link_hash_entry *h; 1688 1689 /* At this point we know that the TOC entry is 1690 for an externally visible symbol. */ 1691 relname = _bfd_coff_internal_syment_name (abfd, &relsym, 1692 relbuf); 1693 if (relname == NULL) 1694 goto error_return; 1695 1696 /* We only merge TOC entries if the TC name is 1697 the same as the symbol name. This handles 1698 the normal case, but not common cases like 1699 SYM.P4 which gcc generates to store SYM + 4 1700 in the TOC. FIXME. */ 1701 if (strcmp (name, relname) == 0) 1702 { 1703 copy = (! info->keep_memory 1704 || relsym._n._n_n._n_zeroes != 0 1705 || relsym._n._n_n._n_offset == 0); 1706 h = xcoff_link_hash_lookup (xcoff_hash_table (info), 1707 relname, true, copy, 1708 false); 1709 if (h == NULL) 1710 goto error_return; 1711 1712 /* At this point h->root.type could be 1713 bfd_link_hash_new. That should be OK, 1714 since we know for sure that we will come 1715 across this symbol as we step through the 1716 file. */ 1717 1718 /* We store h in *sym_hash for the 1719 convenience of the relocate_section 1720 function. */ 1721 *sym_hash = h; 1722 1723 if (h->toc_section != NULL) 1724 { 1725 asection **rel_csects; 1726 1727 /* We already have a TOC entry for this 1728 symbol, so we can just ignore this 1729 one. */ 1730 rel_csects = 1731 reloc_info[enclosing->target_index].csects; 1732 rel_csects[relindx] = bfd_und_section_ptr; 1733 break; 1734 } 1735 1736 /* We are about to create a TOC entry for 1737 this symbol. */ 1738 set_toc = h; 1739 } 1740 } 1741 else if (rel->r_type == R_TLSML) 1742 { 1743 csect_index = ((esym 1744 - (bfd_byte *) obj_coff_external_syms (abfd)) 1745 / symesz); 1746 if (((unsigned long) rel->r_symndx) != csect_index) 1747 { 1748 _bfd_error_handler 1749 /* xgettext:c-format */ 1750 (_("%pB: TOC entry `%s' has a R_TLSML" 1751 "relocation not targeting itself"), 1752 abfd, name); 1753 bfd_set_error (bfd_error_bad_value); 1754 goto error_return; 1755 } 1756 } 1757 } 1758 } 1759 1760 { 1761 asection *enclosing; 1762 1763 /* We need to create a new section. We get the name from 1764 the csect storage mapping class, so that the linker can 1765 accumulate similar csects together. */ 1766 1767 csect = bfd_xcoff_create_csect_from_smclas(abfd, &aux, name); 1768 if (NULL == csect) 1769 goto error_return; 1770 1771 /* The enclosing section is the main section : .data, .text 1772 or .bss that the csect is coming from. */ 1773 enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum); 1774 if (enclosing == NULL) 1775 goto error_return; 1776 1777 if (! bfd_is_abs_section (enclosing) 1778 && ((bfd_vma) sym.n_value < enclosing->vma 1779 || (sym.n_value + aux.x_csect.x_scnlen.u64 1780 > enclosing->vma + enclosing->size))) 1781 { 1782 _bfd_error_handler 1783 /* xgettext:c-format */ 1784 (_("%pB: csect `%s' not in enclosing section"), 1785 abfd, name); 1786 bfd_set_error (bfd_error_bad_value); 1787 goto error_return; 1788 } 1789 csect->vma = sym.n_value; 1790 csect->filepos = (enclosing->filepos 1791 + sym.n_value 1792 - enclosing->vma); 1793 csect->size = aux.x_csect.x_scnlen.u64; 1794 csect->rawsize = aux.x_csect.x_scnlen.u64; 1795 csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS; 1796 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp); 1797 1798 /* Record the enclosing section in the tdata for this new 1799 section. */ 1800 amt = sizeof (struct coff_section_tdata); 1801 csect->used_by_bfd = bfd_zalloc (abfd, amt); 1802 if (csect->used_by_bfd == NULL) 1803 goto error_return; 1804 amt = sizeof (struct xcoff_section_tdata); 1805 coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt); 1806 if (coff_section_data (abfd, csect)->tdata == NULL) 1807 goto error_return; 1808 xcoff_section_data (abfd, csect)->enclosing = enclosing; 1809 xcoff_section_data (abfd, csect)->lineno_count = 1810 enclosing->lineno_count; 1811 1812 if (enclosing->owner == abfd) 1813 { 1814 struct internal_reloc *relocs; 1815 bfd_size_type relindx; 1816 struct internal_reloc *rel; 1817 asection **rel_csect; 1818 1819 relocs = reloc_info[enclosing->target_index].relocs; 1820 amt = enclosing->reloc_count; 1821 relindx = xcoff_find_reloc (relocs, amt, csect->vma); 1822 1823 rel = relocs + relindx; 1824 rel_csect = (reloc_info[enclosing->target_index].csects 1825 + relindx); 1826 1827 csect->rel_filepos = (enclosing->rel_filepos 1828 + relindx * bfd_coff_relsz (abfd)); 1829 while (relindx < enclosing->reloc_count 1830 && *rel_csect == NULL 1831 && rel->r_vaddr < csect->vma + csect->size) 1832 { 1833 1834 *rel_csect = csect; 1835 csect->flags |= SEC_RELOC; 1836 ++csect->reloc_count; 1837 ++relindx; 1838 ++rel; 1839 ++rel_csect; 1840 } 1841 } 1842 1843 /* There are a number of other fields and section flags 1844 which we do not bother to set. */ 1845 1846 csect_index = ((esym 1847 - (bfd_byte *) obj_coff_external_syms (abfd)) 1848 / symesz); 1849 1850 xcoff_section_data (abfd, csect)->first_symndx = csect_index; 1851 1852 if (first_csect == NULL) 1853 first_csect = csect; 1854 1855 /* If this symbol must be added to the linker hash table, 1856 we treat it as starting at the beginning of the newly 1857 created section. */ 1858 if (xcoff_link_add_symbols_to_hash_table (sym, aux)) 1859 { 1860 section = csect; 1861 value = 0; 1862 } 1863 1864 /* If this is a TOC section for a symbol, record it. */ 1865 if (set_toc != NULL) 1866 set_toc->toc_section = csect; 1867 } 1868 break; 1869 1870 case XTY_LD: 1871 /* This is a label definition. The x_scnlen field is the 1872 symbol index of the csect. Usually the XTY_LD symbol will 1873 follow its appropriate XTY_SD symbol. The .set pseudo op can 1874 cause the XTY_LD to not follow the XTY_SD symbol. */ 1875 { 1876 bool bad; 1877 1878 bad = false; 1879 if (aux.x_csect.x_scnlen.u64 1880 >= (size_t) (esym - (bfd_byte *) obj_coff_external_syms (abfd))) 1881 bad = true; 1882 if (! bad) 1883 { 1884 section = xcoff_data (abfd)->csects[aux.x_csect.x_scnlen.u64]; 1885 if (section == NULL 1886 || (section->flags & SEC_HAS_CONTENTS) == 0) 1887 bad = true; 1888 } 1889 if (bad) 1890 { 1891 _bfd_error_handler 1892 /* xgettext:c-format */ 1893 (_("%pB: misplaced XTY_LD `%s'"), 1894 abfd, name); 1895 bfd_set_error (bfd_error_bad_value); 1896 goto error_return; 1897 } 1898 csect = section; 1899 value = sym.n_value - csect->vma; 1900 } 1901 break; 1902 1903 case XTY_CM: 1904 /* This is an unitialized csect. We could base the name on 1905 the storage mapping class, but we don't bother except for 1906 an XMC_TD symbol. If this csect is externally visible, 1907 it is a common symbol. We put XMC_TD symbols in sections 1908 named .tocbss, and rely on the linker script to put that 1909 in the TOC area. */ 1910 1911 if (aux.x_csect.x_smclas == XMC_TD) 1912 { 1913 /* The linker script puts the .td section in the data 1914 section after the .tc section. */ 1915 csect = bfd_make_section_anyway_with_flags (abfd, ".td", 1916 SEC_ALLOC); 1917 } 1918 else if (aux.x_csect.x_smclas == XMC_UL) 1919 { 1920 /* This is a thread-local unitialized csect. */ 1921 csect = bfd_make_section_anyway_with_flags (abfd, ".tbss", 1922 SEC_ALLOC | SEC_THREAD_LOCAL); 1923 } 1924 else 1925 csect = bfd_make_section_anyway_with_flags (abfd, ".bss", 1926 SEC_ALLOC); 1927 1928 if (csect == NULL) 1929 goto error_return; 1930 csect->vma = sym.n_value; 1931 csect->size = aux.x_csect.x_scnlen.u64; 1932 csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp); 1933 /* There are a number of other fields and section flags 1934 which we do not bother to set. */ 1935 1936 csect_index = ((esym 1937 - (bfd_byte *) obj_coff_external_syms (abfd)) 1938 / symesz); 1939 1940 amt = sizeof (struct coff_section_tdata); 1941 csect->used_by_bfd = bfd_zalloc (abfd, amt); 1942 if (csect->used_by_bfd == NULL) 1943 goto error_return; 1944 amt = sizeof (struct xcoff_section_tdata); 1945 coff_section_data (abfd, csect)->tdata = bfd_zalloc (abfd, amt); 1946 if (coff_section_data (abfd, csect)->tdata == NULL) 1947 goto error_return; 1948 xcoff_section_data (abfd, csect)->first_symndx = csect_index; 1949 1950 if (first_csect == NULL) 1951 first_csect = csect; 1952 1953 if (xcoff_link_add_symbols_to_hash_table (sym, aux)) 1954 { 1955 csect->flags |= SEC_IS_COMMON; 1956 csect->size = 0; 1957 section = csect; 1958 value = aux.x_csect.x_scnlen.u64; 1959 } 1960 1961 break; 1962 } 1963 1964 /* Check for magic symbol names. */ 1965 if ((smtyp == XTY_SD || smtyp == XTY_CM) 1966 && aux.x_csect.x_smclas != XMC_TC 1967 && aux.x_csect.x_smclas != XMC_TD) 1968 { 1969 int i = -1; 1970 1971 if (name[0] == '_') 1972 { 1973 if (strcmp (name, "_text") == 0) 1974 i = XCOFF_SPECIAL_SECTION_TEXT; 1975 else if (strcmp (name, "_etext") == 0) 1976 i = XCOFF_SPECIAL_SECTION_ETEXT; 1977 else if (strcmp (name, "_data") == 0) 1978 i = XCOFF_SPECIAL_SECTION_DATA; 1979 else if (strcmp (name, "_edata") == 0) 1980 i = XCOFF_SPECIAL_SECTION_EDATA; 1981 else if (strcmp (name, "_end") == 0) 1982 i = XCOFF_SPECIAL_SECTION_END; 1983 } 1984 else if (name[0] == 'e' && strcmp (name, "end") == 0) 1985 i = XCOFF_SPECIAL_SECTION_END2; 1986 1987 if (i != -1) 1988 xcoff_hash_table (info)->special_sections[i] = csect; 1989 } 1990 1991 /* Now we have enough information to add the symbol to the 1992 linker hash table. */ 1993 1994 if (xcoff_link_add_symbols_to_hash_table (sym, aux)) 1995 { 1996 bool copy, ok; 1997 flagword flags; 1998 1999 BFD_ASSERT (section != NULL); 2000 2001 /* We must copy the name into memory if we got it from the 2002 syment itself, rather than the string table. */ 2003 copy = default_copy; 2004 if (sym._n._n_n._n_zeroes != 0 2005 || sym._n._n_n._n_offset == 0) 2006 copy = true; 2007 2008 /* Ignore global linkage code when linking statically. */ 2009 if (info->static_link 2010 && (smtyp == XTY_SD || smtyp == XTY_LD) 2011 && aux.x_csect.x_smclas == XMC_GL) 2012 { 2013 section = bfd_und_section_ptr; 2014 value = 0; 2015 } 2016 2017 /* The AIX linker appears to only detect multiple symbol 2018 definitions when there is a reference to the symbol. If 2019 a symbol is defined multiple times, and the only 2020 references are from the same object file, the AIX linker 2021 appears to permit it. It does not merge the different 2022 definitions, but handles them independently. On the 2023 other hand, if there is a reference, the linker reports 2024 an error. 2025 2026 This matters because the AIX <net/net_globals.h> header 2027 file actually defines an initialized array, so we have to 2028 actually permit that to work. 2029 2030 Just to make matters even more confusing, the AIX linker 2031 appears to permit multiple symbol definitions whenever 2032 the second definition is in an archive rather than an 2033 object file. This may be a consequence of the manner in 2034 which it handles archives: I think it may load the entire 2035 archive in as separate csects, and then let garbage 2036 collection discard symbols. 2037 2038 We also have to handle the case of statically linking a 2039 shared object, which will cause symbol redefinitions, 2040 although this is an easier case to detect. */ 2041 else if (info->output_bfd->xvec == abfd->xvec) 2042 { 2043 if (! bfd_is_und_section (section)) 2044 *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info), 2045 name, true, copy, false); 2046 else 2047 /* Make a copy of the symbol name to prevent problems with 2048 merging symbols. */ 2049 *sym_hash = ((struct xcoff_link_hash_entry *) 2050 bfd_wrapped_link_hash_lookup (abfd, info, name, 2051 true, true, false)); 2052 2053 if (*sym_hash == NULL) 2054 goto error_return; 2055 if (((*sym_hash)->root.type == bfd_link_hash_defined 2056 || (*sym_hash)->root.type == bfd_link_hash_defweak) 2057 && ! bfd_is_und_section (section) 2058 && ! bfd_is_com_section (section)) 2059 { 2060 /* This is a second definition of a defined symbol. */ 2061 if (((*sym_hash)->flags & XCOFF_DEF_REGULAR) == 0 2062 && ((*sym_hash)->flags & XCOFF_DEF_DYNAMIC) != 0) 2063 { 2064 /* The existing symbol is from a shared library. 2065 Replace it. */ 2066 (*sym_hash)->root.type = bfd_link_hash_undefined; 2067 (*sym_hash)->root.u.undef.abfd = 2068 (*sym_hash)->root.u.def.section->owner; 2069 } 2070 else if (abfd->my_archive != NULL) 2071 { 2072 /* This is a redefinition in an object contained 2073 in an archive. Just ignore it. See the 2074 comment above. */ 2075 section = bfd_und_section_ptr; 2076 value = 0; 2077 } 2078 else if (sym.n_sclass == C_AIX_WEAKEXT 2079 || (*sym_hash)->root.type == bfd_link_hash_defweak) 2080 { 2081 /* At least one of the definitions is weak. 2082 Allow the normal rules to take effect. */ 2083 } 2084 else if ((*sym_hash)->root.u.undef.next != NULL 2085 || info->hash->undefs_tail == &(*sym_hash)->root) 2086 { 2087 /* This symbol has been referenced. In this 2088 case, we just continue and permit the 2089 multiple definition error. See the comment 2090 above about the behaviour of the AIX linker. */ 2091 } 2092 else if ((*sym_hash)->smclas == aux.x_csect.x_smclas) 2093 { 2094 /* The symbols are both csects of the same 2095 class. There is at least a chance that this 2096 is a semi-legitimate redefinition. */ 2097 section = bfd_und_section_ptr; 2098 value = 0; 2099 (*sym_hash)->flags |= XCOFF_MULTIPLY_DEFINED; 2100 } 2101 } 2102 else if (((*sym_hash)->flags & XCOFF_MULTIPLY_DEFINED) != 0 2103 && (*sym_hash)->root.type == bfd_link_hash_defined 2104 && (bfd_is_und_section (section) 2105 || bfd_is_com_section (section))) 2106 { 2107 /* This is a reference to a multiply defined symbol. 2108 Report the error now. See the comment above 2109 about the behaviour of the AIX linker. We could 2110 also do this with warning symbols, but I'm not 2111 sure the XCOFF linker is wholly prepared to 2112 handle them, and that would only be a warning, 2113 not an error. */ 2114 (*info->callbacks->multiple_definition) (info, 2115 &(*sym_hash)->root, 2116 NULL, NULL, 2117 (bfd_vma) 0); 2118 /* Try not to give this error too many times. */ 2119 (*sym_hash)->flags &= ~XCOFF_MULTIPLY_DEFINED; 2120 } 2121 2122 2123 /* If the symbol is hidden or internal, completely undo 2124 any dynamic link state. */ 2125 if ((*sym_hash)->flags & XCOFF_DEF_DYNAMIC 2126 && (visibility == SYM_V_HIDDEN 2127 || visibility == SYM_V_INTERNAL)) 2128 (*sym_hash)->flags &= ~XCOFF_DEF_DYNAMIC; 2129 else 2130 { 2131 /* Keep the most constraining visibility. */ 2132 unsigned short hvis = (*sym_hash)->visibility; 2133 if (visibility && ( !hvis || visibility < hvis)) 2134 (*sym_hash)->visibility = visibility; 2135 } 2136 2137 } 2138 2139 /* _bfd_generic_link_add_one_symbol may call the linker to 2140 generate an error message, and the linker may try to read 2141 the symbol table to give a good error. Right now, the 2142 line numbers are in an inconsistent state, since they are 2143 counted both in the real sections and in the new csects. 2144 We need to leave the count in the real sections so that 2145 the linker can report the line number of the error 2146 correctly, so temporarily clobber the link to the csects 2147 so that the linker will not try to read the line numbers 2148 a second time from the csects. */ 2149 BFD_ASSERT (last_real->next == first_csect); 2150 last_real->next = NULL; 2151 flags = (sym.n_sclass == C_EXT ? BSF_GLOBAL : BSF_WEAK); 2152 ok = (_bfd_generic_link_add_one_symbol 2153 (info, abfd, name, flags, section, value, NULL, copy, true, 2154 (struct bfd_link_hash_entry **) sym_hash)); 2155 last_real->next = first_csect; 2156 if (!ok) 2157 goto error_return; 2158 2159 if (smtyp == XTY_CM) 2160 { 2161 if ((*sym_hash)->root.type != bfd_link_hash_common 2162 || (*sym_hash)->root.u.c.p->section != csect) 2163 /* We don't need the common csect we just created. */ 2164 csect->size = 0; 2165 else 2166 (*sym_hash)->root.u.c.p->alignment_power 2167 = csect->alignment_power; 2168 } 2169 2170 if (info->output_bfd->xvec == abfd->xvec) 2171 { 2172 int flag; 2173 2174 if (smtyp == XTY_ER 2175 || smtyp == XTY_CM 2176 || section == bfd_und_section_ptr) 2177 flag = XCOFF_REF_REGULAR; 2178 else 2179 flag = XCOFF_DEF_REGULAR; 2180 (*sym_hash)->flags |= flag; 2181 2182 if ((*sym_hash)->smclas == XMC_UA 2183 || flag == XCOFF_DEF_REGULAR) 2184 (*sym_hash)->smclas = aux.x_csect.x_smclas; 2185 } 2186 } 2187 2188 if (smtyp == XTY_ER) 2189 *csect_cache = section; 2190 else 2191 { 2192 *csect_cache = csect; 2193 if (csect != NULL) 2194 xcoff_section_data (abfd, csect)->last_symndx 2195 = (esym - (bfd_byte *) obj_coff_external_syms (abfd)) / symesz; 2196 } 2197 2198 esym += (sym.n_numaux + 1) * symesz; 2199 sym_hash += sym.n_numaux + 1; 2200 csect_cache += sym.n_numaux + 1; 2201 lineno_counts += sym.n_numaux + 1; 2202 } 2203 2204 BFD_ASSERT (last_real == NULL || last_real->next == first_csect); 2205 2206 /* Make sure that we have seen all the relocs. */ 2207 for (o = abfd->sections; o != first_csect; o = o->next) 2208 { 2209 /* Debugging sections have no csects. */ 2210 if (bfd_section_flags (o) & SEC_DEBUGGING) 2211 continue; 2212 2213 /* Reset the section size and the line number count, since the 2214 data is now attached to the csects. Don't reset the size of 2215 the .debug section, since we need to read it below in 2216 bfd_xcoff_size_dynamic_sections. */ 2217 if (strcmp (bfd_section_name (o), ".debug") != 0) 2218 o->size = 0; 2219 o->lineno_count = 0; 2220 2221 if ((o->flags & SEC_RELOC) != 0) 2222 { 2223 bfd_size_type i; 2224 struct internal_reloc *rel; 2225 asection **rel_csect; 2226 2227 rel = reloc_info[o->target_index].relocs; 2228 rel_csect = reloc_info[o->target_index].csects; 2229 2230 for (i = 0; i < o->reloc_count; i++, rel++, rel_csect++) 2231 { 2232 if (*rel_csect == NULL) 2233 { 2234 _bfd_error_handler 2235 /* xgettext:c-format */ 2236 (_("%pB: reloc %s:%" PRId64 " not in csect"), 2237 abfd, o->name, (int64_t) i); 2238 bfd_set_error (bfd_error_bad_value); 2239 goto error_return; 2240 } 2241 2242 /* We identify all function symbols that are the target 2243 of a relocation, so that we can create glue code for 2244 functions imported from dynamic objects. */ 2245 if (info->output_bfd->xvec == abfd->xvec 2246 && *rel_csect != bfd_und_section_ptr 2247 && obj_xcoff_sym_hashes (abfd)[rel->r_symndx] != NULL) 2248 { 2249 struct xcoff_link_hash_entry *h; 2250 2251 h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx]; 2252 /* If the symbol name starts with a period, it is 2253 the code of a function. If the symbol is 2254 currently undefined, then add an undefined symbol 2255 for the function descriptor. This should do no 2256 harm, because any regular object that defines the 2257 function should also define the function 2258 descriptor. It helps, because it means that we 2259 will identify the function descriptor with a 2260 dynamic object if a dynamic object defines it. */ 2261 if (h->root.root.string[0] == '.' 2262 && h->descriptor == NULL) 2263 { 2264 struct xcoff_link_hash_entry *hds; 2265 struct bfd_link_hash_entry *bh; 2266 2267 hds = xcoff_link_hash_lookup (xcoff_hash_table (info), 2268 h->root.root.string + 1, 2269 true, false, true); 2270 if (hds == NULL) 2271 goto error_return; 2272 if (hds->root.type == bfd_link_hash_new) 2273 { 2274 bh = &hds->root; 2275 if (! (_bfd_generic_link_add_one_symbol 2276 (info, abfd, hds->root.root.string, 2277 (flagword) 0, bfd_und_section_ptr, 2278 (bfd_vma) 0, NULL, false, 2279 true, &bh))) 2280 goto error_return; 2281 hds = (struct xcoff_link_hash_entry *) bh; 2282 } 2283 hds->flags |= XCOFF_DESCRIPTOR; 2284 BFD_ASSERT ((h->flags & XCOFF_DESCRIPTOR) == 0); 2285 hds->descriptor = h; 2286 h->descriptor = hds; 2287 } 2288 if (h->root.root.string[0] == '.') 2289 h->flags |= XCOFF_CALLED; 2290 } 2291 } 2292 2293 free (reloc_info[o->target_index].csects); 2294 reloc_info[o->target_index].csects = NULL; 2295 2296 /* Reset SEC_RELOC and the reloc_count, since the reloc 2297 information is now attached to the csects. */ 2298 o->flags &=~ SEC_RELOC; 2299 o->reloc_count = 0; 2300 2301 /* If we are not keeping memory, free the reloc information. */ 2302 if (! info->keep_memory 2303 && coff_section_data (abfd, o) != NULL) 2304 { 2305 free (coff_section_data (abfd, o)->relocs); 2306 coff_section_data (abfd, o)->relocs = NULL; 2307 } 2308 } 2309 2310 /* Free up the line numbers. FIXME: We could cache these 2311 somewhere for the final link, to avoid reading them again. */ 2312 free (reloc_info[o->target_index].linenos); 2313 reloc_info[o->target_index].linenos = NULL; 2314 } 2315 2316 free (reloc_info); 2317 2318 obj_coff_keep_syms (abfd) = keep_syms; 2319 2320 return true; 2321 2322 error_return: 2323 if (reloc_info != NULL) 2324 { 2325 for (o = abfd->sections; o != NULL; o = o->next) 2326 { 2327 free (reloc_info[o->target_index].csects); 2328 free (reloc_info[o->target_index].linenos); 2329 } 2330 free (reloc_info); 2331 } 2332 obj_coff_keep_syms (abfd) = keep_syms; 2333 return false; 2334 } 2335 2336 #undef N_TMASK 2337 #undef N_BTSHFT 2338 2339 /* Add symbols from an XCOFF object file. */ 2340 2341 static bool 2342 xcoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 2343 { 2344 if (! _bfd_coff_get_external_symbols (abfd)) 2345 return false; 2346 if (! xcoff_link_add_symbols (abfd, info)) 2347 return false; 2348 if (! info->keep_memory) 2349 { 2350 if (! _bfd_coff_free_symbols (abfd)) 2351 return false; 2352 } 2353 return true; 2354 } 2355 2356 /* Look through the loader symbols to see if this dynamic object 2357 should be included in the link. The native linker uses the loader 2358 symbols, not the normal symbol table, so we do too. */ 2359 2360 static bool 2361 xcoff_link_check_dynamic_ar_symbols (bfd *abfd, 2362 struct bfd_link_info *info, 2363 bool *pneeded, 2364 bfd **subsbfd) 2365 { 2366 asection *lsec; 2367 bfd_byte *contents; 2368 struct internal_ldhdr ldhdr; 2369 const char *strings; 2370 bfd_byte *elsym, *elsymend; 2371 2372 *pneeded = false; 2373 2374 lsec = bfd_get_section_by_name (abfd, ".loader"); 2375 if (lsec == NULL || (lsec->flags & SEC_HAS_CONTENTS) == 0) 2376 /* There are no symbols, so don't try to include it. */ 2377 return true; 2378 2379 contents = xcoff_get_section_contents (abfd, lsec); 2380 if (!contents) 2381 return false; 2382 2383 bfd_xcoff_swap_ldhdr_in (abfd, contents, &ldhdr); 2384 2385 strings = (char *) contents + ldhdr.l_stoff; 2386 2387 elsym = contents + bfd_xcoff_loader_symbol_offset (abfd, &ldhdr); 2388 2389 elsymend = elsym + ldhdr.l_nsyms * bfd_xcoff_ldsymsz (abfd); 2390 for (; elsym < elsymend; elsym += bfd_xcoff_ldsymsz (abfd)) 2391 { 2392 struct internal_ldsym ldsym; 2393 char nambuf[SYMNMLEN + 1]; 2394 const char *name; 2395 struct bfd_link_hash_entry *h; 2396 2397 bfd_xcoff_swap_ldsym_in (abfd, elsym, &ldsym); 2398 2399 /* We are only interested in exported symbols. */ 2400 if ((ldsym.l_smtype & L_EXPORT) == 0) 2401 continue; 2402 2403 if (ldsym._l._l_l._l_zeroes == 0) 2404 name = strings + ldsym._l._l_l._l_offset; 2405 else 2406 { 2407 memcpy (nambuf, ldsym._l._l_name, SYMNMLEN); 2408 nambuf[SYMNMLEN] = '\0'; 2409 name = nambuf; 2410 } 2411 2412 h = bfd_link_hash_lookup (info->hash, name, false, false, true); 2413 2414 /* We are only interested in symbols that are currently 2415 undefined. At this point we know that we are using an XCOFF 2416 hash table. */ 2417 if (h != NULL 2418 && h->type == bfd_link_hash_undefined 2419 && (((struct xcoff_link_hash_entry *) h)->flags 2420 & XCOFF_DEF_DYNAMIC) == 0) 2421 { 2422 if (!(*info->callbacks 2423 ->add_archive_element) (info, abfd, name, subsbfd)) 2424 continue; 2425 *pneeded = true; 2426 return true; 2427 } 2428 } 2429 2430 /* We do not need this shared object's .loader section. */ 2431 free (contents); 2432 coff_section_data (abfd, lsec)->contents = NULL; 2433 2434 return true; 2435 } 2436 2437 /* Look through the symbols to see if this object file should be 2438 included in the link. */ 2439 2440 static bool 2441 xcoff_link_check_ar_symbols (bfd *abfd, 2442 struct bfd_link_info *info, 2443 bool *pneeded, 2444 bfd **subsbfd) 2445 { 2446 bfd_size_type symesz; 2447 bfd_byte *esym; 2448 bfd_byte *esym_end; 2449 2450 *pneeded = false; 2451 2452 if ((abfd->flags & DYNAMIC) != 0 2453 && ! info->static_link 2454 && info->output_bfd->xvec == abfd->xvec) 2455 return xcoff_link_check_dynamic_ar_symbols (abfd, info, pneeded, subsbfd); 2456 2457 symesz = bfd_coff_symesz (abfd); 2458 esym = (bfd_byte *) obj_coff_external_syms (abfd); 2459 esym_end = esym + obj_raw_syment_count (abfd) * symesz; 2460 while (esym < esym_end) 2461 { 2462 struct internal_syment sym; 2463 2464 bfd_coff_swap_sym_in (abfd, (void *) esym, (void *) &sym); 2465 esym += (sym.n_numaux + 1) * symesz; 2466 2467 if (EXTERN_SYM_P (sym.n_sclass) && sym.n_scnum != N_UNDEF) 2468 { 2469 const char *name; 2470 char buf[SYMNMLEN + 1]; 2471 struct bfd_link_hash_entry *h; 2472 2473 /* This symbol is externally visible, and is defined by this 2474 object file. */ 2475 name = _bfd_coff_internal_syment_name (abfd, &sym, buf); 2476 2477 if (name == NULL) 2478 return false; 2479 h = bfd_link_hash_lookup (info->hash, name, false, false, true); 2480 2481 /* We are only interested in symbols that are currently 2482 undefined. If a symbol is currently known to be common, 2483 XCOFF linkers do not bring in an object file which 2484 defines it. We also don't bring in symbols to satisfy 2485 undefined references in shared objects. */ 2486 if (h != NULL 2487 && h->type == bfd_link_hash_undefined 2488 && (info->output_bfd->xvec != abfd->xvec 2489 || (((struct xcoff_link_hash_entry *) h)->flags 2490 & XCOFF_DEF_DYNAMIC) == 0)) 2491 { 2492 if (!(*info->callbacks 2493 ->add_archive_element) (info, abfd, name, subsbfd)) 2494 continue; 2495 *pneeded = true; 2496 return true; 2497 } 2498 } 2499 } 2500 2501 /* We do not need this object file. */ 2502 return true; 2503 } 2504 2505 /* Check a single archive element to see if we need to include it in 2506 the link. *PNEEDED is set according to whether this element is 2507 needed in the link or not. This is called via 2508 _bfd_generic_link_add_archive_symbols. */ 2509 2510 static bool 2511 xcoff_link_check_archive_element (bfd *abfd, 2512 struct bfd_link_info *info, 2513 struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED, 2514 const char *name ATTRIBUTE_UNUSED, 2515 bool *pneeded) 2516 { 2517 bool keep_syms_p; 2518 bfd *oldbfd; 2519 2520 keep_syms_p = (obj_coff_external_syms (abfd) != NULL); 2521 if (!_bfd_coff_get_external_symbols (abfd)) 2522 return false; 2523 2524 oldbfd = abfd; 2525 if (!xcoff_link_check_ar_symbols (abfd, info, pneeded, &abfd)) 2526 return false; 2527 2528 if (*pneeded) 2529 { 2530 /* Potentially, the add_archive_element hook may have set a 2531 substitute BFD for us. */ 2532 if (abfd != oldbfd) 2533 { 2534 if (!keep_syms_p 2535 && !_bfd_coff_free_symbols (oldbfd)) 2536 return false; 2537 keep_syms_p = (obj_coff_external_syms (abfd) != NULL); 2538 if (!_bfd_coff_get_external_symbols (abfd)) 2539 return false; 2540 } 2541 if (!xcoff_link_add_symbols (abfd, info)) 2542 return false; 2543 if (info->keep_memory) 2544 keep_syms_p = true; 2545 } 2546 2547 if (!keep_syms_p) 2548 { 2549 if (!_bfd_coff_free_symbols (abfd)) 2550 return false; 2551 } 2552 2553 return true; 2554 } 2555 2556 /* Given an XCOFF BFD, add symbols to the global hash table as 2557 appropriate. */ 2558 2559 bool 2560 _bfd_xcoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 2561 { 2562 switch (bfd_get_format (abfd)) 2563 { 2564 case bfd_object: 2565 return xcoff_link_add_object_symbols (abfd, info); 2566 2567 case bfd_archive: 2568 /* If the archive has a map, do the usual search. We then need 2569 to check the archive for dynamic objects, because they may not 2570 appear in the archive map even though they should, perhaps, be 2571 included. If the archive has no map, we just consider each object 2572 file in turn, since that apparently is what the AIX native linker 2573 does. */ 2574 if (bfd_has_map (abfd)) 2575 { 2576 if (! (_bfd_generic_link_add_archive_symbols 2577 (abfd, info, xcoff_link_check_archive_element))) 2578 return false; 2579 } 2580 2581 { 2582 bfd *member; 2583 2584 member = bfd_openr_next_archived_file (abfd, NULL); 2585 while (member != NULL) 2586 { 2587 if (bfd_check_format (member, bfd_object) 2588 && (info->output_bfd->xvec == member->xvec) 2589 && (! bfd_has_map (abfd) || (member->flags & DYNAMIC) != 0)) 2590 { 2591 bool needed; 2592 2593 if (! xcoff_link_check_archive_element (member, info, 2594 NULL, NULL, &needed)) 2595 return false; 2596 if (needed) 2597 member->archive_pass = -1; 2598 } 2599 member = bfd_openr_next_archived_file (abfd, member); 2600 } 2601 } 2602 2603 return true; 2604 2605 default: 2606 bfd_set_error (bfd_error_wrong_format); 2607 return false; 2608 } 2609 } 2610 2611 bool 2612 _bfd_xcoff_define_common_symbol (bfd *output_bfd ATTRIBUTE_UNUSED, 2613 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2614 struct bfd_link_hash_entry *harg) 2615 { 2616 struct xcoff_link_hash_entry *h; 2617 2618 if (!bfd_generic_define_common_symbol (output_bfd, info, harg)) 2619 return false; 2620 2621 h = (struct xcoff_link_hash_entry *) harg; 2622 h->flags |= XCOFF_DEF_REGULAR; 2623 return true; 2624 } 2625 2626 /* If symbol H has not been interpreted as a function descriptor, 2627 see whether it should be. Set up its descriptor information if so. */ 2628 2629 static bool 2630 xcoff_find_function (struct bfd_link_info *info, 2631 struct xcoff_link_hash_entry *h) 2632 { 2633 if ((h->flags & XCOFF_DESCRIPTOR) == 0 2634 && h->root.root.string[0] != '.') 2635 { 2636 char *fnname; 2637 struct xcoff_link_hash_entry *hfn; 2638 size_t amt; 2639 2640 amt = strlen (h->root.root.string) + 2; 2641 fnname = bfd_malloc (amt); 2642 if (fnname == NULL) 2643 return false; 2644 fnname[0] = '.'; 2645 strcpy (fnname + 1, h->root.root.string); 2646 hfn = xcoff_link_hash_lookup (xcoff_hash_table (info), 2647 fnname, false, false, true); 2648 free (fnname); 2649 if (hfn != NULL 2650 && hfn->smclas == XMC_PR 2651 && (hfn->root.type == bfd_link_hash_defined 2652 || hfn->root.type == bfd_link_hash_defweak)) 2653 { 2654 h->flags |= XCOFF_DESCRIPTOR; 2655 h->descriptor = hfn; 2656 hfn->descriptor = h; 2657 } 2658 } 2659 return true; 2660 } 2661 2662 /* Return true if the given bfd contains at least one shared object. */ 2663 2664 static bool 2665 xcoff_archive_contains_shared_object_p (struct bfd_link_info *info, 2666 bfd *archive) 2667 { 2668 struct xcoff_archive_info *archive_info; 2669 bfd *member; 2670 2671 archive_info = xcoff_get_archive_info (info, archive); 2672 if (!archive_info->know_contains_shared_object_p) 2673 { 2674 member = bfd_openr_next_archived_file (archive, NULL); 2675 while (member != NULL && (member->flags & DYNAMIC) == 0) 2676 member = bfd_openr_next_archived_file (archive, member); 2677 2678 archive_info->contains_shared_object_p = (member != NULL); 2679 archive_info->know_contains_shared_object_p = 1; 2680 } 2681 return archive_info->contains_shared_object_p; 2682 } 2683 2684 /* Symbol H qualifies for export by -bexpfull. Return true if it also 2685 qualifies for export by -bexpall. */ 2686 2687 static bool 2688 xcoff_covered_by_expall_p (struct xcoff_link_hash_entry *h) 2689 { 2690 /* Exclude symbols beginning with '_'. */ 2691 if (h->root.root.string[0] == '_') 2692 return false; 2693 2694 /* Exclude archive members that would otherwise be unreferenced. */ 2695 if ((h->flags & XCOFF_MARK) == 0 2696 && (h->root.type == bfd_link_hash_defined 2697 || h->root.type == bfd_link_hash_defweak) 2698 && h->root.u.def.section->owner != NULL 2699 && h->root.u.def.section->owner->my_archive != NULL) 2700 return false; 2701 2702 return true; 2703 } 2704 2705 /* Return true if symbol H qualifies for the forms of automatic export 2706 specified by AUTO_EXPORT_FLAGS. */ 2707 2708 static bool 2709 xcoff_auto_export_p (struct bfd_link_info *info, 2710 struct xcoff_link_hash_entry *h, 2711 unsigned int auto_export_flags) 2712 { 2713 /* Don't automatically export things that were explicitly exported. */ 2714 if ((h->flags & XCOFF_EXPORT) != 0) 2715 return false; 2716 2717 /* Don't export things that we don't define. */ 2718 if ((h->flags & XCOFF_DEF_REGULAR) == 0) 2719 return false; 2720 2721 /* Don't export functions; export their descriptors instead. */ 2722 if (h->root.root.string[0] == '.') 2723 return false; 2724 2725 /* Don't export hidden or internal symbols. */ 2726 if (h->visibility == SYM_V_HIDDEN 2727 || h->visibility == SYM_V_INTERNAL) 2728 return false; 2729 2730 /* We don't export a symbol which is being defined by an object 2731 included from an archive which contains a shared object. The 2732 rationale is that if an archive contains both an unshared and 2733 a shared object, then there must be some reason that the 2734 unshared object is unshared, and we don't want to start 2735 providing a shared version of it. In particular, this solves 2736 a bug involving the _savefNN set of functions. gcc will call 2737 those functions without providing a slot to restore the TOC, 2738 so it is essential that these functions be linked in directly 2739 and not from a shared object, which means that a shared 2740 object which also happens to link them in must not export 2741 them. This is confusing, but I haven't been able to think of 2742 a different approach. Note that the symbols can, of course, 2743 be exported explicitly. */ 2744 if (h->root.type == bfd_link_hash_defined 2745 || h->root.type == bfd_link_hash_defweak) 2746 { 2747 bfd *owner; 2748 2749 owner = h->root.u.def.section->owner; 2750 if (owner != NULL 2751 && owner->my_archive != NULL 2752 && xcoff_archive_contains_shared_object_p (info, owner->my_archive)) 2753 return false; 2754 } 2755 2756 /* Otherwise, all symbols are exported by -bexpfull. */ 2757 if ((auto_export_flags & XCOFF_EXPFULL) != 0) 2758 return true; 2759 2760 /* Despite its name, -bexpall exports most but not all symbols. */ 2761 if ((auto_export_flags & XCOFF_EXPALL) != 0 2762 && xcoff_covered_by_expall_p (h)) 2763 return true; 2764 2765 return false; 2766 } 2767 2768 /* Return true if relocation REL needs to be copied to the .loader section. 2769 If REL is against a global symbol, H is that symbol, otherwise it 2770 is null. */ 2771 2772 static bool 2773 xcoff_need_ldrel_p (struct bfd_link_info *info, struct internal_reloc *rel, 2774 struct xcoff_link_hash_entry *h, asection *ssec) 2775 { 2776 if (!xcoff_hash_table (info)->loader_section) 2777 return false; 2778 2779 switch (rel->r_type) 2780 { 2781 case R_TOC: 2782 case R_GL: 2783 case R_TCL: 2784 case R_TRL: 2785 case R_TRLA: 2786 /* We should never need a .loader reloc for a TOC-relative reloc. */ 2787 return false; 2788 2789 default: 2790 /* In this case, relocations against defined symbols can be resolved 2791 statically. */ 2792 if (h == NULL 2793 || h->root.type == bfd_link_hash_defined 2794 || h->root.type == bfd_link_hash_defweak 2795 || h->root.type == bfd_link_hash_common) 2796 return false; 2797 2798 /* We will always provide a local definition of function symbols, 2799 even if we don't have one yet. */ 2800 if ((h->flags & XCOFF_CALLED) != 0) 2801 return false; 2802 2803 return true; 2804 2805 case R_POS: 2806 case R_NEG: 2807 case R_RL: 2808 case R_RLA: 2809 /* Absolute relocations against absolute symbols can be 2810 resolved statically. */ 2811 if (h != NULL 2812 && (h->root.type == bfd_link_hash_defined 2813 || h->root.type == bfd_link_hash_defweak) 2814 && !h->root.rel_from_abs) 2815 { 2816 asection *sec = h->root.u.def.section; 2817 if (bfd_is_abs_section (sec) 2818 || (sec != NULL 2819 && bfd_is_abs_section (sec->output_section))) 2820 return false; 2821 } 2822 2823 /* Absolute relocations from read-only sections are forbidden 2824 by AIX loader. However, they can appear in their section's 2825 relocations. */ 2826 if (ssec != NULL 2827 && (ssec->output_section->flags & SEC_READONLY) != 0) 2828 return false; 2829 2830 return true; 2831 2832 case R_TLS: 2833 case R_TLS_LE: 2834 case R_TLS_IE: 2835 case R_TLS_LD: 2836 case R_TLSM: 2837 case R_TLSML: 2838 return true; 2839 } 2840 } 2841 2842 /* Mark a symbol as not being garbage, including the section in which 2843 it is defined. */ 2844 2845 static inline bool 2846 xcoff_mark_symbol (struct bfd_link_info *info, struct xcoff_link_hash_entry *h) 2847 { 2848 if ((h->flags & XCOFF_MARK) != 0) 2849 return true; 2850 2851 h->flags |= XCOFF_MARK; 2852 2853 /* If we're marking an undefined symbol, try find some way of 2854 defining it. */ 2855 if (!bfd_link_relocatable (info) 2856 && (h->flags & XCOFF_IMPORT) == 0 2857 && (h->flags & XCOFF_DEF_REGULAR) == 0 2858 && (h->root.type == bfd_link_hash_undefined 2859 || h->root.type == bfd_link_hash_undefweak)) 2860 { 2861 /* First check whether this symbol can be interpreted as an 2862 undefined function descriptor for a defined function symbol. */ 2863 if (!xcoff_find_function (info, h)) 2864 return false; 2865 2866 if ((h->flags & XCOFF_DESCRIPTOR) != 0 2867 && (h->descriptor->root.type == bfd_link_hash_defined 2868 || h->descriptor->root.type == bfd_link_hash_defweak)) 2869 { 2870 /* This is a descriptor for a defined symbol, but the input 2871 objects have not defined the descriptor itself. Fill in 2872 the definition automatically. 2873 2874 Note that we do this even if we found a dynamic definition 2875 of H. The local function definition logically overrides 2876 the dynamic one. */ 2877 asection *sec; 2878 2879 sec = xcoff_hash_table (info)->descriptor_section; 2880 h->root.type = bfd_link_hash_defined; 2881 h->root.u.def.section = sec; 2882 h->root.u.def.value = sec->size; 2883 h->smclas = XMC_DS; 2884 h->flags |= XCOFF_DEF_REGULAR; 2885 2886 /* The size of the function descriptor depends on whether this 2887 is xcoff32 (12) or xcoff64 (24). */ 2888 sec->size += bfd_xcoff_function_descriptor_size (sec->owner); 2889 2890 /* A function descriptor uses two relocs: one for the 2891 associated code, and one for the TOC address. */ 2892 xcoff_hash_table (info)->ldinfo.ldrel_count += 2; 2893 sec->reloc_count += 2; 2894 2895 /* Mark the function itself. */ 2896 if (!xcoff_mark_symbol (info, h->descriptor)) 2897 return false; 2898 2899 /* Mark the TOC section, so that we get an anchor 2900 to relocate against. */ 2901 if (!xcoff_mark (info, xcoff_hash_table (info)->toc_section)) 2902 return false; 2903 2904 /* We handle writing out the contents of the descriptor in 2905 xcoff_write_global_symbol. */ 2906 } 2907 else if (info->static_link) 2908 /* We can't get a symbol value dynamically, so just assume 2909 that it's undefined. */ 2910 h->flags |= XCOFF_WAS_UNDEFINED; 2911 else if ((h->flags & XCOFF_CALLED) != 0) 2912 { 2913 /* This is a function symbol for which we need to create 2914 linkage code. */ 2915 asection *sec; 2916 struct xcoff_link_hash_entry *hds; 2917 2918 /* Mark the descriptor (and its TOC section). */ 2919 hds = h->descriptor; 2920 BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined 2921 || hds->root.type == bfd_link_hash_undefweak) 2922 && (hds->flags & XCOFF_DEF_REGULAR) == 0); 2923 if (!xcoff_mark_symbol (info, hds)) 2924 return false; 2925 2926 /* Treat this symbol as undefined if the descriptor was. */ 2927 if ((hds->flags & XCOFF_WAS_UNDEFINED) != 0) 2928 h->flags |= XCOFF_WAS_UNDEFINED; 2929 2930 /* Allocate room for the global linkage code itself. */ 2931 sec = xcoff_hash_table (info)->linkage_section; 2932 h->root.type = bfd_link_hash_defined; 2933 h->root.u.def.section = sec; 2934 h->root.u.def.value = sec->size; 2935 h->smclas = XMC_GL; 2936 h->flags |= XCOFF_DEF_REGULAR; 2937 sec->size += bfd_xcoff_glink_code_size (info->output_bfd); 2938 2939 /* The global linkage code requires a TOC entry for the 2940 descriptor. */ 2941 if (hds->toc_section == NULL) 2942 { 2943 int byte_size; 2944 2945 /* 32 vs 64 2946 xcoff32 uses 4 bytes in the toc. 2947 xcoff64 uses 8 bytes in the toc. */ 2948 if (bfd_xcoff_is_xcoff64 (info->output_bfd)) 2949 byte_size = 8; 2950 else if (bfd_xcoff_is_xcoff32 (info->output_bfd)) 2951 byte_size = 4; 2952 else 2953 return false; 2954 2955 /* Allocate room in the fallback TOC section. */ 2956 hds->toc_section = xcoff_hash_table (info)->toc_section; 2957 hds->u.toc_offset = hds->toc_section->size; 2958 hds->toc_section->size += byte_size; 2959 if (!xcoff_mark (info, hds->toc_section)) 2960 return false; 2961 2962 /* Allocate room for a static and dynamic R_TOC 2963 relocation. */ 2964 ++xcoff_hash_table (info)->ldinfo.ldrel_count; 2965 ++hds->toc_section->reloc_count; 2966 2967 /* Set the index to -2 to force this symbol to 2968 get written out. */ 2969 hds->indx = -2; 2970 hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL; 2971 } 2972 } 2973 else if ((h->flags & XCOFF_DEF_DYNAMIC) == 0) 2974 { 2975 /* Record that the symbol was undefined, then import it. 2976 -brtl links use a special fake import file. */ 2977 h->flags |= XCOFF_WAS_UNDEFINED | XCOFF_IMPORT; 2978 if (xcoff_hash_table (info)->rtld) 2979 { 2980 if (!xcoff_set_import_path (info, h, "", "..", "")) 2981 return false; 2982 } 2983 else 2984 { 2985 if (!xcoff_set_import_path (info, h, NULL, NULL, NULL)) 2986 return false; 2987 } 2988 } 2989 } 2990 2991 if (h->root.type == bfd_link_hash_defined 2992 || h->root.type == bfd_link_hash_defweak) 2993 { 2994 asection *hsec; 2995 2996 hsec = h->root.u.def.section; 2997 if (! bfd_is_abs_section (hsec) 2998 && hsec->gc_mark == 0) 2999 { 3000 if (! xcoff_mark (info, hsec)) 3001 return false; 3002 } 3003 } 3004 3005 if (h->toc_section != NULL 3006 && h->toc_section->gc_mark == 0) 3007 { 3008 if (! xcoff_mark (info, h->toc_section)) 3009 return false; 3010 } 3011 3012 return true; 3013 } 3014 3015 /* Look for a symbol called NAME. If the symbol is defined, mark it. 3016 If the symbol exists, set FLAGS. */ 3017 3018 static bool 3019 xcoff_mark_symbol_by_name (struct bfd_link_info *info, 3020 const char *name, unsigned int flags) 3021 { 3022 struct xcoff_link_hash_entry *h; 3023 3024 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, 3025 false, false, true); 3026 if (h != NULL) 3027 { 3028 h->flags |= flags; 3029 if (h->root.type == bfd_link_hash_defined 3030 || h->root.type == bfd_link_hash_defweak) 3031 { 3032 if (!xcoff_mark (info, h->root.u.def.section)) 3033 return false; 3034 } 3035 } 3036 return true; 3037 } 3038 3039 /* The mark phase of garbage collection. For a given section, mark 3040 it, and all the sections which define symbols to which it refers. 3041 Because this function needs to look at the relocs, we also count 3042 the number of relocs which need to be copied into the .loader 3043 section. */ 3044 3045 static bool 3046 xcoff_mark (struct bfd_link_info *info, asection *sec) 3047 { 3048 if (bfd_is_const_section (sec) 3049 || sec->gc_mark != 0) 3050 return true; 3051 3052 sec->gc_mark = 1; 3053 3054 if (sec->owner->xvec != info->output_bfd->xvec) 3055 return true; 3056 3057 if (coff_section_data (sec->owner, sec) == NULL) 3058 return true; 3059 3060 3061 if (xcoff_section_data (sec->owner, sec) != NULL) 3062 { 3063 struct xcoff_link_hash_entry **syms; 3064 asection **csects; 3065 unsigned long i, first, last; 3066 3067 /* Mark all the symbols in this section. */ 3068 syms = obj_xcoff_sym_hashes (sec->owner); 3069 csects = xcoff_data (sec->owner)->csects; 3070 first = xcoff_section_data (sec->owner, sec)->first_symndx; 3071 last = xcoff_section_data (sec->owner, sec)->last_symndx; 3072 for (i = first; i <= last; i++) 3073 if (csects[i] == sec 3074 && syms[i] != NULL 3075 && (syms[i]->flags & XCOFF_MARK) == 0) 3076 { 3077 if (!xcoff_mark_symbol (info, syms[i])) 3078 return false; 3079 } 3080 } 3081 3082 /* Look through the section relocs. */ 3083 if ((sec->flags & SEC_RELOC) != 0 3084 && sec->reloc_count > 0) 3085 { 3086 struct internal_reloc *rel, *relend; 3087 3088 rel = xcoff_read_internal_relocs (sec->owner, sec, true, 3089 NULL, false, NULL); 3090 if (rel == NULL) 3091 return false; 3092 relend = rel + sec->reloc_count; 3093 for (; rel < relend; rel++) 3094 { 3095 struct xcoff_link_hash_entry *h; 3096 3097 if ((unsigned int) rel->r_symndx 3098 > obj_raw_syment_count (sec->owner)) 3099 continue; 3100 3101 h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx]; 3102 if (h != NULL) 3103 { 3104 if ((h->flags & XCOFF_MARK) == 0) 3105 { 3106 if (!xcoff_mark_symbol (info, h)) 3107 return false; 3108 } 3109 } 3110 else 3111 { 3112 asection *rsec; 3113 3114 rsec = xcoff_data (sec->owner)->csects[rel->r_symndx]; 3115 if (rsec != NULL 3116 && rsec->gc_mark == 0) 3117 { 3118 if (!xcoff_mark (info, rsec)) 3119 return false; 3120 } 3121 } 3122 3123 /* See if this reloc needs to be copied into the .loader 3124 section. */ 3125 if ((sec->flags & SEC_DEBUGGING) == 0 3126 && xcoff_need_ldrel_p (info, rel, h, sec)) 3127 { 3128 ++xcoff_hash_table (info)->ldinfo.ldrel_count; 3129 if (h != NULL) 3130 h->flags |= XCOFF_LDREL; 3131 } 3132 } 3133 3134 if (! info->keep_memory 3135 && coff_section_data (sec->owner, sec) != NULL) 3136 { 3137 free (coff_section_data (sec->owner, sec)->relocs); 3138 coff_section_data (sec->owner, sec)->relocs = NULL; 3139 } 3140 } 3141 3142 return true; 3143 } 3144 3145 /* Routines that are called after all the input files have been 3146 handled, but before the sections are laid out in memory. */ 3147 3148 /* The sweep phase of garbage collection. Remove all garbage 3149 sections. */ 3150 3151 static void 3152 xcoff_sweep (struct bfd_link_info *info) 3153 { 3154 bfd *sub; 3155 3156 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 3157 { 3158 asection *o; 3159 bool some_kept = false; 3160 3161 /* As says below keep all sections from non-XCOFF 3162 input files. */ 3163 if (sub->xvec != info->output_bfd->xvec) 3164 some_kept = true; 3165 else 3166 { 3167 /* See whether any section is already marked. */ 3168 for (o = sub->sections; o != NULL; o = o->next) 3169 if (o->gc_mark) 3170 some_kept = true; 3171 } 3172 3173 /* If no section in this file will be kept, then we can 3174 toss out debug sections. */ 3175 if (!some_kept) 3176 { 3177 for (o = sub->sections; o != NULL; o = o->next) 3178 { 3179 o->size = 0; 3180 o->reloc_count = 0; 3181 } 3182 continue; 3183 } 3184 3185 /* Keep all sections from non-XCOFF input files. Keep 3186 special sections. Keep .debug sections for the 3187 moment. */ 3188 for (o = sub->sections; o != NULL; o = o->next) 3189 { 3190 if (o->gc_mark == 1) 3191 continue; 3192 3193 if (sub->xvec != info->output_bfd->xvec 3194 || o == xcoff_hash_table (info)->debug_section 3195 || o == xcoff_hash_table (info)->loader_section 3196 || o == xcoff_hash_table (info)->linkage_section 3197 || o == xcoff_hash_table (info)->descriptor_section 3198 || (bfd_section_flags (o) & SEC_DEBUGGING) 3199 || strcmp (o->name, ".debug") == 0) 3200 xcoff_mark (info, o); 3201 else 3202 { 3203 o->size = 0; 3204 o->reloc_count = 0; 3205 } 3206 } 3207 } 3208 } 3209 3210 /* Initialize the back-end with linker infos. */ 3211 3212 bool 3213 bfd_xcoff_link_init (struct bfd_link_info *info, 3214 struct bfd_xcoff_link_params *params) 3215 { 3216 xcoff_hash_table (info)->params = params; 3217 3218 return true; 3219 } 3220 3221 /* Record the number of elements in a set. This is used to output the 3222 correct csect length. */ 3223 3224 bool 3225 bfd_xcoff_link_record_set (bfd *output_bfd, 3226 struct bfd_link_info *info, 3227 struct bfd_link_hash_entry *harg, 3228 bfd_size_type size) 3229 { 3230 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg; 3231 struct xcoff_link_size_list *n; 3232 size_t amt; 3233 3234 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3235 return true; 3236 3237 /* This will hardly ever be called. I don't want to burn four bytes 3238 per global symbol, so instead the size is kept on a linked list 3239 attached to the hash table. */ 3240 amt = sizeof (* n); 3241 n = bfd_alloc (output_bfd, amt); 3242 if (n == NULL) 3243 return false; 3244 n->next = xcoff_hash_table (info)->size_list; 3245 n->h = h; 3246 n->size = size; 3247 xcoff_hash_table (info)->size_list = n; 3248 3249 h->flags |= XCOFF_HAS_SIZE; 3250 3251 return true; 3252 } 3253 3254 /* Import a symbol. */ 3255 3256 bool 3257 bfd_xcoff_import_symbol (bfd *output_bfd, 3258 struct bfd_link_info *info, 3259 struct bfd_link_hash_entry *harg, 3260 bfd_vma val, 3261 const char *imppath, 3262 const char *impfile, 3263 const char *impmember, 3264 unsigned int syscall_flag) 3265 { 3266 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg; 3267 3268 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3269 return true; 3270 3271 /* A symbol name which starts with a period is the code for a 3272 function. If the symbol is undefined, then add an undefined 3273 symbol for the function descriptor, and import that instead. */ 3274 if (h->root.root.string[0] == '.' 3275 && h->root.type == bfd_link_hash_undefined 3276 && val == (bfd_vma) -1) 3277 { 3278 struct xcoff_link_hash_entry *hds; 3279 3280 hds = h->descriptor; 3281 if (hds == NULL) 3282 { 3283 hds = xcoff_link_hash_lookup (xcoff_hash_table (info), 3284 h->root.root.string + 1, 3285 true, false, true); 3286 if (hds == NULL) 3287 return false; 3288 if (hds->root.type == bfd_link_hash_new) 3289 { 3290 hds->root.type = bfd_link_hash_undefined; 3291 hds->root.u.undef.abfd = h->root.u.undef.abfd; 3292 } 3293 hds->flags |= XCOFF_DESCRIPTOR; 3294 BFD_ASSERT ((h->flags & XCOFF_DESCRIPTOR) == 0); 3295 hds->descriptor = h; 3296 h->descriptor = hds; 3297 } 3298 3299 /* Now, if the descriptor is undefined, import the descriptor 3300 rather than the symbol we were told to import. FIXME: Is 3301 this correct in all cases? */ 3302 if (hds->root.type == bfd_link_hash_undefined) 3303 h = hds; 3304 } 3305 3306 h->flags |= (XCOFF_IMPORT | syscall_flag); 3307 3308 if (val != (bfd_vma) -1) 3309 { 3310 if (h->root.type == bfd_link_hash_defined) 3311 (*info->callbacks->multiple_definition) (info, &h->root, output_bfd, 3312 bfd_abs_section_ptr, val); 3313 3314 h->root.type = bfd_link_hash_defined; 3315 h->root.u.def.section = bfd_abs_section_ptr; 3316 h->root.u.def.value = val; 3317 h->smclas = XMC_XO; 3318 } 3319 3320 if (!xcoff_set_import_path (info, h, imppath, impfile, impmember)) 3321 return false; 3322 3323 return true; 3324 } 3325 3326 /* Export a symbol. */ 3327 3328 bool 3329 bfd_xcoff_export_symbol (bfd *output_bfd, 3330 struct bfd_link_info *info, 3331 struct bfd_link_hash_entry *harg) 3332 { 3333 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg; 3334 3335 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3336 return true; 3337 3338 /* As AIX linker, symbols exported with hidden visibility are 3339 silently ignored. */ 3340 if (h->visibility == SYM_V_HIDDEN) 3341 return true; 3342 3343 if (h->visibility == SYM_V_INTERNAL) 3344 { 3345 _bfd_error_handler (_("%pB: cannot export internal symbol `%s`."), 3346 output_bfd, h->root.root.string); 3347 bfd_set_error (bfd_error_bad_value); 3348 return false; 3349 } 3350 3351 h->flags |= XCOFF_EXPORT; 3352 3353 /* FIXME: I'm not at all sure what syscall is supposed to mean, so 3354 I'm just going to ignore it until somebody explains it. */ 3355 3356 /* Make sure we don't garbage collect this symbol. */ 3357 if (! xcoff_mark_symbol (info, h)) 3358 return false; 3359 3360 /* If this is a function descriptor, make sure we don't garbage 3361 collect the associated function code. We normally don't have to 3362 worry about this, because the descriptor will be attached to a 3363 section with relocs, but if we are creating the descriptor 3364 ourselves those relocs will not be visible to the mark code. */ 3365 if ((h->flags & XCOFF_DESCRIPTOR) != 0) 3366 { 3367 if (! xcoff_mark_symbol (info, h->descriptor)) 3368 return false; 3369 } 3370 3371 return true; 3372 } 3373 3374 /* Count a reloc against a symbol. This is called for relocs 3375 generated by the linker script, typically for global constructors 3376 and destructors. */ 3377 3378 bool 3379 bfd_xcoff_link_count_reloc (bfd *output_bfd, 3380 struct bfd_link_info *info, 3381 const char *name) 3382 { 3383 struct xcoff_link_hash_entry *h; 3384 3385 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3386 return true; 3387 3388 h = ((struct xcoff_link_hash_entry *) 3389 bfd_wrapped_link_hash_lookup (output_bfd, info, name, false, false, 3390 false)); 3391 if (h == NULL) 3392 { 3393 _bfd_error_handler (_("%s: no such symbol"), name); 3394 bfd_set_error (bfd_error_no_symbols); 3395 return false; 3396 } 3397 3398 h->flags |= XCOFF_REF_REGULAR; 3399 if (xcoff_hash_table (info)->loader_section) 3400 { 3401 h->flags |= XCOFF_LDREL; 3402 ++xcoff_hash_table (info)->ldinfo.ldrel_count; 3403 } 3404 3405 /* Mark the symbol to avoid garbage collection. */ 3406 if (! xcoff_mark_symbol (info, h)) 3407 return false; 3408 3409 return true; 3410 } 3411 3412 /* This function is called for each symbol to which the linker script 3413 assigns a value. 3414 FIXME: In cases like the linker test ld-scripts/defined5 where a 3415 symbol is defined both by an input object file and the script, 3416 the script definition doesn't override the object file definition 3417 as is usual for other targets. At least not when the symbol is 3418 output. Other uses of the symbol value by the linker do use the 3419 script value. */ 3420 3421 bool 3422 bfd_xcoff_record_link_assignment (bfd *output_bfd, 3423 struct bfd_link_info *info, 3424 const char *name) 3425 { 3426 struct xcoff_link_hash_entry *h; 3427 3428 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3429 return true; 3430 3431 h = xcoff_link_hash_lookup (xcoff_hash_table (info), name, true, true, 3432 false); 3433 if (h == NULL) 3434 return false; 3435 3436 h->flags |= XCOFF_DEF_REGULAR; 3437 3438 return true; 3439 } 3440 3441 /* An xcoff_link_hash_traverse callback for which DATA points to an 3442 xcoff_loader_info. Mark all symbols that should be automatically 3443 exported. */ 3444 3445 static bool 3446 xcoff_mark_auto_exports (struct xcoff_link_hash_entry *h, void *data) 3447 { 3448 struct xcoff_loader_info *ldinfo; 3449 3450 ldinfo = (struct xcoff_loader_info *) data; 3451 if (xcoff_auto_export_p (ldinfo->info, h, ldinfo->auto_export_flags)) 3452 { 3453 if (!xcoff_mark_symbol (ldinfo->info, h)) 3454 ldinfo->failed = true; 3455 } 3456 return true; 3457 } 3458 3459 /* INPUT_BFD has an external symbol associated with hash table entry H 3460 and csect CSECT. Return true if INPUT_BFD defines H. */ 3461 3462 static bool 3463 xcoff_final_definition_p (bfd *input_bfd, struct xcoff_link_hash_entry *h, 3464 asection *csect) 3465 { 3466 switch (h->root.type) 3467 { 3468 case bfd_link_hash_defined: 3469 case bfd_link_hash_defweak: 3470 /* No input bfd owns absolute symbols. They are written by 3471 xcoff_write_global_symbol instead. */ 3472 return (!bfd_is_abs_section (csect) 3473 && h->root.u.def.section == csect); 3474 3475 case bfd_link_hash_common: 3476 return h->root.u.c.p->section->owner == input_bfd; 3477 3478 case bfd_link_hash_undefined: 3479 case bfd_link_hash_undefweak: 3480 /* We can't treat undef.abfd as the owner because that bfd 3481 might be a dynamic object. Allow any bfd to claim it. */ 3482 return true; 3483 3484 default: 3485 abort (); 3486 } 3487 } 3488 3489 /* See if H should have a loader symbol associated with it. */ 3490 3491 static bool 3492 xcoff_build_ldsym (struct xcoff_loader_info *ldinfo, 3493 struct xcoff_link_hash_entry *h) 3494 { 3495 size_t amt; 3496 3497 /* Warn if this symbol is exported but not defined. */ 3498 if ((h->flags & XCOFF_EXPORT) != 0 3499 && (h->flags & XCOFF_WAS_UNDEFINED) != 0) 3500 { 3501 _bfd_error_handler 3502 (_("warning: attempt to export undefined symbol `%s'"), 3503 h->root.root.string); 3504 return true; 3505 } 3506 3507 /* We need to add a symbol to the .loader section if it is mentioned 3508 in a reloc which we are copying to the .loader section and it was 3509 not defined or common, or if it is the entry point, or if it is 3510 being exported. */ 3511 if (((h->flags & XCOFF_LDREL) == 0 3512 || h->root.type == bfd_link_hash_defined 3513 || h->root.type == bfd_link_hash_defweak 3514 || h->root.type == bfd_link_hash_common) 3515 && (h->flags & XCOFF_ENTRY) == 0 3516 && (h->flags & XCOFF_EXPORT) == 0) 3517 return true; 3518 3519 /* We need to add this symbol to the .loader symbols. */ 3520 3521 BFD_ASSERT (h->ldsym == NULL); 3522 amt = sizeof (struct internal_ldsym); 3523 h->ldsym = bfd_zalloc (ldinfo->output_bfd, amt); 3524 if (h->ldsym == NULL) 3525 { 3526 ldinfo->failed = true; 3527 return false; 3528 } 3529 3530 if ((h->flags & XCOFF_IMPORT) != 0) 3531 { 3532 /* Give imported descriptors class XMC_DS rather than XMC_UA. */ 3533 if ((h->flags & XCOFF_DESCRIPTOR) != 0) 3534 h->smclas = XMC_DS; 3535 h->ldsym->l_ifile = h->ldindx; 3536 } 3537 3538 /* The first 3 symbol table indices are reserved to indicate the 3539 data, text and bss sections. */ 3540 h->ldindx = ldinfo->ldsym_count + 3; 3541 3542 ++ldinfo->ldsym_count; 3543 3544 if (! bfd_xcoff_put_ldsymbol_name (ldinfo->output_bfd, ldinfo, 3545 h->ldsym, h->root.root.string)) 3546 return false; 3547 3548 h->flags |= XCOFF_BUILT_LDSYM; 3549 return true; 3550 } 3551 3552 /* An xcoff_htab_traverse callback that is called for each symbol 3553 once garbage collection is complete. */ 3554 3555 static bool 3556 xcoff_post_gc_symbol (struct xcoff_link_hash_entry *h, void * p) 3557 { 3558 struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p; 3559 3560 /* __rtinit, this symbol has special handling. */ 3561 if (h->flags & XCOFF_RTINIT) 3562 return true; 3563 3564 /* We don't want to garbage collect symbols which are not defined in 3565 XCOFF files. This is a convenient place to mark them. */ 3566 if (xcoff_hash_table (ldinfo->info)->gc 3567 && (h->flags & XCOFF_MARK) == 0 3568 && (h->root.type == bfd_link_hash_defined 3569 || h->root.type == bfd_link_hash_defweak) 3570 && (h->root.u.def.section->owner == NULL 3571 || (h->root.u.def.section->owner->xvec 3572 != ldinfo->info->output_bfd->xvec))) 3573 h->flags |= XCOFF_MARK; 3574 3575 /* Skip discarded symbols. */ 3576 if (xcoff_hash_table (ldinfo->info)->gc 3577 && (h->flags & XCOFF_MARK) == 0) 3578 return true; 3579 3580 /* If this is still a common symbol, and it wasn't garbage 3581 collected, we need to actually allocate space for it in the .bss 3582 section. */ 3583 if (h->root.type == bfd_link_hash_common 3584 && h->root.u.c.p->section->size == 0) 3585 { 3586 BFD_ASSERT (bfd_is_com_section (h->root.u.c.p->section)); 3587 h->root.u.c.p->section->size = h->root.u.c.size; 3588 } 3589 3590 if (xcoff_hash_table (ldinfo->info)->loader_section) 3591 { 3592 if (xcoff_auto_export_p (ldinfo->info, h, ldinfo->auto_export_flags)) 3593 h->flags |= XCOFF_EXPORT; 3594 3595 if (!xcoff_build_ldsym (ldinfo, h)) 3596 return false; 3597 } 3598 3599 return true; 3600 } 3601 3602 /* INPUT_BFD includes XCOFF symbol ISYM, which is associated with linker 3603 hash table entry H and csect CSECT. AUX contains ISYM's auxiliary 3604 csect information, if any. NAME is the function's name if the name 3605 is stored in the .debug section, otherwise it is null. 3606 3607 Return 1 if we should include an appropriately-adjusted ISYM 3608 in the output file, 0 if we should discard ISYM, or -1 if an 3609 error occured. */ 3610 3611 static int 3612 xcoff_keep_symbol_p (struct bfd_link_info *info, bfd *input_bfd, 3613 struct internal_syment *isym, 3614 union internal_auxent *aux, 3615 struct xcoff_link_hash_entry *h, 3616 asection *csect, const char *name) 3617 { 3618 int smtyp; 3619 3620 /* If we are skipping this csect, we want to strip the symbol too. */ 3621 if (csect == NULL) 3622 return 0; 3623 3624 /* Likewise if we garbage-collected the csect. */ 3625 if (xcoff_hash_table (info)->gc 3626 && !bfd_is_abs_section (csect) 3627 && !bfd_is_und_section (csect) 3628 && csect->gc_mark == 0) 3629 return 0; 3630 3631 /* An XCOFF linker always removes C_STAT symbols. */ 3632 if (isym->n_sclass == C_STAT) 3633 return 0; 3634 3635 /* We generate the TOC anchor separately. */ 3636 if (isym->n_sclass == C_HIDEXT 3637 && aux->x_csect.x_smclas == XMC_TC0) 3638 return 0; 3639 3640 /* If we are stripping all symbols, we want to discard this one. */ 3641 if (info->strip == strip_all) 3642 return 0; 3643 3644 /* Discard symbols that are defined elsewhere. */ 3645 if (EXTERN_SYM_P (isym->n_sclass)) 3646 { 3647 if ((h->flags & XCOFF_ALLOCATED) != 0) 3648 return 0; 3649 if (!xcoff_final_definition_p (input_bfd, h, csect)) 3650 return 0; 3651 } 3652 3653 /* If we're discarding local symbols, check whether ISYM is local. */ 3654 smtyp = SMTYP_SMTYP (aux->x_csect.x_smtyp); 3655 if (info->discard == discard_all 3656 && !EXTERN_SYM_P (isym->n_sclass) 3657 && (isym->n_sclass != C_HIDEXT || smtyp != XTY_SD)) 3658 return 0; 3659 3660 /* If we're stripping debugging symbols, check whether ISYM is one. */ 3661 if (info->strip == strip_debugger 3662 && isym->n_scnum == N_DEBUG) 3663 return 0; 3664 3665 /* If we are stripping symbols based on name, check how ISYM's 3666 name should be handled. */ 3667 if (info->strip == strip_some 3668 || info->discard == discard_l) 3669 { 3670 char buf[SYMNMLEN + 1]; 3671 3672 if (name == NULL) 3673 { 3674 name = _bfd_coff_internal_syment_name (input_bfd, isym, buf); 3675 if (name == NULL) 3676 return -1; 3677 } 3678 3679 if (info->strip == strip_some 3680 && bfd_hash_lookup (info->keep_hash, name, false, false) == NULL) 3681 return 0; 3682 3683 if (info->discard == discard_l 3684 && !EXTERN_SYM_P (isym->n_sclass) 3685 && (isym->n_sclass != C_HIDEXT || smtyp != XTY_SD) 3686 && bfd_is_local_label_name (input_bfd, name)) 3687 return 0; 3688 } 3689 3690 return 1; 3691 } 3692 3693 /* Compute the current size of the .loader section. Start filling 3694 its header but it will be finalized in xcoff_build_loader_section. */ 3695 3696 static bool 3697 xcoff_size_loader_section (struct xcoff_loader_info *ldinfo) 3698 { 3699 bfd *output_bfd; 3700 struct xcoff_link_hash_table *htab; 3701 struct internal_ldhdr *ldhdr; 3702 struct xcoff_import_file *fl; 3703 bfd_size_type stoff; 3704 size_t impsize, impcount; 3705 asection *lsec; 3706 3707 output_bfd = ldinfo->output_bfd; 3708 htab = xcoff_hash_table (ldinfo->info); 3709 ldhdr = &htab->ldhdr; 3710 3711 /* If this function has already been called (ie l_version is set) 3712 and the number of symbols or relocations haven't changed since 3713 last call, the size is already known. */ 3714 if (ldhdr->l_version != 0 3715 && ldhdr->l_nsyms == ldinfo->ldsym_count 3716 && ldhdr->l_nreloc == ldinfo->ldrel_count) 3717 return true; 3718 3719 /* Work out the size of the import file names. Each import file ID 3720 consists of three null terminated strings: the path, the file 3721 name, and the archive member name. The first entry in the list 3722 of names is the path to use to find objects, which the linker has 3723 passed in as the libpath argument. For some reason, the path 3724 entry in the other import file names appears to always be empty. */ 3725 if (ldhdr->l_nimpid == 0) 3726 { 3727 impsize = strlen (ldinfo->libpath) + 3; 3728 impcount = 1; 3729 for (fl = htab->imports; fl != NULL; fl = fl->next) 3730 { 3731 ++impcount; 3732 impsize += (strlen (fl->path) 3733 + strlen (fl->file) 3734 + strlen (fl->member) 3735 + 3); 3736 } 3737 ldhdr->l_istlen = impsize; 3738 ldhdr->l_nimpid = impcount; 3739 } 3740 3741 /* Set up the .loader section header. */ 3742 ldhdr->l_version = bfd_xcoff_ldhdr_version(output_bfd); 3743 ldhdr->l_nsyms = ldinfo->ldsym_count; 3744 ldhdr->l_nreloc = ldinfo->ldrel_count; 3745 ldhdr->l_impoff = (bfd_xcoff_ldhdrsz (output_bfd) 3746 + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (output_bfd) 3747 + ldhdr->l_nreloc * bfd_xcoff_ldrelsz (output_bfd)); 3748 ldhdr->l_stlen = ldinfo->string_size; 3749 stoff = ldhdr->l_impoff + ldhdr->l_istlen; 3750 if (ldinfo->string_size == 0) 3751 ldhdr->l_stoff = 0; 3752 else 3753 ldhdr->l_stoff = stoff; 3754 3755 /* 64 bit elements to ldhdr 3756 The swap out routine for 32 bit will ignore them. 3757 Nothing fancy, symbols come after the header and relocs come 3758 after symbols. */ 3759 ldhdr->l_symoff = bfd_xcoff_ldhdrsz (output_bfd); 3760 ldhdr->l_rldoff = (bfd_xcoff_ldhdrsz (output_bfd) 3761 + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (output_bfd)); 3762 3763 /* Save the size of the .loader section. */ 3764 lsec = htab->loader_section; 3765 lsec->size = stoff + ldhdr->l_stlen; 3766 3767 return true; 3768 } 3769 3770 /* Prepare the .loader section. This is called by the XCOFF linker 3771 emulation before_allocation routine. We must set the size of the 3772 .loader section before the linker lays out the output file. However, 3773 some symbols or relocations might be append to the .loader section 3774 when processing the addresses, thus it's not layout right now and 3775 its size might change. 3776 LIBPATH is the library path to search for shared objects; this is 3777 normally built from the -L arguments passed to the linker. ENTRY 3778 is the name of the entry point symbol (the -e linker option). 3779 FILE_ALIGN is the alignment to use for sections within the file 3780 (the -H linker option). MAXSTACK is the maximum stack size (the 3781 -bmaxstack linker option). MAXDATA is the maximum data size (the 3782 -bmaxdata linker option). GC is whether to do garbage collection 3783 (the -bgc linker option). MODTYPE is the module type (the 3784 -bmodtype linker option). TEXTRO is whether the text section must 3785 be read only (the -btextro linker option). AUTO_EXPORT_FLAGS 3786 is a mask of XCOFF_EXPALL and XCOFF_EXPFULL. SPECIAL_SECTIONS 3787 is set by this routine to csects with magic names like _end. */ 3788 3789 bool 3790 bfd_xcoff_size_dynamic_sections (bfd *output_bfd, 3791 struct bfd_link_info *info, 3792 const char *libpath, 3793 const char *entry, 3794 unsigned long file_align, 3795 unsigned long maxstack, 3796 unsigned long maxdata, 3797 bool gc, 3798 int modtype, 3799 bool textro, 3800 unsigned int auto_export_flags, 3801 asection **special_sections, 3802 bool rtld) 3803 { 3804 struct xcoff_loader_info *ldinfo; 3805 int i; 3806 asection *sec; 3807 bfd *sub; 3808 size_t amt; 3809 3810 if (bfd_get_flavour (output_bfd) != bfd_target_xcoff_flavour) 3811 { 3812 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++) 3813 special_sections[i] = NULL; 3814 return true; 3815 } 3816 3817 /* Setup ldinfo. */ 3818 ldinfo = &(xcoff_hash_table (info)->ldinfo); 3819 3820 ldinfo->failed = false; 3821 ldinfo->output_bfd = output_bfd; 3822 ldinfo->info = info; 3823 ldinfo->auto_export_flags = auto_export_flags; 3824 ldinfo->ldsym_count = 0; 3825 ldinfo->string_size = 0; 3826 ldinfo->strings = NULL; 3827 ldinfo->string_alc = 0; 3828 ldinfo->libpath = libpath; 3829 3830 xcoff_data (output_bfd)->maxstack = maxstack; 3831 xcoff_data (output_bfd)->maxdata = maxdata; 3832 xcoff_data (output_bfd)->modtype = modtype; 3833 3834 xcoff_hash_table (info)->file_align = file_align; 3835 xcoff_hash_table (info)->textro = textro; 3836 xcoff_hash_table (info)->rtld = rtld; 3837 3838 /* __rtinit */ 3839 if (xcoff_hash_table (info)->loader_section 3840 && (info->init_function || info->fini_function || rtld)) 3841 { 3842 struct xcoff_link_hash_entry *hsym; 3843 struct internal_ldsym *ldsym; 3844 3845 hsym = xcoff_link_hash_lookup (xcoff_hash_table (info), 3846 "__rtinit", false, false, true); 3847 if (hsym == NULL) 3848 { 3849 _bfd_error_handler 3850 (_("error: undefined symbol __rtinit")); 3851 return false; 3852 } 3853 3854 xcoff_mark_symbol (info, hsym); 3855 hsym->flags |= (XCOFF_DEF_REGULAR | XCOFF_RTINIT); 3856 3857 /* __rtinit initialized. */ 3858 amt = sizeof (* ldsym); 3859 ldsym = bfd_malloc (amt); 3860 3861 ldsym->l_value = 0; /* Will be filled in later. */ 3862 ldsym->l_scnum = 2; /* Data section. */ 3863 ldsym->l_smtype = XTY_SD; /* Csect section definition. */ 3864 ldsym->l_smclas = 5; /* .rw. */ 3865 ldsym->l_ifile = 0; /* Special system loader symbol. */ 3866 ldsym->l_parm = 0; /* NA. */ 3867 3868 /* Force __rtinit to be the first symbol in the loader symbol table 3869 See xcoff_build_ldsyms 3870 3871 The first 3 symbol table indices are reserved to indicate the data, 3872 text and bss sections. */ 3873 BFD_ASSERT (0 == ldinfo->ldsym_count); 3874 3875 hsym->ldindx = 3; 3876 ldinfo->ldsym_count = 1; 3877 hsym->ldsym = ldsym; 3878 3879 if (! bfd_xcoff_put_ldsymbol_name (ldinfo->output_bfd, ldinfo, 3880 hsym->ldsym, hsym->root.root.string)) 3881 return false; 3882 3883 /* This symbol is written out by xcoff_write_global_symbol 3884 Set stuff up so xcoff_write_global_symbol logic works. */ 3885 hsym->flags |= XCOFF_DEF_REGULAR | XCOFF_MARK; 3886 hsym->root.type = bfd_link_hash_defined; 3887 hsym->root.u.def.value = 0; 3888 } 3889 3890 /* Garbage collect unused sections. */ 3891 if (bfd_link_relocatable (info) || !gc) 3892 { 3893 gc = false; 3894 xcoff_hash_table (info)->gc = false; 3895 3896 /* We still need to call xcoff_mark, in order to set ldrel_count 3897 correctly. */ 3898 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 3899 { 3900 asection *o; 3901 3902 for (o = sub->sections; o != NULL; o = o->next) 3903 { 3904 /* We shouldn't unconditionaly mark the TOC section. 3905 The output file should only have a TOC if either 3906 (a) one of the input files did or (b) we end up 3907 creating TOC references as part of the link process. */ 3908 if (o != xcoff_hash_table (info)->toc_section 3909 && o->gc_mark == 0) 3910 { 3911 if (! xcoff_mark (info, o)) 3912 goto error_return; 3913 } 3914 } 3915 } 3916 } 3917 else 3918 { 3919 if (entry != NULL 3920 && !xcoff_mark_symbol_by_name (info, entry, XCOFF_ENTRY)) 3921 goto error_return; 3922 if (info->init_function != NULL 3923 && !xcoff_mark_symbol_by_name (info, info->init_function, 0)) 3924 goto error_return; 3925 if (info->fini_function != NULL 3926 && !xcoff_mark_symbol_by_name (info, info->fini_function, 0)) 3927 goto error_return; 3928 if (auto_export_flags != 0) 3929 { 3930 xcoff_link_hash_traverse (xcoff_hash_table (info), 3931 xcoff_mark_auto_exports, ldinfo); 3932 if (ldinfo->failed) 3933 goto error_return; 3934 } 3935 xcoff_sweep (info); 3936 xcoff_hash_table (info)->gc = true; 3937 } 3938 3939 /* Return special sections to the caller. */ 3940 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++) 3941 { 3942 sec = xcoff_hash_table (info)->special_sections[i]; 3943 3944 if (sec != NULL 3945 && gc 3946 && sec->gc_mark == 0) 3947 sec = NULL; 3948 3949 special_sections[i] = sec; 3950 } 3951 3952 if (info->input_bfds == NULL) 3953 /* I'm not sure what to do in this bizarre case. */ 3954 return true; 3955 3956 xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_post_gc_symbol, 3957 (void *) ldinfo); 3958 if (ldinfo->failed) 3959 goto error_return; 3960 3961 if (xcoff_hash_table (info)->loader_section 3962 && !xcoff_size_loader_section (ldinfo)) 3963 goto error_return; 3964 3965 return true; 3966 3967 error_return: 3968 free (ldinfo->strings); 3969 return false; 3970 } 3971 3972 /* Lay out the .loader section, finalizing its header and 3973 filling the import paths */ 3974 static bool 3975 xcoff_build_loader_section (struct xcoff_loader_info *ldinfo) 3976 { 3977 bfd *output_bfd; 3978 asection *lsec; 3979 struct xcoff_link_hash_table *htab; 3980 struct internal_ldhdr *ldhdr; 3981 struct xcoff_import_file *fl; 3982 char *out; 3983 3984 output_bfd = ldinfo->output_bfd; 3985 htab = xcoff_hash_table (ldinfo->info); 3986 lsec = htab->loader_section; 3987 ldhdr = &htab->ldhdr; 3988 3989 /* We could have called xcoff_size_loader_section one more time. 3990 However, this function is called once all the addresses have 3991 been layout thus the .loader section shouldn't be changed 3992 anymore. */ 3993 BFD_ASSERT (ldhdr->l_nsyms == ldinfo->ldsym_count); 3994 BFD_ASSERT (ldhdr->l_nreloc == ldinfo->ldrel_count); 3995 3996 /* We now know the final size of the .loader section. Allocate 3997 space for it. */ 3998 lsec->contents = bfd_zalloc (output_bfd, lsec->size); 3999 if (lsec->contents == NULL) 4000 return false; 4001 4002 /* Set up the header. */ 4003 bfd_xcoff_swap_ldhdr_out (output_bfd, ldhdr, lsec->contents); 4004 4005 /* Set up the import file names. */ 4006 out = (char *) lsec->contents + ldhdr->l_impoff; 4007 strcpy (out, ldinfo->libpath); 4008 out += strlen (ldinfo->libpath) + 1; 4009 *out++ = '\0'; 4010 *out++ = '\0'; 4011 for (fl = htab->imports; fl != NULL; fl = fl->next) 4012 { 4013 const char *s; 4014 4015 s = fl->path; 4016 while ((*out++ = *s++) != '\0') 4017 ; 4018 s = fl->file; 4019 while ((*out++ = *s++) != '\0') 4020 ; 4021 s = fl->member; 4022 while ((*out++ = *s++) != '\0') 4023 ; 4024 } 4025 4026 BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents) == ldhdr->l_impoff + ldhdr->l_istlen); 4027 4028 /* Set up the symbol string table. */ 4029 if (ldinfo->string_size > 0) 4030 { 4031 memcpy (out, ldinfo->strings, ldinfo->string_size); 4032 free (ldinfo->strings); 4033 ldinfo->strings = NULL; 4034 } 4035 4036 /* We can't set up the symbol table or the relocs yet, because we 4037 don't yet know the final position of the various sections. The 4038 .loader symbols are written out when the corresponding normal 4039 symbols are written out in xcoff_link_input_bfd or 4040 xcoff_write_global_symbol. The .loader relocs are written out 4041 when the corresponding normal relocs are handled in 4042 xcoff_link_input_bfd. */ 4043 4044 return true; 4045 } 4046 4047 4048 /* Lay out the .loader section and allocate the space for 4049 the other dynamic sections of XCOFF. */ 4050 bool 4051 bfd_xcoff_build_dynamic_sections (bfd *output_bfd, 4052 struct bfd_link_info *info) 4053 { 4054 struct xcoff_loader_info *ldinfo; 4055 struct bfd_strtab_hash *debug_strtab; 4056 bfd_byte *debug_contents = NULL; 4057 bfd *sub; 4058 asection *sec; 4059 4060 ldinfo = &(xcoff_hash_table (info)->ldinfo); 4061 4062 if (xcoff_hash_table (info)->loader_section 4063 && !xcoff_build_loader_section (ldinfo)) 4064 return false; 4065 4066 /* Allocate space for the magic sections. */ 4067 sec = xcoff_hash_table (info)->linkage_section; 4068 if (sec->size > 0) 4069 { 4070 sec->contents = bfd_zalloc (output_bfd, sec->size); 4071 if (sec->contents == NULL) 4072 return false; 4073 } 4074 sec = xcoff_hash_table (info)->toc_section; 4075 if (sec->size > 0) 4076 { 4077 sec->contents = bfd_zalloc (output_bfd, sec->size); 4078 if (sec->contents == NULL) 4079 return false; 4080 } 4081 sec = xcoff_hash_table (info)->descriptor_section; 4082 if (sec->size > 0) 4083 { 4084 sec->contents = bfd_zalloc (output_bfd, sec->size); 4085 if (sec->contents == NULL) 4086 return false; 4087 } 4088 4089 /* Now that we've done garbage collection, decide which symbols to keep, 4090 and figure out the contents of the .debug section. */ 4091 debug_strtab = xcoff_hash_table (info)->debug_strtab; 4092 4093 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 4094 { 4095 asection *subdeb; 4096 bfd_size_type symcount; 4097 long *debug_index; 4098 asection **csectpp; 4099 unsigned int *lineno_counts; 4100 struct xcoff_link_hash_entry **sym_hash; 4101 bfd_byte *esym, *esymend; 4102 bfd_size_type symesz; 4103 4104 if (sub->xvec != info->output_bfd->xvec) 4105 continue; 4106 4107 if ((sub->flags & DYNAMIC) != 0 4108 && !info->static_link) 4109 continue; 4110 4111 if (! _bfd_coff_get_external_symbols (sub)) 4112 goto error_return; 4113 4114 symcount = obj_raw_syment_count (sub); 4115 debug_index = bfd_zalloc (sub, symcount * sizeof (long)); 4116 if (debug_index == NULL) 4117 goto error_return; 4118 xcoff_data (sub)->debug_indices = debug_index; 4119 4120 if (info->strip == strip_all 4121 || info->strip == strip_debugger 4122 || info->discard == discard_all) 4123 /* We're stripping all debugging information, so there's no need 4124 to read SUB's .debug section. */ 4125 subdeb = NULL; 4126 else 4127 { 4128 /* Grab the contents of SUB's .debug section, if any. */ 4129 subdeb = bfd_get_section_by_name (sub, ".debug"); 4130 if (subdeb != NULL 4131 && subdeb->size != 0 4132 && (subdeb->flags & SEC_HAS_CONTENTS) != 0) 4133 { 4134 /* We use malloc and copy the names into the debug 4135 stringtab, rather than bfd_alloc, because I expect 4136 that, when linking many files together, many of the 4137 strings will be the same. Storing the strings in the 4138 hash table should save space in this case. */ 4139 if (!bfd_malloc_and_get_section (sub, subdeb, &debug_contents)) 4140 goto error_return; 4141 } 4142 } 4143 4144 csectpp = xcoff_data (sub)->csects; 4145 lineno_counts = xcoff_data (sub)->lineno_counts; 4146 sym_hash = obj_xcoff_sym_hashes (sub); 4147 symesz = bfd_coff_symesz (sub); 4148 esym = (bfd_byte *) obj_coff_external_syms (sub); 4149 esymend = esym + symcount * symesz; 4150 4151 while (esym < esymend) 4152 { 4153 struct internal_syment sym; 4154 union internal_auxent aux; 4155 asection *csect; 4156 const char *name; 4157 int keep_p; 4158 4159 bfd_coff_swap_sym_in (sub, esym, &sym); 4160 4161 /* Read in the csect information, if any. */ 4162 if (CSECT_SYM_P (sym.n_sclass)) 4163 { 4164 BFD_ASSERT (sym.n_numaux > 0); 4165 bfd_coff_swap_aux_in (sub, esym + symesz * sym.n_numaux, 4166 sym.n_type, sym.n_sclass, 4167 sym.n_numaux - 1, sym.n_numaux, &aux); 4168 } 4169 4170 /* If this symbol's name is stored in the debug section, 4171 get a pointer to it. */ 4172 if (debug_contents != NULL 4173 && sym._n._n_n._n_zeroes == 0 4174 && bfd_coff_symname_in_debug (sub, &sym)) 4175 name = (const char *) debug_contents + sym._n._n_n._n_offset; 4176 else 4177 name = NULL; 4178 4179 /* Decide whether to copy this symbol to the output file. */ 4180 csect = *csectpp; 4181 keep_p = xcoff_keep_symbol_p (info, sub, &sym, &aux, 4182 *sym_hash, csect, name); 4183 if (keep_p < 0) 4184 goto error_return; 4185 4186 if (!keep_p) 4187 /* Use a debug_index of -2 to record that a symbol should 4188 be stripped. */ 4189 *debug_index = -2; 4190 else 4191 { 4192 /* See whether we should store the symbol name in the 4193 output .debug section. */ 4194 if (name != NULL) 4195 { 4196 bfd_size_type indx; 4197 4198 indx = _bfd_stringtab_add (debug_strtab, name, true, true); 4199 if (indx == (bfd_size_type) -1) 4200 goto error_return; 4201 *debug_index = indx; 4202 } 4203 else 4204 *debug_index = -1; 4205 if (*sym_hash != 0) 4206 (*sym_hash)->flags |= XCOFF_ALLOCATED; 4207 if (*lineno_counts > 0) 4208 csect->output_section->lineno_count += *lineno_counts; 4209 } 4210 4211 esym += (sym.n_numaux + 1) * symesz; 4212 csectpp += sym.n_numaux + 1; 4213 sym_hash += sym.n_numaux + 1; 4214 lineno_counts += sym.n_numaux + 1; 4215 debug_index += sym.n_numaux + 1; 4216 } 4217 4218 if (debug_contents) 4219 { 4220 free (debug_contents); 4221 debug_contents = NULL; 4222 4223 /* Clear the size of subdeb, so that it is not included directly 4224 in the output file. */ 4225 subdeb->size = 0; 4226 } 4227 4228 if (! info->keep_memory) 4229 { 4230 if (! _bfd_coff_free_symbols (sub)) 4231 goto error_return; 4232 } 4233 } 4234 4235 if (info->strip != strip_all 4236 && xcoff_hash_table (info)->debug_section != NULL) 4237 xcoff_hash_table (info)->debug_section->size = 4238 _bfd_stringtab_size (debug_strtab); 4239 4240 return true; 4241 4242 error_return: 4243 free (debug_contents); 4244 return false; 4245 } 4246 4247 bool 4248 bfd_xcoff_link_generate_rtinit (bfd *abfd, 4249 const char *init, 4250 const char *fini, 4251 bool rtld) 4252 { 4253 struct bfd_in_memory *bim; 4254 4255 bim = bfd_malloc ((bfd_size_type) sizeof (* bim)); 4256 if (bim == NULL) 4257 return false; 4258 4259 bim->size = 0; 4260 bim->buffer = 0; 4261 4262 abfd->link.next = 0; 4263 abfd->format = bfd_object; 4264 abfd->iostream = (void *) bim; 4265 abfd->flags = BFD_IN_MEMORY; 4266 abfd->iovec = &_bfd_memory_iovec; 4267 abfd->direction = write_direction; 4268 abfd->origin = 0; 4269 abfd->where = 0; 4270 4271 if (! bfd_xcoff_generate_rtinit (abfd, init, fini, rtld)) 4272 return false; 4273 4274 /* need to reset to unknown or it will not be read back in correctly */ 4275 abfd->format = bfd_unknown; 4276 abfd->direction = read_direction; 4277 abfd->where = 0; 4278 4279 return true; 4280 } 4281 4282 4283 /* Linker stubs. 4284 The stubs will be gathered in stub csects named "@FIX'number'". 4285 A new csect will be created by xcoff_stub_get_csect_in_range, 4286 everytime a relocation cannot reach its target and its section 4287 is too far from the others stub csects. 4288 The stubs will simply be code generated inside these stub 4289 csects. In order to simplify the symbol table, only the symbols 4290 for the stub csects are written. 4291 4292 As the code is dependent of the architecture, it's defined 4293 in the backend. 4294 4295 xcoff_stub_indirect_call: 4296 Used when a 24 bit branch cannot reach its destination and that 4297 this destination isn't a global linkage symbol. 4298 4299 xcoff_stub_shared_call: 4300 As above but when it's a global linkage symbol. 4301 The main difference being that it doesn't branch to the global 4302 linkage symbol which will then call the shared library. It 4303 directly call it saving the TOC. 4304 4305 TODO: -bbigtoc option should be able to be implemented using 4306 this stubs. */ 4307 4308 /* Get the name of a csect which will contain stubs. 4309 It has the same pattern as AIX linker: @FIX"number". */ 4310 static char * 4311 xcoff_stub_csect_name (unsigned int n) 4312 { 4313 char buf[8]; 4314 size_t len; 4315 char *csect_name; 4316 4317 /* For now, allow "only" 1000000 stub csects. */ 4318 if (n >= 1000000) 4319 { 4320 BFD_FAIL(); 4321 return NULL; 4322 } 4323 4324 sprintf (buf, "%d", n); 4325 len = 4 + strlen (buf) + 1; 4326 4327 csect_name = bfd_malloc (len); 4328 if (csect_name == NULL) 4329 return NULL; 4330 sprintf (csect_name, "@FIX%d", n); 4331 4332 return csect_name; 4333 } 4334 4335 /* Return a stub section which can be reach with a single branch 4336 from SECTION. CREATE means that creating a csect is allowed. */ 4337 static struct xcoff_link_hash_entry * 4338 xcoff_stub_get_csect_in_range (asection *section, 4339 struct bfd_link_info *info, 4340 bool create) 4341 { 4342 struct xcoff_link_hash_table *htab = xcoff_hash_table (info); 4343 struct xcoff_link_hash_entry *csect_entry; 4344 struct bfd_link_hash_entry *bh = NULL; 4345 asection *csect; 4346 unsigned int it; 4347 char *csect_name; 4348 4349 /* Search for a csect in range. */ 4350 for (csect = htab->params->stub_bfd->sections, it = 0; 4351 csect != NULL; 4352 csect = csect->next, it++) 4353 { 4354 /* A csect is in range if everything instructions in SECTION 4355 can branch to every stubs in the stub csect. This can 4356 be simplify by saying that the first entry of each sections 4357 (ie the vma of this section) can reach the last entry of the 4358 stub csect (ie the vma of the csect + its size). 4359 However, as the stub csect might be growing its size isn't 4360 fixed. Thus, the last entry of SECTION might not be able 4361 to reach the first entry of the stub csect anymore. 4362 If this case happens, the following condition will be 4363 false during the next pass of bfd_xcoff_size_stubs and 4364 another csect will be used. 4365 This means we might create more stubs than needed. */ 4366 bfd_vma csect_vma, section_vma; 4367 bfd_vma csect_last_vma, section_last_vma; 4368 4369 csect_vma = (csect->output_section->vma 4370 + csect->output_offset); 4371 csect_last_vma = (csect->output_section->vma 4372 + csect->output_offset 4373 + csect->size); 4374 section_vma = (section->output_section->vma 4375 + section->output_offset); 4376 section_last_vma = (section->output_section->vma 4377 + section->output_offset 4378 + section->size); 4379 4380 if (csect_last_vma - section_vma + (1 << 25) < 2 * (1 << 25) 4381 && section_last_vma - csect_vma + (1 << 25) < 2 * (1 << 25)) 4382 break; 4383 } 4384 4385 if (!create && csect == NULL) 4386 return NULL; 4387 4388 csect_name = xcoff_stub_csect_name (it); 4389 if (!csect_name) 4390 return NULL; 4391 4392 /* A stub csect already exists, get its entry. */ 4393 if (csect != NULL) 4394 { 4395 csect_entry = xcoff_link_hash_lookup (htab, csect_name, false, false, true); 4396 free(csect_name); 4397 return csect_entry; 4398 } 4399 4400 /* Create the csect and its symbol. */ 4401 csect = (*htab->params->add_stub_section) (".pr", section); 4402 if (!csect) 4403 { 4404 free(csect_name); 4405 return NULL; 4406 } 4407 4408 csect->alignment_power = 2; 4409 csect->gc_mark = 1; 4410 csect->reloc_count = 0; 4411 4412 /* We need to associate a VMA to this new csect. Otherwise, 4413 our "in range" algorithm won't find it for the next stub. 4414 And as we will be adding this stub section just after the 4415 SECTION, we know its address. */ 4416 csect->output_offset = BFD_ALIGN (section->output_offset + section->size, 4417 4); 4418 4419 if (!_bfd_generic_link_add_one_symbol (info, htab->params->stub_bfd, 4420 csect_name, BSF_GLOBAL, csect, 0, 4421 NULL, true, true, &bh)) 4422 { 4423 free(csect_name); 4424 return NULL; 4425 } 4426 4427 csect_entry = (struct xcoff_link_hash_entry *)bh; 4428 csect_entry->smclas = XMC_PR; 4429 csect_entry->flags = XCOFF_MARK | XCOFF_DEF_REGULAR; 4430 4431 free(csect_name); 4432 return csect_entry; 4433 } 4434 4435 4436 /* Build a name for an entry in the stub hash table. */ 4437 static char * 4438 xcoff_stub_name (const struct xcoff_link_hash_entry *h, 4439 const struct xcoff_link_hash_entry *hcsect) 4440 { 4441 char *stub_name; 4442 size_t len; 4443 4444 if (h) 4445 { 4446 /* The name of a stub is based on its stub csect and the 4447 symbol it wants to reach. It looks like: ".@FIX0.tramp.f". 4448 When the stub targets a function, the last dot of ".tramp." 4449 is removed to avoid having two dot. */ 4450 len = (1 + 6 4451 + strlen (hcsect->root.root.string) 4452 + strlen (h->root.root.string) 4453 + 1); 4454 if (h->root.root.string[0] != '.') 4455 len++; 4456 4457 stub_name = bfd_malloc (len); 4458 if (stub_name == NULL) 4459 return stub_name; 4460 4461 if (h->root.root.string[0] == '.') 4462 sprintf (stub_name, ".%s.tramp%s", 4463 hcsect->root.root.string, 4464 h->root.root.string); 4465 else 4466 sprintf (stub_name, ".%s.tramp.%s", 4467 hcsect->root.root.string, 4468 h->root.root.string); 4469 } 4470 else 4471 { 4472 BFD_FAIL(); 4473 return NULL; 4474 } 4475 4476 return stub_name; 4477 } 4478 4479 /* Look up an entry in the stub hash. */ 4480 struct xcoff_stub_hash_entry * 4481 bfd_xcoff_get_stub_entry (asection *section, 4482 struct xcoff_link_hash_entry *h, 4483 struct bfd_link_info *info) 4484 { 4485 struct xcoff_link_hash_table *htab = xcoff_hash_table (info); 4486 struct xcoff_link_hash_entry *hcsect; 4487 struct xcoff_stub_hash_entry *hstub; 4488 char *stub_name; 4489 4490 hcsect = xcoff_stub_get_csect_in_range (section, info, false); 4491 if (!hcsect) 4492 return NULL; 4493 4494 stub_name = xcoff_stub_name (h, hcsect); 4495 if (stub_name == NULL) 4496 return NULL; 4497 4498 hstub = xcoff_stub_hash_lookup (&htab->stub_hash_table, 4499 stub_name, false, false); 4500 4501 free (stub_name); 4502 return hstub; 4503 } 4504 4505 /* Check if the symbol targeted by IREL is reachable. 4506 Return the type of stub needed otherwise. */ 4507 enum xcoff_stub_type 4508 bfd_xcoff_type_of_stub (asection *sec, 4509 const struct internal_reloc *irel, 4510 bfd_vma destination, 4511 struct xcoff_link_hash_entry *h) 4512 { 4513 bfd_vma location, offset, max_offset; 4514 4515 switch (irel->r_type) 4516 { 4517 default: 4518 return xcoff_stub_none; 4519 4520 case R_BR: 4521 case R_RBR: 4522 location = (sec->output_section->vma 4523 + sec->output_offset 4524 + irel->r_vaddr 4525 - sec->vma); 4526 4527 max_offset = 1 << 25 ; 4528 4529 offset = destination - location; 4530 4531 if (offset + max_offset < 2 * max_offset) 4532 return xcoff_stub_none; 4533 4534 /* A stub is needed. Now, check that we can make one. */ 4535 if (h != NULL 4536 && h->descriptor != NULL) 4537 { 4538 /* Not sure how to handle this case. For now, skip it. */ 4539 if (bfd_is_abs_section (h->root.u.def.section)) 4540 return xcoff_stub_none; 4541 4542 if (h->smclas == XMC_GL) 4543 return xcoff_stub_shared_call; 4544 else 4545 return xcoff_stub_indirect_call; 4546 } 4547 break; 4548 } 4549 4550 return xcoff_stub_none; 4551 } 4552 4553 /* Add a new stub entry to the stub hash. Not all fields of the new 4554 stub entry are initialised. */ 4555 static struct xcoff_stub_hash_entry * 4556 xcoff_add_stub (const char *stub_name, 4557 struct xcoff_link_hash_entry *hstub_csect, 4558 struct xcoff_link_hash_entry *htarget, 4559 struct bfd_link_info *info, 4560 enum xcoff_stub_type stub_type) 4561 { 4562 struct xcoff_link_hash_table *htab = xcoff_hash_table (info); 4563 struct xcoff_stub_hash_entry *hstub; 4564 bfd_vma stub_offset; 4565 asection *stub_csect; 4566 4567 stub_csect = hstub_csect->root.u.def.section; 4568 stub_offset = stub_csect->size; 4569 4570 /* Update the relocation counter and the size of 4571 the containing csect. The size is needed for 4572 the algorithm in xcoff_stub_get_csect_in_range. */ 4573 switch (stub_type) 4574 { 4575 default: 4576 BFD_FAIL (); 4577 return NULL; 4578 4579 case xcoff_stub_indirect_call: 4580 stub_csect->reloc_count++; 4581 stub_csect->size += bfd_xcoff_stub_indirect_call_size (info->output_bfd); 4582 break; 4583 4584 case xcoff_stub_shared_call: 4585 stub_csect->reloc_count++; 4586 stub_csect->size += bfd_xcoff_stub_shared_call_size (info->output_bfd); 4587 break; 4588 } 4589 4590 /* Create the stub entry. */ 4591 hstub = xcoff_stub_hash_lookup (&htab->stub_hash_table, stub_name, 4592 true, true); 4593 if (hstub == NULL) 4594 return NULL; 4595 4596 hstub->htarget = htarget; 4597 hstub->stub_offset = stub_offset; 4598 4599 /* For indirect call or shared call, the relocations are against 4600 the target descriptor. Its toc entry will be used. */ 4601 if (stub_type == xcoff_stub_indirect_call 4602 || stub_type == xcoff_stub_shared_call) 4603 { 4604 struct xcoff_link_hash_entry *hds = htarget->descriptor; 4605 asection *hds_section = hds->root.u.def.section; 4606 4607 hstub->htarget = hds; 4608 4609 /* If the symbol haven't been marked, its section might have 4610 its size and its relocation count been deleted by xcoff_sweep. 4611 Restore it. */ 4612 if ((hds->flags & XCOFF_MARK) == 0) 4613 { 4614 if (hds_section->size == 0 4615 && hds_section->reloc_count == 0 4616 && hds_section->rawsize != 0) 4617 { 4618 hds_section->size = hds_section->rawsize; 4619 /* Always two relocations for a XMC_DS symbol. */ 4620 hds_section->reloc_count = 2; 4621 } 4622 4623 /* Mark the section and the symbol. */ 4624 if (!xcoff_mark (info, hds_section)) 4625 return NULL; 4626 } 4627 4628 /* Add a TOC entry for the descriptor if non exists. */ 4629 if (hds->toc_section == NULL) 4630 { 4631 int byte_size; 4632 4633 if (bfd_xcoff_is_xcoff64 (info->output_bfd)) 4634 byte_size = 8; 4635 else if (bfd_xcoff_is_xcoff32 (info->output_bfd)) 4636 byte_size = 4; 4637 else 4638 return NULL; 4639 4640 /* Allocate room in the fallback TOC section. */ 4641 hds->toc_section = xcoff_hash_table (info)->toc_section; 4642 hds->u.toc_offset = hds->toc_section->size; 4643 hds->toc_section->size += byte_size; 4644 if (!xcoff_mark (info, hds->toc_section)) 4645 return NULL; 4646 4647 /* Update relocation counters for a static and dynamic 4648 R_TOC relocation. */ 4649 ++hds->toc_section->reloc_count; 4650 ++htab->ldinfo.ldrel_count; 4651 4652 /* Set the index to -2 to force this symbol to 4653 get written out. */ 4654 hds->indx = -2; 4655 hds->flags |= XCOFF_SET_TOC; 4656 } 4657 } 4658 4659 return hstub; 4660 } 4661 4662 static bool 4663 xcoff_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 4664 { 4665 struct xcoff_stub_hash_entry *hstub 4666 = (struct xcoff_stub_hash_entry *) gen_entry; 4667 4668 bfd *stub_bfd; 4669 bfd *output_bfd; 4670 struct bfd_link_info *info; 4671 bfd_byte *loc; 4672 bfd_byte *p; 4673 unsigned int i; 4674 4675 info = (struct bfd_link_info *) in_arg; 4676 stub_bfd = xcoff_hash_table (info)->params->stub_bfd; 4677 output_bfd = info->output_bfd; 4678 4679 /* Fail if the target section could not be assigned to an output 4680 section. The user should fix his linker script. */ 4681 if (hstub->target_section != NULL 4682 && hstub->target_section->output_section == NULL 4683 && info->non_contiguous_regions) 4684 info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output section. " 4685 "Retry without --enable-non-contiguous-regions.\n"), 4686 hstub->target_section); 4687 4688 loc = (hstub->hcsect->root.u.def.section->contents 4689 + hstub->stub_offset); 4690 p = loc; 4691 4692 switch (hstub->stub_type) 4693 { 4694 case xcoff_stub_indirect_call: 4695 BFD_ASSERT (hstub->htarget->toc_section != NULL); 4696 /* The first instruction in the stub code needs to be 4697 cooked to hold the correct offset in the toc. It will 4698 be filled by xcoff_stub_create_relocations. */ 4699 for (i = 0; i < bfd_xcoff_stub_indirect_call_size(output_bfd) / 4; i++) 4700 bfd_put_32 (stub_bfd, 4701 (bfd_vma) bfd_xcoff_stub_indirect_call_code(output_bfd, i), 4702 &p[4 * i]); 4703 break; 4704 4705 case xcoff_stub_shared_call: 4706 BFD_ASSERT (hstub->htarget->toc_section != NULL); 4707 /* The first instruction in the glink code needs to be 4708 cooked to hold the correct offset in the toc. It will 4709 be filled by xcoff_stub_create_relocations. */ 4710 for (i = 0; i < bfd_xcoff_stub_shared_call_size(output_bfd) / 4; i++) 4711 bfd_put_32 (stub_bfd, 4712 (bfd_vma) bfd_xcoff_stub_shared_call_code(output_bfd, i), 4713 &p[4 * i]); 4714 4715 break; 4716 4717 default: 4718 BFD_FAIL (); 4719 return false; 4720 } 4721 return true; 4722 } 4723 4724 /* Check relocations and adds stubs if needed. */ 4725 4726 bool 4727 bfd_xcoff_size_stubs (struct bfd_link_info *info) 4728 { 4729 struct xcoff_link_hash_table *htab = xcoff_hash_table (info); 4730 struct xcoff_loader_info *ldinfo = &(htab->ldinfo); 4731 4732 while (1) 4733 { 4734 bfd *input_bfd; 4735 bool stub_changed = false; 4736 4737 for (input_bfd = info->input_bfds; 4738 input_bfd != NULL; 4739 input_bfd = input_bfd->link.next) 4740 { 4741 asection *section; 4742 bfd_size_type symcount; 4743 bfd_size_type symesz; 4744 bfd_byte *esyms; 4745 4746 if (bfd_get_flavour (input_bfd) != bfd_target_xcoff_flavour) 4747 continue; 4748 4749 symcount = obj_raw_syment_count (input_bfd); 4750 if (!symcount) 4751 continue; 4752 symesz = bfd_coff_symesz (input_bfd); 4753 esyms = (bfd_byte *) obj_coff_external_syms (input_bfd); 4754 4755 /* Walk over each section attached to the input bfd. */ 4756 for (section = input_bfd->sections; 4757 section != NULL; 4758 section = section->next) 4759 { 4760 struct internal_reloc *internal_relocs; 4761 struct internal_reloc *irel, *irelend; 4762 4763 /* If there aren't any relocs, then there's nothing more 4764 to do. */ 4765 if ((section->flags & SEC_RELOC) == 0 4766 || section->reloc_count == 0) 4767 continue; 4768 4769 /* If this section is a link-once section that will be 4770 discarded, then don't create any stubs. */ 4771 if (section->output_section == NULL 4772 || section->output_section->owner != info->output_bfd) 4773 continue; 4774 4775 /* This section have been garbage-collected. */ 4776 if (section->gc_mark == 0) 4777 continue; 4778 4779 /* Read in the relocs. */ 4780 internal_relocs = (xcoff_read_internal_relocs 4781 (input_bfd, section, true, NULL, 4782 false, NULL)); 4783 if (internal_relocs == NULL) 4784 goto error_ret; 4785 4786 irel = internal_relocs; 4787 irelend = irel + section->reloc_count; 4788 for (; irel < irelend; irel++) 4789 { 4790 enum xcoff_stub_type stub_type; 4791 struct xcoff_link_hash_entry *hsym = NULL; 4792 struct xcoff_link_hash_entry *hstub_csect = NULL; 4793 struct xcoff_stub_hash_entry *hstub = NULL; 4794 asection *sym_sec; 4795 bfd_vma sym_value; 4796 bfd_vma destination; 4797 char *stub_name; 4798 4799 if (irel->r_symndx == -1) 4800 continue; 4801 4802 switch (irel->r_type) 4803 { 4804 default: 4805 continue; 4806 4807 case R_BR: 4808 case R_RBR: 4809 break; 4810 } 4811 4812 /* Retrieve targeted symbol address */ 4813 hsym = obj_xcoff_sym_hashes (input_bfd)[irel->r_symndx]; 4814 if (hsym == NULL) 4815 { 4816 struct internal_syment sym; 4817 if ((long unsigned int)irel->r_symndx > symcount) 4818 { 4819 BFD_FAIL(); 4820 goto error_ret; 4821 } 4822 4823 bfd_coff_swap_sym_in (input_bfd, 4824 (void *) esyms + irel->r_symndx * symesz, 4825 (void *) &sym); 4826 4827 sym_sec = xcoff_data (input_bfd)->csects[irel->r_symndx]; 4828 sym_value = sym.n_value - sym_sec->vma; 4829 4830 destination = (sym_value 4831 + sym_sec->output_section->vma 4832 + sym_sec->output_offset); 4833 } 4834 else if (hsym->root.type == bfd_link_hash_defined 4835 || hsym->root.type == bfd_link_hash_defweak) 4836 { 4837 sym_sec = hsym->root.u.def.section; 4838 sym_value = hsym->root.u.def.value; 4839 destination = (sym_value 4840 + sym_sec->output_section->vma 4841 + sym_sec->output_offset); 4842 } 4843 else 4844 { 4845 bfd_set_error (bfd_error_bad_value); 4846 goto error_ret; 4847 } 4848 4849 /* I'm not sure how to handle this case. Skip it for now. */ 4850 if (bfd_is_abs_section (sym_sec)) 4851 continue; 4852 4853 stub_type = bfd_xcoff_type_of_stub (section, irel, destination, hsym); 4854 4855 if (stub_type == xcoff_stub_none) 4856 continue; 4857 4858 /* Get a stub csect in ranch. */ 4859 hstub_csect = xcoff_stub_get_csect_in_range (section, info, true); 4860 if (!hstub_csect) 4861 { 4862 /* xgettext:c-format */ 4863 _bfd_error_handler (_("%pB: Unable to find a stub csect in range" 4864 "of relocation at %#" PRIx64 " targeting" 4865 "'%s'"), 4866 section->owner, (uint64_t) irel->r_vaddr, 4867 hsym->root.root.string); 4868 goto error_ret; 4869 } 4870 4871 /* Get the name of this stub. */ 4872 stub_name = xcoff_stub_name (hsym, hstub_csect); 4873 if (!stub_name) 4874 goto error_ret; 4875 4876 hstub = xcoff_stub_hash_lookup (&(xcoff_hash_table (info)->stub_hash_table), 4877 stub_name, false, false); 4878 4879 /* A stub entry inside the in range csect already exists. */ 4880 if (hstub != NULL) 4881 { 4882 free (stub_name); 4883 continue; 4884 } 4885 4886 stub_changed = true; 4887 4888 hstub = xcoff_add_stub (stub_name, hstub_csect, hsym, info, stub_type); 4889 if (hstub == NULL) 4890 { 4891 /* xgettext:c-format */ 4892 _bfd_error_handler (_("%pB: Cannot create stub entry '%s'"), 4893 section->owner, stub_name); 4894 free (stub_name); 4895 goto error_ret; 4896 } 4897 4898 hstub->stub_type = stub_type; 4899 hstub->hcsect = hstub_csect; 4900 hstub->target_section = sym_sec; 4901 free (stub_name); 4902 } 4903 } 4904 } 4905 4906 if (!stub_changed) 4907 break; 4908 4909 /* Update the size of the loader. */ 4910 if (xcoff_hash_table (info)->loader_section 4911 && !xcoff_size_loader_section (ldinfo)) 4912 goto error_ret; 4913 4914 /* Ask the linker to do its stuff. */ 4915 (*htab->params->layout_sections_again) (); 4916 4917 } 4918 return true; 4919 4920 error_ret: 4921 bfd_set_error (bfd_error_bad_value); 4922 return false; 4923 } 4924 4925 bool 4926 bfd_xcoff_build_stubs (struct bfd_link_info *info) 4927 { 4928 struct xcoff_link_hash_table *htab = xcoff_hash_table (info); 4929 asection *stub_sec; 4930 4931 for (stub_sec = htab->params->stub_bfd->sections; 4932 stub_sec != NULL; 4933 stub_sec = stub_sec->next) 4934 { 4935 bfd_size_type size; 4936 4937 /* Allocate memory to hold the linker stubs. */ 4938 size = stub_sec->size; 4939 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, size); 4940 if (stub_sec->contents == NULL && size != 0) 4941 return false; 4942 4943 } 4944 4945 /* Build the stubs as directed by the stub hash table. */ 4946 bfd_hash_traverse (&htab->stub_hash_table, xcoff_build_one_stub, info); 4947 return true; 4948 } 4949 4950 /* Create and apply relocations made by a stub entry. */ 4951 static bool 4952 xcoff_stub_create_relocations (struct bfd_hash_entry *bh, void * inf) 4953 { 4954 struct xcoff_stub_hash_entry *hstub 4955 = (struct xcoff_stub_hash_entry *) bh; 4956 struct xcoff_final_link_info *flinfo 4957 = (struct xcoff_final_link_info *) inf; 4958 4959 bfd *output_bfd; 4960 struct internal_reloc *irel; 4961 struct xcoff_link_hash_entry **rel_hash; 4962 struct xcoff_link_hash_entry *htarget; 4963 asection *sec, *osec; 4964 bfd_vma off; 4965 bfd_byte *p; 4966 4967 htarget = hstub->htarget; 4968 sec = hstub->hcsect->root.u.def.section; 4969 osec = sec->output_section; 4970 4971 irel = (flinfo->section_info[osec->target_index].relocs 4972 + osec->reloc_count); 4973 rel_hash = (flinfo->section_info[osec->target_index].rel_hashes 4974 + osec->output_section->reloc_count); 4975 *rel_hash = NULL; 4976 output_bfd = flinfo->output_bfd; 4977 4978 irel->r_symndx = htarget->indx; 4979 irel->r_vaddr = (osec->vma 4980 + sec->output_offset 4981 + hstub->hcsect->root.u.def.value 4982 + hstub->stub_offset); 4983 4984 p = (sec->contents 4985 + hstub->stub_offset); 4986 4987 switch (hstub->stub_type) 4988 { 4989 default: 4990 BFD_FAIL (); 4991 return false; 4992 4993 /* The first instruction of this stub code need 4994 a R_TOC relocation. */ 4995 case xcoff_stub_indirect_call: 4996 case xcoff_stub_shared_call: 4997 irel->r_size = 0xf; 4998 irel->r_type = R_TOC; 4999 5000 /* Retrieve the toc offset of the target which is 5001 a function descriptor. */ 5002 BFD_ASSERT (htarget->toc_section != NULL); 5003 if ((htarget->flags & XCOFF_SET_TOC) != 0) 5004 off = hstub->htarget->u.toc_offset; 5005 else 5006 off = (htarget->toc_section->output_section->vma 5007 + htarget->toc_section->output_offset 5008 - xcoff_data (flinfo->output_bfd)->toc); 5009 if ((off & 0xffff) != off) 5010 { 5011 _bfd_error_handler 5012 (_("TOC overflow during stub generation; try -mminimal-toc " 5013 "when compiling")); 5014 bfd_set_error (bfd_error_file_too_big); 5015 return false; 5016 } 5017 5018 bfd_put_16 (output_bfd, off & 0xffff, p+2); 5019 break; 5020 } 5021 5022 ++osec->reloc_count; 5023 return true; 5024 } 5025 5026 5027 /* Return the section that defines H. Return null if no section does. */ 5028 5029 static asection * 5030 xcoff_symbol_section (struct xcoff_link_hash_entry *h) 5031 { 5032 switch (h->root.type) 5033 { 5034 case bfd_link_hash_defined: 5035 case bfd_link_hash_defweak: 5036 return h->root.u.def.section; 5037 5038 case bfd_link_hash_common: 5039 return h->root.u.c.p->section; 5040 5041 default: 5042 return NULL; 5043 } 5044 } 5045 5046 /* Add a .loader relocation for input relocation IREL. If the loader 5047 relocation should be against an output section, HSEC points to the 5048 input section that IREL is against, otherwise HSEC is null. H is the 5049 symbol that IREL is against, or null if it isn't against a global symbol. 5050 REFERENCE_BFD is the bfd to use in error messages about the relocation. */ 5051 5052 static bool 5053 xcoff_create_ldrel (bfd *output_bfd, struct xcoff_final_link_info *flinfo, 5054 asection *output_section, bfd *reference_bfd, 5055 struct internal_reloc *irel, asection *hsec, 5056 struct xcoff_link_hash_entry *h) 5057 { 5058 struct internal_ldrel ldrel; 5059 5060 ldrel.l_vaddr = irel->r_vaddr; 5061 if (hsec != NULL) 5062 { 5063 const char *secname; 5064 5065 secname = hsec->output_section->name; 5066 if (strcmp (secname, ".text") == 0) 5067 ldrel.l_symndx = 0; 5068 else if (strcmp (secname, ".data") == 0) 5069 ldrel.l_symndx = 1; 5070 else if (strcmp (secname, ".bss") == 0) 5071 ldrel.l_symndx = 2; 5072 else if (strcmp (secname, ".tdata") == 0) 5073 ldrel.l_symndx = -1; 5074 else if (strcmp (secname, ".tbss") == 0) 5075 ldrel.l_symndx = -2; 5076 else 5077 { 5078 _bfd_error_handler 5079 /* xgettext:c-format */ 5080 (_("%pB: loader reloc in unrecognized section `%s'"), 5081 reference_bfd, secname); 5082 bfd_set_error (bfd_error_nonrepresentable_section); 5083 return false; 5084 } 5085 } 5086 else if (h != NULL) 5087 { 5088 if (h->ldindx < 0) 5089 { 5090 _bfd_error_handler 5091 /* xgettext:c-format */ 5092 (_("%pB: `%s' in loader reloc but not loader sym"), 5093 reference_bfd, h->root.root.string); 5094 bfd_set_error (bfd_error_bad_value); 5095 return false; 5096 } 5097 ldrel.l_symndx = h->ldindx; 5098 } 5099 else 5100 ldrel.l_symndx = -(bfd_size_type) 1; 5101 5102 ldrel.l_rtype = (irel->r_size << 8) | irel->r_type; 5103 ldrel.l_rsecnm = output_section->target_index; 5104 if (xcoff_hash_table (flinfo->info)->textro 5105 && strcmp (output_section->name, ".text") == 0) 5106 { 5107 _bfd_error_handler 5108 /* xgettext:c-format */ 5109 (_("%pB: loader reloc in read-only section %pA"), 5110 reference_bfd, output_section); 5111 bfd_set_error (bfd_error_invalid_operation); 5112 return false; 5113 } 5114 bfd_xcoff_swap_ldrel_out (output_bfd, &ldrel, flinfo->ldrel); 5115 flinfo->ldrel += bfd_xcoff_ldrelsz (output_bfd); 5116 return true; 5117 } 5118 5119 /* Link an input file into the linker output file. This function 5120 handles all the sections and relocations of the input file at once. */ 5121 5122 static bool 5123 xcoff_link_input_bfd (struct xcoff_final_link_info *flinfo, 5124 bfd *input_bfd) 5125 { 5126 bfd *output_bfd; 5127 const char *strings; 5128 bfd_size_type syment_base; 5129 unsigned int n_tmask; 5130 unsigned int n_btshft; 5131 bool copy, hash; 5132 bfd_size_type isymesz; 5133 bfd_size_type osymesz; 5134 bfd_size_type linesz; 5135 bfd_byte *esym; 5136 bfd_byte *esym_end; 5137 struct xcoff_link_hash_entry **sym_hash; 5138 struct internal_syment *isymp; 5139 asection **csectpp; 5140 unsigned int *lineno_counts; 5141 long *debug_index; 5142 long *indexp; 5143 unsigned long output_index; 5144 bfd_byte *outsym; 5145 unsigned int incls; 5146 asection *oline; 5147 bool keep_syms; 5148 asection *o; 5149 5150 /* We can just skip DYNAMIC files, unless this is a static link. */ 5151 if ((input_bfd->flags & DYNAMIC) != 0 5152 && ! flinfo->info->static_link) 5153 return true; 5154 5155 /* Move all the symbols to the output file. */ 5156 output_bfd = flinfo->output_bfd; 5157 strings = NULL; 5158 syment_base = obj_raw_syment_count (output_bfd); 5159 isymesz = bfd_coff_symesz (input_bfd); 5160 osymesz = bfd_coff_symesz (output_bfd); 5161 linesz = bfd_coff_linesz (input_bfd); 5162 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd)); 5163 5164 n_tmask = coff_data (input_bfd)->local_n_tmask; 5165 n_btshft = coff_data (input_bfd)->local_n_btshft; 5166 5167 /* Define macros so that ISFCN, et. al., macros work correctly. */ 5168 #define N_TMASK n_tmask 5169 #define N_BTSHFT n_btshft 5170 5171 copy = false; 5172 if (! flinfo->info->keep_memory) 5173 copy = true; 5174 hash = true; 5175 if (flinfo->info->traditional_format) 5176 hash = false; 5177 5178 if (! _bfd_coff_get_external_symbols (input_bfd)) 5179 return false; 5180 5181 /* Make one pass over the symbols and assign indices to symbols that 5182 we have decided to keep. Also use create .loader symbol information 5183 and update information in hash table entries. */ 5184 esym = (bfd_byte *) obj_coff_external_syms (input_bfd); 5185 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; 5186 sym_hash = obj_xcoff_sym_hashes (input_bfd); 5187 csectpp = xcoff_data (input_bfd)->csects; 5188 debug_index = xcoff_data (input_bfd)->debug_indices; 5189 isymp = flinfo->internal_syms; 5190 indexp = flinfo->sym_indices; 5191 output_index = syment_base; 5192 while (esym < esym_end) 5193 { 5194 union internal_auxent aux; 5195 int smtyp = 0; 5196 int add; 5197 5198 bfd_coff_swap_sym_in (input_bfd, (void *) esym, (void *) isymp); 5199 5200 /* Read in the csect information, if any. */ 5201 if (CSECT_SYM_P (isymp->n_sclass)) 5202 { 5203 BFD_ASSERT (isymp->n_numaux > 0); 5204 bfd_coff_swap_aux_in (input_bfd, 5205 (void *) (esym + isymesz * isymp->n_numaux), 5206 isymp->n_type, isymp->n_sclass, 5207 isymp->n_numaux - 1, isymp->n_numaux, 5208 (void *) &aux); 5209 5210 smtyp = SMTYP_SMTYP (aux.x_csect.x_smtyp); 5211 } 5212 5213 /* If this symbol is in the .loader section, swap out the 5214 .loader symbol information. If this is an external symbol 5215 reference to a defined symbol, though, then wait until we get 5216 to the definition. */ 5217 if (EXTERN_SYM_P (isymp->n_sclass) 5218 && *sym_hash != NULL 5219 && (*sym_hash)->ldsym != NULL 5220 && xcoff_final_definition_p (input_bfd, *sym_hash, *csectpp)) 5221 { 5222 struct xcoff_link_hash_entry *h; 5223 struct internal_ldsym *ldsym; 5224 5225 h = *sym_hash; 5226 ldsym = h->ldsym; 5227 if (isymp->n_scnum > 0) 5228 { 5229 ldsym->l_scnum = (*csectpp)->output_section->target_index; 5230 ldsym->l_value = (isymp->n_value 5231 + (*csectpp)->output_section->vma 5232 + (*csectpp)->output_offset 5233 - (*csectpp)->vma); 5234 } 5235 else 5236 { 5237 ldsym->l_scnum = isymp->n_scnum; 5238 ldsym->l_value = isymp->n_value; 5239 } 5240 5241 ldsym->l_smtype = smtyp; 5242 if (((h->flags & XCOFF_DEF_REGULAR) == 0 5243 && (h->flags & XCOFF_DEF_DYNAMIC) != 0) 5244 || (h->flags & XCOFF_IMPORT) != 0) 5245 ldsym->l_smtype |= L_IMPORT; 5246 if (((h->flags & XCOFF_DEF_REGULAR) != 0 5247 && (h->flags & XCOFF_DEF_DYNAMIC) != 0) 5248 || (h->flags & XCOFF_EXPORT) != 0) 5249 ldsym->l_smtype |= L_EXPORT; 5250 if ((h->flags & XCOFF_ENTRY) != 0) 5251 ldsym->l_smtype |= L_ENTRY; 5252 if (isymp->n_sclass == C_AIX_WEAKEXT) 5253 ldsym->l_smtype |= L_WEAK; 5254 5255 ldsym->l_smclas = aux.x_csect.x_smclas; 5256 5257 if (ldsym->l_ifile == (bfd_size_type) -1) 5258 ldsym->l_ifile = 0; 5259 else if (ldsym->l_ifile == 0) 5260 { 5261 if ((ldsym->l_smtype & L_IMPORT) == 0) 5262 ldsym->l_ifile = 0; 5263 else 5264 { 5265 bfd *impbfd; 5266 5267 if (h->root.type == bfd_link_hash_defined 5268 || h->root.type == bfd_link_hash_defweak) 5269 impbfd = h->root.u.def.section->owner; 5270 else if (h->root.type == bfd_link_hash_undefined 5271 || h->root.type == bfd_link_hash_undefweak) 5272 impbfd = h->root.u.undef.abfd; 5273 else 5274 impbfd = NULL; 5275 5276 if (impbfd == NULL) 5277 ldsym->l_ifile = 0; 5278 else 5279 { 5280 BFD_ASSERT (impbfd->xvec == flinfo->output_bfd->xvec); 5281 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id; 5282 } 5283 } 5284 } 5285 5286 ldsym->l_parm = 0; 5287 5288 BFD_ASSERT (h->ldindx >= 0); 5289 bfd_xcoff_swap_ldsym_out (flinfo->output_bfd, ldsym, 5290 (flinfo->ldsym 5291 + ((h->ldindx - 3) 5292 * bfd_xcoff_ldsymsz (flinfo->output_bfd)))); 5293 h->ldsym = NULL; 5294 5295 /* Fill in snentry now that we know the target_index. */ 5296 if ((h->flags & XCOFF_ENTRY) != 0 5297 && (h->root.type == bfd_link_hash_defined 5298 || h->root.type == bfd_link_hash_defweak)) 5299 { 5300 xcoff_data (output_bfd)->snentry = 5301 h->root.u.def.section->output_section->target_index; 5302 } 5303 } 5304 5305 add = 1 + isymp->n_numaux; 5306 5307 if (*debug_index == -2) 5308 /* We've decided to strip this symbol. */ 5309 *indexp = -1; 5310 else 5311 { 5312 /* Assign the next unused index to this symbol. */ 5313 *indexp = output_index; 5314 5315 if (EXTERN_SYM_P (isymp->n_sclass)) 5316 { 5317 BFD_ASSERT (*sym_hash != NULL); 5318 (*sym_hash)->indx = output_index; 5319 } 5320 5321 /* If this is a symbol in the TOC which we may have merged 5322 (class XMC_TC), remember the symbol index of the TOC 5323 symbol. */ 5324 if (isymp->n_sclass == C_HIDEXT 5325 && aux.x_csect.x_smclas == XMC_TC 5326 && *sym_hash != NULL) 5327 { 5328 BFD_ASSERT (((*sym_hash)->flags & XCOFF_SET_TOC) == 0); 5329 BFD_ASSERT ((*sym_hash)->toc_section != NULL); 5330 (*sym_hash)->u.toc_indx = output_index; 5331 } 5332 5333 output_index += add; 5334 } 5335 5336 esym += add * isymesz; 5337 isymp += add; 5338 csectpp += add; 5339 sym_hash += add; 5340 debug_index += add; 5341 ++indexp; 5342 for (--add; add > 0; --add) 5343 *indexp++ = -1; 5344 } 5345 5346 /* Now write out the symbols that we decided to keep. */ 5347 5348 esym = (bfd_byte *) obj_coff_external_syms (input_bfd); 5349 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; 5350 sym_hash = obj_xcoff_sym_hashes (input_bfd); 5351 isymp = flinfo->internal_syms; 5352 indexp = flinfo->sym_indices; 5353 csectpp = xcoff_data (input_bfd)->csects; 5354 lineno_counts = xcoff_data (input_bfd)->lineno_counts; 5355 debug_index = xcoff_data (input_bfd)->debug_indices; 5356 outsym = flinfo->outsyms; 5357 incls = 0; 5358 oline = NULL; 5359 while (esym < esym_end) 5360 { 5361 int add; 5362 5363 add = 1 + isymp->n_numaux; 5364 5365 if (*indexp < 0) 5366 esym += add * isymesz; 5367 else 5368 { 5369 struct internal_syment isym; 5370 int i; 5371 5372 /* Adjust the symbol in order to output it. */ 5373 isym = *isymp; 5374 if (isym._n._n_n._n_zeroes == 0 5375 && isym._n._n_n._n_offset != 0) 5376 { 5377 /* This symbol has a long name. Enter it in the string 5378 table we are building. If *debug_index != -1, the 5379 name has already been entered in the .debug section. */ 5380 if (*debug_index >= 0) 5381 isym._n._n_n._n_offset = *debug_index; 5382 else 5383 { 5384 const char *name; 5385 bfd_size_type indx; 5386 5387 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL); 5388 5389 if (name == NULL) 5390 return false; 5391 indx = _bfd_stringtab_add (flinfo->strtab, name, hash, copy); 5392 if (indx == (bfd_size_type) -1) 5393 return false; 5394 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; 5395 } 5396 } 5397 5398 /* Make __rtinit C_HIDEXT rather than C_EXT. This avoids 5399 multiple definition problems when linking a shared object 5400 statically. (The native linker doesn't enter __rtinit into 5401 the normal table at all, but having a local symbol can make 5402 the objdump output easier to read.) */ 5403 if (isym.n_sclass == C_EXT 5404 && *sym_hash 5405 && ((*sym_hash)->flags & XCOFF_RTINIT) != 0) 5406 isym.n_sclass = C_HIDEXT; 5407 5408 /* The value of a C_FILE symbol is the symbol index of the 5409 next C_FILE symbol. The value of the last C_FILE symbol 5410 is -1. We try to get this right, below, just before we 5411 write the symbols out, but in the general case we may 5412 have to write the symbol out twice. */ 5413 if (isym.n_sclass == C_FILE) 5414 { 5415 if (flinfo->last_file_index != -1 5416 && flinfo->last_file.n_value != (bfd_vma) *indexp) 5417 { 5418 /* We must correct the value of the last C_FILE entry. */ 5419 flinfo->last_file.n_value = *indexp; 5420 if ((bfd_size_type) flinfo->last_file_index >= syment_base) 5421 { 5422 /* The last C_FILE symbol is in this input file. */ 5423 bfd_coff_swap_sym_out (output_bfd, 5424 (void *) &flinfo->last_file, 5425 (void *) (flinfo->outsyms 5426 + ((flinfo->last_file_index 5427 - syment_base) 5428 * osymesz))); 5429 } 5430 else 5431 { 5432 /* We have already written out the last C_FILE 5433 symbol. We need to write it out again. We 5434 borrow *outsym temporarily. */ 5435 file_ptr pos; 5436 5437 bfd_coff_swap_sym_out (output_bfd, 5438 (void *) &flinfo->last_file, 5439 (void *) outsym); 5440 5441 pos = obj_sym_filepos (output_bfd); 5442 pos += flinfo->last_file_index * osymesz; 5443 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 5444 || (bfd_write (outsym, osymesz, output_bfd) 5445 != osymesz)) 5446 return false; 5447 } 5448 } 5449 5450 flinfo->last_file_index = *indexp; 5451 flinfo->last_file = isym; 5452 } 5453 5454 /* The value of a C_BINCL or C_EINCL symbol is a file offset 5455 into the line numbers. We update the symbol values when 5456 we handle the line numbers. */ 5457 if (isym.n_sclass == C_BINCL 5458 || isym.n_sclass == C_EINCL) 5459 { 5460 isym.n_value = flinfo->line_filepos; 5461 ++incls; 5462 } 5463 /* The value of a C_BSTAT symbol is the symbol table 5464 index of the containing csect. */ 5465 else if (isym.n_sclass == C_BSTAT) 5466 { 5467 bfd_vma indx; 5468 5469 indx = isym.n_value; 5470 if (indx < obj_raw_syment_count (input_bfd)) 5471 { 5472 long symindx; 5473 5474 symindx = flinfo->sym_indices[indx]; 5475 if (symindx < 0) 5476 isym.n_value = 0; 5477 else 5478 isym.n_value = symindx; 5479 } 5480 } 5481 else if (isym.n_sclass != C_ESTAT 5482 && isym.n_sclass != C_DECL 5483 && isym.n_scnum > 0) 5484 { 5485 isym.n_scnum = (*csectpp)->output_section->target_index; 5486 isym.n_value += ((*csectpp)->output_section->vma 5487 + (*csectpp)->output_offset 5488 - (*csectpp)->vma); 5489 } 5490 5491 /* Update visibility. */ 5492 if (*sym_hash) 5493 { 5494 isym.n_type &= ~SYM_V_MASK; 5495 isym.n_type |= (*sym_hash)->visibility; 5496 } 5497 5498 /* Output the symbol. */ 5499 bfd_coff_swap_sym_out (output_bfd, (void *) &isym, (void *) outsym); 5500 5501 esym += isymesz; 5502 outsym += osymesz; 5503 5504 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++) 5505 { 5506 union internal_auxent aux; 5507 5508 bfd_coff_swap_aux_in (input_bfd, (void *) esym, isymp->n_type, 5509 isymp->n_sclass, i, isymp->n_numaux, 5510 (void *) &aux); 5511 5512 if (isymp->n_sclass == C_FILE) 5513 { 5514 /* This is the file name (or some comment put in by 5515 the compiler). If it is long, we must put it in 5516 the string table. */ 5517 if (aux.x_file.x_n.x_n.x_zeroes == 0 5518 && aux.x_file.x_n.x_n.x_offset != 0) 5519 { 5520 const char *filename; 5521 bfd_size_type indx; 5522 5523 BFD_ASSERT (aux.x_file.x_n.x_n.x_offset 5524 >= STRING_SIZE_SIZE); 5525 if (strings == NULL) 5526 { 5527 strings = _bfd_coff_read_string_table (input_bfd); 5528 if (strings == NULL) 5529 return false; 5530 } 5531 if ((bfd_size_type) aux.x_file.x_n.x_n.x_offset >= obj_coff_strings_len (input_bfd)) 5532 filename = _("<corrupt>"); 5533 else 5534 filename = strings + aux.x_file.x_n.x_n.x_offset; 5535 indx = _bfd_stringtab_add (flinfo->strtab, filename, 5536 hash, copy); 5537 if (indx == (bfd_size_type) -1) 5538 return false; 5539 aux.x_file.x_n.x_n.x_offset = STRING_SIZE_SIZE + indx; 5540 } 5541 } 5542 else if (CSECT_SYM_P (isymp->n_sclass) 5543 && i + 1 == isymp->n_numaux) 5544 { 5545 5546 /* We don't support type checking. I don't know if 5547 anybody does. */ 5548 aux.x_csect.x_parmhash = 0; 5549 /* I don't think anybody uses these fields, but we'd 5550 better clobber them just in case. */ 5551 aux.x_csect.x_stab = 0; 5552 aux.x_csect.x_snstab = 0; 5553 5554 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_LD) 5555 { 5556 unsigned long indx; 5557 5558 indx = aux.x_csect.x_scnlen.u64; 5559 if (indx < obj_raw_syment_count (input_bfd)) 5560 { 5561 long symindx; 5562 5563 symindx = flinfo->sym_indices[indx]; 5564 if (symindx < 0) 5565 { 5566 aux.x_csect.x_scnlen.u64 = 0; 5567 } 5568 else 5569 { 5570 aux.x_csect.x_scnlen.u64 = symindx; 5571 } 5572 } 5573 } 5574 } 5575 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL) 5576 { 5577 unsigned long indx; 5578 5579 if (ISFCN (isymp->n_type) 5580 || ISTAG (isymp->n_sclass) 5581 || isymp->n_sclass == C_BLOCK 5582 || isymp->n_sclass == C_FCN) 5583 { 5584 indx = aux.x_sym.x_fcnary.x_fcn.x_endndx.u32; 5585 if (indx > 0 5586 && indx < obj_raw_syment_count (input_bfd)) 5587 { 5588 /* We look forward through the symbol for 5589 the index of the next symbol we are going 5590 to include. I don't know if this is 5591 entirely right. */ 5592 while (flinfo->sym_indices[indx] < 0 5593 && indx < obj_raw_syment_count (input_bfd)) 5594 ++indx; 5595 if (indx >= obj_raw_syment_count (input_bfd)) 5596 indx = output_index; 5597 else 5598 indx = flinfo->sym_indices[indx]; 5599 aux.x_sym.x_fcnary.x_fcn.x_endndx.u32 = indx; 5600 5601 } 5602 } 5603 5604 indx = aux.x_sym.x_tagndx.u32; 5605 if (indx > 0 && indx < obj_raw_syment_count (input_bfd)) 5606 { 5607 long symindx; 5608 5609 symindx = flinfo->sym_indices[indx]; 5610 if (symindx < 0) 5611 aux.x_sym.x_tagndx.u32 = 0; 5612 else 5613 aux.x_sym.x_tagndx.u32 = symindx; 5614 } 5615 5616 } 5617 5618 /* Copy over the line numbers, unless we are stripping 5619 them. We do this on a symbol by symbol basis in 5620 order to more easily handle garbage collection. */ 5621 if (CSECT_SYM_P (isymp->n_sclass) 5622 && i == 0 5623 && isymp->n_numaux > 1 5624 && ISFCN (isymp->n_type) 5625 && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0) 5626 { 5627 if (*lineno_counts == 0) 5628 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0; 5629 else 5630 { 5631 asection *enclosing; 5632 unsigned int enc_count; 5633 bfd_signed_vma linoff; 5634 struct internal_lineno lin; 5635 bfd_byte *linp; 5636 bfd_byte *linpend; 5637 bfd_vma offset; 5638 file_ptr pos; 5639 bfd_size_type amt; 5640 5641 /* Read in the enclosing section's line-number 5642 information, if we haven't already. */ 5643 o = *csectpp; 5644 enclosing = xcoff_section_data (abfd, o)->enclosing; 5645 enc_count = xcoff_section_data (abfd, o)->lineno_count; 5646 if (oline != enclosing) 5647 { 5648 pos = enclosing->line_filepos; 5649 amt = linesz * enc_count; 5650 if (bfd_seek (input_bfd, pos, SEEK_SET) != 0 5651 || (bfd_read (flinfo->linenos, amt, input_bfd) 5652 != amt)) 5653 return false; 5654 oline = enclosing; 5655 } 5656 5657 /* Copy across the first entry, adjusting its 5658 symbol index. */ 5659 linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr 5660 - enclosing->line_filepos); 5661 linp = flinfo->linenos + linoff; 5662 bfd_coff_swap_lineno_in (input_bfd, linp, &lin); 5663 lin.l_addr.l_symndx = *indexp; 5664 bfd_coff_swap_lineno_out (output_bfd, &lin, linp); 5665 5666 /* Copy the other entries, adjusting their addresses. */ 5667 linpend = linp + *lineno_counts * linesz; 5668 offset = (o->output_section->vma 5669 + o->output_offset 5670 - o->vma); 5671 for (linp += linesz; linp < linpend; linp += linesz) 5672 { 5673 bfd_coff_swap_lineno_in (input_bfd, linp, &lin); 5674 lin.l_addr.l_paddr += offset; 5675 bfd_coff_swap_lineno_out (output_bfd, &lin, linp); 5676 } 5677 5678 /* Write out the entries we've just processed. */ 5679 pos = (o->output_section->line_filepos 5680 + o->output_section->lineno_count * linesz); 5681 amt = linesz * *lineno_counts; 5682 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 5683 || bfd_write (flinfo->linenos + linoff, amt, 5684 output_bfd) != amt) 5685 return false; 5686 o->output_section->lineno_count += *lineno_counts; 5687 5688 /* Record the offset of the symbol's line numbers 5689 in the output file. */ 5690 aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = pos; 5691 5692 if (incls > 0) 5693 { 5694 struct internal_syment *iisp, *iispend; 5695 long *iindp; 5696 bfd_byte *oos; 5697 bfd_vma range_start, range_end; 5698 int iiadd; 5699 5700 /* Update any C_BINCL or C_EINCL symbols 5701 that refer to a line number in the 5702 range we just output. */ 5703 iisp = flinfo->internal_syms; 5704 iispend = iisp + obj_raw_syment_count (input_bfd); 5705 iindp = flinfo->sym_indices; 5706 oos = flinfo->outsyms; 5707 range_start = enclosing->line_filepos + linoff; 5708 range_end = range_start + *lineno_counts * linesz; 5709 while (iisp < iispend) 5710 { 5711 if (*iindp >= 0 5712 && (iisp->n_sclass == C_BINCL 5713 || iisp->n_sclass == C_EINCL) 5714 && iisp->n_value >= range_start 5715 && iisp->n_value < range_end) 5716 { 5717 struct internal_syment iis; 5718 5719 bfd_coff_swap_sym_in (output_bfd, oos, &iis); 5720 iis.n_value = (iisp->n_value 5721 - range_start 5722 + pos); 5723 bfd_coff_swap_sym_out (output_bfd, 5724 &iis, oos); 5725 --incls; 5726 } 5727 5728 iiadd = 1 + iisp->n_numaux; 5729 if (*iindp >= 0) 5730 oos += iiadd * osymesz; 5731 iisp += iiadd; 5732 iindp += iiadd; 5733 } 5734 } 5735 } 5736 } 5737 5738 bfd_coff_swap_aux_out (output_bfd, (void *) &aux, isymp->n_type, 5739 isymp->n_sclass, i, isymp->n_numaux, 5740 (void *) outsym); 5741 outsym += osymesz; 5742 esym += isymesz; 5743 } 5744 } 5745 5746 sym_hash += add; 5747 indexp += add; 5748 isymp += add; 5749 csectpp += add; 5750 lineno_counts += add; 5751 debug_index += add; 5752 } 5753 5754 /* If we swapped out a C_FILE symbol, guess that the next C_FILE 5755 symbol will be the first symbol in the next input file. In the 5756 normal case, this will save us from writing out the C_FILE symbol 5757 again. */ 5758 if (flinfo->last_file_index != -1 5759 && (bfd_size_type) flinfo->last_file_index >= syment_base) 5760 { 5761 flinfo->last_file.n_value = output_index; 5762 bfd_coff_swap_sym_out (output_bfd, (void *) &flinfo->last_file, 5763 (void *) (flinfo->outsyms 5764 + ((flinfo->last_file_index - syment_base) 5765 * osymesz))); 5766 } 5767 5768 /* Write the modified symbols to the output file. */ 5769 if (outsym > flinfo->outsyms) 5770 { 5771 file_ptr pos = obj_sym_filepos (output_bfd) + syment_base * osymesz; 5772 bfd_size_type amt = outsym - flinfo->outsyms; 5773 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 5774 || bfd_write (flinfo->outsyms, amt, output_bfd) != amt) 5775 return false; 5776 5777 BFD_ASSERT ((obj_raw_syment_count (output_bfd) 5778 + (outsym - flinfo->outsyms) / osymesz) 5779 == output_index); 5780 5781 obj_raw_syment_count (output_bfd) = output_index; 5782 } 5783 5784 /* Don't let the linker relocation routines discard the symbols. */ 5785 keep_syms = obj_coff_keep_syms (input_bfd); 5786 obj_coff_keep_syms (input_bfd) = true; 5787 5788 /* Relocate the contents of each section. */ 5789 for (o = input_bfd->sections; o != NULL; o = o->next) 5790 { 5791 bfd_byte *contents; 5792 5793 if (! o->linker_mark) 5794 /* This section was omitted from the link. */ 5795 continue; 5796 5797 if ((o->flags & SEC_HAS_CONTENTS) == 0 5798 || o->size == 0 5799 || (o->flags & SEC_IN_MEMORY) != 0) 5800 continue; 5801 5802 /* We have set filepos correctly for the sections we created to 5803 represent csects, so bfd_get_section_contents should work. */ 5804 if (coff_section_data (input_bfd, o) != NULL 5805 && coff_section_data (input_bfd, o)->contents != NULL) 5806 contents = coff_section_data (input_bfd, o)->contents; 5807 else 5808 { 5809 bfd_size_type sz = o->rawsize ? o->rawsize : o->size; 5810 if (!bfd_get_section_contents (input_bfd, o, flinfo->contents, 0, sz)) 5811 goto err_out; 5812 contents = flinfo->contents; 5813 } 5814 5815 if ((o->flags & SEC_RELOC) != 0) 5816 { 5817 int target_index; 5818 struct internal_reloc *internal_relocs; 5819 struct internal_reloc *irel; 5820 bfd_vma offset; 5821 struct internal_reloc *irelend; 5822 struct xcoff_link_hash_entry **rel_hash; 5823 long r_symndx; 5824 5825 /* Read in the relocs. */ 5826 target_index = o->output_section->target_index; 5827 internal_relocs = (xcoff_read_internal_relocs 5828 (input_bfd, o, false, flinfo->external_relocs, 5829 true, 5830 (flinfo->section_info[target_index].relocs 5831 + o->output_section->reloc_count))); 5832 if (internal_relocs == NULL) 5833 goto err_out; 5834 5835 /* Call processor specific code to relocate the section 5836 contents. */ 5837 if (! bfd_coff_relocate_section (output_bfd, flinfo->info, 5838 input_bfd, o, 5839 contents, 5840 internal_relocs, 5841 flinfo->internal_syms, 5842 xcoff_data (input_bfd)->csects)) 5843 goto err_out; 5844 5845 offset = o->output_section->vma + o->output_offset - o->vma; 5846 irel = internal_relocs; 5847 irelend = irel + o->reloc_count; 5848 rel_hash = (flinfo->section_info[target_index].rel_hashes 5849 + o->output_section->reloc_count); 5850 for (; irel < irelend; irel++, rel_hash++) 5851 { 5852 struct xcoff_link_hash_entry *h = NULL; 5853 5854 *rel_hash = NULL; 5855 5856 /* Adjust the reloc address and symbol index. */ 5857 5858 r_symndx = irel->r_symndx; 5859 5860 if (r_symndx == -1) 5861 h = NULL; 5862 else 5863 h = obj_xcoff_sym_hashes (input_bfd)[r_symndx]; 5864 5865 /* In case of a R_BR or R_RBR, change the target if 5866 a stub is being called. */ 5867 if (h != NULL 5868 && (irel->r_type == R_BR 5869 || irel->r_type == R_RBR)) 5870 { 5871 asection *sym_sec; 5872 bfd_vma dest; 5873 struct xcoff_stub_hash_entry *hstub = NULL; 5874 enum xcoff_stub_type stub_type; 5875 5876 if (h->root.type == bfd_link_hash_defined 5877 || h->root.type == bfd_link_hash_defweak) 5878 { 5879 sym_sec = h->root.u.def.section; 5880 dest = (h->root.u.def.value 5881 + sym_sec->output_section->vma 5882 + sym_sec->output_offset); 5883 } 5884 else 5885 { 5886 BFD_FAIL (); 5887 goto err_out; 5888 } 5889 5890 stub_type = bfd_xcoff_type_of_stub (o, irel, dest, h); 5891 if (stub_type != xcoff_stub_none) 5892 { 5893 hstub = bfd_xcoff_get_stub_entry (o, h, flinfo->info); 5894 if (hstub == NULL) 5895 goto err_out; 5896 5897 h = hstub->hcsect; 5898 } 5899 5900 } 5901 5902 irel->r_vaddr += offset; 5903 5904 if (r_symndx != -1 && flinfo->info->strip != strip_all) 5905 { 5906 5907 if (h != NULL 5908 && h->smclas != XMC_TD 5909 && (irel->r_type == R_TOC 5910 || irel->r_type == R_GL 5911 || irel->r_type == R_TCL 5912 || irel->r_type == R_TRL 5913 || irel->r_type == R_TRLA)) 5914 { 5915 /* This is a TOC relative reloc with a symbol 5916 attached. The symbol should be the one which 5917 this reloc is for. We want to make this 5918 reloc against the TOC address of the symbol, 5919 not the symbol itself. */ 5920 BFD_ASSERT (h->toc_section != NULL); 5921 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0); 5922 if (h->u.toc_indx != -1) 5923 irel->r_symndx = h->u.toc_indx; 5924 else 5925 { 5926 struct xcoff_toc_rel_hash *n; 5927 struct xcoff_link_section_info *si; 5928 size_t amt; 5929 5930 amt = sizeof (* n); 5931 n = bfd_alloc (flinfo->output_bfd, amt); 5932 if (n == NULL) 5933 goto err_out; 5934 si = flinfo->section_info + target_index; 5935 n->next = si->toc_rel_hashes; 5936 n->h = h; 5937 n->rel = irel; 5938 si->toc_rel_hashes = n; 5939 } 5940 } 5941 else if (h != NULL) 5942 { 5943 /* This is a global symbol. */ 5944 if (h->indx >= 0) 5945 irel->r_symndx = h->indx; 5946 else 5947 { 5948 /* This symbol is being written at the end 5949 of the file, and we do not yet know the 5950 symbol index. We save the pointer to the 5951 hash table entry in the rel_hash list. 5952 We set the indx field to -2 to indicate 5953 that this symbol must not be stripped. */ 5954 *rel_hash = h; 5955 h->indx = -2; 5956 } 5957 } 5958 else 5959 { 5960 long indx; 5961 5962 indx = flinfo->sym_indices[r_symndx]; 5963 5964 if (indx == -1) 5965 { 5966 struct internal_syment *is; 5967 5968 /* Relocations against a TC0 TOC anchor are 5969 automatically transformed to be against 5970 the TOC anchor in the output file. */ 5971 is = flinfo->internal_syms + r_symndx; 5972 if (is->n_sclass == C_HIDEXT 5973 && is->n_numaux > 0) 5974 { 5975 void * auxptr; 5976 union internal_auxent aux; 5977 5978 auxptr = ((void *) 5979 (((bfd_byte *) 5980 obj_coff_external_syms (input_bfd)) 5981 + ((r_symndx + is->n_numaux) 5982 * isymesz))); 5983 bfd_coff_swap_aux_in (input_bfd, auxptr, 5984 is->n_type, is->n_sclass, 5985 is->n_numaux - 1, 5986 is->n_numaux, 5987 (void *) &aux); 5988 if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD 5989 && aux.x_csect.x_smclas == XMC_TC0) 5990 indx = flinfo->toc_symindx; 5991 } 5992 } 5993 5994 if (indx != -1) 5995 irel->r_symndx = indx; 5996 else 5997 { 5998 5999 struct internal_syment *is; 6000 6001 const char *name; 6002 char buf[SYMNMLEN + 1]; 6003 6004 /* This reloc is against a symbol we are 6005 stripping. It would be possible to handle 6006 this case, but I don't think it's worth it. */ 6007 is = flinfo->internal_syms + r_symndx; 6008 6009 if (is->n_sclass != C_DWARF) 6010 { 6011 name = (_bfd_coff_internal_syment_name 6012 (input_bfd, is, buf)); 6013 6014 if (name == NULL) 6015 goto err_out; 6016 6017 (*flinfo->info->callbacks->unattached_reloc) 6018 (flinfo->info, name, 6019 input_bfd, o, irel->r_vaddr); 6020 } 6021 } 6022 } 6023 } 6024 6025 if ((o->flags & SEC_DEBUGGING) == 0 6026 && xcoff_need_ldrel_p (flinfo->info, irel, h, o)) 6027 { 6028 asection *sec; 6029 6030 if (r_symndx == -1) 6031 sec = NULL; 6032 else if (h == NULL) 6033 sec = xcoff_data (input_bfd)->csects[r_symndx]; 6034 else 6035 sec = xcoff_symbol_section (h); 6036 if (!xcoff_create_ldrel (output_bfd, flinfo, 6037 o->output_section, input_bfd, 6038 irel, sec, h)) 6039 goto err_out; 6040 } 6041 } 6042 6043 o->output_section->reloc_count += o->reloc_count; 6044 } 6045 6046 /* Write out the modified section contents. */ 6047 if (! bfd_set_section_contents (output_bfd, o->output_section, 6048 contents, (file_ptr) o->output_offset, 6049 o->size)) 6050 goto err_out; 6051 } 6052 6053 obj_coff_keep_syms (input_bfd) = keep_syms; 6054 6055 if (! flinfo->info->keep_memory) 6056 { 6057 if (! _bfd_coff_free_symbols (input_bfd)) 6058 return false; 6059 } 6060 6061 return true; 6062 6063 err_out: 6064 obj_coff_keep_syms (input_bfd) = keep_syms; 6065 return false; 6066 } 6067 6068 #undef N_TMASK 6069 #undef N_BTSHFT 6070 6071 /* Sort relocs by VMA. This is called via qsort. */ 6072 6073 static int 6074 xcoff_sort_relocs (const void * p1, const void * p2) 6075 { 6076 const struct internal_reloc *r1 = (const struct internal_reloc *) p1; 6077 const struct internal_reloc *r2 = (const struct internal_reloc *) p2; 6078 6079 if (r1->r_vaddr > r2->r_vaddr) 6080 return 1; 6081 else if (r1->r_vaddr < r2->r_vaddr) 6082 return -1; 6083 else 6084 return 0; 6085 } 6086 6087 /* Return true if section SEC is a TOC section. */ 6088 6089 static inline bool 6090 xcoff_toc_section_p (asection *sec) 6091 { 6092 const char *name; 6093 6094 name = sec->name; 6095 if (name[0] == '.' && name[1] == 't') 6096 { 6097 if (name[2] == 'c') 6098 { 6099 if (name[3] == '0' && name[4] == 0) 6100 return true; 6101 if (name[3] == 0) 6102 return true; 6103 } 6104 if (name[2] == 'd' && name[3] == 0) 6105 return true; 6106 } 6107 return false; 6108 } 6109 6110 /* See if the link requires a TOC (it usually does!). If so, find a 6111 good place to put the TOC anchor csect, and write out the associated 6112 symbol. */ 6113 6114 static bool 6115 xcoff_find_tc0 (bfd *output_bfd, struct xcoff_final_link_info *flinfo) 6116 { 6117 bfd_vma toc_start, toc_end, start, end, best_address; 6118 asection *sec; 6119 bfd *input_bfd; 6120 int section_index; 6121 struct internal_syment irsym; 6122 union internal_auxent iraux; 6123 file_ptr pos; 6124 size_t size; 6125 6126 /* Set [TOC_START, TOC_END) to the range of the TOC. Record the 6127 index of a csect at the beginning of the TOC. */ 6128 toc_start = ~(bfd_vma) 0; 6129 toc_end = 0; 6130 section_index = -1; 6131 for (input_bfd = flinfo->info->input_bfds; 6132 input_bfd != NULL; 6133 input_bfd = input_bfd->link.next) 6134 for (sec = input_bfd->sections; sec != NULL; sec = sec->next) 6135 if (sec->gc_mark != 0 && xcoff_toc_section_p (sec)) 6136 { 6137 start = sec->output_section->vma + sec->output_offset; 6138 if (toc_start > start) 6139 { 6140 toc_start = start; 6141 section_index = sec->output_section->target_index; 6142 } 6143 6144 end = start + sec->size; 6145 if (toc_end < end) 6146 toc_end = end; 6147 } 6148 6149 /* There's no need for a TC0 symbol if we don't have a TOC. */ 6150 if (toc_end < toc_start) 6151 { 6152 xcoff_data (output_bfd)->toc = toc_start; 6153 return true; 6154 } 6155 6156 if (toc_end - toc_start < 0x8000) 6157 /* Every TOC csect can be accessed from TOC_START. */ 6158 best_address = toc_start; 6159 else 6160 { 6161 /* Find the lowest TOC csect that is still within range of TOC_END. */ 6162 best_address = toc_end; 6163 for (input_bfd = flinfo->info->input_bfds; 6164 input_bfd != NULL; 6165 input_bfd = input_bfd->link.next) 6166 for (sec = input_bfd->sections; sec != NULL; sec = sec->next) 6167 if (sec->gc_mark != 0 && xcoff_toc_section_p (sec)) 6168 { 6169 start = sec->output_section->vma + sec->output_offset; 6170 if (start < best_address 6171 && start + 0x8000 >= toc_end) 6172 { 6173 best_address = start; 6174 section_index = sec->output_section->target_index; 6175 } 6176 } 6177 6178 /* Make sure that the start of the TOC is also within range. */ 6179 if (best_address > toc_start + 0x8000) 6180 { 6181 _bfd_error_handler 6182 (_("TOC overflow: %#" PRIx64 " > 0x10000; try -mminimal-toc " 6183 "when compiling"), 6184 (uint64_t) (toc_end - toc_start)); 6185 bfd_set_error (bfd_error_file_too_big); 6186 return false; 6187 } 6188 } 6189 6190 /* Record the chosen TOC value. */ 6191 flinfo->toc_symindx = obj_raw_syment_count (output_bfd); 6192 xcoff_data (output_bfd)->toc = best_address; 6193 xcoff_data (output_bfd)->sntoc = section_index; 6194 6195 /* Fill out the TC0 symbol. */ 6196 if (!bfd_xcoff_put_symbol_name (output_bfd, flinfo->info, flinfo->strtab, 6197 &irsym, "TOC")) 6198 return false; 6199 irsym.n_value = best_address; 6200 irsym.n_scnum = section_index; 6201 irsym.n_sclass = C_HIDEXT; 6202 irsym.n_type = T_NULL; 6203 irsym.n_numaux = 1; 6204 bfd_coff_swap_sym_out (output_bfd, &irsym, flinfo->outsyms); 6205 6206 /* Fill out the auxiliary csect information. */ 6207 memset (&iraux, 0, sizeof iraux); 6208 iraux.x_csect.x_smtyp = XTY_SD; 6209 iraux.x_csect.x_smclas = XMC_TC0; 6210 iraux.x_csect.x_scnlen.u64 = 0; 6211 bfd_coff_swap_aux_out (output_bfd, &iraux, T_NULL, C_HIDEXT, 0, 1, 6212 flinfo->outsyms + bfd_coff_symesz (output_bfd)); 6213 6214 /* Write the contents to the file. */ 6215 pos = obj_sym_filepos (output_bfd); 6216 pos += obj_raw_syment_count (output_bfd) * bfd_coff_symesz (output_bfd); 6217 size = 2 * bfd_coff_symesz (output_bfd); 6218 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 6219 || bfd_write (flinfo->outsyms, size, output_bfd) != size) 6220 return false; 6221 obj_raw_syment_count (output_bfd) += 2; 6222 6223 return true; 6224 } 6225 6226 /* Write out a non-XCOFF global symbol. */ 6227 6228 static bool 6229 xcoff_write_global_symbol (struct bfd_hash_entry *bh, void * inf) 6230 { 6231 struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) bh; 6232 struct xcoff_final_link_info *flinfo = (struct xcoff_final_link_info *) inf; 6233 bfd *output_bfd; 6234 bfd_byte *outsym; 6235 struct internal_syment isym; 6236 union internal_auxent aux; 6237 bool result; 6238 file_ptr pos; 6239 bfd_size_type amt; 6240 6241 output_bfd = flinfo->output_bfd; 6242 outsym = flinfo->outsyms; 6243 6244 if (h->root.type == bfd_link_hash_warning) 6245 { 6246 h = (struct xcoff_link_hash_entry *) h->root.u.i.link; 6247 if (h->root.type == bfd_link_hash_new) 6248 return true; 6249 } 6250 6251 /* If this symbol was garbage collected, just skip it. */ 6252 if (xcoff_hash_table (flinfo->info)->gc 6253 && (h->flags & XCOFF_MARK) == 0) 6254 return true; 6255 6256 /* If we need a .loader section entry, write it out. */ 6257 if (h->ldsym != NULL) 6258 { 6259 struct internal_ldsym *ldsym; 6260 bfd *impbfd; 6261 6262 ldsym = h->ldsym; 6263 6264 if (h->root.type == bfd_link_hash_undefined 6265 || h->root.type == bfd_link_hash_undefweak) 6266 { 6267 6268 ldsym->l_value = 0; 6269 ldsym->l_scnum = N_UNDEF; 6270 ldsym->l_smtype = XTY_ER; 6271 impbfd = h->root.u.undef.abfd; 6272 6273 } 6274 else if (h->root.type == bfd_link_hash_defined 6275 || h->root.type == bfd_link_hash_defweak) 6276 { 6277 asection *sec; 6278 6279 sec = h->root.u.def.section; 6280 ldsym->l_value = (sec->output_section->vma 6281 + sec->output_offset 6282 + h->root.u.def.value); 6283 ldsym->l_scnum = sec->output_section->target_index; 6284 ldsym->l_smtype = XTY_SD; 6285 impbfd = sec->owner; 6286 6287 } 6288 else 6289 abort (); 6290 6291 if (((h->flags & XCOFF_DEF_REGULAR) == 0 6292 && (h->flags & XCOFF_DEF_DYNAMIC) != 0) 6293 || (h->flags & XCOFF_IMPORT) != 0) 6294 /* Clear l_smtype 6295 Import symbols are defined so the check above will make 6296 the l_smtype XTY_SD. But this is not correct, it should 6297 be cleared. */ 6298 ldsym->l_smtype |= L_IMPORT; 6299 6300 if (((h->flags & XCOFF_DEF_REGULAR) != 0 6301 && (h->flags & XCOFF_DEF_DYNAMIC) != 0) 6302 || (h->flags & XCOFF_EXPORT) != 0) 6303 ldsym->l_smtype |= L_EXPORT; 6304 6305 if ((h->flags & XCOFF_ENTRY) != 0) 6306 ldsym->l_smtype |= L_ENTRY; 6307 6308 if ((h->flags & XCOFF_RTINIT) != 0) 6309 ldsym->l_smtype = XTY_SD; 6310 6311 ldsym->l_smclas = h->smclas; 6312 6313 if (ldsym->l_smtype & L_IMPORT) 6314 { 6315 if ((h->root.type == bfd_link_hash_defined 6316 || h->root.type == bfd_link_hash_defweak) 6317 && (h->root.u.def.value != 0)) 6318 ldsym->l_smclas = XMC_XO; 6319 6320 else if ((h->flags & (XCOFF_SYSCALL32 | XCOFF_SYSCALL64)) == 6321 (XCOFF_SYSCALL32 | XCOFF_SYSCALL64)) 6322 ldsym->l_smclas = XMC_SV3264; 6323 6324 else if (h->flags & XCOFF_SYSCALL32) 6325 ldsym->l_smclas = XMC_SV; 6326 6327 else if (h->flags & XCOFF_SYSCALL64) 6328 ldsym->l_smclas = XMC_SV64; 6329 } 6330 6331 if (ldsym->l_ifile == -(bfd_size_type) 1) 6332 { 6333 ldsym->l_ifile = 0; 6334 } 6335 else if (ldsym->l_ifile == 0) 6336 { 6337 if ((ldsym->l_smtype & L_IMPORT) == 0) 6338 ldsym->l_ifile = 0; 6339 else if (impbfd == NULL) 6340 ldsym->l_ifile = 0; 6341 else 6342 { 6343 BFD_ASSERT (impbfd->xvec == output_bfd->xvec); 6344 ldsym->l_ifile = xcoff_data (impbfd)->import_file_id; 6345 } 6346 } 6347 6348 ldsym->l_parm = 0; 6349 6350 BFD_ASSERT (h->ldindx >= 0); 6351 6352 bfd_xcoff_swap_ldsym_out (output_bfd, ldsym, 6353 (flinfo->ldsym + 6354 (h->ldindx - 3) 6355 * bfd_xcoff_ldsymsz(flinfo->output_bfd))); 6356 h->ldsym = NULL; 6357 } 6358 6359 /* If this symbol needs global linkage code, write it out. */ 6360 if (h->root.type == bfd_link_hash_defined 6361 && (h->root.u.def.section 6362 == xcoff_hash_table (flinfo->info)->linkage_section)) 6363 { 6364 bfd_byte *p; 6365 bfd_vma tocoff; 6366 unsigned int i; 6367 6368 p = h->root.u.def.section->contents + h->root.u.def.value; 6369 6370 /* The first instruction in the global linkage code loads a 6371 specific TOC element. */ 6372 tocoff = (h->descriptor->toc_section->output_section->vma 6373 + h->descriptor->toc_section->output_offset 6374 - xcoff_data (output_bfd)->toc); 6375 6376 if ((h->descriptor->flags & XCOFF_SET_TOC) != 0) 6377 tocoff += h->descriptor->u.toc_offset; 6378 6379 /* The first instruction in the glink code needs to be 6380 cooked to hold the correct offset in the toc. The 6381 rest are just output raw. */ 6382 bfd_put_32 (output_bfd, 6383 bfd_xcoff_glink_code(output_bfd, 0) | (tocoff & 0xffff), p); 6384 6385 /* Start with i == 1 to get past the first instruction done above 6386 The /4 is because the glink code is in bytes and we are going 6387 4 at a pop. */ 6388 for (i = 1; i < bfd_xcoff_glink_code_size(output_bfd) / 4; i++) 6389 bfd_put_32 (output_bfd, 6390 (bfd_vma) bfd_xcoff_glink_code(output_bfd, i), 6391 &p[4 * i]); 6392 } 6393 6394 /* If we created a TOC entry for this symbol, write out the required 6395 relocs. */ 6396 if ((h->flags & XCOFF_SET_TOC) != 0) 6397 { 6398 asection *tocsec; 6399 asection *osec; 6400 int oindx; 6401 struct internal_reloc *irel; 6402 struct internal_syment irsym; 6403 union internal_auxent iraux; 6404 6405 tocsec = h->toc_section; 6406 osec = tocsec->output_section; 6407 oindx = osec->target_index; 6408 irel = flinfo->section_info[oindx].relocs + osec->reloc_count; 6409 irel->r_vaddr = (osec->vma 6410 + tocsec->output_offset 6411 + h->u.toc_offset); 6412 6413 if (h->indx >= 0) 6414 irel->r_symndx = h->indx; 6415 else 6416 { 6417 h->indx = -2; 6418 irel->r_symndx = obj_raw_syment_count (output_bfd); 6419 } 6420 6421 /* Initialize the aux union here instead of closer to when it is 6422 written out below because the length of the csect depends on 6423 whether the output is 32 or 64 bit. */ 6424 memset (&iraux, 0, sizeof iraux); 6425 iraux.x_csect.x_smtyp = XTY_SD; 6426 /* iraux.x_csect.x_scnlen.u64 = 4 or 8, see below. */ 6427 iraux.x_csect.x_smclas = XMC_TC; 6428 6429 /* 32 bit uses a 32 bit R_POS to do the relocations 6430 64 bit uses a 64 bit R_POS to do the relocations 6431 6432 Also needs to change the csect size : 4 for 32 bit, 8 for 64 bit 6433 6434 Which one is determined by the backend. */ 6435 if (bfd_xcoff_is_xcoff64 (output_bfd)) 6436 { 6437 irel->r_size = 63; 6438 iraux.x_csect.x_scnlen.u64 = 8; 6439 } 6440 else if (bfd_xcoff_is_xcoff32 (output_bfd)) 6441 { 6442 irel->r_size = 31; 6443 iraux.x_csect.x_scnlen.u64 = 4; 6444 } 6445 else 6446 return false; 6447 6448 irel->r_type = R_POS; 6449 flinfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL; 6450 ++osec->reloc_count; 6451 6452 /* There are two kind of linker-created TOC entry. 6453 The ones importing their symbols from outside, made for the 6454 global linkage. These symbols have XCOFF_LDREL set and only 6455 requires a loader relocation on their imported symbol. 6456 On the other hand, symbols without XCOFF_LDREL are TOC entries 6457 of internal symbols (like function descriptors made for stubs). 6458 These symbols needs a loader relocation over .data and this 6459 relocation must be applied. */ 6460 6461 if ((h->flags & XCOFF_LDREL) != 0 6462 && h->ldindx >= 0) 6463 { 6464 if (!xcoff_create_ldrel (output_bfd, flinfo, osec, 6465 output_bfd, irel, NULL, h)) 6466 return false; 6467 } 6468 else 6469 { 6470 bfd_byte *p; 6471 bfd_vma val; 6472 6473 p = tocsec->contents + h->u.toc_offset; 6474 val = (h->root.u.def.value 6475 + h->root.u.def.section->output_section->vma 6476 + h->root.u.def.section->output_offset); 6477 6478 if (bfd_xcoff_is_xcoff64 (output_bfd)) 6479 bfd_put_64 (output_bfd, val, p); 6480 else if (bfd_xcoff_is_xcoff32 (output_bfd)) 6481 bfd_put_32 (output_bfd, val, p); 6482 else 6483 return false; 6484 6485 if (!xcoff_create_ldrel (output_bfd, flinfo, osec, 6486 output_bfd, irel, h->root.u.def.section, h)) 6487 return false; 6488 } 6489 6490 /* We need to emit a symbol to define a csect which holds 6491 the reloc. */ 6492 if (flinfo->info->strip != strip_all) 6493 { 6494 result = bfd_xcoff_put_symbol_name (output_bfd, flinfo->info, 6495 flinfo->strtab, 6496 &irsym, h->root.root.string); 6497 if (!result) 6498 return false; 6499 6500 irsym.n_value = irel->r_vaddr; 6501 irsym.n_scnum = osec->target_index; 6502 irsym.n_sclass = C_HIDEXT; 6503 irsym.n_type = T_NULL; 6504 irsym.n_numaux = 1; 6505 6506 bfd_coff_swap_sym_out (output_bfd, (void *) &irsym, (void *) outsym); 6507 outsym += bfd_coff_symesz (output_bfd); 6508 6509 /* Note : iraux is initialized above. */ 6510 bfd_coff_swap_aux_out (output_bfd, (void *) &iraux, T_NULL, C_HIDEXT, 6511 0, 1, (void *) outsym); 6512 outsym += bfd_coff_auxesz (output_bfd); 6513 6514 if (h->indx >= 0) 6515 { 6516 /* We aren't going to write out the symbols below, so we 6517 need to write them out now. */ 6518 pos = obj_sym_filepos (output_bfd); 6519 pos += (obj_raw_syment_count (output_bfd) 6520 * bfd_coff_symesz (output_bfd)); 6521 amt = outsym - flinfo->outsyms; 6522 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 6523 || bfd_write (flinfo->outsyms, amt, output_bfd) != amt) 6524 return false; 6525 obj_raw_syment_count (output_bfd) += 6526 (outsym - flinfo->outsyms) / bfd_coff_symesz (output_bfd); 6527 6528 outsym = flinfo->outsyms; 6529 } 6530 } 6531 } 6532 6533 /* If this symbol is a specially defined function descriptor, write 6534 it out. The first word is the address of the function code 6535 itself, the second word is the address of the TOC, and the third 6536 word is zero. 6537 6538 32 bit vs 64 bit 6539 The addresses for the 32 bit will take 4 bytes and the addresses 6540 for 64 bit will take 8 bytes. Similar for the relocs. This type 6541 of logic was also done above to create a TOC entry in 6542 xcoff_write_global_symbol. */ 6543 if ((h->flags & XCOFF_DESCRIPTOR) != 0 6544 && h->root.type == bfd_link_hash_defined 6545 && (h->root.u.def.section 6546 == xcoff_hash_table (flinfo->info)->descriptor_section)) 6547 { 6548 asection *sec; 6549 asection *osec; 6550 int oindx; 6551 bfd_byte *p; 6552 struct xcoff_link_hash_entry *hentry; 6553 asection *esec; 6554 struct internal_reloc *irel; 6555 asection *tsec; 6556 unsigned int reloc_size, byte_size; 6557 6558 if (bfd_xcoff_is_xcoff64 (output_bfd)) 6559 { 6560 reloc_size = 63; 6561 byte_size = 8; 6562 } 6563 else if (bfd_xcoff_is_xcoff32 (output_bfd)) 6564 { 6565 reloc_size = 31; 6566 byte_size = 4; 6567 } 6568 else 6569 return false; 6570 6571 sec = h->root.u.def.section; 6572 osec = sec->output_section; 6573 oindx = osec->target_index; 6574 p = sec->contents + h->root.u.def.value; 6575 6576 hentry = h->descriptor; 6577 BFD_ASSERT (hentry != NULL 6578 && (hentry->root.type == bfd_link_hash_defined 6579 || hentry->root.type == bfd_link_hash_defweak)); 6580 esec = hentry->root.u.def.section; 6581 6582 irel = flinfo->section_info[oindx].relocs + osec->reloc_count; 6583 irel->r_vaddr = (osec->vma 6584 + sec->output_offset 6585 + h->root.u.def.value); 6586 irel->r_symndx = esec->output_section->target_index; 6587 irel->r_type = R_POS; 6588 irel->r_size = reloc_size; 6589 flinfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL; 6590 ++osec->reloc_count; 6591 6592 if (!xcoff_create_ldrel (output_bfd, flinfo, osec, 6593 output_bfd, irel, esec, NULL)) 6594 return false; 6595 6596 /* There are three items to write out, 6597 the address of the code 6598 the address of the toc anchor 6599 the environment pointer. 6600 We are ignoring the environment pointer. So set it to zero. */ 6601 if (bfd_xcoff_is_xcoff64 (output_bfd)) 6602 { 6603 bfd_put_64 (output_bfd, 6604 (esec->output_section->vma + esec->output_offset 6605 + hentry->root.u.def.value), 6606 p); 6607 bfd_put_64 (output_bfd, xcoff_data (output_bfd)->toc, p + 8); 6608 bfd_put_64 (output_bfd, (bfd_vma) 0, p + 16); 6609 } 6610 else 6611 { 6612 /* 32 bit backend 6613 This logic was already called above so the error case where 6614 the backend is neither has already been checked. */ 6615 bfd_put_32 (output_bfd, 6616 (esec->output_section->vma + esec->output_offset 6617 + hentry->root.u.def.value), 6618 p); 6619 bfd_put_32 (output_bfd, xcoff_data (output_bfd)->toc, p + 4); 6620 bfd_put_32 (output_bfd, (bfd_vma) 0, p + 8); 6621 } 6622 6623 tsec = coff_section_from_bfd_index (output_bfd, 6624 xcoff_data (output_bfd)->sntoc); 6625 6626 ++irel; 6627 irel->r_vaddr = (osec->vma 6628 + sec->output_offset 6629 + h->root.u.def.value 6630 + byte_size); 6631 irel->r_symndx = tsec->output_section->target_index; 6632 irel->r_type = R_POS; 6633 irel->r_size = reloc_size; 6634 flinfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL; 6635 ++osec->reloc_count; 6636 6637 if (!xcoff_create_ldrel (output_bfd, flinfo, osec, 6638 output_bfd, irel, tsec, NULL)) 6639 return false; 6640 } 6641 6642 if (h->indx >= 0 || flinfo->info->strip == strip_all) 6643 { 6644 BFD_ASSERT (outsym == flinfo->outsyms); 6645 return true; 6646 } 6647 6648 if (h->indx != -2 6649 && (flinfo->info->strip == strip_all 6650 || (flinfo->info->strip == strip_some 6651 && bfd_hash_lookup (flinfo->info->keep_hash, h->root.root.string, 6652 false, false) == NULL))) 6653 { 6654 BFD_ASSERT (outsym == flinfo->outsyms); 6655 return true; 6656 } 6657 6658 if (h->indx != -2 6659 && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0) 6660 { 6661 BFD_ASSERT (outsym == flinfo->outsyms); 6662 return true; 6663 } 6664 6665 memset (&aux, 0, sizeof aux); 6666 6667 h->indx = obj_raw_syment_count (output_bfd); 6668 6669 result = bfd_xcoff_put_symbol_name (output_bfd, flinfo->info, flinfo->strtab, 6670 &isym, h->root.root.string); 6671 if (!result) 6672 return false; 6673 6674 if (h->root.type == bfd_link_hash_undefined 6675 || h->root.type == bfd_link_hash_undefweak) 6676 { 6677 isym.n_value = 0; 6678 isym.n_scnum = N_UNDEF; 6679 if (h->root.type == bfd_link_hash_undefweak 6680 && C_WEAKEXT == C_AIX_WEAKEXT) 6681 isym.n_sclass = C_WEAKEXT; 6682 else 6683 isym.n_sclass = C_EXT; 6684 aux.x_csect.x_smtyp = XTY_ER; 6685 } 6686 else if ((h->root.type == bfd_link_hash_defined 6687 || h->root.type == bfd_link_hash_defweak) 6688 && h->smclas == XMC_XO) 6689 { 6690 BFD_ASSERT (bfd_is_abs_symbol (&h->root)); 6691 isym.n_value = h->root.u.def.value; 6692 isym.n_scnum = N_UNDEF; 6693 if (h->root.type == bfd_link_hash_defweak 6694 && C_WEAKEXT == C_AIX_WEAKEXT) 6695 isym.n_sclass = C_WEAKEXT; 6696 else 6697 isym.n_sclass = C_EXT; 6698 aux.x_csect.x_smtyp = XTY_ER; 6699 } 6700 else if (h->root.type == bfd_link_hash_defined 6701 || h->root.type == bfd_link_hash_defweak) 6702 { 6703 struct xcoff_link_size_list *l; 6704 6705 isym.n_value = (h->root.u.def.section->output_section->vma 6706 + h->root.u.def.section->output_offset 6707 + h->root.u.def.value); 6708 if (bfd_is_abs_section (h->root.u.def.section->output_section)) 6709 isym.n_scnum = N_ABS; 6710 else 6711 isym.n_scnum = h->root.u.def.section->output_section->target_index; 6712 isym.n_sclass = C_HIDEXT; 6713 aux.x_csect.x_smtyp = XTY_SD; 6714 6715 /* For stub symbols, the section already has its correct size. */ 6716 if (h->root.u.def.section->owner == xcoff_hash_table (flinfo->info)->params->stub_bfd) 6717 { 6718 aux.x_csect.x_scnlen.u64 = h->root.u.def.section->size; 6719 } 6720 else if ((h->flags & XCOFF_HAS_SIZE) != 0) 6721 { 6722 for (l = xcoff_hash_table (flinfo->info)->size_list; 6723 l != NULL; 6724 l = l->next) 6725 { 6726 if (l->h == h) 6727 { 6728 aux.x_csect.x_scnlen.u64 = l->size; 6729 break; 6730 } 6731 } 6732 } 6733 } 6734 else if (h->root.type == bfd_link_hash_common) 6735 { 6736 isym.n_value = (h->root.u.c.p->section->output_section->vma 6737 + h->root.u.c.p->section->output_offset); 6738 isym.n_scnum = h->root.u.c.p->section->output_section->target_index; 6739 isym.n_sclass = C_EXT; 6740 aux.x_csect.x_smtyp = XTY_CM; 6741 aux.x_csect.x_scnlen.u64 = h->root.u.c.size; 6742 } 6743 else 6744 abort (); 6745 6746 isym.n_type = T_NULL; 6747 isym.n_numaux = 1; 6748 6749 bfd_coff_swap_sym_out (output_bfd, (void *) &isym, (void *) outsym); 6750 outsym += bfd_coff_symesz (output_bfd); 6751 6752 aux.x_csect.x_smclas = h->smclas; 6753 bfd_coff_swap_aux_out (output_bfd, (void *) &aux, T_NULL, isym.n_sclass, 0, 1, 6754 (void *) outsym); 6755 outsym += bfd_coff_auxesz (output_bfd); 6756 6757 if ((h->root.type == bfd_link_hash_defined 6758 || h->root.type == bfd_link_hash_defweak) 6759 && h->smclas != XMC_XO) 6760 { 6761 /* We just output an SD symbol. Now output an LD symbol. */ 6762 h->indx += 2; 6763 6764 if (h->root.type == bfd_link_hash_defweak 6765 && C_WEAKEXT == C_AIX_WEAKEXT) 6766 isym.n_sclass = C_WEAKEXT; 6767 else 6768 isym.n_sclass = C_EXT; 6769 bfd_coff_swap_sym_out (output_bfd, (void *) &isym, (void *) outsym); 6770 outsym += bfd_coff_symesz (output_bfd); 6771 6772 aux.x_csect.x_smtyp = XTY_LD; 6773 aux.x_csect.x_scnlen.u64 = obj_raw_syment_count (output_bfd); 6774 bfd_coff_swap_aux_out (output_bfd, (void *) &aux, T_NULL, C_EXT, 0, 1, 6775 (void *) outsym); 6776 outsym += bfd_coff_auxesz (output_bfd); 6777 } 6778 6779 pos = obj_sym_filepos (output_bfd); 6780 pos += obj_raw_syment_count (output_bfd) * bfd_coff_symesz (output_bfd); 6781 amt = outsym - flinfo->outsyms; 6782 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 6783 || bfd_write (flinfo->outsyms, amt, output_bfd) != amt) 6784 return false; 6785 obj_raw_syment_count (output_bfd) += 6786 (outsym - flinfo->outsyms) / bfd_coff_symesz (output_bfd); 6787 6788 return true; 6789 } 6790 6791 /* Handle a link order which is supposed to generate a reloc. */ 6792 6793 static bool 6794 xcoff_reloc_link_order (bfd *output_bfd, 6795 struct xcoff_final_link_info *flinfo, 6796 asection *output_section, 6797 struct bfd_link_order *link_order) 6798 { 6799 reloc_howto_type *howto; 6800 struct xcoff_link_hash_entry *h; 6801 asection *hsec; 6802 bfd_vma hval; 6803 bfd_vma addend; 6804 struct internal_reloc *irel; 6805 struct xcoff_link_hash_entry **rel_hash_ptr; 6806 6807 if (link_order->type == bfd_section_reloc_link_order) 6808 /* We need to somehow locate a symbol in the right section. The 6809 symbol must either have a value of zero, or we must adjust 6810 the addend by the value of the symbol. FIXME: Write this 6811 when we need it. The old linker couldn't handle this anyhow. */ 6812 abort (); 6813 6814 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 6815 if (howto == NULL) 6816 { 6817 bfd_set_error (bfd_error_bad_value); 6818 return false; 6819 } 6820 6821 h = ((struct xcoff_link_hash_entry *) 6822 bfd_wrapped_link_hash_lookup (output_bfd, flinfo->info, 6823 link_order->u.reloc.p->u.name, 6824 false, false, true)); 6825 if (h == NULL) 6826 { 6827 (*flinfo->info->callbacks->unattached_reloc) 6828 (flinfo->info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0); 6829 return true; 6830 } 6831 6832 hsec = xcoff_symbol_section (h); 6833 if (h->root.type == bfd_link_hash_defined 6834 || h->root.type == bfd_link_hash_defweak) 6835 hval = h->root.u.def.value; 6836 else 6837 hval = 0; 6838 6839 addend = link_order->u.reloc.p->addend; 6840 if (hsec != NULL) 6841 addend += (hsec->output_section->vma 6842 + hsec->output_offset 6843 + hval); 6844 6845 if (addend != 0) 6846 { 6847 bfd_size_type size; 6848 bfd_byte *buf; 6849 bfd_reloc_status_type rstat; 6850 bool ok; 6851 6852 size = bfd_get_reloc_size (howto); 6853 buf = bfd_zmalloc (size); 6854 if (buf == NULL && size != 0) 6855 return false; 6856 6857 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf); 6858 switch (rstat) 6859 { 6860 case bfd_reloc_ok: 6861 break; 6862 default: 6863 case bfd_reloc_outofrange: 6864 abort (); 6865 case bfd_reloc_overflow: 6866 (*flinfo->info->callbacks->reloc_overflow) 6867 (flinfo->info, NULL, link_order->u.reloc.p->u.name, 6868 howto->name, addend, NULL, NULL, (bfd_vma) 0); 6869 break; 6870 } 6871 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf, 6872 (file_ptr) link_order->offset, size); 6873 free (buf); 6874 if (! ok) 6875 return false; 6876 } 6877 6878 /* Store the reloc information in the right place. It will get 6879 swapped and written out at the end of the final_link routine. */ 6880 irel = (flinfo->section_info[output_section->target_index].relocs 6881 + output_section->reloc_count); 6882 rel_hash_ptr = (flinfo->section_info[output_section->target_index].rel_hashes 6883 + output_section->reloc_count); 6884 6885 memset (irel, 0, sizeof (struct internal_reloc)); 6886 *rel_hash_ptr = NULL; 6887 6888 irel->r_vaddr = output_section->vma + link_order->offset; 6889 6890 if (h->indx >= 0) 6891 irel->r_symndx = h->indx; 6892 else 6893 { 6894 /* Set the index to -2 to force this symbol to get written out. */ 6895 h->indx = -2; 6896 *rel_hash_ptr = h; 6897 irel->r_symndx = 0; 6898 } 6899 6900 irel->r_type = howto->type; 6901 irel->r_size = howto->bitsize - 1; 6902 if (howto->complain_on_overflow == complain_overflow_signed) 6903 irel->r_size |= 0x80; 6904 6905 ++output_section->reloc_count; 6906 6907 /* Now output the reloc to the .loader section. */ 6908 if (xcoff_hash_table (flinfo->info)->loader_section) 6909 { 6910 if (!xcoff_create_ldrel (output_bfd, flinfo, output_section, 6911 output_bfd, irel, hsec, h)) 6912 return false; 6913 } 6914 6915 return true; 6916 } 6917 6918 /* Do the final link step. */ 6919 6920 bool 6921 _bfd_xcoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info) 6922 { 6923 bfd_size_type symesz; 6924 struct xcoff_final_link_info flinfo; 6925 asection *o; 6926 struct bfd_link_order *p; 6927 bfd_size_type max_contents_size; 6928 bfd_size_type max_sym_count; 6929 bfd_size_type max_lineno_count; 6930 bfd_size_type max_reloc_count; 6931 bfd_size_type max_output_reloc_count; 6932 file_ptr rel_filepos; 6933 unsigned int relsz; 6934 file_ptr line_filepos; 6935 unsigned int linesz; 6936 bfd *sub; 6937 bfd_byte *external_relocs = NULL; 6938 char strbuf[STRING_SIZE_SIZE]; 6939 file_ptr pos; 6940 bfd_size_type amt; 6941 6942 if (bfd_link_pic (info)) 6943 abfd->flags |= DYNAMIC; 6944 6945 symesz = bfd_coff_symesz (abfd); 6946 6947 flinfo.info = info; 6948 flinfo.output_bfd = abfd; 6949 flinfo.strtab = NULL; 6950 flinfo.section_info = NULL; 6951 flinfo.last_file_index = -1; 6952 flinfo.toc_symindx = -1; 6953 flinfo.internal_syms = NULL; 6954 flinfo.sym_indices = NULL; 6955 flinfo.outsyms = NULL; 6956 flinfo.linenos = NULL; 6957 flinfo.contents = NULL; 6958 flinfo.external_relocs = NULL; 6959 6960 if (xcoff_hash_table (info)->loader_section) 6961 { 6962 flinfo.ldsym = (xcoff_hash_table (info)->loader_section->contents 6963 + bfd_xcoff_ldhdrsz (abfd)); 6964 flinfo.ldrel = (xcoff_hash_table (info)->loader_section->contents 6965 + bfd_xcoff_ldhdrsz (abfd) 6966 + (xcoff_hash_table (info)->ldhdr.l_nsyms 6967 * bfd_xcoff_ldsymsz (abfd))); 6968 } 6969 else 6970 { 6971 flinfo.ldsym = NULL; 6972 flinfo.ldrel = NULL; 6973 } 6974 6975 xcoff_data (abfd)->coff.link_info = info; 6976 6977 flinfo.strtab = _bfd_stringtab_init (); 6978 if (flinfo.strtab == NULL) 6979 goto error_return; 6980 6981 /* Count the relocation entries required for the output file. 6982 (We've already counted the line numbers.) Determine a few 6983 maximum sizes. */ 6984 max_contents_size = 0; 6985 max_lineno_count = 0; 6986 max_reloc_count = 0; 6987 for (o = abfd->sections; o != NULL; o = o->next) 6988 { 6989 o->reloc_count = 0; 6990 for (p = o->map_head.link_order; p != NULL; p = p->next) 6991 { 6992 if (p->type == bfd_indirect_link_order) 6993 { 6994 asection *sec; 6995 6996 sec = p->u.indirect.section; 6997 6998 /* Mark all sections which are to be included in the 6999 link. This will normally be every section. We need 7000 to do this so that we can identify any sections which 7001 the linker has decided to not include. */ 7002 sec->linker_mark = true; 7003 7004 o->reloc_count += sec->reloc_count; 7005 7006 if ((sec->flags & SEC_IN_MEMORY) == 0) 7007 { 7008 if (sec->rawsize > max_contents_size) 7009 max_contents_size = sec->rawsize; 7010 if (sec->size > max_contents_size) 7011 max_contents_size = sec->size; 7012 } 7013 if (coff_section_data (sec->owner, sec) != NULL 7014 && xcoff_section_data (sec->owner, sec) != NULL 7015 && (xcoff_section_data (sec->owner, sec)->lineno_count 7016 > max_lineno_count)) 7017 max_lineno_count = 7018 xcoff_section_data (sec->owner, sec)->lineno_count; 7019 if (sec->reloc_count > max_reloc_count) 7020 max_reloc_count = sec->reloc_count; 7021 } 7022 else if (p->type == bfd_section_reloc_link_order 7023 || p->type == bfd_symbol_reloc_link_order) 7024 ++o->reloc_count; 7025 } 7026 } 7027 7028 /* Compute the file positions for all the sections. */ 7029 if (abfd->output_has_begun) 7030 { 7031 if (xcoff_hash_table (info)->file_align != 0) 7032 abort (); 7033 } 7034 else 7035 { 7036 bfd_vma file_align; 7037 7038 file_align = xcoff_hash_table (info)->file_align; 7039 if (file_align != 0) 7040 { 7041 bool saw_contents; 7042 int indx; 7043 file_ptr sofar; 7044 7045 /* Insert .pad sections before every section which has 7046 contents and is loaded, if it is preceded by some other 7047 section which has contents and is loaded. */ 7048 saw_contents = true; 7049 for (o = abfd->sections; o != NULL; o = o->next) 7050 { 7051 if (strcmp (o->name, ".pad") == 0) 7052 saw_contents = false; 7053 else if ((o->flags & SEC_HAS_CONTENTS) != 0 7054 && (o->flags & SEC_LOAD) != 0) 7055 { 7056 if (! saw_contents) 7057 saw_contents = true; 7058 else 7059 { 7060 asection *n; 7061 7062 /* Create a pad section and place it before the section 7063 that needs padding. This requires unlinking and 7064 relinking the bfd's section list. */ 7065 7066 n = bfd_make_section_anyway_with_flags (abfd, ".pad", 7067 SEC_HAS_CONTENTS); 7068 n->alignment_power = 0; 7069 7070 bfd_section_list_remove (abfd, n); 7071 bfd_section_list_insert_before (abfd, o, n); 7072 saw_contents = false; 7073 } 7074 } 7075 } 7076 7077 /* Reset the section indices after inserting the new 7078 sections. */ 7079 if (xcoff_data (abfd)->coff.section_by_target_index) 7080 htab_empty (xcoff_data (abfd)->coff.section_by_target_index); 7081 indx = 0; 7082 for (o = abfd->sections; o != NULL; o = o->next) 7083 { 7084 ++indx; 7085 o->target_index = indx; 7086 } 7087 BFD_ASSERT ((unsigned int) indx == abfd->section_count); 7088 7089 /* Work out appropriate sizes for the .pad sections to force 7090 each section to land on a page boundary. This bit of 7091 code knows what compute_section_file_positions is going 7092 to do. */ 7093 sofar = bfd_coff_filhsz (abfd); 7094 sofar += bfd_coff_aoutsz (abfd); 7095 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 7096 for (o = abfd->sections; o != NULL; o = o->next) 7097 if ((bfd_xcoff_is_reloc_count_overflow 7098 (abfd, (bfd_vma) o->reloc_count)) 7099 || (bfd_xcoff_is_lineno_count_overflow 7100 (abfd, (bfd_vma) o->lineno_count))) 7101 /* 64 does not overflow, need to check if 32 does */ 7102 sofar += bfd_coff_scnhsz (abfd); 7103 7104 for (o = abfd->sections; o != NULL; o = o->next) 7105 { 7106 if (strcmp (o->name, ".pad") == 0) 7107 { 7108 bfd_vma pageoff; 7109 7110 BFD_ASSERT (o->size == 0); 7111 pageoff = sofar & (file_align - 1); 7112 if (pageoff != 0) 7113 { 7114 o->size = file_align - pageoff; 7115 sofar += file_align - pageoff; 7116 o->flags |= SEC_HAS_CONTENTS; 7117 } 7118 } 7119 else 7120 { 7121 if ((o->flags & SEC_HAS_CONTENTS) != 0) 7122 sofar += BFD_ALIGN (o->size, 7123 1 << o->alignment_power); 7124 } 7125 } 7126 } 7127 7128 if (! bfd_coff_compute_section_file_positions (abfd)) 7129 goto error_return; 7130 } 7131 7132 /* Allocate space for the pointers we need to keep for the relocs. */ 7133 { 7134 unsigned int i; 7135 7136 /* We use section_count + 1, rather than section_count, because 7137 the target_index fields are 1 based. */ 7138 amt = abfd->section_count + 1; 7139 amt *= sizeof (struct xcoff_link_section_info); 7140 flinfo.section_info = bfd_malloc (amt); 7141 if (flinfo.section_info == NULL) 7142 goto error_return; 7143 for (i = 0; i <= abfd->section_count; i++) 7144 { 7145 flinfo.section_info[i].relocs = NULL; 7146 flinfo.section_info[i].rel_hashes = NULL; 7147 flinfo.section_info[i].toc_rel_hashes = NULL; 7148 } 7149 } 7150 7151 /* Set the file positions for the relocs. */ 7152 rel_filepos = obj_relocbase (abfd); 7153 relsz = bfd_coff_relsz (abfd); 7154 max_output_reloc_count = 0; 7155 for (o = abfd->sections; o != NULL; o = o->next) 7156 { 7157 if (o->reloc_count == 0) 7158 o->rel_filepos = 0; 7159 else 7160 { 7161 /* A stripped file has no relocs. However, we still 7162 allocate the buffers, so that later code doesn't have to 7163 worry about whether we are stripping or not. */ 7164 if (info->strip == strip_all) 7165 o->rel_filepos = 0; 7166 else 7167 { 7168 o->flags |= SEC_RELOC; 7169 o->rel_filepos = rel_filepos; 7170 rel_filepos += o->reloc_count * relsz; 7171 } 7172 7173 /* We don't know the indices of global symbols until we have 7174 written out all the local symbols. For each section in 7175 the output file, we keep an array of pointers to hash 7176 table entries. Each entry in the array corresponds to a 7177 reloc. When we find a reloc against a global symbol, we 7178 set the corresponding entry in this array so that we can 7179 fix up the symbol index after we have written out all the 7180 local symbols. 7181 7182 Because of this problem, we also keep the relocs in 7183 memory until the end of the link. This wastes memory. 7184 We could backpatch the file later, I suppose, although it 7185 would be slow. */ 7186 amt = o->reloc_count; 7187 amt *= sizeof (struct internal_reloc); 7188 flinfo.section_info[o->target_index].relocs = bfd_malloc (amt); 7189 7190 amt = o->reloc_count; 7191 amt *= sizeof (struct xcoff_link_hash_entry *); 7192 flinfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt); 7193 7194 if (flinfo.section_info[o->target_index].relocs == NULL 7195 || flinfo.section_info[o->target_index].rel_hashes == NULL) 7196 goto error_return; 7197 7198 if (o->reloc_count > max_output_reloc_count) 7199 max_output_reloc_count = o->reloc_count; 7200 } 7201 } 7202 7203 /* We now know the size of the relocs, so we can determine the file 7204 positions of the line numbers. */ 7205 line_filepos = rel_filepos; 7206 flinfo.line_filepos = line_filepos; 7207 linesz = bfd_coff_linesz (abfd); 7208 for (o = abfd->sections; o != NULL; o = o->next) 7209 { 7210 if (o->lineno_count == 0) 7211 o->line_filepos = 0; 7212 else 7213 { 7214 o->line_filepos = line_filepos; 7215 line_filepos += o->lineno_count * linesz; 7216 } 7217 7218 /* Reset the reloc and lineno counts, so that we can use them to 7219 count the number of entries we have output so far. */ 7220 o->reloc_count = 0; 7221 o->lineno_count = 0; 7222 } 7223 7224 obj_sym_filepos (abfd) = line_filepos; 7225 7226 /* Figure out the largest number of symbols in an input BFD. Take 7227 the opportunity to clear the output_has_begun fields of all the 7228 input BFD's. We want at least 6 symbols, since that is the 7229 number which xcoff_write_global_symbol may need. */ 7230 max_sym_count = 6; 7231 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 7232 { 7233 bfd_size_type sz; 7234 7235 sub->output_has_begun = false; 7236 sz = obj_raw_syment_count (sub); 7237 if (sz > max_sym_count) 7238 max_sym_count = sz; 7239 } 7240 7241 /* Allocate some buffers used while linking. */ 7242 amt = max_sym_count * sizeof (struct internal_syment); 7243 flinfo.internal_syms = bfd_malloc (amt); 7244 7245 amt = max_sym_count * sizeof (long); 7246 flinfo.sym_indices = bfd_malloc (amt); 7247 7248 amt = (max_sym_count + 1) * symesz; 7249 flinfo.outsyms = bfd_malloc (amt); 7250 7251 amt = max_lineno_count * bfd_coff_linesz (abfd); 7252 flinfo.linenos = bfd_malloc (amt); 7253 7254 amt = max_contents_size; 7255 flinfo.contents = bfd_malloc (amt); 7256 7257 amt = max_reloc_count * relsz; 7258 flinfo.external_relocs = bfd_malloc (amt); 7259 7260 if ((flinfo.internal_syms == NULL && max_sym_count > 0) 7261 || (flinfo.sym_indices == NULL && max_sym_count > 0) 7262 || flinfo.outsyms == NULL 7263 || (flinfo.linenos == NULL && max_lineno_count > 0) 7264 || (flinfo.contents == NULL && max_contents_size > 0) 7265 || (flinfo.external_relocs == NULL && max_reloc_count > 0)) 7266 goto error_return; 7267 7268 obj_raw_syment_count (abfd) = 0; 7269 7270 /* Find a TOC symbol, if we need one. */ 7271 if (!xcoff_find_tc0 (abfd, &flinfo)) 7272 goto error_return; 7273 7274 /* We now know the position of everything in the file, except that 7275 we don't know the size of the symbol table and therefore we don't 7276 know where the string table starts. We just build the string 7277 table in memory as we go along. We process all the relocations 7278 for a single input file at once. */ 7279 for (o = abfd->sections; o != NULL; o = o->next) 7280 { 7281 for (p = o->map_head.link_order; p != NULL; p = p->next) 7282 { 7283 if (p->type == bfd_indirect_link_order 7284 && p->u.indirect.section->owner->xvec == abfd->xvec) 7285 { 7286 sub = p->u.indirect.section->owner; 7287 if (! sub->output_has_begun) 7288 { 7289 if (sub == xcoff_hash_table (info)->params->stub_bfd) 7290 { 7291 continue; 7292 } 7293 else 7294 { 7295 if (! xcoff_link_input_bfd (&flinfo, sub)) 7296 { 7297 _bfd_error_handler 7298 (_("Unable to link input file: %s"), sub->filename); 7299 bfd_set_error (bfd_error_sorry); 7300 goto error_return; 7301 } 7302 } 7303 sub->output_has_begun = true; 7304 } 7305 } 7306 else if (p->type == bfd_section_reloc_link_order 7307 || p->type == bfd_symbol_reloc_link_order) 7308 { 7309 if (! xcoff_reloc_link_order (abfd, &flinfo, o, p)) 7310 goto error_return; 7311 } 7312 else 7313 { 7314 if (! _bfd_default_link_order (abfd, info, o, p)) 7315 goto error_return; 7316 } 7317 } 7318 } 7319 7320 /* Free up the buffers used by xcoff_link_input_bfd. */ 7321 free (flinfo.internal_syms); 7322 flinfo.internal_syms = NULL; 7323 free (flinfo.sym_indices); 7324 flinfo.sym_indices = NULL; 7325 free (flinfo.linenos); 7326 flinfo.linenos = NULL; 7327 free (flinfo.contents); 7328 flinfo.contents = NULL; 7329 free (flinfo.external_relocs); 7330 flinfo.external_relocs = NULL; 7331 7332 /* The value of the last C_FILE symbol is supposed to be -1. Write 7333 it out again. */ 7334 if (flinfo.last_file_index != -1) 7335 { 7336 flinfo.last_file.n_value = -(bfd_vma) 1; 7337 bfd_coff_swap_sym_out (abfd, (void *) &flinfo.last_file, 7338 (void *) flinfo.outsyms); 7339 pos = obj_sym_filepos (abfd) + flinfo.last_file_index * symesz; 7340 if (bfd_seek (abfd, pos, SEEK_SET) != 0 7341 || bfd_write (flinfo.outsyms, symesz, abfd) != symesz) 7342 goto error_return; 7343 } 7344 7345 /* Write out all the global symbols which do not come from XCOFF 7346 input files. */ 7347 bfd_hash_traverse (&info->hash->table, xcoff_write_global_symbol, &flinfo); 7348 7349 /* Write out the relocations created by stub entries. The symbols 7350 will have been already written by xcoff_write_global_symbol. */ 7351 bfd_hash_traverse (&xcoff_hash_table(info)->stub_hash_table, 7352 xcoff_stub_create_relocations, 7353 &flinfo); 7354 7355 free (flinfo.outsyms); 7356 flinfo.outsyms = NULL; 7357 7358 /* Now that we have written out all the global symbols, we know the 7359 symbol indices to use for relocs against them, and we can finally 7360 write out the relocs. */ 7361 amt = max_output_reloc_count * relsz; 7362 external_relocs = bfd_malloc (amt); 7363 if (external_relocs == NULL && max_output_reloc_count != 0) 7364 goto error_return; 7365 7366 for (o = abfd->sections; o != NULL; o = o->next) 7367 { 7368 struct internal_reloc *irel; 7369 struct internal_reloc *irelend; 7370 struct xcoff_link_hash_entry **rel_hash; 7371 struct xcoff_toc_rel_hash *toc_rel_hash; 7372 bfd_byte *erel; 7373 bfd_size_type rel_size; 7374 7375 /* A stripped file has no relocs. */ 7376 if (info->strip == strip_all) 7377 { 7378 o->reloc_count = 0; 7379 continue; 7380 } 7381 7382 if (o->reloc_count == 0) 7383 continue; 7384 7385 irel = flinfo.section_info[o->target_index].relocs; 7386 irelend = irel + o->reloc_count; 7387 rel_hash = flinfo.section_info[o->target_index].rel_hashes; 7388 for (; irel < irelend; irel++, rel_hash++) 7389 { 7390 if (*rel_hash != NULL) 7391 { 7392 if ((*rel_hash)->indx < 0) 7393 { 7394 (*info->callbacks->unattached_reloc) 7395 (info, (*rel_hash)->root.root.string, 7396 NULL, o, irel->r_vaddr); 7397 (*rel_hash)->indx = 0; 7398 } 7399 irel->r_symndx = (*rel_hash)->indx; 7400 } 7401 } 7402 7403 for (toc_rel_hash = flinfo.section_info[o->target_index].toc_rel_hashes; 7404 toc_rel_hash != NULL; 7405 toc_rel_hash = toc_rel_hash->next) 7406 { 7407 if (toc_rel_hash->h->u.toc_indx < 0) 7408 { 7409 (*info->callbacks->unattached_reloc) 7410 (info, toc_rel_hash->h->root.root.string, 7411 NULL, o, toc_rel_hash->rel->r_vaddr); 7412 toc_rel_hash->h->u.toc_indx = 0; 7413 } 7414 toc_rel_hash->rel->r_symndx = toc_rel_hash->h->u.toc_indx; 7415 } 7416 7417 /* XCOFF requires that the relocs be sorted by address. We tend 7418 to produce them in the order in which their containing csects 7419 appear in the symbol table, which is not necessarily by 7420 address. So we sort them here. There may be a better way to 7421 do this. */ 7422 qsort ((void *) flinfo.section_info[o->target_index].relocs, 7423 o->reloc_count, sizeof (struct internal_reloc), 7424 xcoff_sort_relocs); 7425 7426 irel = flinfo.section_info[o->target_index].relocs; 7427 irelend = irel + o->reloc_count; 7428 erel = external_relocs; 7429 for (; irel < irelend; irel++, rel_hash++, erel += relsz) 7430 bfd_coff_swap_reloc_out (abfd, (void *) irel, (void *) erel); 7431 7432 rel_size = relsz * o->reloc_count; 7433 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0 7434 || bfd_write (external_relocs, rel_size, abfd) != rel_size) 7435 goto error_return; 7436 } 7437 7438 free (external_relocs); 7439 external_relocs = NULL; 7440 7441 /* Free up the section information. */ 7442 if (flinfo.section_info != NULL) 7443 { 7444 unsigned int i; 7445 7446 for (i = 0; i < abfd->section_count; i++) 7447 { 7448 free (flinfo.section_info[i].relocs); 7449 free (flinfo.section_info[i].rel_hashes); 7450 } 7451 free (flinfo.section_info); 7452 flinfo.section_info = NULL; 7453 } 7454 7455 /* Write out the stub sections. */ 7456 for (o = xcoff_hash_table (info)->params->stub_bfd->sections; 7457 o != NULL; o = o->next) 7458 { 7459 if ((o->flags & SEC_HAS_CONTENTS) == 0 7460 || o->size == 0) 7461 continue; 7462 7463 if (!bfd_set_section_contents (abfd, o->output_section, o->contents, 7464 (file_ptr) o->output_offset, o->size)) 7465 goto error_return; 7466 } 7467 7468 /* Write out the loader section contents. */ 7469 o = xcoff_hash_table (info)->loader_section; 7470 if (o != NULL 7471 && o->size != 0 7472 && o->output_section != bfd_abs_section_ptr) 7473 { 7474 BFD_ASSERT ((bfd_byte *) flinfo.ldrel 7475 == (xcoff_hash_table (info)->loader_section->contents 7476 + xcoff_hash_table (info)->ldhdr.l_impoff)); 7477 if (!bfd_set_section_contents (abfd, o->output_section, o->contents, 7478 (file_ptr) o->output_offset, o->size)) 7479 goto error_return; 7480 } 7481 7482 /* Write out the magic sections. */ 7483 o = xcoff_hash_table (info)->linkage_section; 7484 if (o != NULL 7485 && o->size != 0 7486 && o->output_section != bfd_abs_section_ptr 7487 && ! bfd_set_section_contents (abfd, o->output_section, o->contents, 7488 (file_ptr) o->output_offset, 7489 o->size)) 7490 goto error_return; 7491 o = xcoff_hash_table (info)->toc_section; 7492 if (o != NULL 7493 && o->size != 0 7494 && o->output_section != bfd_abs_section_ptr 7495 && ! bfd_set_section_contents (abfd, o->output_section, o->contents, 7496 (file_ptr) o->output_offset, 7497 o->size)) 7498 goto error_return; 7499 o = xcoff_hash_table (info)->descriptor_section; 7500 if (o != NULL 7501 && o->size != 0 7502 && o->output_section != bfd_abs_section_ptr 7503 && ! bfd_set_section_contents (abfd, o->output_section, o->contents, 7504 (file_ptr) o->output_offset, 7505 o->size)) 7506 goto error_return; 7507 7508 /* Write out the string table. */ 7509 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz; 7510 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 7511 goto error_return; 7512 H_PUT_32 (abfd, 7513 _bfd_stringtab_size (flinfo.strtab) + STRING_SIZE_SIZE, 7514 strbuf); 7515 amt = STRING_SIZE_SIZE; 7516 if (bfd_write (strbuf, amt, abfd) != amt) 7517 goto error_return; 7518 if (! _bfd_stringtab_emit (abfd, flinfo.strtab)) 7519 goto error_return; 7520 7521 _bfd_stringtab_free (flinfo.strtab); 7522 7523 /* Write out the debugging string table. */ 7524 o = xcoff_hash_table (info)->debug_section; 7525 if (o != NULL 7526 && o->size != 0 7527 && o->output_section != bfd_abs_section_ptr) 7528 { 7529 struct bfd_strtab_hash *debug_strtab; 7530 7531 debug_strtab = xcoff_hash_table (info)->debug_strtab; 7532 BFD_ASSERT (o->output_section->size - o->output_offset 7533 >= _bfd_stringtab_size (debug_strtab)); 7534 pos = o->output_section->filepos + o->output_offset; 7535 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 7536 goto error_return; 7537 if (! _bfd_stringtab_emit (abfd, debug_strtab)) 7538 goto error_return; 7539 } 7540 7541 /* Setting symcount to 0 will cause write_object_contents to 7542 not try to write out the symbols. */ 7543 abfd->symcount = 0; 7544 7545 return true; 7546 7547 error_return: 7548 if (flinfo.strtab != NULL) 7549 _bfd_stringtab_free (flinfo.strtab); 7550 7551 if (flinfo.section_info != NULL) 7552 { 7553 unsigned int i; 7554 7555 for (i = 0; i < abfd->section_count; i++) 7556 { 7557 free (flinfo.section_info[i].relocs); 7558 free (flinfo.section_info[i].rel_hashes); 7559 } 7560 free (flinfo.section_info); 7561 } 7562 7563 free (flinfo.internal_syms); 7564 free (flinfo.sym_indices); 7565 free (flinfo.outsyms); 7566 free (flinfo.linenos); 7567 free (flinfo.contents); 7568 free (flinfo.external_relocs); 7569 free (external_relocs); 7570 return false; 7571 } 7572