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 /* Save intermediate WPA files in lto1 if debug. */
1012 putenv (xstrdup ("WPA_SAVE_LTRANS=1"));
1014 /* Run the LTO back end. */
1015 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
1019 size_t i, num_files;
1022 stream = pex_read_output (pex, 0);
1023 gcc_assert (stream);
1026 while ((c = getc (stream)) != EOF)
1028 obstack_1grow (&temporary_obstack, c);
1033 lto_o_files = XNEWVEC (char *, num_files + 1);
1034 lto_o_files[num_files] = NULL;
1035 start = XOBFINISH (&temporary_obstack, char *);
1036 for (i = 0; i < num_files; ++i)
1039 while (*end != '\n')
1043 lto_o_files[i] = xstrdup (start);
1048 obstack_free (&temporary_obstack, temporary_firstobj);
1050 do_wait (prog, pex);
1053 /* After running the LTO back end, we will relink, substituting
1054 the LTO output for the object files that we submitted to the
1055 LTO. Here, we modify the linker command line for the relink. */
1056 p = CONST_CAST2 (const char **, char **, lto_ld_argv);
1057 lto_o_ptr = CONST_CAST2 (const char **, char **, lto_o_files);
1061 for (list = lto_objects.first; list; list = list->next)
1063 if (*p == list->name) /* Note test for pointer equality! */
1065 /* Excise argument from linker command line. */
1068 /* Replace first argument with LTO output file. */
1069 *p++ = *lto_o_ptr++;
1073 /* Move following arguments one position earlier,
1074 overwriting the current argument. */
1082 /* No need to continue searching the LTO object list. */
1087 /* If we didn't find a match, move on to the next argument.
1088 Otherwise, P has been set to the correct argument position
1089 at which to continue. */
1093 /* The code above assumes we will never have more lto output files than
1094 input files. Otherwise, we need to resize lto_ld_argv. Check this
1097 fatal ("too many lto output files");
1099 /* Run the linker again, this time replacing the object files
1100 optimized by the LTO with the temporary file generated by the LTO. */
1101 fork_execute ("ld", lto_ld_argv);
1103 maybe_unlink_list (lto_o_files);
1107 /* Our caller is relying on us to do the link
1108 even though there is no LTO back end work to be done. */
1109 fork_execute ("ld", lto_ld_argv);
1116 main (int argc, char **argv)
1118 static const char *const ld_suffix = "ld";
1119 static const char *const plugin_ld_suffix = PLUGIN_LD;
1120 static const char *const real_ld_suffix = "real-ld";
1121 static const char *const collect_ld_suffix = "collect-ld";
1122 static const char *const nm_suffix = "nm";
1123 static const char *const gnm_suffix = "gnm";
1125 static const char *const ldd_suffix = LDD_SUFFIX;
1127 static const char *const strip_suffix = "strip";
1128 static const char *const gstrip_suffix = "gstrip";
1130 #ifdef CROSS_DIRECTORY_STRUCTURE
1131 /* If we look for a program in the compiler directories, we just use
1132 the short name, since these directories are already system-specific.
1133 But it we look for a program in the system directories, we need to
1134 qualify the program name with the target machine. */
1136 const char *const full_ld_suffix =
1137 concat(target_machine, "-", ld_suffix, NULL);
1138 const char *const full_plugin_ld_suffix =
1139 concat(target_machine, "-", plugin_ld_suffix, NULL);
1140 const char *const full_nm_suffix =
1141 concat (target_machine, "-", nm_suffix, NULL);
1142 const char *const full_gnm_suffix =
1143 concat (target_machine, "-", gnm_suffix, NULL);
1145 const char *const full_ldd_suffix =
1146 concat (target_machine, "-", ldd_suffix, NULL);
1148 const char *const full_strip_suffix =
1149 concat (target_machine, "-", strip_suffix, NULL);
1150 const char *const full_gstrip_suffix =
1151 concat (target_machine, "-", gstrip_suffix, NULL);
1153 const char *const full_ld_suffix = ld_suffix;
1154 const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1155 const char *const full_nm_suffix = nm_suffix;
1156 const char *const full_gnm_suffix = gnm_suffix;
1158 const char *const full_ldd_suffix = ldd_suffix;
1160 const char *const full_strip_suffix = strip_suffix;
1161 const char *const full_gstrip_suffix = gstrip_suffix;
1162 #endif /* CROSS_DIRECTORY_STRUCTURE */
1166 #ifdef COLLECT_EXPORT_LIST
1169 const char *ld_file_name;
1175 bool use_plugin = false;
1177 /* The kinds of symbols we will have to consider when scanning the
1178 outcome of a first pass link. This is ALL to start with, then might
1179 be adjusted before getting to the first pass link per se, typically on
1180 AIX where we perform an early scan of objects and libraries to fetch
1181 the list of global ctors/dtors and make sure they are not garbage
1183 scanfilter ld1_filter = SCAN_ALL;
1188 const char **object;
1193 bool use_verbose = false;
1196 expandargv (&argc, &argv);
1197 if (argv != old_argv)
1198 at_file_supplied = 1;
1200 num_c_args = argc + 9;
1202 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1204 /* Suppress demangling by the real linker, which may be broken. */
1205 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1207 #if defined (COLLECT2_HOST_INITIALIZATION)
1208 /* Perform system dependent initialization, if necessary. */
1209 COLLECT2_HOST_INITIALIZATION;
1213 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1214 receive the signal. A different setting is inheritable */
1215 signal (SIGCHLD, SIG_DFL);
1218 /* Unlock the stdio streams. */
1219 unlock_std_streams ();
1221 gcc_init_libintl ();
1223 /* Do not invoke xcalloc before this point, since locale needs to be
1224 set first, in case a diagnostic is issued. */
1226 ld1_argv = XCNEWVEC (char *, argc + 4);
1227 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1228 ld2_argv = XCNEWVEC (char *, argc + 11);
1229 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1230 object_lst = XCNEWVEC (char *, argc);
1231 object = CONST_CAST2 (const char **, char **, object_lst);
1237 /* Parse command line early for instances of -debug. This allows
1238 the debug flag to be set before functions like find_a_file()
1239 are called. We also look for the -flto or -fwhopr flag to know
1240 what LTO mode we are in. */
1244 for (i = 1; argv[i] != NULL; i ++)
1246 if (! strcmp (argv[i], "-debug"))
1248 else if (! strcmp (argv[i], "-flto") && ! use_plugin)
1251 lto_mode = LTO_MODE_LTO;
1253 else if (! strcmp (argv[i], "-fwhopr") && ! use_plugin)
1256 lto_mode = LTO_MODE_WHOPR;
1258 else if (! strcmp (argv[i], "-plugin"))
1262 lto_mode = LTO_MODE_NONE;
1264 #ifdef COLLECT_EXPORT_LIST
1265 /* since -brtl, -bexport, -b64 are not position dependent
1266 also check for them here */
1267 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1270 /* We want to disable automatic exports on AIX when user
1271 explicitly puts an export list in command line */
1272 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1274 else if (arg[2] == '6' && arg[3] == '4')
1276 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1284 #ifndef DEFAULT_A_OUT_NAME
1285 output_file = "a.out";
1287 output_file = DEFAULT_A_OUT_NAME;
1290 obstack_begin (&temporary_obstack, 0);
1291 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1293 #ifndef HAVE_LD_DEMANGLE
1294 current_demangling_style = auto_demangling;
1296 p = getenv ("COLLECT_GCC_OPTIONS");
1299 const char *q = extract_string (&p);
1300 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1303 obstack_free (&temporary_obstack, temporary_firstobj);
1305 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1306 -fno-exceptions -w -fno-whole-program */
1309 c_argv = XCNEWVEC (char *, num_c_args);
1310 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1313 fatal ("no arguments");
1316 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1317 signal (SIGQUIT, handler);
1319 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1320 signal (SIGINT, handler);
1322 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1323 signal (SIGALRM, handler);
1326 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1327 signal (SIGHUP, handler);
1329 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1330 signal (SIGSEGV, handler);
1332 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1333 signal (SIGBUS, handler);
1336 /* Extract COMPILER_PATH and PATH into our prefix list. */
1337 prefix_from_env ("COMPILER_PATH", &cpath);
1338 prefix_from_env ("PATH", &path);
1340 /* Try to discover a valid linker/nm/strip to use. */
1342 /* Maybe we know the right file to use (if not cross). */
1344 #ifdef DEFAULT_LINKER
1345 if (access (DEFAULT_LINKER, X_OK) == 0)
1346 ld_file_name = DEFAULT_LINKER;
1347 if (ld_file_name == 0)
1349 #ifdef REAL_LD_FILE_NAME
1350 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1351 if (ld_file_name == 0)
1353 /* Search the (target-specific) compiler dirs for ld'. */
1354 ld_file_name = find_a_file (&cpath, real_ld_suffix);
1355 /* Likewise for `collect-ld'. */
1356 if (ld_file_name == 0)
1357 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1358 /* Search the compiler directories for `ld'. We have protection against
1359 recursive calls in find_a_file. */
1360 if (ld_file_name == 0)
1361 ld_file_name = find_a_file (&cpath,
1365 /* Search the ordinary system bin directories
1366 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1367 if (ld_file_name == 0)
1368 ld_file_name = find_a_file (&path,
1370 ? full_plugin_ld_suffix
1373 #ifdef REAL_NM_FILE_NAME
1374 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1375 if (nm_file_name == 0)
1377 nm_file_name = find_a_file (&cpath, gnm_suffix);
1378 if (nm_file_name == 0)
1379 nm_file_name = find_a_file (&path, full_gnm_suffix);
1380 if (nm_file_name == 0)
1381 nm_file_name = find_a_file (&cpath, nm_suffix);
1382 if (nm_file_name == 0)
1383 nm_file_name = find_a_file (&path, full_nm_suffix);
1386 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1387 if (ldd_file_name == 0)
1388 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1391 #ifdef REAL_STRIP_FILE_NAME
1392 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1393 if (strip_file_name == 0)
1395 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1396 if (strip_file_name == 0)
1397 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1398 if (strip_file_name == 0)
1399 strip_file_name = find_a_file (&cpath, strip_suffix);
1400 if (strip_file_name == 0)
1401 strip_file_name = find_a_file (&path, full_strip_suffix);
1403 /* Determine the full path name of the C compiler to use. */
1404 c_file_name = getenv ("COLLECT_GCC");
1405 if (c_file_name == 0)
1407 #ifdef CROSS_DIRECTORY_STRUCTURE
1408 c_file_name = concat (target_machine, "-gcc", NULL);
1410 c_file_name = "gcc";
1414 p = find_a_file (&cpath, c_file_name);
1416 /* Here it should be safe to use the system search path since we should have
1417 already qualified the name of the compiler when it is needed. */
1419 p = find_a_file (&path, c_file_name);
1424 *ld1++ = *ld2++ = ld_file_name;
1426 /* Make temp file names. */
1427 c_file = make_temp_file (".c");
1428 o_file = make_temp_file (".o");
1429 #ifdef COLLECT_EXPORT_LIST
1430 export_file = make_temp_file (".x");
1432 ldout = make_temp_file (".ld");
1433 lderrout = make_temp_file (".le");
1434 *c_ptr++ = c_file_name;
1441 #ifdef COLLECT_EXPORT_LIST
1442 /* Generate a list of directories from LIBPATH. */
1443 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1444 /* Add to this list also two standard directories where
1445 AIX loader always searches for libraries. */
1446 add_prefix (&libpath_lib_dirs, "/lib");
1447 add_prefix (&libpath_lib_dirs, "/usr/lib");
1450 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1452 AIX support needs to know if -shared has been specified before
1453 parsing commandline arguments. */
1455 p = getenv ("COLLECT_GCC_OPTIONS");
1458 const char *q = extract_string (&p);
1459 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1460 *c_ptr++ = xstrdup (q);
1461 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1462 *c_ptr++ = xstrdup (q);
1463 if (strcmp (q, "-shared") == 0)
1465 if (*q == '-' && q[1] == 'B')
1467 *c_ptr++ = xstrdup (q);
1470 q = extract_string (&p);
1471 *c_ptr++ = xstrdup (q);
1474 if (use_verbose && *q == '-' && q[1] == 'v' && q[2] == 0)
1476 /* Turn on trace in collect2 if needed. */
1480 obstack_free (&temporary_obstack, temporary_firstobj);
1481 *c_ptr++ = "-fno-profile-arcs";
1482 *c_ptr++ = "-fno-test-coverage";
1483 *c_ptr++ = "-fno-branch-probabilities";
1484 *c_ptr++ = "-fno-exceptions";
1486 *c_ptr++ = "-fno-whole-program";
1488 /* !!! When GCC calls collect2,
1489 it does not know whether it is calling collect2 or ld.
1490 So collect2 cannot meaningfully understand any options
1491 except those ld understands.
1492 If you propose to make GCC pass some other option,
1493 just imagine what will happen if ld is really ld!!! */
1495 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1496 /* After the first file, put in the c++ rt0. */
1499 #ifdef HAVE_LD_DEMANGLE
1500 if (!demangle_flag && !no_demangle)
1501 demangle_flag = "--demangle";
1503 *ld1++ = *ld2++ = demangle_flag;
1505 while ((arg = *++argv) != (char *) 0)
1507 *ld1++ = *ld2++ = arg;
1514 if (!strcmp (arg, "-debug"))
1516 /* Already parsed. */
1520 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1523 *ld1++ = *ld2++ = *argv;
1528 if (strcmp (arg, "-flto") == 0 || strcmp (arg, "-fwhopr") == 0)
1531 /* Do not pass LTO flag to the linker. */
1535 error ("LTO support has not been enabled in this "
1544 /* place o_file BEFORE this argument! */
1550 #ifdef COLLECT_EXPORT_LIST
1552 /* Resolving full library name. */
1553 const char *s = resolve_lib_name (arg+2);
1555 /* Saving a full library name. */
1556 add_to_list (&libs, s);
1561 #ifdef COLLECT_EXPORT_LIST
1562 /* Saving directories where to search for libraries. */
1564 add_prefix (&cmdline_lib_dirs, arg+2);
1567 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1569 if (is_in_args (arg,
1570 CONST_CAST2 (const char **, char **, ld1_argv),
1574 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1579 output_file = *ld1++ = *ld2++ = *++argv;
1581 #ifdef SWITCHES_NEED_SPACES
1582 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1586 output_file = &arg[2];
1595 if (arg[2] == '\0' && do_collecting)
1597 /* We must strip after the nm run, otherwise C++ linking
1598 will not work. Thus we strip in the second ld run, or
1599 else with strip if there is no second ld run. */
1611 if (strcmp (arg, "--no-demangle") == 0)
1613 demangle_flag = arg;
1618 else if (strncmp (arg, "--demangle", 10) == 0)
1620 demangle_flag = arg;
1622 #ifndef HAVE_LD_DEMANGLE
1625 enum demangling_styles style
1626 = cplus_demangle_name_to_style (arg+11);
1627 if (style == unknown_demangling)
1628 error ("unknown demangling style '%s'", arg+11);
1630 current_demangling_style = style;
1636 else if (strncmp (arg, "--sysroot=", 10) == 0)
1637 target_system_root = arg + 10;
1638 else if (strncmp (arg, "--version", 9) == 0)
1640 else if (strncmp (arg, "--help", 9) == 0)
1645 else if ((p = strrchr (arg, '.')) != (char *) 0
1646 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1647 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1648 || strcmp (p, ".obj") == 0))
1657 /* place o_file BEFORE this argument! */
1663 if (p[1] == 'o' || p[1] == 'l')
1665 #ifdef COLLECT_EXPORT_LIST
1666 /* libraries can be specified directly, i.e. without -l flag. */
1669 /* Saving a full library name. */
1670 add_to_list (&libs, arg);
1676 #ifdef COLLECT_EXPORT_LIST
1677 /* This is added only for debugging purposes. */
1680 fprintf (stderr, "List of libraries:\n");
1681 dump_list (stderr, "\t", libs.first);
1684 /* The AIX linker will discard static constructors in object files if
1685 nothing else in the file is referenced, so look at them first. Unless
1686 we are building a shared object, ignore the eh frame tables, as we
1687 would otherwise reference them all, hence drag all the corresponding
1688 objects even if nothing else is referenced. */
1690 const char **export_object_lst
1691 = CONST_CAST2 (const char **, char **, object_lst);
1693 struct id *list = libs.first;
1695 /* Compute the filter to use from the current one, do scan, then adjust
1696 the "current" filter to remove what we just included here. This will
1697 control whether we need a first pass link later on or not, and what
1698 will remain to be scanned there. */
1700 scanfilter this_filter = ld1_filter;
1703 this_filter &= ~SCAN_DWEH;
1706 while (export_object_lst < object)
1707 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1709 for (; list; list = list->next)
1710 scan_prog_file (list->name, PASS_FIRST, this_filter);
1712 ld1_filter = ld1_filter & ~this_filter;
1717 char *buf = concat ("-bE:", export_file, NULL);
1722 exportf = fopen (export_file, "w");
1723 if (exportf == (FILE *) 0)
1724 fatal_perror ("fopen %s", export_file);
1725 write_aix_file (exportf, exports.first);
1726 if (fclose (exportf))
1727 fatal_perror ("fclose %s", export_file);
1732 *c_ptr = *ld1 = *object = (char *) 0;
1736 notice ("collect2 version %s", version_string);
1737 #ifdef TARGET_VERSION
1740 fprintf (stderr, "\n");
1745 fprintf (stderr, "Usage: collect2 [options]\n");
1746 fprintf (stderr, " Wrap linker and generate constructor code if needed.\n");
1747 fprintf (stderr, " Options:\n");
1748 fprintf (stderr, " -debug Enable debug output\n");
1749 fprintf (stderr, " --help Display this information\n");
1750 fprintf (stderr, " -v, --version Display this program's version number\n");
1751 fprintf (stderr, "Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1752 fprintf (stderr, "Report bugs: %s\n", bug_report_url);
1760 fprintf (stderr, "ld_file_name = %s\n",
1761 (ld_file_name ? ld_file_name : "not found"));
1762 fprintf (stderr, "c_file_name = %s\n",
1763 (c_file_name ? c_file_name : "not found"));
1764 fprintf (stderr, "nm_file_name = %s\n",
1765 (nm_file_name ? nm_file_name : "not found"));
1767 fprintf (stderr, "ldd_file_name = %s\n",
1768 (ldd_file_name ? ldd_file_name : "not found"));
1770 fprintf (stderr, "strip_file_name = %s\n",
1771 (strip_file_name ? strip_file_name : "not found"));
1772 fprintf (stderr, "c_file = %s\n",
1773 (c_file ? c_file : "not found"));
1774 fprintf (stderr, "o_file = %s\n",
1775 (o_file ? o_file : "not found"));
1777 ptr = getenv ("COLLECT_GCC_OPTIONS");
1779 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1781 ptr = getenv ("COLLECT_GCC");
1783 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1785 ptr = getenv ("COMPILER_PATH");
1787 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1789 ptr = getenv (LIBRARY_PATH_ENV);
1791 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1793 fprintf (stderr, "\n");
1796 /* Load the program, searching all libraries and attempting to provide
1797 undefined symbols from repository information.
1799 If -r or they will be run via some other method, do not build the
1800 constructor or destructor list, just return now. */
1803 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1805 /* Perform the first pass link now, if we're about to exit or if we need
1806 to scan for things we haven't collected yet before pursuing further.
1808 On AIX, the latter typically includes nothing for shared objects or
1809 frame tables for an executable, out of what the required early scan on
1810 objects and libraries has performed above. In the !shared_obj case, we
1811 expect the relevant tables to be dragged together with their associated
1812 functions from precise cross reference insertions by the compiler. */
1814 if (early_exit || ld1_filter != SCAN_NOTHING)
1815 do_tlink (ld1_argv, object_lst);
1819 #ifdef COLLECT_EXPORT_LIST
1820 /* Make sure we delete the export file we may have created. */
1821 if (export_file != 0 && export_file[0])
1822 maybe_unlink (export_file);
1825 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1827 maybe_unlink (c_file);
1828 maybe_unlink (o_file);
1833 /* Unless we have done it all already, examine the namelist and search for
1834 static constructors and destructors to call. Write the constructor and
1835 destructor tables to a .s file and reload. */
1837 if (ld1_filter != SCAN_NOTHING)
1838 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1840 #ifdef SCAN_LIBRARIES
1841 scan_libraries (output_file);
1846 notice_translated (ngettext ("%d constructor found\n",
1847 "%d constructors found\n",
1848 constructors.number),
1849 constructors.number);
1850 notice_translated (ngettext ("%d destructor found\n",
1851 "%d destructors found\n",
1852 destructors.number),
1853 destructors.number);
1854 notice_translated (ngettext("%d frame table found\n",
1855 "%d frame tables found\n",
1856 frame_tables.number),
1857 frame_tables.number);
1860 /* If the scan exposed nothing of special interest, there's no need to
1861 generate the glue code and relink so return now. */
1863 if (constructors.number == 0 && destructors.number == 0
1864 && frame_tables.number == 0
1865 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1866 /* If we will be running these functions ourselves, we want to emit
1867 stubs into the shared library so that we do not have to relink
1868 dependent programs when we add static objects. */
1873 /* Do tlink without additional code generation now if we didn't
1874 do it earlier for scanning purposes. */
1875 if (ld1_filter == SCAN_NOTHING)
1876 do_tlink (ld1_argv, object_lst);
1879 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1881 /* Strip now if it was requested on the command line. */
1884 char **real_strip_argv = XCNEWVEC (char *, 3);
1885 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1888 strip_argv[0] = strip_file_name;
1889 strip_argv[1] = output_file;
1890 strip_argv[2] = (char *) 0;
1891 fork_execute ("strip", real_strip_argv);
1894 #ifdef COLLECT_EXPORT_LIST
1895 maybe_unlink (export_file);
1897 maybe_unlink (c_file);
1898 maybe_unlink (o_file);
1902 /* Sort ctor and dtor lists by priority. */
1903 sort_ids (&constructors);
1904 sort_ids (&destructors);
1906 maybe_unlink(output_file);
1907 outf = fopen (c_file, "w");
1908 if (outf == (FILE *) 0)
1909 fatal_perror ("fopen %s", c_file);
1911 write_c_file (outf, c_file);
1914 fatal_perror ("fclose %s", c_file);
1916 /* Tell the linker that we have initializer and finalizer functions. */
1917 #ifdef LD_INIT_SWITCH
1918 #ifdef COLLECT_EXPORT_LIST
1919 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1921 *ld2++ = LD_INIT_SWITCH;
1923 *ld2++ = LD_FINI_SWITCH;
1928 #ifdef COLLECT_EXPORT_LIST
1931 /* If we did not add export flag to link arguments before, add it to
1932 second link phase now. No new exports should have been added. */
1933 if (! exports.first)
1934 *ld2++ = concat ("-bE:", export_file, NULL);
1936 #ifndef LD_INIT_SWITCH
1937 add_to_list (&exports, initname);
1938 add_to_list (&exports, fininame);
1939 add_to_list (&exports, "_GLOBAL__DI");
1940 add_to_list (&exports, "_GLOBAL__DD");
1942 exportf = fopen (export_file, "w");
1943 if (exportf == (FILE *) 0)
1944 fatal_perror ("fopen %s", export_file);
1945 write_aix_file (exportf, exports.first);
1946 if (fclose (exportf))
1947 fatal_perror ("fclose %s", export_file);
1951 /* End of arguments to second link phase. */
1956 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1957 output_file, c_file);
1958 write_c_file (stderr, "stderr");
1959 fprintf (stderr, "========== end of c_file\n\n");
1960 #ifdef COLLECT_EXPORT_LIST
1961 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1962 write_aix_file (stderr, exports.first);
1963 fprintf (stderr, "========== end of export_file\n\n");
1967 /* Assemble the constructor and destructor tables.
1968 Link the tables in with the rest of the program. */
1970 fork_execute ("gcc", c_argv);
1971 #ifdef COLLECT_EXPORT_LIST
1972 /* On AIX we must call tlink because of possible templates resolution. */
1973 do_tlink (ld2_argv, object_lst);
1976 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1978 /* Otherwise, simply call ld because tlink is already done. */
1980 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1982 fork_execute ("ld", ld2_argv);
1984 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1985 constructors/destructors in shared libraries. */
1986 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1989 maybe_unlink (c_file);
1990 maybe_unlink (o_file);
1992 #ifdef COLLECT_EXPORT_LIST
1993 maybe_unlink (export_file);
2000 /* Wait for a process to finish, and exit if a nonzero status is found. */
2003 collect_wait (const char *prog, struct pex_obj *pex)
2007 if (!pex_get_status (pex, 1, &status))
2008 fatal_perror ("can't get program status");
2013 if (WIFSIGNALED (status))
2015 int sig = WTERMSIG (status);
2016 error ("%s terminated with signal %d [%s]%s",
2017 prog, sig, strsignal(sig),
2018 WCOREDUMP(status) ? ", core dumped" : "");
2019 collect_exit (FATAL_EXIT_CODE);
2022 if (WIFEXITED (status))
2023 return WEXITSTATUS (status);
2029 do_wait (const char *prog, struct pex_obj *pex)
2031 int ret = collect_wait (prog, pex);
2034 error ("%s returned %d exit status", prog, ret);
2040 unlink (response_file);
2041 response_file = NULL;
2046 /* Execute a program, and wait for the reply. */
2049 collect_execute (const char *prog, char **argv, const char *outname,
2050 const char *errname, int flags)
2052 struct pex_obj *pex;
2055 char *response_arg = NULL;
2056 char *response_argv[3] ATTRIBUTE_UNUSED;
2058 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2060 /* If using @file arguments, create a temporary file and put the
2061 contents of argv into it. Then change argv to an array corresponding
2062 to a single argument @FILE, where FILE is the temporary filename. */
2064 char **current_argv = argv + 1;
2065 char *argv0 = argv[0];
2069 /* Note: we assume argv contains at least one element; this is
2072 response_file = make_temp_file ("");
2074 f = fopen (response_file, "w");
2077 fatal ("could not open response file %s", response_file);
2079 status = writeargv (current_argv, f);
2082 fatal ("could not write to response file %s", response_file);
2084 status = fclose (f);
2087 fatal ("could not close response file %s", response_file);
2089 response_arg = concat ("@", response_file, NULL);
2090 response_argv[0] = argv0;
2091 response_argv[1] = response_arg;
2092 response_argv[2] = NULL;
2094 argv = response_argv;
2103 fprintf (stderr, "%s", argv[0]);
2105 notice ("[cannot find %s]", prog);
2107 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2108 fprintf (stderr, " %s", str);
2110 fprintf (stderr, "\n");
2116 /* If we cannot find a program we need, complain error. Do this here
2117 since we might not end up needing something that we could not find. */
2120 fatal ("cannot find '%s'", prog);
2122 pex = pex_init (0, "collect2", NULL);
2124 fatal_perror ("pex_init failed");
2126 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2133 fatal_perror (errmsg);
2140 free (response_arg);
2146 fork_execute (const char *prog, char **argv)
2148 struct pex_obj *pex;
2150 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2151 do_wait (prog, pex);
2154 /* Unlink a file unless we are debugging. */
2157 maybe_unlink (const char *file)
2160 unlink_if_ordinary (file);
2162 notice ("[Leaving %s]\n", file);
2165 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2168 maybe_unlink_list (char **file_list)
2170 char **tmp = file_list;
2173 maybe_unlink (*(tmp++));
2177 static long sequence_number = 0;
2179 /* Add a name to a linked list. */
2182 add_to_list (struct head *head_ptr, const char *name)
2185 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2187 strcpy (newid->name, name);
2189 if (head_ptr->first)
2190 head_ptr->last->next = newid;
2192 head_ptr->first = newid;
2194 /* Check for duplicate symbols. */
2195 for (p = head_ptr->first;
2196 strcmp (name, p->name) != 0;
2201 head_ptr->last->next = 0;
2206 newid->sequence = ++sequence_number;
2207 head_ptr->last = newid;
2211 /* Grab the init priority number from an init function name that
2212 looks like "_GLOBAL_.I.12345.foo". */
2215 extract_init_priority (const char *name)
2219 while (name[pos] == '_')
2221 pos += 10; /* strlen ("GLOBAL__X_") */
2223 /* Extract init_p number from ctor/dtor name. */
2224 pri = atoi (name + pos);
2225 return pri ? pri : DEFAULT_INIT_PRIORITY;
2228 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2229 ctors will be run from right to left, dtors from left to right. */
2232 sort_ids (struct head *head_ptr)
2234 /* id holds the current element to insert. id_next holds the next
2235 element to insert. id_ptr iterates through the already sorted elements
2236 looking for the place to insert id. */
2237 struct id *id, *id_next, **id_ptr;
2239 id = head_ptr->first;
2241 /* We don't have any sorted elements yet. */
2242 head_ptr->first = NULL;
2244 for (; id; id = id_next)
2247 id->sequence = extract_init_priority (id->name);
2249 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2251 /* If the sequence numbers are the same, we put the id from the
2252 file later on the command line later in the list. */
2253 || id->sequence > (*id_ptr)->sequence
2254 /* Hack: do lexical compare, too.
2255 || (id->sequence == (*id_ptr)->sequence
2256 && strcmp (id->name, (*id_ptr)->name) > 0) */
2265 /* Now set the sequence numbers properly so write_c_file works. */
2266 for (id = head_ptr->first; id; id = id->next)
2267 id->sequence = ++sequence_number;
2270 /* Write: `prefix', the names on list LIST, `suffix'. */
2273 write_list (FILE *stream, const char *prefix, struct id *list)
2277 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2282 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2283 /* Given a STRING, return nonzero if it occurs in the list in range
2284 [ARGS_BEGIN,ARGS_END). */
2287 is_in_args (const char *string, const char **args_begin,
2288 const char **args_end)
2290 const char **args_pointer;
2291 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2292 if (strcmp (string, *args_pointer) == 0)
2296 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2298 #ifdef COLLECT_EXPORT_LIST
2299 /* This function is really used only on AIX, but may be useful. */
2302 is_in_list (const char *prefix, struct id *list)
2306 if (!strcmp (prefix, list->name)) return 1;
2312 #endif /* COLLECT_EXPORT_LIST */
2314 /* Added for debugging purpose. */
2315 #ifdef COLLECT_EXPORT_LIST
2317 dump_list (FILE *stream, const char *prefix, struct id *list)
2321 fprintf (stream, "%s%s,\n", prefix, list->name);
2329 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2333 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2340 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2344 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2345 prefix, list->sequence, list->name);
2350 /* Write out the constructor and destructor tables statically (for a shared
2351 object), along with the functions to execute them. */
2354 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2358 int frames = (frame_tables.number > 0);
2360 /* Figure out name of output_file, stripping off .so version. */
2361 p = strrchr (output_file, '/');
2377 if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2379 q += strlen (SHLIB_SUFFIX);
2386 /* q points to null at end of the string (or . of the .so version) */
2387 prefix = XNEWVEC (char, q - p + 1);
2388 strncpy (prefix, p, q - p);
2390 for (r = prefix; *r; r++)
2391 if (!ISALNUM ((unsigned char)*r))
2394 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2395 output_file, prefix);
2397 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2398 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2402 /* Write the tables as C code. */
2404 fprintf (stream, "static int count;\n");
2405 fprintf (stream, "typedef void entry_pt();\n");
2406 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2410 write_list_with_asm (stream, "extern void *", frame_tables.first);
2412 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2413 write_list (stream, "\t\t&", frame_tables.first);
2414 fprintf (stream, "\t0\n};\n");
2416 /* This must match what's in frame.h. */
2417 fprintf (stream, "struct object {\n");
2418 fprintf (stream, " void *pc_begin;\n");
2419 fprintf (stream, " void *pc_end;\n");
2420 fprintf (stream, " void *fde_begin;\n");
2421 fprintf (stream, " void *fde_array;\n");
2422 fprintf (stream, " __SIZE_TYPE__ count;\n");
2423 fprintf (stream, " struct object *next;\n");
2424 fprintf (stream, "};\n");
2426 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2427 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2429 fprintf (stream, "static void reg_frame () {\n");
2430 fprintf (stream, "\tstatic struct object ob;\n");
2431 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2432 fprintf (stream, "\t}\n");
2434 fprintf (stream, "static void dereg_frame () {\n");
2435 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2436 fprintf (stream, "\t}\n");
2439 fprintf (stream, "void %s() {\n", initname);
2440 if (constructors.number > 0 || frames)
2442 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2443 write_list (stream, "\t\t", constructors.first);
2445 fprintf (stream, "\treg_frame,\n");
2446 fprintf (stream, "\t};\n");
2447 fprintf (stream, "\tentry_pt **p;\n");
2448 fprintf (stream, "\tif (count++ != 0) return;\n");
2449 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2450 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2453 fprintf (stream, "\t++count;\n");
2454 fprintf (stream, "}\n");
2455 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2456 fprintf (stream, "void %s() {\n", fininame);
2457 if (destructors.number > 0 || frames)
2459 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2460 write_list (stream, "\t\t", destructors.first);
2462 fprintf (stream, "\tdereg_frame,\n");
2463 fprintf (stream, "\t};\n");
2464 fprintf (stream, "\tentry_pt **p;\n");
2465 fprintf (stream, "\tif (--count != 0) return;\n");
2466 fprintf (stream, "\tp = dtors;\n");
2467 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2468 destructors.number + frames);
2470 fprintf (stream, "}\n");
2474 COLLECT_SHARED_INIT_FUNC(stream, initname);
2475 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2479 /* Write the constructor/destructor tables. */
2481 #ifndef LD_INIT_SWITCH
2483 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2485 /* Write the tables as C code. */
2487 int frames = (frame_tables.number > 0);
2489 fprintf (stream, "typedef void entry_pt();\n\n");
2491 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2495 write_list_with_asm (stream, "extern void *", frame_tables.first);
2497 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2498 write_list (stream, "\t\t&", frame_tables.first);
2499 fprintf (stream, "\t0\n};\n");
2501 /* This must match what's in frame.h. */
2502 fprintf (stream, "struct object {\n");
2503 fprintf (stream, " void *pc_begin;\n");
2504 fprintf (stream, " void *pc_end;\n");
2505 fprintf (stream, " void *fde_begin;\n");
2506 fprintf (stream, " void *fde_array;\n");
2507 fprintf (stream, " __SIZE_TYPE__ count;\n");
2508 fprintf (stream, " struct object *next;\n");
2509 fprintf (stream, "};\n");
2511 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2512 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2514 fprintf (stream, "static void reg_frame () {\n");
2515 fprintf (stream, "\tstatic struct object ob;\n");
2516 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2517 fprintf (stream, "\t}\n");
2519 fprintf (stream, "static void dereg_frame () {\n");
2520 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2521 fprintf (stream, "\t}\n");
2524 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2525 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2526 write_list (stream, "\t", constructors.first);
2528 fprintf (stream, "\treg_frame,\n");
2529 fprintf (stream, "\t0\n};\n\n");
2531 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2533 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2534 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2535 write_list (stream, "\t", destructors.first);
2537 fprintf (stream, "\tdereg_frame,\n");
2538 fprintf (stream, "\t0\n};\n\n");
2540 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2541 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2543 #endif /* ! LD_INIT_SWITCH */
2546 write_c_file (FILE *stream, const char *name)
2548 #ifndef LD_INIT_SWITCH
2550 write_c_file_glob (stream, name);
2553 write_c_file_stat (stream, name);
2556 #ifdef COLLECT_EXPORT_LIST
2558 write_aix_file (FILE *stream, struct id *list)
2560 for (; list; list = list->next)
2562 fputs (list->name, stream);
2563 putc ('\n', stream);
2568 #ifdef OBJECT_FORMAT_NONE
2570 /* Check to make sure the file is an ELF file. LTO objects must
2571 be in ELF format. */
2574 is_elf_or_coff (const char *prog_name)
2578 static char magic[4] = { 0x7f, 'E', 'L', 'F' };
2579 static char coffmag[2] = { 0x4c, 0x01 };
2581 f = fopen (prog_name, "rb");
2584 if (fread (buf, sizeof (buf), 1, f) != 1)
2587 return memcmp (buf, magic, sizeof (magic)) == 0
2588 || memcmp (buf, coffmag, sizeof (coffmag)) == 0;
2591 /* Generic version to scan the name list of the loaded program for
2592 the symbols g++ uses for static constructors and destructors. */
2595 scan_prog_file (const char *prog_name, scanpass which_pass,
2598 void (*int_handler) (int);
2600 void (*quit_handler) (int);
2602 char *real_nm_argv[4];
2603 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2605 struct pex_obj *pex;
2612 if (which_pass == PASS_SECOND)
2615 /* LTO objects must be in a known format. This check prevents
2616 us from accepting an archive containing LTO objects, which
2617 gcc cannnot currently handle. */
2618 if (which_pass == PASS_LTOINFO && !is_elf_or_coff (prog_name))
2621 /* If we do not have an `nm', complain. */
2622 if (nm_file_name == 0)
2623 fatal ("cannot find 'nm'");
2625 nm_argv[argc++] = nm_file_name;
2626 if (NM_FLAGS[0] != '\0')
2627 nm_argv[argc++] = NM_FLAGS;
2629 nm_argv[argc++] = prog_name;
2630 nm_argv[argc++] = (char *) 0;
2632 /* Trace if needed. */
2635 const char **p_argv;
2638 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2639 fprintf (stderr, " %s", str);
2641 fprintf (stderr, "\n");
2647 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2649 fatal_perror ("pex_init failed");
2651 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2658 fatal_perror (errmsg);
2664 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2666 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2669 inf = pex_read_output (pex, 0);
2671 fatal_perror ("can't open nm output");
2675 if (which_pass == PASS_LTOINFO)
2676 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2678 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2681 /* Read each line of nm output. */
2682 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2688 fprintf (stderr, "\t%s\n", buf);
2690 if (which_pass == PASS_LTOINFO)
2695 /* Look for the LTO info marker symbol, and add filename to
2696 the LTO objects list if found. */
2697 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2698 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2699 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2700 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2702 add_lto_object (<o_objects, prog_name);
2704 /* We need to read all the input, so we can't just
2705 return here. But we can avoid useless work. */
2714 /* If it contains a constructor or destructor name, add the name
2715 to the appropriate list unless this is a kind of symbol we're
2716 not supposed to even consider. */
2718 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2719 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2726 /* Find the end of the symbol name.
2727 Do not include `|', because Encore nm can tack that on the end. */
2728 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2734 switch (is_ctor_dtor (name))
2737 if (! (filter & SCAN_CTOR))
2739 if (which_pass != PASS_LIB)
2740 add_to_list (&constructors, name);
2744 if (! (filter & SCAN_DTOR))
2746 if (which_pass != PASS_LIB)
2747 add_to_list (&destructors, name);
2751 if (! (filter & SCAN_INIT))
2753 if (which_pass != PASS_LIB)
2754 fatal ("init function found in object %s", prog_name);
2755 #ifndef LD_INIT_SWITCH
2756 add_to_list (&constructors, name);
2761 if (! (filter & SCAN_FINI))
2763 if (which_pass != PASS_LIB)
2764 fatal ("fini function found in object %s", prog_name);
2765 #ifndef LD_FINI_SWITCH
2766 add_to_list (&destructors, name);
2771 if (! (filter & SCAN_DWEH))
2773 if (which_pass != PASS_LIB)
2774 add_to_list (&frame_tables, name);
2777 default: /* not a constructor or destructor */
2783 fprintf (stderr, "\n");
2785 do_wait (nm_file_name, pex);
2787 signal (SIGINT, int_handler);
2789 signal (SIGQUIT, quit_handler);
2795 /* Use the List Dynamic Dependencies program to find shared libraries that
2796 the output file depends upon and their initialization/finalization
2797 routines, if any. */
2800 scan_libraries (const char *prog_name)
2802 static struct head libraries; /* list of shared libraries found */
2804 void (*int_handler) (int);
2806 void (*quit_handler) (int);
2808 char *real_ldd_argv[4];
2809 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2811 struct pex_obj *pex;
2817 /* If we do not have an `ldd', complain. */
2818 if (ldd_file_name == 0)
2820 error ("cannot find 'ldd'");
2824 ldd_argv[argc++] = ldd_file_name;
2825 ldd_argv[argc++] = prog_name;
2826 ldd_argv[argc++] = (char *) 0;
2828 /* Trace if needed. */
2831 const char **p_argv;
2834 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2835 fprintf (stderr, " %s", str);
2837 fprintf (stderr, "\n");
2843 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2845 fatal_perror ("pex_init failed");
2847 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2853 fatal_perror (errmsg);
2859 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2861 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2864 inf = pex_read_output (pex, 0);
2866 fatal_perror ("can't open ldd output");
2869 notice ("\nldd output with constructors/destructors.\n");
2871 /* Read each line of ldd output. */
2872 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2875 char *name, *end, *p = buf;
2877 /* Extract names of libraries and add to list. */
2878 PARSE_LDD_OUTPUT (p);
2883 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2884 fatal ("dynamic dependency %s not found", buf);
2886 /* Find the end of the symbol name. */
2888 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2893 if (access (name, R_OK) == 0)
2894 add_to_list (&libraries, name);
2896 fatal ("unable to open dynamic dependency '%s'", buf);
2899 fprintf (stderr, "\t%s\n", buf);
2902 fprintf (stderr, "\n");
2904 do_wait (ldd_file_name, pex);
2906 signal (SIGINT, int_handler);
2908 signal (SIGQUIT, quit_handler);
2911 /* Now iterate through the library list adding their symbols to
2913 for (list = libraries.first; list; list = list->next)
2914 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2917 #endif /* LDD_SUFFIX */
2919 #endif /* OBJECT_FORMAT_NONE */
2923 * COFF specific stuff.
2926 #ifdef OBJECT_FORMAT_COFF
2928 #if defined (EXTENDED_COFF)
2930 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2931 # define GCC_SYMENT SYMR
2932 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2933 # define GCC_SYMINC(X) (1)
2934 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2935 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2939 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2940 # define GCC_SYMENT SYMENT
2941 # if defined (C_WEAKEXT)
2942 # define GCC_OK_SYMBOL(X) \
2943 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2944 ((X).n_scnum > N_UNDEF) && \
2946 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2947 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2948 # define GCC_UNDEF_SYMBOL(X) \
2949 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2950 ((X).n_scnum == N_UNDEF))
2952 # define GCC_OK_SYMBOL(X) \
2953 (((X).n_sclass == C_EXT) && \
2954 ((X).n_scnum > N_UNDEF) && \
2956 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2957 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2958 # define GCC_UNDEF_SYMBOL(X) \
2959 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2961 # define GCC_SYMINC(X) ((X).n_numaux+1)
2962 # define GCC_SYMZERO(X) 0
2964 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2965 #if TARGET_AIX_VERSION >= 51
2966 # define GCC_CHECK_HDR(X) \
2967 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2968 || (HEADER (X).f_magic == 0767 && aix64_flag))
2970 # define GCC_CHECK_HDR(X) \
2971 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2972 || (HEADER (X).f_magic == 0757 && aix64_flag))
2977 #ifdef COLLECT_EXPORT_LIST
2978 /* Array of standard AIX libraries which should not
2979 be scanned for ctors/dtors. */
2980 static const char *const aix_std_libs[] = {
2988 "/usr/lib/libc_r.a",
2989 "/usr/lib/libm_r.a",
2990 "/usr/lib/threads/libc.a",
2991 "/usr/ccs/lib/libc.a",
2992 "/usr/ccs/lib/libm.a",
2993 "/usr/ccs/lib/libc_r.a",
2994 "/usr/ccs/lib/libm_r.a",
2998 /* This function checks the filename and returns 1
2999 if this name matches the location of a standard AIX library. */
3000 static int ignore_library (const char *);
3002 ignore_library (const char *name)
3004 const char *const *p;
3007 if (target_system_root[0] != '\0')
3009 length = strlen (target_system_root);
3010 if (strncmp (name, target_system_root, length) != 0)
3014 for (p = &aix_std_libs[0]; *p != NULL; ++p)
3015 if (strcmp (name, *p) == 0)
3019 #endif /* COLLECT_EXPORT_LIST */
3021 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
3022 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
3025 /* COFF version to scan the name list of the loaded program for
3026 the symbols g++ uses for static constructors and destructors. */
3029 scan_prog_file (const char *prog_name, scanpass which_pass,
3032 LDFILE *ldptr = NULL;
3033 int sym_index, sym_count;
3036 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3039 #ifdef COLLECT_EXPORT_LIST
3040 /* We do not need scanning for some standard C libraries. */
3041 if (which_pass == PASS_FIRST && ignore_library (prog_name))
3044 /* On AIX we have a loop, because there is not much difference
3045 between an object and an archive. This trick allows us to
3046 eliminate scan_libraries() function. */
3050 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3051 non-const char * filename parameter, even though it will not
3052 modify that string. So we must cast away const-ness here,
3053 using CONST_CAST to prevent complaints from -Wcast-qual. */
3054 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3056 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3057 fatal ("%s: not a COFF file", prog_name);
3059 if (GCC_CHECK_HDR (ldptr))
3061 sym_count = GCC_SYMBOLS (ldptr);
3062 sym_index = GCC_SYMZERO (ldptr);
3064 #ifdef COLLECT_EXPORT_LIST
3065 /* Is current archive member a shared object? */
3066 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3069 while (sym_index < sym_count)
3073 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3075 sym_index += GCC_SYMINC (symbol);
3077 if (GCC_OK_SYMBOL (symbol))
3081 if ((name = ldgetname (ldptr, &symbol)) == NULL)
3082 continue; /* Should never happen. */
3084 #ifdef XCOFF_DEBUGGING_INFO
3085 /* All AIX function names have a duplicate entry
3086 beginning with a dot. */
3091 switch (is_ctor_dtor (name))
3094 if (! (filter & SCAN_CTOR))
3097 add_to_list (&constructors, name);
3098 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3099 if (which_pass == PASS_OBJ)
3100 add_to_list (&exports, name);
3105 if (! (filter & SCAN_DTOR))
3108 add_to_list (&destructors, name);
3109 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3110 if (which_pass == PASS_OBJ)
3111 add_to_list (&exports, name);
3115 #ifdef COLLECT_EXPORT_LIST
3117 if (! (filter & SCAN_INIT))
3119 #ifndef LD_INIT_SWITCH
3121 add_to_list (&constructors, name);
3126 if (! (filter & SCAN_FINI))
3128 #ifndef LD_INIT_SWITCH
3130 add_to_list (&destructors, name);
3136 if (! (filter & SCAN_DWEH))
3139 add_to_list (&frame_tables, name);
3140 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3141 if (which_pass == PASS_OBJ)
3142 add_to_list (&exports, name);
3146 default: /* not a constructor or destructor */
3147 #ifdef COLLECT_EXPORT_LIST
3148 /* Explicitly export all global symbols when
3149 building a shared object on AIX, but do not
3150 re-export symbols from another shared object
3151 and do not export symbols if the user
3152 provides an explicit export list. */
3153 if (shared_obj && !is_shared
3154 && which_pass == PASS_OBJ && !export_flag)
3155 add_to_list (&exports, name);
3161 #if !defined(EXTENDED_COFF)
3162 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3163 symbol.n_scnum, symbol.n_sclass,
3164 (symbol.n_type ? "0" : ""), symbol.n_type,
3168 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3169 symbol.iss, (long) symbol.value, symbol.index, name);
3174 #ifdef COLLECT_EXPORT_LIST
3177 /* If archive contains both 32-bit and 64-bit objects,
3178 we want to skip objects in other mode so mismatch normal. */
3180 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3181 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3187 fatal ("%s: cannot open as COFF file", prog_name);
3189 #ifdef COLLECT_EXPORT_LIST
3190 /* On AIX loop continues while there are more members in archive. */
3192 while (ldclose (ldptr) == FAILURE);
3194 /* Otherwise we simply close ldptr. */
3195 (void) ldclose(ldptr);
3198 #endif /* OBJECT_FORMAT_COFF */
3200 #ifdef COLLECT_EXPORT_LIST
3201 /* Given a library name without "lib" prefix, this function
3202 returns a full library name including a path. */
3204 resolve_lib_name (const char *name)
3208 /* Library extensions for AIX dynamic linking. */
3209 const char * const libexts[2] = {"a", "so"};
3211 for (i = 0; libpaths[i]; i++)
3212 if (libpaths[i]->max_len > l)
3213 l = libpaths[i]->max_len;
3215 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3217 for (i = 0; libpaths[i]; i++)
3219 struct prefix_list *list = libpaths[i]->plist;
3220 for (; list; list = list->next)
3222 /* The following lines are needed because path_prefix list
3223 may contain directories both with trailing '/' and
3226 if (list->prefix[strlen(list->prefix)-1] != '/')
3228 for (j = 0; j < 2; j++)
3230 sprintf (lib_buf, "%s%slib%s.%s",
3231 list->prefix, p, name,
3232 libexts[(j + aixrtl_flag) % 2]);
3233 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3234 if (file_exists (lib_buf))
3236 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3243 fprintf (stderr, "not found\n");
3245 fatal ("library lib%s not found", name);
3248 #endif /* COLLECT_EXPORT_LIST */