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