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