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, 2011
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"
33 #include "filenames.h"
35 /* TARGET_64BIT may be defined to use driver specific functionality. */
37 #define TARGET_64BIT TARGET_64BIT_DEFAULT
39 #ifndef LIBRARY_PATH_ENV
40 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
46 #include "collect2-aix.h"
47 #include "diagnostic.h"
53 /* On certain systems, we have code that works by scanning the object file
54 directly. But this code uses system-specific header files and library
55 functions, so turn it off in a cross-compiler. Likewise, the names of
56 the utilities are not correct for a cross-compiler; we have to hope that
57 cross-versions are in the proper directories. */
59 #ifdef CROSS_DIRECTORY_STRUCTURE
60 #ifndef CROSS_AIX_SUPPORT
61 #undef OBJECT_FORMAT_COFF
64 #undef REAL_LD_FILE_NAME
65 #undef REAL_NM_FILE_NAME
66 #undef REAL_STRIP_FILE_NAME
69 /* If we cannot use a special method, use the ordinary one:
70 run nm to find what symbols are present.
71 In a cross-compiler, this means you need a cross nm,
72 but that is not quite as unpleasant as special headers. */
74 #if !defined (OBJECT_FORMAT_COFF)
75 #define OBJECT_FORMAT_NONE
78 #ifdef OBJECT_FORMAT_COFF
80 #ifndef CROSS_DIRECTORY_STRUCTURE
88 /* Many versions of ldfcn.h define these. */
97 /* Some systems have an ISCOFF macro, but others do not. In some cases
98 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
99 that either do not have an ISCOFF macro in /usr/include or for those
100 where it is wrong. */
103 #define MY_ISCOFF(X) ISCOFF (X)
106 #endif /* OBJECT_FORMAT_COFF */
108 #ifdef OBJECT_FORMAT_NONE
110 /* Default flags to pass to nm. */
112 #define NM_FLAGS "-n"
115 #endif /* OBJECT_FORMAT_NONE */
117 /* Some systems use __main in a way incompatible with its use in gcc, in these
118 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
119 give the same symbol without quotes for an alternative entry point. */
121 #define NAME__MAIN "__main"
124 /* This must match tree.h. */
125 #define DEFAULT_INIT_PRIORITY 65535
127 #ifndef COLLECT_SHARED_INIT_FUNC
128 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
129 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
131 #ifndef COLLECT_SHARED_FINI_FUNC
132 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
133 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
137 #define SCAN_LIBRARIES
141 #define SHLIB_SUFFIX ".so"
145 int do_collecting = 1;
147 int do_collecting = 0;
150 /* Cook up an always defined indication of whether we proceed the
151 "EXPORT_LIST" way. */
153 #ifdef COLLECT_EXPORT_LIST
154 #define DO_COLLECT_EXPORT_LIST 1
156 #define DO_COLLECT_EXPORT_LIST 0
159 /* Nonzero if we should suppress the automatic demangling of identifiers
160 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
163 /* Linked lists of constructor and destructor names. */
179 bool vflag; /* true if -v or --version */
180 static int rflag; /* true if -r */
181 static int strip_flag; /* true if -s */
182 #ifdef COLLECT_EXPORT_LIST
183 static int export_flag; /* true if -bE */
184 static int aix64_flag; /* true if -b64 */
185 static int aixrtl_flag; /* true if -brtl */
189 LTO_MODE_NONE, /* Not doing LTO. */
190 LTO_MODE_LTO, /* Normal LTO. */
191 LTO_MODE_WHOPR /* WHOPR. */
194 /* Current LTO mode. */
195 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
197 bool debug; /* true if -debug */
198 bool helpflag; /* true if --help */
200 static int shared_obj; /* true if -shared */
202 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
203 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
204 #ifdef COLLECT_EXPORT_LIST
205 static const char *export_file; /* <xxx>.x for AIX export list. */
207 static char **lto_o_files; /* Output files for LTO. */
208 const char *ldout; /* File for ld stdout. */
209 const char *lderrout; /* File for ld stderr. */
210 static const char *output_file; /* Output file for ld. */
211 static const char *nm_file_name; /* pathname of nm */
213 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
215 static const char *strip_file_name; /* pathname of strip */
216 const char *c_file_name; /* pathname of gcc */
217 static char *initname, *fininame; /* names of init and fini funcs */
219 static struct head constructors; /* list of constructors found */
220 static struct head destructors; /* list of destructors found */
221 #ifdef COLLECT_EXPORT_LIST
222 static struct head exports; /* list of exported symbols */
224 static struct head frame_tables; /* list of frame unwind info tables */
226 static bool at_file_supplied; /* Whether to use @file arguments */
227 static char *response_file; /* Name of any current response file */
229 struct obstack temporary_obstack;
230 char * temporary_firstobj;
232 /* A string that must be prepended to a target OS path in order to find
233 it on the host system. */
234 #ifdef TARGET_SYSTEM_ROOT
235 static const char *target_system_root = TARGET_SYSTEM_ROOT;
237 static const char *target_system_root = "";
240 /* Structure to hold all the directories in which to search for files to
245 const char *prefix; /* String to prepend to the path. */
246 struct prefix_list *next; /* Next in linked list. */
251 struct prefix_list *plist; /* List of prefixes to try */
252 int max_len; /* Max length of a prefix in PLIST */
253 const char *name; /* Name of this list (used in config stuff) */
256 #ifdef COLLECT_EXPORT_LIST
257 /* Lists to keep libraries to be scanned for global constructors/destructors. */
258 static struct head libs; /* list of libraries */
259 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
260 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
261 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
262 &libpath_lib_dirs, NULL};
265 /* List of names of object files containing LTO information.
266 These are a subset of the object file names appearing on the
267 command line, and must be identical, in the sense of pointer
268 equality, with the names passed to maybe_run_lto_and_relink(). */
272 const char *name; /* Name of object file. */
273 struct lto_object *next; /* Next in linked list. */
276 struct lto_object_list
278 struct lto_object *first; /* First list element. */
279 struct lto_object *last; /* Last list element. */
282 static struct lto_object_list lto_objects;
284 /* Special kinds of symbols that a name may denote. */
287 SYM_REGULAR = 0, /* nothing special */
289 SYM_CTOR = 1, /* constructor */
290 SYM_DTOR = 2, /* destructor */
291 SYM_INIT = 3, /* shared object routine that calls all the ctors */
292 SYM_FINI = 4, /* shared object routine that calls all the dtors */
293 SYM_DWEH = 5 /* DWARF exception handling table */
296 static symkind is_ctor_dtor (const char *);
298 static void handler (int);
299 static char *find_a_file (struct path_prefix *, const char *);
300 static void add_prefix (struct path_prefix *, const char *);
301 static void prefix_from_env (const char *, struct path_prefix *);
302 static void prefix_from_string (const char *, struct path_prefix *);
303 static void do_wait (const char *, struct pex_obj *);
304 static void fork_execute (const char *, char **);
305 static void maybe_unlink (const char *);
306 static void maybe_unlink_list (char **);
307 static void add_to_list (struct head *, const char *);
308 static int extract_init_priority (const char *);
309 static void sort_ids (struct head *);
310 static void write_list (FILE *, const char *, struct id *);
311 #ifdef COLLECT_EXPORT_LIST
312 static void dump_list (FILE *, const char *, struct id *);
315 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
317 static void write_list_with_asm (FILE *, const char *, struct id *);
318 static void write_c_file (FILE *, const char *);
319 static void write_c_file_stat (FILE *, const char *);
320 #ifndef LD_INIT_SWITCH
321 static void write_c_file_glob (FILE *, const char *);
323 #ifdef SCAN_LIBRARIES
324 static void scan_libraries (const char *);
326 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
327 static int is_in_args (const char *, const char **, const char **);
329 #ifdef COLLECT_EXPORT_LIST
331 static int is_in_list (const char *, struct id *);
333 static void write_aix_file (FILE *, struct id *);
334 static char *resolve_lib_name (const char *);
336 static char *extract_string (const char **);
337 static void post_ld_pass (bool);
338 static void process_args (int *argcp, char **argv);
340 /* Enumerations describing which pass this is for scanning the
344 PASS_FIRST, /* without constructors */
345 PASS_OBJ, /* individual objects */
346 PASS_LIB, /* looking for shared libraries */
347 PASS_SECOND, /* with constructors linked in */
348 PASS_LTOINFO /* looking for objects with LTO info */
351 /* ... and which kinds of symbols are to be considered. */
353 enum scanfilter_masks {
356 SCAN_CTOR = 1 << SYM_CTOR,
357 SCAN_DTOR = 1 << SYM_DTOR,
358 SCAN_INIT = 1 << SYM_INIT,
359 SCAN_FINI = 1 << SYM_FINI,
360 SCAN_DWEH = 1 << SYM_DWEH,
364 /* This type is used for parameters and variables which hold
365 combinations of the flags in enum scanfilter_masks. */
366 typedef int scanfilter;
368 /* Scan the name list of the loaded program for the symbols g++ uses for
369 static constructors and destructors.
371 The SCANPASS argument tells which collect processing pass this is for and
372 the SCANFILTER argument tells which kinds of symbols to consider in this
373 pass. Symbols of a special kind not in the filter mask are considered as
376 The constructor table begins at __CTOR_LIST__ and contains a count of the
377 number of pointers (or -1 if the constructors are built in a separate
378 section by the linker), followed by the pointers to the constructor
379 functions, terminated with a null pointer. The destructor table has the
380 same format, and begins at __DTOR_LIST__. */
382 static void scan_prog_file (const char *, scanpass, scanfilter);
385 /* Delete tempfiles and exit function. */
388 collect_exit (int status)
390 if (c_file != 0 && c_file[0])
391 maybe_unlink (c_file);
393 if (o_file != 0 && o_file[0])
394 maybe_unlink (o_file);
396 #ifdef COLLECT_EXPORT_LIST
397 if (export_file != 0 && export_file[0])
398 maybe_unlink (export_file);
402 maybe_unlink_list (lto_o_files);
404 if (ldout != 0 && ldout[0])
406 dump_file (ldout, stdout);
407 maybe_unlink (ldout);
410 if (lderrout != 0 && lderrout[0])
412 dump_file (lderrout, stderr);
413 maybe_unlink (lderrout);
416 if (status != 0 && output_file != 0 && output_file[0])
417 maybe_unlink (output_file);
420 maybe_unlink (response_file);
426 /* Notify user of a non-error. */
428 notice (const char *cmsgid, ...)
432 va_start (ap, cmsgid);
433 vfprintf (stderr, _(cmsgid), ap);
437 /* Notify user of a non-error, without translating the format string. */
439 notice_translated (const char *cmsgid, ...)
443 va_start (ap, cmsgid);
444 vfprintf (stderr, cmsgid, ap);
451 if (c_file != 0 && c_file[0])
452 maybe_unlink (c_file);
454 if (o_file != 0 && o_file[0])
455 maybe_unlink (o_file);
457 if (ldout != 0 && ldout[0])
458 maybe_unlink (ldout);
460 if (lderrout != 0 && lderrout[0])
461 maybe_unlink (lderrout);
463 #ifdef COLLECT_EXPORT_LIST
464 if (export_file != 0 && export_file[0])
465 maybe_unlink (export_file);
469 maybe_unlink_list (lto_o_files);
472 maybe_unlink (response_file);
474 signal (signo, SIG_DFL);
480 file_exists (const char *name)
482 return access (name, R_OK) == 0;
485 /* Parse a reasonable subset of shell quoting syntax. */
488 extract_string (const char **pp)
501 obstack_1grow (&temporary_obstack, c);
502 else if (! inside && c == ' ')
504 else if (! inside && c == '\\')
509 obstack_1grow (&temporary_obstack, c);
512 obstack_1grow (&temporary_obstack, '\0');
514 return XOBFINISH (&temporary_obstack, char *);
518 dump_file (const char *name, FILE *to)
520 FILE *stream = fopen (name, "r");
527 while (c = getc (stream),
528 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
529 obstack_1grow (&temporary_obstack, c);
530 if (obstack_object_size (&temporary_obstack) > 0)
532 const char *word, *p;
534 obstack_1grow (&temporary_obstack, '\0');
535 word = XOBFINISH (&temporary_obstack, const char *);
538 ++word, putc ('.', to);
540 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
541 p += strlen (USER_LABEL_PREFIX);
543 #ifdef HAVE_LD_DEMANGLE
549 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
557 diff = strlen (word) - strlen (result);
558 while (diff > 0 && c == ' ')
559 --diff, putc (' ', to);
560 if (diff < 0 && c == ' ')
562 while (diff < 0 && c == ' ')
563 ++diff, c = getc (stream);
566 /* Make sure we output at least one space, or
567 the demangled symbol name will run into
568 whatever text follows. */
579 obstack_free (&temporary_obstack, temporary_firstobj);
588 /* Return the kind of symbol denoted by name S. */
591 is_ctor_dtor (const char *s)
593 struct names { const char *const name; const int len; symkind ret;
594 const int two_underscores; };
596 const struct names *p;
598 const char *orig_s = s;
600 static const struct names special[] = {
601 #ifndef NO_DOLLAR_IN_LABEL
602 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
603 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
605 #ifndef NO_DOT_IN_LABEL
606 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
607 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
608 #endif /* NO_DOT_IN_LABEL */
609 #endif /* NO_DOLLAR_IN_LABEL */
610 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
611 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
612 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
613 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
614 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
615 { NULL, 0, SYM_REGULAR, 0 }
618 while ((ch = *s) == '_')
624 for (p = &special[0]; p->len > 0; p++)
627 && (!p->two_underscores || ((s - orig_s) >= 2))
628 && strncmp(s, p->name, p->len) == 0)
636 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
637 and one from the PATH variable. */
639 static struct path_prefix cpath, path;
641 #ifdef CROSS_DIRECTORY_STRUCTURE
642 /* This is the name of the target machine. We use it to form the name
643 of the files to execute. */
645 static const char *const target_machine = TARGET_MACHINE;
648 /* Search for NAME using prefix list PPREFIX. We only look for executable
651 Return 0 if not found, otherwise return its name, allocated with malloc. */
654 find_a_file (struct path_prefix *pprefix, const char *name)
657 struct prefix_list *pl;
658 int len = pprefix->max_len + strlen (name) + 1;
661 fprintf (stderr, "Looking for '%s'\n", name);
663 #ifdef HOST_EXECUTABLE_SUFFIX
664 len += strlen (HOST_EXECUTABLE_SUFFIX);
667 temp = XNEWVEC (char, len);
669 /* Determine the filename to execute (special case for absolute paths). */
671 if (IS_ABSOLUTE_PATH (name))
673 if (access (name, X_OK) == 0)
678 fprintf (stderr, " - found: absolute path\n");
683 #ifdef HOST_EXECUTABLE_SUFFIX
684 /* Some systems have a suffix for executable files.
685 So try appending that. */
687 strcat (temp, HOST_EXECUTABLE_SUFFIX);
689 if (access (temp, X_OK) == 0)
694 fprintf (stderr, " - failed to locate using absolute path\n");
697 for (pl = pprefix->plist; pl; pl = pl->next)
701 strcpy (temp, pl->prefix);
704 if (stat (temp, &st) >= 0
705 && ! S_ISDIR (st.st_mode)
706 && access (temp, X_OK) == 0)
709 #ifdef HOST_EXECUTABLE_SUFFIX
710 /* Some systems have a suffix for executable files.
711 So try appending that. */
712 strcat (temp, HOST_EXECUTABLE_SUFFIX);
714 if (stat (temp, &st) >= 0
715 && ! S_ISDIR (st.st_mode)
716 && access (temp, X_OK) == 0)
721 if (debug && pprefix->plist == NULL)
722 fprintf (stderr, " - failed: no entries in prefix list\n");
728 /* Add an entry for PREFIX to prefix list PPREFIX. */
731 add_prefix (struct path_prefix *pprefix, const char *prefix)
733 struct prefix_list *pl, **prev;
738 for (pl = pprefix->plist; pl->next; pl = pl->next)
743 prev = &pprefix->plist;
745 /* Keep track of the longest prefix. */
747 len = strlen (prefix);
748 if (len > pprefix->max_len)
749 pprefix->max_len = len;
751 pl = XNEW (struct prefix_list);
752 pl->prefix = xstrdup (prefix);
757 pl->next = (struct prefix_list *) 0;
761 /* Take the value of the environment variable ENV, break it into a path, and
762 add of the entries to PPREFIX. */
765 prefix_from_env (const char *env, struct path_prefix *pprefix)
771 prefix_from_string (p, pprefix);
775 prefix_from_string (const char *p, struct path_prefix *pprefix)
777 const char *startp, *endp;
778 char *nstore = XNEWVEC (char, strlen (p) + 3);
781 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
786 if (*endp == PATH_SEPARATOR || *endp == 0)
788 strncpy (nstore, startp, endp-startp);
791 strcpy (nstore, "./");
793 else if (! IS_DIR_SEPARATOR (endp[-1]))
795 nstore[endp-startp] = DIR_SEPARATOR;
796 nstore[endp-startp+1] = 0;
799 nstore[endp-startp] = 0;
802 fprintf (stderr, " - add prefix: %s\n", nstore);
804 add_prefix (pprefix, nstore);
807 endp = startp = endp + 1;
815 #ifdef OBJECT_FORMAT_NONE
817 /* Add an entry for the object file NAME to object file list LIST.
818 New entries are added at the end of the list. The original pointer
819 value of NAME is preserved, i.e., no string copy is performed. */
822 add_lto_object (struct lto_object_list *list, const char *name)
824 struct lto_object *n = XNEW (struct lto_object);
829 list->last->next = n;
835 #endif /* OBJECT_FORMAT_NONE */
838 /* Perform a link-time recompilation and relink if any of the object
839 files contain LTO info. The linker command line LTO_LD_ARGV
840 represents the linker command that would produce a final executable
841 without the use of LTO. OBJECT_LST is a vector of object file names
842 appearing in LTO_LD_ARGV that are to be considerd for link-time
843 recompilation, where OBJECT is a pointer to the last valid element.
844 (This awkward convention avoids an impedance mismatch with the
845 usage of similarly-named variables in main().) The elements of
846 OBJECT_LST must be identical, i.e., pointer equal, to the
847 corresponding arguments in LTO_LD_ARGV.
849 Upon entry, at least one linker run has been performed without the
850 use of any LTO info that might be present. Any recompilations
851 necessary for template instantiations have been performed, and
852 initializer/finalizer tables have been created if needed and
853 included in the linker command line LTO_LD_ARGV. If any of the
854 object files contain LTO info, we run the LTO back end on all such
855 files, and perform the final link with the LTO back end output
856 substituted for the LTO-optimized files. In some cases, a final
857 link with all link-time generated code has already been performed,
858 so there is no need to relink if no LTO info is found. In other
859 cases, our caller has not produced the final executable, and is
860 relying on us to perform the required link whether LTO info is
861 present or not. In that case, the FORCE argument should be true.
862 Note that the linker command line argument LTO_LD_ARGV passed into
863 this function may be modified in place. */
866 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
867 const char **object, bool force)
869 const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
871 int num_lto_c_args = 1; /* Allow space for the terminating NULL. */
873 while (object_file < object)
875 /* If file contains LTO info, add it to the list of LTO objects. */
876 scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
878 /* Increment the argument count by the number of object file arguments
879 we will add. An upper bound suffices, so just count all of the
880 object files regardless of whether they contain LTO info. */
884 if (lto_objects.first)
887 const char **lto_c_ptr;
890 struct lto_object *list;
891 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
893 const char *prog = "lto-wrapper";
894 int lto_ld_argv_size = 0;
895 char **out_lto_ld_argv;
896 int out_lto_ld_argv_size;
900 fatal_error ("COLLECT_LTO_WRAPPER must be set");
904 /* There is at least one object file containing LTO info,
905 so we need to run the LTO back end and relink.
907 To do so we build updated ld arguments with first
908 LTO object replaced by all partitions and other LTO
911 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
912 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
914 *lto_c_ptr++ = lto_wrapper;
916 /* Add LTO objects to the wrapper command line. */
917 for (list = lto_objects.first; list; list = list->next)
918 *lto_c_ptr++ = list->name;
922 /* Run the LTO back end. */
923 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
930 stream = pex_read_output (pex, 0);
934 while ((c = getc (stream)) != EOF)
936 obstack_1grow (&temporary_obstack, c);
941 lto_o_files = XNEWVEC (char *, num_files + 1);
942 lto_o_files[num_files] = NULL;
943 start = XOBFINISH (&temporary_obstack, char *);
944 for (i = 0; i < num_files; ++i)
951 lto_o_files[i] = xstrdup (start);
956 obstack_free (&temporary_obstack, temporary_firstobj);
961 /* Compute memory needed for new LD arguments. At most number of original arguemtns
962 plus number of partitions. */
963 for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
965 out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1);
966 out_lto_ld_argv_size = 0;
968 /* After running the LTO back end, we will relink, substituting
969 the LTO output for the object files that we submitted to the
970 LTO. Here, we modify the linker command line for the relink. */
972 /* Copy all arguments until we find first LTO file. */
976 for (list = lto_objects.first; list; list = list->next)
977 if (*p == list->name) /* Note test for pointer equality! */
981 out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
984 /* Now insert all LTO partitions. */
985 lto_o_ptr = lto_o_files;
987 out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
989 /* ... and copy the rest. */
992 for (list = lto_objects.first; list; list = list->next)
993 if (*p == list->name) /* Note test for pointer equality! */
996 out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
999 out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
1001 /* Run the linker again, this time replacing the object files
1002 optimized by the LTO with the temporary file generated by the LTO. */
1003 fork_execute ("ld", out_lto_ld_argv);
1004 post_ld_pass (true);
1007 maybe_unlink_list (lto_o_files);
1011 /* Our caller is relying on us to do the link
1012 even though there is no LTO back end work to be done. */
1013 fork_execute ("ld", lto_ld_argv);
1014 post_ld_pass (false);
1021 main (int argc, char **argv)
1023 static const char *const ld_suffix = "ld";
1024 static const char *const plugin_ld_suffix = PLUGIN_LD;
1025 static const char *const real_ld_suffix = "real-ld";
1026 static const char *const collect_ld_suffix = "collect-ld";
1027 static const char *const nm_suffix = "nm";
1028 static const char *const gnm_suffix = "gnm";
1030 static const char *const ldd_suffix = LDD_SUFFIX;
1032 static const char *const strip_suffix = "strip";
1033 static const char *const gstrip_suffix = "gstrip";
1035 #ifdef CROSS_DIRECTORY_STRUCTURE
1036 /* If we look for a program in the compiler directories, we just use
1037 the short name, since these directories are already system-specific.
1038 But it we look for a program in the system directories, we need to
1039 qualify the program name with the target machine. */
1041 const char *const full_ld_suffix =
1042 concat(target_machine, "-", ld_suffix, NULL);
1043 const char *const full_plugin_ld_suffix =
1044 concat(target_machine, "-", plugin_ld_suffix, NULL);
1045 const char *const full_nm_suffix =
1046 concat (target_machine, "-", nm_suffix, NULL);
1047 const char *const full_gnm_suffix =
1048 concat (target_machine, "-", gnm_suffix, NULL);
1050 const char *const full_ldd_suffix =
1051 concat (target_machine, "-", ldd_suffix, NULL);
1053 const char *const full_strip_suffix =
1054 concat (target_machine, "-", strip_suffix, NULL);
1055 const char *const full_gstrip_suffix =
1056 concat (target_machine, "-", gstrip_suffix, NULL);
1058 const char *const full_ld_suffix = ld_suffix;
1059 const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1060 const char *const full_nm_suffix = nm_suffix;
1061 const char *const full_gnm_suffix = gnm_suffix;
1063 const char *const full_ldd_suffix = ldd_suffix;
1065 const char *const full_strip_suffix = strip_suffix;
1066 const char *const full_gstrip_suffix = gstrip_suffix;
1067 #endif /* CROSS_DIRECTORY_STRUCTURE */
1071 #ifdef COLLECT_EXPORT_LIST
1074 const char *ld_file_name;
1080 bool use_plugin = false;
1082 /* The kinds of symbols we will have to consider when scanning the
1083 outcome of a first pass link. This is ALL to start with, then might
1084 be adjusted before getting to the first pass link per se, typically on
1085 AIX where we perform an early scan of objects and libraries to fetch
1086 the list of global ctors/dtors and make sure they are not garbage
1088 scanfilter ld1_filter = SCAN_ALL;
1093 const char **object;
1098 p = argv[0] + strlen (argv[0]);
1099 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1103 xmalloc_set_program_name (progname);
1106 expandargv (&argc, &argv);
1107 if (argv != old_argv)
1108 at_file_supplied = 1;
1110 process_args (&argc, argv);
1112 num_c_args = argc + 9;
1114 #ifndef HAVE_LD_DEMANGLE
1115 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1117 /* Suppress demangling by the real linker, which may be broken. */
1118 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
1121 #if defined (COLLECT2_HOST_INITIALIZATION)
1122 /* Perform system dependent initialization, if necessary. */
1123 COLLECT2_HOST_INITIALIZATION;
1127 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1128 receive the signal. A different setting is inheritable */
1129 signal (SIGCHLD, SIG_DFL);
1132 /* Unlock the stdio streams. */
1133 unlock_std_streams ();
1135 gcc_init_libintl ();
1137 diagnostic_initialize (global_dc, 0);
1139 /* Do not invoke xcalloc before this point, since locale needs to be
1140 set first, in case a diagnostic is issued. */
1142 ld1_argv = XCNEWVEC (char *, argc + 4);
1143 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1144 ld2_argv = XCNEWVEC (char *, argc + 11);
1145 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1146 object_lst = XCNEWVEC (char *, argc);
1147 object = CONST_CAST2 (const char **, char **, object_lst);
1153 /* Parse command line early for instances of -debug. This allows
1154 the debug flag to be set before functions like find_a_file()
1155 are called. We also look for the -flto or -flto-partition=none flag to know
1156 what LTO mode we are in. */
1159 bool no_partition = false;
1161 for (i = 1; argv[i] != NULL; i ++)
1163 if (! strcmp (argv[i], "-debug"))
1165 else if (! strcmp (argv[i], "-flto-partition=none"))
1166 no_partition = true;
1167 else if ((! strncmp (argv[i], "-flto=", 6)
1168 || ! strcmp (argv[i], "-flto")) && ! use_plugin)
1169 lto_mode = LTO_MODE_WHOPR;
1170 else if (!strncmp (argv[i], "-fno-lto", 8))
1171 lto_mode = LTO_MODE_NONE;
1172 else if (! strcmp (argv[i], "-plugin"))
1175 lto_mode = LTO_MODE_NONE;
1177 #ifdef COLLECT_EXPORT_LIST
1178 /* since -brtl, -bexport, -b64 are not position dependent
1179 also check for them here */
1180 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1183 /* We want to disable automatic exports on AIX when user
1184 explicitly puts an export list in command line */
1185 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1187 else if (arg[2] == '6' && arg[3] == '4')
1189 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1195 if (no_partition && lto_mode == LTO_MODE_WHOPR)
1196 lto_mode = LTO_MODE_LTO;
1199 #ifndef DEFAULT_A_OUT_NAME
1200 output_file = "a.out";
1202 output_file = DEFAULT_A_OUT_NAME;
1205 obstack_begin (&temporary_obstack, 0);
1206 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1208 #ifndef HAVE_LD_DEMANGLE
1209 current_demangling_style = auto_demangling;
1211 p = getenv ("COLLECT_GCC_OPTIONS");
1214 const char *q = extract_string (&p);
1215 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1218 obstack_free (&temporary_obstack, temporary_firstobj);
1220 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1221 -fno-exceptions -w -fno-whole-program */
1224 c_argv = XCNEWVEC (char *, num_c_args);
1225 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1228 fatal_error ("no arguments");
1231 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1232 signal (SIGQUIT, handler);
1234 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1235 signal (SIGINT, handler);
1237 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1238 signal (SIGALRM, handler);
1241 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1242 signal (SIGHUP, handler);
1244 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1245 signal (SIGSEGV, handler);
1247 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1248 signal (SIGBUS, handler);
1251 /* Extract COMPILER_PATH and PATH into our prefix list. */
1252 prefix_from_env ("COMPILER_PATH", &cpath);
1253 prefix_from_env ("PATH", &path);
1255 /* Try to discover a valid linker/nm/strip to use. */
1257 /* Maybe we know the right file to use (if not cross). */
1259 #ifdef DEFAULT_LINKER
1260 if (access (DEFAULT_LINKER, X_OK) == 0)
1261 ld_file_name = DEFAULT_LINKER;
1262 if (ld_file_name == 0)
1264 #ifdef REAL_LD_FILE_NAME
1265 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1266 if (ld_file_name == 0)
1268 /* Search the (target-specific) compiler dirs for ld'. */
1269 ld_file_name = find_a_file (&cpath, real_ld_suffix);
1270 /* Likewise for `collect-ld'. */
1271 if (ld_file_name == 0)
1272 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1273 /* Search the compiler directories for `ld'. We have protection against
1274 recursive calls in find_a_file. */
1275 if (ld_file_name == 0)
1276 ld_file_name = find_a_file (&cpath,
1280 /* Search the ordinary system bin directories
1281 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1282 if (ld_file_name == 0)
1283 ld_file_name = find_a_file (&path,
1285 ? full_plugin_ld_suffix
1288 #ifdef REAL_NM_FILE_NAME
1289 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1290 if (nm_file_name == 0)
1292 nm_file_name = find_a_file (&cpath, gnm_suffix);
1293 if (nm_file_name == 0)
1294 nm_file_name = find_a_file (&path, full_gnm_suffix);
1295 if (nm_file_name == 0)
1296 nm_file_name = find_a_file (&cpath, nm_suffix);
1297 if (nm_file_name == 0)
1298 nm_file_name = find_a_file (&path, full_nm_suffix);
1301 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1302 if (ldd_file_name == 0)
1303 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1306 #ifdef REAL_STRIP_FILE_NAME
1307 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1308 if (strip_file_name == 0)
1310 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1311 if (strip_file_name == 0)
1312 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1313 if (strip_file_name == 0)
1314 strip_file_name = find_a_file (&cpath, strip_suffix);
1315 if (strip_file_name == 0)
1316 strip_file_name = find_a_file (&path, full_strip_suffix);
1318 /* Determine the full path name of the C compiler to use. */
1319 c_file_name = getenv ("COLLECT_GCC");
1320 if (c_file_name == 0)
1322 #ifdef CROSS_DIRECTORY_STRUCTURE
1323 c_file_name = concat (target_machine, "-gcc", NULL);
1325 c_file_name = "gcc";
1329 p = find_a_file (&cpath, c_file_name);
1331 /* Here it should be safe to use the system search path since we should have
1332 already qualified the name of the compiler when it is needed. */
1334 p = find_a_file (&path, c_file_name);
1339 *ld1++ = *ld2++ = ld_file_name;
1341 /* Make temp file names. */
1342 c_file = make_temp_file (".c");
1343 o_file = make_temp_file (".o");
1344 #ifdef COLLECT_EXPORT_LIST
1345 export_file = make_temp_file (".x");
1347 ldout = make_temp_file (".ld");
1348 lderrout = make_temp_file (".le");
1349 *c_ptr++ = c_file_name;
1356 #ifdef COLLECT_EXPORT_LIST
1357 /* Generate a list of directories from LIBPATH. */
1358 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1359 /* Add to this list also two standard directories where
1360 AIX loader always searches for libraries. */
1361 add_prefix (&libpath_lib_dirs, "/lib");
1362 add_prefix (&libpath_lib_dirs, "/usr/lib");
1365 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1367 AIX support needs to know if -shared has been specified before
1368 parsing commandline arguments. */
1370 p = getenv ("COLLECT_GCC_OPTIONS");
1373 const char *q = extract_string (&p);
1374 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1375 *c_ptr++ = xstrdup (q);
1376 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1377 *c_ptr++ = xstrdup (q);
1378 if (strcmp (q, "-shared") == 0)
1380 if (*q == '-' && q[1] == 'B')
1382 *c_ptr++ = xstrdup (q);
1385 q = extract_string (&p);
1386 *c_ptr++ = xstrdup (q);
1390 obstack_free (&temporary_obstack, temporary_firstobj);
1391 *c_ptr++ = "-fno-profile-arcs";
1392 *c_ptr++ = "-fno-test-coverage";
1393 *c_ptr++ = "-fno-branch-probabilities";
1394 *c_ptr++ = "-fno-exceptions";
1396 *c_ptr++ = "-fno-whole-program";
1398 /* !!! When GCC calls collect2,
1399 it does not know whether it is calling collect2 or ld.
1400 So collect2 cannot meaningfully understand any options
1401 except those ld understands.
1402 If you propose to make GCC pass some other option,
1403 just imagine what will happen if ld is really ld!!! */
1405 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1406 /* After the first file, put in the c++ rt0. */
1409 while ((arg = *++argv) != (char *) 0)
1411 *ld1++ = *ld2++ = arg;
1418 if (!strcmp (arg, "-debug"))
1420 /* Already parsed. */
1424 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1427 *ld1++ = *ld2++ = *argv;
1432 if (strncmp (arg, "-flto", 5) == 0)
1435 /* Do not pass LTO flag to the linker. */
1439 error ("LTO support has not been enabled in this "
1448 /* place o_file BEFORE this argument! */
1454 #ifdef COLLECT_EXPORT_LIST
1456 /* Resolving full library name. */
1457 const char *s = resolve_lib_name (arg+2);
1459 /* Saving a full library name. */
1460 add_to_list (&libs, s);
1465 #ifdef COLLECT_EXPORT_LIST
1466 /* Saving directories where to search for libraries. */
1468 add_prefix (&cmdline_lib_dirs, arg+2);
1471 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1473 if (is_in_args (arg,
1474 CONST_CAST2 (const char **, char **, ld1_argv),
1478 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1483 output_file = *ld1++ = *ld2++ = *++argv;
1485 output_file = &arg[2];
1494 if (arg[2] == '\0' && do_collecting)
1496 /* We must strip after the nm run, otherwise C++ linking
1497 will not work. Thus we strip in the second ld run, or
1498 else with strip if there is no second ld run. */
1510 if (strcmp (arg, "--no-demangle") == 0)
1512 #ifndef HAVE_LD_DEMANGLE
1518 else if (strncmp (arg, "--demangle", 10) == 0)
1520 #ifndef HAVE_LD_DEMANGLE
1524 enum demangling_styles style
1525 = cplus_demangle_name_to_style (arg+11);
1526 if (style == unknown_demangling)
1527 error ("unknown demangling style '%s'", arg+11);
1529 current_demangling_style = style;
1535 else if (strncmp (arg, "--sysroot=", 10) == 0)
1536 target_system_root = arg + 10;
1537 else if (strcmp (arg, "--version") == 0)
1539 else if (strcmp (arg, "--help") == 0)
1544 else if ((p = strrchr (arg, '.')) != (char *) 0
1545 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1546 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1547 || strcmp (p, ".obj") == 0))
1556 /* place o_file BEFORE this argument! */
1562 if (p[1] == 'o' || p[1] == 'l')
1564 #ifdef COLLECT_EXPORT_LIST
1565 /* libraries can be specified directly, i.e. without -l flag. */
1568 /* Saving a full library name. */
1569 add_to_list (&libs, arg);
1575 #ifdef COLLECT_EXPORT_LIST
1576 /* This is added only for debugging purposes. */
1579 fprintf (stderr, "List of libraries:\n");
1580 dump_list (stderr, "\t", libs.first);
1583 /* The AIX linker will discard static constructors in object files if
1584 nothing else in the file is referenced, so look at them first. Unless
1585 we are building a shared object, ignore the eh frame tables, as we
1586 would otherwise reference them all, hence drag all the corresponding
1587 objects even if nothing else is referenced. */
1589 const char **export_object_lst
1590 = CONST_CAST2 (const char **, char **, object_lst);
1592 struct id *list = libs.first;
1594 /* Compute the filter to use from the current one, do scan, then adjust
1595 the "current" filter to remove what we just included here. This will
1596 control whether we need a first pass link later on or not, and what
1597 will remain to be scanned there. */
1599 scanfilter this_filter = ld1_filter;
1602 this_filter &= ~SCAN_DWEH;
1605 while (export_object_lst < object)
1606 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1608 for (; list; list = list->next)
1609 scan_prog_file (list->name, PASS_FIRST, this_filter);
1611 ld1_filter = ld1_filter & ~this_filter;
1616 char *buf = concat ("-bE:", export_file, NULL);
1621 exportf = fopen (export_file, "w");
1622 if (exportf == (FILE *) 0)
1623 fatal_error ("fopen %s: %m", export_file);
1624 write_aix_file (exportf, exports.first);
1625 if (fclose (exportf))
1626 fatal_error ("fclose %s: %m", export_file);
1631 *c_ptr = *ld1 = *object = (char *) 0;
1634 notice ("collect2 version %s\n", version_string);
1638 printf ("Usage: collect2 [options]\n");
1639 printf (" Wrap linker and generate constructor code if needed.\n");
1640 printf (" Options:\n");
1641 printf (" -debug Enable debug output\n");
1642 printf (" --help Display this information\n");
1643 printf (" -v, --version Display this program's version number\n");
1645 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1646 printf ("Report bugs: %s\n", bug_report_url);
1653 fprintf (stderr, "ld_file_name = %s\n",
1654 (ld_file_name ? ld_file_name : "not found"));
1655 fprintf (stderr, "c_file_name = %s\n",
1656 (c_file_name ? c_file_name : "not found"));
1657 fprintf (stderr, "nm_file_name = %s\n",
1658 (nm_file_name ? nm_file_name : "not found"));
1660 fprintf (stderr, "ldd_file_name = %s\n",
1661 (ldd_file_name ? ldd_file_name : "not found"));
1663 fprintf (stderr, "strip_file_name = %s\n",
1664 (strip_file_name ? strip_file_name : "not found"));
1665 fprintf (stderr, "c_file = %s\n",
1666 (c_file ? c_file : "not found"));
1667 fprintf (stderr, "o_file = %s\n",
1668 (o_file ? o_file : "not found"));
1670 ptr = getenv ("COLLECT_GCC_OPTIONS");
1672 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1674 ptr = getenv ("COLLECT_GCC");
1676 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1678 ptr = getenv ("COMPILER_PATH");
1680 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1682 ptr = getenv (LIBRARY_PATH_ENV);
1684 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1686 fprintf (stderr, "\n");
1689 /* Load the program, searching all libraries and attempting to provide
1690 undefined symbols from repository information.
1692 If -r or they will be run via some other method, do not build the
1693 constructor or destructor list, just return now. */
1696 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1698 /* Perform the first pass link now, if we're about to exit or if we need
1699 to scan for things we haven't collected yet before pursuing further.
1701 On AIX, the latter typically includes nothing for shared objects or
1702 frame tables for an executable, out of what the required early scan on
1703 objects and libraries has performed above. In the !shared_obj case, we
1704 expect the relevant tables to be dragged together with their associated
1705 functions from precise cross reference insertions by the compiler. */
1707 if (early_exit || ld1_filter != SCAN_NOTHING)
1708 do_tlink (ld1_argv, object_lst);
1712 #ifdef COLLECT_EXPORT_LIST
1713 /* Make sure we delete the export file we may have created. */
1714 if (export_file != 0 && export_file[0])
1715 maybe_unlink (export_file);
1717 if (lto_mode != LTO_MODE_NONE)
1718 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1720 post_ld_pass (false);
1722 maybe_unlink (c_file);
1723 maybe_unlink (o_file);
1728 /* Unless we have done it all already, examine the namelist and search for
1729 static constructors and destructors to call. Write the constructor and
1730 destructor tables to a .s file and reload. */
1732 if (ld1_filter != SCAN_NOTHING)
1733 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1735 #ifdef SCAN_LIBRARIES
1736 scan_libraries (output_file);
1741 notice_translated (ngettext ("%d constructor found\n",
1742 "%d constructors found\n",
1743 constructors.number),
1744 constructors.number);
1745 notice_translated (ngettext ("%d destructor found\n",
1746 "%d destructors found\n",
1747 destructors.number),
1748 destructors.number);
1749 notice_translated (ngettext("%d frame table found\n",
1750 "%d frame tables found\n",
1751 frame_tables.number),
1752 frame_tables.number);
1755 /* If the scan exposed nothing of special interest, there's no need to
1756 generate the glue code and relink so return now. */
1758 if (constructors.number == 0 && destructors.number == 0
1759 && frame_tables.number == 0
1760 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1761 /* If we will be running these functions ourselves, we want to emit
1762 stubs into the shared library so that we do not have to relink
1763 dependent programs when we add static objects. */
1768 /* Do tlink without additional code generation now if we didn't
1769 do it earlier for scanning purposes. */
1770 if (ld1_filter == SCAN_NOTHING)
1771 do_tlink (ld1_argv, object_lst);
1774 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1776 /* Strip now if it was requested on the command line. */
1779 char **real_strip_argv = XCNEWVEC (char *, 3);
1780 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1783 strip_argv[0] = strip_file_name;
1784 strip_argv[1] = output_file;
1785 strip_argv[2] = (char *) 0;
1786 fork_execute ("strip", real_strip_argv);
1789 #ifdef COLLECT_EXPORT_LIST
1790 maybe_unlink (export_file);
1792 post_ld_pass (false);
1794 maybe_unlink (c_file);
1795 maybe_unlink (o_file);
1799 /* Sort ctor and dtor lists by priority. */
1800 sort_ids (&constructors);
1801 sort_ids (&destructors);
1803 maybe_unlink(output_file);
1804 outf = fopen (c_file, "w");
1805 if (outf == (FILE *) 0)
1806 fatal_error ("fopen %s: %m", c_file);
1808 write_c_file (outf, c_file);
1811 fatal_error ("fclose %s: %m", c_file);
1813 /* Tell the linker that we have initializer and finalizer functions. */
1814 #ifdef LD_INIT_SWITCH
1815 #ifdef COLLECT_EXPORT_LIST
1816 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1818 *ld2++ = LD_INIT_SWITCH;
1820 *ld2++ = LD_FINI_SWITCH;
1825 #ifdef COLLECT_EXPORT_LIST
1828 /* If we did not add export flag to link arguments before, add it to
1829 second link phase now. No new exports should have been added. */
1830 if (! exports.first)
1831 *ld2++ = concat ("-bE:", export_file, NULL);
1833 #ifndef LD_INIT_SWITCH
1834 add_to_list (&exports, initname);
1835 add_to_list (&exports, fininame);
1836 add_to_list (&exports, "_GLOBAL__DI");
1837 add_to_list (&exports, "_GLOBAL__DD");
1839 exportf = fopen (export_file, "w");
1840 if (exportf == (FILE *) 0)
1841 fatal_error ("fopen %s: %m", export_file);
1842 write_aix_file (exportf, exports.first);
1843 if (fclose (exportf))
1844 fatal_error ("fclose %s: %m", export_file);
1848 /* End of arguments to second link phase. */
1853 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1854 output_file, c_file);
1855 write_c_file (stderr, "stderr");
1856 fprintf (stderr, "========== end of c_file\n\n");
1857 #ifdef COLLECT_EXPORT_LIST
1858 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1859 write_aix_file (stderr, exports.first);
1860 fprintf (stderr, "========== end of export_file\n\n");
1864 /* Assemble the constructor and destructor tables.
1865 Link the tables in with the rest of the program. */
1867 fork_execute ("gcc", c_argv);
1868 #ifdef COLLECT_EXPORT_LIST
1869 /* On AIX we must call tlink because of possible templates resolution. */
1870 do_tlink (ld2_argv, object_lst);
1873 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1875 /* Otherwise, simply call ld because tlink is already done. */
1877 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1880 fork_execute ("ld", ld2_argv);
1881 post_ld_pass (false);
1884 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1885 constructors/destructors in shared libraries. */
1886 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1889 maybe_unlink (c_file);
1890 maybe_unlink (o_file);
1892 #ifdef COLLECT_EXPORT_LIST
1893 maybe_unlink (export_file);
1900 /* Wait for a process to finish, and exit if a nonzero status is found. */
1903 collect_wait (const char *prog, struct pex_obj *pex)
1907 if (!pex_get_status (pex, 1, &status))
1908 fatal_error ("can't get program status: %m");
1913 if (WIFSIGNALED (status))
1915 int sig = WTERMSIG (status);
1916 error ("%s terminated with signal %d [%s]%s",
1917 prog, sig, strsignal(sig),
1918 WCOREDUMP(status) ? ", core dumped" : "");
1919 collect_exit (FATAL_EXIT_CODE);
1922 if (WIFEXITED (status))
1923 return WEXITSTATUS (status);
1929 do_wait (const char *prog, struct pex_obj *pex)
1931 int ret = collect_wait (prog, pex);
1934 error ("%s returned %d exit status", prog, ret);
1940 unlink (response_file);
1941 response_file = NULL;
1946 /* Execute a program, and wait for the reply. */
1949 collect_execute (const char *prog, char **argv, const char *outname,
1950 const char *errname, int flags)
1952 struct pex_obj *pex;
1955 char *response_arg = NULL;
1956 char *response_argv[3] ATTRIBUTE_UNUSED;
1958 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
1960 /* If using @file arguments, create a temporary file and put the
1961 contents of argv into it. Then change argv to an array corresponding
1962 to a single argument @FILE, where FILE is the temporary filename. */
1964 char **current_argv = argv + 1;
1965 char *argv0 = argv[0];
1969 /* Note: we assume argv contains at least one element; this is
1972 response_file = make_temp_file ("");
1974 f = fopen (response_file, "w");
1977 fatal_error ("could not open response file %s", response_file);
1979 status = writeargv (current_argv, f);
1982 fatal_error ("could not write to response file %s", response_file);
1984 status = fclose (f);
1987 fatal_error ("could not close response file %s", response_file);
1989 response_arg = concat ("@", response_file, NULL);
1990 response_argv[0] = argv0;
1991 response_argv[1] = response_arg;
1992 response_argv[2] = NULL;
1994 argv = response_argv;
2003 fprintf (stderr, "%s", argv[0]);
2005 notice ("[cannot find %s]", prog);
2007 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2008 fprintf (stderr, " %s", str);
2010 fprintf (stderr, "\n");
2016 /* If we cannot find a program we need, complain error. Do this here
2017 since we might not end up needing something that we could not find. */
2020 fatal_error ("cannot find '%s'", prog);
2022 pex = pex_init (0, "collect2", NULL);
2024 fatal_error ("pex_init failed: %m");
2026 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2033 fatal_error ("%s: %m", _(errmsg));
2036 fatal_error (errmsg);
2039 free (response_arg);
2045 fork_execute (const char *prog, char **argv)
2047 struct pex_obj *pex;
2049 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2050 do_wait (prog, pex);
2053 /* Unlink a file unless we are debugging. */
2056 maybe_unlink (const char *file)
2059 unlink_if_ordinary (file);
2061 notice ("[Leaving %s]\n", file);
2064 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2067 maybe_unlink_list (char **file_list)
2069 char **tmp = file_list;
2072 maybe_unlink (*(tmp++));
2076 static long sequence_number = 0;
2078 /* Add a name to a linked list. */
2081 add_to_list (struct head *head_ptr, const char *name)
2084 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2086 strcpy (newid->name, name);
2088 if (head_ptr->first)
2089 head_ptr->last->next = newid;
2091 head_ptr->first = newid;
2093 /* Check for duplicate symbols. */
2094 for (p = head_ptr->first;
2095 strcmp (name, p->name) != 0;
2100 head_ptr->last->next = 0;
2105 newid->sequence = ++sequence_number;
2106 head_ptr->last = newid;
2110 /* Grab the init priority number from an init function name that
2111 looks like "_GLOBAL_.I.12345.foo". */
2114 extract_init_priority (const char *name)
2118 while (name[pos] == '_')
2120 pos += 10; /* strlen ("GLOBAL__X_") */
2122 /* Extract init_p number from ctor/dtor name. */
2123 pri = atoi (name + pos);
2124 return pri ? pri : DEFAULT_INIT_PRIORITY;
2127 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2128 ctors will be run from right to left, dtors from left to right. */
2131 sort_ids (struct head *head_ptr)
2133 /* id holds the current element to insert. id_next holds the next
2134 element to insert. id_ptr iterates through the already sorted elements
2135 looking for the place to insert id. */
2136 struct id *id, *id_next, **id_ptr;
2138 id = head_ptr->first;
2140 /* We don't have any sorted elements yet. */
2141 head_ptr->first = NULL;
2143 for (; id; id = id_next)
2146 id->sequence = extract_init_priority (id->name);
2148 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2150 /* If the sequence numbers are the same, we put the id from the
2151 file later on the command line later in the list. */
2152 || id->sequence > (*id_ptr)->sequence
2153 /* Hack: do lexical compare, too.
2154 || (id->sequence == (*id_ptr)->sequence
2155 && strcmp (id->name, (*id_ptr)->name) > 0) */
2164 /* Now set the sequence numbers properly so write_c_file works. */
2165 for (id = head_ptr->first; id; id = id->next)
2166 id->sequence = ++sequence_number;
2169 /* Write: `prefix', the names on list LIST, `suffix'. */
2172 write_list (FILE *stream, const char *prefix, struct id *list)
2176 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2181 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2182 /* Given a STRING, return nonzero if it occurs in the list in range
2183 [ARGS_BEGIN,ARGS_END). */
2186 is_in_args (const char *string, const char **args_begin,
2187 const char **args_end)
2189 const char **args_pointer;
2190 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2191 if (strcmp (string, *args_pointer) == 0)
2195 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2197 #ifdef COLLECT_EXPORT_LIST
2198 /* This function is really used only on AIX, but may be useful. */
2201 is_in_list (const char *prefix, struct id *list)
2205 if (!strcmp (prefix, list->name)) return 1;
2211 #endif /* COLLECT_EXPORT_LIST */
2213 /* Added for debugging purpose. */
2214 #ifdef COLLECT_EXPORT_LIST
2216 dump_list (FILE *stream, const char *prefix, struct id *list)
2220 fprintf (stream, "%s%s,\n", prefix, list->name);
2228 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2232 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2239 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2243 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2244 prefix, list->sequence, list->name);
2249 /* Write out the constructor and destructor tables statically (for a shared
2250 object), along with the functions to execute them. */
2253 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2257 int frames = (frame_tables.number > 0);
2259 /* Figure out name of output_file, stripping off .so version. */
2260 q = p = lbasename (output_file);
2272 if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2274 q += strlen (SHLIB_SUFFIX);
2281 /* q points to null at end of the string (or . of the .so version) */
2282 prefix = XNEWVEC (char, q - p + 1);
2283 strncpy (prefix, p, q - p);
2285 for (r = prefix; *r; r++)
2286 if (!ISALNUM ((unsigned char)*r))
2289 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2290 output_file, prefix);
2292 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2293 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2297 /* Write the tables as C code. */
2299 fprintf (stream, "static int count;\n");
2300 fprintf (stream, "typedef void entry_pt();\n");
2301 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2305 write_list_with_asm (stream, "extern void *", frame_tables.first);
2307 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2308 write_list (stream, "\t\t&", frame_tables.first);
2309 fprintf (stream, "\t0\n};\n");
2311 /* This must match what's in frame.h. */
2312 fprintf (stream, "struct object {\n");
2313 fprintf (stream, " void *pc_begin;\n");
2314 fprintf (stream, " void *pc_end;\n");
2315 fprintf (stream, " void *fde_begin;\n");
2316 fprintf (stream, " void *fde_array;\n");
2317 fprintf (stream, " __SIZE_TYPE__ count;\n");
2318 fprintf (stream, " struct object *next;\n");
2319 fprintf (stream, "};\n");
2321 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2322 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2324 fprintf (stream, "static void reg_frame () {\n");
2325 fprintf (stream, "\tstatic struct object ob;\n");
2326 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2327 fprintf (stream, "\t}\n");
2329 fprintf (stream, "static void dereg_frame () {\n");
2330 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2331 fprintf (stream, "\t}\n");
2334 fprintf (stream, "void %s() {\n", initname);
2335 if (constructors.number > 0 || frames)
2337 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2338 write_list (stream, "\t\t", constructors.first);
2340 fprintf (stream, "\treg_frame,\n");
2341 fprintf (stream, "\t};\n");
2342 fprintf (stream, "\tentry_pt **p;\n");
2343 fprintf (stream, "\tif (count++ != 0) return;\n");
2344 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2345 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2348 fprintf (stream, "\t++count;\n");
2349 fprintf (stream, "}\n");
2350 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2351 fprintf (stream, "void %s() {\n", fininame);
2352 if (destructors.number > 0 || frames)
2354 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2355 write_list (stream, "\t\t", destructors.first);
2357 fprintf (stream, "\tdereg_frame,\n");
2358 fprintf (stream, "\t};\n");
2359 fprintf (stream, "\tentry_pt **p;\n");
2360 fprintf (stream, "\tif (--count != 0) return;\n");
2361 fprintf (stream, "\tp = dtors;\n");
2362 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2363 destructors.number + frames);
2365 fprintf (stream, "}\n");
2369 COLLECT_SHARED_INIT_FUNC(stream, initname);
2370 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2374 /* Write the constructor/destructor tables. */
2376 #ifndef LD_INIT_SWITCH
2378 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2380 /* Write the tables as C code. */
2382 int frames = (frame_tables.number > 0);
2384 fprintf (stream, "typedef void entry_pt();\n\n");
2386 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2390 write_list_with_asm (stream, "extern void *", frame_tables.first);
2392 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2393 write_list (stream, "\t\t&", frame_tables.first);
2394 fprintf (stream, "\t0\n};\n");
2396 /* This must match what's in frame.h. */
2397 fprintf (stream, "struct object {\n");
2398 fprintf (stream, " void *pc_begin;\n");
2399 fprintf (stream, " void *pc_end;\n");
2400 fprintf (stream, " void *fde_begin;\n");
2401 fprintf (stream, " void *fde_array;\n");
2402 fprintf (stream, " __SIZE_TYPE__ count;\n");
2403 fprintf (stream, " struct object *next;\n");
2404 fprintf (stream, "};\n");
2406 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2407 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2409 fprintf (stream, "static void reg_frame () {\n");
2410 fprintf (stream, "\tstatic struct object ob;\n");
2411 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2412 fprintf (stream, "\t}\n");
2414 fprintf (stream, "static void dereg_frame () {\n");
2415 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2416 fprintf (stream, "\t}\n");
2419 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2420 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2421 write_list (stream, "\t", constructors.first);
2423 fprintf (stream, "\treg_frame,\n");
2424 fprintf (stream, "\t0\n};\n\n");
2426 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2428 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2429 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2430 write_list (stream, "\t", destructors.first);
2432 fprintf (stream, "\tdereg_frame,\n");
2433 fprintf (stream, "\t0\n};\n\n");
2435 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2436 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2438 #endif /* ! LD_INIT_SWITCH */
2441 write_c_file (FILE *stream, const char *name)
2443 #ifndef LD_INIT_SWITCH
2445 write_c_file_glob (stream, name);
2448 write_c_file_stat (stream, name);
2451 #ifdef COLLECT_EXPORT_LIST
2453 write_aix_file (FILE *stream, struct id *list)
2455 for (; list; list = list->next)
2457 fputs (list->name, stream);
2458 putc ('\n', stream);
2463 #ifdef OBJECT_FORMAT_NONE
2465 /* Check to make sure the file is an LTO object file. */
2468 maybe_lto_object_file (const char *prog_name)
2471 unsigned char buf[4];
2474 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2475 static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2476 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2477 static unsigned char machomagic[4][4] = {
2478 { 0xcf, 0xfa, 0xed, 0xfe },
2479 { 0xce, 0xfa, 0xed, 0xfe },
2480 { 0xfe, 0xed, 0xfa, 0xcf },
2481 { 0xfe, 0xed, 0xfa, 0xce }
2484 f = fopen (prog_name, "rb");
2487 if (fread (buf, sizeof (buf), 1, f) != 1)
2491 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2492 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2493 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2495 for (i = 0; i < 4; i++)
2496 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2502 /* Generic version to scan the name list of the loaded program for
2503 the symbols g++ uses for static constructors and destructors. */
2506 scan_prog_file (const char *prog_name, scanpass which_pass,
2509 void (*int_handler) (int);
2511 void (*quit_handler) (int);
2513 char *real_nm_argv[4];
2514 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2516 struct pex_obj *pex;
2523 if (which_pass == PASS_SECOND)
2526 /* LTO objects must be in a known format. This check prevents
2527 us from accepting an archive containing LTO objects, which
2528 gcc cannnot currently handle. */
2529 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2532 /* If we do not have an `nm', complain. */
2533 if (nm_file_name == 0)
2534 fatal_error ("cannot find 'nm'");
2536 nm_argv[argc++] = nm_file_name;
2537 if (NM_FLAGS[0] != '\0')
2538 nm_argv[argc++] = NM_FLAGS;
2540 nm_argv[argc++] = prog_name;
2541 nm_argv[argc++] = (char *) 0;
2543 /* Trace if needed. */
2546 const char **p_argv;
2549 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2550 fprintf (stderr, " %s", str);
2552 fprintf (stderr, "\n");
2558 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2560 fatal_error ("pex_init failed: %m");
2562 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2569 fatal_error ("%s: %m", _(errmsg));
2572 fatal_error (errmsg);
2575 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2577 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2580 inf = pex_read_output (pex, 0);
2582 fatal_error ("can't open nm output: %m");
2586 if (which_pass == PASS_LTOINFO)
2587 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2589 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2592 /* Read each line of nm output. */
2593 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2599 fprintf (stderr, "\t%s\n", buf);
2601 if (which_pass == PASS_LTOINFO)
2606 /* Look for the LTO info marker symbol, and add filename to
2607 the LTO objects list if found. */
2608 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2609 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2610 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2611 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2613 add_lto_object (<o_objects, prog_name);
2615 /* We need to read all the input, so we can't just
2616 return here. But we can avoid useless work. */
2625 /* If it contains a constructor or destructor name, add the name
2626 to the appropriate list unless this is a kind of symbol we're
2627 not supposed to even consider. */
2629 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2630 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2637 /* Find the end of the symbol name.
2638 Do not include `|', because Encore nm can tack that on the end. */
2639 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2645 switch (is_ctor_dtor (name))
2648 if (! (filter & SCAN_CTOR))
2650 if (which_pass != PASS_LIB)
2651 add_to_list (&constructors, name);
2655 if (! (filter & SCAN_DTOR))
2657 if (which_pass != PASS_LIB)
2658 add_to_list (&destructors, name);
2662 if (! (filter & SCAN_INIT))
2664 if (which_pass != PASS_LIB)
2665 fatal_error ("init function found in object %s", prog_name);
2666 #ifndef LD_INIT_SWITCH
2667 add_to_list (&constructors, name);
2672 if (! (filter & SCAN_FINI))
2674 if (which_pass != PASS_LIB)
2675 fatal_error ("fini function found in object %s", prog_name);
2676 #ifndef LD_FINI_SWITCH
2677 add_to_list (&destructors, name);
2682 if (! (filter & SCAN_DWEH))
2684 if (which_pass != PASS_LIB)
2685 add_to_list (&frame_tables, name);
2688 default: /* not a constructor or destructor */
2694 fprintf (stderr, "\n");
2696 do_wait (nm_file_name, pex);
2698 signal (SIGINT, int_handler);
2700 signal (SIGQUIT, quit_handler);
2706 /* Use the List Dynamic Dependencies program to find shared libraries that
2707 the output file depends upon and their initialization/finalization
2708 routines, if any. */
2711 scan_libraries (const char *prog_name)
2713 static struct head libraries; /* list of shared libraries found */
2715 void (*int_handler) (int);
2717 void (*quit_handler) (int);
2719 char *real_ldd_argv[4];
2720 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2722 struct pex_obj *pex;
2728 /* If we do not have an `ldd', complain. */
2729 if (ldd_file_name == 0)
2731 error ("cannot find 'ldd'");
2735 ldd_argv[argc++] = ldd_file_name;
2736 ldd_argv[argc++] = prog_name;
2737 ldd_argv[argc++] = (char *) 0;
2739 /* Trace if needed. */
2742 const char **p_argv;
2745 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2746 fprintf (stderr, " %s", str);
2748 fprintf (stderr, "\n");
2754 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2756 fatal_error ("pex_init failed: %m");
2758 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2764 fatal_error ("%s: %m", _(errmsg));
2767 fatal_error (errmsg);
2770 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2772 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2775 inf = pex_read_output (pex, 0);
2777 fatal_error ("can't open ldd output: %m");
2780 notice ("\nldd output with constructors/destructors.\n");
2782 /* Read each line of ldd output. */
2783 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2786 char *name, *end, *p = buf;
2788 /* Extract names of libraries and add to list. */
2789 PARSE_LDD_OUTPUT (p);
2794 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2795 fatal_error ("dynamic dependency %s not found", buf);
2797 /* Find the end of the symbol name. */
2799 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2804 if (access (name, R_OK) == 0)
2805 add_to_list (&libraries, name);
2807 fatal_error ("unable to open dynamic dependency '%s'", buf);
2810 fprintf (stderr, "\t%s\n", buf);
2813 fprintf (stderr, "\n");
2815 do_wait (ldd_file_name, pex);
2817 signal (SIGINT, int_handler);
2819 signal (SIGQUIT, quit_handler);
2822 /* Now iterate through the library list adding their symbols to
2824 for (list = libraries.first; list; list = list->next)
2825 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2828 #endif /* LDD_SUFFIX */
2830 #endif /* OBJECT_FORMAT_NONE */
2834 * COFF specific stuff.
2837 #ifdef OBJECT_FORMAT_COFF
2839 #if defined (EXTENDED_COFF)
2841 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2842 # define GCC_SYMENT SYMR
2843 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2844 # define GCC_SYMINC(X) (1)
2845 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2846 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2850 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2851 # define GCC_SYMENT SYMENT
2852 # if defined (C_WEAKEXT)
2853 # define GCC_OK_SYMBOL(X) \
2854 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2855 ((X).n_scnum > N_UNDEF) && \
2857 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2858 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2859 # define GCC_UNDEF_SYMBOL(X) \
2860 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2861 ((X).n_scnum == N_UNDEF))
2863 # define GCC_OK_SYMBOL(X) \
2864 (((X).n_sclass == C_EXT) && \
2865 ((X).n_scnum > N_UNDEF) && \
2867 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2868 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2869 # define GCC_UNDEF_SYMBOL(X) \
2870 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2872 # define GCC_SYMINC(X) ((X).n_numaux+1)
2873 # define GCC_SYMZERO(X) 0
2875 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2876 #if TARGET_AIX_VERSION >= 51
2877 # define GCC_CHECK_HDR(X) \
2878 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2879 || (HEADER (X).f_magic == 0767 && aix64_flag))
2881 # define GCC_CHECK_HDR(X) \
2882 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2883 || (HEADER (X).f_magic == 0757 && aix64_flag))
2888 #ifdef COLLECT_EXPORT_LIST
2889 /* Array of standard AIX libraries which should not
2890 be scanned for ctors/dtors. */
2891 static const char *const aix_std_libs[] = {
2899 "/usr/lib/libc_r.a",
2900 "/usr/lib/libm_r.a",
2901 "/usr/lib/threads/libc.a",
2902 "/usr/ccs/lib/libc.a",
2903 "/usr/ccs/lib/libm.a",
2904 "/usr/ccs/lib/libc_r.a",
2905 "/usr/ccs/lib/libm_r.a",
2909 /* This function checks the filename and returns 1
2910 if this name matches the location of a standard AIX library. */
2911 static int ignore_library (const char *);
2913 ignore_library (const char *name)
2915 const char *const *p;
2918 if (target_system_root[0] != '\0')
2920 length = strlen (target_system_root);
2921 if (strncmp (name, target_system_root, length) != 0)
2925 for (p = &aix_std_libs[0]; *p != NULL; ++p)
2926 if (strcmp (name, *p) == 0)
2930 #endif /* COLLECT_EXPORT_LIST */
2932 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2933 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2936 /* COFF version to scan the name list of the loaded program for
2937 the symbols g++ uses for static constructors and destructors. */
2940 scan_prog_file (const char *prog_name, scanpass which_pass,
2943 LDFILE *ldptr = NULL;
2944 int sym_index, sym_count;
2947 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2950 #ifdef COLLECT_EXPORT_LIST
2951 /* We do not need scanning for some standard C libraries. */
2952 if (which_pass == PASS_FIRST && ignore_library (prog_name))
2955 /* On AIX we have a loop, because there is not much difference
2956 between an object and an archive. This trick allows us to
2957 eliminate scan_libraries() function. */
2961 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2962 non-const char * filename parameter, even though it will not
2963 modify that string. So we must cast away const-ness here,
2964 using CONST_CAST to prevent complaints from -Wcast-qual. */
2965 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
2967 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2968 fatal_error ("%s: not a COFF file", prog_name);
2970 if (GCC_CHECK_HDR (ldptr))
2972 sym_count = GCC_SYMBOLS (ldptr);
2973 sym_index = GCC_SYMZERO (ldptr);
2975 #ifdef COLLECT_EXPORT_LIST
2976 /* Is current archive member a shared object? */
2977 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2980 while (sym_index < sym_count)
2984 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2986 sym_index += GCC_SYMINC (symbol);
2988 if (GCC_OK_SYMBOL (symbol))
2992 if ((name = ldgetname (ldptr, &symbol)) == NULL)
2993 continue; /* Should never happen. */
2995 #ifdef XCOFF_DEBUGGING_INFO
2996 /* All AIX function names have a duplicate entry
2997 beginning with a dot. */
3002 switch (is_ctor_dtor (name))
3005 if (! (filter & SCAN_CTOR))
3008 add_to_list (&constructors, name);
3009 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3010 if (which_pass == PASS_OBJ)
3011 add_to_list (&exports, name);
3016 if (! (filter & SCAN_DTOR))
3019 add_to_list (&destructors, name);
3020 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3021 if (which_pass == PASS_OBJ)
3022 add_to_list (&exports, name);
3026 #ifdef COLLECT_EXPORT_LIST
3028 if (! (filter & SCAN_INIT))
3030 #ifndef LD_INIT_SWITCH
3032 add_to_list (&constructors, name);
3037 if (! (filter & SCAN_FINI))
3039 #ifndef LD_INIT_SWITCH
3041 add_to_list (&destructors, name);
3047 if (! (filter & SCAN_DWEH))
3050 add_to_list (&frame_tables, name);
3051 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3052 if (which_pass == PASS_OBJ)
3053 add_to_list (&exports, name);
3057 default: /* not a constructor or destructor */
3058 #ifdef COLLECT_EXPORT_LIST
3059 /* Explicitly export all global symbols when
3060 building a shared object on AIX, but do not
3061 re-export symbols from another shared object
3062 and do not export symbols if the user
3063 provides an explicit export list. */
3064 if (shared_obj && !is_shared
3065 && which_pass == PASS_OBJ && !export_flag)
3066 add_to_list (&exports, name);
3072 #if !defined(EXTENDED_COFF)
3073 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3074 symbol.n_scnum, symbol.n_sclass,
3075 (symbol.n_type ? "0" : ""), symbol.n_type,
3079 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3080 symbol.iss, (long) symbol.value, symbol.index, name);
3085 #ifdef COLLECT_EXPORT_LIST
3088 /* If archive contains both 32-bit and 64-bit objects,
3089 we want to skip objects in other mode so mismatch normal. */
3091 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3092 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3098 fatal_error ("%s: cannot open as COFF file", prog_name);
3100 #ifdef COLLECT_EXPORT_LIST
3101 /* On AIX loop continues while there are more members in archive. */
3103 while (ldclose (ldptr) == FAILURE);
3105 /* Otherwise we simply close ldptr. */
3106 (void) ldclose(ldptr);
3109 #endif /* OBJECT_FORMAT_COFF */
3111 #ifdef COLLECT_EXPORT_LIST
3112 /* Given a library name without "lib" prefix, this function
3113 returns a full library name including a path. */
3115 resolve_lib_name (const char *name)
3119 /* Library extensions for AIX dynamic linking. */
3120 const char * const libexts[2] = {"a", "so"};
3122 for (i = 0; libpaths[i]; i++)
3123 if (libpaths[i]->max_len > l)
3124 l = libpaths[i]->max_len;
3126 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3128 for (i = 0; libpaths[i]; i++)
3130 struct prefix_list *list = libpaths[i]->plist;
3131 for (; list; list = list->next)
3133 /* The following lines are needed because path_prefix list
3134 may contain directories both with trailing DIR_SEPARATOR and
3137 if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
3139 for (j = 0; j < 2; j++)
3141 sprintf (lib_buf, "%s%slib%s.%s",
3142 list->prefix, p, name,
3143 libexts[(j + aixrtl_flag) % 2]);
3144 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3145 if (file_exists (lib_buf))
3147 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3154 fprintf (stderr, "not found\n");
3156 fatal_error ("library lib%s not found", name);
3159 #endif /* COLLECT_EXPORT_LIST */
3161 #ifdef COLLECT_RUN_DSYMUTIL
3162 static int flag_dsym = false;
3163 static int flag_idsym = false;
3166 process_args (int *argcp, char **argv) {
3169 for (i=0; i<argc; ++i)
3171 if (strcmp (argv[i], "-dsym") == 0)
3174 /* Remove the flag, as we handle all processing for it. */
3177 argv[j] = argv[j+1];
3182 else if (strcmp (argv[i], "-idsym") == 0)
3185 /* Remove the flag, as we handle all processing for it. */
3188 argv[j] = argv[j+1];
3197 do_dsymutil (const char *output_file) {
3198 const char *dsymutil = DSYMUTIL + 1;
3199 struct pex_obj *pex;
3200 char **real_argv = XCNEWVEC (char *, 3);
3201 const char ** argv = CONST_CAST2 (const char **, char **,
3205 argv[1] = output_file;
3206 argv[2] = (char *) 0;
3208 pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3209 do_wait (dsymutil, pex);
3213 post_ld_pass (bool temp_file) {
3214 if (!(temp_file && flag_idsym) && !flag_dsym)
3217 do_dsymutil (output_file);
3221 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3222 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }