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)
945 const char **lto_c_ptr;
947 const char **p, **q, **r;
948 const char **lto_o_ptr;
949 struct lto_object *list;
950 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
952 const char *prog = "lto-wrapper";
955 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 /* Get compiler options passed down from the parent `gcc' command.
961 These must be passed to the LTO back end. */
962 opts = getenv ("COLLECT_GCC_OPTIONS");
964 /* Increment the argument count by the number of inherited options.
965 Some arguments may be filtered out later. Again, an upper bound
972 extract_string (&cp);
975 obstack_free (&temporary_obstack, temporary_firstobj);
980 /* Increment the argument count by the number of initial
981 arguments added below. */
984 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
985 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
987 *lto_c_ptr++ = lto_wrapper;
988 *lto_c_ptr++ = c_file_name;
994 const char *s = extract_string (&cp);
996 /* Pass the option or argument to the wrapper. */
997 *lto_c_ptr++ = xstrdup (s);
999 obstack_free (&temporary_obstack, temporary_firstobj);
1002 *lto_c_ptr++ = xstrdup ("-debug");
1004 /* Add LTO objects to the wrapper command line. */
1005 for (list = lto_objects.first; list; list = list->next)
1006 *lto_c_ptr++ = list->name;
1010 /* Run the LTO back end. */
1011 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
1015 size_t i, num_files;
1018 stream = pex_read_output (pex, 0);
1019 gcc_assert (stream);
1022 while ((c = getc (stream)) != EOF)
1024 obstack_1grow (&temporary_obstack, c);
1029 lto_o_files = XNEWVEC (char *, num_files + 1);
1030 lto_o_files[num_files] = NULL;
1031 start = XOBFINISH (&temporary_obstack, char *);
1032 for (i = 0; i < num_files; ++i)
1035 while (*end != '\n')
1039 lto_o_files[i] = xstrdup (start);
1044 obstack_free (&temporary_obstack, temporary_firstobj);
1046 do_wait (prog, pex);
1049 /* After running the LTO back end, we will relink, substituting
1050 the LTO output for the object files that we submitted to the
1051 LTO. Here, we modify the linker command line for the relink. */
1052 p = CONST_CAST2 (const char **, char **, lto_ld_argv);
1053 lto_o_ptr = CONST_CAST2 (const char **, char **, lto_o_files);
1057 for (list = lto_objects.first; list; list = list->next)
1059 if (*p == list->name) /* Note test for pointer equality! */
1061 /* Excise argument from linker command line. */
1064 /* Replace first argument with LTO output file. */
1065 *p++ = *lto_o_ptr++;
1069 /* Move following arguments one position earlier,
1070 overwriting the current argument. */
1078 /* No need to continue searching the LTO object list. */
1083 /* If we didn't find a match, move on to the next argument.
1084 Otherwise, P has been set to the correct argument position
1085 at which to continue. */
1089 /* The code above assumes we will never have more lto output files than
1090 input files. Otherwise, we need to resize lto_ld_argv. Check this
1093 fatal ("too many lto output files");
1095 /* Run the linker again, this time replacing the object files
1096 optimized by the LTO with the temporary file generated by the LTO. */
1097 fork_execute ("ld", lto_ld_argv);
1099 maybe_unlink_list (lto_o_files);
1103 /* Our caller is relying on us to do the link
1104 even though there is no LTO back end work to be done. */
1105 fork_execute ("ld", lto_ld_argv);
1112 main (int argc, char **argv)
1114 static const char *const ld_suffix = "ld";
1115 static const char *const plugin_ld_suffix = PLUGIN_LD;
1116 static const char *const real_ld_suffix = "real-ld";
1117 static const char *const collect_ld_suffix = "collect-ld";
1118 static const char *const nm_suffix = "nm";
1119 static const char *const gnm_suffix = "gnm";
1121 static const char *const ldd_suffix = LDD_SUFFIX;
1123 static const char *const strip_suffix = "strip";
1124 static const char *const gstrip_suffix = "gstrip";
1126 #ifdef CROSS_DIRECTORY_STRUCTURE
1127 /* If we look for a program in the compiler directories, we just use
1128 the short name, since these directories are already system-specific.
1129 But it we look for a program in the system directories, we need to
1130 qualify the program name with the target machine. */
1132 const char *const full_ld_suffix =
1133 concat(target_machine, "-", ld_suffix, NULL);
1134 const char *const full_plugin_ld_suffix =
1135 concat(target_machine, "-", plugin_ld_suffix, NULL);
1136 const char *const full_nm_suffix =
1137 concat (target_machine, "-", nm_suffix, NULL);
1138 const char *const full_gnm_suffix =
1139 concat (target_machine, "-", gnm_suffix, NULL);
1141 const char *const full_ldd_suffix =
1142 concat (target_machine, "-", ldd_suffix, NULL);
1144 const char *const full_strip_suffix =
1145 concat (target_machine, "-", strip_suffix, NULL);
1146 const char *const full_gstrip_suffix =
1147 concat (target_machine, "-", gstrip_suffix, NULL);
1149 const char *const full_ld_suffix = ld_suffix;
1150 const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1151 const char *const full_nm_suffix = nm_suffix;
1152 const char *const full_gnm_suffix = gnm_suffix;
1154 const char *const full_ldd_suffix = ldd_suffix;
1156 const char *const full_strip_suffix = strip_suffix;
1157 const char *const full_gstrip_suffix = gstrip_suffix;
1158 #endif /* CROSS_DIRECTORY_STRUCTURE */
1162 #ifdef COLLECT_EXPORT_LIST
1165 const char *ld_file_name;
1171 bool use_plugin = false;
1173 /* The kinds of symbols we will have to consider when scanning the
1174 outcome of a first pass link. This is ALL to start with, then might
1175 be adjusted before getting to the first pass link per se, typically on
1176 AIX where we perform an early scan of objects and libraries to fetch
1177 the list of global ctors/dtors and make sure they are not garbage
1179 scanfilter ld1_filter = SCAN_ALL;
1184 const char **object;
1189 bool use_verbose = false;
1192 expandargv (&argc, &argv);
1193 if (argv != old_argv)
1194 at_file_supplied = 1;
1196 num_c_args = argc + 9;
1198 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1200 /* Suppress demangling by the real linker, which may be broken. */
1201 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1203 #if defined (COLLECT2_HOST_INITIALIZATION)
1204 /* Perform system dependent initialization, if necessary. */
1205 COLLECT2_HOST_INITIALIZATION;
1209 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1210 receive the signal. A different setting is inheritable */
1211 signal (SIGCHLD, SIG_DFL);
1214 /* Unlock the stdio streams. */
1215 unlock_std_streams ();
1217 gcc_init_libintl ();
1219 /* Do not invoke xcalloc before this point, since locale needs to be
1220 set first, in case a diagnostic is issued. */
1222 ld1_argv = XCNEWVEC (char *, argc + 4);
1223 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1224 ld2_argv = XCNEWVEC (char *, argc + 11);
1225 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1226 object_lst = XCNEWVEC (char *, argc);
1227 object = CONST_CAST2 (const char **, char **, object_lst);
1233 /* Parse command line early for instances of -debug. This allows
1234 the debug flag to be set before functions like find_a_file()
1235 are called. We also look for the -flto or -fwhopr flag to know
1236 what LTO mode we are in. */
1240 for (i = 1; argv[i] != NULL; i ++)
1242 if (! strcmp (argv[i], "-debug"))
1244 else if (! strcmp (argv[i], "-flto") && ! use_plugin)
1247 lto_mode = LTO_MODE_LTO;
1249 else if (! strcmp (argv[i], "-fwhopr") && ! use_plugin)
1252 lto_mode = LTO_MODE_WHOPR;
1254 else if (! strcmp (argv[i], "-plugin"))
1258 lto_mode = LTO_MODE_NONE;
1260 #ifdef COLLECT_EXPORT_LIST
1261 /* since -brtl, -bexport, -b64 are not position dependent
1262 also check for them here */
1263 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1266 /* We want to disable automatic exports on AIX when user
1267 explicitly puts an export list in command line */
1268 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1270 else if (arg[2] == '6' && arg[3] == '4')
1272 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1280 #ifndef DEFAULT_A_OUT_NAME
1281 output_file = "a.out";
1283 output_file = DEFAULT_A_OUT_NAME;
1286 obstack_begin (&temporary_obstack, 0);
1287 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1289 #ifndef HAVE_LD_DEMANGLE
1290 current_demangling_style = auto_demangling;
1292 p = getenv ("COLLECT_GCC_OPTIONS");
1295 const char *q = extract_string (&p);
1296 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1299 obstack_free (&temporary_obstack, temporary_firstobj);
1301 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1302 -fno-exceptions -w -fno-whole-program */
1305 c_argv = XCNEWVEC (char *, num_c_args);
1306 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1309 fatal ("no arguments");
1312 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1313 signal (SIGQUIT, handler);
1315 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1316 signal (SIGINT, handler);
1318 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1319 signal (SIGALRM, handler);
1322 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1323 signal (SIGHUP, handler);
1325 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1326 signal (SIGSEGV, handler);
1328 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1329 signal (SIGBUS, handler);
1332 /* Extract COMPILER_PATH and PATH into our prefix list. */
1333 prefix_from_env ("COMPILER_PATH", &cpath);
1334 prefix_from_env ("PATH", &path);
1336 /* Try to discover a valid linker/nm/strip to use. */
1338 /* Maybe we know the right file to use (if not cross). */
1340 #ifdef DEFAULT_LINKER
1341 if (access (DEFAULT_LINKER, X_OK) == 0)
1342 ld_file_name = DEFAULT_LINKER;
1343 if (ld_file_name == 0)
1345 #ifdef REAL_LD_FILE_NAME
1346 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1347 if (ld_file_name == 0)
1349 /* Search the (target-specific) compiler dirs for ld'. */
1350 ld_file_name = find_a_file (&cpath, real_ld_suffix);
1351 /* Likewise for `collect-ld'. */
1352 if (ld_file_name == 0)
1353 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1354 /* Search the compiler directories for `ld'. We have protection against
1355 recursive calls in find_a_file. */
1356 if (ld_file_name == 0)
1357 ld_file_name = find_a_file (&cpath,
1361 /* Search the ordinary system bin directories
1362 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1363 if (ld_file_name == 0)
1364 ld_file_name = find_a_file (&path,
1366 ? full_plugin_ld_suffix
1369 #ifdef REAL_NM_FILE_NAME
1370 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1371 if (nm_file_name == 0)
1373 nm_file_name = find_a_file (&cpath, gnm_suffix);
1374 if (nm_file_name == 0)
1375 nm_file_name = find_a_file (&path, full_gnm_suffix);
1376 if (nm_file_name == 0)
1377 nm_file_name = find_a_file (&cpath, nm_suffix);
1378 if (nm_file_name == 0)
1379 nm_file_name = find_a_file (&path, full_nm_suffix);
1382 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1383 if (ldd_file_name == 0)
1384 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1387 #ifdef REAL_STRIP_FILE_NAME
1388 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1389 if (strip_file_name == 0)
1391 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1392 if (strip_file_name == 0)
1393 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1394 if (strip_file_name == 0)
1395 strip_file_name = find_a_file (&cpath, strip_suffix);
1396 if (strip_file_name == 0)
1397 strip_file_name = find_a_file (&path, full_strip_suffix);
1399 /* Determine the full path name of the C compiler to use. */
1400 c_file_name = getenv ("COLLECT_GCC");
1401 if (c_file_name == 0)
1403 #ifdef CROSS_DIRECTORY_STRUCTURE
1404 c_file_name = concat (target_machine, "-gcc", NULL);
1406 c_file_name = "gcc";
1410 p = find_a_file (&cpath, c_file_name);
1412 /* Here it should be safe to use the system search path since we should have
1413 already qualified the name of the compiler when it is needed. */
1415 p = find_a_file (&path, c_file_name);
1420 *ld1++ = *ld2++ = ld_file_name;
1422 /* Make temp file names. */
1423 c_file = make_temp_file (".c");
1424 o_file = make_temp_file (".o");
1425 #ifdef COLLECT_EXPORT_LIST
1426 export_file = make_temp_file (".x");
1428 ldout = make_temp_file (".ld");
1429 lderrout = make_temp_file (".le");
1430 *c_ptr++ = c_file_name;
1437 #ifdef COLLECT_EXPORT_LIST
1438 /* Generate a list of directories from LIBPATH. */
1439 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1440 /* Add to this list also two standard directories where
1441 AIX loader always searches for libraries. */
1442 add_prefix (&libpath_lib_dirs, "/lib");
1443 add_prefix (&libpath_lib_dirs, "/usr/lib");
1446 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1448 AIX support needs to know if -shared has been specified before
1449 parsing commandline arguments. */
1451 p = getenv ("COLLECT_GCC_OPTIONS");
1454 const char *q = extract_string (&p);
1455 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1456 *c_ptr++ = xstrdup (q);
1457 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1458 *c_ptr++ = xstrdup (q);
1459 if (strcmp (q, "-shared") == 0)
1461 if (*q == '-' && q[1] == 'B')
1463 *c_ptr++ = xstrdup (q);
1466 q = extract_string (&p);
1467 *c_ptr++ = xstrdup (q);
1470 if (use_verbose && *q == '-' && q[1] == 'v' && q[2] == 0)
1472 /* Turn on trace in collect2 if needed. */
1476 obstack_free (&temporary_obstack, temporary_firstobj);
1477 *c_ptr++ = "-fno-profile-arcs";
1478 *c_ptr++ = "-fno-test-coverage";
1479 *c_ptr++ = "-fno-branch-probabilities";
1480 *c_ptr++ = "-fno-exceptions";
1482 *c_ptr++ = "-fno-whole-program";
1484 /* !!! When GCC calls collect2,
1485 it does not know whether it is calling collect2 or ld.
1486 So collect2 cannot meaningfully understand any options
1487 except those ld understands.
1488 If you propose to make GCC pass some other option,
1489 just imagine what will happen if ld is really ld!!! */
1491 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1492 /* After the first file, put in the c++ rt0. */
1495 #ifdef HAVE_LD_DEMANGLE
1496 if (!demangle_flag && !no_demangle)
1497 demangle_flag = "--demangle";
1499 *ld1++ = *ld2++ = demangle_flag;
1501 while ((arg = *++argv) != (char *) 0)
1503 *ld1++ = *ld2++ = arg;
1510 if (!strcmp (arg, "-debug"))
1512 /* Already parsed. */
1516 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1519 *ld1++ = *ld2++ = *argv;
1524 if (strcmp (arg, "-flto") == 0 || strcmp (arg, "-fwhopr") == 0)
1527 /* Do not pass LTO flag to the linker. */
1531 error ("LTO support has not been enabled in this "
1540 /* place o_file BEFORE this argument! */
1546 #ifdef COLLECT_EXPORT_LIST
1548 /* Resolving full library name. */
1549 const char *s = resolve_lib_name (arg+2);
1551 /* Saving a full library name. */
1552 add_to_list (&libs, s);
1557 #ifdef COLLECT_EXPORT_LIST
1558 /* Saving directories where to search for libraries. */
1560 add_prefix (&cmdline_lib_dirs, arg+2);
1563 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1565 if (is_in_args (arg,
1566 CONST_CAST2 (const char **, char **, ld1_argv),
1570 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1575 output_file = *ld1++ = *ld2++ = *++argv;
1577 #ifdef SWITCHES_NEED_SPACES
1578 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1582 output_file = &arg[2];
1591 if (arg[2] == '\0' && do_collecting)
1593 /* We must strip after the nm run, otherwise C++ linking
1594 will not work. Thus we strip in the second ld run, or
1595 else with strip if there is no second ld run. */
1607 if (strcmp (arg, "--no-demangle") == 0)
1609 demangle_flag = arg;
1614 else if (strncmp (arg, "--demangle", 10) == 0)
1616 demangle_flag = arg;
1618 #ifndef HAVE_LD_DEMANGLE
1621 enum demangling_styles style
1622 = cplus_demangle_name_to_style (arg+11);
1623 if (style == unknown_demangling)
1624 error ("unknown demangling style '%s'", arg+11);
1626 current_demangling_style = style;
1632 else if (strncmp (arg, "--sysroot=", 10) == 0)
1633 target_system_root = arg + 10;
1634 else if (strncmp (arg, "--version", 9) == 0)
1636 else if (strncmp (arg, "--help", 9) == 0)
1641 else if ((p = strrchr (arg, '.')) != (char *) 0
1642 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1643 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1644 || strcmp (p, ".obj") == 0))
1653 /* place o_file BEFORE this argument! */
1659 if (p[1] == 'o' || p[1] == 'l')
1661 #ifdef COLLECT_EXPORT_LIST
1662 /* libraries can be specified directly, i.e. without -l flag. */
1665 /* Saving a full library name. */
1666 add_to_list (&libs, arg);
1672 #ifdef COLLECT_EXPORT_LIST
1673 /* This is added only for debugging purposes. */
1676 fprintf (stderr, "List of libraries:\n");
1677 dump_list (stderr, "\t", libs.first);
1680 /* The AIX linker will discard static constructors in object files if
1681 nothing else in the file is referenced, so look at them first. Unless
1682 we are building a shared object, ignore the eh frame tables, as we
1683 would otherwise reference them all, hence drag all the corresponding
1684 objects even if nothing else is referenced. */
1686 const char **export_object_lst
1687 = CONST_CAST2 (const char **, char **, object_lst);
1689 struct id *list = libs.first;
1691 /* Compute the filter to use from the current one, do scan, then adjust
1692 the "current" filter to remove what we just included here. This will
1693 control whether we need a first pass link later on or not, and what
1694 will remain to be scanned there. */
1696 scanfilter this_filter = ld1_filter;
1699 this_filter &= ~SCAN_DWEH;
1702 while (export_object_lst < object)
1703 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1705 for (; list; list = list->next)
1706 scan_prog_file (list->name, PASS_FIRST, this_filter);
1708 ld1_filter = ld1_filter & ~this_filter;
1713 char *buf = concat ("-bE:", export_file, NULL);
1718 exportf = fopen (export_file, "w");
1719 if (exportf == (FILE *) 0)
1720 fatal_perror ("fopen %s", export_file);
1721 write_aix_file (exportf, exports.first);
1722 if (fclose (exportf))
1723 fatal_perror ("fclose %s", export_file);
1728 *c_ptr = *ld1 = *object = (char *) 0;
1732 notice ("collect2 version %s", version_string);
1733 #ifdef TARGET_VERSION
1736 fprintf (stderr, "\n");
1741 fprintf (stderr, "Usage: collect2 [options]\n");
1742 fprintf (stderr, " Wrap linker and generate constructor code if needed.\n");
1743 fprintf (stderr, " Options:\n");
1744 fprintf (stderr, " -debug Enable debug output\n");
1745 fprintf (stderr, " --help Display this information\n");
1746 fprintf (stderr, " -v, --version Display this program's version number\n");
1747 fprintf (stderr, "Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1748 fprintf (stderr, "Report bugs: %s\n", bug_report_url);
1756 fprintf (stderr, "ld_file_name = %s\n",
1757 (ld_file_name ? ld_file_name : "not found"));
1758 fprintf (stderr, "c_file_name = %s\n",
1759 (c_file_name ? c_file_name : "not found"));
1760 fprintf (stderr, "nm_file_name = %s\n",
1761 (nm_file_name ? nm_file_name : "not found"));
1763 fprintf (stderr, "ldd_file_name = %s\n",
1764 (ldd_file_name ? ldd_file_name : "not found"));
1766 fprintf (stderr, "strip_file_name = %s\n",
1767 (strip_file_name ? strip_file_name : "not found"));
1768 fprintf (stderr, "c_file = %s\n",
1769 (c_file ? c_file : "not found"));
1770 fprintf (stderr, "o_file = %s\n",
1771 (o_file ? o_file : "not found"));
1773 ptr = getenv ("COLLECT_GCC_OPTIONS");
1775 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1777 ptr = getenv ("COLLECT_GCC");
1779 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1781 ptr = getenv ("COMPILER_PATH");
1783 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1785 ptr = getenv (LIBRARY_PATH_ENV);
1787 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1789 fprintf (stderr, "\n");
1792 /* Load the program, searching all libraries and attempting to provide
1793 undefined symbols from repository information.
1795 If -r or they will be run via some other method, do not build the
1796 constructor or destructor list, just return now. */
1799 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1801 /* Perform the first pass link now, if we're about to exit or if we need
1802 to scan for things we haven't collected yet before pursuing further.
1804 On AIX, the latter typically includes nothing for shared objects or
1805 frame tables for an executable, out of what the required early scan on
1806 objects and libraries has performed above. In the !shared_obj case, we
1807 expect the relevant tables to be dragged together with their associated
1808 functions from precise cross reference insertions by the compiler. */
1810 if (early_exit || ld1_filter != SCAN_NOTHING)
1811 do_tlink (ld1_argv, object_lst);
1815 #ifdef COLLECT_EXPORT_LIST
1816 /* Make sure we delete the export file we may have created. */
1817 if (export_file != 0 && export_file[0])
1818 maybe_unlink (export_file);
1821 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1823 maybe_unlink (c_file);
1824 maybe_unlink (o_file);
1829 /* Unless we have done it all already, examine the namelist and search for
1830 static constructors and destructors to call. Write the constructor and
1831 destructor tables to a .s file and reload. */
1833 if (ld1_filter != SCAN_NOTHING)
1834 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1836 #ifdef SCAN_LIBRARIES
1837 scan_libraries (output_file);
1842 notice_translated (ngettext ("%d constructor found\n",
1843 "%d constructors found\n",
1844 constructors.number),
1845 constructors.number);
1846 notice_translated (ngettext ("%d destructor found\n",
1847 "%d destructors found\n",
1848 destructors.number),
1849 destructors.number);
1850 notice_translated (ngettext("%d frame table found\n",
1851 "%d frame tables found\n",
1852 frame_tables.number),
1853 frame_tables.number);
1856 /* If the scan exposed nothing of special interest, there's no need to
1857 generate the glue code and relink so return now. */
1859 if (constructors.number == 0 && destructors.number == 0
1860 && frame_tables.number == 0
1861 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1862 /* If we will be running these functions ourselves, we want to emit
1863 stubs into the shared library so that we do not have to relink
1864 dependent programs when we add static objects. */
1869 /* Do tlink without additional code generation now if we didn't
1870 do it earlier for scanning purposes. */
1871 if (ld1_filter == SCAN_NOTHING)
1872 do_tlink (ld1_argv, object_lst);
1875 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1877 /* Strip now if it was requested on the command line. */
1880 char **real_strip_argv = XCNEWVEC (char *, 3);
1881 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1884 strip_argv[0] = strip_file_name;
1885 strip_argv[1] = output_file;
1886 strip_argv[2] = (char *) 0;
1887 fork_execute ("strip", real_strip_argv);
1890 #ifdef COLLECT_EXPORT_LIST
1891 maybe_unlink (export_file);
1893 maybe_unlink (c_file);
1894 maybe_unlink (o_file);
1898 /* Sort ctor and dtor lists by priority. */
1899 sort_ids (&constructors);
1900 sort_ids (&destructors);
1902 maybe_unlink(output_file);
1903 outf = fopen (c_file, "w");
1904 if (outf == (FILE *) 0)
1905 fatal_perror ("fopen %s", c_file);
1907 write_c_file (outf, c_file);
1910 fatal_perror ("fclose %s", c_file);
1912 /* Tell the linker that we have initializer and finalizer functions. */
1913 #ifdef LD_INIT_SWITCH
1914 #ifdef COLLECT_EXPORT_LIST
1915 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1917 *ld2++ = LD_INIT_SWITCH;
1919 *ld2++ = LD_FINI_SWITCH;
1924 #ifdef COLLECT_EXPORT_LIST
1927 /* If we did not add export flag to link arguments before, add it to
1928 second link phase now. No new exports should have been added. */
1929 if (! exports.first)
1930 *ld2++ = concat ("-bE:", export_file, NULL);
1932 #ifndef LD_INIT_SWITCH
1933 add_to_list (&exports, initname);
1934 add_to_list (&exports, fininame);
1935 add_to_list (&exports, "_GLOBAL__DI");
1936 add_to_list (&exports, "_GLOBAL__DD");
1938 exportf = fopen (export_file, "w");
1939 if (exportf == (FILE *) 0)
1940 fatal_perror ("fopen %s", export_file);
1941 write_aix_file (exportf, exports.first);
1942 if (fclose (exportf))
1943 fatal_perror ("fclose %s", export_file);
1947 /* End of arguments to second link phase. */
1952 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1953 output_file, c_file);
1954 write_c_file (stderr, "stderr");
1955 fprintf (stderr, "========== end of c_file\n\n");
1956 #ifdef COLLECT_EXPORT_LIST
1957 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1958 write_aix_file (stderr, exports.first);
1959 fprintf (stderr, "========== end of export_file\n\n");
1963 /* Assemble the constructor and destructor tables.
1964 Link the tables in with the rest of the program. */
1966 fork_execute ("gcc", c_argv);
1967 #ifdef COLLECT_EXPORT_LIST
1968 /* On AIX we must call tlink because of possible templates resolution. */
1969 do_tlink (ld2_argv, object_lst);
1972 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1974 /* Otherwise, simply call ld because tlink is already done. */
1976 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1978 fork_execute ("ld", ld2_argv);
1980 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1981 constructors/destructors in shared libraries. */
1982 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1985 maybe_unlink (c_file);
1986 maybe_unlink (o_file);
1988 #ifdef COLLECT_EXPORT_LIST
1989 maybe_unlink (export_file);
1996 /* Wait for a process to finish, and exit if a nonzero status is found. */
1999 collect_wait (const char *prog, struct pex_obj *pex)
2003 if (!pex_get_status (pex, 1, &status))
2004 fatal_perror ("can't get program status");
2009 if (WIFSIGNALED (status))
2011 int sig = WTERMSIG (status);
2012 error ("%s terminated with signal %d [%s]%s",
2013 prog, sig, strsignal(sig),
2014 WCOREDUMP(status) ? ", core dumped" : "");
2015 collect_exit (FATAL_EXIT_CODE);
2018 if (WIFEXITED (status))
2019 return WEXITSTATUS (status);
2025 do_wait (const char *prog, struct pex_obj *pex)
2027 int ret = collect_wait (prog, pex);
2030 error ("%s returned %d exit status", prog, ret);
2036 unlink (response_file);
2037 response_file = NULL;
2042 /* Execute a program, and wait for the reply. */
2045 collect_execute (const char *prog, char **argv, const char *outname,
2046 const char *errname, int flags)
2048 struct pex_obj *pex;
2051 char *response_arg = NULL;
2052 char *response_argv[3] ATTRIBUTE_UNUSED;
2054 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2056 /* If using @file arguments, create a temporary file and put the
2057 contents of argv into it. Then change argv to an array corresponding
2058 to a single argument @FILE, where FILE is the temporary filename. */
2060 char **current_argv = argv + 1;
2061 char *argv0 = argv[0];
2065 /* Note: we assume argv contains at least one element; this is
2068 response_file = make_temp_file ("");
2070 f = fopen (response_file, "w");
2073 fatal ("could not open response file %s", response_file);
2075 status = writeargv (current_argv, f);
2078 fatal ("could not write to response file %s", response_file);
2080 status = fclose (f);
2083 fatal ("could not close response file %s", response_file);
2085 response_arg = concat ("@", response_file, NULL);
2086 response_argv[0] = argv0;
2087 response_argv[1] = response_arg;
2088 response_argv[2] = NULL;
2090 argv = response_argv;
2099 fprintf (stderr, "%s", argv[0]);
2101 notice ("[cannot find %s]", prog);
2103 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2104 fprintf (stderr, " %s", str);
2106 fprintf (stderr, "\n");
2112 /* If we cannot find a program we need, complain error. Do this here
2113 since we might not end up needing something that we could not find. */
2116 fatal ("cannot find '%s'", prog);
2118 pex = pex_init (0, "collect2", NULL);
2120 fatal_perror ("pex_init failed");
2122 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2129 fatal_perror (errmsg);
2136 free (response_arg);
2142 fork_execute (const char *prog, char **argv)
2144 struct pex_obj *pex;
2146 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2147 do_wait (prog, pex);
2150 /* Unlink a file unless we are debugging. */
2153 maybe_unlink (const char *file)
2156 unlink_if_ordinary (file);
2158 notice ("[Leaving %s]\n", file);
2161 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2164 maybe_unlink_list (char **file_list)
2166 char **tmp = file_list;
2169 maybe_unlink (*(tmp++));
2173 static long sequence_number = 0;
2175 /* Add a name to a linked list. */
2178 add_to_list (struct head *head_ptr, const char *name)
2181 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2183 strcpy (newid->name, name);
2185 if (head_ptr->first)
2186 head_ptr->last->next = newid;
2188 head_ptr->first = newid;
2190 /* Check for duplicate symbols. */
2191 for (p = head_ptr->first;
2192 strcmp (name, p->name) != 0;
2197 head_ptr->last->next = 0;
2202 newid->sequence = ++sequence_number;
2203 head_ptr->last = newid;
2207 /* Grab the init priority number from an init function name that
2208 looks like "_GLOBAL_.I.12345.foo". */
2211 extract_init_priority (const char *name)
2215 while (name[pos] == '_')
2217 pos += 10; /* strlen ("GLOBAL__X_") */
2219 /* Extract init_p number from ctor/dtor name. */
2220 pri = atoi (name + pos);
2221 return pri ? pri : DEFAULT_INIT_PRIORITY;
2224 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2225 ctors will be run from right to left, dtors from left to right. */
2228 sort_ids (struct head *head_ptr)
2230 /* id holds the current element to insert. id_next holds the next
2231 element to insert. id_ptr iterates through the already sorted elements
2232 looking for the place to insert id. */
2233 struct id *id, *id_next, **id_ptr;
2235 id = head_ptr->first;
2237 /* We don't have any sorted elements yet. */
2238 head_ptr->first = NULL;
2240 for (; id; id = id_next)
2243 id->sequence = extract_init_priority (id->name);
2245 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2247 /* If the sequence numbers are the same, we put the id from the
2248 file later on the command line later in the list. */
2249 || id->sequence > (*id_ptr)->sequence
2250 /* Hack: do lexical compare, too.
2251 || (id->sequence == (*id_ptr)->sequence
2252 && strcmp (id->name, (*id_ptr)->name) > 0) */
2261 /* Now set the sequence numbers properly so write_c_file works. */
2262 for (id = head_ptr->first; id; id = id->next)
2263 id->sequence = ++sequence_number;
2266 /* Write: `prefix', the names on list LIST, `suffix'. */
2269 write_list (FILE *stream, const char *prefix, struct id *list)
2273 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2278 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2279 /* Given a STRING, return nonzero if it occurs in the list in range
2280 [ARGS_BEGIN,ARGS_END). */
2283 is_in_args (const char *string, const char **args_begin,
2284 const char **args_end)
2286 const char **args_pointer;
2287 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2288 if (strcmp (string, *args_pointer) == 0)
2292 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2294 #ifdef COLLECT_EXPORT_LIST
2295 /* This function is really used only on AIX, but may be useful. */
2298 is_in_list (const char *prefix, struct id *list)
2302 if (!strcmp (prefix, list->name)) return 1;
2308 #endif /* COLLECT_EXPORT_LIST */
2310 /* Added for debugging purpose. */
2311 #ifdef COLLECT_EXPORT_LIST
2313 dump_list (FILE *stream, const char *prefix, struct id *list)
2317 fprintf (stream, "%s%s,\n", prefix, list->name);
2325 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2329 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2336 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2340 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2341 prefix, list->sequence, list->name);
2346 /* Write out the constructor and destructor tables statically (for a shared
2347 object), along with the functions to execute them. */
2350 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2354 int frames = (frame_tables.number > 0);
2356 /* Figure out name of output_file, stripping off .so version. */
2357 p = strrchr (output_file, '/');
2373 if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2375 q += strlen (SHLIB_SUFFIX);
2382 /* q points to null at end of the string (or . of the .so version) */
2383 prefix = XNEWVEC (char, q - p + 1);
2384 strncpy (prefix, p, q - p);
2386 for (r = prefix; *r; r++)
2387 if (!ISALNUM ((unsigned char)*r))
2390 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2391 output_file, prefix);
2393 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2394 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2398 /* Write the tables as C code. */
2400 fprintf (stream, "static int count;\n");
2401 fprintf (stream, "typedef void entry_pt();\n");
2402 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2406 write_list_with_asm (stream, "extern void *", frame_tables.first);
2408 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2409 write_list (stream, "\t\t&", frame_tables.first);
2410 fprintf (stream, "\t0\n};\n");
2412 /* This must match what's in frame.h. */
2413 fprintf (stream, "struct object {\n");
2414 fprintf (stream, " void *pc_begin;\n");
2415 fprintf (stream, " void *pc_end;\n");
2416 fprintf (stream, " void *fde_begin;\n");
2417 fprintf (stream, " void *fde_array;\n");
2418 fprintf (stream, " __SIZE_TYPE__ count;\n");
2419 fprintf (stream, " struct object *next;\n");
2420 fprintf (stream, "};\n");
2422 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2423 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2425 fprintf (stream, "static void reg_frame () {\n");
2426 fprintf (stream, "\tstatic struct object ob;\n");
2427 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2428 fprintf (stream, "\t}\n");
2430 fprintf (stream, "static void dereg_frame () {\n");
2431 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2432 fprintf (stream, "\t}\n");
2435 fprintf (stream, "void %s() {\n", initname);
2436 if (constructors.number > 0 || frames)
2438 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2439 write_list (stream, "\t\t", constructors.first);
2441 fprintf (stream, "\treg_frame,\n");
2442 fprintf (stream, "\t};\n");
2443 fprintf (stream, "\tentry_pt **p;\n");
2444 fprintf (stream, "\tif (count++ != 0) return;\n");
2445 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2446 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2449 fprintf (stream, "\t++count;\n");
2450 fprintf (stream, "}\n");
2451 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2452 fprintf (stream, "void %s() {\n", fininame);
2453 if (destructors.number > 0 || frames)
2455 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2456 write_list (stream, "\t\t", destructors.first);
2458 fprintf (stream, "\tdereg_frame,\n");
2459 fprintf (stream, "\t};\n");
2460 fprintf (stream, "\tentry_pt **p;\n");
2461 fprintf (stream, "\tif (--count != 0) return;\n");
2462 fprintf (stream, "\tp = dtors;\n");
2463 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2464 destructors.number + frames);
2466 fprintf (stream, "}\n");
2470 COLLECT_SHARED_INIT_FUNC(stream, initname);
2471 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2475 /* Write the constructor/destructor tables. */
2477 #ifndef LD_INIT_SWITCH
2479 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2481 /* Write the tables as C code. */
2483 int frames = (frame_tables.number > 0);
2485 fprintf (stream, "typedef void entry_pt();\n\n");
2487 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2491 write_list_with_asm (stream, "extern void *", frame_tables.first);
2493 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2494 write_list (stream, "\t\t&", frame_tables.first);
2495 fprintf (stream, "\t0\n};\n");
2497 /* This must match what's in frame.h. */
2498 fprintf (stream, "struct object {\n");
2499 fprintf (stream, " void *pc_begin;\n");
2500 fprintf (stream, " void *pc_end;\n");
2501 fprintf (stream, " void *fde_begin;\n");
2502 fprintf (stream, " void *fde_array;\n");
2503 fprintf (stream, " __SIZE_TYPE__ count;\n");
2504 fprintf (stream, " struct object *next;\n");
2505 fprintf (stream, "};\n");
2507 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2508 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2510 fprintf (stream, "static void reg_frame () {\n");
2511 fprintf (stream, "\tstatic struct object ob;\n");
2512 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2513 fprintf (stream, "\t}\n");
2515 fprintf (stream, "static void dereg_frame () {\n");
2516 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2517 fprintf (stream, "\t}\n");
2520 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2521 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2522 write_list (stream, "\t", constructors.first);
2524 fprintf (stream, "\treg_frame,\n");
2525 fprintf (stream, "\t0\n};\n\n");
2527 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2529 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2530 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2531 write_list (stream, "\t", destructors.first);
2533 fprintf (stream, "\tdereg_frame,\n");
2534 fprintf (stream, "\t0\n};\n\n");
2536 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2537 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2539 #endif /* ! LD_INIT_SWITCH */
2542 write_c_file (FILE *stream, const char *name)
2544 #ifndef LD_INIT_SWITCH
2546 write_c_file_glob (stream, name);
2549 write_c_file_stat (stream, name);
2552 #ifdef COLLECT_EXPORT_LIST
2554 write_aix_file (FILE *stream, struct id *list)
2556 for (; list; list = list->next)
2558 fputs (list->name, stream);
2559 putc ('\n', stream);
2564 #ifdef OBJECT_FORMAT_NONE
2566 /* Check to make sure the file is an ELF file. LTO objects must
2567 be in ELF format. */
2570 is_elf_or_coff (const char *prog_name)
2574 static char magic[4] = { 0x7f, 'E', 'L', 'F' };
2575 static char coffmag[2] = { 0x4c, 0x01 };
2577 f = fopen (prog_name, "rb");
2580 if (fread (buf, sizeof (buf), 1, f) != 1)
2583 return memcmp (buf, magic, sizeof (magic)) == 0
2584 || memcmp (buf, coffmag, sizeof (coffmag)) == 0;
2587 /* Generic version to scan the name list of the loaded program for
2588 the symbols g++ uses for static constructors and destructors. */
2591 scan_prog_file (const char *prog_name, scanpass which_pass,
2594 void (*int_handler) (int);
2596 void (*quit_handler) (int);
2598 char *real_nm_argv[4];
2599 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2601 struct pex_obj *pex;
2608 if (which_pass == PASS_SECOND)
2611 /* LTO objects must be in a known format. This check prevents
2612 us from accepting an archive containing LTO objects, which
2613 gcc cannnot currently handle. */
2614 if (which_pass == PASS_LTOINFO && !is_elf_or_coff (prog_name))
2617 /* If we do not have an `nm', complain. */
2618 if (nm_file_name == 0)
2619 fatal ("cannot find 'nm'");
2621 nm_argv[argc++] = nm_file_name;
2622 if (NM_FLAGS[0] != '\0')
2623 nm_argv[argc++] = NM_FLAGS;
2625 nm_argv[argc++] = prog_name;
2626 nm_argv[argc++] = (char *) 0;
2628 /* Trace if needed. */
2631 const char **p_argv;
2634 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2635 fprintf (stderr, " %s", str);
2637 fprintf (stderr, "\n");
2643 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2645 fatal_perror ("pex_init failed");
2647 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2654 fatal_perror (errmsg);
2660 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2662 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2665 inf = pex_read_output (pex, 0);
2667 fatal_perror ("can't open nm output");
2671 if (which_pass == PASS_LTOINFO)
2672 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2674 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2677 /* Read each line of nm output. */
2678 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2684 fprintf (stderr, "\t%s\n", buf);
2686 if (which_pass == PASS_LTOINFO)
2691 /* Look for the LTO info marker symbol, and add filename to
2692 the LTO objects list if found. */
2693 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2694 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2695 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2696 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2698 add_lto_object (<o_objects, prog_name);
2700 /* We need to read all the input, so we can't just
2701 return here. But we can avoid useless work. */
2710 /* If it contains a constructor or destructor name, add the name
2711 to the appropriate list unless this is a kind of symbol we're
2712 not supposed to even consider. */
2714 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2715 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2722 /* Find the end of the symbol name.
2723 Do not include `|', because Encore nm can tack that on the end. */
2724 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2730 switch (is_ctor_dtor (name))
2733 if (! (filter & SCAN_CTOR))
2735 if (which_pass != PASS_LIB)
2736 add_to_list (&constructors, name);
2740 if (! (filter & SCAN_DTOR))
2742 if (which_pass != PASS_LIB)
2743 add_to_list (&destructors, name);
2747 if (! (filter & SCAN_INIT))
2749 if (which_pass != PASS_LIB)
2750 fatal ("init function found in object %s", prog_name);
2751 #ifndef LD_INIT_SWITCH
2752 add_to_list (&constructors, name);
2757 if (! (filter & SCAN_FINI))
2759 if (which_pass != PASS_LIB)
2760 fatal ("fini function found in object %s", prog_name);
2761 #ifndef LD_FINI_SWITCH
2762 add_to_list (&destructors, name);
2767 if (! (filter & SCAN_DWEH))
2769 if (which_pass != PASS_LIB)
2770 add_to_list (&frame_tables, name);
2773 default: /* not a constructor or destructor */
2779 fprintf (stderr, "\n");
2781 do_wait (nm_file_name, pex);
2783 signal (SIGINT, int_handler);
2785 signal (SIGQUIT, quit_handler);
2791 /* Use the List Dynamic Dependencies program to find shared libraries that
2792 the output file depends upon and their initialization/finalization
2793 routines, if any. */
2796 scan_libraries (const char *prog_name)
2798 static struct head libraries; /* list of shared libraries found */
2800 void (*int_handler) (int);
2802 void (*quit_handler) (int);
2804 char *real_ldd_argv[4];
2805 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2807 struct pex_obj *pex;
2813 /* If we do not have an `ldd', complain. */
2814 if (ldd_file_name == 0)
2816 error ("cannot find 'ldd'");
2820 ldd_argv[argc++] = ldd_file_name;
2821 ldd_argv[argc++] = prog_name;
2822 ldd_argv[argc++] = (char *) 0;
2824 /* Trace if needed. */
2827 const char **p_argv;
2830 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2831 fprintf (stderr, " %s", str);
2833 fprintf (stderr, "\n");
2839 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2841 fatal_perror ("pex_init failed");
2843 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2849 fatal_perror (errmsg);
2855 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2857 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2860 inf = pex_read_output (pex, 0);
2862 fatal_perror ("can't open ldd output");
2865 notice ("\nldd output with constructors/destructors.\n");
2867 /* Read each line of ldd output. */
2868 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2871 char *name, *end, *p = buf;
2873 /* Extract names of libraries and add to list. */
2874 PARSE_LDD_OUTPUT (p);
2879 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2880 fatal ("dynamic dependency %s not found", buf);
2882 /* Find the end of the symbol name. */
2884 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2889 if (access (name, R_OK) == 0)
2890 add_to_list (&libraries, name);
2892 fatal ("unable to open dynamic dependency '%s'", buf);
2895 fprintf (stderr, "\t%s\n", buf);
2898 fprintf (stderr, "\n");
2900 do_wait (ldd_file_name, pex);
2902 signal (SIGINT, int_handler);
2904 signal (SIGQUIT, quit_handler);
2907 /* Now iterate through the library list adding their symbols to
2909 for (list = libraries.first; list; list = list->next)
2910 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2913 #endif /* LDD_SUFFIX */
2915 #endif /* OBJECT_FORMAT_NONE */
2919 * COFF specific stuff.
2922 #ifdef OBJECT_FORMAT_COFF
2924 #if defined (EXTENDED_COFF)
2926 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2927 # define GCC_SYMENT SYMR
2928 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2929 # define GCC_SYMINC(X) (1)
2930 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2931 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2935 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2936 # define GCC_SYMENT SYMENT
2937 # if defined (C_WEAKEXT)
2938 # define GCC_OK_SYMBOL(X) \
2939 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2940 ((X).n_scnum > N_UNDEF) && \
2942 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2943 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2944 # define GCC_UNDEF_SYMBOL(X) \
2945 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2946 ((X).n_scnum == N_UNDEF))
2948 # define GCC_OK_SYMBOL(X) \
2949 (((X).n_sclass == C_EXT) && \
2950 ((X).n_scnum > N_UNDEF) && \
2952 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2953 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2954 # define GCC_UNDEF_SYMBOL(X) \
2955 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2957 # define GCC_SYMINC(X) ((X).n_numaux+1)
2958 # define GCC_SYMZERO(X) 0
2960 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2961 #if TARGET_AIX_VERSION >= 51
2962 # define GCC_CHECK_HDR(X) \
2963 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2964 || (HEADER (X).f_magic == 0767 && aix64_flag))
2966 # define GCC_CHECK_HDR(X) \
2967 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2968 || (HEADER (X).f_magic == 0757 && aix64_flag))
2973 #ifdef COLLECT_EXPORT_LIST
2974 /* Array of standard AIX libraries which should not
2975 be scanned for ctors/dtors. */
2976 static const char *const aix_std_libs[] = {
2984 "/usr/lib/libc_r.a",
2985 "/usr/lib/libm_r.a",
2986 "/usr/lib/threads/libc.a",
2987 "/usr/ccs/lib/libc.a",
2988 "/usr/ccs/lib/libm.a",
2989 "/usr/ccs/lib/libc_r.a",
2990 "/usr/ccs/lib/libm_r.a",
2994 /* This function checks the filename and returns 1
2995 if this name matches the location of a standard AIX library. */
2996 static int ignore_library (const char *);
2998 ignore_library (const char *name)
3000 const char *const *p;
3003 if (target_system_root[0] != '\0')
3005 length = strlen (target_system_root);
3006 if (strncmp (name, target_system_root, length) != 0)
3010 for (p = &aix_std_libs[0]; *p != NULL; ++p)
3011 if (strcmp (name, *p) == 0)
3015 #endif /* COLLECT_EXPORT_LIST */
3017 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
3018 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
3021 /* COFF version to scan the name list of the loaded program for
3022 the symbols g++ uses for static constructors and destructors. */
3025 scan_prog_file (const char *prog_name, scanpass which_pass,
3028 LDFILE *ldptr = NULL;
3029 int sym_index, sym_count;
3032 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3035 #ifdef COLLECT_EXPORT_LIST
3036 /* We do not need scanning for some standard C libraries. */
3037 if (which_pass == PASS_FIRST && ignore_library (prog_name))
3040 /* On AIX we have a loop, because there is not much difference
3041 between an object and an archive. This trick allows us to
3042 eliminate scan_libraries() function. */
3046 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3047 non-const char * filename parameter, even though it will not
3048 modify that string. So we must cast away const-ness here,
3049 using CONST_CAST to prevent complaints from -Wcast-qual. */
3050 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3052 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3053 fatal ("%s: not a COFF file", prog_name);
3055 if (GCC_CHECK_HDR (ldptr))
3057 sym_count = GCC_SYMBOLS (ldptr);
3058 sym_index = GCC_SYMZERO (ldptr);
3060 #ifdef COLLECT_EXPORT_LIST
3061 /* Is current archive member a shared object? */
3062 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3065 while (sym_index < sym_count)
3069 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3071 sym_index += GCC_SYMINC (symbol);
3073 if (GCC_OK_SYMBOL (symbol))
3077 if ((name = ldgetname (ldptr, &symbol)) == NULL)
3078 continue; /* Should never happen. */
3080 #ifdef XCOFF_DEBUGGING_INFO
3081 /* All AIX function names have a duplicate entry
3082 beginning with a dot. */
3087 switch (is_ctor_dtor (name))
3090 if (! (filter & SCAN_CTOR))
3093 add_to_list (&constructors, name);
3094 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3095 if (which_pass == PASS_OBJ)
3096 add_to_list (&exports, name);
3101 if (! (filter & SCAN_DTOR))
3104 add_to_list (&destructors, name);
3105 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3106 if (which_pass == PASS_OBJ)
3107 add_to_list (&exports, name);
3111 #ifdef COLLECT_EXPORT_LIST
3113 if (! (filter & SCAN_INIT))
3115 #ifndef LD_INIT_SWITCH
3117 add_to_list (&constructors, name);
3122 if (! (filter & SCAN_FINI))
3124 #ifndef LD_INIT_SWITCH
3126 add_to_list (&destructors, name);
3132 if (! (filter & SCAN_DWEH))
3135 add_to_list (&frame_tables, name);
3136 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3137 if (which_pass == PASS_OBJ)
3138 add_to_list (&exports, name);
3142 default: /* not a constructor or destructor */
3143 #ifdef COLLECT_EXPORT_LIST
3144 /* Explicitly export all global symbols when
3145 building a shared object on AIX, but do not
3146 re-export symbols from another shared object
3147 and do not export symbols if the user
3148 provides an explicit export list. */
3149 if (shared_obj && !is_shared
3150 && which_pass == PASS_OBJ && !export_flag)
3151 add_to_list (&exports, name);
3157 #if !defined(EXTENDED_COFF)
3158 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3159 symbol.n_scnum, symbol.n_sclass,
3160 (symbol.n_type ? "0" : ""), symbol.n_type,
3164 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3165 symbol.iss, (long) symbol.value, symbol.index, name);
3170 #ifdef COLLECT_EXPORT_LIST
3173 /* If archive contains both 32-bit and 64-bit objects,
3174 we want to skip objects in other mode so mismatch normal. */
3176 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3177 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3183 fatal ("%s: cannot open as COFF file", prog_name);
3185 #ifdef COLLECT_EXPORT_LIST
3186 /* On AIX loop continues while there are more members in archive. */
3188 while (ldclose (ldptr) == FAILURE);
3190 /* Otherwise we simply close ldptr. */
3191 (void) ldclose(ldptr);
3194 #endif /* OBJECT_FORMAT_COFF */
3196 #ifdef COLLECT_EXPORT_LIST
3197 /* Given a library name without "lib" prefix, this function
3198 returns a full library name including a path. */
3200 resolve_lib_name (const char *name)
3204 /* Library extensions for AIX dynamic linking. */
3205 const char * const libexts[2] = {"a", "so"};
3207 for (i = 0; libpaths[i]; i++)
3208 if (libpaths[i]->max_len > l)
3209 l = libpaths[i]->max_len;
3211 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3213 for (i = 0; libpaths[i]; i++)
3215 struct prefix_list *list = libpaths[i]->plist;
3216 for (; list; list = list->next)
3218 /* The following lines are needed because path_prefix list
3219 may contain directories both with trailing '/' and
3222 if (list->prefix[strlen(list->prefix)-1] != '/')
3224 for (j = 0; j < 2; j++)
3226 sprintf (lib_buf, "%s%slib%s.%s",
3227 list->prefix, p, name,
3228 libexts[(j + aixrtl_flag) % 2]);
3229 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3230 if (file_exists (lib_buf))
3232 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3239 fprintf (stderr, "not found\n");
3241 fatal ("library lib%s not found", name);
3244 #endif /* COLLECT_EXPORT_LIST */