1 /* Collect static initialization info into data structures that can be 2 traversed by C++ initialization and finalization routines. 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 Contributed by Chris Smith (csmith@convex.com). 7 Heavily modified by Michael Meissner (meissner@cygnus.com), 8 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com). 9 10 This file is part of GCC. 11 12 GCC is free software; you can redistribute it and/or modify it under 13 the terms of the GNU General Public License as published by the Free 14 Software Foundation; either version 3, or (at your option) any later 15 version. 16 17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 18 WARRANTY; without even the implied warranty of MERCHANTABILITY or 19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 20 for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with GCC; see the file COPYING3. If not see 24 <http://www.gnu.org/licenses/>. */ 25 26 27 /* Build tables of static constructors and destructors and run ld. */ 28 29 #include "config.h" 30 #include "system.h" 31 #include "coretypes.h" 32 #include "tm.h" 33 #include "filenames.h" 34 35 /* TARGET_64BIT may be defined to use driver specific functionality. */ 36 #undef TARGET_64BIT 37 #define TARGET_64BIT TARGET_64BIT_DEFAULT 38 39 #ifndef LIBRARY_PATH_ENV 40 #define LIBRARY_PATH_ENV "LIBRARY_PATH" 41 #endif 42 43 #define COLLECT 44 45 #include "collect2.h" 46 #include "collect2-aix.h" 47 #include "diagnostic.h" 48 #include "demangle.h" 49 #include "obstack.h" 50 #include "intl.h" 51 #include "version.h" 52 53 /* On certain systems, we have code that works by scanning the object file 54 directly. But this code uses system-specific header files and library 55 functions, so turn it off in a cross-compiler. Likewise, the names of 56 the utilities are not correct for a cross-compiler; we have to hope that 57 cross-versions are in the proper directories. */ 58 59 #ifdef CROSS_DIRECTORY_STRUCTURE 60 #ifndef CROSS_AIX_SUPPORT 61 #undef OBJECT_FORMAT_COFF 62 #endif 63 #undef MD_EXEC_PREFIX 64 #undef REAL_LD_FILE_NAME 65 #undef REAL_NM_FILE_NAME 66 #undef REAL_STRIP_FILE_NAME 67 #endif 68 69 /* If we cannot use a special method, use the ordinary one: 70 run nm to find what symbols are present. 71 In a cross-compiler, this means you need a cross nm, 72 but that is not quite as unpleasant as special headers. */ 73 74 #if !defined (OBJECT_FORMAT_COFF) 75 #define OBJECT_FORMAT_NONE 76 #endif 77 78 #ifdef OBJECT_FORMAT_COFF 79 80 #ifndef CROSS_DIRECTORY_STRUCTURE 81 #include <a.out.h> 82 #include <ar.h> 83 84 #ifdef UMAX 85 #include <sgs.h> 86 #endif 87 88 /* Many versions of ldfcn.h define these. */ 89 #ifdef FREAD 90 #undef FREAD 91 #undef FWRITE 92 #endif 93 94 #include <ldfcn.h> 95 #endif 96 97 /* Some systems have an ISCOFF macro, but others do not. In some cases 98 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines 99 that either do not have an ISCOFF macro in /usr/include or for those 100 where it is wrong. */ 101 102 #ifndef MY_ISCOFF 103 #define MY_ISCOFF(X) ISCOFF (X) 104 #endif 105 106 #endif /* OBJECT_FORMAT_COFF */ 107 108 #ifdef OBJECT_FORMAT_NONE 109 110 /* Default flags to pass to nm. */ 111 #ifndef NM_FLAGS 112 #define NM_FLAGS "-n" 113 #endif 114 115 #endif /* OBJECT_FORMAT_NONE */ 116 117 /* Some systems use __main in a way incompatible with its use in gcc, in these 118 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to 119 give the same symbol without quotes for an alternative entry point. */ 120 #ifndef NAME__MAIN 121 #define NAME__MAIN "__main" 122 #endif 123 124 /* This must match tree.h. */ 125 #define DEFAULT_INIT_PRIORITY 65535 126 127 #ifndef COLLECT_SHARED_INIT_FUNC 128 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \ 129 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC)) 130 #endif 131 #ifndef COLLECT_SHARED_FINI_FUNC 132 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \ 133 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC)) 134 #endif 135 136 #ifdef LDD_SUFFIX 137 #define SCAN_LIBRARIES 138 #endif 139 140 #ifndef SHLIB_SUFFIX 141 #define SHLIB_SUFFIX ".so" 142 #endif 143 144 #ifdef USE_COLLECT2 145 int do_collecting = 1; 146 #else 147 int do_collecting = 0; 148 #endif 149 150 /* Cook up an always defined indication of whether we proceed the 151 "EXPORT_LIST" way. */ 152 153 #ifdef COLLECT_EXPORT_LIST 154 #define DO_COLLECT_EXPORT_LIST 1 155 #else 156 #define DO_COLLECT_EXPORT_LIST 0 157 #endif 158 159 /* Nonzero if we should suppress the automatic demangling of identifiers 160 in linker error messages. Set from COLLECT_NO_DEMANGLE. */ 161 int no_demangle; 162 163 /* Linked lists of constructor and destructor names. */ 164 165 struct id 166 { 167 struct id *next; 168 int sequence; 169 char name[1]; 170 }; 171 172 struct head 173 { 174 struct id *first; 175 struct id *last; 176 int number; 177 }; 178 179 bool vflag; /* true if -v or --version */ 180 static int rflag; /* true if -r */ 181 static int strip_flag; /* true if -s */ 182 #ifdef COLLECT_EXPORT_LIST 183 static int export_flag; /* true if -bE */ 184 static int aix64_flag; /* true if -b64 */ 185 static int aixrtl_flag; /* true if -brtl */ 186 #endif 187 188 enum lto_mode_d { 189 LTO_MODE_NONE, /* Not doing LTO. */ 190 LTO_MODE_LTO, /* Normal LTO. */ 191 LTO_MODE_WHOPR /* WHOPR. */ 192 }; 193 194 /* Current LTO mode. */ 195 static enum lto_mode_d lto_mode = LTO_MODE_NONE; 196 197 bool debug; /* true if -debug */ 198 bool helpflag; /* true if --help */ 199 200 static int shared_obj; /* true if -shared */ 201 202 static const char *c_file; /* <xxx>.c for constructor/destructor list. */ 203 static const char *o_file; /* <xxx>.o for constructor/destructor list. */ 204 #ifdef COLLECT_EXPORT_LIST 205 static const char *export_file; /* <xxx>.x for AIX export list. */ 206 #endif 207 static char **lto_o_files; /* Output files for LTO. */ 208 const char *ldout; /* File for ld stdout. */ 209 const char *lderrout; /* File for ld stderr. */ 210 static const char *output_file; /* Output file for ld. */ 211 static const char *nm_file_name; /* pathname of nm */ 212 #ifdef LDD_SUFFIX 213 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */ 214 #endif 215 static const char *strip_file_name; /* pathname of strip */ 216 const char *c_file_name; /* pathname of gcc */ 217 static char *initname, *fininame; /* names of init and fini funcs */ 218 219 static struct head constructors; /* list of constructors found */ 220 static struct head destructors; /* list of destructors found */ 221 #ifdef COLLECT_EXPORT_LIST 222 static struct head exports; /* list of exported symbols */ 223 #endif 224 static struct head frame_tables; /* list of frame unwind info tables */ 225 226 static bool at_file_supplied; /* Whether to use @file arguments */ 227 static char *response_file; /* Name of any current response file */ 228 229 struct obstack temporary_obstack; 230 char * temporary_firstobj; 231 232 /* A string that must be prepended to a target OS path in order to find 233 it on the host system. */ 234 #ifdef TARGET_SYSTEM_ROOT 235 static const char *target_system_root = TARGET_SYSTEM_ROOT; 236 #else 237 static const char *target_system_root = ""; 238 #endif 239 240 /* Structure to hold all the directories in which to search for files to 241 execute. */ 242 243 struct prefix_list 244 { 245 const char *prefix; /* String to prepend to the path. */ 246 struct prefix_list *next; /* Next in linked list. */ 247 }; 248 249 struct path_prefix 250 { 251 struct prefix_list *plist; /* List of prefixes to try */ 252 int max_len; /* Max length of a prefix in PLIST */ 253 const char *name; /* Name of this list (used in config stuff) */ 254 }; 255 256 #ifdef COLLECT_EXPORT_LIST 257 /* Lists to keep libraries to be scanned for global constructors/destructors. */ 258 static struct head libs; /* list of libraries */ 259 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */ 260 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */ 261 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs, 262 &libpath_lib_dirs, NULL}; 263 #endif 264 265 /* List of names of object files containing LTO information. 266 These are a subset of the object file names appearing on the 267 command line, and must be identical, in the sense of pointer 268 equality, with the names passed to maybe_run_lto_and_relink(). */ 269 270 struct lto_object 271 { 272 const char *name; /* Name of object file. */ 273 struct lto_object *next; /* Next in linked list. */ 274 }; 275 276 struct lto_object_list 277 { 278 struct lto_object *first; /* First list element. */ 279 struct lto_object *last; /* Last list element. */ 280 }; 281 282 static struct lto_object_list lto_objects; 283 284 /* Special kinds of symbols that a name may denote. */ 285 286 typedef enum { 287 SYM_REGULAR = 0, /* nothing special */ 288 289 SYM_CTOR = 1, /* constructor */ 290 SYM_DTOR = 2, /* destructor */ 291 SYM_INIT = 3, /* shared object routine that calls all the ctors */ 292 SYM_FINI = 4, /* shared object routine that calls all the dtors */ 293 SYM_DWEH = 5 /* DWARF exception handling table */ 294 } symkind; 295 296 static symkind is_ctor_dtor (const char *); 297 298 static void handler (int); 299 static char *find_a_file (struct path_prefix *, const char *); 300 static void add_prefix (struct path_prefix *, const char *); 301 static void prefix_from_env (const char *, struct path_prefix *); 302 static void prefix_from_string (const char *, struct path_prefix *); 303 static void do_wait (const char *, struct pex_obj *); 304 static void fork_execute (const char *, char **); 305 static void maybe_unlink (const char *); 306 static void maybe_unlink_list (char **); 307 static void add_to_list (struct head *, const char *); 308 static int extract_init_priority (const char *); 309 static void sort_ids (struct head *); 310 static void write_list (FILE *, const char *, struct id *); 311 #ifdef COLLECT_EXPORT_LIST 312 static void dump_list (FILE *, const char *, struct id *); 313 #endif 314 #if 0 315 static void dump_prefix_list (FILE *, const char *, struct prefix_list *); 316 #endif 317 static void write_list_with_asm (FILE *, const char *, struct id *); 318 static void write_c_file (FILE *, const char *); 319 static void write_c_file_stat (FILE *, const char *); 320 #ifndef LD_INIT_SWITCH 321 static void write_c_file_glob (FILE *, const char *); 322 #endif 323 #ifdef SCAN_LIBRARIES 324 static void scan_libraries (const char *); 325 #endif 326 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 327 static int is_in_args (const char *, const char **, const char **); 328 #endif 329 #ifdef COLLECT_EXPORT_LIST 330 #if 0 331 static int is_in_list (const char *, struct id *); 332 #endif 333 static void write_aix_file (FILE *, struct id *); 334 static char *resolve_lib_name (const char *); 335 #endif 336 static char *extract_string (const char **); 337 static void post_ld_pass (bool); 338 static void process_args (int *argcp, char **argv); 339 340 /* Enumerations describing which pass this is for scanning the 341 program file ... */ 342 343 typedef enum { 344 PASS_FIRST, /* without constructors */ 345 PASS_OBJ, /* individual objects */ 346 PASS_LIB, /* looking for shared libraries */ 347 PASS_SECOND, /* with constructors linked in */ 348 PASS_LTOINFO /* looking for objects with LTO info */ 349 } scanpass; 350 351 /* ... and which kinds of symbols are to be considered. */ 352 353 enum scanfilter_masks { 354 SCAN_NOTHING = 0, 355 356 SCAN_CTOR = 1 << SYM_CTOR, 357 SCAN_DTOR = 1 << SYM_DTOR, 358 SCAN_INIT = 1 << SYM_INIT, 359 SCAN_FINI = 1 << SYM_FINI, 360 SCAN_DWEH = 1 << SYM_DWEH, 361 SCAN_ALL = ~0 362 }; 363 364 /* This type is used for parameters and variables which hold 365 combinations of the flags in enum scanfilter_masks. */ 366 typedef int scanfilter; 367 368 /* Scan the name list of the loaded program for the symbols g++ uses for 369 static constructors and destructors. 370 371 The SCANPASS argument tells which collect processing pass this is for and 372 the SCANFILTER argument tells which kinds of symbols to consider in this 373 pass. Symbols of a special kind not in the filter mask are considered as 374 regular ones. 375 376 The constructor table begins at __CTOR_LIST__ and contains a count of the 377 number of pointers (or -1 if the constructors are built in a separate 378 section by the linker), followed by the pointers to the constructor 379 functions, terminated with a null pointer. The destructor table has the 380 same format, and begins at __DTOR_LIST__. */ 381 382 static void scan_prog_file (const char *, scanpass, scanfilter); 383 384 385 /* Delete tempfiles and exit function. */ 386 387 void 388 collect_exit (int status) 389 { 390 if (c_file != 0 && c_file[0]) 391 maybe_unlink (c_file); 392 393 if (o_file != 0 && o_file[0]) 394 maybe_unlink (o_file); 395 396 #ifdef COLLECT_EXPORT_LIST 397 if (export_file != 0 && export_file[0]) 398 maybe_unlink (export_file); 399 #endif 400 401 if (lto_o_files) 402 maybe_unlink_list (lto_o_files); 403 404 if (ldout != 0 && ldout[0]) 405 { 406 dump_file (ldout, stdout); 407 maybe_unlink (ldout); 408 } 409 410 if (lderrout != 0 && lderrout[0]) 411 { 412 dump_file (lderrout, stderr); 413 maybe_unlink (lderrout); 414 } 415 416 if (status != 0 && output_file != 0 && output_file[0]) 417 maybe_unlink (output_file); 418 419 if (response_file) 420 maybe_unlink (response_file); 421 422 exit (status); 423 } 424 425 426 /* Notify user of a non-error. */ 427 void 428 notice (const char *cmsgid, ...) 429 { 430 va_list ap; 431 432 va_start (ap, cmsgid); 433 vfprintf (stderr, _(cmsgid), ap); 434 va_end (ap); 435 } 436 437 /* Notify user of a non-error, without translating the format string. */ 438 void 439 notice_translated (const char *cmsgid, ...) 440 { 441 va_list ap; 442 443 va_start (ap, cmsgid); 444 vfprintf (stderr, cmsgid, ap); 445 va_end (ap); 446 } 447 448 static void 449 handler (int signo) 450 { 451 if (c_file != 0 && c_file[0]) 452 maybe_unlink (c_file); 453 454 if (o_file != 0 && o_file[0]) 455 maybe_unlink (o_file); 456 457 if (ldout != 0 && ldout[0]) 458 maybe_unlink (ldout); 459 460 if (lderrout != 0 && lderrout[0]) 461 maybe_unlink (lderrout); 462 463 #ifdef COLLECT_EXPORT_LIST 464 if (export_file != 0 && export_file[0]) 465 maybe_unlink (export_file); 466 #endif 467 468 if (lto_o_files) 469 maybe_unlink_list (lto_o_files); 470 471 if (response_file) 472 maybe_unlink (response_file); 473 474 signal (signo, SIG_DFL); 475 raise (signo); 476 } 477 478 479 int 480 file_exists (const char *name) 481 { 482 return access (name, R_OK) == 0; 483 } 484 485 /* Parse a reasonable subset of shell quoting syntax. */ 486 487 static char * 488 extract_string (const char **pp) 489 { 490 const char *p = *pp; 491 int backquote = 0; 492 int inside = 0; 493 494 for (;;) 495 { 496 char c = *p; 497 if (c == '\0') 498 break; 499 ++p; 500 if (backquote) 501 obstack_1grow (&temporary_obstack, c); 502 else if (! inside && c == ' ') 503 break; 504 else if (! inside && c == '\\') 505 backquote = 1; 506 else if (c == '\'') 507 inside = !inside; 508 else 509 obstack_1grow (&temporary_obstack, c); 510 } 511 512 obstack_1grow (&temporary_obstack, '\0'); 513 *pp = p; 514 return XOBFINISH (&temporary_obstack, char *); 515 } 516 517 void 518 dump_file (const char *name, FILE *to) 519 { 520 FILE *stream = fopen (name, "r"); 521 522 if (stream == 0) 523 return; 524 while (1) 525 { 526 int c; 527 while (c = getc (stream), 528 c != EOF && (ISIDNUM (c) || c == '$' || c == '.')) 529 obstack_1grow (&temporary_obstack, c); 530 if (obstack_object_size (&temporary_obstack) > 0) 531 { 532 const char *word, *p; 533 char *result; 534 obstack_1grow (&temporary_obstack, '\0'); 535 word = XOBFINISH (&temporary_obstack, const char *); 536 537 if (*word == '.') 538 ++word, putc ('.', to); 539 p = word; 540 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX))) 541 p += strlen (USER_LABEL_PREFIX); 542 543 #ifdef HAVE_LD_DEMANGLE 544 result = 0; 545 #else 546 if (no_demangle) 547 result = 0; 548 else 549 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE); 550 #endif 551 552 if (result) 553 { 554 int diff; 555 fputs (result, to); 556 557 diff = strlen (word) - strlen (result); 558 while (diff > 0 && c == ' ') 559 --diff, putc (' ', to); 560 if (diff < 0 && c == ' ') 561 { 562 while (diff < 0 && c == ' ') 563 ++diff, c = getc (stream); 564 if (!ISSPACE (c)) 565 { 566 /* Make sure we output at least one space, or 567 the demangled symbol name will run into 568 whatever text follows. */ 569 putc (' ', to); 570 } 571 } 572 573 free (result); 574 } 575 else 576 fputs (word, to); 577 578 fflush (to); 579 obstack_free (&temporary_obstack, temporary_firstobj); 580 } 581 if (c == EOF) 582 break; 583 putc (c, to); 584 } 585 fclose (stream); 586 } 587 588 /* Return the kind of symbol denoted by name S. */ 589 590 static symkind 591 is_ctor_dtor (const char *s) 592 { 593 struct names { const char *const name; const int len; symkind ret; 594 const int two_underscores; }; 595 596 const struct names *p; 597 int ch; 598 const char *orig_s = s; 599 600 static const struct names special[] = { 601 #ifndef NO_DOLLAR_IN_LABEL 602 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 }, 603 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 }, 604 #else 605 #ifndef NO_DOT_IN_LABEL 606 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 }, 607 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 }, 608 #endif /* NO_DOT_IN_LABEL */ 609 #endif /* NO_DOLLAR_IN_LABEL */ 610 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 }, 611 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 }, 612 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 }, 613 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 }, 614 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 }, 615 { NULL, 0, SYM_REGULAR, 0 } 616 }; 617 618 while ((ch = *s) == '_') 619 ++s; 620 621 if (s == orig_s) 622 return SYM_REGULAR; 623 624 for (p = &special[0]; p->len > 0; p++) 625 { 626 if (ch == p->name[0] 627 && (!p->two_underscores || ((s - orig_s) >= 2)) 628 && strncmp(s, p->name, p->len) == 0) 629 { 630 return p->ret; 631 } 632 } 633 return SYM_REGULAR; 634 } 635 636 /* We maintain two prefix lists: one from COMPILER_PATH environment variable 637 and one from the PATH variable. */ 638 639 static struct path_prefix cpath, path; 640 641 #ifdef CROSS_DIRECTORY_STRUCTURE 642 /* This is the name of the target machine. We use it to form the name 643 of the files to execute. */ 644 645 static const char *const target_machine = TARGET_MACHINE; 646 #endif 647 648 /* Search for NAME using prefix list PPREFIX. We only look for executable 649 files. 650 651 Return 0 if not found, otherwise return its name, allocated with malloc. */ 652 653 static char * 654 find_a_file (struct path_prefix *pprefix, const char *name) 655 { 656 char *temp; 657 struct prefix_list *pl; 658 int len = pprefix->max_len + strlen (name) + 1; 659 660 if (debug) 661 fprintf (stderr, "Looking for '%s'\n", name); 662 663 #ifdef HOST_EXECUTABLE_SUFFIX 664 len += strlen (HOST_EXECUTABLE_SUFFIX); 665 #endif 666 667 temp = XNEWVEC (char, len); 668 669 /* Determine the filename to execute (special case for absolute paths). */ 670 671 if (IS_ABSOLUTE_PATH (name)) 672 { 673 if (access (name, X_OK) == 0) 674 { 675 strcpy (temp, name); 676 677 if (debug) 678 fprintf (stderr, " - found: absolute path\n"); 679 680 return temp; 681 } 682 683 #ifdef HOST_EXECUTABLE_SUFFIX 684 /* Some systems have a suffix for executable files. 685 So try appending that. */ 686 strcpy (temp, name); 687 strcat (temp, HOST_EXECUTABLE_SUFFIX); 688 689 if (access (temp, X_OK) == 0) 690 return temp; 691 #endif 692 693 if (debug) 694 fprintf (stderr, " - failed to locate using absolute path\n"); 695 } 696 else 697 for (pl = pprefix->plist; pl; pl = pl->next) 698 { 699 struct stat st; 700 701 strcpy (temp, pl->prefix); 702 strcat (temp, name); 703 704 if (stat (temp, &st) >= 0 705 && ! S_ISDIR (st.st_mode) 706 && access (temp, X_OK) == 0) 707 return temp; 708 709 #ifdef HOST_EXECUTABLE_SUFFIX 710 /* Some systems have a suffix for executable files. 711 So try appending that. */ 712 strcat (temp, HOST_EXECUTABLE_SUFFIX); 713 714 if (stat (temp, &st) >= 0 715 && ! S_ISDIR (st.st_mode) 716 && access (temp, X_OK) == 0) 717 return temp; 718 #endif 719 } 720 721 if (debug && pprefix->plist == NULL) 722 fprintf (stderr, " - failed: no entries in prefix list\n"); 723 724 free (temp); 725 return 0; 726 } 727 728 /* Add an entry for PREFIX to prefix list PPREFIX. */ 729 730 static void 731 add_prefix (struct path_prefix *pprefix, const char *prefix) 732 { 733 struct prefix_list *pl, **prev; 734 int len; 735 736 if (pprefix->plist) 737 { 738 for (pl = pprefix->plist; pl->next; pl = pl->next) 739 ; 740 prev = &pl->next; 741 } 742 else 743 prev = &pprefix->plist; 744 745 /* Keep track of the longest prefix. */ 746 747 len = strlen (prefix); 748 if (len > pprefix->max_len) 749 pprefix->max_len = len; 750 751 pl = XNEW (struct prefix_list); 752 pl->prefix = xstrdup (prefix); 753 754 if (*prev) 755 pl->next = *prev; 756 else 757 pl->next = (struct prefix_list *) 0; 758 *prev = pl; 759 } 760 761 /* Take the value of the environment variable ENV, break it into a path, and 762 add of the entries to PPREFIX. */ 763 764 static void 765 prefix_from_env (const char *env, struct path_prefix *pprefix) 766 { 767 const char *p; 768 p = getenv (env); 769 770 if (p) 771 prefix_from_string (p, pprefix); 772 } 773 774 static void 775 prefix_from_string (const char *p, struct path_prefix *pprefix) 776 { 777 const char *startp, *endp; 778 char *nstore = XNEWVEC (char, strlen (p) + 3); 779 780 if (debug) 781 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR); 782 783 startp = endp = p; 784 while (1) 785 { 786 if (*endp == PATH_SEPARATOR || *endp == 0) 787 { 788 strncpy (nstore, startp, endp-startp); 789 if (endp == startp) 790 { 791 strcpy (nstore, "./"); 792 } 793 else if (! IS_DIR_SEPARATOR (endp[-1])) 794 { 795 nstore[endp-startp] = DIR_SEPARATOR; 796 nstore[endp-startp+1] = 0; 797 } 798 else 799 nstore[endp-startp] = 0; 800 801 if (debug) 802 fprintf (stderr, " - add prefix: %s\n", nstore); 803 804 add_prefix (pprefix, nstore); 805 if (*endp == 0) 806 break; 807 endp = startp = endp + 1; 808 } 809 else 810 endp++; 811 } 812 free (nstore); 813 } 814 815 #ifdef OBJECT_FORMAT_NONE 816 817 /* Add an entry for the object file NAME to object file list LIST. 818 New entries are added at the end of the list. The original pointer 819 value of NAME is preserved, i.e., no string copy is performed. */ 820 821 static void 822 add_lto_object (struct lto_object_list *list, const char *name) 823 { 824 struct lto_object *n = XNEW (struct lto_object); 825 n->name = name; 826 n->next = NULL; 827 828 if (list->last) 829 list->last->next = n; 830 else 831 list->first = n; 832 833 list->last = n; 834 } 835 #endif /* OBJECT_FORMAT_NONE */ 836 837 838 /* Perform a link-time recompilation and relink if any of the object 839 files contain LTO info. The linker command line LTO_LD_ARGV 840 represents the linker command that would produce a final executable 841 without the use of LTO. OBJECT_LST is a vector of object file names 842 appearing in LTO_LD_ARGV that are to be considerd for link-time 843 recompilation, where OBJECT is a pointer to the last valid element. 844 (This awkward convention avoids an impedance mismatch with the 845 usage of similarly-named variables in main().) The elements of 846 OBJECT_LST must be identical, i.e., pointer equal, to the 847 corresponding arguments in LTO_LD_ARGV. 848 849 Upon entry, at least one linker run has been performed without the 850 use of any LTO info that might be present. Any recompilations 851 necessary for template instantiations have been performed, and 852 initializer/finalizer tables have been created if needed and 853 included in the linker command line LTO_LD_ARGV. If any of the 854 object files contain LTO info, we run the LTO back end on all such 855 files, and perform the final link with the LTO back end output 856 substituted for the LTO-optimized files. In some cases, a final 857 link with all link-time generated code has already been performed, 858 so there is no need to relink if no LTO info is found. In other 859 cases, our caller has not produced the final executable, and is 860 relying on us to perform the required link whether LTO info is 861 present or not. In that case, the FORCE argument should be true. 862 Note that the linker command line argument LTO_LD_ARGV passed into 863 this function may be modified in place. */ 864 865 static void 866 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst, 867 const char **object, bool force) 868 { 869 const char **object_file = CONST_CAST2 (const char **, char **, object_lst); 870 871 int num_lto_c_args = 1; /* Allow space for the terminating NULL. */ 872 873 while (object_file < object) 874 { 875 /* If file contains LTO info, add it to the list of LTO objects. */ 876 scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL); 877 878 /* Increment the argument count by the number of object file arguments 879 we will add. An upper bound suffices, so just count all of the 880 object files regardless of whether they contain LTO info. */ 881 num_lto_c_args++; 882 } 883 884 if (lto_objects.first) 885 { 886 char **lto_c_argv; 887 const char **lto_c_ptr; 888 char **p; 889 char **lto_o_ptr; 890 struct lto_object *list; 891 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER"); 892 struct pex_obj *pex; 893 const char *prog = "lto-wrapper"; 894 int lto_ld_argv_size = 0; 895 char **out_lto_ld_argv; 896 int out_lto_ld_argv_size; 897 size_t num_files; 898 899 if (!lto_wrapper) 900 fatal_error ("COLLECT_LTO_WRAPPER must be set"); 901 902 num_lto_c_args++; 903 904 /* There is at least one object file containing LTO info, 905 so we need to run the LTO back end and relink. 906 907 To do so we build updated ld arguments with first 908 LTO object replaced by all partitions and other LTO 909 objects removed. */ 910 911 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args); 912 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv); 913 914 *lto_c_ptr++ = lto_wrapper; 915 916 /* Add LTO objects to the wrapper command line. */ 917 for (list = lto_objects.first; list; list = list->next) 918 *lto_c_ptr++ = list->name; 919 920 *lto_c_ptr = NULL; 921 922 /* Run the LTO back end. */ 923 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH); 924 { 925 int c; 926 FILE *stream; 927 size_t i; 928 char *start, *end; 929 930 stream = pex_read_output (pex, 0); 931 gcc_assert (stream); 932 933 num_files = 0; 934 while ((c = getc (stream)) != EOF) 935 { 936 obstack_1grow (&temporary_obstack, c); 937 if (c == '\n') 938 ++num_files; 939 } 940 941 lto_o_files = XNEWVEC (char *, num_files + 1); 942 lto_o_files[num_files] = NULL; 943 start = XOBFINISH (&temporary_obstack, char *); 944 for (i = 0; i < num_files; ++i) 945 { 946 end = start; 947 while (*end != '\n') 948 ++end; 949 *end = '\0'; 950 951 lto_o_files[i] = xstrdup (start); 952 953 start = end + 1; 954 } 955 956 obstack_free (&temporary_obstack, temporary_firstobj); 957 } 958 do_wait (prog, pex); 959 pex = NULL; 960 961 /* Compute memory needed for new LD arguments. At most number of original arguemtns 962 plus number of partitions. */ 963 for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++) 964 ; 965 out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1); 966 out_lto_ld_argv_size = 0; 967 968 /* After running the LTO back end, we will relink, substituting 969 the LTO output for the object files that we submitted to the 970 LTO. Here, we modify the linker command line for the relink. */ 971 972 /* Copy all arguments until we find first LTO file. */ 973 p = lto_ld_argv; 974 while (*p != NULL) 975 { 976 for (list = lto_objects.first; list; list = list->next) 977 if (*p == list->name) /* Note test for pointer equality! */ 978 break; 979 if (list) 980 break; 981 out_lto_ld_argv[out_lto_ld_argv_size++] = *p++; 982 } 983 984 /* Now insert all LTO partitions. */ 985 lto_o_ptr = lto_o_files; 986 while (*lto_o_ptr) 987 out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++; 988 989 /* ... and copy the rest. */ 990 while (*p != NULL) 991 { 992 for (list = lto_objects.first; list; list = list->next) 993 if (*p == list->name) /* Note test for pointer equality! */ 994 break; 995 if (!list) 996 out_lto_ld_argv[out_lto_ld_argv_size++] = *p; 997 p++; 998 } 999 out_lto_ld_argv[out_lto_ld_argv_size++] = 0; 1000 1001 /* Run the linker again, this time replacing the object files 1002 optimized by the LTO with the temporary file generated by the LTO. */ 1003 fork_execute ("ld", out_lto_ld_argv); 1004 post_ld_pass (true); 1005 free (lto_ld_argv); 1006 1007 maybe_unlink_list (lto_o_files); 1008 } 1009 else if (force) 1010 { 1011 /* Our caller is relying on us to do the link 1012 even though there is no LTO back end work to be done. */ 1013 fork_execute ("ld", lto_ld_argv); 1014 post_ld_pass (false); 1015 } 1016 } 1017 1018 /* Main program. */ 1019 1020 int 1021 main (int argc, char **argv) 1022 { 1023 static const char *const ld_suffix = "ld"; 1024 static const char *const plugin_ld_suffix = PLUGIN_LD; 1025 static const char *const real_ld_suffix = "real-ld"; 1026 static const char *const collect_ld_suffix = "collect-ld"; 1027 static const char *const nm_suffix = "nm"; 1028 static const char *const gnm_suffix = "gnm"; 1029 #ifdef LDD_SUFFIX 1030 static const char *const ldd_suffix = LDD_SUFFIX; 1031 #endif 1032 static const char *const strip_suffix = "strip"; 1033 static const char *const gstrip_suffix = "gstrip"; 1034 1035 #ifdef CROSS_DIRECTORY_STRUCTURE 1036 /* If we look for a program in the compiler directories, we just use 1037 the short name, since these directories are already system-specific. 1038 But it we look for a program in the system directories, we need to 1039 qualify the program name with the target machine. */ 1040 1041 const char *const full_ld_suffix = 1042 concat(target_machine, "-", ld_suffix, NULL); 1043 const char *const full_plugin_ld_suffix = 1044 concat(target_machine, "-", plugin_ld_suffix, NULL); 1045 const char *const full_nm_suffix = 1046 concat (target_machine, "-", nm_suffix, NULL); 1047 const char *const full_gnm_suffix = 1048 concat (target_machine, "-", gnm_suffix, NULL); 1049 #ifdef LDD_SUFFIX 1050 const char *const full_ldd_suffix = 1051 concat (target_machine, "-", ldd_suffix, NULL); 1052 #endif 1053 const char *const full_strip_suffix = 1054 concat (target_machine, "-", strip_suffix, NULL); 1055 const char *const full_gstrip_suffix = 1056 concat (target_machine, "-", gstrip_suffix, NULL); 1057 #else 1058 const char *const full_ld_suffix = ld_suffix; 1059 const char *const full_plugin_ld_suffix = plugin_ld_suffix; 1060 const char *const full_nm_suffix = nm_suffix; 1061 const char *const full_gnm_suffix = gnm_suffix; 1062 #ifdef LDD_SUFFIX 1063 const char *const full_ldd_suffix = ldd_suffix; 1064 #endif 1065 const char *const full_strip_suffix = strip_suffix; 1066 const char *const full_gstrip_suffix = gstrip_suffix; 1067 #endif /* CROSS_DIRECTORY_STRUCTURE */ 1068 1069 const char *arg; 1070 FILE *outf; 1071 #ifdef COLLECT_EXPORT_LIST 1072 FILE *exportf; 1073 #endif 1074 const char *ld_file_name; 1075 const char *p; 1076 char **c_argv; 1077 const char **c_ptr; 1078 char **ld1_argv; 1079 const char **ld1; 1080 bool use_plugin = false; 1081 1082 /* The kinds of symbols we will have to consider when scanning the 1083 outcome of a first pass link. This is ALL to start with, then might 1084 be adjusted before getting to the first pass link per se, typically on 1085 AIX where we perform an early scan of objects and libraries to fetch 1086 the list of global ctors/dtors and make sure they are not garbage 1087 collected. */ 1088 scanfilter ld1_filter = SCAN_ALL; 1089 1090 char **ld2_argv; 1091 const char **ld2; 1092 char **object_lst; 1093 const char **object; 1094 #ifdef TARGET_AIX_VERSION 1095 int object_nbr = argc; 1096 #endif 1097 int first_file; 1098 int num_c_args; 1099 char **old_argv; 1100 1101 p = argv[0] + strlen (argv[0]); 1102 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 1103 --p; 1104 progname = p; 1105 1106 xmalloc_set_program_name (progname); 1107 1108 old_argv = argv; 1109 expandargv (&argc, &argv); 1110 if (argv != old_argv) 1111 at_file_supplied = 1; 1112 1113 process_args (&argc, argv); 1114 1115 num_c_args = argc + 9; 1116 1117 #ifndef HAVE_LD_DEMANGLE 1118 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE"); 1119 1120 /* Suppress demangling by the real linker, which may be broken. */ 1121 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1")); 1122 #endif 1123 1124 #if defined (COLLECT2_HOST_INITIALIZATION) 1125 /* Perform system dependent initialization, if necessary. */ 1126 COLLECT2_HOST_INITIALIZATION; 1127 #endif 1128 1129 #ifdef SIGCHLD 1130 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 1131 receive the signal. A different setting is inheritable */ 1132 signal (SIGCHLD, SIG_DFL); 1133 #endif 1134 1135 /* Unlock the stdio streams. */ 1136 unlock_std_streams (); 1137 1138 gcc_init_libintl (); 1139 1140 diagnostic_initialize (global_dc, 0); 1141 1142 /* Do not invoke xcalloc before this point, since locale needs to be 1143 set first, in case a diagnostic is issued. */ 1144 1145 ld1_argv = XCNEWVEC (char *, argc + 4); 1146 ld1 = CONST_CAST2 (const char **, char **, ld1_argv); 1147 ld2_argv = XCNEWVEC (char *, argc + 11); 1148 ld2 = CONST_CAST2 (const char **, char **, ld2_argv); 1149 object_lst = XCNEWVEC (char *, argc); 1150 object = CONST_CAST2 (const char **, char **, object_lst); 1151 1152 #ifdef DEBUG 1153 debug = 1; 1154 #endif 1155 1156 /* Parse command line early for instances of -debug. This allows 1157 the debug flag to be set before functions like find_a_file() 1158 are called. We also look for the -flto or -flto-partition=none flag to know 1159 what LTO mode we are in. */ 1160 { 1161 int i; 1162 bool no_partition = false; 1163 1164 for (i = 1; argv[i] != NULL; i ++) 1165 { 1166 if (! strcmp (argv[i], "-debug")) 1167 debug = true; 1168 else if (! strcmp (argv[i], "-flto-partition=none")) 1169 no_partition = true; 1170 else if ((! strncmp (argv[i], "-flto=", 6) 1171 || ! strcmp (argv[i], "-flto")) && ! use_plugin) 1172 lto_mode = LTO_MODE_WHOPR; 1173 else if (!strncmp (argv[i], "-fno-lto", 8)) 1174 lto_mode = LTO_MODE_NONE; 1175 else if (! strcmp (argv[i], "-plugin")) 1176 { 1177 use_plugin = true; 1178 lto_mode = LTO_MODE_NONE; 1179 } 1180 #ifdef COLLECT_EXPORT_LIST 1181 /* since -brtl, -bexport, -b64 are not position dependent 1182 also check for them here */ 1183 if ((argv[i][0] == '-') && (argv[i][1] == 'b')) 1184 { 1185 arg = argv[i]; 1186 /* We want to disable automatic exports on AIX when user 1187 explicitly puts an export list in command line */ 1188 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0) 1189 export_flag = 1; 1190 else if (arg[2] == '6' && arg[3] == '4') 1191 aix64_flag = 1; 1192 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l') 1193 aixrtl_flag = 1; 1194 } 1195 #endif 1196 } 1197 vflag = debug; 1198 if (no_partition && lto_mode == LTO_MODE_WHOPR) 1199 lto_mode = LTO_MODE_LTO; 1200 } 1201 1202 #ifndef DEFAULT_A_OUT_NAME 1203 output_file = "a.out"; 1204 #else 1205 output_file = DEFAULT_A_OUT_NAME; 1206 #endif 1207 1208 obstack_begin (&temporary_obstack, 0); 1209 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); 1210 1211 #ifndef HAVE_LD_DEMANGLE 1212 current_demangling_style = auto_demangling; 1213 #endif 1214 p = getenv ("COLLECT_GCC_OPTIONS"); 1215 while (p && *p) 1216 { 1217 const char *q = extract_string (&p); 1218 if (*q == '-' && (q[1] == 'm' || q[1] == 'f')) 1219 num_c_args++; 1220 } 1221 obstack_free (&temporary_obstack, temporary_firstobj); 1222 1223 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities 1224 -fno-exceptions -w -fno-whole-program */ 1225 num_c_args += 6; 1226 1227 c_argv = XCNEWVEC (char *, num_c_args); 1228 c_ptr = CONST_CAST2 (const char **, char **, c_argv); 1229 1230 if (argc < 2) 1231 fatal_error ("no arguments"); 1232 1233 #ifdef SIGQUIT 1234 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN) 1235 signal (SIGQUIT, handler); 1236 #endif 1237 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 1238 signal (SIGINT, handler); 1239 #ifdef SIGALRM 1240 if (signal (SIGALRM, SIG_IGN) != SIG_IGN) 1241 signal (SIGALRM, handler); 1242 #endif 1243 #ifdef SIGHUP 1244 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 1245 signal (SIGHUP, handler); 1246 #endif 1247 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN) 1248 signal (SIGSEGV, handler); 1249 #ifdef SIGBUS 1250 if (signal (SIGBUS, SIG_IGN) != SIG_IGN) 1251 signal (SIGBUS, handler); 1252 #endif 1253 1254 /* Extract COMPILER_PATH and PATH into our prefix list. */ 1255 prefix_from_env ("COMPILER_PATH", &cpath); 1256 prefix_from_env ("PATH", &path); 1257 1258 /* Try to discover a valid linker/nm/strip to use. */ 1259 1260 /* Maybe we know the right file to use (if not cross). */ 1261 ld_file_name = 0; 1262 #ifdef DEFAULT_LINKER 1263 if (access (DEFAULT_LINKER, X_OK) == 0) 1264 ld_file_name = DEFAULT_LINKER; 1265 if (ld_file_name == 0) 1266 #endif 1267 #ifdef REAL_LD_FILE_NAME 1268 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME); 1269 if (ld_file_name == 0) 1270 #endif 1271 /* Search the (target-specific) compiler dirs for ld'. */ 1272 ld_file_name = find_a_file (&cpath, real_ld_suffix); 1273 /* Likewise for `collect-ld'. */ 1274 if (ld_file_name == 0) 1275 ld_file_name = find_a_file (&cpath, collect_ld_suffix); 1276 /* Search the compiler directories for `ld'. We have protection against 1277 recursive calls in find_a_file. */ 1278 if (ld_file_name == 0) 1279 ld_file_name = find_a_file (&cpath, 1280 use_plugin 1281 ? plugin_ld_suffix 1282 : ld_suffix); 1283 /* Search the ordinary system bin directories 1284 for `ld' (if native linking) or `TARGET-ld' (if cross). */ 1285 if (ld_file_name == 0) 1286 ld_file_name = find_a_file (&path, 1287 use_plugin 1288 ? full_plugin_ld_suffix 1289 : full_ld_suffix); 1290 1291 #ifdef REAL_NM_FILE_NAME 1292 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME); 1293 if (nm_file_name == 0) 1294 #endif 1295 nm_file_name = find_a_file (&cpath, gnm_suffix); 1296 if (nm_file_name == 0) 1297 nm_file_name = find_a_file (&path, full_gnm_suffix); 1298 if (nm_file_name == 0) 1299 nm_file_name = find_a_file (&cpath, nm_suffix); 1300 if (nm_file_name == 0) 1301 nm_file_name = find_a_file (&path, full_nm_suffix); 1302 1303 #ifdef LDD_SUFFIX 1304 ldd_file_name = find_a_file (&cpath, ldd_suffix); 1305 if (ldd_file_name == 0) 1306 ldd_file_name = find_a_file (&path, full_ldd_suffix); 1307 #endif 1308 1309 #ifdef REAL_STRIP_FILE_NAME 1310 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME); 1311 if (strip_file_name == 0) 1312 #endif 1313 strip_file_name = find_a_file (&cpath, gstrip_suffix); 1314 if (strip_file_name == 0) 1315 strip_file_name = find_a_file (&path, full_gstrip_suffix); 1316 if (strip_file_name == 0) 1317 strip_file_name = find_a_file (&cpath, strip_suffix); 1318 if (strip_file_name == 0) 1319 strip_file_name = find_a_file (&path, full_strip_suffix); 1320 1321 /* Determine the full path name of the C compiler to use. */ 1322 c_file_name = getenv ("COLLECT_GCC"); 1323 if (c_file_name == 0) 1324 { 1325 #ifdef CROSS_DIRECTORY_STRUCTURE 1326 c_file_name = concat (target_machine, "-gcc", NULL); 1327 #else 1328 c_file_name = "gcc"; 1329 #endif 1330 } 1331 1332 p = find_a_file (&cpath, c_file_name); 1333 1334 /* Here it should be safe to use the system search path since we should have 1335 already qualified the name of the compiler when it is needed. */ 1336 if (p == 0) 1337 p = find_a_file (&path, c_file_name); 1338 1339 if (p) 1340 c_file_name = p; 1341 1342 *ld1++ = *ld2++ = ld_file_name; 1343 1344 /* Make temp file names. */ 1345 c_file = make_temp_file (".c"); 1346 o_file = make_temp_file (".o"); 1347 #ifdef COLLECT_EXPORT_LIST 1348 export_file = make_temp_file (".x"); 1349 #endif 1350 ldout = make_temp_file (".ld"); 1351 lderrout = make_temp_file (".le"); 1352 *c_ptr++ = c_file_name; 1353 *c_ptr++ = "-x"; 1354 *c_ptr++ = "c"; 1355 *c_ptr++ = "-c"; 1356 *c_ptr++ = "-o"; 1357 *c_ptr++ = o_file; 1358 1359 #ifdef COLLECT_EXPORT_LIST 1360 /* Generate a list of directories from LIBPATH. */ 1361 prefix_from_env ("LIBPATH", &libpath_lib_dirs); 1362 /* Add to this list also two standard directories where 1363 AIX loader always searches for libraries. */ 1364 add_prefix (&libpath_lib_dirs, "/lib"); 1365 add_prefix (&libpath_lib_dirs, "/usr/lib"); 1366 #endif 1367 1368 /* Get any options that the upper GCC wants to pass to the sub-GCC. 1369 1370 AIX support needs to know if -shared has been specified before 1371 parsing commandline arguments. */ 1372 1373 p = getenv ("COLLECT_GCC_OPTIONS"); 1374 while (p && *p) 1375 { 1376 const char *q = extract_string (&p); 1377 if (*q == '-' && (q[1] == 'm' || q[1] == 'f')) 1378 *c_ptr++ = xstrdup (q); 1379 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0) 1380 *c_ptr++ = xstrdup (q); 1381 if (strcmp (q, "-shared") == 0) 1382 shared_obj = 1; 1383 if (*q == '-' && q[1] == 'B') 1384 { 1385 *c_ptr++ = xstrdup (q); 1386 if (q[2] == 0) 1387 { 1388 q = extract_string (&p); 1389 *c_ptr++ = xstrdup (q); 1390 } 1391 } 1392 } 1393 obstack_free (&temporary_obstack, temporary_firstobj); 1394 *c_ptr++ = "-fno-profile-arcs"; 1395 *c_ptr++ = "-fno-test-coverage"; 1396 *c_ptr++ = "-fno-branch-probabilities"; 1397 *c_ptr++ = "-fno-exceptions"; 1398 *c_ptr++ = "-w"; 1399 *c_ptr++ = "-fno-whole-program"; 1400 1401 /* !!! When GCC calls collect2, 1402 it does not know whether it is calling collect2 or ld. 1403 So collect2 cannot meaningfully understand any options 1404 except those ld understands. 1405 If you propose to make GCC pass some other option, 1406 just imagine what will happen if ld is really ld!!! */ 1407 1408 /* Parse arguments. Remember output file spec, pass the rest to ld. */ 1409 /* After the first file, put in the c++ rt0. */ 1410 1411 first_file = 1; 1412 while ((arg = *++argv) != (char *) 0) 1413 { 1414 *ld1++ = *ld2++ = arg; 1415 1416 if (arg[0] == '-') 1417 { 1418 switch (arg[1]) 1419 { 1420 case 'd': 1421 if (!strcmp (arg, "-debug")) 1422 { 1423 /* Already parsed. */ 1424 ld1--; 1425 ld2--; 1426 } 1427 if (!strcmp (arg, "-dynamic-linker") && argv[1]) 1428 { 1429 ++argv; 1430 *ld1++ = *ld2++ = *argv; 1431 } 1432 break; 1433 1434 case 'f': 1435 if (strncmp (arg, "-flto", 5) == 0) 1436 { 1437 #ifdef ENABLE_LTO 1438 /* Do not pass LTO flag to the linker. */ 1439 ld1--; 1440 ld2--; 1441 #else 1442 error ("LTO support has not been enabled in this " 1443 "configuration"); 1444 #endif 1445 } 1446 #ifdef TARGET_AIX_VERSION 1447 else 1448 { 1449 /* File containing a list of input files to process. */ 1450 1451 FILE *stream; 1452 char buf[MAXPATHLEN + 2]; 1453 /* Number of additionnal object files. */ 1454 int add_nbr = 0; 1455 /* Maximum of additionnal object files before vector 1456 expansion. */ 1457 int add_max = 0; 1458 const char *list_filename = arg + 2; 1459 1460 /* Accept -fFILENAME and -f FILENAME. */ 1461 if (*list_filename == '\0' && argv[1]) 1462 { 1463 ++argv; 1464 list_filename = *argv; 1465 *ld1++ = *ld2++ = *argv; 1466 } 1467 1468 stream = fopen (list_filename, "r"); 1469 if (stream == NULL) 1470 fatal_error ("can't open %s: %m", list_filename); 1471 1472 while (fgets (buf, sizeof buf, stream) != NULL) 1473 { 1474 /* Remove end of line. */ 1475 int len = strlen (buf); 1476 if (len >= 1 && buf[len - 1] =='\n') 1477 buf[len - 1] = '\0'; 1478 1479 /* Put on object vector. 1480 Note: we only expanse vector here, so we must keep 1481 extra space for remaining arguments. */ 1482 if (add_nbr >= add_max) 1483 { 1484 int pos = 1485 object - CONST_CAST2 (const char **, char **, 1486 object_lst); 1487 add_max = (add_max == 0) ? 16 : add_max * 2; 1488 object_lst = XRESIZEVEC (char *, object_lst, 1489 object_nbr + add_max); 1490 object = CONST_CAST2 (const char **, char **, 1491 object_lst) + pos; 1492 object_nbr += add_max; 1493 } 1494 *object++ = xstrdup (buf); 1495 add_nbr++; 1496 } 1497 fclose (stream); 1498 } 1499 #endif 1500 break; 1501 1502 case 'l': 1503 if (first_file) 1504 { 1505 /* place o_file BEFORE this argument! */ 1506 first_file = 0; 1507 ld2--; 1508 *ld2++ = o_file; 1509 *ld2++ = arg; 1510 } 1511 #ifdef COLLECT_EXPORT_LIST 1512 { 1513 /* Resolving full library name. */ 1514 const char *s = resolve_lib_name (arg+2); 1515 1516 /* Saving a full library name. */ 1517 add_to_list (&libs, s); 1518 } 1519 #endif 1520 break; 1521 1522 #ifdef COLLECT_EXPORT_LIST 1523 /* Saving directories where to search for libraries. */ 1524 case 'L': 1525 add_prefix (&cmdline_lib_dirs, arg+2); 1526 break; 1527 #else 1528 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 1529 case 'L': 1530 if (is_in_args (arg, 1531 CONST_CAST2 (const char **, char **, ld1_argv), 1532 ld1 - 1)) 1533 --ld1; 1534 break; 1535 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */ 1536 #endif 1537 1538 case 'o': 1539 if (arg[2] == '\0') 1540 output_file = *ld1++ = *ld2++ = *++argv; 1541 else 1542 output_file = &arg[2]; 1543 break; 1544 1545 case 'r': 1546 if (arg[2] == '\0') 1547 rflag = 1; 1548 break; 1549 1550 case 's': 1551 if (arg[2] == '\0' && do_collecting) 1552 { 1553 /* We must strip after the nm run, otherwise C++ linking 1554 will not work. Thus we strip in the second ld run, or 1555 else with strip if there is no second ld run. */ 1556 strip_flag = 1; 1557 ld1--; 1558 } 1559 break; 1560 1561 case 'v': 1562 if (arg[2] == '\0') 1563 vflag = true; 1564 break; 1565 1566 case '-': 1567 if (strcmp (arg, "--no-demangle") == 0) 1568 { 1569 #ifndef HAVE_LD_DEMANGLE 1570 no_demangle = 1; 1571 ld1--; 1572 ld2--; 1573 #endif 1574 } 1575 else if (strncmp (arg, "--demangle", 10) == 0) 1576 { 1577 #ifndef HAVE_LD_DEMANGLE 1578 no_demangle = 0; 1579 if (arg[10] == '=') 1580 { 1581 enum demangling_styles style 1582 = cplus_demangle_name_to_style (arg+11); 1583 if (style == unknown_demangling) 1584 error ("unknown demangling style '%s'", arg+11); 1585 else 1586 current_demangling_style = style; 1587 } 1588 ld1--; 1589 ld2--; 1590 #endif 1591 } 1592 else if (strncmp (arg, "--sysroot=", 10) == 0) 1593 target_system_root = arg + 10; 1594 else if (strcmp (arg, "--version") == 0) 1595 vflag = true; 1596 else if (strcmp (arg, "--help") == 0) 1597 helpflag = true; 1598 break; 1599 } 1600 } 1601 else if ((p = strrchr (arg, '.')) != (char *) 0 1602 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0 1603 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0 1604 || strcmp (p, ".obj") == 0)) 1605 { 1606 if (first_file) 1607 { 1608 first_file = 0; 1609 if (p[1] == 'o') 1610 *ld2++ = o_file; 1611 else 1612 { 1613 /* place o_file BEFORE this argument! */ 1614 ld2--; 1615 *ld2++ = o_file; 1616 *ld2++ = arg; 1617 } 1618 } 1619 if (p[1] == 'o' || p[1] == 'l') 1620 *object++ = arg; 1621 #ifdef COLLECT_EXPORT_LIST 1622 /* libraries can be specified directly, i.e. without -l flag. */ 1623 else 1624 { 1625 /* Saving a full library name. */ 1626 add_to_list (&libs, arg); 1627 } 1628 #endif 1629 } 1630 } 1631 1632 #ifdef COLLECT_EXPORT_LIST 1633 /* This is added only for debugging purposes. */ 1634 if (debug) 1635 { 1636 fprintf (stderr, "List of libraries:\n"); 1637 dump_list (stderr, "\t", libs.first); 1638 } 1639 1640 /* The AIX linker will discard static constructors in object files if 1641 nothing else in the file is referenced, so look at them first. Unless 1642 we are building a shared object, ignore the eh frame tables, as we 1643 would otherwise reference them all, hence drag all the corresponding 1644 objects even if nothing else is referenced. */ 1645 { 1646 const char **export_object_lst 1647 = CONST_CAST2 (const char **, char **, object_lst); 1648 1649 struct id *list = libs.first; 1650 1651 /* Compute the filter to use from the current one, do scan, then adjust 1652 the "current" filter to remove what we just included here. This will 1653 control whether we need a first pass link later on or not, and what 1654 will remain to be scanned there. */ 1655 1656 scanfilter this_filter = ld1_filter; 1657 #if HAVE_AS_REF 1658 if (!shared_obj) 1659 this_filter &= ~SCAN_DWEH; 1660 #endif 1661 1662 while (export_object_lst < object) 1663 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter); 1664 1665 for (; list; list = list->next) 1666 scan_prog_file (list->name, PASS_FIRST, this_filter); 1667 1668 ld1_filter = ld1_filter & ~this_filter; 1669 } 1670 1671 if (exports.first) 1672 { 1673 char *buf = concat ("-bE:", export_file, NULL); 1674 1675 *ld1++ = buf; 1676 *ld2++ = buf; 1677 1678 exportf = fopen (export_file, "w"); 1679 if (exportf == (FILE *) 0) 1680 fatal_error ("fopen %s: %m", export_file); 1681 write_aix_file (exportf, exports.first); 1682 if (fclose (exportf)) 1683 fatal_error ("fclose %s: %m", export_file); 1684 } 1685 #endif 1686 1687 *c_ptr++ = c_file; 1688 *c_ptr = *ld1 = *object = (char *) 0; 1689 1690 if (vflag) 1691 notice ("collect2 version %s\n", version_string); 1692 1693 if (helpflag) 1694 { 1695 printf ("Usage: collect2 [options]\n"); 1696 printf (" Wrap linker and generate constructor code if needed.\n"); 1697 printf (" Options:\n"); 1698 printf (" -debug Enable debug output\n"); 1699 printf (" --help Display this information\n"); 1700 printf (" -v, --version Display this program's version number\n"); 1701 printf ("\n"); 1702 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n"); 1703 printf ("Report bugs: %s\n", bug_report_url); 1704 printf ("\n"); 1705 } 1706 1707 if (debug) 1708 { 1709 const char *ptr; 1710 fprintf (stderr, "ld_file_name = %s\n", 1711 (ld_file_name ? ld_file_name : "not found")); 1712 fprintf (stderr, "c_file_name = %s\n", 1713 (c_file_name ? c_file_name : "not found")); 1714 fprintf (stderr, "nm_file_name = %s\n", 1715 (nm_file_name ? nm_file_name : "not found")); 1716 #ifdef LDD_SUFFIX 1717 fprintf (stderr, "ldd_file_name = %s\n", 1718 (ldd_file_name ? ldd_file_name : "not found")); 1719 #endif 1720 fprintf (stderr, "strip_file_name = %s\n", 1721 (strip_file_name ? strip_file_name : "not found")); 1722 fprintf (stderr, "c_file = %s\n", 1723 (c_file ? c_file : "not found")); 1724 fprintf (stderr, "o_file = %s\n", 1725 (o_file ? o_file : "not found")); 1726 1727 ptr = getenv ("COLLECT_GCC_OPTIONS"); 1728 if (ptr) 1729 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr); 1730 1731 ptr = getenv ("COLLECT_GCC"); 1732 if (ptr) 1733 fprintf (stderr, "COLLECT_GCC = %s\n", ptr); 1734 1735 ptr = getenv ("COMPILER_PATH"); 1736 if (ptr) 1737 fprintf (stderr, "COMPILER_PATH = %s\n", ptr); 1738 1739 ptr = getenv (LIBRARY_PATH_ENV); 1740 if (ptr) 1741 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr); 1742 1743 fprintf (stderr, "\n"); 1744 } 1745 1746 /* Load the program, searching all libraries and attempting to provide 1747 undefined symbols from repository information. 1748 1749 If -r or they will be run via some other method, do not build the 1750 constructor or destructor list, just return now. */ 1751 { 1752 bool early_exit 1753 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting); 1754 1755 /* Perform the first pass link now, if we're about to exit or if we need 1756 to scan for things we haven't collected yet before pursuing further. 1757 1758 On AIX, the latter typically includes nothing for shared objects or 1759 frame tables for an executable, out of what the required early scan on 1760 objects and libraries has performed above. In the !shared_obj case, we 1761 expect the relevant tables to be dragged together with their associated 1762 functions from precise cross reference insertions by the compiler. */ 1763 1764 if (early_exit || ld1_filter != SCAN_NOTHING) 1765 do_tlink (ld1_argv, object_lst); 1766 1767 if (early_exit) 1768 { 1769 #ifdef COLLECT_EXPORT_LIST 1770 /* Make sure we delete the export file we may have created. */ 1771 if (export_file != 0 && export_file[0]) 1772 maybe_unlink (export_file); 1773 #endif 1774 if (lto_mode != LTO_MODE_NONE) 1775 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false); 1776 else 1777 post_ld_pass (false); 1778 1779 maybe_unlink (c_file); 1780 maybe_unlink (o_file); 1781 return 0; 1782 } 1783 } 1784 1785 /* Unless we have done it all already, examine the namelist and search for 1786 static constructors and destructors to call. Write the constructor and 1787 destructor tables to a .s file and reload. */ 1788 1789 if (ld1_filter != SCAN_NOTHING) 1790 scan_prog_file (output_file, PASS_FIRST, ld1_filter); 1791 1792 #ifdef SCAN_LIBRARIES 1793 scan_libraries (output_file); 1794 #endif 1795 1796 if (debug) 1797 { 1798 notice_translated (ngettext ("%d constructor found\n", 1799 "%d constructors found\n", 1800 constructors.number), 1801 constructors.number); 1802 notice_translated (ngettext ("%d destructor found\n", 1803 "%d destructors found\n", 1804 destructors.number), 1805 destructors.number); 1806 notice_translated (ngettext("%d frame table found\n", 1807 "%d frame tables found\n", 1808 frame_tables.number), 1809 frame_tables.number); 1810 } 1811 1812 /* If the scan exposed nothing of special interest, there's no need to 1813 generate the glue code and relink so return now. */ 1814 1815 if (constructors.number == 0 && destructors.number == 0 1816 && frame_tables.number == 0 1817 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST) 1818 /* If we will be running these functions ourselves, we want to emit 1819 stubs into the shared library so that we do not have to relink 1820 dependent programs when we add static objects. */ 1821 && ! shared_obj 1822 #endif 1823 ) 1824 { 1825 /* Do tlink without additional code generation now if we didn't 1826 do it earlier for scanning purposes. */ 1827 if (ld1_filter == SCAN_NOTHING) 1828 do_tlink (ld1_argv, object_lst); 1829 1830 if (lto_mode) 1831 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false); 1832 1833 /* Strip now if it was requested on the command line. */ 1834 if (strip_flag) 1835 { 1836 char **real_strip_argv = XCNEWVEC (char *, 3); 1837 const char ** strip_argv = CONST_CAST2 (const char **, char **, 1838 real_strip_argv); 1839 1840 strip_argv[0] = strip_file_name; 1841 strip_argv[1] = output_file; 1842 strip_argv[2] = (char *) 0; 1843 fork_execute ("strip", real_strip_argv); 1844 } 1845 1846 #ifdef COLLECT_EXPORT_LIST 1847 maybe_unlink (export_file); 1848 #endif 1849 post_ld_pass (false); 1850 1851 maybe_unlink (c_file); 1852 maybe_unlink (o_file); 1853 return 0; 1854 } 1855 1856 /* Sort ctor and dtor lists by priority. */ 1857 sort_ids (&constructors); 1858 sort_ids (&destructors); 1859 1860 maybe_unlink(output_file); 1861 outf = fopen (c_file, "w"); 1862 if (outf == (FILE *) 0) 1863 fatal_error ("fopen %s: %m", c_file); 1864 1865 write_c_file (outf, c_file); 1866 1867 if (fclose (outf)) 1868 fatal_error ("fclose %s: %m", c_file); 1869 1870 /* Tell the linker that we have initializer and finalizer functions. */ 1871 #ifdef LD_INIT_SWITCH 1872 #ifdef COLLECT_EXPORT_LIST 1873 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL); 1874 #else 1875 *ld2++ = LD_INIT_SWITCH; 1876 *ld2++ = initname; 1877 *ld2++ = LD_FINI_SWITCH; 1878 *ld2++ = fininame; 1879 #endif 1880 #endif 1881 1882 #ifdef COLLECT_EXPORT_LIST 1883 if (shared_obj) 1884 { 1885 /* If we did not add export flag to link arguments before, add it to 1886 second link phase now. No new exports should have been added. */ 1887 if (! exports.first) 1888 *ld2++ = concat ("-bE:", export_file, NULL); 1889 1890 #ifndef LD_INIT_SWITCH 1891 add_to_list (&exports, initname); 1892 add_to_list (&exports, fininame); 1893 add_to_list (&exports, "_GLOBAL__DI"); 1894 add_to_list (&exports, "_GLOBAL__DD"); 1895 #endif 1896 exportf = fopen (export_file, "w"); 1897 if (exportf == (FILE *) 0) 1898 fatal_error ("fopen %s: %m", export_file); 1899 write_aix_file (exportf, exports.first); 1900 if (fclose (exportf)) 1901 fatal_error ("fclose %s: %m", export_file); 1902 } 1903 #endif 1904 1905 /* End of arguments to second link phase. */ 1906 *ld2 = (char*) 0; 1907 1908 if (debug) 1909 { 1910 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n", 1911 output_file, c_file); 1912 write_c_file (stderr, "stderr"); 1913 fprintf (stderr, "========== end of c_file\n\n"); 1914 #ifdef COLLECT_EXPORT_LIST 1915 fprintf (stderr, "\n========== export_file = %s\n", export_file); 1916 write_aix_file (stderr, exports.first); 1917 fprintf (stderr, "========== end of export_file\n\n"); 1918 #endif 1919 } 1920 1921 /* Assemble the constructor and destructor tables. 1922 Link the tables in with the rest of the program. */ 1923 1924 fork_execute ("gcc", c_argv); 1925 #ifdef COLLECT_EXPORT_LIST 1926 /* On AIX we must call tlink because of possible templates resolution. */ 1927 do_tlink (ld2_argv, object_lst); 1928 1929 if (lto_mode) 1930 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false); 1931 #else 1932 /* Otherwise, simply call ld because tlink is already done. */ 1933 if (lto_mode) 1934 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true); 1935 else 1936 { 1937 fork_execute ("ld", ld2_argv); 1938 post_ld_pass (false); 1939 } 1940 1941 /* Let scan_prog_file do any final mods (OSF/rose needs this for 1942 constructors/destructors in shared libraries. */ 1943 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL); 1944 #endif 1945 1946 maybe_unlink (c_file); 1947 maybe_unlink (o_file); 1948 1949 #ifdef COLLECT_EXPORT_LIST 1950 maybe_unlink (export_file); 1951 #endif 1952 1953 return 0; 1954 } 1955 1956 1957 /* Wait for a process to finish, and exit if a nonzero status is found. */ 1958 1959 int 1960 collect_wait (const char *prog, struct pex_obj *pex) 1961 { 1962 int status; 1963 1964 if (!pex_get_status (pex, 1, &status)) 1965 fatal_error ("can't get program status: %m"); 1966 pex_free (pex); 1967 1968 if (status) 1969 { 1970 if (WIFSIGNALED (status)) 1971 { 1972 int sig = WTERMSIG (status); 1973 error ("%s terminated with signal %d [%s]%s", 1974 prog, sig, strsignal(sig), 1975 WCOREDUMP(status) ? ", core dumped" : ""); 1976 collect_exit (FATAL_EXIT_CODE); 1977 } 1978 1979 if (WIFEXITED (status)) 1980 return WEXITSTATUS (status); 1981 } 1982 return 0; 1983 } 1984 1985 static void 1986 do_wait (const char *prog, struct pex_obj *pex) 1987 { 1988 int ret = collect_wait (prog, pex); 1989 if (ret != 0) 1990 { 1991 error ("%s returned %d exit status", prog, ret); 1992 collect_exit (ret); 1993 } 1994 1995 if (response_file) 1996 { 1997 unlink (response_file); 1998 response_file = NULL; 1999 } 2000 } 2001 2002 2003 /* Execute a program, and wait for the reply. */ 2004 2005 struct pex_obj * 2006 collect_execute (const char *prog, char **argv, const char *outname, 2007 const char *errname, int flags) 2008 { 2009 struct pex_obj *pex; 2010 const char *errmsg; 2011 int err; 2012 char *response_arg = NULL; 2013 char *response_argv[3] ATTRIBUTE_UNUSED; 2014 2015 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL) 2016 { 2017 /* If using @file arguments, create a temporary file and put the 2018 contents of argv into it. Then change argv to an array corresponding 2019 to a single argument @FILE, where FILE is the temporary filename. */ 2020 2021 char **current_argv = argv + 1; 2022 char *argv0 = argv[0]; 2023 int status; 2024 FILE *f; 2025 2026 /* Note: we assume argv contains at least one element; this is 2027 checked above. */ 2028 2029 response_file = make_temp_file (""); 2030 2031 f = fopen (response_file, "w"); 2032 2033 if (f == NULL) 2034 fatal_error ("could not open response file %s", response_file); 2035 2036 status = writeargv (current_argv, f); 2037 2038 if (status) 2039 fatal_error ("could not write to response file %s", response_file); 2040 2041 status = fclose (f); 2042 2043 if (EOF == status) 2044 fatal_error ("could not close response file %s", response_file); 2045 2046 response_arg = concat ("@", response_file, NULL); 2047 response_argv[0] = argv0; 2048 response_argv[1] = response_arg; 2049 response_argv[2] = NULL; 2050 2051 argv = response_argv; 2052 } 2053 2054 if (vflag || debug) 2055 { 2056 char **p_argv; 2057 const char *str; 2058 2059 if (argv[0]) 2060 fprintf (stderr, "%s", argv[0]); 2061 else 2062 notice ("[cannot find %s]", prog); 2063 2064 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++) 2065 fprintf (stderr, " %s", str); 2066 2067 fprintf (stderr, "\n"); 2068 } 2069 2070 fflush (stdout); 2071 fflush (stderr); 2072 2073 /* If we cannot find a program we need, complain error. Do this here 2074 since we might not end up needing something that we could not find. */ 2075 2076 if (argv[0] == 0) 2077 fatal_error ("cannot find '%s'", prog); 2078 2079 pex = pex_init (0, "collect2", NULL); 2080 if (pex == NULL) 2081 fatal_error ("pex_init failed: %m"); 2082 2083 errmsg = pex_run (pex, flags, argv[0], argv, outname, 2084 errname, &err); 2085 if (errmsg != NULL) 2086 { 2087 if (err != 0) 2088 { 2089 errno = err; 2090 fatal_error ("%s: %m", _(errmsg)); 2091 } 2092 else 2093 fatal_error (errmsg); 2094 } 2095 2096 free (response_arg); 2097 2098 return pex; 2099 } 2100 2101 static void 2102 fork_execute (const char *prog, char **argv) 2103 { 2104 struct pex_obj *pex; 2105 2106 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH); 2107 do_wait (prog, pex); 2108 } 2109 2110 /* Unlink a file unless we are debugging. */ 2111 2112 static void 2113 maybe_unlink (const char *file) 2114 { 2115 if (!debug) 2116 unlink_if_ordinary (file); 2117 else 2118 notice ("[Leaving %s]\n", file); 2119 } 2120 2121 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */ 2122 2123 static void 2124 maybe_unlink_list (char **file_list) 2125 { 2126 char **tmp = file_list; 2127 2128 while (*tmp) 2129 maybe_unlink (*(tmp++)); 2130 } 2131 2132 2133 static long sequence_number = 0; 2134 2135 /* Add a name to a linked list. */ 2136 2137 static void 2138 add_to_list (struct head *head_ptr, const char *name) 2139 { 2140 struct id *newid 2141 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1); 2142 struct id *p; 2143 strcpy (newid->name, name); 2144 2145 if (head_ptr->first) 2146 head_ptr->last->next = newid; 2147 else 2148 head_ptr->first = newid; 2149 2150 /* Check for duplicate symbols. */ 2151 for (p = head_ptr->first; 2152 strcmp (name, p->name) != 0; 2153 p = p->next) 2154 ; 2155 if (p != newid) 2156 { 2157 head_ptr->last->next = 0; 2158 free (newid); 2159 return; 2160 } 2161 2162 newid->sequence = ++sequence_number; 2163 head_ptr->last = newid; 2164 head_ptr->number++; 2165 } 2166 2167 /* Grab the init priority number from an init function name that 2168 looks like "_GLOBAL_.I.12345.foo". */ 2169 2170 static int 2171 extract_init_priority (const char *name) 2172 { 2173 int pos = 0, pri; 2174 2175 while (name[pos] == '_') 2176 ++pos; 2177 pos += 10; /* strlen ("GLOBAL__X_") */ 2178 2179 /* Extract init_p number from ctor/dtor name. */ 2180 pri = atoi (name + pos); 2181 return pri ? pri : DEFAULT_INIT_PRIORITY; 2182 } 2183 2184 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order. 2185 ctors will be run from right to left, dtors from left to right. */ 2186 2187 static void 2188 sort_ids (struct head *head_ptr) 2189 { 2190 /* id holds the current element to insert. id_next holds the next 2191 element to insert. id_ptr iterates through the already sorted elements 2192 looking for the place to insert id. */ 2193 struct id *id, *id_next, **id_ptr; 2194 2195 id = head_ptr->first; 2196 2197 /* We don't have any sorted elements yet. */ 2198 head_ptr->first = NULL; 2199 2200 for (; id; id = id_next) 2201 { 2202 id_next = id->next; 2203 id->sequence = extract_init_priority (id->name); 2204 2205 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next)) 2206 if (*id_ptr == NULL 2207 /* If the sequence numbers are the same, we put the id from the 2208 file later on the command line later in the list. */ 2209 || id->sequence > (*id_ptr)->sequence 2210 /* Hack: do lexical compare, too. 2211 || (id->sequence == (*id_ptr)->sequence 2212 && strcmp (id->name, (*id_ptr)->name) > 0) */ 2213 ) 2214 { 2215 id->next = *id_ptr; 2216 *id_ptr = id; 2217 break; 2218 } 2219 } 2220 2221 /* Now set the sequence numbers properly so write_c_file works. */ 2222 for (id = head_ptr->first; id; id = id->next) 2223 id->sequence = ++sequence_number; 2224 } 2225 2226 /* Write: `prefix', the names on list LIST, `suffix'. */ 2227 2228 static void 2229 write_list (FILE *stream, const char *prefix, struct id *list) 2230 { 2231 while (list) 2232 { 2233 fprintf (stream, "%sx%d,\n", prefix, list->sequence); 2234 list = list->next; 2235 } 2236 } 2237 2238 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 2239 /* Given a STRING, return nonzero if it occurs in the list in range 2240 [ARGS_BEGIN,ARGS_END). */ 2241 2242 static int 2243 is_in_args (const char *string, const char **args_begin, 2244 const char **args_end) 2245 { 2246 const char **args_pointer; 2247 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer) 2248 if (strcmp (string, *args_pointer) == 0) 2249 return 1; 2250 return 0; 2251 } 2252 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */ 2253 2254 #ifdef COLLECT_EXPORT_LIST 2255 /* This function is really used only on AIX, but may be useful. */ 2256 #if 0 2257 static int 2258 is_in_list (const char *prefix, struct id *list) 2259 { 2260 while (list) 2261 { 2262 if (!strcmp (prefix, list->name)) return 1; 2263 list = list->next; 2264 } 2265 return 0; 2266 } 2267 #endif 2268 #endif /* COLLECT_EXPORT_LIST */ 2269 2270 /* Added for debugging purpose. */ 2271 #ifdef COLLECT_EXPORT_LIST 2272 static void 2273 dump_list (FILE *stream, const char *prefix, struct id *list) 2274 { 2275 while (list) 2276 { 2277 fprintf (stream, "%s%s,\n", prefix, list->name); 2278 list = list->next; 2279 } 2280 } 2281 #endif 2282 2283 #if 0 2284 static void 2285 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list) 2286 { 2287 while (list) 2288 { 2289 fprintf (stream, "%s%s,\n", prefix, list->prefix); 2290 list = list->next; 2291 } 2292 } 2293 #endif 2294 2295 static void 2296 write_list_with_asm (FILE *stream, const char *prefix, struct id *list) 2297 { 2298 while (list) 2299 { 2300 fprintf (stream, "%sx%d __asm__ (\"%s\");\n", 2301 prefix, list->sequence, list->name); 2302 list = list->next; 2303 } 2304 } 2305 2306 /* Write out the constructor and destructor tables statically (for a shared 2307 object), along with the functions to execute them. */ 2308 2309 static void 2310 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED) 2311 { 2312 const char *p, *q; 2313 char *prefix, *r; 2314 int frames = (frame_tables.number > 0); 2315 2316 /* Figure out name of output_file, stripping off .so version. */ 2317 q = p = lbasename (output_file); 2318 2319 while (q) 2320 { 2321 q = strchr (q,'.'); 2322 if (q == 0) 2323 { 2324 q = p + strlen (p); 2325 break; 2326 } 2327 else 2328 { 2329 if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0) 2330 { 2331 q += strlen (SHLIB_SUFFIX); 2332 break; 2333 } 2334 else 2335 q++; 2336 } 2337 } 2338 /* q points to null at end of the string (or . of the .so version) */ 2339 prefix = XNEWVEC (char, q - p + 1); 2340 strncpy (prefix, p, q - p); 2341 prefix[q - p] = 0; 2342 for (r = prefix; *r; r++) 2343 if (!ISALNUM ((unsigned char)*r)) 2344 *r = '_'; 2345 if (debug) 2346 notice ("\nwrite_c_file - output name is %s, prefix is %s\n", 2347 output_file, prefix); 2348 2349 initname = concat ("_GLOBAL__FI_", prefix, NULL); 2350 fininame = concat ("_GLOBAL__FD_", prefix, NULL); 2351 2352 free (prefix); 2353 2354 /* Write the tables as C code. */ 2355 2356 fprintf (stream, "static int count;\n"); 2357 fprintf (stream, "typedef void entry_pt();\n"); 2358 write_list_with_asm (stream, "extern entry_pt ", constructors.first); 2359 2360 if (frames) 2361 { 2362 write_list_with_asm (stream, "extern void *", frame_tables.first); 2363 2364 fprintf (stream, "\tstatic void *frame_table[] = {\n"); 2365 write_list (stream, "\t\t&", frame_tables.first); 2366 fprintf (stream, "\t0\n};\n"); 2367 2368 /* This must match what's in frame.h. */ 2369 fprintf (stream, "struct object {\n"); 2370 fprintf (stream, " void *pc_begin;\n"); 2371 fprintf (stream, " void *pc_end;\n"); 2372 fprintf (stream, " void *fde_begin;\n"); 2373 fprintf (stream, " void *fde_array;\n"); 2374 fprintf (stream, " __SIZE_TYPE__ count;\n"); 2375 fprintf (stream, " struct object *next;\n"); 2376 fprintf (stream, "};\n"); 2377 2378 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n"); 2379 fprintf (stream, "extern void *__deregister_frame_info (void *);\n"); 2380 2381 fprintf (stream, "static void reg_frame () {\n"); 2382 fprintf (stream, "\tstatic struct object ob;\n"); 2383 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n"); 2384 fprintf (stream, "\t}\n"); 2385 2386 fprintf (stream, "static void dereg_frame () {\n"); 2387 fprintf (stream, "\t__deregister_frame_info (frame_table);\n"); 2388 fprintf (stream, "\t}\n"); 2389 } 2390 2391 fprintf (stream, "void %s() {\n", initname); 2392 if (constructors.number > 0 || frames) 2393 { 2394 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n"); 2395 write_list (stream, "\t\t", constructors.first); 2396 if (frames) 2397 fprintf (stream, "\treg_frame,\n"); 2398 fprintf (stream, "\t};\n"); 2399 fprintf (stream, "\tentry_pt **p;\n"); 2400 fprintf (stream, "\tif (count++ != 0) return;\n"); 2401 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames); 2402 fprintf (stream, "\twhile (p > ctors) (*--p)();\n"); 2403 } 2404 else 2405 fprintf (stream, "\t++count;\n"); 2406 fprintf (stream, "}\n"); 2407 write_list_with_asm (stream, "extern entry_pt ", destructors.first); 2408 fprintf (stream, "void %s() {\n", fininame); 2409 if (destructors.number > 0 || frames) 2410 { 2411 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n"); 2412 write_list (stream, "\t\t", destructors.first); 2413 if (frames) 2414 fprintf (stream, "\tdereg_frame,\n"); 2415 fprintf (stream, "\t};\n"); 2416 fprintf (stream, "\tentry_pt **p;\n"); 2417 fprintf (stream, "\tif (--count != 0) return;\n"); 2418 fprintf (stream, "\tp = dtors;\n"); 2419 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n", 2420 destructors.number + frames); 2421 } 2422 fprintf (stream, "}\n"); 2423 2424 if (shared_obj) 2425 { 2426 COLLECT_SHARED_INIT_FUNC(stream, initname); 2427 COLLECT_SHARED_FINI_FUNC(stream, fininame); 2428 } 2429 } 2430 2431 /* Write the constructor/destructor tables. */ 2432 2433 #ifndef LD_INIT_SWITCH 2434 static void 2435 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED) 2436 { 2437 /* Write the tables as C code. */ 2438 2439 int frames = (frame_tables.number > 0); 2440 2441 fprintf (stream, "typedef void entry_pt();\n\n"); 2442 2443 write_list_with_asm (stream, "extern entry_pt ", constructors.first); 2444 2445 if (frames) 2446 { 2447 write_list_with_asm (stream, "extern void *", frame_tables.first); 2448 2449 fprintf (stream, "\tstatic void *frame_table[] = {\n"); 2450 write_list (stream, "\t\t&", frame_tables.first); 2451 fprintf (stream, "\t0\n};\n"); 2452 2453 /* This must match what's in frame.h. */ 2454 fprintf (stream, "struct object {\n"); 2455 fprintf (stream, " void *pc_begin;\n"); 2456 fprintf (stream, " void *pc_end;\n"); 2457 fprintf (stream, " void *fde_begin;\n"); 2458 fprintf (stream, " void *fde_array;\n"); 2459 fprintf (stream, " __SIZE_TYPE__ count;\n"); 2460 fprintf (stream, " struct object *next;\n"); 2461 fprintf (stream, "};\n"); 2462 2463 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n"); 2464 fprintf (stream, "extern void *__deregister_frame_info (void *);\n"); 2465 2466 fprintf (stream, "static void reg_frame () {\n"); 2467 fprintf (stream, "\tstatic struct object ob;\n"); 2468 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n"); 2469 fprintf (stream, "\t}\n"); 2470 2471 fprintf (stream, "static void dereg_frame () {\n"); 2472 fprintf (stream, "\t__deregister_frame_info (frame_table);\n"); 2473 fprintf (stream, "\t}\n"); 2474 } 2475 2476 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n"); 2477 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames); 2478 write_list (stream, "\t", constructors.first); 2479 if (frames) 2480 fprintf (stream, "\treg_frame,\n"); 2481 fprintf (stream, "\t0\n};\n\n"); 2482 2483 write_list_with_asm (stream, "extern entry_pt ", destructors.first); 2484 2485 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n"); 2486 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames); 2487 write_list (stream, "\t", destructors.first); 2488 if (frames) 2489 fprintf (stream, "\tdereg_frame,\n"); 2490 fprintf (stream, "\t0\n};\n\n"); 2491 2492 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN); 2493 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN); 2494 } 2495 #endif /* ! LD_INIT_SWITCH */ 2496 2497 static void 2498 write_c_file (FILE *stream, const char *name) 2499 { 2500 #ifndef LD_INIT_SWITCH 2501 if (! shared_obj) 2502 write_c_file_glob (stream, name); 2503 else 2504 #endif 2505 write_c_file_stat (stream, name); 2506 } 2507 2508 #ifdef COLLECT_EXPORT_LIST 2509 static void 2510 write_aix_file (FILE *stream, struct id *list) 2511 { 2512 for (; list; list = list->next) 2513 { 2514 fputs (list->name, stream); 2515 putc ('\n', stream); 2516 } 2517 } 2518 #endif 2519 2520 #ifdef OBJECT_FORMAT_NONE 2521 2522 /* Check to make sure the file is an LTO object file. */ 2523 2524 static bool 2525 maybe_lto_object_file (const char *prog_name) 2526 { 2527 FILE *f; 2528 unsigned char buf[4]; 2529 int i; 2530 2531 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' }; 2532 static unsigned char coffmagic[2] = { 0x4c, 0x01 }; 2533 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 }; 2534 static unsigned char machomagic[4][4] = { 2535 { 0xcf, 0xfa, 0xed, 0xfe }, 2536 { 0xce, 0xfa, 0xed, 0xfe }, 2537 { 0xfe, 0xed, 0xfa, 0xcf }, 2538 { 0xfe, 0xed, 0xfa, 0xce } 2539 }; 2540 2541 f = fopen (prog_name, "rb"); 2542 if (f == NULL) 2543 return false; 2544 if (fread (buf, sizeof (buf), 1, f) != 1) 2545 buf[0] = 0; 2546 fclose (f); 2547 2548 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0 2549 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0 2550 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0) 2551 return true; 2552 for (i = 0; i < 4; i++) 2553 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0) 2554 return true; 2555 2556 return false; 2557 } 2558 2559 /* Generic version to scan the name list of the loaded program for 2560 the symbols g++ uses for static constructors and destructors. */ 2561 2562 static void 2563 scan_prog_file (const char *prog_name, scanpass which_pass, 2564 scanfilter filter) 2565 { 2566 void (*int_handler) (int); 2567 #ifdef SIGQUIT 2568 void (*quit_handler) (int); 2569 #endif 2570 char *real_nm_argv[4]; 2571 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv); 2572 int argc = 0; 2573 struct pex_obj *pex; 2574 const char *errmsg; 2575 int err; 2576 char *p, buf[1024]; 2577 FILE *inf; 2578 int found_lto = 0; 2579 2580 if (which_pass == PASS_SECOND) 2581 return; 2582 2583 /* LTO objects must be in a known format. This check prevents 2584 us from accepting an archive containing LTO objects, which 2585 gcc cannnot currently handle. */ 2586 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name)) 2587 return; 2588 2589 /* If we do not have an `nm', complain. */ 2590 if (nm_file_name == 0) 2591 fatal_error ("cannot find 'nm'"); 2592 2593 nm_argv[argc++] = nm_file_name; 2594 if (NM_FLAGS[0] != '\0') 2595 nm_argv[argc++] = NM_FLAGS; 2596 2597 nm_argv[argc++] = prog_name; 2598 nm_argv[argc++] = (char *) 0; 2599 2600 /* Trace if needed. */ 2601 if (vflag) 2602 { 2603 const char **p_argv; 2604 const char *str; 2605 2606 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++) 2607 fprintf (stderr, " %s", str); 2608 2609 fprintf (stderr, "\n"); 2610 } 2611 2612 fflush (stdout); 2613 fflush (stderr); 2614 2615 pex = pex_init (PEX_USE_PIPES, "collect2", NULL); 2616 if (pex == NULL) 2617 fatal_error ("pex_init failed: %m"); 2618 2619 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET, 2620 &err); 2621 if (errmsg != NULL) 2622 { 2623 if (err != 0) 2624 { 2625 errno = err; 2626 fatal_error ("%s: %m", _(errmsg)); 2627 } 2628 else 2629 fatal_error (errmsg); 2630 } 2631 2632 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN); 2633 #ifdef SIGQUIT 2634 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN); 2635 #endif 2636 2637 inf = pex_read_output (pex, 0); 2638 if (inf == NULL) 2639 fatal_error ("can't open nm output: %m"); 2640 2641 if (debug) 2642 { 2643 if (which_pass == PASS_LTOINFO) 2644 fprintf (stderr, "\nnm output with LTO info marker symbol.\n"); 2645 else 2646 fprintf (stderr, "\nnm output with constructors/destructors.\n"); 2647 } 2648 2649 /* Read each line of nm output. */ 2650 while (fgets (buf, sizeof buf, inf) != (char *) 0) 2651 { 2652 int ch, ch2; 2653 char *name, *end; 2654 2655 if (debug) 2656 fprintf (stderr, "\t%s\n", buf); 2657 2658 if (which_pass == PASS_LTOINFO) 2659 { 2660 if (found_lto) 2661 continue; 2662 2663 /* Look for the LTO info marker symbol, and add filename to 2664 the LTO objects list if found. */ 2665 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++) 2666 if (ch == ' ' && p[1] == '_' && p[2] == '_' 2667 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0) 2668 && ISSPACE (p[p[3] == '_' ? 14 : 13])) 2669 { 2670 add_lto_object (<o_objects, prog_name); 2671 2672 /* We need to read all the input, so we can't just 2673 return here. But we can avoid useless work. */ 2674 found_lto = 1; 2675 2676 break; 2677 } 2678 2679 continue; 2680 } 2681 2682 /* If it contains a constructor or destructor name, add the name 2683 to the appropriate list unless this is a kind of symbol we're 2684 not supposed to even consider. */ 2685 2686 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++) 2687 if (ch == ' ' && p[1] == 'U' && p[2] == ' ') 2688 break; 2689 2690 if (ch != '_') 2691 continue; 2692 2693 name = p; 2694 /* Find the end of the symbol name. 2695 Do not include `|', because Encore nm can tack that on the end. */ 2696 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|'; 2697 end++) 2698 continue; 2699 2700 2701 *end = '\0'; 2702 switch (is_ctor_dtor (name)) 2703 { 2704 case SYM_CTOR: 2705 if (! (filter & SCAN_CTOR)) 2706 break; 2707 if (which_pass != PASS_LIB) 2708 add_to_list (&constructors, name); 2709 break; 2710 2711 case SYM_DTOR: 2712 if (! (filter & SCAN_DTOR)) 2713 break; 2714 if (which_pass != PASS_LIB) 2715 add_to_list (&destructors, name); 2716 break; 2717 2718 case SYM_INIT: 2719 if (! (filter & SCAN_INIT)) 2720 break; 2721 if (which_pass != PASS_LIB) 2722 fatal_error ("init function found in object %s", prog_name); 2723 #ifndef LD_INIT_SWITCH 2724 add_to_list (&constructors, name); 2725 #endif 2726 break; 2727 2728 case SYM_FINI: 2729 if (! (filter & SCAN_FINI)) 2730 break; 2731 if (which_pass != PASS_LIB) 2732 fatal_error ("fini function found in object %s", prog_name); 2733 #ifndef LD_FINI_SWITCH 2734 add_to_list (&destructors, name); 2735 #endif 2736 break; 2737 2738 case SYM_DWEH: 2739 if (! (filter & SCAN_DWEH)) 2740 break; 2741 if (which_pass != PASS_LIB) 2742 add_to_list (&frame_tables, name); 2743 break; 2744 2745 default: /* not a constructor or destructor */ 2746 continue; 2747 } 2748 } 2749 2750 if (debug) 2751 fprintf (stderr, "\n"); 2752 2753 do_wait (nm_file_name, pex); 2754 2755 signal (SIGINT, int_handler); 2756 #ifdef SIGQUIT 2757 signal (SIGQUIT, quit_handler); 2758 #endif 2759 } 2760 2761 #ifdef LDD_SUFFIX 2762 2763 /* Use the List Dynamic Dependencies program to find shared libraries that 2764 the output file depends upon and their initialization/finalization 2765 routines, if any. */ 2766 2767 static void 2768 scan_libraries (const char *prog_name) 2769 { 2770 static struct head libraries; /* list of shared libraries found */ 2771 struct id *list; 2772 void (*int_handler) (int); 2773 #ifdef SIGQUIT 2774 void (*quit_handler) (int); 2775 #endif 2776 char *real_ldd_argv[4]; 2777 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv); 2778 int argc = 0; 2779 struct pex_obj *pex; 2780 const char *errmsg; 2781 int err; 2782 char buf[1024]; 2783 FILE *inf; 2784 2785 /* If we do not have an `ldd', complain. */ 2786 if (ldd_file_name == 0) 2787 { 2788 error ("cannot find 'ldd'"); 2789 return; 2790 } 2791 2792 ldd_argv[argc++] = ldd_file_name; 2793 ldd_argv[argc++] = prog_name; 2794 ldd_argv[argc++] = (char *) 0; 2795 2796 /* Trace if needed. */ 2797 if (vflag) 2798 { 2799 const char **p_argv; 2800 const char *str; 2801 2802 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++) 2803 fprintf (stderr, " %s", str); 2804 2805 fprintf (stderr, "\n"); 2806 } 2807 2808 fflush (stdout); 2809 fflush (stderr); 2810 2811 pex = pex_init (PEX_USE_PIPES, "collect2", NULL); 2812 if (pex == NULL) 2813 fatal_error ("pex_init failed: %m"); 2814 2815 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err); 2816 if (errmsg != NULL) 2817 { 2818 if (err != 0) 2819 { 2820 errno = err; 2821 fatal_error ("%s: %m", _(errmsg)); 2822 } 2823 else 2824 fatal_error (errmsg); 2825 } 2826 2827 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN); 2828 #ifdef SIGQUIT 2829 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN); 2830 #endif 2831 2832 inf = pex_read_output (pex, 0); 2833 if (inf == NULL) 2834 fatal_error ("can't open ldd output: %m"); 2835 2836 if (debug) 2837 notice ("\nldd output with constructors/destructors.\n"); 2838 2839 /* Read each line of ldd output. */ 2840 while (fgets (buf, sizeof buf, inf) != (char *) 0) 2841 { 2842 int ch2; 2843 char *name, *end, *p = buf; 2844 2845 /* Extract names of libraries and add to list. */ 2846 PARSE_LDD_OUTPUT (p); 2847 if (p == 0) 2848 continue; 2849 2850 name = p; 2851 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0) 2852 fatal_error ("dynamic dependency %s not found", buf); 2853 2854 /* Find the end of the symbol name. */ 2855 for (end = p; 2856 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|'; 2857 end++) 2858 continue; 2859 *end = '\0'; 2860 2861 if (access (name, R_OK) == 0) 2862 add_to_list (&libraries, name); 2863 else 2864 fatal_error ("unable to open dynamic dependency '%s'", buf); 2865 2866 if (debug) 2867 fprintf (stderr, "\t%s\n", buf); 2868 } 2869 if (debug) 2870 fprintf (stderr, "\n"); 2871 2872 do_wait (ldd_file_name, pex); 2873 2874 signal (SIGINT, int_handler); 2875 #ifdef SIGQUIT 2876 signal (SIGQUIT, quit_handler); 2877 #endif 2878 2879 /* Now iterate through the library list adding their symbols to 2880 the list. */ 2881 for (list = libraries.first; list; list = list->next) 2882 scan_prog_file (list->name, PASS_LIB, SCAN_ALL); 2883 } 2884 2885 #endif /* LDD_SUFFIX */ 2886 2887 #endif /* OBJECT_FORMAT_NONE */ 2888 2889 2890 /* 2891 * COFF specific stuff. 2892 */ 2893 2894 #ifdef OBJECT_FORMAT_COFF 2895 2896 #if defined (EXTENDED_COFF) 2897 2898 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax) 2899 # define GCC_SYMENT SYMR 2900 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal) 2901 # define GCC_SYMINC(X) (1) 2902 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax) 2903 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0) 2904 2905 #else 2906 2907 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms) 2908 # define GCC_SYMENT SYMENT 2909 # if defined (C_WEAKEXT) 2910 # define GCC_OK_SYMBOL(X) \ 2911 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \ 2912 ((X).n_scnum > N_UNDEF) && \ 2913 (aix64_flag \ 2914 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \ 2915 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))) 2916 # define GCC_UNDEF_SYMBOL(X) \ 2917 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \ 2918 ((X).n_scnum == N_UNDEF)) 2919 # else 2920 # define GCC_OK_SYMBOL(X) \ 2921 (((X).n_sclass == C_EXT) && \ 2922 ((X).n_scnum > N_UNDEF) && \ 2923 (aix64_flag \ 2924 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \ 2925 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))) 2926 # define GCC_UNDEF_SYMBOL(X) \ 2927 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF)) 2928 # endif 2929 # define GCC_SYMINC(X) ((X).n_numaux+1) 2930 # define GCC_SYMZERO(X) 0 2931 2932 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */ 2933 #if TARGET_AIX_VERSION >= 51 2934 # define GCC_CHECK_HDR(X) \ 2935 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \ 2936 || (HEADER (X).f_magic == 0767 && aix64_flag)) 2937 #else 2938 # define GCC_CHECK_HDR(X) \ 2939 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \ 2940 || (HEADER (X).f_magic == 0757 && aix64_flag)) 2941 #endif 2942 2943 #endif 2944 2945 #ifdef COLLECT_EXPORT_LIST 2946 /* Array of standard AIX libraries which should not 2947 be scanned for ctors/dtors. */ 2948 static const char *const aix_std_libs[] = { 2949 "/unix", 2950 "/lib/libc.a", 2951 "/lib/libm.a", 2952 "/lib/libc_r.a", 2953 "/lib/libm_r.a", 2954 "/usr/lib/libc.a", 2955 "/usr/lib/libm.a", 2956 "/usr/lib/libc_r.a", 2957 "/usr/lib/libm_r.a", 2958 "/usr/lib/threads/libc.a", 2959 "/usr/ccs/lib/libc.a", 2960 "/usr/ccs/lib/libm.a", 2961 "/usr/ccs/lib/libc_r.a", 2962 "/usr/ccs/lib/libm_r.a", 2963 NULL 2964 }; 2965 2966 /* This function checks the filename and returns 1 2967 if this name matches the location of a standard AIX library. */ 2968 static int ignore_library (const char *); 2969 static int 2970 ignore_library (const char *name) 2971 { 2972 const char *const *p; 2973 size_t length; 2974 2975 if (target_system_root[0] != '\0') 2976 { 2977 length = strlen (target_system_root); 2978 if (strncmp (name, target_system_root, length) != 0) 2979 return 0; 2980 name += length; 2981 } 2982 for (p = &aix_std_libs[0]; *p != NULL; ++p) 2983 if (strcmp (name, *p) == 0) 2984 return 1; 2985 return 0; 2986 } 2987 #endif /* COLLECT_EXPORT_LIST */ 2988 2989 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME 2990 extern char *ldgetname (LDFILE *, GCC_SYMENT *); 2991 #endif 2992 2993 /* COFF version to scan the name list of the loaded program for 2994 the symbols g++ uses for static constructors and destructors. */ 2995 2996 static void 2997 scan_prog_file (const char *prog_name, scanpass which_pass, 2998 scanfilter filter) 2999 { 3000 LDFILE *ldptr = NULL; 3001 int sym_index, sym_count; 3002 int is_shared = 0; 3003 3004 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ) 3005 return; 3006 3007 #ifdef COLLECT_EXPORT_LIST 3008 /* We do not need scanning for some standard C libraries. */ 3009 if (which_pass == PASS_FIRST && ignore_library (prog_name)) 3010 return; 3011 3012 /* On AIX we have a loop, because there is not much difference 3013 between an object and an archive. This trick allows us to 3014 eliminate scan_libraries() function. */ 3015 do 3016 { 3017 #endif 3018 /* Some platforms (e.g. OSF4) declare ldopen as taking a 3019 non-const char * filename parameter, even though it will not 3020 modify that string. So we must cast away const-ness here, 3021 using CONST_CAST to prevent complaints from -Wcast-qual. */ 3022 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL) 3023 { 3024 if (! MY_ISCOFF (HEADER (ldptr).f_magic)) 3025 fatal_error ("%s: not a COFF file", prog_name); 3026 3027 if (GCC_CHECK_HDR (ldptr)) 3028 { 3029 sym_count = GCC_SYMBOLS (ldptr); 3030 sym_index = GCC_SYMZERO (ldptr); 3031 3032 #ifdef COLLECT_EXPORT_LIST 3033 /* Is current archive member a shared object? */ 3034 is_shared = HEADER (ldptr).f_flags & F_SHROBJ; 3035 #endif 3036 3037 while (sym_index < sym_count) 3038 { 3039 GCC_SYMENT symbol; 3040 3041 if (ldtbread (ldptr, sym_index, &symbol) <= 0) 3042 break; 3043 sym_index += GCC_SYMINC (symbol); 3044 3045 if (GCC_OK_SYMBOL (symbol)) 3046 { 3047 char *name; 3048 3049 if ((name = ldgetname (ldptr, &symbol)) == NULL) 3050 continue; /* Should never happen. */ 3051 3052 #ifdef XCOFF_DEBUGGING_INFO 3053 /* All AIX function names have a duplicate entry 3054 beginning with a dot. */ 3055 if (*name == '.') 3056 ++name; 3057 #endif 3058 3059 switch (is_ctor_dtor (name)) 3060 { 3061 case SYM_CTOR: 3062 if (! (filter & SCAN_CTOR)) 3063 break; 3064 if (! is_shared) 3065 add_to_list (&constructors, name); 3066 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 3067 if (which_pass == PASS_OBJ) 3068 add_to_list (&exports, name); 3069 #endif 3070 break; 3071 3072 case SYM_DTOR: 3073 if (! (filter & SCAN_DTOR)) 3074 break; 3075 if (! is_shared) 3076 add_to_list (&destructors, name); 3077 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 3078 if (which_pass == PASS_OBJ) 3079 add_to_list (&exports, name); 3080 #endif 3081 break; 3082 3083 #ifdef COLLECT_EXPORT_LIST 3084 case SYM_INIT: 3085 if (! (filter & SCAN_INIT)) 3086 break; 3087 #ifndef LD_INIT_SWITCH 3088 if (is_shared) 3089 add_to_list (&constructors, name); 3090 #endif 3091 break; 3092 3093 case SYM_FINI: 3094 if (! (filter & SCAN_FINI)) 3095 break; 3096 #ifndef LD_INIT_SWITCH 3097 if (is_shared) 3098 add_to_list (&destructors, name); 3099 #endif 3100 break; 3101 #endif 3102 3103 case SYM_DWEH: 3104 if (! (filter & SCAN_DWEH)) 3105 break; 3106 if (! is_shared) 3107 add_to_list (&frame_tables, name); 3108 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 3109 if (which_pass == PASS_OBJ) 3110 add_to_list (&exports, name); 3111 #endif 3112 break; 3113 3114 default: /* not a constructor or destructor */ 3115 #ifdef COLLECT_EXPORT_LIST 3116 /* Explicitly export all global symbols when 3117 building a shared object on AIX, but do not 3118 re-export symbols from another shared object 3119 and do not export symbols if the user 3120 provides an explicit export list. */ 3121 if (shared_obj && !is_shared 3122 && which_pass == PASS_OBJ && !export_flag) 3123 add_to_list (&exports, name); 3124 #endif 3125 continue; 3126 } 3127 3128 if (debug) 3129 #if !defined(EXTENDED_COFF) 3130 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n", 3131 symbol.n_scnum, symbol.n_sclass, 3132 (symbol.n_type ? "0" : ""), symbol.n_type, 3133 name); 3134 #else 3135 fprintf (stderr, 3136 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n", 3137 symbol.iss, (long) symbol.value, symbol.index, name); 3138 #endif 3139 } 3140 } 3141 } 3142 #ifdef COLLECT_EXPORT_LIST 3143 else 3144 { 3145 /* If archive contains both 32-bit and 64-bit objects, 3146 we want to skip objects in other mode so mismatch normal. */ 3147 if (debug) 3148 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n", 3149 prog_name, HEADER (ldptr).f_magic, aix64_flag); 3150 } 3151 #endif 3152 } 3153 else 3154 { 3155 fatal_error ("%s: cannot open as COFF file", prog_name); 3156 } 3157 #ifdef COLLECT_EXPORT_LIST 3158 /* On AIX loop continues while there are more members in archive. */ 3159 } 3160 while (ldclose (ldptr) == FAILURE); 3161 #else 3162 /* Otherwise we simply close ldptr. */ 3163 (void) ldclose(ldptr); 3164 #endif 3165 } 3166 #endif /* OBJECT_FORMAT_COFF */ 3167 3168 #ifdef COLLECT_EXPORT_LIST 3169 /* Given a library name without "lib" prefix, this function 3170 returns a full library name including a path. */ 3171 static char * 3172 resolve_lib_name (const char *name) 3173 { 3174 char *lib_buf; 3175 int i, j, l = 0; 3176 /* Library extensions for AIX dynamic linking. */ 3177 const char * const libexts[2] = {"a", "so"}; 3178 3179 for (i = 0; libpaths[i]; i++) 3180 if (libpaths[i]->max_len > l) 3181 l = libpaths[i]->max_len; 3182 3183 lib_buf = XNEWVEC (char, l + strlen(name) + 10); 3184 3185 for (i = 0; libpaths[i]; i++) 3186 { 3187 struct prefix_list *list = libpaths[i]->plist; 3188 for (; list; list = list->next) 3189 { 3190 /* The following lines are needed because path_prefix list 3191 may contain directories both with trailing DIR_SEPARATOR and 3192 without it. */ 3193 const char *p = ""; 3194 if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1])) 3195 p = "/"; 3196 for (j = 0; j < 2; j++) 3197 { 3198 sprintf (lib_buf, "%s%slib%s.%s", 3199 list->prefix, p, name, 3200 libexts[(j + aixrtl_flag) % 2]); 3201 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf); 3202 if (file_exists (lib_buf)) 3203 { 3204 if (debug) fprintf (stderr, "found: %s\n", lib_buf); 3205 return (lib_buf); 3206 } 3207 } 3208 } 3209 } 3210 if (debug) 3211 fprintf (stderr, "not found\n"); 3212 else 3213 fatal_error ("library lib%s not found", name); 3214 return (NULL); 3215 } 3216 #endif /* COLLECT_EXPORT_LIST */ 3217 3218 #ifdef COLLECT_RUN_DSYMUTIL 3219 static int flag_dsym = false; 3220 static int flag_idsym = false; 3221 3222 static void 3223 process_args (int *argcp, char **argv) { 3224 int i, j; 3225 int argc = *argcp; 3226 for (i=0; i<argc; ++i) 3227 { 3228 if (strcmp (argv[i], "-dsym") == 0) 3229 { 3230 flag_dsym = true; 3231 /* Remove the flag, as we handle all processing for it. */ 3232 j = i; 3233 do 3234 argv[j] = argv[j+1]; 3235 while (++j < argc); 3236 --i; 3237 argc = --(*argcp); 3238 } 3239 else if (strcmp (argv[i], "-idsym") == 0) 3240 { 3241 flag_idsym = true; 3242 /* Remove the flag, as we handle all processing for it. */ 3243 j = i; 3244 do 3245 argv[j] = argv[j+1]; 3246 while (++j < argc); 3247 --i; 3248 argc = --(*argcp); 3249 } 3250 } 3251 } 3252 3253 static void 3254 do_dsymutil (const char *output_file) { 3255 const char *dsymutil = DSYMUTIL + 1; 3256 struct pex_obj *pex; 3257 char **real_argv = XCNEWVEC (char *, 3); 3258 const char ** argv = CONST_CAST2 (const char **, char **, 3259 real_argv); 3260 3261 argv[0] = dsymutil; 3262 argv[1] = output_file; 3263 argv[2] = (char *) 0; 3264 3265 pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH); 3266 do_wait (dsymutil, pex); 3267 } 3268 3269 static void 3270 post_ld_pass (bool temp_file) { 3271 if (!(temp_file && flag_idsym) && !flag_dsym) 3272 return; 3273 3274 do_dsymutil (output_file); 3275 } 3276 #else 3277 static void 3278 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { } 3279 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { } 3280 #endif 3281