1 /* Collect static initialization info into data structures that can be 2 traversed by C++ initialization and finalization routines. 3 Copyright (C) 1992-2018 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 static int static_obj; /* true if -static */ 205 206 static const char *c_file; /* <xxx>.c for constructor/destructor list. */ 207 static const char *o_file; /* <xxx>.o for constructor/destructor list. */ 208 #ifdef COLLECT_EXPORT_LIST 209 static const char *export_file; /* <xxx>.x for AIX export list. */ 210 #endif 211 static char **lto_o_files; /* Output files for LTO. */ 212 const char *ldout; /* File for ld stdout. */ 213 const char *lderrout; /* File for ld stderr. */ 214 static const char *output_file; /* Output file for ld. */ 215 static const char *nm_file_name; /* pathname of nm */ 216 #ifdef LDD_SUFFIX 217 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */ 218 #endif 219 static const char *strip_file_name; /* pathname of strip */ 220 const char *c_file_name; /* pathname of gcc */ 221 static char *initname, *fininame; /* names of init and fini funcs */ 222 223 224 #ifdef TARGET_AIX_VERSION 225 static char *aix_shared_initname; 226 static char *aix_shared_fininame; /* init/fini names as per the scheme 227 described in config/rs6000/aix.h */ 228 #endif 229 230 static struct head constructors; /* list of constructors found */ 231 static struct head destructors; /* list of destructors found */ 232 #ifdef COLLECT_EXPORT_LIST 233 static struct head exports; /* list of exported symbols */ 234 #endif 235 static struct head frame_tables; /* list of frame unwind info tables */ 236 237 bool at_file_supplied; /* Whether to use @file arguments */ 238 239 struct obstack temporary_obstack; 240 char * temporary_firstobj; 241 242 /* A string that must be prepended to a target OS path in order to find 243 it on the host system. */ 244 #ifdef TARGET_SYSTEM_ROOT 245 static const char *target_system_root = TARGET_SYSTEM_ROOT; 246 #else 247 static const char *target_system_root = ""; 248 #endif 249 250 /* Whether we may unlink the output file, which should be set as soon as we 251 know we have successfully produced it. This is typically useful to prevent 252 blindly attempting to unlink a read-only output that the target linker 253 would leave untouched. */ 254 bool may_unlink_output_file = false; 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 head static_libs; /* list of statically linked libraries */ 260 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */ 261 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */ 262 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs, 263 &libpath_lib_dirs, NULL}; 264 #endif 265 266 /* List of names of object files containing LTO information. 267 These are a subset of the object file names appearing on the 268 command line, and must be identical, in the sense of pointer 269 equality, with the names passed to maybe_run_lto_and_relink(). */ 270 271 struct lto_object 272 { 273 const char *name; /* Name of object file. */ 274 struct lto_object *next; /* Next in linked list. */ 275 }; 276 277 struct lto_object_list 278 { 279 struct lto_object *first; /* First list element. */ 280 struct lto_object *last; /* Last list element. */ 281 }; 282 283 static struct lto_object_list lto_objects; 284 285 /* Special kinds of symbols that a name may denote. */ 286 287 enum symkind { 288 SYM_REGULAR = 0, /* nothing special */ 289 290 SYM_CTOR = 1, /* constructor */ 291 SYM_DTOR = 2, /* destructor */ 292 SYM_INIT = 3, /* shared object routine that calls all the ctors */ 293 SYM_FINI = 4, /* shared object routine that calls all the dtors */ 294 SYM_DWEH = 5, /* DWARF exception handling table */ 295 SYM_AIXI = 6, 296 SYM_AIXD = 7 297 }; 298 299 const char tool_name[] = "collect2"; 300 301 static symkind is_ctor_dtor (const char *); 302 303 static void handler (int); 304 static void maybe_unlink_list (char **); 305 static void add_to_list (struct head *, const char *); 306 static int extract_init_priority (const char *); 307 static void sort_ids (struct head *); 308 static void write_list (FILE *, const char *, struct id *); 309 #ifdef COLLECT_EXPORT_LIST 310 static void dump_list (FILE *, const char *, struct id *); 311 #endif 312 #if 0 313 static void dump_prefix_list (FILE *, const char *, struct prefix_list *); 314 #endif 315 static void write_list_with_asm (FILE *, const char *, struct id *); 316 static void write_c_file (FILE *, const char *); 317 static void write_c_file_stat (FILE *, const char *); 318 #ifndef LD_INIT_SWITCH 319 static void write_c_file_glob (FILE *, const char *); 320 #endif 321 #ifdef SCAN_LIBRARIES 322 static void scan_libraries (const char *); 323 #endif 324 #ifdef COLLECT_EXPORT_LIST 325 static int is_in_list (const char *, struct id *); 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 enum scanpass { 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 }; 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 #if defined (OBJECT_FORMAT_NONE) || defined (OBJECT_FORMAT_COFF) 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 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 arguments 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 #ifdef COLLECT_EXPORT_LIST 915 bool is_static = false; 916 #endif 917 int i; 918 919 for (i = 0; i < USE_LD_MAX; i++) 920 full_ld_suffixes[i] 921 #ifdef CROSS_DIRECTORY_STRUCTURE 922 = concat (target_machine, "-", ld_suffixes[i], NULL); 923 #else 924 = ld_suffixes[i]; 925 #endif 926 927 p = argv[0] + strlen (argv[0]); 928 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 929 --p; 930 progname = p; 931 932 xmalloc_set_program_name (progname); 933 934 old_argv = argv; 935 expandargv (&argc, &argv); 936 if (argv != old_argv) 937 at_file_supplied = 1; 938 939 process_args (&argc, argv); 940 941 num_c_args = argc + 9; 942 943 #ifndef HAVE_LD_DEMANGLE 944 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE"); 945 946 /* Suppress demangling by the real linker, which may be broken. */ 947 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1")); 948 #endif 949 950 #if defined (COLLECT2_HOST_INITIALIZATION) 951 /* Perform system dependent initialization, if necessary. */ 952 COLLECT2_HOST_INITIALIZATION; 953 #endif 954 955 #ifdef SIGCHLD 956 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 957 receive the signal. A different setting is inheritable */ 958 signal (SIGCHLD, SIG_DFL); 959 #endif 960 961 /* Unlock the stdio streams. */ 962 unlock_std_streams (); 963 964 gcc_init_libintl (); 965 966 diagnostic_initialize (global_dc, 0); 967 968 if (atexit (collect_atexit) != 0) 969 fatal_error (input_location, "atexit failed"); 970 971 /* Do not invoke xcalloc before this point, since locale needs to be 972 set first, in case a diagnostic is issued. */ 973 974 ld1_argv = XCNEWVEC (char *, argc + 4); 975 ld1 = CONST_CAST2 (const char **, char **, ld1_argv); 976 ld2_argv = XCNEWVEC (char *, argc + 11); 977 ld2 = CONST_CAST2 (const char **, char **, ld2_argv); 978 object_lst = XCNEWVEC (char *, argc); 979 object = CONST_CAST2 (const char **, char **, object_lst); 980 981 #ifdef DEBUG 982 debug = 1; 983 #endif 984 985 /* Parse command line early for instances of -debug. This allows 986 the debug flag to be set before functions like find_a_file() 987 are called. We also look for the -flto or -flto-partition=none flag to know 988 what LTO mode we are in. */ 989 { 990 bool no_partition = false; 991 992 for (i = 1; argv[i] != NULL; i ++) 993 { 994 if (! strcmp (argv[i], "-debug")) 995 debug = true; 996 else if (! strcmp (argv[i], "-flto-partition=none")) 997 no_partition = true; 998 else if (!strncmp (argv[i], "-fno-lto", 8)) 999 lto_mode = LTO_MODE_NONE; 1000 else if (! strcmp (argv[i], "-plugin")) 1001 { 1002 use_plugin = true; 1003 if (selected_linker == USE_DEFAULT_LD) 1004 selected_linker = USE_PLUGIN_LD; 1005 } 1006 else if (strcmp (argv[i], "-fuse-ld=bfd") == 0) 1007 selected_linker = USE_BFD_LD; 1008 else if (strcmp (argv[i], "-fuse-ld=gold") == 0) 1009 selected_linker = USE_GOLD_LD; 1010 1011 #ifdef COLLECT_EXPORT_LIST 1012 /* These flags are position independent, although their order 1013 is important - subsequent flags override earlier ones. */ 1014 else if (strcmp (argv[i], "-b64") == 0) 1015 aix64_flag = 1; 1016 /* -bexport:filename always needs the :filename */ 1017 else if (strncmp (argv[i], "-bE:", 4) == 0 1018 || strncmp (argv[i], "-bexport:", 9) == 0) 1019 export_flag = 1; 1020 else if (strcmp (argv[i], "-brtl") == 0 1021 || strcmp (argv[i], "-bsvr4") == 0 1022 || strcmp (argv[i], "-G") == 0) 1023 aixrtl_flag = 1; 1024 else if (strcmp (argv[i], "-bnortl") == 0) 1025 aixrtl_flag = 0; 1026 else if (strcmp (argv[i], "-blazy") == 0) 1027 aixlazy_flag = 1; 1028 #endif 1029 } 1030 verbose = debug; 1031 find_file_set_debug (debug); 1032 if (use_plugin) 1033 lto_mode = LTO_MODE_NONE; 1034 if (no_partition && lto_mode == LTO_MODE_WHOPR) 1035 lto_mode = LTO_MODE_LTO; 1036 } 1037 1038 #ifndef DEFAULT_A_OUT_NAME 1039 output_file = "a.out"; 1040 #else 1041 output_file = DEFAULT_A_OUT_NAME; 1042 #endif 1043 1044 obstack_begin (&temporary_obstack, 0); 1045 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); 1046 1047 #ifndef HAVE_LD_DEMANGLE 1048 current_demangling_style = auto_demangling; 1049 #endif 1050 p = getenv ("COLLECT_GCC_OPTIONS"); 1051 while (p && *p) 1052 { 1053 const char *q = extract_string (&p); 1054 if (*q == '-' && (q[1] == 'm' || q[1] == 'f')) 1055 num_c_args++; 1056 } 1057 obstack_free (&temporary_obstack, temporary_firstobj); 1058 1059 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities 1060 -fno-exceptions -w -fno-whole-program */ 1061 num_c_args += 6; 1062 1063 c_argv = XCNEWVEC (char *, num_c_args); 1064 c_ptr = CONST_CAST2 (const char **, char **, c_argv); 1065 1066 if (argc < 2) 1067 fatal_error (input_location, "no arguments"); 1068 1069 #ifdef SIGQUIT 1070 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN) 1071 signal (SIGQUIT, handler); 1072 #endif 1073 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 1074 signal (SIGINT, handler); 1075 #ifdef SIGALRM 1076 if (signal (SIGALRM, SIG_IGN) != SIG_IGN) 1077 signal (SIGALRM, handler); 1078 #endif 1079 #ifdef SIGHUP 1080 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 1081 signal (SIGHUP, handler); 1082 #endif 1083 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN) 1084 signal (SIGSEGV, handler); 1085 #ifdef SIGBUS 1086 if (signal (SIGBUS, SIG_IGN) != SIG_IGN) 1087 signal (SIGBUS, handler); 1088 #endif 1089 1090 /* Extract COMPILER_PATH and PATH into our prefix list. */ 1091 prefix_from_env ("COMPILER_PATH", &cpath); 1092 prefix_from_env ("PATH", &path); 1093 1094 /* Try to discover a valid linker/nm/strip to use. */ 1095 1096 /* Maybe we know the right file to use (if not cross). */ 1097 ld_file_name = 0; 1098 #ifdef DEFAULT_LINKER 1099 if (selected_linker == USE_BFD_LD || selected_linker == USE_GOLD_LD) 1100 { 1101 char *linker_name; 1102 # ifdef HOST_EXECUTABLE_SUFFIX 1103 int len = (sizeof (DEFAULT_LINKER) 1104 - sizeof (HOST_EXECUTABLE_SUFFIX)); 1105 linker_name = NULL; 1106 if (len > 0) 1107 { 1108 char *default_linker = xstrdup (DEFAULT_LINKER); 1109 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains 1110 HOST_EXECUTABLE_SUFFIX. */ 1111 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX)) 1112 { 1113 default_linker[len] = '\0'; 1114 linker_name = concat (default_linker, 1115 &ld_suffixes[selected_linker][2], 1116 HOST_EXECUTABLE_SUFFIX, NULL); 1117 } 1118 } 1119 if (linker_name == NULL) 1120 # endif 1121 linker_name = concat (DEFAULT_LINKER, 1122 &ld_suffixes[selected_linker][2], 1123 NULL); 1124 if (access (linker_name, X_OK) == 0) 1125 ld_file_name = linker_name; 1126 } 1127 if (ld_file_name == 0 && access (DEFAULT_LINKER, X_OK) == 0) 1128 ld_file_name = DEFAULT_LINKER; 1129 if (ld_file_name == 0) 1130 #endif 1131 #ifdef REAL_LD_FILE_NAME 1132 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME, X_OK); 1133 if (ld_file_name == 0) 1134 #endif 1135 /* Search the (target-specific) compiler dirs for ld'. */ 1136 ld_file_name = find_a_file (&cpath, real_ld_suffix, X_OK); 1137 /* Likewise for `collect-ld'. */ 1138 if (ld_file_name == 0) 1139 { 1140 ld_file_name = find_a_file (&cpath, collect_ld_suffix, X_OK); 1141 use_collect_ld = ld_file_name != 0; 1142 } 1143 /* Search the compiler directories for `ld'. We have protection against 1144 recursive calls in find_a_file. */ 1145 if (ld_file_name == 0) 1146 ld_file_name = find_a_file (&cpath, ld_suffixes[selected_linker], X_OK); 1147 /* Search the ordinary system bin directories 1148 for `ld' (if native linking) or `TARGET-ld' (if cross). */ 1149 if (ld_file_name == 0) 1150 ld_file_name = find_a_file (&path, full_ld_suffixes[selected_linker], X_OK); 1151 1152 #ifdef REAL_NM_FILE_NAME 1153 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME, X_OK); 1154 if (nm_file_name == 0) 1155 #endif 1156 nm_file_name = find_a_file (&cpath, gnm_suffix, X_OK); 1157 if (nm_file_name == 0) 1158 nm_file_name = find_a_file (&path, full_gnm_suffix, X_OK); 1159 if (nm_file_name == 0) 1160 nm_file_name = find_a_file (&cpath, nm_suffix, X_OK); 1161 if (nm_file_name == 0) 1162 nm_file_name = find_a_file (&path, full_nm_suffix, X_OK); 1163 1164 #ifdef LDD_SUFFIX 1165 ldd_file_name = find_a_file (&cpath, ldd_suffix, X_OK); 1166 if (ldd_file_name == 0) 1167 ldd_file_name = find_a_file (&path, full_ldd_suffix, X_OK); 1168 #endif 1169 1170 #ifdef REAL_STRIP_FILE_NAME 1171 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME, X_OK); 1172 if (strip_file_name == 0) 1173 #endif 1174 strip_file_name = find_a_file (&cpath, gstrip_suffix, X_OK); 1175 if (strip_file_name == 0) 1176 strip_file_name = find_a_file (&path, full_gstrip_suffix, X_OK); 1177 if (strip_file_name == 0) 1178 strip_file_name = find_a_file (&cpath, strip_suffix, X_OK); 1179 if (strip_file_name == 0) 1180 strip_file_name = find_a_file (&path, full_strip_suffix, X_OK); 1181 1182 /* Determine the full path name of the C compiler to use. */ 1183 c_file_name = getenv ("COLLECT_GCC"); 1184 if (c_file_name == 0) 1185 { 1186 #ifdef CROSS_DIRECTORY_STRUCTURE 1187 c_file_name = concat (target_machine, "-gcc", NULL); 1188 #else 1189 c_file_name = "gcc"; 1190 #endif 1191 } 1192 1193 p = find_a_file (&cpath, c_file_name, X_OK); 1194 1195 /* Here it should be safe to use the system search path since we should have 1196 already qualified the name of the compiler when it is needed. */ 1197 if (p == 0) 1198 p = find_a_file (&path, c_file_name, X_OK); 1199 1200 if (p) 1201 c_file_name = p; 1202 1203 *ld1++ = *ld2++ = ld_file_name; 1204 1205 /* Make temp file names. */ 1206 c_file = make_temp_file (".c"); 1207 o_file = make_temp_file (".o"); 1208 #ifdef COLLECT_EXPORT_LIST 1209 export_file = make_temp_file (".x"); 1210 #endif 1211 if (!debug) 1212 { 1213 ldout = make_temp_file (".ld"); 1214 lderrout = make_temp_file (".le"); 1215 } 1216 *c_ptr++ = c_file_name; 1217 *c_ptr++ = "-x"; 1218 *c_ptr++ = "c"; 1219 *c_ptr++ = "-c"; 1220 *c_ptr++ = "-o"; 1221 *c_ptr++ = o_file; 1222 1223 #ifdef COLLECT_EXPORT_LIST 1224 /* Generate a list of directories from LIBPATH. */ 1225 prefix_from_env ("LIBPATH", &libpath_lib_dirs); 1226 /* Add to this list also two standard directories where 1227 AIX loader always searches for libraries. */ 1228 add_prefix (&libpath_lib_dirs, "/lib"); 1229 add_prefix (&libpath_lib_dirs, "/usr/lib"); 1230 #endif 1231 1232 /* Get any options that the upper GCC wants to pass to the sub-GCC. 1233 1234 AIX support needs to know if -shared has been specified before 1235 parsing commandline arguments. */ 1236 1237 p = getenv ("COLLECT_GCC_OPTIONS"); 1238 while (p && *p) 1239 { 1240 const char *q = extract_string (&p); 1241 if (*q == '-' && (q[1] == 'm' || q[1] == 'f')) 1242 *c_ptr++ = xstrdup (q); 1243 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0) 1244 *c_ptr++ = xstrdup (q); 1245 if (strcmp (q, "-shared") == 0) 1246 shared_obj = 1; 1247 if (strcmp (q, "-static") == 0) 1248 static_obj = 1; 1249 if (*q == '-' && q[1] == 'B') 1250 { 1251 *c_ptr++ = xstrdup (q); 1252 if (q[2] == 0) 1253 { 1254 q = extract_string (&p); 1255 *c_ptr++ = xstrdup (q); 1256 } 1257 } 1258 } 1259 obstack_free (&temporary_obstack, temporary_firstobj); 1260 *c_ptr++ = "-fno-profile-arcs"; 1261 *c_ptr++ = "-fno-test-coverage"; 1262 *c_ptr++ = "-fno-branch-probabilities"; 1263 *c_ptr++ = "-fno-exceptions"; 1264 *c_ptr++ = "-w"; 1265 *c_ptr++ = "-fno-whole-program"; 1266 1267 /* !!! When GCC calls collect2, 1268 it does not know whether it is calling collect2 or ld. 1269 So collect2 cannot meaningfully understand any options 1270 except those ld understands. 1271 If you propose to make GCC pass some other option, 1272 just imagine what will happen if ld is really ld!!! */ 1273 1274 /* Parse arguments. Remember output file spec, pass the rest to ld. */ 1275 /* After the first file, put in the c++ rt0. */ 1276 1277 #ifdef COLLECT_EXPORT_LIST 1278 is_static = static_obj; 1279 #endif 1280 first_file = 1; 1281 while ((arg = *++argv) != (char *) 0) 1282 { 1283 *ld1++ = *ld2++ = arg; 1284 1285 if (arg[0] == '-') 1286 { 1287 switch (arg[1]) 1288 { 1289 case 'd': 1290 if (!strcmp (arg, "-debug")) 1291 { 1292 /* Already parsed. */ 1293 ld1--; 1294 ld2--; 1295 } 1296 if (!strcmp (arg, "-dynamic-linker") && argv[1]) 1297 { 1298 ++argv; 1299 *ld1++ = *ld2++ = *argv; 1300 } 1301 break; 1302 1303 case 'f': 1304 if (strncmp (arg, "-flto", 5) == 0) 1305 { 1306 #ifdef ENABLE_LTO 1307 /* Do not pass LTO flag to the linker. */ 1308 ld1--; 1309 ld2--; 1310 #else 1311 error ("LTO support has not been enabled in this " 1312 "configuration"); 1313 #endif 1314 } 1315 else if (!use_collect_ld 1316 && strncmp (arg, "-fuse-ld=", 9) == 0) 1317 { 1318 /* Do not pass -fuse-ld={bfd|gold} to the linker. */ 1319 ld1--; 1320 ld2--; 1321 } 1322 else if (strncmp (arg, "-fno-lto", 8) == 0) 1323 { 1324 /* Do not pass -fno-lto to the linker. */ 1325 ld1--; 1326 ld2--; 1327 } 1328 #ifdef TARGET_AIX_VERSION 1329 else 1330 { 1331 /* File containing a list of input files to process. */ 1332 1333 FILE *stream; 1334 char buf[MAXPATHLEN + 2]; 1335 /* Number of additionnal object files. */ 1336 int add_nbr = 0; 1337 /* Maximum of additionnal object files before vector 1338 expansion. */ 1339 int add_max = 0; 1340 const char *list_filename = arg + 2; 1341 1342 /* Accept -fFILENAME and -f FILENAME. */ 1343 if (*list_filename == '\0' && argv[1]) 1344 { 1345 ++argv; 1346 list_filename = *argv; 1347 *ld1++ = *ld2++ = *argv; 1348 } 1349 1350 stream = fopen (list_filename, "r"); 1351 if (stream == NULL) 1352 fatal_error (input_location, "can't open %s: %m", 1353 list_filename); 1354 1355 while (fgets (buf, sizeof buf, stream) != NULL) 1356 { 1357 /* Remove end of line. */ 1358 int len = strlen (buf); 1359 if (len >= 1 && buf[len - 1] =='\n') 1360 buf[len - 1] = '\0'; 1361 1362 /* Put on object vector. 1363 Note: we only expanse vector here, so we must keep 1364 extra space for remaining arguments. */ 1365 if (add_nbr >= add_max) 1366 { 1367 int pos = 1368 object - CONST_CAST2 (const char **, char **, 1369 object_lst); 1370 add_max = (add_max == 0) ? 16 : add_max * 2; 1371 object_lst = XRESIZEVEC (char *, object_lst, 1372 object_nbr + add_max); 1373 object = CONST_CAST2 (const char **, char **, 1374 object_lst) + pos; 1375 object_nbr += add_max; 1376 } 1377 *object++ = xstrdup (buf); 1378 add_nbr++; 1379 } 1380 fclose (stream); 1381 } 1382 #endif 1383 break; 1384 1385 #ifdef COLLECT_EXPORT_LIST 1386 case 'b': 1387 if (!strcmp (arg, "-bstatic")) 1388 { 1389 is_static = true; 1390 } 1391 else if (!strcmp (arg, "-bdynamic") || !strcmp (arg, "-bshared")) 1392 { 1393 is_static = false; 1394 } 1395 break; 1396 #endif 1397 case 'l': 1398 if (first_file) 1399 { 1400 /* place o_file BEFORE this argument! */ 1401 first_file = 0; 1402 ld2--; 1403 *ld2++ = o_file; 1404 *ld2++ = arg; 1405 } 1406 #ifdef COLLECT_EXPORT_LIST 1407 { 1408 /* Resolving full library name. */ 1409 const char *s = resolve_lib_name (arg+2); 1410 1411 /* Saving a full library name. */ 1412 add_to_list (&libs, s); 1413 if (is_static) 1414 add_to_list (&static_libs, s); 1415 } 1416 #endif 1417 break; 1418 1419 #ifdef COLLECT_EXPORT_LIST 1420 /* Saving directories where to search for libraries. */ 1421 case 'L': 1422 add_prefix (&cmdline_lib_dirs, arg+2); 1423 break; 1424 #endif 1425 1426 case 'o': 1427 if (arg[2] == '\0') 1428 output_file = *ld1++ = *ld2++ = *++argv; 1429 else 1430 output_file = &arg[2]; 1431 break; 1432 1433 case 'r': 1434 if (arg[2] == '\0') 1435 rflag = 1; 1436 break; 1437 1438 case 's': 1439 if (arg[2] == '\0' && do_collecting) 1440 { 1441 /* We must strip after the nm run, otherwise C++ linking 1442 will not work. Thus we strip in the second ld run, or 1443 else with strip if there is no second ld run. */ 1444 strip_flag = 1; 1445 ld1--; 1446 } 1447 break; 1448 1449 case 'v': 1450 if (arg[2] == '\0') 1451 verbose = true; 1452 break; 1453 1454 case '-': 1455 if (strcmp (arg, "--no-demangle") == 0) 1456 { 1457 #ifndef HAVE_LD_DEMANGLE 1458 no_demangle = 1; 1459 ld1--; 1460 ld2--; 1461 #endif 1462 } 1463 else if (strncmp (arg, "--demangle", 10) == 0) 1464 { 1465 #ifndef HAVE_LD_DEMANGLE 1466 no_demangle = 0; 1467 if (arg[10] == '=') 1468 { 1469 enum demangling_styles style 1470 = cplus_demangle_name_to_style (arg+11); 1471 if (style == unknown_demangling) 1472 error ("unknown demangling style '%s'", arg+11); 1473 else 1474 current_demangling_style = style; 1475 } 1476 ld1--; 1477 ld2--; 1478 #endif 1479 } 1480 else if (strncmp (arg, "--sysroot=", 10) == 0) 1481 target_system_root = arg + 10; 1482 else if (strcmp (arg, "--version") == 0) 1483 verbose = true; 1484 else if (strcmp (arg, "--help") == 0) 1485 helpflag = true; 1486 break; 1487 } 1488 } 1489 else if ((p = strrchr (arg, '.')) != (char *) 0 1490 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0 1491 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0 1492 || strcmp (p, ".obj") == 0)) 1493 { 1494 if (first_file) 1495 { 1496 first_file = 0; 1497 if (p[1] == 'o') 1498 *ld2++ = o_file; 1499 else 1500 { 1501 /* place o_file BEFORE this argument! */ 1502 ld2--; 1503 *ld2++ = o_file; 1504 *ld2++ = arg; 1505 } 1506 } 1507 if (p[1] == 'o' || p[1] == 'l') 1508 *object++ = arg; 1509 #ifdef COLLECT_EXPORT_LIST 1510 /* libraries can be specified directly, i.e. without -l flag. */ 1511 else 1512 { 1513 /* Saving a full library name. */ 1514 add_to_list (&libs, arg); 1515 if (is_static) 1516 add_to_list (&static_libs, arg); 1517 } 1518 #endif 1519 } 1520 } 1521 1522 #ifdef COLLECT_EXPORT_LIST 1523 /* This is added only for debugging purposes. */ 1524 if (debug) 1525 { 1526 fprintf (stderr, "List of libraries:\n"); 1527 dump_list (stderr, "\t", libs.first); 1528 fprintf (stderr, "List of statically linked libraries:\n"); 1529 dump_list (stderr, "\t", static_libs.first); 1530 } 1531 1532 /* The AIX linker will discard static constructors in object files if 1533 nothing else in the file is referenced, so look at them first. Unless 1534 we are building a shared object, ignore the eh frame tables, as we 1535 would otherwise reference them all, hence drag all the corresponding 1536 objects even if nothing else is referenced. */ 1537 { 1538 const char **export_object_lst 1539 = CONST_CAST2 (const char **, char **, object_lst); 1540 1541 struct id *list = libs.first; 1542 1543 /* Compute the filter to use from the current one, do scan, then adjust 1544 the "current" filter to remove what we just included here. This will 1545 control whether we need a first pass link later on or not, and what 1546 will remain to be scanned there. */ 1547 1548 scanfilter this_filter = ld1_filter; 1549 #if HAVE_AS_REF 1550 if (!shared_obj) 1551 this_filter &= ~SCAN_DWEH; 1552 #endif 1553 1554 /* Scan object files. */ 1555 while (export_object_lst < object) 1556 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter); 1557 1558 /* Scan libraries. */ 1559 for (; list; list = list->next) 1560 scan_prog_file (list->name, PASS_FIRST, this_filter); 1561 1562 ld1_filter = ld1_filter & ~this_filter; 1563 } 1564 1565 if (exports.first) 1566 { 1567 char *buf = concat ("-bE:", export_file, NULL); 1568 1569 *ld1++ = buf; 1570 *ld2++ = buf; 1571 1572 exportf = fopen (export_file, "w"); 1573 if (exportf == (FILE *) 0) 1574 fatal_error (input_location, "fopen %s: %m", export_file); 1575 write_aix_file (exportf, exports.first); 1576 if (fclose (exportf)) 1577 fatal_error (input_location, "fclose %s: %m", export_file); 1578 } 1579 #endif 1580 1581 *c_ptr++ = c_file; 1582 *c_ptr = *ld1 = *object = (char *) 0; 1583 1584 if (verbose) 1585 notice ("collect2 version %s\n", version_string); 1586 1587 if (helpflag) 1588 { 1589 printf ("Usage: collect2 [options]\n"); 1590 printf (" Wrap linker and generate constructor code if needed.\n"); 1591 printf (" Options:\n"); 1592 printf (" -debug Enable debug output\n"); 1593 printf (" --help Display this information\n"); 1594 printf (" -v, --version Display this program's version number\n"); 1595 printf ("\n"); 1596 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n"); 1597 printf ("Report bugs: %s\n", bug_report_url); 1598 printf ("\n"); 1599 } 1600 1601 if (debug) 1602 { 1603 const char *ptr; 1604 fprintf (stderr, "ld_file_name = %s\n", 1605 (ld_file_name ? ld_file_name : "not found")); 1606 fprintf (stderr, "c_file_name = %s\n", 1607 (c_file_name ? c_file_name : "not found")); 1608 fprintf (stderr, "nm_file_name = %s\n", 1609 (nm_file_name ? nm_file_name : "not found")); 1610 #ifdef LDD_SUFFIX 1611 fprintf (stderr, "ldd_file_name = %s\n", 1612 (ldd_file_name ? ldd_file_name : "not found")); 1613 #endif 1614 fprintf (stderr, "strip_file_name = %s\n", 1615 (strip_file_name ? strip_file_name : "not found")); 1616 fprintf (stderr, "c_file = %s\n", 1617 (c_file ? c_file : "not found")); 1618 fprintf (stderr, "o_file = %s\n", 1619 (o_file ? o_file : "not found")); 1620 1621 ptr = getenv ("COLLECT_GCC_OPTIONS"); 1622 if (ptr) 1623 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr); 1624 1625 ptr = getenv ("COLLECT_GCC"); 1626 if (ptr) 1627 fprintf (stderr, "COLLECT_GCC = %s\n", ptr); 1628 1629 ptr = getenv ("COMPILER_PATH"); 1630 if (ptr) 1631 fprintf (stderr, "COMPILER_PATH = %s\n", ptr); 1632 1633 ptr = getenv (LIBRARY_PATH_ENV); 1634 if (ptr) 1635 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr); 1636 1637 fprintf (stderr, "\n"); 1638 } 1639 1640 /* Load the program, searching all libraries and attempting to provide 1641 undefined symbols from repository information. 1642 1643 If -r or they will be run via some other method, do not build the 1644 constructor or destructor list, just return now. */ 1645 { 1646 bool early_exit 1647 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting); 1648 1649 /* Perform the first pass link now, if we're about to exit or if we need 1650 to scan for things we haven't collected yet before pursuing further. 1651 1652 On AIX, the latter typically includes nothing for shared objects or 1653 frame tables for an executable, out of what the required early scan on 1654 objects and libraries has performed above. In the !shared_obj case, we 1655 expect the relevant tables to be dragged together with their associated 1656 functions from precise cross reference insertions by the compiler. */ 1657 1658 if (early_exit || ld1_filter != SCAN_NOTHING) 1659 do_tlink (ld1_argv, object_lst); 1660 1661 if (early_exit) 1662 { 1663 #ifdef COLLECT_EXPORT_LIST 1664 /* Make sure we delete the export file we may have created. */ 1665 if (export_file != 0 && export_file[0]) 1666 maybe_unlink (export_file); 1667 #endif 1668 if (lto_mode != LTO_MODE_NONE) 1669 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false); 1670 else 1671 post_ld_pass (false); 1672 1673 maybe_unlink (c_file); 1674 maybe_unlink (o_file); 1675 return 0; 1676 } 1677 } 1678 1679 /* Unless we have done it all already, examine the namelist and search for 1680 static constructors and destructors to call. Write the constructor and 1681 destructor tables to a .s file and reload. */ 1682 1683 if (ld1_filter != SCAN_NOTHING) 1684 scan_prog_file (output_file, PASS_FIRST, ld1_filter); 1685 1686 #ifdef SCAN_LIBRARIES 1687 scan_libraries (output_file); 1688 #endif 1689 1690 if (debug) 1691 { 1692 notice_translated (ngettext ("%d constructor found\n", 1693 "%d constructors found\n", 1694 constructors.number), 1695 constructors.number); 1696 notice_translated (ngettext ("%d destructor found\n", 1697 "%d destructors found\n", 1698 destructors.number), 1699 destructors.number); 1700 notice_translated (ngettext ("%d frame table found\n", 1701 "%d frame tables found\n", 1702 frame_tables.number), 1703 frame_tables.number); 1704 } 1705 1706 /* If the scan exposed nothing of special interest, there's no need to 1707 generate the glue code and relink so return now. */ 1708 1709 if (constructors.number == 0 && destructors.number == 0 1710 && frame_tables.number == 0 1711 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST) 1712 /* If we will be running these functions ourselves, we want to emit 1713 stubs into the shared library so that we do not have to relink 1714 dependent programs when we add static objects. */ 1715 && ! shared_obj 1716 #endif 1717 ) 1718 { 1719 /* Do tlink without additional code generation now if we didn't 1720 do it earlier for scanning purposes. */ 1721 if (ld1_filter == SCAN_NOTHING) 1722 do_tlink (ld1_argv, object_lst); 1723 1724 if (lto_mode) 1725 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false); 1726 1727 /* Strip now if it was requested on the command line. */ 1728 if (strip_flag) 1729 { 1730 char **real_strip_argv = XCNEWVEC (char *, 3); 1731 const char ** strip_argv = CONST_CAST2 (const char **, char **, 1732 real_strip_argv); 1733 1734 strip_argv[0] = strip_file_name; 1735 strip_argv[1] = output_file; 1736 strip_argv[2] = (char *) 0; 1737 fork_execute ("strip", real_strip_argv, false); 1738 } 1739 1740 #ifdef COLLECT_EXPORT_LIST 1741 maybe_unlink (export_file); 1742 #endif 1743 post_ld_pass (false); 1744 1745 maybe_unlink (c_file); 1746 maybe_unlink (o_file); 1747 return 0; 1748 } 1749 1750 /* Sort ctor and dtor lists by priority. */ 1751 sort_ids (&constructors); 1752 sort_ids (&destructors); 1753 1754 maybe_unlink (output_file); 1755 outf = fopen (c_file, "w"); 1756 if (outf == (FILE *) 0) 1757 fatal_error (input_location, "fopen %s: %m", c_file); 1758 1759 write_c_file (outf, c_file); 1760 1761 if (fclose (outf)) 1762 fatal_error (input_location, "fclose %s: %m", c_file); 1763 1764 /* Tell the linker that we have initializer and finalizer functions. */ 1765 #ifdef LD_INIT_SWITCH 1766 #ifdef COLLECT_EXPORT_LIST 1767 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL); 1768 #else 1769 *ld2++ = LD_INIT_SWITCH; 1770 *ld2++ = initname; 1771 *ld2++ = LD_FINI_SWITCH; 1772 *ld2++ = fininame; 1773 #endif 1774 #endif 1775 1776 #ifdef COLLECT_EXPORT_LIST 1777 if (shared_obj) 1778 { 1779 /* If we did not add export flag to link arguments before, add it to 1780 second link phase now. No new exports should have been added. */ 1781 if (! exports.first) 1782 *ld2++ = concat ("-bE:", export_file, NULL); 1783 1784 #ifdef TARGET_AIX_VERSION 1785 add_to_list (&exports, aix_shared_initname); 1786 add_to_list (&exports, aix_shared_fininame); 1787 #endif 1788 1789 #ifndef LD_INIT_SWITCH 1790 add_to_list (&exports, initname); 1791 add_to_list (&exports, fininame); 1792 add_to_list (&exports, "_GLOBAL__DI"); 1793 add_to_list (&exports, "_GLOBAL__DD"); 1794 #endif 1795 exportf = fopen (export_file, "w"); 1796 if (exportf == (FILE *) 0) 1797 fatal_error (input_location, "fopen %s: %m", export_file); 1798 write_aix_file (exportf, exports.first); 1799 if (fclose (exportf)) 1800 fatal_error (input_location, "fclose %s: %m", export_file); 1801 } 1802 #endif 1803 1804 /* End of arguments to second link phase. */ 1805 *ld2 = (char*) 0; 1806 1807 if (debug) 1808 { 1809 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n", 1810 output_file, c_file); 1811 write_c_file (stderr, "stderr"); 1812 fprintf (stderr, "========== end of c_file\n\n"); 1813 #ifdef COLLECT_EXPORT_LIST 1814 fprintf (stderr, "\n========== export_file = %s\n", export_file); 1815 write_aix_file (stderr, exports.first); 1816 fprintf (stderr, "========== end of export_file\n\n"); 1817 #endif 1818 } 1819 1820 /* Assemble the constructor and destructor tables. 1821 Link the tables in with the rest of the program. */ 1822 1823 fork_execute ("gcc", c_argv, at_file_supplied); 1824 #ifdef COLLECT_EXPORT_LIST 1825 /* On AIX we must call tlink because of possible templates resolution. */ 1826 do_tlink (ld2_argv, object_lst); 1827 1828 if (lto_mode) 1829 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false); 1830 #else 1831 /* Otherwise, simply call ld because tlink is already done. */ 1832 if (lto_mode) 1833 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true); 1834 else 1835 { 1836 fork_execute ("ld", ld2_argv, HAVE_GNU_LD && at_file_supplied); 1837 post_ld_pass (false); 1838 } 1839 1840 /* Let scan_prog_file do any final mods (OSF/rose needs this for 1841 constructors/destructors in shared libraries. */ 1842 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL); 1843 #endif 1844 1845 maybe_unlink (c_file); 1846 maybe_unlink (o_file); 1847 1848 #ifdef COLLECT_EXPORT_LIST 1849 maybe_unlink (export_file); 1850 #endif 1851 1852 return 0; 1853 } 1854 1855 1856 /* Unlink FILE unless we are debugging or this is the output_file 1857 and we may not unlink it. */ 1858 1859 void 1860 maybe_unlink (const char *file) 1861 { 1862 if (debug) 1863 { 1864 notice ("[Leaving %s]\n", file); 1865 return; 1866 } 1867 1868 if (file == output_file && !may_unlink_output_file) 1869 return; 1870 1871 unlink_if_ordinary (file); 1872 } 1873 1874 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */ 1875 1876 static void 1877 maybe_unlink_list (char **file_list) 1878 { 1879 char **tmp = file_list; 1880 1881 while (*tmp) 1882 maybe_unlink (*(tmp++)); 1883 } 1884 1885 1886 static long sequence_number = 0; 1887 1888 /* Add a name to a linked list. */ 1889 1890 static void 1891 add_to_list (struct head *head_ptr, const char *name) 1892 { 1893 struct id *newid 1894 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1); 1895 struct id *p; 1896 strcpy (newid->name, name); 1897 1898 if (head_ptr->first) 1899 head_ptr->last->next = newid; 1900 else 1901 head_ptr->first = newid; 1902 1903 /* Check for duplicate symbols. */ 1904 for (p = head_ptr->first; 1905 strcmp (name, p->name) != 0; 1906 p = p->next) 1907 ; 1908 if (p != newid) 1909 { 1910 head_ptr->last->next = 0; 1911 free (newid); 1912 return; 1913 } 1914 1915 newid->sequence = ++sequence_number; 1916 head_ptr->last = newid; 1917 head_ptr->number++; 1918 } 1919 1920 /* Grab the init priority number from an init function name that 1921 looks like "_GLOBAL_.I.12345.foo". */ 1922 1923 static int 1924 extract_init_priority (const char *name) 1925 { 1926 int pos = 0, pri; 1927 1928 #ifdef TARGET_AIX_VERSION 1929 /* Run dependent module initializers before any constructors in this 1930 module. */ 1931 switch (is_ctor_dtor (name)) 1932 { 1933 case SYM_AIXI: 1934 case SYM_AIXD: 1935 return INT_MIN; 1936 default: 1937 break; 1938 } 1939 #endif 1940 1941 while (name[pos] == '_') 1942 ++pos; 1943 pos += 10; /* strlen ("GLOBAL__X_") */ 1944 1945 /* Extract init_p number from ctor/dtor name. */ 1946 pri = atoi (name + pos); 1947 return pri ? pri : DEFAULT_INIT_PRIORITY; 1948 } 1949 1950 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order. 1951 ctors will be run from right to left, dtors from left to right. */ 1952 1953 static void 1954 sort_ids (struct head *head_ptr) 1955 { 1956 /* id holds the current element to insert. id_next holds the next 1957 element to insert. id_ptr iterates through the already sorted elements 1958 looking for the place to insert id. */ 1959 struct id *id, *id_next, **id_ptr; 1960 1961 id = head_ptr->first; 1962 1963 /* We don't have any sorted elements yet. */ 1964 head_ptr->first = NULL; 1965 1966 for (; id; id = id_next) 1967 { 1968 id_next = id->next; 1969 id->sequence = extract_init_priority (id->name); 1970 1971 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next)) 1972 if (*id_ptr == NULL 1973 /* If the sequence numbers are the same, we put the id from the 1974 file later on the command line later in the list. */ 1975 || id->sequence > (*id_ptr)->sequence 1976 /* Hack: do lexical compare, too. 1977 || (id->sequence == (*id_ptr)->sequence 1978 && strcmp (id->name, (*id_ptr)->name) > 0) */ 1979 ) 1980 { 1981 id->next = *id_ptr; 1982 *id_ptr = id; 1983 break; 1984 } 1985 } 1986 1987 /* Now set the sequence numbers properly so write_c_file works. */ 1988 for (id = head_ptr->first; id; id = id->next) 1989 id->sequence = ++sequence_number; 1990 } 1991 1992 /* Write: `prefix', the names on list LIST, `suffix'. */ 1993 1994 static void 1995 write_list (FILE *stream, const char *prefix, struct id *list) 1996 { 1997 while (list) 1998 { 1999 fprintf (stream, "%sx%d,\n", prefix, list->sequence); 2000 list = list->next; 2001 } 2002 } 2003 2004 #ifdef COLLECT_EXPORT_LIST 2005 /* This function is really used only on AIX, but may be useful. */ 2006 static int 2007 is_in_list (const char *prefix, struct id *list) 2008 { 2009 while (list) 2010 { 2011 if (!strcmp (prefix, list->name)) return 1; 2012 list = list->next; 2013 } 2014 return 0; 2015 } 2016 #endif /* COLLECT_EXPORT_LIST */ 2017 2018 /* Added for debugging purpose. */ 2019 #ifdef COLLECT_EXPORT_LIST 2020 static void 2021 dump_list (FILE *stream, const char *prefix, struct id *list) 2022 { 2023 while (list) 2024 { 2025 fprintf (stream, "%s%s,\n", prefix, list->name); 2026 list = list->next; 2027 } 2028 } 2029 #endif 2030 2031 #if 0 2032 static void 2033 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list) 2034 { 2035 while (list) 2036 { 2037 fprintf (stream, "%s%s,\n", prefix, list->prefix); 2038 list = list->next; 2039 } 2040 } 2041 #endif 2042 2043 static void 2044 write_list_with_asm (FILE *stream, const char *prefix, struct id *list) 2045 { 2046 while (list) 2047 { 2048 fprintf (stream, "%sx%d __asm__ (\"%s\");\n", 2049 prefix, list->sequence, list->name); 2050 list = list->next; 2051 } 2052 } 2053 2054 /* Write out the constructor and destructor tables statically (for a shared 2055 object), along with the functions to execute them. */ 2056 2057 static void 2058 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED) 2059 { 2060 const char *p, *q; 2061 char *prefix, *r; 2062 int frames = (frame_tables.number > 0); 2063 2064 /* Figure out name of output_file, stripping off .so version. */ 2065 q = p = lbasename (output_file); 2066 2067 while (q) 2068 { 2069 q = strchr (q,'.'); 2070 if (q == 0) 2071 { 2072 q = p + strlen (p); 2073 break; 2074 } 2075 else 2076 { 2077 if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0) 2078 { 2079 q += strlen (SHLIB_SUFFIX); 2080 break; 2081 } 2082 else 2083 q++; 2084 } 2085 } 2086 /* q points to null at end of the string (or . of the .so version) */ 2087 prefix = XNEWVEC (char, q - p + 1); 2088 strncpy (prefix, p, q - p); 2089 prefix[q - p] = 0; 2090 for (r = prefix; *r; r++) 2091 if (!ISALNUM ((unsigned char)*r)) 2092 *r = '_'; 2093 if (debug) 2094 notice ("\nwrite_c_file - output name is %s, prefix is %s\n", 2095 output_file, prefix); 2096 2097 initname = concat ("_GLOBAL__FI_", prefix, NULL); 2098 fininame = concat ("_GLOBAL__FD_", prefix, NULL); 2099 #ifdef TARGET_AIX_VERSION 2100 aix_shared_initname = concat ("_GLOBAL__AIXI_", prefix, NULL); 2101 aix_shared_fininame = concat ("_GLOBAL__AIXD_", prefix, NULL); 2102 #endif 2103 2104 free (prefix); 2105 2106 /* Write the tables as C code. */ 2107 2108 /* This count variable is used to prevent multiple calls to the 2109 constructors/destructors. 2110 This guard against multiple calls is important on AIX as the initfini 2111 functions are deliberately invoked multiple times as part of the 2112 mechanisms GCC uses to order constructors across different dependent 2113 shared libraries (see config/rs6000/aix.h). 2114 */ 2115 fprintf (stream, "static int count;\n"); 2116 fprintf (stream, "typedef void entry_pt();\n"); 2117 write_list_with_asm (stream, "extern entry_pt ", constructors.first); 2118 2119 if (frames) 2120 { 2121 write_list_with_asm (stream, "extern void *", frame_tables.first); 2122 2123 fprintf (stream, "\tstatic void *frame_table[] = {\n"); 2124 write_list (stream, "\t\t&", frame_tables.first); 2125 fprintf (stream, "\t0\n};\n"); 2126 2127 /* This must match what's in frame.h. */ 2128 fprintf (stream, "struct object {\n"); 2129 fprintf (stream, " void *pc_begin;\n"); 2130 fprintf (stream, " void *pc_end;\n"); 2131 fprintf (stream, " void *fde_begin;\n"); 2132 fprintf (stream, " void *fde_array;\n"); 2133 fprintf (stream, " __SIZE_TYPE__ count;\n"); 2134 fprintf (stream, " struct object *next;\n"); 2135 fprintf (stream, "};\n"); 2136 2137 fprintf (stream, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n"); 2138 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n"); 2139 fprintf (stream, "extern void *__deregister_frame_info (void *);\n"); 2140 #ifdef TARGET_AIX_VERSION 2141 fprintf (stream, "extern void *__gcc_unwind_dbase;\n"); 2142 #endif 2143 2144 fprintf (stream, "static void reg_frame () {\n"); 2145 fprintf (stream, "\tstatic struct object ob;\n"); 2146 #ifdef TARGET_AIX_VERSION 2147 /* Use __gcc_unwind_dbase as the base address for data on AIX. 2148 This might not be the start of the segment, signed offsets assumed. 2149 */ 2150 fprintf (stream, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n"); 2151 #else 2152 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n"); 2153 #endif 2154 fprintf (stream, "\t}\n"); 2155 2156 fprintf (stream, "static void dereg_frame () {\n"); 2157 fprintf (stream, "\t__deregister_frame_info (frame_table);\n"); 2158 fprintf (stream, "\t}\n"); 2159 } 2160 2161 fprintf (stream, "void %s() {\n", initname); 2162 if (constructors.number > 0 || frames) 2163 { 2164 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n"); 2165 write_list (stream, "\t\t", constructors.first); 2166 if (frames) 2167 fprintf (stream, "\treg_frame,\n"); 2168 fprintf (stream, "\t};\n"); 2169 fprintf (stream, "\tentry_pt **p;\n"); 2170 fprintf (stream, "\tif (count++ != 0) return;\n"); 2171 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames); 2172 fprintf (stream, "\twhile (p > ctors) (*--p)();\n"); 2173 } 2174 else 2175 fprintf (stream, "\t++count;\n"); 2176 fprintf (stream, "}\n"); 2177 write_list_with_asm (stream, "extern entry_pt ", destructors.first); 2178 fprintf (stream, "void %s() {\n", fininame); 2179 if (destructors.number > 0 || frames) 2180 { 2181 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n"); 2182 write_list (stream, "\t\t", destructors.first); 2183 if (frames) 2184 fprintf (stream, "\tdereg_frame,\n"); 2185 fprintf (stream, "\t};\n"); 2186 fprintf (stream, "\tentry_pt **p;\n"); 2187 fprintf (stream, "\tif (--count != 0) return;\n"); 2188 fprintf (stream, "\tp = dtors;\n"); 2189 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n", 2190 destructors.number + frames); 2191 } 2192 fprintf (stream, "}\n"); 2193 2194 if (shared_obj) 2195 { 2196 COLLECT_SHARED_INIT_FUNC (stream, initname); 2197 COLLECT_SHARED_FINI_FUNC (stream, fininame); 2198 } 2199 } 2200 2201 /* Write the constructor/destructor tables. */ 2202 2203 #ifndef LD_INIT_SWITCH 2204 static void 2205 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED) 2206 { 2207 /* Write the tables as C code. */ 2208 2209 int frames = (frame_tables.number > 0); 2210 2211 fprintf (stream, "typedef void entry_pt();\n\n"); 2212 2213 write_list_with_asm (stream, "extern entry_pt ", constructors.first); 2214 2215 if (frames) 2216 { 2217 write_list_with_asm (stream, "extern void *", frame_tables.first); 2218 2219 fprintf (stream, "\tstatic void *frame_table[] = {\n"); 2220 write_list (stream, "\t\t&", frame_tables.first); 2221 fprintf (stream, "\t0\n};\n"); 2222 2223 /* This must match what's in frame.h. */ 2224 fprintf (stream, "struct object {\n"); 2225 fprintf (stream, " void *pc_begin;\n"); 2226 fprintf (stream, " void *pc_end;\n"); 2227 fprintf (stream, " void *fde_begin;\n"); 2228 fprintf (stream, " void *fde_array;\n"); 2229 fprintf (stream, " __SIZE_TYPE__ count;\n"); 2230 fprintf (stream, " struct object *next;\n"); 2231 fprintf (stream, "};\n"); 2232 2233 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n"); 2234 fprintf (stream, "extern void *__deregister_frame_info (void *);\n"); 2235 2236 fprintf (stream, "static void reg_frame () {\n"); 2237 fprintf (stream, "\tstatic struct object ob;\n"); 2238 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n"); 2239 fprintf (stream, "\t}\n"); 2240 2241 fprintf (stream, "static void dereg_frame () {\n"); 2242 fprintf (stream, "\t__deregister_frame_info (frame_table);\n"); 2243 fprintf (stream, "\t}\n"); 2244 } 2245 2246 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n"); 2247 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames); 2248 write_list (stream, "\t", constructors.first); 2249 if (frames) 2250 fprintf (stream, "\treg_frame,\n"); 2251 fprintf (stream, "\t0\n};\n\n"); 2252 2253 write_list_with_asm (stream, "extern entry_pt ", destructors.first); 2254 2255 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n"); 2256 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames); 2257 write_list (stream, "\t", destructors.first); 2258 if (frames) 2259 fprintf (stream, "\tdereg_frame,\n"); 2260 fprintf (stream, "\t0\n};\n\n"); 2261 2262 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN); 2263 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN); 2264 } 2265 #endif /* ! LD_INIT_SWITCH */ 2266 2267 static void 2268 write_c_file (FILE *stream, const char *name) 2269 { 2270 #ifndef LD_INIT_SWITCH 2271 if (! shared_obj) 2272 write_c_file_glob (stream, name); 2273 else 2274 #endif 2275 write_c_file_stat (stream, name); 2276 } 2277 2278 #ifdef COLLECT_EXPORT_LIST 2279 static void 2280 write_aix_file (FILE *stream, struct id *list) 2281 { 2282 for (; list; list = list->next) 2283 { 2284 fputs (list->name, stream); 2285 putc ('\n', stream); 2286 } 2287 } 2288 #endif 2289 2290 #ifdef OBJECT_FORMAT_NONE 2291 2292 /* Check to make sure the file is an LTO object file. */ 2293 2294 static bool 2295 maybe_lto_object_file (const char *prog_name) 2296 { 2297 FILE *f; 2298 unsigned char buf[4]; 2299 int i; 2300 2301 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' }; 2302 static unsigned char coffmagic[2] = { 0x4c, 0x01 }; 2303 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 }; 2304 static unsigned char machomagic[4][4] = { 2305 { 0xcf, 0xfa, 0xed, 0xfe }, 2306 { 0xce, 0xfa, 0xed, 0xfe }, 2307 { 0xfe, 0xed, 0xfa, 0xcf }, 2308 { 0xfe, 0xed, 0xfa, 0xce } 2309 }; 2310 2311 f = fopen (prog_name, "rb"); 2312 if (f == NULL) 2313 return false; 2314 if (fread (buf, sizeof (buf), 1, f) != 1) 2315 buf[0] = 0; 2316 fclose (f); 2317 2318 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0 2319 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0 2320 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0) 2321 return true; 2322 for (i = 0; i < 4; i++) 2323 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0) 2324 return true; 2325 2326 return false; 2327 } 2328 2329 /* Generic version to scan the name list of the loaded program for 2330 the symbols g++ uses for static constructors and destructors. */ 2331 2332 static void 2333 scan_prog_file (const char *prog_name, scanpass which_pass, 2334 scanfilter filter) 2335 { 2336 void (*int_handler) (int); 2337 #ifdef SIGQUIT 2338 void (*quit_handler) (int); 2339 #endif 2340 char *real_nm_argv[4]; 2341 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv); 2342 int argc = 0; 2343 struct pex_obj *pex; 2344 const char *errmsg; 2345 int err; 2346 char *p, buf[1024]; 2347 FILE *inf; 2348 int found_lto = 0; 2349 2350 if (which_pass == PASS_SECOND) 2351 return; 2352 2353 /* LTO objects must be in a known format. This check prevents 2354 us from accepting an archive containing LTO objects, which 2355 gcc cannot currently handle. */ 2356 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name)) 2357 return; 2358 2359 /* If we do not have an `nm', complain. */ 2360 if (nm_file_name == 0) 2361 fatal_error (input_location, "cannot find 'nm'"); 2362 2363 nm_argv[argc++] = nm_file_name; 2364 if (NM_FLAGS[0] != '\0') 2365 nm_argv[argc++] = NM_FLAGS; 2366 2367 nm_argv[argc++] = prog_name; 2368 nm_argv[argc++] = (char *) 0; 2369 2370 /* Trace if needed. */ 2371 if (verbose) 2372 { 2373 const char **p_argv; 2374 const char *str; 2375 2376 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++) 2377 fprintf (stderr, " %s", str); 2378 2379 fprintf (stderr, "\n"); 2380 } 2381 2382 fflush (stdout); 2383 fflush (stderr); 2384 2385 pex = pex_init (PEX_USE_PIPES, "collect2", NULL); 2386 if (pex == NULL) 2387 fatal_error (input_location, "pex_init failed: %m"); 2388 2389 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET, 2390 &err); 2391 if (errmsg != NULL) 2392 { 2393 if (err != 0) 2394 { 2395 errno = err; 2396 fatal_error (input_location, "%s: %m", _(errmsg)); 2397 } 2398 else 2399 fatal_error (input_location, errmsg); 2400 } 2401 2402 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN); 2403 #ifdef SIGQUIT 2404 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN); 2405 #endif 2406 2407 inf = pex_read_output (pex, 0); 2408 if (inf == NULL) 2409 fatal_error (input_location, "can't open nm output: %m"); 2410 2411 if (debug) 2412 { 2413 if (which_pass == PASS_LTOINFO) 2414 fprintf (stderr, "\nnm output with LTO info marker symbol.\n"); 2415 else 2416 fprintf (stderr, "\nnm output with constructors/destructors.\n"); 2417 } 2418 2419 /* Read each line of nm output. */ 2420 while (fgets (buf, sizeof buf, inf) != (char *) 0) 2421 { 2422 int ch, ch2; 2423 char *name, *end; 2424 2425 if (debug) 2426 fprintf (stderr, "\t%s\n", buf); 2427 2428 if (which_pass == PASS_LTOINFO) 2429 { 2430 if (found_lto) 2431 continue; 2432 2433 /* Look for the LTO info marker symbol, and add filename to 2434 the LTO objects list if found. */ 2435 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++) 2436 if (ch == ' ' && p[1] == '_' && p[2] == '_' 2437 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0) 2438 && ISSPACE (p[p[3] == '_' ? 14 : 13])) 2439 { 2440 add_lto_object (<o_objects, prog_name); 2441 2442 /* We need to read all the input, so we can't just 2443 return here. But we can avoid useless work. */ 2444 found_lto = 1; 2445 2446 break; 2447 } 2448 2449 continue; 2450 } 2451 2452 /* If it contains a constructor or destructor name, add the name 2453 to the appropriate list unless this is a kind of symbol we're 2454 not supposed to even consider. */ 2455 2456 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++) 2457 if (ch == ' ' && p[1] == 'U' && p[2] == ' ') 2458 break; 2459 2460 if (ch != '_') 2461 continue; 2462 2463 name = p; 2464 /* Find the end of the symbol name. 2465 Do not include `|', because Encore nm can tack that on the end. */ 2466 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|'; 2467 end++) 2468 continue; 2469 2470 2471 *end = '\0'; 2472 2473 switch (is_ctor_dtor (name)) 2474 { 2475 case SYM_CTOR: 2476 if (! (filter & SCAN_CTOR)) 2477 break; 2478 if (which_pass != PASS_LIB) 2479 add_to_list (&constructors, name); 2480 break; 2481 2482 case SYM_DTOR: 2483 if (! (filter & SCAN_DTOR)) 2484 break; 2485 if (which_pass != PASS_LIB) 2486 add_to_list (&destructors, name); 2487 break; 2488 2489 case SYM_INIT: 2490 if (! (filter & SCAN_INIT)) 2491 break; 2492 if (which_pass != PASS_LIB) 2493 fatal_error (input_location, "init function found in object %s", 2494 prog_name); 2495 #ifndef LD_INIT_SWITCH 2496 add_to_list (&constructors, name); 2497 #endif 2498 break; 2499 2500 case SYM_FINI: 2501 if (! (filter & SCAN_FINI)) 2502 break; 2503 if (which_pass != PASS_LIB) 2504 fatal_error (input_location, "fini function found in object %s", 2505 prog_name); 2506 #ifndef LD_FINI_SWITCH 2507 add_to_list (&destructors, name); 2508 #endif 2509 break; 2510 2511 case SYM_DWEH: 2512 if (! (filter & SCAN_DWEH)) 2513 break; 2514 if (which_pass != PASS_LIB) 2515 add_to_list (&frame_tables, name); 2516 break; 2517 2518 default: /* not a constructor or destructor */ 2519 continue; 2520 } 2521 } 2522 2523 if (debug) 2524 fprintf (stderr, "\n"); 2525 2526 do_wait (nm_file_name, pex); 2527 2528 signal (SIGINT, int_handler); 2529 #ifdef SIGQUIT 2530 signal (SIGQUIT, quit_handler); 2531 #endif 2532 } 2533 2534 #ifdef LDD_SUFFIX 2535 2536 /* Use the List Dynamic Dependencies program to find shared libraries that 2537 the output file depends upon and their initialization/finalization 2538 routines, if any. */ 2539 2540 static void 2541 scan_libraries (const char *prog_name) 2542 { 2543 static struct head libraries; /* list of shared libraries found */ 2544 struct id *list; 2545 void (*int_handler) (int); 2546 #ifdef SIGQUIT 2547 void (*quit_handler) (int); 2548 #endif 2549 char *real_ldd_argv[4]; 2550 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv); 2551 int argc = 0; 2552 struct pex_obj *pex; 2553 const char *errmsg; 2554 int err; 2555 char buf[1024]; 2556 FILE *inf; 2557 2558 /* If we do not have an `ldd', complain. */ 2559 if (ldd_file_name == 0) 2560 { 2561 error ("cannot find 'ldd'"); 2562 return; 2563 } 2564 2565 ldd_argv[argc++] = ldd_file_name; 2566 ldd_argv[argc++] = prog_name; 2567 ldd_argv[argc++] = (char *) 0; 2568 2569 /* Trace if needed. */ 2570 if (verbose) 2571 { 2572 const char **p_argv; 2573 const char *str; 2574 2575 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++) 2576 fprintf (stderr, " %s", str); 2577 2578 fprintf (stderr, "\n"); 2579 } 2580 2581 fflush (stdout); 2582 fflush (stderr); 2583 2584 pex = pex_init (PEX_USE_PIPES, "collect2", NULL); 2585 if (pex == NULL) 2586 fatal_error (input_location, "pex_init failed: %m"); 2587 2588 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err); 2589 if (errmsg != NULL) 2590 { 2591 if (err != 0) 2592 { 2593 errno = err; 2594 fatal_error (input_location, "%s: %m", _(errmsg)); 2595 } 2596 else 2597 fatal_error (input_location, errmsg); 2598 } 2599 2600 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN); 2601 #ifdef SIGQUIT 2602 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN); 2603 #endif 2604 2605 inf = pex_read_output (pex, 0); 2606 if (inf == NULL) 2607 fatal_error (input_location, "can't open ldd output: %m"); 2608 2609 if (debug) 2610 notice ("\nldd output with constructors/destructors.\n"); 2611 2612 /* Read each line of ldd output. */ 2613 while (fgets (buf, sizeof buf, inf) != (char *) 0) 2614 { 2615 int ch2; 2616 char *name, *end, *p = buf; 2617 2618 /* Extract names of libraries and add to list. */ 2619 PARSE_LDD_OUTPUT (p); 2620 if (p == 0) 2621 continue; 2622 2623 name = p; 2624 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0) 2625 fatal_error (input_location, "dynamic dependency %s not found", buf); 2626 2627 /* Find the end of the symbol name. */ 2628 for (end = p; 2629 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|'; 2630 end++) 2631 continue; 2632 *end = '\0'; 2633 2634 if (access (name, R_OK) == 0) 2635 add_to_list (&libraries, name); 2636 else 2637 fatal_error (input_location, "unable to open dynamic dependency '%s'", 2638 buf); 2639 2640 if (debug) 2641 fprintf (stderr, "\t%s\n", buf); 2642 } 2643 if (debug) 2644 fprintf (stderr, "\n"); 2645 2646 do_wait (ldd_file_name, pex); 2647 2648 signal (SIGINT, int_handler); 2649 #ifdef SIGQUIT 2650 signal (SIGQUIT, quit_handler); 2651 #endif 2652 2653 /* Now iterate through the library list adding their symbols to 2654 the list. */ 2655 for (list = libraries.first; list; list = list->next) 2656 scan_prog_file (list->name, PASS_LIB, SCAN_ALL); 2657 } 2658 2659 #endif /* LDD_SUFFIX */ 2660 2661 #endif /* OBJECT_FORMAT_NONE */ 2662 2663 2664 /* 2665 * COFF specific stuff. 2666 */ 2667 2668 #ifdef OBJECT_FORMAT_COFF 2669 2670 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms) 2671 # define GCC_SYMENT SYMENT 2672 # if defined (C_WEAKEXT) 2673 # define GCC_OK_SYMBOL(X) \ 2674 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \ 2675 ((X).n_scnum > N_UNDEF) && \ 2676 (aix64_flag \ 2677 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \ 2678 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))) 2679 # define GCC_UNDEF_SYMBOL(X) \ 2680 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \ 2681 ((X).n_scnum == N_UNDEF)) 2682 # else 2683 # define GCC_OK_SYMBOL(X) \ 2684 (((X).n_sclass == C_EXT) && \ 2685 ((X).n_scnum > N_UNDEF) && \ 2686 (aix64_flag \ 2687 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \ 2688 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))) 2689 # define GCC_UNDEF_SYMBOL(X) \ 2690 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF)) 2691 # endif 2692 # define GCC_SYMINC(X) ((X).n_numaux+1) 2693 # define GCC_SYMZERO(X) 0 2694 2695 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */ 2696 #if TARGET_AIX_VERSION >= 51 2697 # define GCC_CHECK_HDR(X) \ 2698 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \ 2699 || (HEADER (X).f_magic == 0767 && aix64_flag)) \ 2700 && !(HEADER (X).f_flags & F_LOADONLY)) 2701 #else 2702 # define GCC_CHECK_HDR(X) \ 2703 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \ 2704 || (HEADER (X).f_magic == 0757 && aix64_flag)) \ 2705 && !(HEADER (X).f_flags & F_LOADONLY)) 2706 #endif 2707 2708 #ifdef COLLECT_EXPORT_LIST 2709 /* Array of standard AIX libraries which should not 2710 be scanned for ctors/dtors. */ 2711 static const char *const aix_std_libs[] = { 2712 "/unix", 2713 "/lib/libc.a", 2714 "/lib/libm.a", 2715 "/lib/libc_r.a", 2716 "/lib/libm_r.a", 2717 "/usr/lib/libc.a", 2718 "/usr/lib/libm.a", 2719 "/usr/lib/libc_r.a", 2720 "/usr/lib/libm_r.a", 2721 "/usr/lib/threads/libc.a", 2722 "/usr/ccs/lib/libc.a", 2723 "/usr/ccs/lib/libm.a", 2724 "/usr/ccs/lib/libc_r.a", 2725 "/usr/ccs/lib/libm_r.a", 2726 NULL 2727 }; 2728 2729 /* This function checks the filename and returns 1 2730 if this name matches the location of a standard AIX library. */ 2731 static int ignore_library (const char *); 2732 static int 2733 ignore_library (const char *name) 2734 { 2735 const char *const *p; 2736 size_t length; 2737 2738 if (target_system_root[0] != '\0') 2739 { 2740 length = strlen (target_system_root); 2741 if (strncmp (name, target_system_root, length) != 0) 2742 return 0; 2743 name += length; 2744 } 2745 for (p = &aix_std_libs[0]; *p != NULL; ++p) 2746 if (strcmp (name, *p) == 0) 2747 return 1; 2748 return 0; 2749 } 2750 #endif /* COLLECT_EXPORT_LIST */ 2751 2752 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME 2753 extern char *ldgetname (LDFILE *, GCC_SYMENT *); 2754 #endif 2755 2756 /* COFF version to scan the name list of the loaded program for 2757 the symbols g++ uses for static constructors and destructors. */ 2758 2759 static void 2760 scan_prog_file (const char *prog_name, scanpass which_pass, 2761 scanfilter filter) 2762 { 2763 LDFILE *ldptr = NULL; 2764 int sym_index, sym_count; 2765 int is_shared = 0; 2766 int found_lto = 0; 2767 2768 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ 2769 && which_pass != PASS_LTOINFO) 2770 return; 2771 2772 #ifdef COLLECT_EXPORT_LIST 2773 /* We do not need scanning for some standard C libraries. */ 2774 if (which_pass == PASS_FIRST && ignore_library (prog_name)) 2775 return; 2776 2777 /* On AIX we have a loop, because there is not much difference 2778 between an object and an archive. This trick allows us to 2779 eliminate scan_libraries() function. */ 2780 do 2781 { 2782 found_lto = 0; 2783 #endif 2784 /* Some platforms (e.g. OSF4) declare ldopen as taking a 2785 non-const char * filename parameter, even though it will not 2786 modify that string. So we must cast away const-ness here, 2787 using CONST_CAST to prevent complaints from -Wcast-qual. */ 2788 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL) 2789 { 2790 if (! MY_ISCOFF (HEADER (ldptr).f_magic)) 2791 fatal_error (input_location, "%s: not a COFF file", prog_name); 2792 2793 if (GCC_CHECK_HDR (ldptr)) 2794 { 2795 sym_count = GCC_SYMBOLS (ldptr); 2796 sym_index = GCC_SYMZERO (ldptr); 2797 2798 #ifdef COLLECT_EXPORT_LIST 2799 /* Is current archive member a shared object? */ 2800 is_shared = HEADER (ldptr).f_flags & F_SHROBJ; 2801 #endif 2802 2803 while (sym_index < sym_count) 2804 { 2805 GCC_SYMENT symbol; 2806 2807 if (ldtbread (ldptr, sym_index, &symbol) <= 0) 2808 break; 2809 sym_index += GCC_SYMINC (symbol); 2810 2811 if (GCC_OK_SYMBOL (symbol)) 2812 { 2813 char *name; 2814 2815 if ((name = ldgetname (ldptr, &symbol)) == NULL) 2816 continue; /* Should never happen. */ 2817 2818 #ifdef XCOFF_DEBUGGING_INFO 2819 /* All AIX function names have a duplicate entry 2820 beginning with a dot. */ 2821 if (*name == '.') 2822 ++name; 2823 #endif 2824 2825 if (which_pass == PASS_LTOINFO) 2826 { 2827 if (found_lto) 2828 continue; 2829 if (strncmp (name, "__gnu_lto_v1", 12) == 0) 2830 { 2831 add_lto_object (<o_objects, prog_name); 2832 found_lto = 1; 2833 break; 2834 } 2835 continue; 2836 } 2837 2838 switch (is_ctor_dtor (name)) 2839 { 2840 #if TARGET_AIX_VERSION 2841 /* Add AIX shared library initalisers/finalisers 2842 to the constructors/destructors list of the 2843 current module. */ 2844 case SYM_AIXI: 2845 if (! (filter & SCAN_CTOR)) 2846 break; 2847 if (is_shared && !aixlazy_flag 2848 #ifdef COLLECT_EXPORT_LIST 2849 && ! static_obj 2850 && ! is_in_list (prog_name, static_libs.first) 2851 #endif 2852 ) 2853 add_to_list (&constructors, name); 2854 break; 2855 2856 case SYM_AIXD: 2857 if (! (filter & SCAN_DTOR)) 2858 break; 2859 if (is_shared && !aixlazy_flag) 2860 add_to_list (&destructors, name); 2861 break; 2862 #endif 2863 2864 case SYM_CTOR: 2865 if (! (filter & SCAN_CTOR)) 2866 break; 2867 if (! is_shared) 2868 add_to_list (&constructors, name); 2869 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 2870 if (which_pass == PASS_OBJ) 2871 add_to_list (&exports, name); 2872 #endif 2873 break; 2874 2875 case SYM_DTOR: 2876 if (! (filter & SCAN_DTOR)) 2877 break; 2878 if (! is_shared) 2879 add_to_list (&destructors, name); 2880 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 2881 if (which_pass == PASS_OBJ) 2882 add_to_list (&exports, name); 2883 #endif 2884 break; 2885 2886 #ifdef COLLECT_EXPORT_LIST 2887 case SYM_INIT: 2888 if (! (filter & SCAN_INIT)) 2889 break; 2890 #ifndef LD_INIT_SWITCH 2891 if (is_shared) 2892 add_to_list (&constructors, name); 2893 #endif 2894 break; 2895 2896 case SYM_FINI: 2897 if (! (filter & SCAN_FINI)) 2898 break; 2899 #ifndef LD_INIT_SWITCH 2900 if (is_shared) 2901 add_to_list (&destructors, name); 2902 #endif 2903 break; 2904 #endif 2905 2906 case SYM_DWEH: 2907 if (! (filter & SCAN_DWEH)) 2908 break; 2909 if (! is_shared) 2910 add_to_list (&frame_tables, name); 2911 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH) 2912 if (which_pass == PASS_OBJ) 2913 add_to_list (&exports, name); 2914 #endif 2915 break; 2916 2917 default: /* not a constructor or destructor */ 2918 #ifdef COLLECT_EXPORT_LIST 2919 /* Explicitly export all global symbols when 2920 building a shared object on AIX, but do not 2921 re-export symbols from another shared object 2922 and do not export symbols if the user 2923 provides an explicit export list. */ 2924 if (shared_obj && !is_shared 2925 && which_pass == PASS_OBJ && !export_flag) 2926 { 2927 /* Do not auto-export __dso_handle or 2928 __gcc_unwind_dbase. They are required 2929 to be local to each module. */ 2930 if (strcmp(name, "__dso_handle") != 0 2931 && strcmp(name, "__gcc_unwind_dbase") != 0) 2932 { 2933 add_to_list (&exports, name); 2934 } 2935 } 2936 #endif 2937 continue; 2938 } 2939 2940 if (debug) 2941 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n", 2942 symbol.n_scnum, symbol.n_sclass, 2943 (symbol.n_type ? "0" : ""), symbol.n_type, 2944 name); 2945 } 2946 } 2947 } 2948 #ifdef COLLECT_EXPORT_LIST 2949 else 2950 { 2951 /* If archive contains both 32-bit and 64-bit objects, 2952 we want to skip objects in other mode so mismatch normal. */ 2953 if (debug) 2954 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n", 2955 prog_name, HEADER (ldptr).f_magic, aix64_flag); 2956 } 2957 #endif 2958 } 2959 else 2960 { 2961 fatal_error (input_location, "%s: cannot open as COFF file", 2962 prog_name); 2963 } 2964 #ifdef COLLECT_EXPORT_LIST 2965 /* On AIX loop continues while there are more members in archive. */ 2966 } 2967 while (ldclose (ldptr) == FAILURE); 2968 #else 2969 /* Otherwise we simply close ldptr. */ 2970 (void) ldclose (ldptr); 2971 #endif 2972 } 2973 #endif /* OBJECT_FORMAT_COFF */ 2974 2975 #ifdef COLLECT_EXPORT_LIST 2976 /* Given a library name without "lib" prefix, this function 2977 returns a full library name including a path. */ 2978 static char * 2979 resolve_lib_name (const char *name) 2980 { 2981 char *lib_buf; 2982 int i, j, l = 0; 2983 /* Library extensions for AIX dynamic linking. */ 2984 const char * const libexts[2] = {"a", "so"}; 2985 2986 for (i = 0; libpaths[i]; i++) 2987 if (libpaths[i]->max_len > l) 2988 l = libpaths[i]->max_len; 2989 2990 lib_buf = XNEWVEC (char, l + strlen (name) + 10); 2991 2992 for (i = 0; libpaths[i]; i++) 2993 { 2994 struct prefix_list *list = libpaths[i]->plist; 2995 for (; list; list = list->next) 2996 { 2997 /* The following lines are needed because path_prefix list 2998 may contain directories both with trailing DIR_SEPARATOR and 2999 without it. */ 3000 const char *p = ""; 3001 if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1])) 3002 p = "/"; 3003 for (j = 0; j < 2; j++) 3004 { 3005 sprintf (lib_buf, "%s%slib%s.%s", 3006 list->prefix, p, name, 3007 libexts[(j + aixrtl_flag) % 2]); 3008 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf); 3009 if (file_exists (lib_buf)) 3010 { 3011 if (debug) fprintf (stderr, "found: %s\n", lib_buf); 3012 return (lib_buf); 3013 } 3014 } 3015 } 3016 } 3017 if (debug) 3018 fprintf (stderr, "not found\n"); 3019 else 3020 fatal_error (input_location, "library lib%s not found", name); 3021 return (NULL); 3022 } 3023 #endif /* COLLECT_EXPORT_LIST */ 3024 3025 #ifdef COLLECT_RUN_DSYMUTIL 3026 static int flag_dsym = false; 3027 static int flag_idsym = false; 3028 3029 static void 3030 process_args (int *argcp, char **argv) { 3031 int i, j; 3032 int argc = *argcp; 3033 for (i=0; i<argc; ++i) 3034 { 3035 if (strcmp (argv[i], "-dsym") == 0) 3036 { 3037 flag_dsym = true; 3038 /* Remove the flag, as we handle all processing for it. */ 3039 j = i; 3040 do 3041 argv[j] = argv[j+1]; 3042 while (++j < argc); 3043 --i; 3044 argc = --(*argcp); 3045 } 3046 else if (strcmp (argv[i], "-idsym") == 0) 3047 { 3048 flag_idsym = true; 3049 /* Remove the flag, as we handle all processing for it. */ 3050 j = i; 3051 do 3052 argv[j] = argv[j+1]; 3053 while (++j < argc); 3054 --i; 3055 argc = --(*argcp); 3056 } 3057 } 3058 } 3059 3060 static void 3061 do_dsymutil (const char *output_file) { 3062 const char *dsymutil = DSYMUTIL + 1; 3063 struct pex_obj *pex; 3064 char **real_argv = XCNEWVEC (char *, 3); 3065 const char ** argv = CONST_CAST2 (const char **, char **, 3066 real_argv); 3067 3068 argv[0] = dsymutil; 3069 argv[1] = output_file; 3070 argv[2] = (char *) 0; 3071 3072 pex = collect_execute (dsymutil, real_argv, NULL, NULL, 3073 PEX_LAST | PEX_SEARCH, false); 3074 do_wait (dsymutil, pex); 3075 } 3076 3077 static void 3078 post_ld_pass (bool temp_file) { 3079 if (!(temp_file && flag_idsym) && !flag_dsym) 3080 return; 3081 3082 do_dsymutil (output_file); 3083 } 3084 #else 3085 static void 3086 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { } 3087 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { } 3088 #endif 3089