1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
6 Contributed by Chris Smith (csmith@convex.com).
7 Heavily modified by Michael Meissner (meissner@cygnus.com),
8 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
27 /* Build tables of static constructors and destructors and run ld. */
31 #include "coretypes.h"
34 #if ! defined( SIGCHLD ) && defined( SIGCLD )
35 # define SIGCHLD SIGCLD
38 /* TARGET_64BIT may be defined to use driver specific functionality. */
40 #define TARGET_64BIT TARGET_64BIT_DEFAULT
42 #ifndef LIBRARY_PATH_ENV
43 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
49 #include "collect2-aix.h"
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. */
61 #ifdef CROSS_DIRECTORY_STRUCTURE
62 #ifndef CROSS_AIX_SUPPORT
63 #undef OBJECT_FORMAT_COFF
66 #undef REAL_LD_FILE_NAME
67 #undef REAL_NM_FILE_NAME
68 #undef REAL_STRIP_FILE_NAME
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. */
76 #if !defined (OBJECT_FORMAT_COFF)
77 #define OBJECT_FORMAT_NONE
80 #ifdef OBJECT_FORMAT_COFF
82 #ifndef CROSS_DIRECTORY_STRUCTURE
90 /* Many versions of ldfcn.h define these. */
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. */
105 #define MY_ISCOFF(X) ISCOFF (X)
108 #endif /* OBJECT_FORMAT_COFF */
110 #ifdef OBJECT_FORMAT_NONE
112 /* Default flags to pass to nm. */
114 #define NM_FLAGS "-n"
117 #endif /* OBJECT_FORMAT_NONE */
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. */
123 #define NAME__MAIN "__main"
126 /* This must match tree.h. */
127 #define DEFAULT_INIT_PRIORITY 65535
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))
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))
139 #define SCAN_LIBRARIES
143 #define SHLIB_SUFFIX ".so"
147 int do_collecting = 1;
149 int do_collecting = 0;
152 /* Cook up an always defined indication of whether we proceed the
153 "EXPORT_LIST" way. */
155 #ifdef COLLECT_EXPORT_LIST
156 #define DO_COLLECT_EXPORT_LIST 1
158 #define DO_COLLECT_EXPORT_LIST 0
161 /* Nonzero if we should suppress the automatic demangling of identifiers
162 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
165 /* Linked lists of constructor and destructor names. */
181 bool vflag; /* true if -v or --version */
182 static int rflag; /* true if -r */
183 static int strip_flag; /* true if -s */
184 static const char *demangle_flag;
185 #ifdef COLLECT_EXPORT_LIST
186 static int export_flag; /* true if -bE */
187 static int aix64_flag; /* true if -b64 */
188 static int aixrtl_flag; /* true if -brtl */
192 LTO_MODE_NONE, /* Not doing LTO. */
193 LTO_MODE_LTO, /* Normal LTO. */
194 LTO_MODE_WHOPR /* WHOPR. */
197 /* Current LTO mode. */
198 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
200 bool debug; /* true if -debug */
201 bool helpflag; /* true if --help */
203 static int shared_obj; /* true if -shared */
205 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
206 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
207 #ifdef COLLECT_EXPORT_LIST
208 static const char *export_file; /* <xxx>.x for AIX export list. */
210 static char **lto_o_files; /* Output files for LTO. */
211 const char *ldout; /* File for ld stdout. */
212 const char *lderrout; /* File for ld stderr. */
213 static const char *output_file; /* Output file for ld. */
214 static const char *nm_file_name; /* pathname of nm */
216 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
218 static const char *strip_file_name; /* pathname of strip */
219 const char *c_file_name; /* pathname of gcc */
220 static char *initname, *fininame; /* names of init and fini funcs */
222 static struct head constructors; /* list of constructors found */
223 static struct head destructors; /* list of destructors found */
224 #ifdef COLLECT_EXPORT_LIST
225 static struct head exports; /* list of exported symbols */
227 static struct head frame_tables; /* list of frame unwind info tables */
229 static bool at_file_supplied; /* Whether to use @file arguments */
230 static char *response_file; /* Name of any current response file */
232 struct obstack temporary_obstack;
233 char * temporary_firstobj;
235 /* A string that must be prepended to a target OS path in order to find
236 it on the host system. */
237 #ifdef TARGET_SYSTEM_ROOT
238 static const char *target_system_root = TARGET_SYSTEM_ROOT;
240 static const char *target_system_root = "";
243 /* Structure to hold all the directories in which to search for files to
248 const char *prefix; /* String to prepend to the path. */
249 struct prefix_list *next; /* Next in linked list. */
254 struct prefix_list *plist; /* List of prefixes to try */
255 int max_len; /* Max length of a prefix in PLIST */
256 const char *name; /* Name of this list (used in config stuff) */
259 #ifdef COLLECT_EXPORT_LIST
260 /* Lists to keep libraries to be scanned for global constructors/destructors. */
261 static struct head libs; /* list of libraries */
262 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
263 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
264 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
265 &libpath_lib_dirs, NULL};
268 /* List of names of object files containing LTO information.
269 These are a subset of the object file names appearing on the
270 command line, and must be identical, in the sense of pointer
271 equality, with the names passed to maybe_run_lto_and_relink(). */
275 const char *name; /* Name of object file. */
276 struct lto_object *next; /* Next in linked list. */
279 struct lto_object_list
281 struct lto_object *first; /* First list element. */
282 struct lto_object *last; /* Last list element. */
285 static struct lto_object_list lto_objects;
287 /* Special kinds of symbols that a name may denote. */
290 SYM_REGULAR = 0, /* nothing special */
292 SYM_CTOR = 1, /* constructor */
293 SYM_DTOR = 2, /* destructor */
294 SYM_INIT = 3, /* shared object routine that calls all the ctors */
295 SYM_FINI = 4, /* shared object routine that calls all the dtors */
296 SYM_DWEH = 5 /* DWARF exception handling table */
299 static symkind is_ctor_dtor (const char *);
301 static void handler (int);
302 static char *find_a_file (struct path_prefix *, const char *);
303 static void add_prefix (struct path_prefix *, const char *);
304 static void prefix_from_env (const char *, struct path_prefix *);
305 static void prefix_from_string (const char *, struct path_prefix *);
306 static void do_wait (const char *, struct pex_obj *);
307 static void fork_execute (const char *, char **);
308 static void maybe_unlink (const char *);
309 static void maybe_unlink_list (char **);
310 static void add_to_list (struct head *, const char *);
311 static int extract_init_priority (const char *);
312 static void sort_ids (struct head *);
313 static void write_list (FILE *, const char *, struct id *);
314 #ifdef COLLECT_EXPORT_LIST
315 static void dump_list (FILE *, const char *, struct id *);
318 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
320 static void write_list_with_asm (FILE *, const char *, struct id *);
321 static void write_c_file (FILE *, const char *);
322 static void write_c_file_stat (FILE *, const char *);
323 #ifndef LD_INIT_SWITCH
324 static void write_c_file_glob (FILE *, const char *);
326 #ifdef SCAN_LIBRARIES
327 static void scan_libraries (const char *);
329 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
330 static int is_in_args (const char *, const char **, const char **);
332 #ifdef COLLECT_EXPORT_LIST
334 static int is_in_list (const char *, struct id *);
336 static void write_aix_file (FILE *, struct id *);
337 static char *resolve_lib_name (const char *);
339 static char *extract_string (const char **);
341 /* Enumerations describing which pass this is for scanning the
345 PASS_FIRST, /* without constructors */
346 PASS_OBJ, /* individual objects */
347 PASS_LIB, /* looking for shared libraries */
348 PASS_SECOND, /* with constructors linked in */
349 PASS_LTOINFO /* looking for objects with LTO info */
352 /* ... and which kinds of symbols are to be considered. */
354 enum scanfilter_masks {
357 SCAN_CTOR = 1 << SYM_CTOR,
358 SCAN_DTOR = 1 << SYM_DTOR,
359 SCAN_INIT = 1 << SYM_INIT,
360 SCAN_FINI = 1 << SYM_FINI,
361 SCAN_DWEH = 1 << SYM_DWEH,
365 /* This type is used for parameters and variables which hold
366 combinations of the flags in enum scanfilter_masks. */
367 typedef int scanfilter;
369 /* Scan the name list of the loaded program for the symbols g++ uses for
370 static constructors and destructors.
372 The SCANPASS argument tells which collect processing pass this is for and
373 the SCANFILTER argument tells which kinds of symbols to consider in this
374 pass. Symbols of a special kind not in the filter mask are considered as
377 The constructor table begins at __CTOR_LIST__ and contains a count of the
378 number of pointers (or -1 if the constructors are built in a separate
379 section by the linker), followed by the pointers to the constructor
380 functions, terminated with a null pointer. The destructor table has the
381 same format, and begins at __DTOR_LIST__. */
383 static void scan_prog_file (const char *, scanpass, scanfilter);
386 /* Delete tempfiles and exit function. */
389 collect_exit (int status)
391 if (c_file != 0 && c_file[0])
392 maybe_unlink (c_file);
394 if (o_file != 0 && o_file[0])
395 maybe_unlink (o_file);
397 #ifdef COLLECT_EXPORT_LIST
398 if (export_file != 0 && export_file[0])
399 maybe_unlink (export_file);
403 maybe_unlink_list (lto_o_files);
405 if (ldout != 0 && ldout[0])
407 dump_file (ldout, stdout);
408 maybe_unlink (ldout);
411 if (lderrout != 0 && lderrout[0])
413 dump_file (lderrout, stderr);
414 maybe_unlink (lderrout);
417 if (status != 0 && output_file != 0 && output_file[0])
418 maybe_unlink (output_file);
421 maybe_unlink (response_file);
427 /* Notify user of a non-error. */
429 notice (const char *cmsgid, ...)
433 va_start (ap, cmsgid);
434 vfprintf (stderr, _(cmsgid), ap);
438 /* Notify user of a non-error, without translating the format string. */
440 notice_translated (const char *cmsgid, ...)
444 va_start (ap, cmsgid);
445 vfprintf (stderr, cmsgid, ap);
449 /* Die when sys call fails. */
452 fatal_perror (const char * cmsgid, ...)
457 va_start (ap, cmsgid);
458 fprintf (stderr, "collect2: ");
459 vfprintf (stderr, _(cmsgid), ap);
460 fprintf (stderr, ": %s\n", xstrerror (e));
463 collect_exit (FATAL_EXIT_CODE);
469 fatal (const char * cmsgid, ...)
473 va_start (ap, cmsgid);
474 fprintf (stderr, "collect2: ");
475 vfprintf (stderr, _(cmsgid), ap);
476 fprintf (stderr, "\n");
479 collect_exit (FATAL_EXIT_CODE);
482 /* Write error message. */
485 error (const char * gmsgid, ...)
489 va_start (ap, gmsgid);
490 fprintf (stderr, "collect2: ");
491 vfprintf (stderr, _(gmsgid), ap);
492 fprintf (stderr, "\n");
496 /* In case obstack is linked in, and abort is defined to fancy_abort,
497 provide a default entry. */
500 fancy_abort (const char *file, int line, const char *func)
502 fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
508 if (c_file != 0 && c_file[0])
509 maybe_unlink (c_file);
511 if (o_file != 0 && o_file[0])
512 maybe_unlink (o_file);
514 if (ldout != 0 && ldout[0])
515 maybe_unlink (ldout);
517 if (lderrout != 0 && lderrout[0])
518 maybe_unlink (lderrout);
520 #ifdef COLLECT_EXPORT_LIST
521 if (export_file != 0 && export_file[0])
522 maybe_unlink (export_file);
526 maybe_unlink_list (lto_o_files);
529 maybe_unlink (response_file);
531 signal (signo, SIG_DFL);
537 file_exists (const char *name)
539 return access (name, R_OK) == 0;
542 /* Parse a reasonable subset of shell quoting syntax. */
545 extract_string (const char **pp)
558 obstack_1grow (&temporary_obstack, c);
559 else if (! inside && c == ' ')
561 else if (! inside && c == '\\')
566 obstack_1grow (&temporary_obstack, c);
569 obstack_1grow (&temporary_obstack, '\0');
571 return XOBFINISH (&temporary_obstack, char *);
575 dump_file (const char *name, FILE *to)
577 FILE *stream = fopen (name, "r");
584 while (c = getc (stream),
585 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
586 obstack_1grow (&temporary_obstack, c);
587 if (obstack_object_size (&temporary_obstack) > 0)
589 const char *word, *p;
591 obstack_1grow (&temporary_obstack, '\0');
592 word = XOBFINISH (&temporary_obstack, const char *);
595 ++word, putc ('.', to);
597 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
598 p += strlen (USER_LABEL_PREFIX);
600 #ifdef HAVE_LD_DEMANGLE
606 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
614 diff = strlen (word) - strlen (result);
615 while (diff > 0 && c == ' ')
616 --diff, putc (' ', to);
617 if (diff < 0 && c == ' ')
619 while (diff < 0 && c == ' ')
620 ++diff, c = getc (stream);
623 /* Make sure we output at least one space, or
624 the demangled symbol name will run into
625 whatever text follows. */
636 obstack_free (&temporary_obstack, temporary_firstobj);
645 /* Return the kind of symbol denoted by name S. */
648 is_ctor_dtor (const char *s)
650 struct names { const char *const name; const int len; symkind ret;
651 const int two_underscores; };
653 const struct names *p;
655 const char *orig_s = s;
657 static const struct names special[] = {
658 #ifndef NO_DOLLAR_IN_LABEL
659 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
660 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
662 #ifndef NO_DOT_IN_LABEL
663 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
664 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
665 #endif /* NO_DOT_IN_LABEL */
666 #endif /* NO_DOLLAR_IN_LABEL */
667 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
668 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
669 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
670 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
671 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
672 { NULL, 0, SYM_REGULAR, 0 }
675 while ((ch = *s) == '_')
681 for (p = &special[0]; p->len > 0; p++)
684 && (!p->two_underscores || ((s - orig_s) >= 2))
685 && strncmp(s, p->name, p->len) == 0)
693 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
694 and one from the PATH variable. */
696 static struct path_prefix cpath, path;
698 #ifdef CROSS_DIRECTORY_STRUCTURE
699 /* This is the name of the target machine. We use it to form the name
700 of the files to execute. */
702 static const char *const target_machine = TARGET_MACHINE;
705 /* Search for NAME using prefix list PPREFIX. We only look for executable
708 Return 0 if not found, otherwise return its name, allocated with malloc. */
711 find_a_file (struct path_prefix *pprefix, const char *name)
714 struct prefix_list *pl;
715 int len = pprefix->max_len + strlen (name) + 1;
718 fprintf (stderr, "Looking for '%s'\n", name);
720 #ifdef HOST_EXECUTABLE_SUFFIX
721 len += strlen (HOST_EXECUTABLE_SUFFIX);
724 temp = XNEWVEC (char, len);
726 /* Determine the filename to execute (special case for absolute paths). */
728 if (IS_ABSOLUTE_PATH (name))
730 if (access (name, X_OK) == 0)
735 fprintf (stderr, " - found: absolute path\n");
740 #ifdef HOST_EXECUTABLE_SUFFIX
741 /* Some systems have a suffix for executable files.
742 So try appending that. */
744 strcat (temp, HOST_EXECUTABLE_SUFFIX);
746 if (access (temp, X_OK) == 0)
751 fprintf (stderr, " - failed to locate using absolute path\n");
754 for (pl = pprefix->plist; pl; pl = pl->next)
758 strcpy (temp, pl->prefix);
761 if (stat (temp, &st) >= 0
762 && ! S_ISDIR (st.st_mode)
763 && access (temp, X_OK) == 0)
766 #ifdef HOST_EXECUTABLE_SUFFIX
767 /* Some systems have a suffix for executable files.
768 So try appending that. */
769 strcat (temp, HOST_EXECUTABLE_SUFFIX);
771 if (stat (temp, &st) >= 0
772 && ! S_ISDIR (st.st_mode)
773 && access (temp, X_OK) == 0)
778 if (debug && pprefix->plist == NULL)
779 fprintf (stderr, " - failed: no entries in prefix list\n");
785 /* Add an entry for PREFIX to prefix list PPREFIX. */
788 add_prefix (struct path_prefix *pprefix, const char *prefix)
790 struct prefix_list *pl, **prev;
795 for (pl = pprefix->plist; pl->next; pl = pl->next)
800 prev = &pprefix->plist;
802 /* Keep track of the longest prefix. */
804 len = strlen (prefix);
805 if (len > pprefix->max_len)
806 pprefix->max_len = len;
808 pl = XNEW (struct prefix_list);
809 pl->prefix = xstrdup (prefix);
814 pl->next = (struct prefix_list *) 0;
818 /* Take the value of the environment variable ENV, break it into a path, and
819 add of the entries to PPREFIX. */
822 prefix_from_env (const char *env, struct path_prefix *pprefix)
825 GET_ENVIRONMENT (p, env);
828 prefix_from_string (p, pprefix);
832 prefix_from_string (const char *p, struct path_prefix *pprefix)
834 const char *startp, *endp;
835 char *nstore = XNEWVEC (char, strlen (p) + 3);
838 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
843 if (*endp == PATH_SEPARATOR || *endp == 0)
845 strncpy (nstore, startp, endp-startp);
848 strcpy (nstore, "./");
850 else if (! IS_DIR_SEPARATOR (endp[-1]))
852 nstore[endp-startp] = DIR_SEPARATOR;
853 nstore[endp-startp+1] = 0;
856 nstore[endp-startp] = 0;
859 fprintf (stderr, " - add prefix: %s\n", nstore);
861 add_prefix (pprefix, nstore);
864 endp = startp = endp + 1;
872 #ifdef OBJECT_FORMAT_NONE
874 /* Add an entry for the object file NAME to object file list LIST.
875 New entries are added at the end of the list. The original pointer
876 value of NAME is preserved, i.e., no string copy is performed. */
879 add_lto_object (struct lto_object_list *list, const char *name)
881 struct lto_object *n = XNEW (struct lto_object);
886 list->last->next = n;
892 #endif /* OBJECT_FORMAT_NONE */
895 /* Perform a link-time recompilation and relink if any of the object
896 files contain LTO info. The linker command line LTO_LD_ARGV
897 represents the linker command that would produce a final executable
898 without the use of LTO. OBJECT_LST is a vector of object file names
899 appearing in LTO_LD_ARGV that are to be considerd for link-time
900 recompilation, where OBJECT is a pointer to the last valid element.
901 (This awkward convention avoids an impedance mismatch with the
902 usage of similarly-named variables in main().) The elements of
903 OBJECT_LST must be identical, i.e., pointer equal, to the
904 corresponding arguments in LTO_LD_ARGV.
906 Upon entry, at least one linker run has been performed without the
907 use of any LTO info that might be present. Any recompilations
908 necessary for template instantiations have been performed, and
909 initializer/finalizer tables have been created if needed and
910 included in the linker command line LTO_LD_ARGV. If any of the
911 object files contain LTO info, we run the LTO back end on all such
912 files, and perform the final link with the LTO back end output
913 substituted for the LTO-optimized files. In some cases, a final
914 link with all link-time generated code has already been performed,
915 so there is no need to relink if no LTO info is found. In other
916 cases, our caller has not produced the final executable, and is
917 relying on us to perform the required link whether LTO info is
918 present or not. In that case, the FORCE argument should be true.
919 Note that the linker command line argument LTO_LD_ARGV passed into
920 this function may be modified in place. */
923 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
924 const char **object, bool force)
926 const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
928 int num_lto_c_args = 1; /* Allow space for the terminating NULL. */
930 while (object_file < object)
932 /* If file contains LTO info, add it to the list of LTO objects. */
933 scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
935 /* Increment the argument count by the number of object file arguments
936 we will add. An upper bound suffices, so just count all of the
937 object files regardless of whether they contain LTO info. */
941 if (lto_objects.first)
944 const char **lto_c_ptr;
945 const char **p, **q, **r;
946 const char **lto_o_ptr;
947 struct lto_object *list;
948 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
950 const char *prog = "lto-wrapper";
953 fatal ("COLLECT_LTO_WRAPPER must be set.");
957 /* There is at least one object file containing LTO info,
958 so we need to run the LTO back end and relink. */
960 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
961 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
963 *lto_c_ptr++ = lto_wrapper;
965 /* Add LTO objects to the wrapper command line. */
966 for (list = lto_objects.first; list; list = list->next)
967 *lto_c_ptr++ = list->name;
971 /* Run the LTO back end. */
972 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
979 stream = pex_read_output (pex, 0);
983 while ((c = getc (stream)) != EOF)
985 obstack_1grow (&temporary_obstack, c);
990 lto_o_files = XNEWVEC (char *, num_files + 1);
991 lto_o_files[num_files] = NULL;
992 start = XOBFINISH (&temporary_obstack, char *);
993 for (i = 0; i < num_files; ++i)
1000 lto_o_files[i] = xstrdup (start);
1005 obstack_free (&temporary_obstack, temporary_firstobj);
1007 do_wait (prog, pex);
1010 /* After running the LTO back end, we will relink, substituting
1011 the LTO output for the object files that we submitted to the
1012 LTO. Here, we modify the linker command line for the relink. */
1013 p = CONST_CAST2 (const char **, char **, lto_ld_argv);
1014 lto_o_ptr = CONST_CAST2 (const char **, char **, lto_o_files);
1018 for (list = lto_objects.first; list; list = list->next)
1020 if (*p == list->name) /* Note test for pointer equality! */
1022 /* Excise argument from linker command line. */
1025 /* Replace first argument with LTO output file. */
1026 *p++ = *lto_o_ptr++;
1030 /* Move following arguments one position earlier,
1031 overwriting the current argument. */
1039 /* No need to continue searching the LTO object list. */
1044 /* If we didn't find a match, move on to the next argument.
1045 Otherwise, P has been set to the correct argument position
1046 at which to continue. */
1050 /* The code above assumes we will never have more lto output files than
1051 input files. Otherwise, we need to resize lto_ld_argv. Check this
1054 fatal ("too many lto output files");
1056 /* Run the linker again, this time replacing the object files
1057 optimized by the LTO with the temporary file generated by the LTO. */
1058 fork_execute ("ld", lto_ld_argv);
1060 maybe_unlink_list (lto_o_files);
1064 /* Our caller is relying on us to do the link
1065 even though there is no LTO back end work to be done. */
1066 fork_execute ("ld", lto_ld_argv);
1073 main (int argc, char **argv)
1075 static const char *const ld_suffix = "ld";
1076 static const char *const plugin_ld_suffix = PLUGIN_LD;
1077 static const char *const real_ld_suffix = "real-ld";
1078 static const char *const collect_ld_suffix = "collect-ld";
1079 static const char *const nm_suffix = "nm";
1080 static const char *const gnm_suffix = "gnm";
1082 static const char *const ldd_suffix = LDD_SUFFIX;
1084 static const char *const strip_suffix = "strip";
1085 static const char *const gstrip_suffix = "gstrip";
1087 #ifdef CROSS_DIRECTORY_STRUCTURE
1088 /* If we look for a program in the compiler directories, we just use
1089 the short name, since these directories are already system-specific.
1090 But it we look for a program in the system directories, we need to
1091 qualify the program name with the target machine. */
1093 const char *const full_ld_suffix =
1094 concat(target_machine, "-", ld_suffix, NULL);
1095 const char *const full_plugin_ld_suffix =
1096 concat(target_machine, "-", plugin_ld_suffix, NULL);
1097 const char *const full_nm_suffix =
1098 concat (target_machine, "-", nm_suffix, NULL);
1099 const char *const full_gnm_suffix =
1100 concat (target_machine, "-", gnm_suffix, NULL);
1102 const char *const full_ldd_suffix =
1103 concat (target_machine, "-", ldd_suffix, NULL);
1105 const char *const full_strip_suffix =
1106 concat (target_machine, "-", strip_suffix, NULL);
1107 const char *const full_gstrip_suffix =
1108 concat (target_machine, "-", gstrip_suffix, NULL);
1110 const char *const full_ld_suffix = ld_suffix;
1111 const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1112 const char *const full_nm_suffix = nm_suffix;
1113 const char *const full_gnm_suffix = gnm_suffix;
1115 const char *const full_ldd_suffix = ldd_suffix;
1117 const char *const full_strip_suffix = strip_suffix;
1118 const char *const full_gstrip_suffix = gstrip_suffix;
1119 #endif /* CROSS_DIRECTORY_STRUCTURE */
1123 #ifdef COLLECT_EXPORT_LIST
1126 const char *ld_file_name;
1132 bool use_plugin = false;
1134 /* The kinds of symbols we will have to consider when scanning the
1135 outcome of a first pass link. This is ALL to start with, then might
1136 be adjusted before getting to the first pass link per se, typically on
1137 AIX where we perform an early scan of objects and libraries to fetch
1138 the list of global ctors/dtors and make sure they are not garbage
1140 scanfilter ld1_filter = SCAN_ALL;
1145 const char **object;
1150 bool use_verbose = false;
1153 expandargv (&argc, &argv);
1154 if (argv != old_argv)
1155 at_file_supplied = 1;
1157 num_c_args = argc + 9;
1159 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1161 /* Suppress demangling by the real linker, which may be broken. */
1162 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1164 #if defined (COLLECT2_HOST_INITIALIZATION)
1165 /* Perform system dependent initialization, if necessary. */
1166 COLLECT2_HOST_INITIALIZATION;
1170 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1171 receive the signal. A different setting is inheritable */
1172 signal (SIGCHLD, SIG_DFL);
1175 /* Unlock the stdio streams. */
1176 unlock_std_streams ();
1178 gcc_init_libintl ();
1180 /* Do not invoke xcalloc before this point, since locale needs to be
1181 set first, in case a diagnostic is issued. */
1183 ld1_argv = XCNEWVEC (char *, argc + 4);
1184 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1185 ld2_argv = XCNEWVEC (char *, argc + 11);
1186 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1187 object_lst = XCNEWVEC (char *, argc);
1188 object = CONST_CAST2 (const char **, char **, object_lst);
1194 /* Parse command line early for instances of -debug. This allows
1195 the debug flag to be set before functions like find_a_file()
1196 are called. We also look for the -flto or -fwhopr flag to know
1197 what LTO mode we are in. */
1201 for (i = 1; argv[i] != NULL; i ++)
1203 if (! strcmp (argv[i], "-debug"))
1205 else if (! strcmp (argv[i], "-flto") && ! use_plugin)
1208 lto_mode = LTO_MODE_LTO;
1210 else if (! strcmp (argv[i], "-fwhopr") && ! use_plugin)
1213 lto_mode = LTO_MODE_WHOPR;
1215 else if (! strcmp (argv[i], "-plugin"))
1219 lto_mode = LTO_MODE_NONE;
1221 #ifdef COLLECT_EXPORT_LIST
1222 /* since -brtl, -bexport, -b64 are not position dependent
1223 also check for them here */
1224 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1227 /* We want to disable automatic exports on AIX when user
1228 explicitly puts an export list in command line */
1229 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1231 else if (arg[2] == '6' && arg[3] == '4')
1233 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1241 #ifndef DEFAULT_A_OUT_NAME
1242 output_file = "a.out";
1244 output_file = DEFAULT_A_OUT_NAME;
1247 obstack_begin (&temporary_obstack, 0);
1248 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1250 #ifndef HAVE_LD_DEMANGLE
1251 current_demangling_style = auto_demangling;
1253 p = getenv ("COLLECT_GCC_OPTIONS");
1256 const char *q = extract_string (&p);
1257 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1260 obstack_free (&temporary_obstack, temporary_firstobj);
1262 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1263 -fno-exceptions -w -fno-whole-program */
1266 c_argv = XCNEWVEC (char *, num_c_args);
1267 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1270 fatal ("no arguments");
1273 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1274 signal (SIGQUIT, handler);
1276 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1277 signal (SIGINT, handler);
1279 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1280 signal (SIGALRM, handler);
1283 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1284 signal (SIGHUP, handler);
1286 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1287 signal (SIGSEGV, handler);
1289 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1290 signal (SIGBUS, handler);
1293 /* Extract COMPILER_PATH and PATH into our prefix list. */
1294 prefix_from_env ("COMPILER_PATH", &cpath);
1295 prefix_from_env ("PATH", &path);
1297 /* Try to discover a valid linker/nm/strip to use. */
1299 /* Maybe we know the right file to use (if not cross). */
1301 #ifdef DEFAULT_LINKER
1302 if (access (DEFAULT_LINKER, X_OK) == 0)
1303 ld_file_name = DEFAULT_LINKER;
1304 if (ld_file_name == 0)
1306 #ifdef REAL_LD_FILE_NAME
1307 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1308 if (ld_file_name == 0)
1310 /* Search the (target-specific) compiler dirs for ld'. */
1311 ld_file_name = find_a_file (&cpath, real_ld_suffix);
1312 /* Likewise for `collect-ld'. */
1313 if (ld_file_name == 0)
1314 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1315 /* Search the compiler directories for `ld'. We have protection against
1316 recursive calls in find_a_file. */
1317 if (ld_file_name == 0)
1318 ld_file_name = find_a_file (&cpath,
1322 /* Search the ordinary system bin directories
1323 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1324 if (ld_file_name == 0)
1325 ld_file_name = find_a_file (&path,
1327 ? full_plugin_ld_suffix
1330 #ifdef REAL_NM_FILE_NAME
1331 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1332 if (nm_file_name == 0)
1334 nm_file_name = find_a_file (&cpath, gnm_suffix);
1335 if (nm_file_name == 0)
1336 nm_file_name = find_a_file (&path, full_gnm_suffix);
1337 if (nm_file_name == 0)
1338 nm_file_name = find_a_file (&cpath, nm_suffix);
1339 if (nm_file_name == 0)
1340 nm_file_name = find_a_file (&path, full_nm_suffix);
1343 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1344 if (ldd_file_name == 0)
1345 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1348 #ifdef REAL_STRIP_FILE_NAME
1349 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1350 if (strip_file_name == 0)
1352 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1353 if (strip_file_name == 0)
1354 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1355 if (strip_file_name == 0)
1356 strip_file_name = find_a_file (&cpath, strip_suffix);
1357 if (strip_file_name == 0)
1358 strip_file_name = find_a_file (&path, full_strip_suffix);
1360 /* Determine the full path name of the C compiler to use. */
1361 c_file_name = getenv ("COLLECT_GCC");
1362 if (c_file_name == 0)
1364 #ifdef CROSS_DIRECTORY_STRUCTURE
1365 c_file_name = concat (target_machine, "-gcc", NULL);
1367 c_file_name = "gcc";
1371 p = find_a_file (&cpath, c_file_name);
1373 /* Here it should be safe to use the system search path since we should have
1374 already qualified the name of the compiler when it is needed. */
1376 p = find_a_file (&path, c_file_name);
1381 *ld1++ = *ld2++ = ld_file_name;
1383 /* Make temp file names. */
1384 c_file = make_temp_file (".c");
1385 o_file = make_temp_file (".o");
1386 #ifdef COLLECT_EXPORT_LIST
1387 export_file = make_temp_file (".x");
1389 ldout = make_temp_file (".ld");
1390 lderrout = make_temp_file (".le");
1391 *c_ptr++ = c_file_name;
1398 #ifdef COLLECT_EXPORT_LIST
1399 /* Generate a list of directories from LIBPATH. */
1400 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1401 /* Add to this list also two standard directories where
1402 AIX loader always searches for libraries. */
1403 add_prefix (&libpath_lib_dirs, "/lib");
1404 add_prefix (&libpath_lib_dirs, "/usr/lib");
1407 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1409 AIX support needs to know if -shared has been specified before
1410 parsing commandline arguments. */
1412 p = getenv ("COLLECT_GCC_OPTIONS");
1415 const char *q = extract_string (&p);
1416 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1417 *c_ptr++ = xstrdup (q);
1418 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1419 *c_ptr++ = xstrdup (q);
1420 if (strcmp (q, "-shared") == 0)
1422 if (*q == '-' && q[1] == 'B')
1424 *c_ptr++ = xstrdup (q);
1427 q = extract_string (&p);
1428 *c_ptr++ = xstrdup (q);
1431 if (use_verbose && *q == '-' && q[1] == 'v' && q[2] == 0)
1433 /* Turn on trace in collect2 if needed. */
1437 obstack_free (&temporary_obstack, temporary_firstobj);
1438 *c_ptr++ = "-fno-profile-arcs";
1439 *c_ptr++ = "-fno-test-coverage";
1440 *c_ptr++ = "-fno-branch-probabilities";
1441 *c_ptr++ = "-fno-exceptions";
1443 *c_ptr++ = "-fno-whole-program";
1445 /* !!! When GCC calls collect2,
1446 it does not know whether it is calling collect2 or ld.
1447 So collect2 cannot meaningfully understand any options
1448 except those ld understands.
1449 If you propose to make GCC pass some other option,
1450 just imagine what will happen if ld is really ld!!! */
1452 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1453 /* After the first file, put in the c++ rt0. */
1456 #ifdef HAVE_LD_DEMANGLE
1457 if (!demangle_flag && !no_demangle)
1458 demangle_flag = "--demangle";
1460 *ld1++ = *ld2++ = demangle_flag;
1462 while ((arg = *++argv) != (char *) 0)
1464 *ld1++ = *ld2++ = arg;
1471 if (!strcmp (arg, "-debug"))
1473 /* Already parsed. */
1477 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1480 *ld1++ = *ld2++ = *argv;
1485 if (strcmp (arg, "-flto") == 0 || strcmp (arg, "-fwhopr") == 0)
1488 /* Do not pass LTO flag to the linker. */
1492 error ("LTO support has not been enabled in this "
1501 /* place o_file BEFORE this argument! */
1507 #ifdef COLLECT_EXPORT_LIST
1509 /* Resolving full library name. */
1510 const char *s = resolve_lib_name (arg+2);
1512 /* Saving a full library name. */
1513 add_to_list (&libs, s);
1518 #ifdef COLLECT_EXPORT_LIST
1519 /* Saving directories where to search for libraries. */
1521 add_prefix (&cmdline_lib_dirs, arg+2);
1524 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1526 if (is_in_args (arg,
1527 CONST_CAST2 (const char **, char **, ld1_argv),
1531 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1536 output_file = *ld1++ = *ld2++ = *++argv;
1538 #ifdef SWITCHES_NEED_SPACES
1539 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1543 output_file = &arg[2];
1552 if (arg[2] == '\0' && do_collecting)
1554 /* We must strip after the nm run, otherwise C++ linking
1555 will not work. Thus we strip in the second ld run, or
1556 else with strip if there is no second ld run. */
1568 if (strcmp (arg, "--no-demangle") == 0)
1570 demangle_flag = arg;
1575 else if (strncmp (arg, "--demangle", 10) == 0)
1577 demangle_flag = arg;
1579 #ifndef HAVE_LD_DEMANGLE
1582 enum demangling_styles style
1583 = cplus_demangle_name_to_style (arg+11);
1584 if (style == unknown_demangling)
1585 error ("unknown demangling style '%s'", arg+11);
1587 current_demangling_style = style;
1593 else if (strncmp (arg, "--sysroot=", 10) == 0)
1594 target_system_root = arg + 10;
1595 else if (strncmp (arg, "--version", 9) == 0)
1597 else if (strncmp (arg, "--help", 9) == 0)
1602 else if ((p = strrchr (arg, '.')) != (char *) 0
1603 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1604 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1605 || strcmp (p, ".obj") == 0))
1614 /* place o_file BEFORE this argument! */
1620 if (p[1] == 'o' || p[1] == 'l')
1622 #ifdef COLLECT_EXPORT_LIST
1623 /* libraries can be specified directly, i.e. without -l flag. */
1626 /* Saving a full library name. */
1627 add_to_list (&libs, arg);
1633 #ifdef COLLECT_EXPORT_LIST
1634 /* This is added only for debugging purposes. */
1637 fprintf (stderr, "List of libraries:\n");
1638 dump_list (stderr, "\t", libs.first);
1641 /* The AIX linker will discard static constructors in object files if
1642 nothing else in the file is referenced, so look at them first. Unless
1643 we are building a shared object, ignore the eh frame tables, as we
1644 would otherwise reference them all, hence drag all the corresponding
1645 objects even if nothing else is referenced. */
1647 const char **export_object_lst
1648 = CONST_CAST2 (const char **, char **, object_lst);
1650 struct id *list = libs.first;
1652 /* Compute the filter to use from the current one, do scan, then adjust
1653 the "current" filter to remove what we just included here. This will
1654 control whether we need a first pass link later on or not, and what
1655 will remain to be scanned there. */
1657 scanfilter this_filter = ld1_filter;
1660 this_filter &= ~SCAN_DWEH;
1663 while (export_object_lst < object)
1664 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1666 for (; list; list = list->next)
1667 scan_prog_file (list->name, PASS_FIRST, this_filter);
1669 ld1_filter = ld1_filter & ~this_filter;
1674 char *buf = concat ("-bE:", export_file, NULL);
1679 exportf = fopen (export_file, "w");
1680 if (exportf == (FILE *) 0)
1681 fatal_perror ("fopen %s", export_file);
1682 write_aix_file (exportf, exports.first);
1683 if (fclose (exportf))
1684 fatal_perror ("fclose %s", export_file);
1689 *c_ptr = *ld1 = *object = (char *) 0;
1693 notice ("collect2 version %s", version_string);
1694 #ifdef TARGET_VERSION
1697 fprintf (stderr, "\n");
1702 fprintf (stderr, "Usage: collect2 [options]\n");
1703 fprintf (stderr, " Wrap linker and generate constructor code if needed.\n");
1704 fprintf (stderr, " Options:\n");
1705 fprintf (stderr, " -debug Enable debug output\n");
1706 fprintf (stderr, " --help Display this information\n");
1707 fprintf (stderr, " -v, --version Display this program's version number\n");
1708 fprintf (stderr, "Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1709 fprintf (stderr, "Report bugs: %s\n", bug_report_url);
1717 fprintf (stderr, "ld_file_name = %s\n",
1718 (ld_file_name ? ld_file_name : "not found"));
1719 fprintf (stderr, "c_file_name = %s\n",
1720 (c_file_name ? c_file_name : "not found"));
1721 fprintf (stderr, "nm_file_name = %s\n",
1722 (nm_file_name ? nm_file_name : "not found"));
1724 fprintf (stderr, "ldd_file_name = %s\n",
1725 (ldd_file_name ? ldd_file_name : "not found"));
1727 fprintf (stderr, "strip_file_name = %s\n",
1728 (strip_file_name ? strip_file_name : "not found"));
1729 fprintf (stderr, "c_file = %s\n",
1730 (c_file ? c_file : "not found"));
1731 fprintf (stderr, "o_file = %s\n",
1732 (o_file ? o_file : "not found"));
1734 ptr = getenv ("COLLECT_GCC_OPTIONS");
1736 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1738 ptr = getenv ("COLLECT_GCC");
1740 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1742 ptr = getenv ("COMPILER_PATH");
1744 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1746 ptr = getenv (LIBRARY_PATH_ENV);
1748 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1750 fprintf (stderr, "\n");
1753 /* Load the program, searching all libraries and attempting to provide
1754 undefined symbols from repository information.
1756 If -r or they will be run via some other method, do not build the
1757 constructor or destructor list, just return now. */
1760 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1762 /* Perform the first pass link now, if we're about to exit or if we need
1763 to scan for things we haven't collected yet before pursuing further.
1765 On AIX, the latter typically includes nothing for shared objects or
1766 frame tables for an executable, out of what the required early scan on
1767 objects and libraries has performed above. In the !shared_obj case, we
1768 expect the relevant tables to be dragged together with their associated
1769 functions from precise cross reference insertions by the compiler. */
1771 if (early_exit || ld1_filter != SCAN_NOTHING)
1772 do_tlink (ld1_argv, object_lst);
1776 #ifdef COLLECT_EXPORT_LIST
1777 /* Make sure we delete the export file we may have created. */
1778 if (export_file != 0 && export_file[0])
1779 maybe_unlink (export_file);
1781 if (lto_mode != LTO_MODE_NONE)
1782 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1784 maybe_unlink (c_file);
1785 maybe_unlink (o_file);
1790 /* Unless we have done it all already, examine the namelist and search for
1791 static constructors and destructors to call. Write the constructor and
1792 destructor tables to a .s file and reload. */
1794 if (ld1_filter != SCAN_NOTHING)
1795 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1797 #ifdef SCAN_LIBRARIES
1798 scan_libraries (output_file);
1803 notice_translated (ngettext ("%d constructor found\n",
1804 "%d constructors found\n",
1805 constructors.number),
1806 constructors.number);
1807 notice_translated (ngettext ("%d destructor found\n",
1808 "%d destructors found\n",
1809 destructors.number),
1810 destructors.number);
1811 notice_translated (ngettext("%d frame table found\n",
1812 "%d frame tables found\n",
1813 frame_tables.number),
1814 frame_tables.number);
1817 /* If the scan exposed nothing of special interest, there's no need to
1818 generate the glue code and relink so return now. */
1820 if (constructors.number == 0 && destructors.number == 0
1821 && frame_tables.number == 0
1822 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1823 /* If we will be running these functions ourselves, we want to emit
1824 stubs into the shared library so that we do not have to relink
1825 dependent programs when we add static objects. */
1830 /* Do tlink without additional code generation now if we didn't
1831 do it earlier for scanning purposes. */
1832 if (ld1_filter == SCAN_NOTHING)
1833 do_tlink (ld1_argv, object_lst);
1836 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1838 /* Strip now if it was requested on the command line. */
1841 char **real_strip_argv = XCNEWVEC (char *, 3);
1842 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1845 strip_argv[0] = strip_file_name;
1846 strip_argv[1] = output_file;
1847 strip_argv[2] = (char *) 0;
1848 fork_execute ("strip", real_strip_argv);
1851 #ifdef COLLECT_EXPORT_LIST
1852 maybe_unlink (export_file);
1854 maybe_unlink (c_file);
1855 maybe_unlink (o_file);
1859 /* Sort ctor and dtor lists by priority. */
1860 sort_ids (&constructors);
1861 sort_ids (&destructors);
1863 maybe_unlink(output_file);
1864 outf = fopen (c_file, "w");
1865 if (outf == (FILE *) 0)
1866 fatal_perror ("fopen %s", c_file);
1868 write_c_file (outf, c_file);
1871 fatal_perror ("fclose %s", c_file);
1873 /* Tell the linker that we have initializer and finalizer functions. */
1874 #ifdef LD_INIT_SWITCH
1875 #ifdef COLLECT_EXPORT_LIST
1876 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1878 *ld2++ = LD_INIT_SWITCH;
1880 *ld2++ = LD_FINI_SWITCH;
1885 #ifdef COLLECT_EXPORT_LIST
1888 /* If we did not add export flag to link arguments before, add it to
1889 second link phase now. No new exports should have been added. */
1890 if (! exports.first)
1891 *ld2++ = concat ("-bE:", export_file, NULL);
1893 #ifndef LD_INIT_SWITCH
1894 add_to_list (&exports, initname);
1895 add_to_list (&exports, fininame);
1896 add_to_list (&exports, "_GLOBAL__DI");
1897 add_to_list (&exports, "_GLOBAL__DD");
1899 exportf = fopen (export_file, "w");
1900 if (exportf == (FILE *) 0)
1901 fatal_perror ("fopen %s", export_file);
1902 write_aix_file (exportf, exports.first);
1903 if (fclose (exportf))
1904 fatal_perror ("fclose %s", export_file);
1908 /* End of arguments to second link phase. */
1913 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1914 output_file, c_file);
1915 write_c_file (stderr, "stderr");
1916 fprintf (stderr, "========== end of c_file\n\n");
1917 #ifdef COLLECT_EXPORT_LIST
1918 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1919 write_aix_file (stderr, exports.first);
1920 fprintf (stderr, "========== end of export_file\n\n");
1924 /* Assemble the constructor and destructor tables.
1925 Link the tables in with the rest of the program. */
1927 fork_execute ("gcc", c_argv);
1928 #ifdef COLLECT_EXPORT_LIST
1929 /* On AIX we must call tlink because of possible templates resolution. */
1930 do_tlink (ld2_argv, object_lst);
1933 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1935 /* Otherwise, simply call ld because tlink is already done. */
1937 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1939 fork_execute ("ld", ld2_argv);
1941 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1942 constructors/destructors in shared libraries. */
1943 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1946 maybe_unlink (c_file);
1947 maybe_unlink (o_file);
1949 #ifdef COLLECT_EXPORT_LIST
1950 maybe_unlink (export_file);
1957 /* Wait for a process to finish, and exit if a nonzero status is found. */
1960 collect_wait (const char *prog, struct pex_obj *pex)
1964 if (!pex_get_status (pex, 1, &status))
1965 fatal_perror ("can't get program status");
1970 if (WIFSIGNALED (status))
1972 int sig = WTERMSIG (status);
1973 error ("%s terminated with signal %d [%s]%s",
1974 prog, sig, strsignal(sig),
1975 WCOREDUMP(status) ? ", core dumped" : "");
1976 collect_exit (FATAL_EXIT_CODE);
1979 if (WIFEXITED (status))
1980 return WEXITSTATUS (status);
1986 do_wait (const char *prog, struct pex_obj *pex)
1988 int ret = collect_wait (prog, pex);
1991 error ("%s returned %d exit status", prog, ret);
1997 unlink (response_file);
1998 response_file = NULL;
2003 /* Execute a program, and wait for the reply. */
2006 collect_execute (const char *prog, char **argv, const char *outname,
2007 const char *errname, int flags)
2009 struct pex_obj *pex;
2012 char *response_arg = NULL;
2013 char *response_argv[3] ATTRIBUTE_UNUSED;
2015 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2017 /* If using @file arguments, create a temporary file and put the
2018 contents of argv into it. Then change argv to an array corresponding
2019 to a single argument @FILE, where FILE is the temporary filename. */
2021 char **current_argv = argv + 1;
2022 char *argv0 = argv[0];
2026 /* Note: we assume argv contains at least one element; this is
2029 response_file = make_temp_file ("");
2031 f = fopen (response_file, "w");
2034 fatal ("could not open response file %s", response_file);
2036 status = writeargv (current_argv, f);
2039 fatal ("could not write to response file %s", response_file);
2041 status = fclose (f);
2044 fatal ("could not close response file %s", response_file);
2046 response_arg = concat ("@", response_file, NULL);
2047 response_argv[0] = argv0;
2048 response_argv[1] = response_arg;
2049 response_argv[2] = NULL;
2051 argv = response_argv;
2060 fprintf (stderr, "%s", argv[0]);
2062 notice ("[cannot find %s]", prog);
2064 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2065 fprintf (stderr, " %s", str);
2067 fprintf (stderr, "\n");
2073 /* If we cannot find a program we need, complain error. Do this here
2074 since we might not end up needing something that we could not find. */
2077 fatal ("cannot find '%s'", prog);
2079 pex = pex_init (0, "collect2", NULL);
2081 fatal_perror ("pex_init failed");
2083 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2090 fatal_perror (errmsg);
2097 free (response_arg);
2103 fork_execute (const char *prog, char **argv)
2105 struct pex_obj *pex;
2107 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2108 do_wait (prog, pex);
2111 /* Unlink a file unless we are debugging. */
2114 maybe_unlink (const char *file)
2117 unlink_if_ordinary (file);
2119 notice ("[Leaving %s]\n", file);
2122 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2125 maybe_unlink_list (char **file_list)
2127 char **tmp = file_list;
2130 maybe_unlink (*(tmp++));
2134 static long sequence_number = 0;
2136 /* Add a name to a linked list. */
2139 add_to_list (struct head *head_ptr, const char *name)
2142 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2144 strcpy (newid->name, name);
2146 if (head_ptr->first)
2147 head_ptr->last->next = newid;
2149 head_ptr->first = newid;
2151 /* Check for duplicate symbols. */
2152 for (p = head_ptr->first;
2153 strcmp (name, p->name) != 0;
2158 head_ptr->last->next = 0;
2163 newid->sequence = ++sequence_number;
2164 head_ptr->last = newid;
2168 /* Grab the init priority number from an init function name that
2169 looks like "_GLOBAL_.I.12345.foo". */
2172 extract_init_priority (const char *name)
2176 while (name[pos] == '_')
2178 pos += 10; /* strlen ("GLOBAL__X_") */
2180 /* Extract init_p number from ctor/dtor name. */
2181 pri = atoi (name + pos);
2182 return pri ? pri : DEFAULT_INIT_PRIORITY;
2185 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2186 ctors will be run from right to left, dtors from left to right. */
2189 sort_ids (struct head *head_ptr)
2191 /* id holds the current element to insert. id_next holds the next
2192 element to insert. id_ptr iterates through the already sorted elements
2193 looking for the place to insert id. */
2194 struct id *id, *id_next, **id_ptr;
2196 id = head_ptr->first;
2198 /* We don't have any sorted elements yet. */
2199 head_ptr->first = NULL;
2201 for (; id; id = id_next)
2204 id->sequence = extract_init_priority (id->name);
2206 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2208 /* If the sequence numbers are the same, we put the id from the
2209 file later on the command line later in the list. */
2210 || id->sequence > (*id_ptr)->sequence
2211 /* Hack: do lexical compare, too.
2212 || (id->sequence == (*id_ptr)->sequence
2213 && strcmp (id->name, (*id_ptr)->name) > 0) */
2222 /* Now set the sequence numbers properly so write_c_file works. */
2223 for (id = head_ptr->first; id; id = id->next)
2224 id->sequence = ++sequence_number;
2227 /* Write: `prefix', the names on list LIST, `suffix'. */
2230 write_list (FILE *stream, const char *prefix, struct id *list)
2234 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2239 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2240 /* Given a STRING, return nonzero if it occurs in the list in range
2241 [ARGS_BEGIN,ARGS_END). */
2244 is_in_args (const char *string, const char **args_begin,
2245 const char **args_end)
2247 const char **args_pointer;
2248 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2249 if (strcmp (string, *args_pointer) == 0)
2253 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2255 #ifdef COLLECT_EXPORT_LIST
2256 /* This function is really used only on AIX, but may be useful. */
2259 is_in_list (const char *prefix, struct id *list)
2263 if (!strcmp (prefix, list->name)) return 1;
2269 #endif /* COLLECT_EXPORT_LIST */
2271 /* Added for debugging purpose. */
2272 #ifdef COLLECT_EXPORT_LIST
2274 dump_list (FILE *stream, const char *prefix, struct id *list)
2278 fprintf (stream, "%s%s,\n", prefix, list->name);
2286 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2290 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2297 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2301 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2302 prefix, list->sequence, list->name);
2307 /* Write out the constructor and destructor tables statically (for a shared
2308 object), along with the functions to execute them. */
2311 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2315 int frames = (frame_tables.number > 0);
2317 /* Figure out name of output_file, stripping off .so version. */
2318 p = strrchr (output_file, '/');
2334 if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2336 q += strlen (SHLIB_SUFFIX);
2343 /* q points to null at end of the string (or . of the .so version) */
2344 prefix = XNEWVEC (char, q - p + 1);
2345 strncpy (prefix, p, q - p);
2347 for (r = prefix; *r; r++)
2348 if (!ISALNUM ((unsigned char)*r))
2351 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2352 output_file, prefix);
2354 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2355 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2359 /* Write the tables as C code. */
2361 fprintf (stream, "static int count;\n");
2362 fprintf (stream, "typedef void entry_pt();\n");
2363 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2367 write_list_with_asm (stream, "extern void *", frame_tables.first);
2369 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2370 write_list (stream, "\t\t&", frame_tables.first);
2371 fprintf (stream, "\t0\n};\n");
2373 /* This must match what's in frame.h. */
2374 fprintf (stream, "struct object {\n");
2375 fprintf (stream, " void *pc_begin;\n");
2376 fprintf (stream, " void *pc_end;\n");
2377 fprintf (stream, " void *fde_begin;\n");
2378 fprintf (stream, " void *fde_array;\n");
2379 fprintf (stream, " __SIZE_TYPE__ count;\n");
2380 fprintf (stream, " struct object *next;\n");
2381 fprintf (stream, "};\n");
2383 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2384 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2386 fprintf (stream, "static void reg_frame () {\n");
2387 fprintf (stream, "\tstatic struct object ob;\n");
2388 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2389 fprintf (stream, "\t}\n");
2391 fprintf (stream, "static void dereg_frame () {\n");
2392 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2393 fprintf (stream, "\t}\n");
2396 fprintf (stream, "void %s() {\n", initname);
2397 if (constructors.number > 0 || frames)
2399 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2400 write_list (stream, "\t\t", constructors.first);
2402 fprintf (stream, "\treg_frame,\n");
2403 fprintf (stream, "\t};\n");
2404 fprintf (stream, "\tentry_pt **p;\n");
2405 fprintf (stream, "\tif (count++ != 0) return;\n");
2406 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2407 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2410 fprintf (stream, "\t++count;\n");
2411 fprintf (stream, "}\n");
2412 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2413 fprintf (stream, "void %s() {\n", fininame);
2414 if (destructors.number > 0 || frames)
2416 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2417 write_list (stream, "\t\t", destructors.first);
2419 fprintf (stream, "\tdereg_frame,\n");
2420 fprintf (stream, "\t};\n");
2421 fprintf (stream, "\tentry_pt **p;\n");
2422 fprintf (stream, "\tif (--count != 0) return;\n");
2423 fprintf (stream, "\tp = dtors;\n");
2424 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2425 destructors.number + frames);
2427 fprintf (stream, "}\n");
2431 COLLECT_SHARED_INIT_FUNC(stream, initname);
2432 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2436 /* Write the constructor/destructor tables. */
2438 #ifndef LD_INIT_SWITCH
2440 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2442 /* Write the tables as C code. */
2444 int frames = (frame_tables.number > 0);
2446 fprintf (stream, "typedef void entry_pt();\n\n");
2448 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2452 write_list_with_asm (stream, "extern void *", frame_tables.first);
2454 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2455 write_list (stream, "\t\t&", frame_tables.first);
2456 fprintf (stream, "\t0\n};\n");
2458 /* This must match what's in frame.h. */
2459 fprintf (stream, "struct object {\n");
2460 fprintf (stream, " void *pc_begin;\n");
2461 fprintf (stream, " void *pc_end;\n");
2462 fprintf (stream, " void *fde_begin;\n");
2463 fprintf (stream, " void *fde_array;\n");
2464 fprintf (stream, " __SIZE_TYPE__ count;\n");
2465 fprintf (stream, " struct object *next;\n");
2466 fprintf (stream, "};\n");
2468 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2469 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2471 fprintf (stream, "static void reg_frame () {\n");
2472 fprintf (stream, "\tstatic struct object ob;\n");
2473 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2474 fprintf (stream, "\t}\n");
2476 fprintf (stream, "static void dereg_frame () {\n");
2477 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2478 fprintf (stream, "\t}\n");
2481 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2482 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2483 write_list (stream, "\t", constructors.first);
2485 fprintf (stream, "\treg_frame,\n");
2486 fprintf (stream, "\t0\n};\n\n");
2488 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2490 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2491 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2492 write_list (stream, "\t", destructors.first);
2494 fprintf (stream, "\tdereg_frame,\n");
2495 fprintf (stream, "\t0\n};\n\n");
2497 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2498 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2500 #endif /* ! LD_INIT_SWITCH */
2503 write_c_file (FILE *stream, const char *name)
2505 #ifndef LD_INIT_SWITCH
2507 write_c_file_glob (stream, name);
2510 write_c_file_stat (stream, name);
2513 #ifdef COLLECT_EXPORT_LIST
2515 write_aix_file (FILE *stream, struct id *list)
2517 for (; list; list = list->next)
2519 fputs (list->name, stream);
2520 putc ('\n', stream);
2525 #ifdef OBJECT_FORMAT_NONE
2527 /* Check to make sure the file is an LTO object file. */
2530 maybe_lto_object_file (const char *prog_name)
2533 unsigned char buf[4];
2536 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2537 static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2538 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2539 static unsigned char machomagic[4][4] = {
2540 { 0xcf, 0xfa, 0xed, 0xfe },
2541 { 0xce, 0xfa, 0xed, 0xfe },
2542 { 0xfe, 0xed, 0xfa, 0xcf },
2543 { 0xfe, 0xed, 0xfa, 0xce }
2546 f = fopen (prog_name, "rb");
2549 if (fread (buf, sizeof (buf), 1, f) != 1)
2553 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2554 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2555 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2557 for (i = 0; i < 4; i++)
2558 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2564 /* Generic version to scan the name list of the loaded program for
2565 the symbols g++ uses for static constructors and destructors. */
2568 scan_prog_file (const char *prog_name, scanpass which_pass,
2571 void (*int_handler) (int);
2573 void (*quit_handler) (int);
2575 char *real_nm_argv[4];
2576 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2578 struct pex_obj *pex;
2585 if (which_pass == PASS_SECOND)
2588 /* LTO objects must be in a known format. This check prevents
2589 us from accepting an archive containing LTO objects, which
2590 gcc cannnot currently handle. */
2591 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2594 /* If we do not have an `nm', complain. */
2595 if (nm_file_name == 0)
2596 fatal ("cannot find 'nm'");
2598 nm_argv[argc++] = nm_file_name;
2599 if (NM_FLAGS[0] != '\0')
2600 nm_argv[argc++] = NM_FLAGS;
2602 nm_argv[argc++] = prog_name;
2603 nm_argv[argc++] = (char *) 0;
2605 /* Trace if needed. */
2608 const char **p_argv;
2611 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2612 fprintf (stderr, " %s", str);
2614 fprintf (stderr, "\n");
2620 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2622 fatal_perror ("pex_init failed");
2624 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2631 fatal_perror (errmsg);
2637 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2639 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2642 inf = pex_read_output (pex, 0);
2644 fatal_perror ("can't open nm output");
2648 if (which_pass == PASS_LTOINFO)
2649 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2651 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2654 /* Read each line of nm output. */
2655 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2661 fprintf (stderr, "\t%s\n", buf);
2663 if (which_pass == PASS_LTOINFO)
2668 /* Look for the LTO info marker symbol, and add filename to
2669 the LTO objects list if found. */
2670 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2671 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2672 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2673 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2675 add_lto_object (<o_objects, prog_name);
2677 /* We need to read all the input, so we can't just
2678 return here. But we can avoid useless work. */
2687 /* If it contains a constructor or destructor name, add the name
2688 to the appropriate list unless this is a kind of symbol we're
2689 not supposed to even consider. */
2691 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2692 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2699 /* Find the end of the symbol name.
2700 Do not include `|', because Encore nm can tack that on the end. */
2701 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2707 switch (is_ctor_dtor (name))
2710 if (! (filter & SCAN_CTOR))
2712 if (which_pass != PASS_LIB)
2713 add_to_list (&constructors, name);
2717 if (! (filter & SCAN_DTOR))
2719 if (which_pass != PASS_LIB)
2720 add_to_list (&destructors, name);
2724 if (! (filter & SCAN_INIT))
2726 if (which_pass != PASS_LIB)
2727 fatal ("init function found in object %s", prog_name);
2728 #ifndef LD_INIT_SWITCH
2729 add_to_list (&constructors, name);
2734 if (! (filter & SCAN_FINI))
2736 if (which_pass != PASS_LIB)
2737 fatal ("fini function found in object %s", prog_name);
2738 #ifndef LD_FINI_SWITCH
2739 add_to_list (&destructors, name);
2744 if (! (filter & SCAN_DWEH))
2746 if (which_pass != PASS_LIB)
2747 add_to_list (&frame_tables, name);
2750 default: /* not a constructor or destructor */
2756 fprintf (stderr, "\n");
2758 do_wait (nm_file_name, pex);
2760 signal (SIGINT, int_handler);
2762 signal (SIGQUIT, quit_handler);
2768 /* Use the List Dynamic Dependencies program to find shared libraries that
2769 the output file depends upon and their initialization/finalization
2770 routines, if any. */
2773 scan_libraries (const char *prog_name)
2775 static struct head libraries; /* list of shared libraries found */
2777 void (*int_handler) (int);
2779 void (*quit_handler) (int);
2781 char *real_ldd_argv[4];
2782 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2784 struct pex_obj *pex;
2790 /* If we do not have an `ldd', complain. */
2791 if (ldd_file_name == 0)
2793 error ("cannot find 'ldd'");
2797 ldd_argv[argc++] = ldd_file_name;
2798 ldd_argv[argc++] = prog_name;
2799 ldd_argv[argc++] = (char *) 0;
2801 /* Trace if needed. */
2804 const char **p_argv;
2807 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2808 fprintf (stderr, " %s", str);
2810 fprintf (stderr, "\n");
2816 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2818 fatal_perror ("pex_init failed");
2820 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2826 fatal_perror (errmsg);
2832 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2834 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2837 inf = pex_read_output (pex, 0);
2839 fatal_perror ("can't open ldd output");
2842 notice ("\nldd output with constructors/destructors.\n");
2844 /* Read each line of ldd output. */
2845 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2848 char *name, *end, *p = buf;
2850 /* Extract names of libraries and add to list. */
2851 PARSE_LDD_OUTPUT (p);
2856 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2857 fatal ("dynamic dependency %s not found", buf);
2859 /* Find the end of the symbol name. */
2861 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2866 if (access (name, R_OK) == 0)
2867 add_to_list (&libraries, name);
2869 fatal ("unable to open dynamic dependency '%s'", buf);
2872 fprintf (stderr, "\t%s\n", buf);
2875 fprintf (stderr, "\n");
2877 do_wait (ldd_file_name, pex);
2879 signal (SIGINT, int_handler);
2881 signal (SIGQUIT, quit_handler);
2884 /* Now iterate through the library list adding their symbols to
2886 for (list = libraries.first; list; list = list->next)
2887 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2890 #endif /* LDD_SUFFIX */
2892 #endif /* OBJECT_FORMAT_NONE */
2896 * COFF specific stuff.
2899 #ifdef OBJECT_FORMAT_COFF
2901 #if defined (EXTENDED_COFF)
2903 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2904 # define GCC_SYMENT SYMR
2905 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2906 # define GCC_SYMINC(X) (1)
2907 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2908 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2912 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2913 # define GCC_SYMENT SYMENT
2914 # if defined (C_WEAKEXT)
2915 # define GCC_OK_SYMBOL(X) \
2916 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2917 ((X).n_scnum > N_UNDEF) && \
2919 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2920 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2921 # define GCC_UNDEF_SYMBOL(X) \
2922 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2923 ((X).n_scnum == N_UNDEF))
2925 # define GCC_OK_SYMBOL(X) \
2926 (((X).n_sclass == C_EXT) && \
2927 ((X).n_scnum > N_UNDEF) && \
2929 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2930 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2931 # define GCC_UNDEF_SYMBOL(X) \
2932 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2934 # define GCC_SYMINC(X) ((X).n_numaux+1)
2935 # define GCC_SYMZERO(X) 0
2937 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2938 #if TARGET_AIX_VERSION >= 51
2939 # define GCC_CHECK_HDR(X) \
2940 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2941 || (HEADER (X).f_magic == 0767 && aix64_flag))
2943 # define GCC_CHECK_HDR(X) \
2944 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2945 || (HEADER (X).f_magic == 0757 && aix64_flag))
2950 #ifdef COLLECT_EXPORT_LIST
2951 /* Array of standard AIX libraries which should not
2952 be scanned for ctors/dtors. */
2953 static const char *const aix_std_libs[] = {
2961 "/usr/lib/libc_r.a",
2962 "/usr/lib/libm_r.a",
2963 "/usr/lib/threads/libc.a",
2964 "/usr/ccs/lib/libc.a",
2965 "/usr/ccs/lib/libm.a",
2966 "/usr/ccs/lib/libc_r.a",
2967 "/usr/ccs/lib/libm_r.a",
2971 /* This function checks the filename and returns 1
2972 if this name matches the location of a standard AIX library. */
2973 static int ignore_library (const char *);
2975 ignore_library (const char *name)
2977 const char *const *p;
2980 if (target_system_root[0] != '\0')
2982 length = strlen (target_system_root);
2983 if (strncmp (name, target_system_root, length) != 0)
2987 for (p = &aix_std_libs[0]; *p != NULL; ++p)
2988 if (strcmp (name, *p) == 0)
2992 #endif /* COLLECT_EXPORT_LIST */
2994 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2995 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2998 /* COFF version to scan the name list of the loaded program for
2999 the symbols g++ uses for static constructors and destructors. */
3002 scan_prog_file (const char *prog_name, scanpass which_pass,
3005 LDFILE *ldptr = NULL;
3006 int sym_index, sym_count;
3009 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3012 #ifdef COLLECT_EXPORT_LIST
3013 /* We do not need scanning for some standard C libraries. */
3014 if (which_pass == PASS_FIRST && ignore_library (prog_name))
3017 /* On AIX we have a loop, because there is not much difference
3018 between an object and an archive. This trick allows us to
3019 eliminate scan_libraries() function. */
3023 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3024 non-const char * filename parameter, even though it will not
3025 modify that string. So we must cast away const-ness here,
3026 using CONST_CAST to prevent complaints from -Wcast-qual. */
3027 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3029 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3030 fatal ("%s: not a COFF file", prog_name);
3032 if (GCC_CHECK_HDR (ldptr))
3034 sym_count = GCC_SYMBOLS (ldptr);
3035 sym_index = GCC_SYMZERO (ldptr);
3037 #ifdef COLLECT_EXPORT_LIST
3038 /* Is current archive member a shared object? */
3039 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3042 while (sym_index < sym_count)
3046 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3048 sym_index += GCC_SYMINC (symbol);
3050 if (GCC_OK_SYMBOL (symbol))
3054 if ((name = ldgetname (ldptr, &symbol)) == NULL)
3055 continue; /* Should never happen. */
3057 #ifdef XCOFF_DEBUGGING_INFO
3058 /* All AIX function names have a duplicate entry
3059 beginning with a dot. */
3064 switch (is_ctor_dtor (name))
3067 if (! (filter & SCAN_CTOR))
3070 add_to_list (&constructors, name);
3071 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3072 if (which_pass == PASS_OBJ)
3073 add_to_list (&exports, name);
3078 if (! (filter & SCAN_DTOR))
3081 add_to_list (&destructors, name);
3082 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3083 if (which_pass == PASS_OBJ)
3084 add_to_list (&exports, name);
3088 #ifdef COLLECT_EXPORT_LIST
3090 if (! (filter & SCAN_INIT))
3092 #ifndef LD_INIT_SWITCH
3094 add_to_list (&constructors, name);
3099 if (! (filter & SCAN_FINI))
3101 #ifndef LD_INIT_SWITCH
3103 add_to_list (&destructors, name);
3109 if (! (filter & SCAN_DWEH))
3112 add_to_list (&frame_tables, name);
3113 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3114 if (which_pass == PASS_OBJ)
3115 add_to_list (&exports, name);
3119 default: /* not a constructor or destructor */
3120 #ifdef COLLECT_EXPORT_LIST
3121 /* Explicitly export all global symbols when
3122 building a shared object on AIX, but do not
3123 re-export symbols from another shared object
3124 and do not export symbols if the user
3125 provides an explicit export list. */
3126 if (shared_obj && !is_shared
3127 && which_pass == PASS_OBJ && !export_flag)
3128 add_to_list (&exports, name);
3134 #if !defined(EXTENDED_COFF)
3135 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3136 symbol.n_scnum, symbol.n_sclass,
3137 (symbol.n_type ? "0" : ""), symbol.n_type,
3141 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3142 symbol.iss, (long) symbol.value, symbol.index, name);
3147 #ifdef COLLECT_EXPORT_LIST
3150 /* If archive contains both 32-bit and 64-bit objects,
3151 we want to skip objects in other mode so mismatch normal. */
3153 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3154 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3160 fatal ("%s: cannot open as COFF file", prog_name);
3162 #ifdef COLLECT_EXPORT_LIST
3163 /* On AIX loop continues while there are more members in archive. */
3165 while (ldclose (ldptr) == FAILURE);
3167 /* Otherwise we simply close ldptr. */
3168 (void) ldclose(ldptr);
3171 #endif /* OBJECT_FORMAT_COFF */
3173 #ifdef COLLECT_EXPORT_LIST
3174 /* Given a library name without "lib" prefix, this function
3175 returns a full library name including a path. */
3177 resolve_lib_name (const char *name)
3181 /* Library extensions for AIX dynamic linking. */
3182 const char * const libexts[2] = {"a", "so"};
3184 for (i = 0; libpaths[i]; i++)
3185 if (libpaths[i]->max_len > l)
3186 l = libpaths[i]->max_len;
3188 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3190 for (i = 0; libpaths[i]; i++)
3192 struct prefix_list *list = libpaths[i]->plist;
3193 for (; list; list = list->next)
3195 /* The following lines are needed because path_prefix list
3196 may contain directories both with trailing '/' and
3199 if (list->prefix[strlen(list->prefix)-1] != '/')
3201 for (j = 0; j < 2; j++)
3203 sprintf (lib_buf, "%s%slib%s.%s",
3204 list->prefix, p, name,
3205 libexts[(j + aixrtl_flag) % 2]);
3206 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3207 if (file_exists (lib_buf))
3209 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3216 fprintf (stderr, "not found\n");
3218 fatal ("library lib%s not found", name);
3221 #endif /* COLLECT_EXPORT_LIST */