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;
1094 #ifdef TARGET_AIX_VERSION
1095 int object_nbr = argc;
1101 p = argv[0] + strlen (argv[0]);
1102 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1106 xmalloc_set_program_name (progname);
1109 expandargv (&argc, &argv);
1110 if (argv != old_argv)
1111 at_file_supplied = 1;
1113 process_args (&argc, argv);
1115 num_c_args = argc + 9;
1117 #ifndef HAVE_LD_DEMANGLE
1118 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1120 /* Suppress demangling by the real linker, which may be broken. */
1121 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
1124 #if defined (COLLECT2_HOST_INITIALIZATION)
1125 /* Perform system dependent initialization, if necessary. */
1126 COLLECT2_HOST_INITIALIZATION;
1130 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1131 receive the signal. A different setting is inheritable */
1132 signal (SIGCHLD, SIG_DFL);
1135 /* Unlock the stdio streams. */
1136 unlock_std_streams ();
1138 gcc_init_libintl ();
1140 diagnostic_initialize (global_dc, 0);
1142 /* Do not invoke xcalloc before this point, since locale needs to be
1143 set first, in case a diagnostic is issued. */
1145 ld1_argv = XCNEWVEC (char *, argc + 4);
1146 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1147 ld2_argv = XCNEWVEC (char *, argc + 11);
1148 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1149 object_lst = XCNEWVEC (char *, argc);
1150 object = CONST_CAST2 (const char **, char **, object_lst);
1156 /* Parse command line early for instances of -debug. This allows
1157 the debug flag to be set before functions like find_a_file()
1158 are called. We also look for the -flto or -flto-partition=none flag to know
1159 what LTO mode we are in. */
1162 bool no_partition = false;
1164 for (i = 1; argv[i] != NULL; i ++)
1166 if (! strcmp (argv[i], "-debug"))
1168 else if (! strcmp (argv[i], "-flto-partition=none"))
1169 no_partition = true;
1170 else if ((! strncmp (argv[i], "-flto=", 6)
1171 || ! strcmp (argv[i], "-flto")) && ! use_plugin)
1172 lto_mode = LTO_MODE_WHOPR;
1173 else if (!strncmp (argv[i], "-fno-lto", 8))
1174 lto_mode = LTO_MODE_NONE;
1175 else if (! strcmp (argv[i], "-plugin"))
1178 lto_mode = LTO_MODE_NONE;
1180 #ifdef COLLECT_EXPORT_LIST
1181 /* since -brtl, -bexport, -b64 are not position dependent
1182 also check for them here */
1183 if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1186 /* We want to disable automatic exports on AIX when user
1187 explicitly puts an export list in command line */
1188 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1190 else if (arg[2] == '6' && arg[3] == '4')
1192 else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1198 if (no_partition && lto_mode == LTO_MODE_WHOPR)
1199 lto_mode = LTO_MODE_LTO;
1202 #ifndef DEFAULT_A_OUT_NAME
1203 output_file = "a.out";
1205 output_file = DEFAULT_A_OUT_NAME;
1208 obstack_begin (&temporary_obstack, 0);
1209 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1211 #ifndef HAVE_LD_DEMANGLE
1212 current_demangling_style = auto_demangling;
1214 p = getenv ("COLLECT_GCC_OPTIONS");
1217 const char *q = extract_string (&p);
1218 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1221 obstack_free (&temporary_obstack, temporary_firstobj);
1223 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1224 -fno-exceptions -w -fno-whole-program */
1227 c_argv = XCNEWVEC (char *, num_c_args);
1228 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1231 fatal_error ("no arguments");
1234 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1235 signal (SIGQUIT, handler);
1237 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1238 signal (SIGINT, handler);
1240 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1241 signal (SIGALRM, handler);
1244 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1245 signal (SIGHUP, handler);
1247 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1248 signal (SIGSEGV, handler);
1250 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1251 signal (SIGBUS, handler);
1254 /* Extract COMPILER_PATH and PATH into our prefix list. */
1255 prefix_from_env ("COMPILER_PATH", &cpath);
1256 prefix_from_env ("PATH", &path);
1258 /* Try to discover a valid linker/nm/strip to use. */
1260 /* Maybe we know the right file to use (if not cross). */
1261 ld_file_name = NULL;
1262 #ifdef DEFAULT_LINKER
1263 if (access (DEFAULT_LINKER, X_OK) == 0)
1264 ld_file_name = DEFAULT_LINKER;
1265 if (ld_file_name == 0)
1267 #ifdef REAL_LD_FILE_NAME
1268 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1269 if (ld_file_name == 0)
1271 /* Search the (target-specific) compiler dirs for ld'. */
1272 ld_file_name = find_a_file (&cpath, real_ld_suffix);
1273 /* Likewise for `collect-ld'. */
1274 if (ld_file_name == 0)
1275 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1276 /* Search the compiler directories for `ld'. We have protection against
1277 recursive calls in find_a_file. */
1278 if (ld_file_name == 0)
1279 ld_file_name = find_a_file (&cpath,
1283 /* Search the ordinary system bin directories
1284 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1285 if (ld_file_name == 0)
1286 ld_file_name = find_a_file (&path,
1288 ? full_plugin_ld_suffix
1291 if (ld_file_name == NULL)
1293 #define LD_NEW_PREFIX "../ld/"
1294 struct prefix_list l = { LD_NEW_PREFIX, NULL };
1295 struct path_prefix p = { NULL, sizeof LD_NEW_PREFIX, "in-build-tree-linker" };
1298 ld_file_name = find_a_file (& p, "ld-new" );
1301 if (ld_file_name == NULL && use_plugin)
1303 /* Configure will set PLUGIN_LD to the in-build-tree name of the plugin
1304 supporting linker. If we are running from an installed set of binaries
1305 however then we need to search for the built linker, not the in-tree linker. */
1306 ld_file_name = find_a_file (& cpath, ld_suffix);
1307 if (ld_file_name == NULL)
1308 ld_file_name = find_a_file (& path, full_ld_suffix);
1311 #ifdef REAL_NM_FILE_NAME
1312 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1313 if (nm_file_name == 0)
1315 nm_file_name = find_a_file (&cpath, gnm_suffix);
1316 if (nm_file_name == 0)
1317 nm_file_name = find_a_file (&path, full_gnm_suffix);
1318 if (nm_file_name == 0)
1319 nm_file_name = find_a_file (&cpath, nm_suffix);
1320 if (nm_file_name == 0)
1321 nm_file_name = find_a_file (&path, full_nm_suffix);
1324 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1325 if (ldd_file_name == 0)
1326 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1329 #ifdef REAL_STRIP_FILE_NAME
1330 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1331 if (strip_file_name == 0)
1333 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1334 if (strip_file_name == 0)
1335 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1336 if (strip_file_name == 0)
1337 strip_file_name = find_a_file (&cpath, strip_suffix);
1338 if (strip_file_name == 0)
1339 strip_file_name = find_a_file (&path, full_strip_suffix);
1341 /* Determine the full path name of the C compiler to use. */
1342 c_file_name = getenv ("COLLECT_GCC");
1343 if (c_file_name == 0)
1345 #ifdef CROSS_DIRECTORY_STRUCTURE
1346 c_file_name = concat (target_machine, "-gcc", NULL);
1348 c_file_name = "gcc";
1352 p = find_a_file (&cpath, c_file_name);
1354 /* Here it should be safe to use the system search path since we should have
1355 already qualified the name of the compiler when it is needed. */
1357 p = find_a_file (&path, c_file_name);
1362 *ld1++ = *ld2++ = ld_file_name;
1364 /* Make temp file names. */
1365 c_file = make_temp_file (".c");
1366 o_file = make_temp_file (".o");
1367 #ifdef COLLECT_EXPORT_LIST
1368 export_file = make_temp_file (".x");
1370 ldout = make_temp_file (".ld");
1371 lderrout = make_temp_file (".le");
1372 *c_ptr++ = c_file_name;
1379 #ifdef COLLECT_EXPORT_LIST
1380 /* Generate a list of directories from LIBPATH. */
1381 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1382 /* Add to this list also two standard directories where
1383 AIX loader always searches for libraries. */
1384 add_prefix (&libpath_lib_dirs, "/lib");
1385 add_prefix (&libpath_lib_dirs, "/usr/lib");
1388 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1390 AIX support needs to know if -shared has been specified before
1391 parsing commandline arguments. */
1393 p = getenv ("COLLECT_GCC_OPTIONS");
1396 const char *q = extract_string (&p);
1397 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1398 *c_ptr++ = xstrdup (q);
1399 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1400 *c_ptr++ = xstrdup (q);
1401 if (strcmp (q, "-shared") == 0)
1403 if (*q == '-' && q[1] == 'B')
1405 *c_ptr++ = xstrdup (q);
1408 q = extract_string (&p);
1409 *c_ptr++ = xstrdup (q);
1413 obstack_free (&temporary_obstack, temporary_firstobj);
1414 *c_ptr++ = "-fno-profile-arcs";
1415 *c_ptr++ = "-fno-test-coverage";
1416 *c_ptr++ = "-fno-branch-probabilities";
1417 *c_ptr++ = "-fno-exceptions";
1419 *c_ptr++ = "-fno-whole-program";
1421 /* !!! When GCC calls collect2,
1422 it does not know whether it is calling collect2 or ld.
1423 So collect2 cannot meaningfully understand any options
1424 except those ld understands.
1425 If you propose to make GCC pass some other option,
1426 just imagine what will happen if ld is really ld!!! */
1428 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1429 /* After the first file, put in the c++ rt0. */
1432 while ((arg = *++argv) != (char *) 0)
1434 *ld1++ = *ld2++ = arg;
1441 if (!strcmp (arg, "-debug"))
1443 /* Already parsed. */
1447 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1450 *ld1++ = *ld2++ = *argv;
1455 if (strncmp (arg, "-flto", 5) == 0)
1458 /* Do not pass LTO flag to the linker. */
1462 error ("LTO support has not been enabled in this "
1466 #ifdef TARGET_AIX_VERSION
1469 /* File containing a list of input files to process. */
1472 char buf[MAXPATHLEN + 2];
1473 /* Number of additionnal object files. */
1475 /* Maximum of additionnal object files before vector
1478 const char *list_filename = arg + 2;
1480 /* Accept -fFILENAME and -f FILENAME. */
1481 if (*list_filename == '\0' && argv[1])
1484 list_filename = *argv;
1485 *ld1++ = *ld2++ = *argv;
1488 stream = fopen (list_filename, "r");
1490 fatal_error ("can't open %s: %m", list_filename);
1492 while (fgets (buf, sizeof buf, stream) != NULL)
1494 /* Remove end of line. */
1495 int len = strlen (buf);
1496 if (len >= 1 && buf[len - 1] =='\n')
1497 buf[len - 1] = '\0';
1499 /* Put on object vector.
1500 Note: we only expanse vector here, so we must keep
1501 extra space for remaining arguments. */
1502 if (add_nbr >= add_max)
1505 object - CONST_CAST2 (const char **, char **,
1507 add_max = (add_max == 0) ? 16 : add_max * 2;
1508 object_lst = XRESIZEVEC (char *, object_lst,
1509 object_nbr + add_max);
1510 object = CONST_CAST2 (const char **, char **,
1512 object_nbr += add_max;
1514 *object++ = xstrdup (buf);
1525 /* place o_file BEFORE this argument! */
1531 #ifdef COLLECT_EXPORT_LIST
1533 /* Resolving full library name. */
1534 const char *s = resolve_lib_name (arg+2);
1536 /* Saving a full library name. */
1537 add_to_list (&libs, s);
1542 #ifdef COLLECT_EXPORT_LIST
1543 /* Saving directories where to search for libraries. */
1545 add_prefix (&cmdline_lib_dirs, arg+2);
1548 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1550 if (is_in_args (arg,
1551 CONST_CAST2 (const char **, char **, ld1_argv),
1555 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1560 output_file = *ld1++ = *ld2++ = *++argv;
1562 output_file = &arg[2];
1571 if (arg[2] == '\0' && do_collecting)
1573 /* We must strip after the nm run, otherwise C++ linking
1574 will not work. Thus we strip in the second ld run, or
1575 else with strip if there is no second ld run. */
1587 if (strcmp (arg, "--no-demangle") == 0)
1589 #ifndef HAVE_LD_DEMANGLE
1595 else if (strncmp (arg, "--demangle", 10) == 0)
1597 #ifndef HAVE_LD_DEMANGLE
1601 enum demangling_styles style
1602 = cplus_demangle_name_to_style (arg+11);
1603 if (style == unknown_demangling)
1604 error ("unknown demangling style '%s'", arg+11);
1606 current_demangling_style = style;
1612 else if (strncmp (arg, "--sysroot=", 10) == 0)
1613 target_system_root = arg + 10;
1614 else if (strcmp (arg, "--version") == 0)
1616 else if (strcmp (arg, "--help") == 0)
1621 else if ((p = strrchr (arg, '.')) != (char *) 0
1622 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1623 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1624 || strcmp (p, ".obj") == 0))
1633 /* place o_file BEFORE this argument! */
1639 if (p[1] == 'o' || p[1] == 'l')
1641 #ifdef COLLECT_EXPORT_LIST
1642 /* libraries can be specified directly, i.e. without -l flag. */
1645 /* Saving a full library name. */
1646 add_to_list (&libs, arg);
1652 #ifdef COLLECT_EXPORT_LIST
1653 /* This is added only for debugging purposes. */
1656 fprintf (stderr, "List of libraries:\n");
1657 dump_list (stderr, "\t", libs.first);
1660 /* The AIX linker will discard static constructors in object files if
1661 nothing else in the file is referenced, so look at them first. Unless
1662 we are building a shared object, ignore the eh frame tables, as we
1663 would otherwise reference them all, hence drag all the corresponding
1664 objects even if nothing else is referenced. */
1666 const char **export_object_lst
1667 = CONST_CAST2 (const char **, char **, object_lst);
1669 struct id *list = libs.first;
1671 /* Compute the filter to use from the current one, do scan, then adjust
1672 the "current" filter to remove what we just included here. This will
1673 control whether we need a first pass link later on or not, and what
1674 will remain to be scanned there. */
1676 scanfilter this_filter = ld1_filter;
1679 this_filter &= ~SCAN_DWEH;
1682 while (export_object_lst < object)
1683 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1685 for (; list; list = list->next)
1686 scan_prog_file (list->name, PASS_FIRST, this_filter);
1688 ld1_filter = ld1_filter & ~this_filter;
1693 char *buf = concat ("-bE:", export_file, NULL);
1698 exportf = fopen (export_file, "w");
1699 if (exportf == (FILE *) 0)
1700 fatal_error ("fopen %s: %m", export_file);
1701 write_aix_file (exportf, exports.first);
1702 if (fclose (exportf))
1703 fatal_error ("fclose %s: %m", export_file);
1708 *c_ptr = *ld1 = *object = (char *) 0;
1711 notice ("collect2 version %s\n", version_string);
1715 printf ("Usage: collect2 [options]\n");
1716 printf (" Wrap linker and generate constructor code if needed.\n");
1717 printf (" Options:\n");
1718 printf (" -debug Enable debug output\n");
1719 printf (" --help Display this information\n");
1720 printf (" -v, --version Display this program's version number\n");
1722 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1723 printf ("Report bugs: %s\n", bug_report_url);
1730 fprintf (stderr, "ld_file_name = %s\n",
1731 (ld_file_name ? ld_file_name : "not found"));
1732 fprintf (stderr, "c_file_name = %s\n",
1733 (c_file_name ? c_file_name : "not found"));
1734 fprintf (stderr, "nm_file_name = %s\n",
1735 (nm_file_name ? nm_file_name : "not found"));
1737 fprintf (stderr, "ldd_file_name = %s\n",
1738 (ldd_file_name ? ldd_file_name : "not found"));
1740 fprintf (stderr, "strip_file_name = %s\n",
1741 (strip_file_name ? strip_file_name : "not found"));
1742 fprintf (stderr, "c_file = %s\n",
1743 (c_file ? c_file : "not found"));
1744 fprintf (stderr, "o_file = %s\n",
1745 (o_file ? o_file : "not found"));
1747 ptr = getenv ("COLLECT_GCC_OPTIONS");
1749 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1751 ptr = getenv ("COLLECT_GCC");
1753 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1755 ptr = getenv ("COMPILER_PATH");
1757 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1759 ptr = getenv (LIBRARY_PATH_ENV);
1761 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1763 fprintf (stderr, "\n");
1766 /* Load the program, searching all libraries and attempting to provide
1767 undefined symbols from repository information.
1769 If -r or they will be run via some other method, do not build the
1770 constructor or destructor list, just return now. */
1773 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1775 /* Perform the first pass link now, if we're about to exit or if we need
1776 to scan for things we haven't collected yet before pursuing further.
1778 On AIX, the latter typically includes nothing for shared objects or
1779 frame tables for an executable, out of what the required early scan on
1780 objects and libraries has performed above. In the !shared_obj case, we
1781 expect the relevant tables to be dragged together with their associated
1782 functions from precise cross reference insertions by the compiler. */
1784 if (early_exit || ld1_filter != SCAN_NOTHING)
1785 do_tlink (ld1_argv, object_lst);
1789 #ifdef COLLECT_EXPORT_LIST
1790 /* Make sure we delete the export file we may have created. */
1791 if (export_file != 0 && export_file[0])
1792 maybe_unlink (export_file);
1794 if (lto_mode != LTO_MODE_NONE)
1795 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1797 post_ld_pass (false);
1799 maybe_unlink (c_file);
1800 maybe_unlink (o_file);
1805 /* Unless we have done it all already, examine the namelist and search for
1806 static constructors and destructors to call. Write the constructor and
1807 destructor tables to a .s file and reload. */
1809 if (ld1_filter != SCAN_NOTHING)
1810 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1812 #ifdef SCAN_LIBRARIES
1813 scan_libraries (output_file);
1818 notice_translated (ngettext ("%d constructor found\n",
1819 "%d constructors found\n",
1820 constructors.number),
1821 constructors.number);
1822 notice_translated (ngettext ("%d destructor found\n",
1823 "%d destructors found\n",
1824 destructors.number),
1825 destructors.number);
1826 notice_translated (ngettext("%d frame table found\n",
1827 "%d frame tables found\n",
1828 frame_tables.number),
1829 frame_tables.number);
1832 /* If the scan exposed nothing of special interest, there's no need to
1833 generate the glue code and relink so return now. */
1835 if (constructors.number == 0 && destructors.number == 0
1836 && frame_tables.number == 0
1837 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1838 /* If we will be running these functions ourselves, we want to emit
1839 stubs into the shared library so that we do not have to relink
1840 dependent programs when we add static objects. */
1845 /* Do tlink without additional code generation now if we didn't
1846 do it earlier for scanning purposes. */
1847 if (ld1_filter == SCAN_NOTHING)
1848 do_tlink (ld1_argv, object_lst);
1851 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1853 /* Strip now if it was requested on the command line. */
1856 char **real_strip_argv = XCNEWVEC (char *, 3);
1857 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1860 strip_argv[0] = strip_file_name;
1861 strip_argv[1] = output_file;
1862 strip_argv[2] = (char *) 0;
1863 fork_execute ("strip", real_strip_argv);
1866 #ifdef COLLECT_EXPORT_LIST
1867 maybe_unlink (export_file);
1869 post_ld_pass (false);
1871 maybe_unlink (c_file);
1872 maybe_unlink (o_file);
1876 /* Sort ctor and dtor lists by priority. */
1877 sort_ids (&constructors);
1878 sort_ids (&destructors);
1880 maybe_unlink(output_file);
1881 outf = fopen (c_file, "w");
1882 if (outf == (FILE *) 0)
1883 fatal_error ("fopen %s: %m", c_file);
1885 write_c_file (outf, c_file);
1888 fatal_error ("fclose %s: %m", c_file);
1890 /* Tell the linker that we have initializer and finalizer functions. */
1891 #ifdef LD_INIT_SWITCH
1892 #ifdef COLLECT_EXPORT_LIST
1893 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1895 *ld2++ = LD_INIT_SWITCH;
1897 *ld2++ = LD_FINI_SWITCH;
1902 #ifdef COLLECT_EXPORT_LIST
1905 /* If we did not add export flag to link arguments before, add it to
1906 second link phase now. No new exports should have been added. */
1907 if (! exports.first)
1908 *ld2++ = concat ("-bE:", export_file, NULL);
1910 #ifndef LD_INIT_SWITCH
1911 add_to_list (&exports, initname);
1912 add_to_list (&exports, fininame);
1913 add_to_list (&exports, "_GLOBAL__DI");
1914 add_to_list (&exports, "_GLOBAL__DD");
1916 exportf = fopen (export_file, "w");
1917 if (exportf == (FILE *) 0)
1918 fatal_error ("fopen %s: %m", export_file);
1919 write_aix_file (exportf, exports.first);
1920 if (fclose (exportf))
1921 fatal_error ("fclose %s: %m", export_file);
1925 /* End of arguments to second link phase. */
1930 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1931 output_file, c_file);
1932 write_c_file (stderr, "stderr");
1933 fprintf (stderr, "========== end of c_file\n\n");
1934 #ifdef COLLECT_EXPORT_LIST
1935 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1936 write_aix_file (stderr, exports.first);
1937 fprintf (stderr, "========== end of export_file\n\n");
1941 /* Assemble the constructor and destructor tables.
1942 Link the tables in with the rest of the program. */
1944 fork_execute ("gcc", c_argv);
1945 #ifdef COLLECT_EXPORT_LIST
1946 /* On AIX we must call tlink because of possible templates resolution. */
1947 do_tlink (ld2_argv, object_lst);
1950 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1952 /* Otherwise, simply call ld because tlink is already done. */
1954 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1957 fork_execute ("ld", ld2_argv);
1958 post_ld_pass (false);
1961 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1962 constructors/destructors in shared libraries. */
1963 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1966 maybe_unlink (c_file);
1967 maybe_unlink (o_file);
1969 #ifdef COLLECT_EXPORT_LIST
1970 maybe_unlink (export_file);
1977 /* Wait for a process to finish, and exit if a nonzero status is found. */
1980 collect_wait (const char *prog, struct pex_obj *pex)
1984 if (!pex_get_status (pex, 1, &status))
1985 fatal_error ("can't get program status: %m");
1990 if (WIFSIGNALED (status))
1992 int sig = WTERMSIG (status);
1993 error ("%s terminated with signal %d [%s]%s",
1994 prog, sig, strsignal(sig),
1995 WCOREDUMP(status) ? ", core dumped" : "");
1996 collect_exit (FATAL_EXIT_CODE);
1999 if (WIFEXITED (status))
2000 return WEXITSTATUS (status);
2006 do_wait (const char *prog, struct pex_obj *pex)
2008 int ret = collect_wait (prog, pex);
2011 error ("%s returned %d exit status", prog, ret);
2017 unlink (response_file);
2018 response_file = NULL;
2023 /* Execute a program, and wait for the reply. */
2026 collect_execute (const char *prog, char **argv, const char *outname,
2027 const char *errname, int flags)
2029 struct pex_obj *pex;
2032 char *response_arg = NULL;
2033 char *response_argv[3] ATTRIBUTE_UNUSED;
2035 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2037 /* If using @file arguments, create a temporary file and put the
2038 contents of argv into it. Then change argv to an array corresponding
2039 to a single argument @FILE, where FILE is the temporary filename. */
2041 char **current_argv = argv + 1;
2042 char *argv0 = argv[0];
2046 /* Note: we assume argv contains at least one element; this is
2049 response_file = make_temp_file ("");
2051 f = fopen (response_file, "w");
2054 fatal_error ("could not open response file %s", response_file);
2056 status = writeargv (current_argv, f);
2059 fatal_error ("could not write to response file %s", response_file);
2061 status = fclose (f);
2064 fatal_error ("could not close response file %s", response_file);
2066 response_arg = concat ("@", response_file, NULL);
2067 response_argv[0] = argv0;
2068 response_argv[1] = response_arg;
2069 response_argv[2] = NULL;
2071 argv = response_argv;
2080 fprintf (stderr, "%s", argv[0]);
2082 notice ("[cannot find %s]", prog);
2084 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2085 fprintf (stderr, " %s", str);
2087 fprintf (stderr, "\n");
2093 /* If we cannot find a program we need, complain error. Do this here
2094 since we might not end up needing something that we could not find. */
2097 fatal_error ("cannot find '%s'", prog);
2099 pex = pex_init (0, "collect2", NULL);
2101 fatal_error ("pex_init failed: %m");
2103 errmsg = pex_run (pex, flags, argv[0], argv, outname,
2110 fatal_error ("%s: %m", _(errmsg));
2113 fatal_error (errmsg);
2116 free (response_arg);
2122 fork_execute (const char *prog, char **argv)
2124 struct pex_obj *pex;
2126 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2127 do_wait (prog, pex);
2130 /* Unlink a file unless we are debugging. */
2133 maybe_unlink (const char *file)
2136 unlink_if_ordinary (file);
2138 notice ("[Leaving %s]\n", file);
2141 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2144 maybe_unlink_list (char **file_list)
2146 char **tmp = file_list;
2149 maybe_unlink (*(tmp++));
2153 static long sequence_number = 0;
2155 /* Add a name to a linked list. */
2158 add_to_list (struct head *head_ptr, const char *name)
2161 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2163 strcpy (newid->name, name);
2165 if (head_ptr->first)
2166 head_ptr->last->next = newid;
2168 head_ptr->first = newid;
2170 /* Check for duplicate symbols. */
2171 for (p = head_ptr->first;
2172 strcmp (name, p->name) != 0;
2177 head_ptr->last->next = 0;
2182 newid->sequence = ++sequence_number;
2183 head_ptr->last = newid;
2187 /* Grab the init priority number from an init function name that
2188 looks like "_GLOBAL_.I.12345.foo". */
2191 extract_init_priority (const char *name)
2195 while (name[pos] == '_')
2197 pos += 10; /* strlen ("GLOBAL__X_") */
2199 /* Extract init_p number from ctor/dtor name. */
2200 pri = atoi (name + pos);
2201 return pri ? pri : DEFAULT_INIT_PRIORITY;
2204 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2205 ctors will be run from right to left, dtors from left to right. */
2208 sort_ids (struct head *head_ptr)
2210 /* id holds the current element to insert. id_next holds the next
2211 element to insert. id_ptr iterates through the already sorted elements
2212 looking for the place to insert id. */
2213 struct id *id, *id_next, **id_ptr;
2215 id = head_ptr->first;
2217 /* We don't have any sorted elements yet. */
2218 head_ptr->first = NULL;
2220 for (; id; id = id_next)
2223 id->sequence = extract_init_priority (id->name);
2225 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2227 /* If the sequence numbers are the same, we put the id from the
2228 file later on the command line later in the list. */
2229 || id->sequence > (*id_ptr)->sequence
2230 /* Hack: do lexical compare, too.
2231 || (id->sequence == (*id_ptr)->sequence
2232 && strcmp (id->name, (*id_ptr)->name) > 0) */
2241 /* Now set the sequence numbers properly so write_c_file works. */
2242 for (id = head_ptr->first; id; id = id->next)
2243 id->sequence = ++sequence_number;
2246 /* Write: `prefix', the names on list LIST, `suffix'. */
2249 write_list (FILE *stream, const char *prefix, struct id *list)
2253 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2258 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2259 /* Given a STRING, return nonzero if it occurs in the list in range
2260 [ARGS_BEGIN,ARGS_END). */
2263 is_in_args (const char *string, const char **args_begin,
2264 const char **args_end)
2266 const char **args_pointer;
2267 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2268 if (strcmp (string, *args_pointer) == 0)
2272 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2274 #ifdef COLLECT_EXPORT_LIST
2275 /* This function is really used only on AIX, but may be useful. */
2278 is_in_list (const char *prefix, struct id *list)
2282 if (!strcmp (prefix, list->name)) return 1;
2288 #endif /* COLLECT_EXPORT_LIST */
2290 /* Added for debugging purpose. */
2291 #ifdef COLLECT_EXPORT_LIST
2293 dump_list (FILE *stream, const char *prefix, struct id *list)
2297 fprintf (stream, "%s%s,\n", prefix, list->name);
2305 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2309 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2316 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2320 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2321 prefix, list->sequence, list->name);
2326 /* Write out the constructor and destructor tables statically (for a shared
2327 object), along with the functions to execute them. */
2330 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2334 int frames = (frame_tables.number > 0);
2336 /* Figure out name of output_file, stripping off .so version. */
2337 q = p = lbasename (output_file);
2349 if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2351 q += strlen (SHLIB_SUFFIX);
2358 /* q points to null at end of the string (or . of the .so version) */
2359 prefix = XNEWVEC (char, q - p + 1);
2360 strncpy (prefix, p, q - p);
2362 for (r = prefix; *r; r++)
2363 if (!ISALNUM ((unsigned char)*r))
2366 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2367 output_file, prefix);
2369 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2370 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2374 /* Write the tables as C code. */
2376 fprintf (stream, "static int count;\n");
2377 fprintf (stream, "typedef void entry_pt();\n");
2378 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2382 write_list_with_asm (stream, "extern void *", frame_tables.first);
2384 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2385 write_list (stream, "\t\t&", frame_tables.first);
2386 fprintf (stream, "\t0\n};\n");
2388 /* This must match what's in frame.h. */
2389 fprintf (stream, "struct object {\n");
2390 fprintf (stream, " void *pc_begin;\n");
2391 fprintf (stream, " void *pc_end;\n");
2392 fprintf (stream, " void *fde_begin;\n");
2393 fprintf (stream, " void *fde_array;\n");
2394 fprintf (stream, " __SIZE_TYPE__ count;\n");
2395 fprintf (stream, " struct object *next;\n");
2396 fprintf (stream, "};\n");
2398 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2399 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2401 fprintf (stream, "static void reg_frame () {\n");
2402 fprintf (stream, "\tstatic struct object ob;\n");
2403 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2404 fprintf (stream, "\t}\n");
2406 fprintf (stream, "static void dereg_frame () {\n");
2407 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2408 fprintf (stream, "\t}\n");
2411 fprintf (stream, "void %s() {\n", initname);
2412 if (constructors.number > 0 || frames)
2414 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2415 write_list (stream, "\t\t", constructors.first);
2417 fprintf (stream, "\treg_frame,\n");
2418 fprintf (stream, "\t};\n");
2419 fprintf (stream, "\tentry_pt **p;\n");
2420 fprintf (stream, "\tif (count++ != 0) return;\n");
2421 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2422 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2425 fprintf (stream, "\t++count;\n");
2426 fprintf (stream, "}\n");
2427 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2428 fprintf (stream, "void %s() {\n", fininame);
2429 if (destructors.number > 0 || frames)
2431 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2432 write_list (stream, "\t\t", destructors.first);
2434 fprintf (stream, "\tdereg_frame,\n");
2435 fprintf (stream, "\t};\n");
2436 fprintf (stream, "\tentry_pt **p;\n");
2437 fprintf (stream, "\tif (--count != 0) return;\n");
2438 fprintf (stream, "\tp = dtors;\n");
2439 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2440 destructors.number + frames);
2442 fprintf (stream, "}\n");
2446 COLLECT_SHARED_INIT_FUNC(stream, initname);
2447 COLLECT_SHARED_FINI_FUNC(stream, fininame);
2451 /* Write the constructor/destructor tables. */
2453 #ifndef LD_INIT_SWITCH
2455 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2457 /* Write the tables as C code. */
2459 int frames = (frame_tables.number > 0);
2461 fprintf (stream, "typedef void entry_pt();\n\n");
2463 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2467 write_list_with_asm (stream, "extern void *", frame_tables.first);
2469 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2470 write_list (stream, "\t\t&", frame_tables.first);
2471 fprintf (stream, "\t0\n};\n");
2473 /* This must match what's in frame.h. */
2474 fprintf (stream, "struct object {\n");
2475 fprintf (stream, " void *pc_begin;\n");
2476 fprintf (stream, " void *pc_end;\n");
2477 fprintf (stream, " void *fde_begin;\n");
2478 fprintf (stream, " void *fde_array;\n");
2479 fprintf (stream, " __SIZE_TYPE__ count;\n");
2480 fprintf (stream, " struct object *next;\n");
2481 fprintf (stream, "};\n");
2483 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2484 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2486 fprintf (stream, "static void reg_frame () {\n");
2487 fprintf (stream, "\tstatic struct object ob;\n");
2488 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2489 fprintf (stream, "\t}\n");
2491 fprintf (stream, "static void dereg_frame () {\n");
2492 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2493 fprintf (stream, "\t}\n");
2496 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2497 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2498 write_list (stream, "\t", constructors.first);
2500 fprintf (stream, "\treg_frame,\n");
2501 fprintf (stream, "\t0\n};\n\n");
2503 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2505 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2506 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2507 write_list (stream, "\t", destructors.first);
2509 fprintf (stream, "\tdereg_frame,\n");
2510 fprintf (stream, "\t0\n};\n\n");
2512 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2513 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2515 #endif /* ! LD_INIT_SWITCH */
2518 write_c_file (FILE *stream, const char *name)
2520 #ifndef LD_INIT_SWITCH
2522 write_c_file_glob (stream, name);
2525 write_c_file_stat (stream, name);
2528 #ifdef COLLECT_EXPORT_LIST
2530 write_aix_file (FILE *stream, struct id *list)
2532 for (; list; list = list->next)
2534 fputs (list->name, stream);
2535 putc ('\n', stream);
2540 #ifdef OBJECT_FORMAT_NONE
2542 /* Check to make sure the file is an LTO object file. */
2545 maybe_lto_object_file (const char *prog_name)
2548 unsigned char buf[4];
2551 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2552 static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2553 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2554 static unsigned char machomagic[4][4] = {
2555 { 0xcf, 0xfa, 0xed, 0xfe },
2556 { 0xce, 0xfa, 0xed, 0xfe },
2557 { 0xfe, 0xed, 0xfa, 0xcf },
2558 { 0xfe, 0xed, 0xfa, 0xce }
2561 f = fopen (prog_name, "rb");
2564 if (fread (buf, sizeof (buf), 1, f) != 1)
2568 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2569 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2570 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2572 for (i = 0; i < 4; i++)
2573 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2579 /* Generic version to scan the name list of the loaded program for
2580 the symbols g++ uses for static constructors and destructors. */
2583 scan_prog_file (const char *prog_name, scanpass which_pass,
2586 void (*int_handler) (int);
2588 void (*quit_handler) (int);
2590 char *real_nm_argv[4];
2591 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2593 struct pex_obj *pex;
2600 if (which_pass == PASS_SECOND)
2603 /* LTO objects must be in a known format. This check prevents
2604 us from accepting an archive containing LTO objects, which
2605 gcc cannnot currently handle. */
2606 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2609 /* If we do not have an `nm', complain. */
2610 if (nm_file_name == 0)
2611 fatal_error ("cannot find 'nm'");
2613 nm_argv[argc++] = nm_file_name;
2614 if (NM_FLAGS[0] != '\0')
2615 nm_argv[argc++] = NM_FLAGS;
2617 nm_argv[argc++] = prog_name;
2618 nm_argv[argc++] = (char *) 0;
2620 /* Trace if needed. */
2623 const char **p_argv;
2626 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2627 fprintf (stderr, " %s", str);
2629 fprintf (stderr, "\n");
2635 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2637 fatal_error ("pex_init failed: %m");
2639 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2646 fatal_error ("%s: %m", _(errmsg));
2649 fatal_error (errmsg);
2652 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2654 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2657 inf = pex_read_output (pex, 0);
2659 fatal_error ("can't open nm output: %m");
2663 if (which_pass == PASS_LTOINFO)
2664 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2666 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2669 /* Read each line of nm output. */
2670 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2676 fprintf (stderr, "\t%s\n", buf);
2678 if (which_pass == PASS_LTOINFO)
2683 /* Look for the LTO info marker symbol, and add filename to
2684 the LTO objects list if found. */
2685 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2686 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2687 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2688 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2690 add_lto_object (<o_objects, prog_name);
2692 /* We need to read all the input, so we can't just
2693 return here. But we can avoid useless work. */
2702 /* If it contains a constructor or destructor name, add the name
2703 to the appropriate list unless this is a kind of symbol we're
2704 not supposed to even consider. */
2706 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2707 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2714 /* Find the end of the symbol name.
2715 Do not include `|', because Encore nm can tack that on the end. */
2716 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2722 switch (is_ctor_dtor (name))
2725 if (! (filter & SCAN_CTOR))
2727 if (which_pass != PASS_LIB)
2728 add_to_list (&constructors, name);
2732 if (! (filter & SCAN_DTOR))
2734 if (which_pass != PASS_LIB)
2735 add_to_list (&destructors, name);
2739 if (! (filter & SCAN_INIT))
2741 if (which_pass != PASS_LIB)
2742 fatal_error ("init function found in object %s", prog_name);
2743 #ifndef LD_INIT_SWITCH
2744 add_to_list (&constructors, name);
2749 if (! (filter & SCAN_FINI))
2751 if (which_pass != PASS_LIB)
2752 fatal_error ("fini function found in object %s", prog_name);
2753 #ifndef LD_FINI_SWITCH
2754 add_to_list (&destructors, name);
2759 if (! (filter & SCAN_DWEH))
2761 if (which_pass != PASS_LIB)
2762 add_to_list (&frame_tables, name);
2765 default: /* not a constructor or destructor */
2771 fprintf (stderr, "\n");
2773 do_wait (nm_file_name, pex);
2775 signal (SIGINT, int_handler);
2777 signal (SIGQUIT, quit_handler);
2783 /* Use the List Dynamic Dependencies program to find shared libraries that
2784 the output file depends upon and their initialization/finalization
2785 routines, if any. */
2788 scan_libraries (const char *prog_name)
2790 static struct head libraries; /* list of shared libraries found */
2792 void (*int_handler) (int);
2794 void (*quit_handler) (int);
2796 char *real_ldd_argv[4];
2797 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2799 struct pex_obj *pex;
2805 /* If we do not have an `ldd', complain. */
2806 if (ldd_file_name == 0)
2808 error ("cannot find 'ldd'");
2812 ldd_argv[argc++] = ldd_file_name;
2813 ldd_argv[argc++] = prog_name;
2814 ldd_argv[argc++] = (char *) 0;
2816 /* Trace if needed. */
2819 const char **p_argv;
2822 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2823 fprintf (stderr, " %s", str);
2825 fprintf (stderr, "\n");
2831 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2833 fatal_error ("pex_init failed: %m");
2835 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2841 fatal_error ("%s: %m", _(errmsg));
2844 fatal_error (errmsg);
2847 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2849 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2852 inf = pex_read_output (pex, 0);
2854 fatal_error ("can't open ldd output: %m");
2857 notice ("\nldd output with constructors/destructors.\n");
2859 /* Read each line of ldd output. */
2860 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2863 char *name, *end, *p = buf;
2865 /* Extract names of libraries and add to list. */
2866 PARSE_LDD_OUTPUT (p);
2871 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2872 fatal_error ("dynamic dependency %s not found", buf);
2874 /* Find the end of the symbol name. */
2876 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2881 if (access (name, R_OK) == 0)
2882 add_to_list (&libraries, name);
2884 fatal_error ("unable to open dynamic dependency '%s'", buf);
2887 fprintf (stderr, "\t%s\n", buf);
2890 fprintf (stderr, "\n");
2892 do_wait (ldd_file_name, pex);
2894 signal (SIGINT, int_handler);
2896 signal (SIGQUIT, quit_handler);
2899 /* Now iterate through the library list adding their symbols to
2901 for (list = libraries.first; list; list = list->next)
2902 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2905 #endif /* LDD_SUFFIX */
2907 #endif /* OBJECT_FORMAT_NONE */
2911 * COFF specific stuff.
2914 #ifdef OBJECT_FORMAT_COFF
2916 #if defined (EXTENDED_COFF)
2918 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2919 # define GCC_SYMENT SYMR
2920 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2921 # define GCC_SYMINC(X) (1)
2922 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2923 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2927 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2928 # define GCC_SYMENT SYMENT
2929 # if defined (C_WEAKEXT)
2930 # define GCC_OK_SYMBOL(X) \
2931 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2932 ((X).n_scnum > N_UNDEF) && \
2934 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2935 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2936 # define GCC_UNDEF_SYMBOL(X) \
2937 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2938 ((X).n_scnum == N_UNDEF))
2940 # define GCC_OK_SYMBOL(X) \
2941 (((X).n_sclass == C_EXT) && \
2942 ((X).n_scnum > N_UNDEF) && \
2944 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2945 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2946 # define GCC_UNDEF_SYMBOL(X) \
2947 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2949 # define GCC_SYMINC(X) ((X).n_numaux+1)
2950 # define GCC_SYMZERO(X) 0
2952 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2953 #if TARGET_AIX_VERSION >= 51
2954 # define GCC_CHECK_HDR(X) \
2955 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2956 || (HEADER (X).f_magic == 0767 && aix64_flag))
2958 # define GCC_CHECK_HDR(X) \
2959 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2960 || (HEADER (X).f_magic == 0757 && aix64_flag))
2965 #ifdef COLLECT_EXPORT_LIST
2966 /* Array of standard AIX libraries which should not
2967 be scanned for ctors/dtors. */
2968 static const char *const aix_std_libs[] = {
2976 "/usr/lib/libc_r.a",
2977 "/usr/lib/libm_r.a",
2978 "/usr/lib/threads/libc.a",
2979 "/usr/ccs/lib/libc.a",
2980 "/usr/ccs/lib/libm.a",
2981 "/usr/ccs/lib/libc_r.a",
2982 "/usr/ccs/lib/libm_r.a",
2986 /* This function checks the filename and returns 1
2987 if this name matches the location of a standard AIX library. */
2988 static int ignore_library (const char *);
2990 ignore_library (const char *name)
2992 const char *const *p;
2995 if (target_system_root[0] != '\0')
2997 length = strlen (target_system_root);
2998 if (strncmp (name, target_system_root, length) != 0)
3002 for (p = &aix_std_libs[0]; *p != NULL; ++p)
3003 if (strcmp (name, *p) == 0)
3007 #endif /* COLLECT_EXPORT_LIST */
3009 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
3010 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
3013 /* COFF version to scan the name list of the loaded program for
3014 the symbols g++ uses for static constructors and destructors. */
3017 scan_prog_file (const char *prog_name, scanpass which_pass,
3020 LDFILE *ldptr = NULL;
3021 int sym_index, sym_count;
3024 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3027 #ifdef COLLECT_EXPORT_LIST
3028 /* We do not need scanning for some standard C libraries. */
3029 if (which_pass == PASS_FIRST && ignore_library (prog_name))
3032 /* On AIX we have a loop, because there is not much difference
3033 between an object and an archive. This trick allows us to
3034 eliminate scan_libraries() function. */
3038 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3039 non-const char * filename parameter, even though it will not
3040 modify that string. So we must cast away const-ness here,
3041 using CONST_CAST to prevent complaints from -Wcast-qual. */
3042 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3044 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3045 fatal_error ("%s: not a COFF file", prog_name);
3047 if (GCC_CHECK_HDR (ldptr))
3049 sym_count = GCC_SYMBOLS (ldptr);
3050 sym_index = GCC_SYMZERO (ldptr);
3052 #ifdef COLLECT_EXPORT_LIST
3053 /* Is current archive member a shared object? */
3054 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3057 while (sym_index < sym_count)
3061 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3063 sym_index += GCC_SYMINC (symbol);
3065 if (GCC_OK_SYMBOL (symbol))
3069 if ((name = ldgetname (ldptr, &symbol)) == NULL)
3070 continue; /* Should never happen. */
3072 #ifdef XCOFF_DEBUGGING_INFO
3073 /* All AIX function names have a duplicate entry
3074 beginning with a dot. */
3079 switch (is_ctor_dtor (name))
3082 if (! (filter & SCAN_CTOR))
3085 add_to_list (&constructors, name);
3086 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3087 if (which_pass == PASS_OBJ)
3088 add_to_list (&exports, name);
3093 if (! (filter & SCAN_DTOR))
3096 add_to_list (&destructors, name);
3097 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3098 if (which_pass == PASS_OBJ)
3099 add_to_list (&exports, name);
3103 #ifdef COLLECT_EXPORT_LIST
3105 if (! (filter & SCAN_INIT))
3107 #ifndef LD_INIT_SWITCH
3109 add_to_list (&constructors, name);
3114 if (! (filter & SCAN_FINI))
3116 #ifndef LD_INIT_SWITCH
3118 add_to_list (&destructors, name);
3124 if (! (filter & SCAN_DWEH))
3127 add_to_list (&frame_tables, name);
3128 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3129 if (which_pass == PASS_OBJ)
3130 add_to_list (&exports, name);
3134 default: /* not a constructor or destructor */
3135 #ifdef COLLECT_EXPORT_LIST
3136 /* Explicitly export all global symbols when
3137 building a shared object on AIX, but do not
3138 re-export symbols from another shared object
3139 and do not export symbols if the user
3140 provides an explicit export list. */
3141 if (shared_obj && !is_shared
3142 && which_pass == PASS_OBJ && !export_flag)
3143 add_to_list (&exports, name);
3149 #if !defined(EXTENDED_COFF)
3150 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3151 symbol.n_scnum, symbol.n_sclass,
3152 (symbol.n_type ? "0" : ""), symbol.n_type,
3156 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3157 symbol.iss, (long) symbol.value, symbol.index, name);
3162 #ifdef COLLECT_EXPORT_LIST
3165 /* If archive contains both 32-bit and 64-bit objects,
3166 we want to skip objects in other mode so mismatch normal. */
3168 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3169 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3175 fatal_error ("%s: cannot open as COFF file", prog_name);
3177 #ifdef COLLECT_EXPORT_LIST
3178 /* On AIX loop continues while there are more members in archive. */
3180 while (ldclose (ldptr) == FAILURE);
3182 /* Otherwise we simply close ldptr. */
3183 (void) ldclose(ldptr);
3186 #endif /* OBJECT_FORMAT_COFF */
3188 #ifdef COLLECT_EXPORT_LIST
3189 /* Given a library name without "lib" prefix, this function
3190 returns a full library name including a path. */
3192 resolve_lib_name (const char *name)
3196 /* Library extensions for AIX dynamic linking. */
3197 const char * const libexts[2] = {"a", "so"};
3199 for (i = 0; libpaths[i]; i++)
3200 if (libpaths[i]->max_len > l)
3201 l = libpaths[i]->max_len;
3203 lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3205 for (i = 0; libpaths[i]; i++)
3207 struct prefix_list *list = libpaths[i]->plist;
3208 for (; list; list = list->next)
3210 /* The following lines are needed because path_prefix list
3211 may contain directories both with trailing DIR_SEPARATOR and
3214 if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
3216 for (j = 0; j < 2; j++)
3218 sprintf (lib_buf, "%s%slib%s.%s",
3219 list->prefix, p, name,
3220 libexts[(j + aixrtl_flag) % 2]);
3221 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3222 if (file_exists (lib_buf))
3224 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3231 fprintf (stderr, "not found\n");
3233 fatal_error ("library lib%s not found", name);
3236 #endif /* COLLECT_EXPORT_LIST */
3238 #ifdef COLLECT_RUN_DSYMUTIL
3239 static int flag_dsym = false;
3240 static int flag_idsym = false;
3243 process_args (int *argcp, char **argv) {
3246 for (i=0; i<argc; ++i)
3248 if (strcmp (argv[i], "-dsym") == 0)
3251 /* Remove the flag, as we handle all processing for it. */
3254 argv[j] = argv[j+1];
3259 else if (strcmp (argv[i], "-idsym") == 0)
3262 /* Remove the flag, as we handle all processing for it. */
3265 argv[j] = argv[j+1];
3274 do_dsymutil (const char *output_file) {
3275 const char *dsymutil = DSYMUTIL + 1;
3276 struct pex_obj *pex;
3277 char **real_argv = XCNEWVEC (char *, 3);
3278 const char ** argv = CONST_CAST2 (const char **, char **,
3282 argv[1] = output_file;
3283 argv[2] = (char *) 0;
3285 pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3286 do_wait (dsymutil, pex);
3290 post_ld_pass (bool temp_file) {
3291 if (!(temp_file && flag_idsym) && !flag_dsym)
3294 do_dsymutil (output_file);
3298 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3299 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }