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 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
45 #include "collect2-aix.h"
51 /* On certain systems, we have code that works by scanning the object file
52 directly. But this code uses system-specific header files and library
53 functions, so turn it off in a cross-compiler. Likewise, the names of
54 the utilities are not correct for a cross-compiler; we have to hope that
55 cross-versions are in the proper directories. */
57 #ifdef CROSS_DIRECTORY_STRUCTURE
58 #ifndef CROSS_AIX_SUPPORT
59 #undef OBJECT_FORMAT_COFF
62 #undef REAL_LD_FILE_NAME
63 #undef REAL_NM_FILE_NAME
64 #undef REAL_STRIP_FILE_NAME
67 /* If we cannot use a special method, use the ordinary one:
68 run nm to find what symbols are present.
69 In a cross-compiler, this means you need a cross nm,
70 but that is not quite as unpleasant as special headers. */
72 #if !defined (OBJECT_FORMAT_COFF)
73 #define OBJECT_FORMAT_NONE
76 #ifdef OBJECT_FORMAT_COFF
78 #ifndef CROSS_DIRECTORY_STRUCTURE
86 /* Many versions of ldfcn.h define these. */
95 /* Some systems have an ISCOFF macro, but others do not. In some cases
96 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
97 that either do not have an ISCOFF macro in /usr/include or for those
101 #define MY_ISCOFF(X) ISCOFF (X)
104 #endif /* OBJECT_FORMAT_COFF */
106 #ifdef OBJECT_FORMAT_NONE
108 /* Default flags to pass to nm. */
110 #define NM_FLAGS "-n"
113 #endif /* OBJECT_FORMAT_NONE */
115 /* Some systems use __main in a way incompatible with its use in gcc, in these
116 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
117 give the same symbol without quotes for an alternative entry point. */
119 #define NAME__MAIN "__main"
122 /* This must match tree.h. */
123 #define DEFAULT_INIT_PRIORITY 65535
125 #ifndef COLLECT_SHARED_INIT_FUNC
126 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
127 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
129 #ifndef COLLECT_SHARED_FINI_FUNC
130 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
135 #define SCAN_LIBRARIES
139 #define SHLIB_SUFFIX ".so"
143 int do_collecting = 1;
145 int do_collecting = 0;
148 /* Cook up an always defined indication of whether we proceed the
149 "EXPORT_LIST" way. */
151 #ifdef COLLECT_EXPORT_LIST
152 #define DO_COLLECT_EXPORT_LIST 1
154 #define DO_COLLECT_EXPORT_LIST 0
157 /* Nonzero if we should suppress the automatic demangling of identifiers
158 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
161 /* Linked lists of constructor and destructor names. */
177 bool vflag; /* true if -v or --version */
178 static int rflag; /* true if -r */
179 static int strip_flag; /* true if -s */
180 static const char *demangle_flag;
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag; /* true if -bE */
183 static int aix64_flag; /* true if -b64 */
184 static int aixrtl_flag; /* true if -brtl */
188 LTO_MODE_NONE, /* Not doing LTO. */
189 LTO_MODE_LTO, /* Normal LTO. */
190 LTO_MODE_WHOPR /* WHOPR. */
193 /* Current LTO mode. */
194 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
196 bool debug; /* true if -debug */
197 bool helpflag; /* true if --help */
199 static int shared_obj; /* true if -shared */
201 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
202 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
203 #ifdef COLLECT_EXPORT_LIST
204 static const char *export_file; /* <xxx>.x for AIX export list. */
206 static char **lto_o_files; /* Output files for LTO. */
207 const char *ldout; /* File for ld stdout. */
208 const char *lderrout; /* File for ld stderr. */
209 static const char *output_file; /* Output file for ld. */
210 static const char *nm_file_name; /* pathname of nm */
212 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
214 static const char *strip_file_name; /* pathname of strip */
215 const char *c_file_name; /* pathname of gcc */
216 static char *initname, *fininame; /* names of init and fini funcs */
218 static struct head constructors; /* list of constructors found */
219 static struct head destructors; /* list of destructors found */
220 #ifdef COLLECT_EXPORT_LIST
221 static struct head exports; /* list of exported symbols */
223 static struct head frame_tables; /* list of frame unwind info tables */
225 static bool at_file_supplied; /* Whether to use @file arguments */
226 static char *response_file; /* Name of any current response file */
228 struct obstack temporary_obstack;
229 char * temporary_firstobj;
231 /* A string that must be prepended to a target OS path in order to find
232 it on the host system. */
233 #ifdef TARGET_SYSTEM_ROOT
234 static const char *target_system_root = TARGET_SYSTEM_ROOT;
236 static const char *target_system_root = "";
239 /* Structure to hold all the directories in which to search for files to
244 const char *prefix; /* String to prepend to the path. */
245 struct prefix_list *next; /* Next in linked list. */
250 struct prefix_list *plist; /* List of prefixes to try */
251 int max_len; /* Max length of a prefix in PLIST */
252 const char *name; /* Name of this list (used in config stuff) */
255 #ifdef COLLECT_EXPORT_LIST
256 /* Lists to keep libraries to be scanned for global constructors/destructors. */
257 static struct head libs; /* list of libraries */
258 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
259 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
260 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
261 &libpath_lib_dirs, NULL};
264 /* List of names of object files containing LTO information.
265 These are a subset of the object file names appearing on the
266 command line, and must be identical, in the sense of pointer
267 equality, with the names passed to maybe_run_lto_and_relink(). */
271 const char *name; /* Name of object file. */
272 struct lto_object *next; /* Next in linked list. */
275 struct lto_object_list
277 struct lto_object *first; /* First list element. */
278 struct lto_object *last; /* Last list element. */
281 static struct lto_object_list lto_objects;
283 /* Special kinds of symbols that a name may denote. */
286 SYM_REGULAR = 0, /* nothing special */
288 SYM_CTOR = 1, /* constructor */
289 SYM_DTOR = 2, /* destructor */
290 SYM_INIT = 3, /* shared object routine that calls all the ctors */
291 SYM_FINI = 4, /* shared object routine that calls all the dtors */
292 SYM_DWEH = 5 /* DWARF exception handling table */
295 static symkind is_ctor_dtor (const char *);
297 static void handler (int);
298 static char *find_a_file (struct path_prefix *, const char *);
299 static void add_prefix (struct path_prefix *, const char *);
300 static void prefix_from_env (const char *, struct path_prefix *);
301 static void prefix_from_string (const char *, struct path_prefix *);
302 static void do_wait (const char *, struct pex_obj *);
303 static void fork_execute (const char *, char **);
304 static void maybe_unlink (const char *);
305 static void maybe_unlink_list (char **);
306 static void add_to_list (struct head *, const char *);
307 static int extract_init_priority (const char *);
308 static void sort_ids (struct head *);
309 static void write_list (FILE *, const char *, struct id *);
310 #ifdef COLLECT_EXPORT_LIST
311 static void dump_list (FILE *, const char *, struct id *);
314 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
316 static void write_list_with_asm (FILE *, const char *, struct id *);
317 static void write_c_file (FILE *, const char *);
318 static void write_c_file_stat (FILE *, const char *);
319 #ifndef LD_INIT_SWITCH
320 static void write_c_file_glob (FILE *, const char *);
322 #ifdef SCAN_LIBRARIES
323 static void scan_libraries (const char *);
325 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
326 static int is_in_args (const char *, const char **, const char **);
328 #ifdef COLLECT_EXPORT_LIST
330 static int is_in_list (const char *, struct id *);
332 static void write_aix_file (FILE *, struct id *);
333 static char *resolve_lib_name (const char *);
335 static char *extract_string (const char **);
336 static void post_ld_pass (bool);
337 static void process_args (int *argcp, char **argv);
339 /* Enumerations describing which pass this is for scanning the
343 PASS_FIRST, /* without constructors */
344 PASS_OBJ, /* individual objects */
345 PASS_LIB, /* looking for shared libraries */
346 PASS_SECOND, /* with constructors linked in */
347 PASS_LTOINFO /* looking for objects with LTO info */
350 /* ... and which kinds of symbols are to be considered. */
352 enum scanfilter_masks {
355 SCAN_CTOR = 1 << SYM_CTOR,
356 SCAN_DTOR = 1 << SYM_DTOR,
357 SCAN_INIT = 1 << SYM_INIT,
358 SCAN_FINI = 1 << SYM_FINI,
359 SCAN_DWEH = 1 << SYM_DWEH,
363 /* This type is used for parameters and variables which hold
364 combinations of the flags in enum scanfilter_masks. */
365 typedef int scanfilter;
367 /* Scan the name list of the loaded program for the symbols g++ uses for
368 static constructors and destructors.
370 The SCANPASS argument tells which collect processing pass this is for and
371 the SCANFILTER argument tells which kinds of symbols to consider in this
372 pass. Symbols of a special kind not in the filter mask are considered as
375 The constructor table begins at __CTOR_LIST__ and contains a count of the
376 number of pointers (or -1 if the constructors are built in a separate
377 section by the linker), followed by the pointers to the constructor
378 functions, terminated with a null pointer. The destructor table has the
379 same format, and begins at __DTOR_LIST__. */
381 static void scan_prog_file (const char *, scanpass, scanfilter);
384 /* Delete tempfiles and exit function. */
387 collect_exit (int status)
389 if (c_file != 0 && c_file[0])
390 maybe_unlink (c_file);
392 if (o_file != 0 && o_file[0])
393 maybe_unlink (o_file);
395 #ifdef COLLECT_EXPORT_LIST
396 if (export_file != 0 && export_file[0])
397 maybe_unlink (export_file);
401 maybe_unlink_list (lto_o_files);
403 if (ldout != 0 && ldout[0])
405 dump_file (ldout, stdout);
406 maybe_unlink (ldout);
409 if (lderrout != 0 && lderrout[0])
411 dump_file (lderrout, stderr);
412 maybe_unlink (lderrout);
415 if (status != 0 && output_file != 0 && output_file[0])
416 maybe_unlink (output_file);
419 maybe_unlink (response_file);
425 /* Notify user of a non-error. */
427 notice (const char *cmsgid, ...)
431 va_start (ap, cmsgid);
432 vfprintf (stderr, _(cmsgid), ap);
436 /* Notify user of a non-error, without translating the format string. */
438 notice_translated (const char *cmsgid, ...)
442 va_start (ap, cmsgid);
443 vfprintf (stderr, cmsgid, ap);
447 /* Die when sys call fails. */
450 fatal_perror (const char * cmsgid, ...)
455 va_start (ap, cmsgid);
456 fprintf (stderr, "collect2: ");
457 vfprintf (stderr, _(cmsgid), ap);
458 fprintf (stderr, ": %s\n", xstrerror (e));
461 collect_exit (FATAL_EXIT_CODE);
467 fatal (const char * cmsgid, ...)
471 va_start (ap, cmsgid);
472 fprintf (stderr, "collect2: ");
473 vfprintf (stderr, _(cmsgid), ap);
474 fprintf (stderr, "\n");
477 collect_exit (FATAL_EXIT_CODE);
480 /* Write error message. */
483 error (const char * gmsgid, ...)
487 va_start (ap, gmsgid);
488 fprintf (stderr, "collect2: ");
489 vfprintf (stderr, _(gmsgid), ap);
490 fprintf (stderr, "\n");
494 /* In case obstack is linked in, and abort is defined to fancy_abort,
495 provide a default entry. */
498 fancy_abort (const char *file, int line, const char *func)
500 fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
506 if (c_file != 0 && c_file[0])
507 maybe_unlink (c_file);
509 if (o_file != 0 && o_file[0])
510 maybe_unlink (o_file);
512 if (ldout != 0 && ldout[0])
513 maybe_unlink (ldout);
515 if (lderrout != 0 && lderrout[0])
516 maybe_unlink (lderrout);
518 #ifdef COLLECT_EXPORT_LIST
519 if (export_file != 0 && export_file[0])
520 maybe_unlink (export_file);
524 maybe_unlink_list (lto_o_files);
527 maybe_unlink (response_file);
529 signal (signo, SIG_DFL);
535 file_exists (const char *name)
537 return access (name, R_OK) == 0;
540 /* Parse a reasonable subset of shell quoting syntax. */
543 extract_string (const char **pp)
556 obstack_1grow (&temporary_obstack, c);
557 else if (! inside && c == ' ')
559 else if (! inside && c == '\\')
564 obstack_1grow (&temporary_obstack, c);
567 obstack_1grow (&temporary_obstack, '\0');
569 return XOBFINISH (&temporary_obstack, char *);
573 dump_file (const char *name, FILE *to)
575 FILE *stream = fopen (name, "r");
582 while (c = getc (stream),
583 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
584 obstack_1grow (&temporary_obstack, c);
585 if (obstack_object_size (&temporary_obstack) > 0)
587 const char *word, *p;
589 obstack_1grow (&temporary_obstack, '\0');
590 word = XOBFINISH (&temporary_obstack, const char *);
593 ++word, putc ('.', to);
595 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
596 p += strlen (USER_LABEL_PREFIX);
598 #ifdef HAVE_LD_DEMANGLE
604 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
612 diff = strlen (word) - strlen (result);
613 while (diff > 0 && c == ' ')
614 --diff, putc (' ', to);
615 if (diff < 0 && c == ' ')
617 while (diff < 0 && c == ' ')
618 ++diff, c = getc (stream);
621 /* Make sure we output at least one space, or
622 the demangled symbol name will run into
623 whatever text follows. */
634 obstack_free (&temporary_obstack, temporary_firstobj);
643 /* Return the kind of symbol denoted by name S. */
646 is_ctor_dtor (const char *s)
648 struct names { const char *const name; const int len; symkind ret;
649 const int two_underscores; };
651 const struct names *p;
653 const char *orig_s = s;
655 static const struct names special[] = {
656 #ifndef NO_DOLLAR_IN_LABEL
657 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
658 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
660 #ifndef NO_DOT_IN_LABEL
661 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
662 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
663 #endif /* NO_DOT_IN_LABEL */
664 #endif /* NO_DOLLAR_IN_LABEL */
665 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
666 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
667 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
668 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
669 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
670 { NULL, 0, SYM_REGULAR, 0 }
673 while ((ch = *s) == '_')
679 for (p = &special[0]; p->len > 0; p++)
682 && (!p->two_underscores || ((s - orig_s) >= 2))
683 && strncmp(s, p->name, p->len) == 0)
691 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
692 and one from the PATH variable. */
694 static struct path_prefix cpath, path;
696 #ifdef CROSS_DIRECTORY_STRUCTURE
697 /* This is the name of the target machine. We use it to form the name
698 of the files to execute. */
700 static const char *const target_machine = TARGET_MACHINE;
703 /* Search for NAME using prefix list PPREFIX. We only look for executable
706 Return 0 if not found, otherwise return its name, allocated with malloc. */
709 find_a_file (struct path_prefix *pprefix, const char *name)
712 struct prefix_list *pl;
713 int len = pprefix->max_len + strlen (name) + 1;
716 fprintf (stderr, "Looking for '%s'\n", name);
718 #ifdef HOST_EXECUTABLE_SUFFIX
719 len += strlen (HOST_EXECUTABLE_SUFFIX);
722 temp = XNEWVEC (char, len);
724 /* Determine the filename to execute (special case for absolute paths). */
726 if (IS_ABSOLUTE_PATH (name))
728 if (access (name, X_OK) == 0)
733 fprintf (stderr, " - found: absolute path\n");
738 #ifdef HOST_EXECUTABLE_SUFFIX
739 /* Some systems have a suffix for executable files.
740 So try appending that. */
742 strcat (temp, HOST_EXECUTABLE_SUFFIX);
744 if (access (temp, X_OK) == 0)
749 fprintf (stderr, " - failed to locate using absolute path\n");
752 for (pl = pprefix->plist; pl; pl = pl->next)
756 strcpy (temp, pl->prefix);
759 if (stat (temp, &st) >= 0
760 && ! S_ISDIR (st.st_mode)
761 && access (temp, X_OK) == 0)
764 #ifdef HOST_EXECUTABLE_SUFFIX
765 /* Some systems have a suffix for executable files.
766 So try appending that. */
767 strcat (temp, HOST_EXECUTABLE_SUFFIX);
769 if (stat (temp, &st) >= 0
770 && ! S_ISDIR (st.st_mode)
771 && access (temp, X_OK) == 0)
776 if (debug && pprefix->plist == NULL)
777 fprintf (stderr, " - failed: no entries in prefix list\n");
783 /* Add an entry for PREFIX to prefix list PPREFIX. */
786 add_prefix (struct path_prefix *pprefix, const char *prefix)
788 struct prefix_list *pl, **prev;
793 for (pl = pprefix->plist; pl->next; pl = pl->next)
798 prev = &pprefix->plist;
800 /* Keep track of the longest prefix. */
802 len = strlen (prefix);
803 if (len > pprefix->max_len)
804 pprefix->max_len = len;
806 pl = XNEW (struct prefix_list);
807 pl->prefix = xstrdup (prefix);
812 pl->next = (struct prefix_list *) 0;
816 /* Take the value of the environment variable ENV, break it into a path, and
817 add of the entries to PPREFIX. */
820 prefix_from_env (const char *env, struct path_prefix *pprefix)
826 prefix_from_string (p, pprefix);
830 prefix_from_string (const char *p, struct path_prefix *pprefix)
832 const char *startp, *endp;
833 char *nstore = XNEWVEC (char, strlen (p) + 3);
836 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
841 if (*endp == PATH_SEPARATOR || *endp == 0)
843 strncpy (nstore, startp, endp-startp);
846 strcpy (nstore, "./");
848 else if (! IS_DIR_SEPARATOR (endp[-1]))
850 nstore[endp-startp] = DIR_SEPARATOR;
851 nstore[endp-startp+1] = 0;
854 nstore[endp-startp] = 0;
857 fprintf (stderr, " - add prefix: %s\n", nstore);
859 add_prefix (pprefix, nstore);
862 endp = startp = endp + 1;
870 #ifdef OBJECT_FORMAT_NONE
872 /* Add an entry for the object file NAME to object file list LIST.
873 New entries are added at the end of the list. The original pointer
874 value of NAME is preserved, i.e., no string copy is performed. */
877 add_lto_object (struct lto_object_list *list, const char *name)
879 struct lto_object *n = XNEW (struct lto_object);
884 list->last->next = n;
890 #endif /* OBJECT_FORMAT_NONE */
893 /* Perform a link-time recompilation and relink if any of the object
894 files contain LTO info. The linker command line LTO_LD_ARGV
895 represents the linker command that would produce a final executable
896 without the use of LTO. OBJECT_LST is a vector of object file names
897 appearing in LTO_LD_ARGV that are to be considerd for link-time
898 recompilation, where OBJECT is a pointer to the last valid element.
899 (This awkward convention avoids an impedance mismatch with the
900 usage of similarly-named variables in main().) The elements of
901 OBJECT_LST must be identical, i.e., pointer equal, to the
902 corresponding arguments in LTO_LD_ARGV.
904 Upon entry, at least one linker run has been performed without the
905 use of any LTO info that might be present. Any recompilations
906 necessary for template instantiations have been performed, and
907 initializer/finalizer tables have been created if needed and
908 included in the linker command line LTO_LD_ARGV. If any of the
909 object files contain LTO info, we run the LTO back end on all such
910 files, and perform the final link with the LTO back end output
911 substituted for the LTO-optimized files. In some cases, a final
912 link with all link-time generated code has already been performed,
913 so there is no need to relink if no LTO info is found. In other
914 cases, our caller has not produced the final executable, and is
915 relying on us to perform the required link whether LTO info is
916 present or not. In that case, the FORCE argument should be true.
917 Note that the linker command line argument LTO_LD_ARGV passed into
918 this function may be modified in place. */
921 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
922 const char **object, bool force)
924 const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
926 int num_lto_c_args = 1; /* Allow space for the terminating NULL. */
928 while (object_file < object)
930 /* If file contains LTO info, add it to the list of LTO objects. */
931 scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
933 /* Increment the argument count by the number of object file arguments
934 we will add. An upper bound suffices, so just count all of the
935 object files regardless of whether they contain LTO info. */
939 if (lto_objects.first)
942 const char **lto_c_ptr;
945 struct lto_object *list;
946 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
948 const char *prog = "lto-wrapper";
949 int lto_ld_argv_size = 0;
950 char **out_lto_ld_argv;
951 int out_lto_ld_argv_size;
955 fatal ("COLLECT_LTO_WRAPPER must be set");
959 /* There is at least one object file containing LTO info,
960 so we need to run the LTO back end and relink.
962 To do so we build updated ld arguments with first
963 LTO object replaced by all partitions and other LTO
966 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
967 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
969 *lto_c_ptr++ = lto_wrapper;
971 /* Add LTO objects to the wrapper command line. */
972 for (list = lto_objects.first; list; list = list->next)
973 *lto_c_ptr++ = list->name;
977 /* Run the LTO back end. */
978 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
985 stream = pex_read_output (pex, 0);
989 while ((c = getc (stream)) != EOF)
991 obstack_1grow (&temporary_obstack, c);
996 lto_o_files = XNEWVEC (char *, num_files + 1);
997 lto_o_files[num_files] = NULL;
998 start = XOBFINISH (&temporary_obstack, char *);
999 for (i = 0; i < num_files; ++i)
1002 while (*end != '\n')
1006 lto_o_files[i] = xstrdup (start);
1011 obstack_free (&temporary_obstack, temporary_firstobj);
1013 do_wait (prog, pex);
1016 /* Compute memory needed for new LD arguments. At most number of original arguemtns
1017 plus number of partitions. */
1018 for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
1020 out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1);
1021 out_lto_ld_argv_size = 0;
1023 /* After running the LTO back end, we will relink, substituting
1024 the LTO output for the object files that we submitted to the
1025 LTO. Here, we modify the linker command line for the relink. */
1027 /* Copy all arguments until we find first LTO file. */
1031 for (list = lto_objects.first; list; list = list->next)
1032 if (*p == list->name) /* Note test for pointer equality! */
1036 out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
1039 /* Now insert all LTO partitions. */
1040 lto_o_ptr = lto_o_files;
1042 out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
1044 /* ... and copy the rest. */
1047 for (list = lto_objects.first; list; list = list->next)
1048 if (*p == list->name) /* Note test for pointer equality! */
1051 out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
1054 out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
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", out_lto_ld_argv);
1059 post_ld_pass (true);
1062 maybe_unlink_list (lto_o_files);
1066 /* Our caller is relying on us to do the link
1067 even though there is no LTO back end work to be done. */
1068 fork_execute ("ld", lto_ld_argv);
1069 post_ld_pass (false);
1076 main (int argc, char **argv)
1078 static const char *const ld_suffix = "ld";
1079 static const char *const plugin_ld_suffix = PLUGIN_LD;
1080 static const char *const real_ld_suffix = "real-ld";
1081 static const char *const collect_ld_suffix = "collect-ld";
1082 static const char *const nm_suffix = "nm";
1083 static const char *const gnm_suffix = "gnm";
1085 static const char *const ldd_suffix = LDD_SUFFIX;
1087 static const char *const strip_suffix = "strip";
1088 static const char *const gstrip_suffix = "gstrip";
1090 #ifdef CROSS_DIRECTORY_STRUCTURE
1091 /* If we look for a program in the compiler directories, we just use
1092 the short name, since these directories are already system-specific.
1093 But it we look for a program in the system directories, we need to
1094 qualify the program name with the target machine. */
1096 const char *const full_ld_suffix =
1097 concat(target_machine, "-", ld_suffix, NULL);
1098 const char *const full_plugin_ld_suffix =
1099 concat(target_machine, "-", plugin_ld_suffix, NULL);
1100 const char *const full_nm_suffix =
1101 concat (target_machine, "-", nm_suffix, NULL);
1102 const char *const full_gnm_suffix =
1103 concat (target_machine, "-", gnm_suffix, NULL);
1105 const char *const full_ldd_suffix =
1106 concat (target_machine, "-", ldd_suffix, NULL);
1108 const char *const full_strip_suffix =
1109 concat (target_machine, "-", strip_suffix, NULL);
1110 const char *const full_gstrip_suffix =
1111 concat (target_machine, "-", gstrip_suffix, NULL);
1113 const char *const full_ld_suffix = ld_suffix;
1114 const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1115 const char *const full_nm_suffix = nm_suffix;
1116 const char *const full_gnm_suffix = gnm_suffix;
1118 const char *const full_ldd_suffix = ldd_suffix;
1120 const char *const full_strip_suffix = strip_suffix;
1121 const char *const full_gstrip_suffix = gstrip_suffix;
1122 #endif /* CROSS_DIRECTORY_STRUCTURE */
1126 #ifdef COLLECT_EXPORT_LIST
1129 const char *ld_file_name;
1135 bool use_plugin = false;
1137 /* The kinds of symbols we will have to consider when scanning the
1138 outcome of a first pass link. This is ALL to start with, then might
1139 be adjusted before getting to the first pass link per se, typically on
1140 AIX where we perform an early scan of objects and libraries to fetch
1141 the list of global ctors/dtors and make sure they are not garbage
1143 scanfilter ld1_filter = SCAN_ALL;
1148 const char **object;
1154 expandargv (&argc, &argv);
1155 if (argv != old_argv)
1156 at_file_supplied = 1;
1158 process_args (&argc, argv);
1160 num_c_args = argc + 9;
1162 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1164 /* Suppress demangling by the real linker, which may be broken. */
1165 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1167 #if defined (COLLECT2_HOST_INITIALIZATION)
1168 /* Perform system dependent initialization, if necessary. */
1169 COLLECT2_HOST_INITIALIZATION;
1173 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1174 receive the signal. A different setting is inheritable */
1175 signal (SIGCHLD, SIG_DFL);
1178 /* Unlock the stdio streams. */
1179 unlock_std_streams ();
1181 gcc_init_libintl ();
1183 /* Do not invoke xcalloc before this point, since locale needs to be
1184 set first, in case a diagnostic is issued. */
1186 ld1_argv = XCNEWVEC (char *, argc + 4);
1187 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1188 ld2_argv = XCNEWVEC (char *, argc + 11);
1189 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1190 object_lst = XCNEWVEC (char *, argc);
1191 object = CONST_CAST2 (const char **, char **, object_lst);
1197 /* Parse command line early for instances of -debug. This allows
1198 the debug flag to be set before functions like find_a_file()
1199 are called. We also look for the -flto or -flto-partition=none flag to know
1200 what LTO mode we are in. */
1203 bool no_partition = false;
1205 for (i = 1; argv[i] != NULL; i ++)
1207 if (! strcmp (argv[i], "-debug"))
1209 else if (! strcmp (argv[i], "-flto-partition=none"))
1210 no_partition = true;
1211 else if ((! strncmp (argv[i], "-flto=", 6)
1212 || ! strcmp (argv[i], "-flto")) && ! use_plugin)
1213 lto_mode = LTO_MODE_WHOPR;
1214 else if (! strcmp (argv[i], "-plugin"))
1217 lto_mode = LTO_MODE_NONE;
1219 #ifdef COLLECT_EXPORT_LIST
1220 /* since -brtl, -bexport, -b64 are not position dependent
1221 also check for them here */
1222 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1225 /* We want to disable automatic exports on AIX when user
1226 explicitly puts an export list in command line */
1227 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1229 else if (arg[2] == '6' && arg[3] == '4')
1231 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1238 lto_mode = LTO_MODE_LTO;
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);
1432 obstack_free (&temporary_obstack, temporary_firstobj);
1433 *c_ptr++ = "-fno-profile-arcs";
1434 *c_ptr++ = "-fno-test-coverage";
1435 *c_ptr++ = "-fno-branch-probabilities";
1436 *c_ptr++ = "-fno-exceptions";
1438 *c_ptr++ = "-fno-whole-program";
1440 /* !!! When GCC calls collect2,
1441 it does not know whether it is calling collect2 or ld.
1442 So collect2 cannot meaningfully understand any options
1443 except those ld understands.
1444 If you propose to make GCC pass some other option,
1445 just imagine what will happen if ld is really ld!!! */
1447 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1448 /* After the first file, put in the c++ rt0. */
1451 #ifdef HAVE_LD_DEMANGLE
1452 if (!demangle_flag && !no_demangle)
1453 demangle_flag = "--demangle";
1455 *ld1++ = *ld2++ = demangle_flag;
1457 while ((arg = *++argv) != (char *) 0)
1459 *ld1++ = *ld2++ = arg;
1466 if (!strcmp (arg, "-debug"))
1468 /* Already parsed. */
1472 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1475 *ld1++ = *ld2++ = *argv;
1480 if (strncmp (arg, "-flto", 5) == 0)
1483 /* Do not pass LTO flag to the linker. */
1487 error ("LTO support has not been enabled in this "
1496 /* place o_file BEFORE this argument! */
1502 #ifdef COLLECT_EXPORT_LIST
1504 /* Resolving full library name. */
1505 const char *s = resolve_lib_name (arg+2);
1507 /* Saving a full library name. */
1508 add_to_list (&libs, s);
1513 #ifdef COLLECT_EXPORT_LIST
1514 /* Saving directories where to search for libraries. */
1516 add_prefix (&cmdline_lib_dirs, arg+2);
1519 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1521 if (is_in_args (arg,
1522 CONST_CAST2 (const char **, char **, ld1_argv),
1526 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1531 output_file = *ld1++ = *ld2++ = *++argv;
1533 output_file = &arg[2];
1542 if (arg[2] == '\0' && do_collecting)
1544 /* We must strip after the nm run, otherwise C++ linking
1545 will not work. Thus we strip in the second ld run, or
1546 else with strip if there is no second ld run. */
1558 if (strcmp (arg, "--no-demangle") == 0)
1560 demangle_flag = arg;
1565 else if (strncmp (arg, "--demangle", 10) == 0)
1567 demangle_flag = arg;
1569 #ifndef HAVE_LD_DEMANGLE
1572 enum demangling_styles style
1573 = cplus_demangle_name_to_style (arg+11);
1574 if (style == unknown_demangling)
1575 error ("unknown demangling style '%s'", arg+11);
1577 current_demangling_style = style;
1583 else if (strncmp (arg, "--sysroot=", 10) == 0)
1584 target_system_root = arg + 10;
1585 else if (strcmp (arg, "--version") == 0)
1587 else if (strcmp (arg, "--help") == 0)
1592 else if ((p = strrchr (arg, '.')) != (char *) 0
1593 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1594 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1595 || strcmp (p, ".obj") == 0))
1604 /* place o_file BEFORE this argument! */
1610 if (p[1] == 'o' || p[1] == 'l')
1612 #ifdef COLLECT_EXPORT_LIST
1613 /* libraries can be specified directly, i.e. without -l flag. */
1616 /* Saving a full library name. */
1617 add_to_list (&libs, arg);
1623 #ifdef COLLECT_EXPORT_LIST
1624 /* This is added only for debugging purposes. */
1627 fprintf (stderr, "List of libraries:\n");
1628 dump_list (stderr, "\t", libs.first);
1631 /* The AIX linker will discard static constructors in object files if
1632 nothing else in the file is referenced, so look at them first. Unless
1633 we are building a shared object, ignore the eh frame tables, as we
1634 would otherwise reference them all, hence drag all the corresponding
1635 objects even if nothing else is referenced. */
1637 const char **export_object_lst
1638 = CONST_CAST2 (const char **, char **, object_lst);
1640 struct id *list = libs.first;
1642 /* Compute the filter to use from the current one, do scan, then adjust
1643 the "current" filter to remove what we just included here. This will
1644 control whether we need a first pass link later on or not, and what
1645 will remain to be scanned there. */
1647 scanfilter this_filter = ld1_filter;
1650 this_filter &= ~SCAN_DWEH;
1653 while (export_object_lst < object)
1654 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1656 for (; list; list = list->next)
1657 scan_prog_file (list->name, PASS_FIRST, this_filter);
1659 ld1_filter = ld1_filter & ~this_filter;
1664 char *buf = concat ("-bE:", export_file, NULL);
1669 exportf = fopen (export_file, "w");
1670 if (exportf == (FILE *) 0)
1671 fatal_perror ("fopen %s", export_file);
1672 write_aix_file (exportf, exports.first);
1673 if (fclose (exportf))
1674 fatal_perror ("fclose %s", export_file);
1679 *c_ptr = *ld1 = *object = (char *) 0;
1683 notice ("collect2 version %s", version_string);
1684 #ifdef TARGET_VERSION
1687 fprintf (stderr, "\n");
1692 printf ("Usage: collect2 [options]\n");
1693 printf (" Wrap linker and generate constructor code if needed.\n");
1694 printf (" Options:\n");
1695 printf (" -debug Enable debug output\n");
1696 printf (" --help Display this information\n");
1697 printf (" -v, --version Display this program's version number\n");
1699 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1700 printf ("Report bugs: %s\n", bug_report_url);
1707 fprintf (stderr, "ld_file_name = %s\n",
1708 (ld_file_name ? ld_file_name : "not found"));
1709 fprintf (stderr, "c_file_name = %s\n",
1710 (c_file_name ? c_file_name : "not found"));
1711 fprintf (stderr, "nm_file_name = %s\n",
1712 (nm_file_name ? nm_file_name : "not found"));
1714 fprintf (stderr, "ldd_file_name = %s\n",
1715 (ldd_file_name ? ldd_file_name : "not found"));
1717 fprintf (stderr, "strip_file_name = %s\n",
1718 (strip_file_name ? strip_file_name : "not found"));
1719 fprintf (stderr, "c_file = %s\n",
1720 (c_file ? c_file : "not found"));
1721 fprintf (stderr, "o_file = %s\n",
1722 (o_file ? o_file : "not found"));
1724 ptr = getenv ("COLLECT_GCC_OPTIONS");
1726 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1728 ptr = getenv ("COLLECT_GCC");
1730 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1732 ptr = getenv ("COMPILER_PATH");
1734 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1736 ptr = getenv (LIBRARY_PATH_ENV);
1738 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1740 fprintf (stderr, "\n");
1743 /* Load the program, searching all libraries and attempting to provide
1744 undefined symbols from repository information.
1746 If -r or they will be run via some other method, do not build the
1747 constructor or destructor list, just return now. */
1750 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1752 /* Perform the first pass link now, if we're about to exit or if we need
1753 to scan for things we haven't collected yet before pursuing further.
1755 On AIX, the latter typically includes nothing for shared objects or
1756 frame tables for an executable, out of what the required early scan on
1757 objects and libraries has performed above. In the !shared_obj case, we
1758 expect the relevant tables to be dragged together with their associated
1759 functions from precise cross reference insertions by the compiler. */
1761 if (early_exit || ld1_filter != SCAN_NOTHING)
1762 do_tlink (ld1_argv, object_lst);
1766 #ifdef COLLECT_EXPORT_LIST
1767 /* Make sure we delete the export file we may have created. */
1768 if (export_file != 0 && export_file[0])
1769 maybe_unlink (export_file);
1771 if (lto_mode != LTO_MODE_NONE)
1772 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1774 post_ld_pass (false);
1776 maybe_unlink (c_file);
1777 maybe_unlink (o_file);
1782 /* Unless we have done it all already, examine the namelist and search for
1783 static constructors and destructors to call. Write the constructor and
1784 destructor tables to a .s file and reload. */
1786 if (ld1_filter != SCAN_NOTHING)
1787 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1789 #ifdef SCAN_LIBRARIES
1790 scan_libraries (output_file);
1795 notice_translated (ngettext ("%d constructor found\n",
1796 "%d constructors found\n",
1797 constructors.number),
1798 constructors.number);
1799 notice_translated (ngettext ("%d destructor found\n",
1800 "%d destructors found\n",
1801 destructors.number),
1802 destructors.number);
1803 notice_translated (ngettext("%d frame table found\n",
1804 "%d frame tables found\n",
1805 frame_tables.number),
1806 frame_tables.number);
1809 /* If the scan exposed nothing of special interest, there's no need to
1810 generate the glue code and relink so return now. */
1812 if (constructors.number == 0 && destructors.number == 0
1813 && frame_tables.number == 0
1814 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1815 /* If we will be running these functions ourselves, we want to emit
1816 stubs into the shared library so that we do not have to relink
1817 dependent programs when we add static objects. */
1822 /* Do tlink without additional code generation now if we didn't
1823 do it earlier for scanning purposes. */
1824 if (ld1_filter == SCAN_NOTHING)
1825 do_tlink (ld1_argv, object_lst);
1828 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1830 /* Strip now if it was requested on the command line. */
1833 char **real_strip_argv = XCNEWVEC (char *, 3);
1834 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1837 strip_argv[0] = strip_file_name;
1838 strip_argv[1] = output_file;
1839 strip_argv[2] = (char *) 0;
1840 fork_execute ("strip", real_strip_argv);
1843 #ifdef COLLECT_EXPORT_LIST
1844 maybe_unlink (export_file);
1846 post_ld_pass (false);
1848 maybe_unlink (c_file);
1849 maybe_unlink (o_file);
1853 /* Sort ctor and dtor lists by priority. */
1854 sort_ids (&constructors);
1855 sort_ids (&destructors);
1857 maybe_unlink(output_file);
1858 outf = fopen (c_file, "w");
1859 if (outf == (FILE *) 0)
1860 fatal_perror ("fopen %s", c_file);
1862 write_c_file (outf, c_file);
1865 fatal_perror ("fclose %s", c_file);
1867 /* Tell the linker that we have initializer and finalizer functions. */
1868 #ifdef LD_INIT_SWITCH
1869 #ifdef COLLECT_EXPORT_LIST
1870 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1872 *ld2++ = LD_INIT_SWITCH;
1874 *ld2++ = LD_FINI_SWITCH;
1879 #ifdef COLLECT_EXPORT_LIST
1882 /* If we did not add export flag to link arguments before, add it to
1883 second link phase now. No new exports should have been added. */
1884 if (! exports.first)
1885 *ld2++ = concat ("-bE:", export_file, NULL);
1887 #ifndef LD_INIT_SWITCH
1888 add_to_list (&exports, initname);
1889 add_to_list (&exports, fininame);
1890 add_to_list (&exports, "_GLOBAL__DI");
1891 add_to_list (&exports, "_GLOBAL__DD");
1893 exportf = fopen (export_file, "w");
1894 if (exportf == (FILE *) 0)
1895 fatal_perror ("fopen %s", export_file);
1896 write_aix_file (exportf, exports.first);
1897 if (fclose (exportf))
1898 fatal_perror ("fclose %s", export_file);
1902 /* End of arguments to second link phase. */
1907 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1908 output_file, c_file);
1909 write_c_file (stderr, "stderr");
1910 fprintf (stderr, "========== end of c_file\n\n");
1911 #ifdef COLLECT_EXPORT_LIST
1912 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1913 write_aix_file (stderr, exports.first);
1914 fprintf (stderr, "========== end of export_file\n\n");
1918 /* Assemble the constructor and destructor tables.
1919 Link the tables in with the rest of the program. */
1921 fork_execute ("gcc", c_argv);
1922 #ifdef COLLECT_EXPORT_LIST
1923 /* On AIX we must call tlink because of possible templates resolution. */
1924 do_tlink (ld2_argv, object_lst);
1927 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1929 /* Otherwise, simply call ld because tlink is already done. */
1931 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1934 fork_execute ("ld", ld2_argv);
1935 post_ld_pass (false);
1938 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1939 constructors/destructors in shared libraries. */
1940 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1943 maybe_unlink (c_file);
1944 maybe_unlink (o_file);
1946 #ifdef COLLECT_EXPORT_LIST
1947 maybe_unlink (export_file);
1954 /* Wait for a process to finish, and exit if a nonzero status is found. */
1957 collect_wait (const char *prog, struct pex_obj *pex)
1961 if (!pex_get_status (pex, 1, &status))
1962 fatal_perror ("can't get program status");
1967 if (WIFSIGNALED (status))
1969 int sig = WTERMSIG (status);
1970 error ("%s terminated with signal %d [%s]%s",
1971 prog, sig, strsignal(sig),
1972 WCOREDUMP(status) ? ", core dumped" : "");
1973 collect_exit (FATAL_EXIT_CODE);
1976 if (WIFEXITED (status))
1977 return WEXITSTATUS (status);
1983 do_wait (const char *prog, struct pex_obj *pex)
1985 int ret = collect_wait (prog, pex);
1988 error ("%s returned %d exit status", prog, ret);
1994 unlink (response_file);
1995 response_file = NULL;
2000 /* Execute a program, and wait for the reply. */
2003 collect_execute (const char *prog, char **argv, const char *outname,
2004 const char *errname, int flags)
2006 struct pex_obj *pex;
2009 char *response_arg = NULL;
2010 char *response_argv[3] ATTRIBUTE_UNUSED;
2012 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2014 /* If using @file arguments, create a temporary file and put the
2015 contents of argv into it. Then change argv to an array corresponding
2016 to a single argument @FILE, where FILE is the temporary filename. */
2018 char **current_argv = argv + 1;
2019 char *argv0 = argv[0];
2023 /* Note: we assume argv contains at least one element; this is
2026 response_file = make_temp_file ("");
2028 f = fopen (response_file, "w");
2031 fatal ("could not open response file %s", response_file);
2033 status = writeargv (current_argv, f);
2036 fatal ("could not write to response file %s", response_file);
2038 status = fclose (f);
2041 fatal ("could not close response file %s", response_file);
2043 response_arg = concat ("@", response_file, NULL);
2044 response_argv[0] = argv0;
2045 response_argv[1] = response_arg;
2046 response_argv[2] = NULL;
2048 argv = response_argv;
2057 fprintf (stderr, "%s", argv[0]);
2059 notice ("[cannot find %s]", prog);
2061 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2062 fprintf (stderr, " %s", str);
2064 fprintf (stderr, "\n");
2070 /* If we cannot find a program we need, complain error. Do this here
2071 since we might not end up needing something that we could not find. */
2074 fatal ("cannot find '%s'", prog);
2076 pex = pex_init (0, "collect2", NULL);
2078 fatal_perror ("pex_init failed");
2080 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2087 fatal_perror (errmsg);
2094 free (response_arg);
2100 fork_execute (const char *prog, char **argv)
2102 struct pex_obj *pex;
2104 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2105 do_wait (prog, pex);
2108 /* Unlink a file unless we are debugging. */
2111 maybe_unlink (const char *file)
2114 unlink_if_ordinary (file);
2116 notice ("[Leaving %s]\n", file);
2119 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2122 maybe_unlink_list (char **file_list)
2124 char **tmp = file_list;
2127 maybe_unlink (*(tmp++));
2131 static long sequence_number = 0;
2133 /* Add a name to a linked list. */
2136 add_to_list (struct head *head_ptr, const char *name)
2139 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2141 strcpy (newid->name, name);
2143 if (head_ptr->first)
2144 head_ptr->last->next = newid;
2146 head_ptr->first = newid;
2148 /* Check for duplicate symbols. */
2149 for (p = head_ptr->first;
2150 strcmp (name, p->name) != 0;
2155 head_ptr->last->next = 0;
2160 newid->sequence = ++sequence_number;
2161 head_ptr->last = newid;
2165 /* Grab the init priority number from an init function name that
2166 looks like "_GLOBAL_.I.12345.foo". */
2169 extract_init_priority (const char *name)
2173 while (name[pos] == '_')
2175 pos += 10; /* strlen ("GLOBAL__X_") */
2177 /* Extract init_p number from ctor/dtor name. */
2178 pri = atoi (name + pos);
2179 return pri ? pri : DEFAULT_INIT_PRIORITY;
2182 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2183 ctors will be run from right to left, dtors from left to right. */
2186 sort_ids (struct head *head_ptr)
2188 /* id holds the current element to insert. id_next holds the next
2189 element to insert. id_ptr iterates through the already sorted elements
2190 looking for the place to insert id. */
2191 struct id *id, *id_next, **id_ptr;
2193 id = head_ptr->first;
2195 /* We don't have any sorted elements yet. */
2196 head_ptr->first = NULL;
2198 for (; id; id = id_next)
2201 id->sequence = extract_init_priority (id->name);
2203 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2205 /* If the sequence numbers are the same, we put the id from the
2206 file later on the command line later in the list. */
2207 || id->sequence > (*id_ptr)->sequence
2208 /* Hack: do lexical compare, too.
2209 || (id->sequence == (*id_ptr)->sequence
2210 && strcmp (id->name, (*id_ptr)->name) > 0) */
2219 /* Now set the sequence numbers properly so write_c_file works. */
2220 for (id = head_ptr->first; id; id = id->next)
2221 id->sequence = ++sequence_number;
2224 /* Write: `prefix', the names on list LIST, `suffix'. */
2227 write_list (FILE *stream, const char *prefix, struct id *list)
2231 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2236 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2237 /* Given a STRING, return nonzero if it occurs in the list in range
2238 [ARGS_BEGIN,ARGS_END). */
2241 is_in_args (const char *string, const char **args_begin,
2242 const char **args_end)
2244 const char **args_pointer;
2245 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2246 if (strcmp (string, *args_pointer) == 0)
2250 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2252 #ifdef COLLECT_EXPORT_LIST
2253 /* This function is really used only on AIX, but may be useful. */
2256 is_in_list (const char *prefix, struct id *list)
2260 if (!strcmp (prefix, list->name)) return 1;
2266 #endif /* COLLECT_EXPORT_LIST */
2268 /* Added for debugging purpose. */
2269 #ifdef COLLECT_EXPORT_LIST
2271 dump_list (FILE *stream, const char *prefix, struct id *list)
2275 fprintf (stream, "%s%s,\n", prefix, list->name);
2283 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2287 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2294 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2298 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2299 prefix, list->sequence, list->name);
2304 /* Write out the constructor and destructor tables statically (for a shared
2305 object), along with the functions to execute them. */
2308 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2312 int frames = (frame_tables.number > 0);
2314 /* Figure out name of output_file, stripping off .so version. */
2315 p = strrchr (output_file, '/');
2331 if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2333 q += strlen (SHLIB_SUFFIX);
2340 /* q points to null at end of the string (or . of the .so version) */
2341 prefix = XNEWVEC (char, q - p + 1);
2342 strncpy (prefix, p, q - p);
2344 for (r = prefix; *r; r++)
2345 if (!ISALNUM ((unsigned char)*r))
2348 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2349 output_file, prefix);
2351 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2352 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2356 /* Write the tables as C code. */
2358 fprintf (stream, "static int count;\n");
2359 fprintf (stream, "typedef void entry_pt();\n");
2360 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2364 write_list_with_asm (stream, "extern void *", frame_tables.first);
2366 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2367 write_list (stream, "\t\t&", frame_tables.first);
2368 fprintf (stream, "\t0\n};\n");
2370 /* This must match what's in frame.h. */
2371 fprintf (stream, "struct object {\n");
2372 fprintf (stream, " void *pc_begin;\n");
2373 fprintf (stream, " void *pc_end;\n");
2374 fprintf (stream, " void *fde_begin;\n");
2375 fprintf (stream, " void *fde_array;\n");
2376 fprintf (stream, " __SIZE_TYPE__ count;\n");
2377 fprintf (stream, " struct object *next;\n");
2378 fprintf (stream, "};\n");
2380 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2381 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2383 fprintf (stream, "static void reg_frame () {\n");
2384 fprintf (stream, "\tstatic struct object ob;\n");
2385 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2386 fprintf (stream, "\t}\n");
2388 fprintf (stream, "static void dereg_frame () {\n");
2389 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2390 fprintf (stream, "\t}\n");
2393 fprintf (stream, "void %s() {\n", initname);
2394 if (constructors.number > 0 || frames)
2396 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2397 write_list (stream, "\t\t", constructors.first);
2399 fprintf (stream, "\treg_frame,\n");
2400 fprintf (stream, "\t};\n");
2401 fprintf (stream, "\tentry_pt **p;\n");
2402 fprintf (stream, "\tif (count++ != 0) return;\n");
2403 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2404 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2407 fprintf (stream, "\t++count;\n");
2408 fprintf (stream, "}\n");
2409 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2410 fprintf (stream, "void %s() {\n", fininame);
2411 if (destructors.number > 0 || frames)
2413 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2414 write_list (stream, "\t\t", destructors.first);
2416 fprintf (stream, "\tdereg_frame,\n");
2417 fprintf (stream, "\t};\n");
2418 fprintf (stream, "\tentry_pt **p;\n");
2419 fprintf (stream, "\tif (--count != 0) return;\n");
2420 fprintf (stream, "\tp = dtors;\n");
2421 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2422 destructors.number + frames);
2424 fprintf (stream, "}\n");
2428 COLLECT_SHARED_INIT_FUNC(stream, initname);
2429 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2433 /* Write the constructor/destructor tables. */
2435 #ifndef LD_INIT_SWITCH
2437 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2439 /* Write the tables as C code. */
2441 int frames = (frame_tables.number > 0);
2443 fprintf (stream, "typedef void entry_pt();\n\n");
2445 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2449 write_list_with_asm (stream, "extern void *", frame_tables.first);
2451 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2452 write_list (stream, "\t\t&", frame_tables.first);
2453 fprintf (stream, "\t0\n};\n");
2455 /* This must match what's in frame.h. */
2456 fprintf (stream, "struct object {\n");
2457 fprintf (stream, " void *pc_begin;\n");
2458 fprintf (stream, " void *pc_end;\n");
2459 fprintf (stream, " void *fde_begin;\n");
2460 fprintf (stream, " void *fde_array;\n");
2461 fprintf (stream, " __SIZE_TYPE__ count;\n");
2462 fprintf (stream, " struct object *next;\n");
2463 fprintf (stream, "};\n");
2465 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2466 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2468 fprintf (stream, "static void reg_frame () {\n");
2469 fprintf (stream, "\tstatic struct object ob;\n");
2470 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2471 fprintf (stream, "\t}\n");
2473 fprintf (stream, "static void dereg_frame () {\n");
2474 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2475 fprintf (stream, "\t}\n");
2478 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2479 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2480 write_list (stream, "\t", constructors.first);
2482 fprintf (stream, "\treg_frame,\n");
2483 fprintf (stream, "\t0\n};\n\n");
2485 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2487 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2488 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2489 write_list (stream, "\t", destructors.first);
2491 fprintf (stream, "\tdereg_frame,\n");
2492 fprintf (stream, "\t0\n};\n\n");
2494 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2495 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2497 #endif /* ! LD_INIT_SWITCH */
2500 write_c_file (FILE *stream, const char *name)
2502 #ifndef LD_INIT_SWITCH
2504 write_c_file_glob (stream, name);
2507 write_c_file_stat (stream, name);
2510 #ifdef COLLECT_EXPORT_LIST
2512 write_aix_file (FILE *stream, struct id *list)
2514 for (; list; list = list->next)
2516 fputs (list->name, stream);
2517 putc ('\n', stream);
2522 #ifdef OBJECT_FORMAT_NONE
2524 /* Check to make sure the file is an LTO object file. */
2527 maybe_lto_object_file (const char *prog_name)
2530 unsigned char buf[4];
2533 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2534 static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2535 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2536 static unsigned char machomagic[4][4] = {
2537 { 0xcf, 0xfa, 0xed, 0xfe },
2538 { 0xce, 0xfa, 0xed, 0xfe },
2539 { 0xfe, 0xed, 0xfa, 0xcf },
2540 { 0xfe, 0xed, 0xfa, 0xce }
2543 f = fopen (prog_name, "rb");
2546 if (fread (buf, sizeof (buf), 1, f) != 1)
2550 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2551 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2552 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2554 for (i = 0; i < 4; i++)
2555 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2561 /* Generic version to scan the name list of the loaded program for
2562 the symbols g++ uses for static constructors and destructors. */
2565 scan_prog_file (const char *prog_name, scanpass which_pass,
2568 void (*int_handler) (int);
2570 void (*quit_handler) (int);
2572 char *real_nm_argv[4];
2573 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2575 struct pex_obj *pex;
2582 if (which_pass == PASS_SECOND)
2585 /* LTO objects must be in a known format. This check prevents
2586 us from accepting an archive containing LTO objects, which
2587 gcc cannnot currently handle. */
2588 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2591 /* If we do not have an `nm', complain. */
2592 if (nm_file_name == 0)
2593 fatal ("cannot find 'nm'");
2595 nm_argv[argc++] = nm_file_name;
2596 if (NM_FLAGS[0] != '\0')
2597 nm_argv[argc++] = NM_FLAGS;
2599 nm_argv[argc++] = prog_name;
2600 nm_argv[argc++] = (char *) 0;
2602 /* Trace if needed. */
2605 const char **p_argv;
2608 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2609 fprintf (stderr, " %s", str);
2611 fprintf (stderr, "\n");
2617 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2619 fatal_perror ("pex_init failed");
2621 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2628 fatal_perror (errmsg);
2634 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2636 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2639 inf = pex_read_output (pex, 0);
2641 fatal_perror ("can't open nm output");
2645 if (which_pass == PASS_LTOINFO)
2646 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2648 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2651 /* Read each line of nm output. */
2652 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2658 fprintf (stderr, "\t%s\n", buf);
2660 if (which_pass == PASS_LTOINFO)
2665 /* Look for the LTO info marker symbol, and add filename to
2666 the LTO objects list if found. */
2667 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2668 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2669 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2670 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2672 add_lto_object (<o_objects, prog_name);
2674 /* We need to read all the input, so we can't just
2675 return here. But we can avoid useless work. */
2684 /* If it contains a constructor or destructor name, add the name
2685 to the appropriate list unless this is a kind of symbol we're
2686 not supposed to even consider. */
2688 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2689 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2696 /* Find the end of the symbol name.
2697 Do not include `|', because Encore nm can tack that on the end. */
2698 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2704 switch (is_ctor_dtor (name))
2707 if (! (filter & SCAN_CTOR))
2709 if (which_pass != PASS_LIB)
2710 add_to_list (&constructors, name);
2714 if (! (filter & SCAN_DTOR))
2716 if (which_pass != PASS_LIB)
2717 add_to_list (&destructors, name);
2721 if (! (filter & SCAN_INIT))
2723 if (which_pass != PASS_LIB)
2724 fatal ("init function found in object %s", prog_name);
2725 #ifndef LD_INIT_SWITCH
2726 add_to_list (&constructors, name);
2731 if (! (filter & SCAN_FINI))
2733 if (which_pass != PASS_LIB)
2734 fatal ("fini function found in object %s", prog_name);
2735 #ifndef LD_FINI_SWITCH
2736 add_to_list (&destructors, name);
2741 if (! (filter & SCAN_DWEH))
2743 if (which_pass != PASS_LIB)
2744 add_to_list (&frame_tables, name);
2747 default: /* not a constructor or destructor */
2753 fprintf (stderr, "\n");
2755 do_wait (nm_file_name, pex);
2757 signal (SIGINT, int_handler);
2759 signal (SIGQUIT, quit_handler);
2765 /* Use the List Dynamic Dependencies program to find shared libraries that
2766 the output file depends upon and their initialization/finalization
2767 routines, if any. */
2770 scan_libraries (const char *prog_name)
2772 static struct head libraries; /* list of shared libraries found */
2774 void (*int_handler) (int);
2776 void (*quit_handler) (int);
2778 char *real_ldd_argv[4];
2779 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2781 struct pex_obj *pex;
2787 /* If we do not have an `ldd', complain. */
2788 if (ldd_file_name == 0)
2790 error ("cannot find 'ldd'");
2794 ldd_argv[argc++] = ldd_file_name;
2795 ldd_argv[argc++] = prog_name;
2796 ldd_argv[argc++] = (char *) 0;
2798 /* Trace if needed. */
2801 const char **p_argv;
2804 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2805 fprintf (stderr, " %s", str);
2807 fprintf (stderr, "\n");
2813 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2815 fatal_perror ("pex_init failed");
2817 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2823 fatal_perror (errmsg);
2829 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2831 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2834 inf = pex_read_output (pex, 0);
2836 fatal_perror ("can't open ldd output");
2839 notice ("\nldd output with constructors/destructors.\n");
2841 /* Read each line of ldd output. */
2842 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2845 char *name, *end, *p = buf;
2847 /* Extract names of libraries and add to list. */
2848 PARSE_LDD_OUTPUT (p);
2853 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2854 fatal ("dynamic dependency %s not found", buf);
2856 /* Find the end of the symbol name. */
2858 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2863 if (access (name, R_OK) == 0)
2864 add_to_list (&libraries, name);
2866 fatal ("unable to open dynamic dependency '%s'", buf);
2869 fprintf (stderr, "\t%s\n", buf);
2872 fprintf (stderr, "\n");
2874 do_wait (ldd_file_name, pex);
2876 signal (SIGINT, int_handler);
2878 signal (SIGQUIT, quit_handler);
2881 /* Now iterate through the library list adding their symbols to
2883 for (list = libraries.first; list; list = list->next)
2884 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2887 #endif /* LDD_SUFFIX */
2889 #endif /* OBJECT_FORMAT_NONE */
2893 * COFF specific stuff.
2896 #ifdef OBJECT_FORMAT_COFF
2898 #if defined (EXTENDED_COFF)
2900 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2901 # define GCC_SYMENT SYMR
2902 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2903 # define GCC_SYMINC(X) (1)
2904 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2905 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2909 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2910 # define GCC_SYMENT SYMENT
2911 # if defined (C_WEAKEXT)
2912 # define GCC_OK_SYMBOL(X) \
2913 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2914 ((X).n_scnum > N_UNDEF) && \
2916 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2917 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2918 # define GCC_UNDEF_SYMBOL(X) \
2919 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2920 ((X).n_scnum == N_UNDEF))
2922 # define GCC_OK_SYMBOL(X) \
2923 (((X).n_sclass == C_EXT) && \
2924 ((X).n_scnum > N_UNDEF) && \
2926 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2927 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2928 # define GCC_UNDEF_SYMBOL(X) \
2929 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2931 # define GCC_SYMINC(X) ((X).n_numaux+1)
2932 # define GCC_SYMZERO(X) 0
2934 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2935 #if TARGET_AIX_VERSION >= 51
2936 # define GCC_CHECK_HDR(X) \
2937 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2938 || (HEADER (X).f_magic == 0767 && aix64_flag))
2940 # define GCC_CHECK_HDR(X) \
2941 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2942 || (HEADER (X).f_magic == 0757 && aix64_flag))
2947 #ifdef COLLECT_EXPORT_LIST
2948 /* Array of standard AIX libraries which should not
2949 be scanned for ctors/dtors. */
2950 static const char *const aix_std_libs[] = {
2958 "/usr/lib/libc_r.a",
2959 "/usr/lib/libm_r.a",
2960 "/usr/lib/threads/libc.a",
2961 "/usr/ccs/lib/libc.a",
2962 "/usr/ccs/lib/libm.a",
2963 "/usr/ccs/lib/libc_r.a",
2964 "/usr/ccs/lib/libm_r.a",
2968 /* This function checks the filename and returns 1
2969 if this name matches the location of a standard AIX library. */
2970 static int ignore_library (const char *);
2972 ignore_library (const char *name)
2974 const char *const *p;
2977 if (target_system_root[0] != '\0')
2979 length = strlen (target_system_root);
2980 if (strncmp (name, target_system_root, length) != 0)
2984 for (p = &aix_std_libs[0]; *p != NULL; ++p)
2985 if (strcmp (name, *p) == 0)
2989 #endif /* COLLECT_EXPORT_LIST */
2991 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2992 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2995 /* COFF version to scan the name list of the loaded program for
2996 the symbols g++ uses for static constructors and destructors. */
2999 scan_prog_file (const char *prog_name, scanpass which_pass,
3002 LDFILE *ldptr = NULL;
3003 int sym_index, sym_count;
3006 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3009 #ifdef COLLECT_EXPORT_LIST
3010 /* We do not need scanning for some standard C libraries. */
3011 if (which_pass == PASS_FIRST && ignore_library (prog_name))
3014 /* On AIX we have a loop, because there is not much difference
3015 between an object and an archive. This trick allows us to
3016 eliminate scan_libraries() function. */
3020 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3021 non-const char * filename parameter, even though it will not
3022 modify that string. So we must cast away const-ness here,
3023 using CONST_CAST to prevent complaints from -Wcast-qual. */
3024 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3026 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3027 fatal ("%s: not a COFF file", prog_name);
3029 if (GCC_CHECK_HDR (ldptr))
3031 sym_count = GCC_SYMBOLS (ldptr);
3032 sym_index = GCC_SYMZERO (ldptr);
3034 #ifdef COLLECT_EXPORT_LIST
3035 /* Is current archive member a shared object? */
3036 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3039 while (sym_index < sym_count)
3043 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3045 sym_index += GCC_SYMINC (symbol);
3047 if (GCC_OK_SYMBOL (symbol))
3051 if ((name = ldgetname (ldptr, &symbol)) == NULL)
3052 continue; /* Should never happen. */
3054 #ifdef XCOFF_DEBUGGING_INFO
3055 /* All AIX function names have a duplicate entry
3056 beginning with a dot. */
3061 switch (is_ctor_dtor (name))
3064 if (! (filter & SCAN_CTOR))
3067 add_to_list (&constructors, name);
3068 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3069 if (which_pass == PASS_OBJ)
3070 add_to_list (&exports, name);
3075 if (! (filter & SCAN_DTOR))
3078 add_to_list (&destructors, name);
3079 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3080 if (which_pass == PASS_OBJ)
3081 add_to_list (&exports, name);
3085 #ifdef COLLECT_EXPORT_LIST
3087 if (! (filter & SCAN_INIT))
3089 #ifndef LD_INIT_SWITCH
3091 add_to_list (&constructors, name);
3096 if (! (filter & SCAN_FINI))
3098 #ifndef LD_INIT_SWITCH
3100 add_to_list (&destructors, name);
3106 if (! (filter & SCAN_DWEH))
3109 add_to_list (&frame_tables, name);
3110 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3111 if (which_pass == PASS_OBJ)
3112 add_to_list (&exports, name);
3116 default: /* not a constructor or destructor */
3117 #ifdef COLLECT_EXPORT_LIST
3118 /* Explicitly export all global symbols when
3119 building a shared object on AIX, but do not
3120 re-export symbols from another shared object
3121 and do not export symbols if the user
3122 provides an explicit export list. */
3123 if (shared_obj && !is_shared
3124 && which_pass == PASS_OBJ && !export_flag)
3125 add_to_list (&exports, name);
3131 #if !defined(EXTENDED_COFF)
3132 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3133 symbol.n_scnum, symbol.n_sclass,
3134 (symbol.n_type ? "0" : ""), symbol.n_type,
3138 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3139 symbol.iss, (long) symbol.value, symbol.index, name);
3144 #ifdef COLLECT_EXPORT_LIST
3147 /* If archive contains both 32-bit and 64-bit objects,
3148 we want to skip objects in other mode so mismatch normal. */
3150 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3151 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3157 fatal ("%s: cannot open as COFF file", prog_name);
3159 #ifdef COLLECT_EXPORT_LIST
3160 /* On AIX loop continues while there are more members in archive. */
3162 while (ldclose (ldptr) == FAILURE);
3164 /* Otherwise we simply close ldptr. */
3165 (void) ldclose(ldptr);
3168 #endif /* OBJECT_FORMAT_COFF */
3170 #ifdef COLLECT_EXPORT_LIST
3171 /* Given a library name without "lib" prefix, this function
3172 returns a full library name including a path. */
3174 resolve_lib_name (const char *name)
3178 /* Library extensions for AIX dynamic linking. */
3179 const char * const libexts[2] = {"a", "so"};
3181 for (i = 0; libpaths[i]; i++)
3182 if (libpaths[i]->max_len > l)
3183 l = libpaths[i]->max_len;
3185 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3187 for (i = 0; libpaths[i]; i++)
3189 struct prefix_list *list = libpaths[i]->plist;
3190 for (; list; list = list->next)
3192 /* The following lines are needed because path_prefix list
3193 may contain directories both with trailing '/' and
3196 if (list->prefix[strlen(list->prefix)-1] != '/')
3198 for (j = 0; j < 2; j++)
3200 sprintf (lib_buf, "%s%slib%s.%s",
3201 list->prefix, p, name,
3202 libexts[(j + aixrtl_flag) % 2]);
3203 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3204 if (file_exists (lib_buf))
3206 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3213 fprintf (stderr, "not found\n");
3215 fatal ("library lib%s not found", name);
3218 #endif /* COLLECT_EXPORT_LIST */
3220 #ifdef COLLECT_RUN_DSYMUTIL
3221 static int flag_dsym = false;
3222 static int flag_idsym = false;
3225 process_args (int *argcp, char **argv) {
3228 for (i=0; i<argc; ++i)
3230 if (strcmp (argv[i], "-dsym") == 0)
3233 /* Remove the flag, as we handle all processing for it. */
3236 argv[j] = argv[j+1];
3241 else if (strcmp (argv[i], "-idsym") == 0)
3244 /* Remove the flag, as we handle all processing for it. */
3247 argv[j] = argv[j+1];
3256 do_dsymutil (const char *output_file) {
3257 const char *dsymutil = DSYMUTIL + 1;
3258 struct pex_obj *pex;
3259 char **real_argv = XCNEWVEC (char *, 3);
3260 const char ** argv = CONST_CAST2 (const char **, char **,
3264 argv[1] = output_file;
3265 argv[2] = (char *) 0;
3267 pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3268 do_wait (dsymutil, pex);
3272 post_ld_pass (bool temp_file) {
3273 if (!(temp_file && flag_idsym) && !flag_dsym)
3276 do_dsymutil (output_file);
3280 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3281 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }