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, 2012
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 #ifdef COLLECT_EXPORT_LIST
328 static int is_in_list (const char *, struct id
*);
330 static void write_aix_file (FILE *, struct id
*);
331 static char *resolve_lib_name (const char *);
333 static char *extract_string (const char **);
334 static void post_ld_pass (bool);
335 static void process_args (int *argcp
, char **argv
);
337 /* Enumerations describing which pass this is for scanning the
341 PASS_FIRST
, /* without constructors */
342 PASS_OBJ
, /* individual objects */
343 PASS_LIB
, /* looking for shared libraries */
344 PASS_SECOND
, /* with constructors linked in */
345 PASS_LTOINFO
/* looking for objects with LTO info */
348 /* ... and which kinds of symbols are to be considered. */
350 enum scanfilter_masks
{
353 SCAN_CTOR
= 1 << SYM_CTOR
,
354 SCAN_DTOR
= 1 << SYM_DTOR
,
355 SCAN_INIT
= 1 << SYM_INIT
,
356 SCAN_FINI
= 1 << SYM_FINI
,
357 SCAN_DWEH
= 1 << SYM_DWEH
,
361 /* This type is used for parameters and variables which hold
362 combinations of the flags in enum scanfilter_masks. */
363 typedef int scanfilter
;
365 /* Scan the name list of the loaded program for the symbols g++ uses for
366 static constructors and destructors.
368 The SCANPASS argument tells which collect processing pass this is for and
369 the SCANFILTER argument tells which kinds of symbols to consider in this
370 pass. Symbols of a special kind not in the filter mask are considered as
373 The constructor table begins at __CTOR_LIST__ and contains a count of the
374 number of pointers (or -1 if the constructors are built in a separate
375 section by the linker), followed by the pointers to the constructor
376 functions, terminated with a null pointer. The destructor table has the
377 same format, and begins at __DTOR_LIST__. */
379 static void scan_prog_file (const char *, scanpass
, scanfilter
);
382 /* Delete tempfiles and exit function. */
385 collect_exit (int status
)
387 if (c_file
!= 0 && c_file
[0])
388 maybe_unlink (c_file
);
390 if (o_file
!= 0 && o_file
[0])
391 maybe_unlink (o_file
);
393 #ifdef COLLECT_EXPORT_LIST
394 if (export_file
!= 0 && export_file
[0])
395 maybe_unlink (export_file
);
399 maybe_unlink_list (lto_o_files
);
401 if (ldout
!= 0 && ldout
[0])
403 dump_file (ldout
, stdout
);
404 maybe_unlink (ldout
);
407 if (lderrout
!= 0 && lderrout
[0])
409 dump_file (lderrout
, stderr
);
410 maybe_unlink (lderrout
);
413 if (status
!= 0 && output_file
!= 0 && output_file
[0])
414 maybe_unlink (output_file
);
417 maybe_unlink (response_file
);
423 /* Notify user of a non-error. */
425 notice (const char *cmsgid
, ...)
429 va_start (ap
, cmsgid
);
430 vfprintf (stderr
, _(cmsgid
), ap
);
434 /* Notify user of a non-error, without translating the format string. */
436 notice_translated (const char *cmsgid
, ...)
440 va_start (ap
, cmsgid
);
441 vfprintf (stderr
, cmsgid
, ap
);
448 if (c_file
!= 0 && c_file
[0])
449 maybe_unlink (c_file
);
451 if (o_file
!= 0 && o_file
[0])
452 maybe_unlink (o_file
);
454 if (ldout
!= 0 && ldout
[0])
455 maybe_unlink (ldout
);
457 if (lderrout
!= 0 && lderrout
[0])
458 maybe_unlink (lderrout
);
460 #ifdef COLLECT_EXPORT_LIST
461 if (export_file
!= 0 && export_file
[0])
462 maybe_unlink (export_file
);
466 maybe_unlink_list (lto_o_files
);
469 maybe_unlink (response_file
);
471 signal (signo
, SIG_DFL
);
477 file_exists (const char *name
)
479 return access (name
, R_OK
) == 0;
482 /* Parse a reasonable subset of shell quoting syntax. */
485 extract_string (const char **pp
)
498 obstack_1grow (&temporary_obstack
, c
);
499 else if (! inside
&& c
== ' ')
501 else if (! inside
&& c
== '\\')
506 obstack_1grow (&temporary_obstack
, c
);
509 obstack_1grow (&temporary_obstack
, '\0');
511 return XOBFINISH (&temporary_obstack
, char *);
515 dump_file (const char *name
, FILE *to
)
517 FILE *stream
= fopen (name
, "r");
524 while (c
= getc (stream
),
525 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
526 obstack_1grow (&temporary_obstack
, c
);
527 if (obstack_object_size (&temporary_obstack
) > 0)
529 const char *word
, *p
;
531 obstack_1grow (&temporary_obstack
, '\0');
532 word
= XOBFINISH (&temporary_obstack
, const char *);
535 ++word
, putc ('.', to
);
537 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
538 p
+= strlen (USER_LABEL_PREFIX
);
540 #ifdef HAVE_LD_DEMANGLE
546 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
554 diff
= strlen (word
) - strlen (result
);
555 while (diff
> 0 && c
== ' ')
556 --diff
, putc (' ', to
);
557 if (diff
< 0 && c
== ' ')
559 while (diff
< 0 && c
== ' ')
560 ++diff
, c
= getc (stream
);
563 /* Make sure we output at least one space, or
564 the demangled symbol name will run into
565 whatever text follows. */
576 obstack_free (&temporary_obstack
, temporary_firstobj
);
585 /* Return the kind of symbol denoted by name S. */
588 is_ctor_dtor (const char *s
)
590 struct names
{ const char *const name
; const int len
; symkind ret
;
591 const int two_underscores
; };
593 const struct names
*p
;
595 const char *orig_s
= s
;
597 static const struct names special
[] = {
598 #ifndef NO_DOLLAR_IN_LABEL
599 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
600 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
602 #ifndef NO_DOT_IN_LABEL
603 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
604 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
605 #endif /* NO_DOT_IN_LABEL */
606 #endif /* NO_DOLLAR_IN_LABEL */
607 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
608 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
609 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
610 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
611 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
612 { NULL
, 0, SYM_REGULAR
, 0 }
615 while ((ch
= *s
) == '_')
621 for (p
= &special
[0]; p
->len
> 0; p
++)
624 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
625 && strncmp(s
, p
->name
, p
->len
) == 0)
633 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
634 and one from the PATH variable. */
636 static struct path_prefix cpath
, path
;
638 #ifdef CROSS_DIRECTORY_STRUCTURE
639 /* This is the name of the target machine. We use it to form the name
640 of the files to execute. */
642 static const char *const target_machine
= TARGET_MACHINE
;
645 /* Search for NAME using prefix list PPREFIX. We only look for executable
648 Return 0 if not found, otherwise return its name, allocated with malloc. */
651 find_a_file (struct path_prefix
*pprefix
, const char *name
)
654 struct prefix_list
*pl
;
655 int len
= pprefix
->max_len
+ strlen (name
) + 1;
658 fprintf (stderr
, "Looking for '%s'\n", name
);
660 #ifdef HOST_EXECUTABLE_SUFFIX
661 len
+= strlen (HOST_EXECUTABLE_SUFFIX
);
664 temp
= XNEWVEC (char, len
);
666 /* Determine the filename to execute (special case for absolute paths). */
668 if (IS_ABSOLUTE_PATH (name
))
670 if (access (name
, X_OK
) == 0)
675 fprintf (stderr
, " - found: absolute path\n");
680 #ifdef HOST_EXECUTABLE_SUFFIX
681 /* Some systems have a suffix for executable files.
682 So try appending that. */
684 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
686 if (access (temp
, X_OK
) == 0)
691 fprintf (stderr
, " - failed to locate using absolute path\n");
694 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
698 strcpy (temp
, pl
->prefix
);
701 if (stat (temp
, &st
) >= 0
702 && ! S_ISDIR (st
.st_mode
)
703 && access (temp
, X_OK
) == 0)
706 #ifdef HOST_EXECUTABLE_SUFFIX
707 /* Some systems have a suffix for executable files.
708 So try appending that. */
709 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
711 if (stat (temp
, &st
) >= 0
712 && ! S_ISDIR (st
.st_mode
)
713 && access (temp
, X_OK
) == 0)
718 if (debug
&& pprefix
->plist
== NULL
)
719 fprintf (stderr
, " - failed: no entries in prefix list\n");
725 /* Add an entry for PREFIX to prefix list PPREFIX. */
728 add_prefix (struct path_prefix
*pprefix
, const char *prefix
)
730 struct prefix_list
*pl
, **prev
;
735 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
740 prev
= &pprefix
->plist
;
742 /* Keep track of the longest prefix. */
744 len
= strlen (prefix
);
745 if (len
> pprefix
->max_len
)
746 pprefix
->max_len
= len
;
748 pl
= XNEW (struct prefix_list
);
749 pl
->prefix
= xstrdup (prefix
);
754 pl
->next
= (struct prefix_list
*) 0;
758 /* Take the value of the environment variable ENV, break it into a path, and
759 add of the entries to PPREFIX. */
762 prefix_from_env (const char *env
, struct path_prefix
*pprefix
)
768 prefix_from_string (p
, pprefix
);
772 prefix_from_string (const char *p
, struct path_prefix
*pprefix
)
774 const char *startp
, *endp
;
775 char *nstore
= XNEWVEC (char, strlen (p
) + 3);
778 fprintf (stderr
, "Convert string '%s' into prefixes, separator = '%c'\n", p
, PATH_SEPARATOR
);
783 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
785 strncpy (nstore
, startp
, endp
-startp
);
788 strcpy (nstore
, "./");
790 else if (! IS_DIR_SEPARATOR (endp
[-1]))
792 nstore
[endp
-startp
] = DIR_SEPARATOR
;
793 nstore
[endp
-startp
+1] = 0;
796 nstore
[endp
-startp
] = 0;
799 fprintf (stderr
, " - add prefix: %s\n", nstore
);
801 add_prefix (pprefix
, nstore
);
804 endp
= startp
= endp
+ 1;
812 #ifdef OBJECT_FORMAT_NONE
814 /* Add an entry for the object file NAME to object file list LIST.
815 New entries are added at the end of the list. The original pointer
816 value of NAME is preserved, i.e., no string copy is performed. */
819 add_lto_object (struct lto_object_list
*list
, const char *name
)
821 struct lto_object
*n
= XNEW (struct lto_object
);
826 list
->last
->next
= n
;
832 #endif /* OBJECT_FORMAT_NONE */
835 /* Perform a link-time recompilation and relink if any of the object
836 files contain LTO info. The linker command line LTO_LD_ARGV
837 represents the linker command that would produce a final executable
838 without the use of LTO. OBJECT_LST is a vector of object file names
839 appearing in LTO_LD_ARGV that are to be considerd for link-time
840 recompilation, where OBJECT is a pointer to the last valid element.
841 (This awkward convention avoids an impedance mismatch with the
842 usage of similarly-named variables in main().) The elements of
843 OBJECT_LST must be identical, i.e., pointer equal, to the
844 corresponding arguments in LTO_LD_ARGV.
846 Upon entry, at least one linker run has been performed without the
847 use of any LTO info that might be present. Any recompilations
848 necessary for template instantiations have been performed, and
849 initializer/finalizer tables have been created if needed and
850 included in the linker command line LTO_LD_ARGV. If any of the
851 object files contain LTO info, we run the LTO back end on all such
852 files, and perform the final link with the LTO back end output
853 substituted for the LTO-optimized files. In some cases, a final
854 link with all link-time generated code has already been performed,
855 so there is no need to relink if no LTO info is found. In other
856 cases, our caller has not produced the final executable, and is
857 relying on us to perform the required link whether LTO info is
858 present or not. In that case, the FORCE argument should be true.
859 Note that the linker command line argument LTO_LD_ARGV passed into
860 this function may be modified in place. */
863 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
864 const char **object
, bool force
)
866 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
868 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
870 while (object_file
< object
)
872 /* If file contains LTO info, add it to the list of LTO objects. */
873 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
875 /* Increment the argument count by the number of object file arguments
876 we will add. An upper bound suffices, so just count all of the
877 object files regardless of whether they contain LTO info. */
881 if (lto_objects
.first
)
884 const char **lto_c_ptr
;
887 struct lto_object
*list
;
888 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
890 const char *prog
= "lto-wrapper";
891 int lto_ld_argv_size
= 0;
892 char **out_lto_ld_argv
;
893 int out_lto_ld_argv_size
;
897 fatal_error ("COLLECT_LTO_WRAPPER must be set");
901 /* There is at least one object file containing LTO info,
902 so we need to run the LTO back end and relink.
904 To do so we build updated ld arguments with first
905 LTO object replaced by all partitions and other LTO
908 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
909 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
911 *lto_c_ptr
++ = lto_wrapper
;
913 /* Add LTO objects to the wrapper command line. */
914 for (list
= lto_objects
.first
; list
; list
= list
->next
)
915 *lto_c_ptr
++ = list
->name
;
919 /* Run the LTO back end. */
920 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
927 stream
= pex_read_output (pex
, 0);
931 while ((c
= getc (stream
)) != EOF
)
933 obstack_1grow (&temporary_obstack
, c
);
938 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
939 lto_o_files
[num_files
] = NULL
;
940 start
= XOBFINISH (&temporary_obstack
, char *);
941 for (i
= 0; i
< num_files
; ++i
)
948 lto_o_files
[i
] = xstrdup (start
);
953 obstack_free (&temporary_obstack
, temporary_firstobj
);
958 /* Compute memory needed for new LD arguments. At most number of original arguemtns
959 plus number of partitions. */
960 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
962 out_lto_ld_argv
= XCNEWVEC(char *, num_files
+ lto_ld_argv_size
+ 1);
963 out_lto_ld_argv_size
= 0;
965 /* After running the LTO back end, we will relink, substituting
966 the LTO output for the object files that we submitted to the
967 LTO. Here, we modify the linker command line for the relink. */
969 /* Copy all arguments until we find first LTO file. */
973 for (list
= lto_objects
.first
; list
; list
= list
->next
)
974 if (*p
== list
->name
) /* Note test for pointer equality! */
978 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
981 /* Now insert all LTO partitions. */
982 lto_o_ptr
= lto_o_files
;
984 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
986 /* ... and copy the rest. */
989 for (list
= lto_objects
.first
; list
; list
= list
->next
)
990 if (*p
== list
->name
) /* Note test for pointer equality! */
993 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
996 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
998 /* Run the linker again, this time replacing the object files
999 optimized by the LTO with the temporary file generated by the LTO. */
1000 fork_execute ("ld", out_lto_ld_argv
);
1001 post_ld_pass (true);
1004 maybe_unlink_list (lto_o_files
);
1008 /* Our caller is relying on us to do the link
1009 even though there is no LTO back end work to be done. */
1010 fork_execute ("ld", lto_ld_argv
);
1011 post_ld_pass (false);
1018 main (int argc
, char **argv
)
1020 static const char *const ld_suffix
= "ld";
1021 static const char *const plugin_ld_suffix
= PLUGIN_LD
;
1022 static const char *const real_ld_suffix
= "real-ld";
1023 static const char *const collect_ld_suffix
= "collect-ld";
1024 static const char *const nm_suffix
= "nm";
1025 static const char *const gnm_suffix
= "gnm";
1027 static const char *const ldd_suffix
= LDD_SUFFIX
;
1029 static const char *const strip_suffix
= "strip";
1030 static const char *const gstrip_suffix
= "gstrip";
1032 #ifdef CROSS_DIRECTORY_STRUCTURE
1033 /* If we look for a program in the compiler directories, we just use
1034 the short name, since these directories are already system-specific.
1035 But it we look for a program in the system directories, we need to
1036 qualify the program name with the target machine. */
1038 const char *const full_ld_suffix
=
1039 concat(target_machine
, "-", ld_suffix
, NULL
);
1040 const char *const full_plugin_ld_suffix
=
1041 concat(target_machine
, "-", plugin_ld_suffix
, NULL
);
1042 const char *const full_nm_suffix
=
1043 concat (target_machine
, "-", nm_suffix
, NULL
);
1044 const char *const full_gnm_suffix
=
1045 concat (target_machine
, "-", gnm_suffix
, NULL
);
1047 const char *const full_ldd_suffix
=
1048 concat (target_machine
, "-", ldd_suffix
, NULL
);
1050 const char *const full_strip_suffix
=
1051 concat (target_machine
, "-", strip_suffix
, NULL
);
1052 const char *const full_gstrip_suffix
=
1053 concat (target_machine
, "-", gstrip_suffix
, NULL
);
1055 const char *const full_ld_suffix
= ld_suffix
;
1056 const char *const full_plugin_ld_suffix
= plugin_ld_suffix
;
1057 const char *const full_nm_suffix
= nm_suffix
;
1058 const char *const full_gnm_suffix
= gnm_suffix
;
1060 const char *const full_ldd_suffix
= ldd_suffix
;
1062 const char *const full_strip_suffix
= strip_suffix
;
1063 const char *const full_gstrip_suffix
= gstrip_suffix
;
1064 #endif /* CROSS_DIRECTORY_STRUCTURE */
1068 #ifdef COLLECT_EXPORT_LIST
1071 const char *ld_file_name
;
1077 bool use_plugin
= false;
1079 /* The kinds of symbols we will have to consider when scanning the
1080 outcome of a first pass link. This is ALL to start with, then might
1081 be adjusted before getting to the first pass link per se, typically on
1082 AIX where we perform an early scan of objects and libraries to fetch
1083 the list of global ctors/dtors and make sure they are not garbage
1085 scanfilter ld1_filter
= SCAN_ALL
;
1090 const char **object
;
1091 #ifdef TARGET_AIX_VERSION
1092 int object_nbr
= argc
;
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 "
1443 #ifdef TARGET_AIX_VERSION
1446 /* File containing a list of input files to process. */
1449 char buf
[MAXPATHLEN
+ 2];
1450 /* Number of additionnal object files. */
1452 /* Maximum of additionnal object files before vector
1455 const char *list_filename
= arg
+ 2;
1457 /* Accept -fFILENAME and -f FILENAME. */
1458 if (*list_filename
== '\0' && argv
[1])
1461 list_filename
= *argv
;
1462 *ld1
++ = *ld2
++ = *argv
;
1465 stream
= fopen (list_filename
, "r");
1467 fatal_error ("can't open %s: %m", list_filename
);
1469 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1471 /* Remove end of line. */
1472 int len
= strlen (buf
);
1473 if (len
>= 1 && buf
[len
- 1] =='\n')
1474 buf
[len
- 1] = '\0';
1476 /* Put on object vector.
1477 Note: we only expanse vector here, so we must keep
1478 extra space for remaining arguments. */
1479 if (add_nbr
>= add_max
)
1482 object
- CONST_CAST2 (const char **, char **,
1484 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1485 object_lst
= XRESIZEVEC (char *, object_lst
,
1486 object_nbr
+ add_max
);
1487 object
= CONST_CAST2 (const char **, char **,
1489 object_nbr
+= add_max
;
1491 *object
++ = xstrdup (buf
);
1502 /* place o_file BEFORE this argument! */
1508 #ifdef COLLECT_EXPORT_LIST
1510 /* Resolving full library name. */
1511 const char *s
= resolve_lib_name (arg
+2);
1513 /* Saving a full library name. */
1514 add_to_list (&libs
, s
);
1519 #ifdef COLLECT_EXPORT_LIST
1520 /* Saving directories where to search for libraries. */
1522 add_prefix (&cmdline_lib_dirs
, arg
+2);
1528 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1530 output_file
= &arg
[2];
1539 if (arg
[2] == '\0' && do_collecting
)
1541 /* We must strip after the nm run, otherwise C++ linking
1542 will not work. Thus we strip in the second ld run, or
1543 else with strip if there is no second ld run. */
1555 if (strcmp (arg
, "--no-demangle") == 0)
1557 #ifndef HAVE_LD_DEMANGLE
1563 else if (strncmp (arg
, "--demangle", 10) == 0)
1565 #ifndef HAVE_LD_DEMANGLE
1569 enum demangling_styles style
1570 = cplus_demangle_name_to_style (arg
+11);
1571 if (style
== unknown_demangling
)
1572 error ("unknown demangling style '%s'", arg
+11);
1574 current_demangling_style
= style
;
1580 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1581 target_system_root
= arg
+ 10;
1582 else if (strcmp (arg
, "--version") == 0)
1584 else if (strcmp (arg
, "--help") == 0)
1589 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1590 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1591 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1592 || strcmp (p
, ".obj") == 0))
1601 /* place o_file BEFORE this argument! */
1607 if (p
[1] == 'o' || p
[1] == 'l')
1609 #ifdef COLLECT_EXPORT_LIST
1610 /* libraries can be specified directly, i.e. without -l flag. */
1613 /* Saving a full library name. */
1614 add_to_list (&libs
, arg
);
1620 #ifdef COLLECT_EXPORT_LIST
1621 /* This is added only for debugging purposes. */
1624 fprintf (stderr
, "List of libraries:\n");
1625 dump_list (stderr
, "\t", libs
.first
);
1628 /* The AIX linker will discard static constructors in object files if
1629 nothing else in the file is referenced, so look at them first. Unless
1630 we are building a shared object, ignore the eh frame tables, as we
1631 would otherwise reference them all, hence drag all the corresponding
1632 objects even if nothing else is referenced. */
1634 const char **export_object_lst
1635 = CONST_CAST2 (const char **, char **, object_lst
);
1637 struct id
*list
= libs
.first
;
1639 /* Compute the filter to use from the current one, do scan, then adjust
1640 the "current" filter to remove what we just included here. This will
1641 control whether we need a first pass link later on or not, and what
1642 will remain to be scanned there. */
1644 scanfilter this_filter
= ld1_filter
;
1647 this_filter
&= ~SCAN_DWEH
;
1650 while (export_object_lst
< object
)
1651 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1653 for (; list
; list
= list
->next
)
1654 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1656 ld1_filter
= ld1_filter
& ~this_filter
;
1661 char *buf
= concat ("-bE:", export_file
, NULL
);
1666 exportf
= fopen (export_file
, "w");
1667 if (exportf
== (FILE *) 0)
1668 fatal_error ("fopen %s: %m", export_file
);
1669 write_aix_file (exportf
, exports
.first
);
1670 if (fclose (exportf
))
1671 fatal_error ("fclose %s: %m", export_file
);
1676 *c_ptr
= *ld1
= *object
= (char *) 0;
1679 notice ("collect2 version %s\n", version_string
);
1683 printf ("Usage: collect2 [options]\n");
1684 printf (" Wrap linker and generate constructor code if needed.\n");
1685 printf (" Options:\n");
1686 printf (" -debug Enable debug output\n");
1687 printf (" --help Display this information\n");
1688 printf (" -v, --version Display this program's version number\n");
1690 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1691 printf ("Report bugs: %s\n", bug_report_url
);
1698 fprintf (stderr
, "ld_file_name = %s\n",
1699 (ld_file_name
? ld_file_name
: "not found"));
1700 fprintf (stderr
, "c_file_name = %s\n",
1701 (c_file_name
? c_file_name
: "not found"));
1702 fprintf (stderr
, "nm_file_name = %s\n",
1703 (nm_file_name
? nm_file_name
: "not found"));
1705 fprintf (stderr
, "ldd_file_name = %s\n",
1706 (ldd_file_name
? ldd_file_name
: "not found"));
1708 fprintf (stderr
, "strip_file_name = %s\n",
1709 (strip_file_name
? strip_file_name
: "not found"));
1710 fprintf (stderr
, "c_file = %s\n",
1711 (c_file
? c_file
: "not found"));
1712 fprintf (stderr
, "o_file = %s\n",
1713 (o_file
? o_file
: "not found"));
1715 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1717 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1719 ptr
= getenv ("COLLECT_GCC");
1721 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1723 ptr
= getenv ("COMPILER_PATH");
1725 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1727 ptr
= getenv (LIBRARY_PATH_ENV
);
1729 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1731 fprintf (stderr
, "\n");
1734 /* Load the program, searching all libraries and attempting to provide
1735 undefined symbols from repository information.
1737 If -r or they will be run via some other method, do not build the
1738 constructor or destructor list, just return now. */
1741 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1743 /* Perform the first pass link now, if we're about to exit or if we need
1744 to scan for things we haven't collected yet before pursuing further.
1746 On AIX, the latter typically includes nothing for shared objects or
1747 frame tables for an executable, out of what the required early scan on
1748 objects and libraries has performed above. In the !shared_obj case, we
1749 expect the relevant tables to be dragged together with their associated
1750 functions from precise cross reference insertions by the compiler. */
1752 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1753 do_tlink (ld1_argv
, object_lst
);
1757 #ifdef COLLECT_EXPORT_LIST
1758 /* Make sure we delete the export file we may have created. */
1759 if (export_file
!= 0 && export_file
[0])
1760 maybe_unlink (export_file
);
1762 if (lto_mode
!= LTO_MODE_NONE
)
1763 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1765 post_ld_pass (false);
1767 maybe_unlink (c_file
);
1768 maybe_unlink (o_file
);
1773 /* Unless we have done it all already, examine the namelist and search for
1774 static constructors and destructors to call. Write the constructor and
1775 destructor tables to a .s file and reload. */
1777 if (ld1_filter
!= SCAN_NOTHING
)
1778 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1780 #ifdef SCAN_LIBRARIES
1781 scan_libraries (output_file
);
1786 notice_translated (ngettext ("%d constructor found\n",
1787 "%d constructors found\n",
1788 constructors
.number
),
1789 constructors
.number
);
1790 notice_translated (ngettext ("%d destructor found\n",
1791 "%d destructors found\n",
1792 destructors
.number
),
1793 destructors
.number
);
1794 notice_translated (ngettext("%d frame table found\n",
1795 "%d frame tables found\n",
1796 frame_tables
.number
),
1797 frame_tables
.number
);
1800 /* If the scan exposed nothing of special interest, there's no need to
1801 generate the glue code and relink so return now. */
1803 if (constructors
.number
== 0 && destructors
.number
== 0
1804 && frame_tables
.number
== 0
1805 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1806 /* If we will be running these functions ourselves, we want to emit
1807 stubs into the shared library so that we do not have to relink
1808 dependent programs when we add static objects. */
1813 /* Do tlink without additional code generation now if we didn't
1814 do it earlier for scanning purposes. */
1815 if (ld1_filter
== SCAN_NOTHING
)
1816 do_tlink (ld1_argv
, object_lst
);
1819 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1821 /* Strip now if it was requested on the command line. */
1824 char **real_strip_argv
= XCNEWVEC (char *, 3);
1825 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1828 strip_argv
[0] = strip_file_name
;
1829 strip_argv
[1] = output_file
;
1830 strip_argv
[2] = (char *) 0;
1831 fork_execute ("strip", real_strip_argv
);
1834 #ifdef COLLECT_EXPORT_LIST
1835 maybe_unlink (export_file
);
1837 post_ld_pass (false);
1839 maybe_unlink (c_file
);
1840 maybe_unlink (o_file
);
1844 /* Sort ctor and dtor lists by priority. */
1845 sort_ids (&constructors
);
1846 sort_ids (&destructors
);
1848 maybe_unlink(output_file
);
1849 outf
= fopen (c_file
, "w");
1850 if (outf
== (FILE *) 0)
1851 fatal_error ("fopen %s: %m", c_file
);
1853 write_c_file (outf
, c_file
);
1856 fatal_error ("fclose %s: %m", c_file
);
1858 /* Tell the linker that we have initializer and finalizer functions. */
1859 #ifdef LD_INIT_SWITCH
1860 #ifdef COLLECT_EXPORT_LIST
1861 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1863 *ld2
++ = LD_INIT_SWITCH
;
1865 *ld2
++ = LD_FINI_SWITCH
;
1870 #ifdef COLLECT_EXPORT_LIST
1873 /* If we did not add export flag to link arguments before, add it to
1874 second link phase now. No new exports should have been added. */
1875 if (! exports
.first
)
1876 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1878 #ifndef LD_INIT_SWITCH
1879 add_to_list (&exports
, initname
);
1880 add_to_list (&exports
, fininame
);
1881 add_to_list (&exports
, "_GLOBAL__DI");
1882 add_to_list (&exports
, "_GLOBAL__DD");
1884 exportf
= fopen (export_file
, "w");
1885 if (exportf
== (FILE *) 0)
1886 fatal_error ("fopen %s: %m", export_file
);
1887 write_aix_file (exportf
, exports
.first
);
1888 if (fclose (exportf
))
1889 fatal_error ("fclose %s: %m", export_file
);
1893 /* End of arguments to second link phase. */
1898 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1899 output_file
, c_file
);
1900 write_c_file (stderr
, "stderr");
1901 fprintf (stderr
, "========== end of c_file\n\n");
1902 #ifdef COLLECT_EXPORT_LIST
1903 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1904 write_aix_file (stderr
, exports
.first
);
1905 fprintf (stderr
, "========== end of export_file\n\n");
1909 /* Assemble the constructor and destructor tables.
1910 Link the tables in with the rest of the program. */
1912 fork_execute ("gcc", c_argv
);
1913 #ifdef COLLECT_EXPORT_LIST
1914 /* On AIX we must call tlink because of possible templates resolution. */
1915 do_tlink (ld2_argv
, object_lst
);
1918 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1920 /* Otherwise, simply call ld because tlink is already done. */
1922 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1925 fork_execute ("ld", ld2_argv
);
1926 post_ld_pass (false);
1929 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1930 constructors/destructors in shared libraries. */
1931 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1934 maybe_unlink (c_file
);
1935 maybe_unlink (o_file
);
1937 #ifdef COLLECT_EXPORT_LIST
1938 maybe_unlink (export_file
);
1945 /* Wait for a process to finish, and exit if a nonzero status is found. */
1948 collect_wait (const char *prog
, struct pex_obj
*pex
)
1952 if (!pex_get_status (pex
, 1, &status
))
1953 fatal_error ("can't get program status: %m");
1958 if (WIFSIGNALED (status
))
1960 int sig
= WTERMSIG (status
);
1961 error ("%s terminated with signal %d [%s]%s",
1962 prog
, sig
, strsignal(sig
),
1963 WCOREDUMP(status
) ? ", core dumped" : "");
1964 collect_exit (FATAL_EXIT_CODE
);
1967 if (WIFEXITED (status
))
1968 return WEXITSTATUS (status
);
1974 do_wait (const char *prog
, struct pex_obj
*pex
)
1976 int ret
= collect_wait (prog
, pex
);
1979 error ("%s returned %d exit status", prog
, ret
);
1985 unlink (response_file
);
1986 response_file
= NULL
;
1991 /* Execute a program, and wait for the reply. */
1994 collect_execute (const char *prog
, char **argv
, const char *outname
,
1995 const char *errname
, int flags
)
1997 struct pex_obj
*pex
;
2000 char *response_arg
= NULL
;
2001 char *response_argv
[3] ATTRIBUTE_UNUSED
;
2003 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
2005 /* If using @file arguments, create a temporary file and put the
2006 contents of argv into it. Then change argv to an array corresponding
2007 to a single argument @FILE, where FILE is the temporary filename. */
2009 char **current_argv
= argv
+ 1;
2010 char *argv0
= argv
[0];
2014 /* Note: we assume argv contains at least one element; this is
2017 response_file
= make_temp_file ("");
2019 f
= fopen (response_file
, "w");
2022 fatal_error ("could not open response file %s", response_file
);
2024 status
= writeargv (current_argv
, f
);
2027 fatal_error ("could not write to response file %s", response_file
);
2029 status
= fclose (f
);
2032 fatal_error ("could not close response file %s", response_file
);
2034 response_arg
= concat ("@", response_file
, NULL
);
2035 response_argv
[0] = argv0
;
2036 response_argv
[1] = response_arg
;
2037 response_argv
[2] = NULL
;
2039 argv
= response_argv
;
2048 fprintf (stderr
, "%s", argv
[0]);
2050 notice ("[cannot find %s]", prog
);
2052 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2053 fprintf (stderr
, " %s", str
);
2055 fprintf (stderr
, "\n");
2061 /* If we cannot find a program we need, complain error. Do this here
2062 since we might not end up needing something that we could not find. */
2065 fatal_error ("cannot find '%s'", prog
);
2067 pex
= pex_init (0, "collect2", NULL
);
2069 fatal_error ("pex_init failed: %m");
2071 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
2078 fatal_error ("%s: %m", _(errmsg
));
2081 fatal_error (errmsg
);
2084 free (response_arg
);
2090 fork_execute (const char *prog
, char **argv
)
2092 struct pex_obj
*pex
;
2094 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
2095 do_wait (prog
, pex
);
2098 /* Unlink a file unless we are debugging. */
2101 maybe_unlink (const char *file
)
2104 unlink_if_ordinary (file
);
2106 notice ("[Leaving %s]\n", file
);
2109 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2112 maybe_unlink_list (char **file_list
)
2114 char **tmp
= file_list
;
2117 maybe_unlink (*(tmp
++));
2121 static long sequence_number
= 0;
2123 /* Add a name to a linked list. */
2126 add_to_list (struct head
*head_ptr
, const char *name
)
2129 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2131 strcpy (newid
->name
, name
);
2133 if (head_ptr
->first
)
2134 head_ptr
->last
->next
= newid
;
2136 head_ptr
->first
= newid
;
2138 /* Check for duplicate symbols. */
2139 for (p
= head_ptr
->first
;
2140 strcmp (name
, p
->name
) != 0;
2145 head_ptr
->last
->next
= 0;
2150 newid
->sequence
= ++sequence_number
;
2151 head_ptr
->last
= newid
;
2155 /* Grab the init priority number from an init function name that
2156 looks like "_GLOBAL_.I.12345.foo". */
2159 extract_init_priority (const char *name
)
2163 while (name
[pos
] == '_')
2165 pos
+= 10; /* strlen ("GLOBAL__X_") */
2167 /* Extract init_p number from ctor/dtor name. */
2168 pri
= atoi (name
+ pos
);
2169 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2172 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2173 ctors will be run from right to left, dtors from left to right. */
2176 sort_ids (struct head
*head_ptr
)
2178 /* id holds the current element to insert. id_next holds the next
2179 element to insert. id_ptr iterates through the already sorted elements
2180 looking for the place to insert id. */
2181 struct id
*id
, *id_next
, **id_ptr
;
2183 id
= head_ptr
->first
;
2185 /* We don't have any sorted elements yet. */
2186 head_ptr
->first
= NULL
;
2188 for (; id
; id
= id_next
)
2191 id
->sequence
= extract_init_priority (id
->name
);
2193 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2195 /* If the sequence numbers are the same, we put the id from the
2196 file later on the command line later in the list. */
2197 || id
->sequence
> (*id_ptr
)->sequence
2198 /* Hack: do lexical compare, too.
2199 || (id->sequence == (*id_ptr)->sequence
2200 && strcmp (id->name, (*id_ptr)->name) > 0) */
2209 /* Now set the sequence numbers properly so write_c_file works. */
2210 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2211 id
->sequence
= ++sequence_number
;
2214 /* Write: `prefix', the names on list LIST, `suffix'. */
2217 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2221 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2226 #ifdef COLLECT_EXPORT_LIST
2227 /* This function is really used only on AIX, but may be useful. */
2230 is_in_list (const char *prefix
, struct id
*list
)
2234 if (!strcmp (prefix
, list
->name
)) return 1;
2240 #endif /* COLLECT_EXPORT_LIST */
2242 /* Added for debugging purpose. */
2243 #ifdef COLLECT_EXPORT_LIST
2245 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2249 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2257 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2261 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2268 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2272 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2273 prefix
, list
->sequence
, list
->name
);
2278 /* Write out the constructor and destructor tables statically (for a shared
2279 object), along with the functions to execute them. */
2282 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2286 int frames
= (frame_tables
.number
> 0);
2288 /* Figure out name of output_file, stripping off .so version. */
2289 q
= p
= lbasename (output_file
);
2301 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2303 q
+= strlen (SHLIB_SUFFIX
);
2310 /* q points to null at end of the string (or . of the .so version) */
2311 prefix
= XNEWVEC (char, q
- p
+ 1);
2312 strncpy (prefix
, p
, q
- p
);
2314 for (r
= prefix
; *r
; r
++)
2315 if (!ISALNUM ((unsigned char)*r
))
2318 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2319 output_file
, prefix
);
2321 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2322 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2326 /* Write the tables as C code. */
2328 fprintf (stream
, "static int count;\n");
2329 fprintf (stream
, "typedef void entry_pt();\n");
2330 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2334 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2336 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2337 write_list (stream
, "\t\t&", frame_tables
.first
);
2338 fprintf (stream
, "\t0\n};\n");
2340 /* This must match what's in frame.h. */
2341 fprintf (stream
, "struct object {\n");
2342 fprintf (stream
, " void *pc_begin;\n");
2343 fprintf (stream
, " void *pc_end;\n");
2344 fprintf (stream
, " void *fde_begin;\n");
2345 fprintf (stream
, " void *fde_array;\n");
2346 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2347 fprintf (stream
, " struct object *next;\n");
2348 fprintf (stream
, "};\n");
2350 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2351 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2353 fprintf (stream
, "static void reg_frame () {\n");
2354 fprintf (stream
, "\tstatic struct object ob;\n");
2355 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2356 fprintf (stream
, "\t}\n");
2358 fprintf (stream
, "static void dereg_frame () {\n");
2359 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2360 fprintf (stream
, "\t}\n");
2363 fprintf (stream
, "void %s() {\n", initname
);
2364 if (constructors
.number
> 0 || frames
)
2366 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2367 write_list (stream
, "\t\t", constructors
.first
);
2369 fprintf (stream
, "\treg_frame,\n");
2370 fprintf (stream
, "\t};\n");
2371 fprintf (stream
, "\tentry_pt **p;\n");
2372 fprintf (stream
, "\tif (count++ != 0) return;\n");
2373 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2374 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2377 fprintf (stream
, "\t++count;\n");
2378 fprintf (stream
, "}\n");
2379 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2380 fprintf (stream
, "void %s() {\n", fininame
);
2381 if (destructors
.number
> 0 || frames
)
2383 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2384 write_list (stream
, "\t\t", destructors
.first
);
2386 fprintf (stream
, "\tdereg_frame,\n");
2387 fprintf (stream
, "\t};\n");
2388 fprintf (stream
, "\tentry_pt **p;\n");
2389 fprintf (stream
, "\tif (--count != 0) return;\n");
2390 fprintf (stream
, "\tp = dtors;\n");
2391 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2392 destructors
.number
+ frames
);
2394 fprintf (stream
, "}\n");
2398 COLLECT_SHARED_INIT_FUNC(stream
, initname
);
2399 COLLECT_SHARED_FINI_FUNC(stream
, fininame
);
2403 /* Write the constructor/destructor tables. */
2405 #ifndef LD_INIT_SWITCH
2407 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2409 /* Write the tables as C code. */
2411 int frames
= (frame_tables
.number
> 0);
2413 fprintf (stream
, "typedef void entry_pt();\n\n");
2415 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2419 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2421 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2422 write_list (stream
, "\t\t&", frame_tables
.first
);
2423 fprintf (stream
, "\t0\n};\n");
2425 /* This must match what's in frame.h. */
2426 fprintf (stream
, "struct object {\n");
2427 fprintf (stream
, " void *pc_begin;\n");
2428 fprintf (stream
, " void *pc_end;\n");
2429 fprintf (stream
, " void *fde_begin;\n");
2430 fprintf (stream
, " void *fde_array;\n");
2431 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2432 fprintf (stream
, " struct object *next;\n");
2433 fprintf (stream
, "};\n");
2435 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2436 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2438 fprintf (stream
, "static void reg_frame () {\n");
2439 fprintf (stream
, "\tstatic struct object ob;\n");
2440 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2441 fprintf (stream
, "\t}\n");
2443 fprintf (stream
, "static void dereg_frame () {\n");
2444 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2445 fprintf (stream
, "\t}\n");
2448 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2449 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2450 write_list (stream
, "\t", constructors
.first
);
2452 fprintf (stream
, "\treg_frame,\n");
2453 fprintf (stream
, "\t0\n};\n\n");
2455 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2457 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2458 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2459 write_list (stream
, "\t", destructors
.first
);
2461 fprintf (stream
, "\tdereg_frame,\n");
2462 fprintf (stream
, "\t0\n};\n\n");
2464 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2465 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2467 #endif /* ! LD_INIT_SWITCH */
2470 write_c_file (FILE *stream
, const char *name
)
2472 #ifndef LD_INIT_SWITCH
2474 write_c_file_glob (stream
, name
);
2477 write_c_file_stat (stream
, name
);
2480 #ifdef COLLECT_EXPORT_LIST
2482 write_aix_file (FILE *stream
, struct id
*list
)
2484 for (; list
; list
= list
->next
)
2486 fputs (list
->name
, stream
);
2487 putc ('\n', stream
);
2492 #ifdef OBJECT_FORMAT_NONE
2494 /* Check to make sure the file is an LTO object file. */
2497 maybe_lto_object_file (const char *prog_name
)
2500 unsigned char buf
[4];
2503 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2504 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2505 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2506 static unsigned char machomagic
[4][4] = {
2507 { 0xcf, 0xfa, 0xed, 0xfe },
2508 { 0xce, 0xfa, 0xed, 0xfe },
2509 { 0xfe, 0xed, 0xfa, 0xcf },
2510 { 0xfe, 0xed, 0xfa, 0xce }
2513 f
= fopen (prog_name
, "rb");
2516 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2520 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2521 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2522 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2524 for (i
= 0; i
< 4; i
++)
2525 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2531 /* Generic version to scan the name list of the loaded program for
2532 the symbols g++ uses for static constructors and destructors. */
2535 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2538 void (*int_handler
) (int);
2540 void (*quit_handler
) (int);
2542 char *real_nm_argv
[4];
2543 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2545 struct pex_obj
*pex
;
2552 if (which_pass
== PASS_SECOND
)
2555 /* LTO objects must be in a known format. This check prevents
2556 us from accepting an archive containing LTO objects, which
2557 gcc cannnot currently handle. */
2558 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2561 /* If we do not have an `nm', complain. */
2562 if (nm_file_name
== 0)
2563 fatal_error ("cannot find 'nm'");
2565 nm_argv
[argc
++] = nm_file_name
;
2566 if (NM_FLAGS
[0] != '\0')
2567 nm_argv
[argc
++] = NM_FLAGS
;
2569 nm_argv
[argc
++] = prog_name
;
2570 nm_argv
[argc
++] = (char *) 0;
2572 /* Trace if needed. */
2575 const char **p_argv
;
2578 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2579 fprintf (stderr
, " %s", str
);
2581 fprintf (stderr
, "\n");
2587 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2589 fatal_error ("pex_init failed: %m");
2591 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2598 fatal_error ("%s: %m", _(errmsg
));
2601 fatal_error (errmsg
);
2604 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2606 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2609 inf
= pex_read_output (pex
, 0);
2611 fatal_error ("can't open nm output: %m");
2615 if (which_pass
== PASS_LTOINFO
)
2616 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2618 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2621 /* Read each line of nm output. */
2622 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2628 fprintf (stderr
, "\t%s\n", buf
);
2630 if (which_pass
== PASS_LTOINFO
)
2635 /* Look for the LTO info marker symbol, and add filename to
2636 the LTO objects list if found. */
2637 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2638 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2639 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2640 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2642 add_lto_object (<o_objects
, prog_name
);
2644 /* We need to read all the input, so we can't just
2645 return here. But we can avoid useless work. */
2654 /* If it contains a constructor or destructor name, add the name
2655 to the appropriate list unless this is a kind of symbol we're
2656 not supposed to even consider. */
2658 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2659 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2666 /* Find the end of the symbol name.
2667 Do not include `|', because Encore nm can tack that on the end. */
2668 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2674 switch (is_ctor_dtor (name
))
2677 if (! (filter
& SCAN_CTOR
))
2679 if (which_pass
!= PASS_LIB
)
2680 add_to_list (&constructors
, name
);
2684 if (! (filter
& SCAN_DTOR
))
2686 if (which_pass
!= PASS_LIB
)
2687 add_to_list (&destructors
, name
);
2691 if (! (filter
& SCAN_INIT
))
2693 if (which_pass
!= PASS_LIB
)
2694 fatal_error ("init function found in object %s", prog_name
);
2695 #ifndef LD_INIT_SWITCH
2696 add_to_list (&constructors
, name
);
2701 if (! (filter
& SCAN_FINI
))
2703 if (which_pass
!= PASS_LIB
)
2704 fatal_error ("fini function found in object %s", prog_name
);
2705 #ifndef LD_FINI_SWITCH
2706 add_to_list (&destructors
, name
);
2711 if (! (filter
& SCAN_DWEH
))
2713 if (which_pass
!= PASS_LIB
)
2714 add_to_list (&frame_tables
, name
);
2717 default: /* not a constructor or destructor */
2723 fprintf (stderr
, "\n");
2725 do_wait (nm_file_name
, pex
);
2727 signal (SIGINT
, int_handler
);
2729 signal (SIGQUIT
, quit_handler
);
2735 /* Use the List Dynamic Dependencies program to find shared libraries that
2736 the output file depends upon and their initialization/finalization
2737 routines, if any. */
2740 scan_libraries (const char *prog_name
)
2742 static struct head libraries
; /* list of shared libraries found */
2744 void (*int_handler
) (int);
2746 void (*quit_handler
) (int);
2748 char *real_ldd_argv
[4];
2749 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2751 struct pex_obj
*pex
;
2757 /* If we do not have an `ldd', complain. */
2758 if (ldd_file_name
== 0)
2760 error ("cannot find 'ldd'");
2764 ldd_argv
[argc
++] = ldd_file_name
;
2765 ldd_argv
[argc
++] = prog_name
;
2766 ldd_argv
[argc
++] = (char *) 0;
2768 /* Trace if needed. */
2771 const char **p_argv
;
2774 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2775 fprintf (stderr
, " %s", str
);
2777 fprintf (stderr
, "\n");
2783 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2785 fatal_error ("pex_init failed: %m");
2787 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2793 fatal_error ("%s: %m", _(errmsg
));
2796 fatal_error (errmsg
);
2799 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2801 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2804 inf
= pex_read_output (pex
, 0);
2806 fatal_error ("can't open ldd output: %m");
2809 notice ("\nldd output with constructors/destructors.\n");
2811 /* Read each line of ldd output. */
2812 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2815 char *name
, *end
, *p
= buf
;
2817 /* Extract names of libraries and add to list. */
2818 PARSE_LDD_OUTPUT (p
);
2823 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2824 fatal_error ("dynamic dependency %s not found", buf
);
2826 /* Find the end of the symbol name. */
2828 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2833 if (access (name
, R_OK
) == 0)
2834 add_to_list (&libraries
, name
);
2836 fatal_error ("unable to open dynamic dependency '%s'", buf
);
2839 fprintf (stderr
, "\t%s\n", buf
);
2842 fprintf (stderr
, "\n");
2844 do_wait (ldd_file_name
, pex
);
2846 signal (SIGINT
, int_handler
);
2848 signal (SIGQUIT
, quit_handler
);
2851 /* Now iterate through the library list adding their symbols to
2853 for (list
= libraries
.first
; list
; list
= list
->next
)
2854 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2857 #endif /* LDD_SUFFIX */
2859 #endif /* OBJECT_FORMAT_NONE */
2863 * COFF specific stuff.
2866 #ifdef OBJECT_FORMAT_COFF
2868 #if defined (EXTENDED_COFF)
2870 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2871 # define GCC_SYMENT SYMR
2872 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2873 # define GCC_SYMINC(X) (1)
2874 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2875 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2879 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2880 # define GCC_SYMENT SYMENT
2881 # if defined (C_WEAKEXT)
2882 # define GCC_OK_SYMBOL(X) \
2883 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2884 ((X).n_scnum > N_UNDEF) && \
2886 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2887 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2888 # define GCC_UNDEF_SYMBOL(X) \
2889 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2890 ((X).n_scnum == N_UNDEF))
2892 # define GCC_OK_SYMBOL(X) \
2893 (((X).n_sclass == C_EXT) && \
2894 ((X).n_scnum > N_UNDEF) && \
2896 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2897 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2898 # define GCC_UNDEF_SYMBOL(X) \
2899 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2901 # define GCC_SYMINC(X) ((X).n_numaux+1)
2902 # define GCC_SYMZERO(X) 0
2904 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2905 #if TARGET_AIX_VERSION >= 51
2906 # define GCC_CHECK_HDR(X) \
2907 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2908 || (HEADER (X).f_magic == 0767 && aix64_flag))
2910 # define GCC_CHECK_HDR(X) \
2911 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2912 || (HEADER (X).f_magic == 0757 && aix64_flag))
2917 #ifdef COLLECT_EXPORT_LIST
2918 /* Array of standard AIX libraries which should not
2919 be scanned for ctors/dtors. */
2920 static const char *const aix_std_libs
[] = {
2928 "/usr/lib/libc_r.a",
2929 "/usr/lib/libm_r.a",
2930 "/usr/lib/threads/libc.a",
2931 "/usr/ccs/lib/libc.a",
2932 "/usr/ccs/lib/libm.a",
2933 "/usr/ccs/lib/libc_r.a",
2934 "/usr/ccs/lib/libm_r.a",
2938 /* This function checks the filename and returns 1
2939 if this name matches the location of a standard AIX library. */
2940 static int ignore_library (const char *);
2942 ignore_library (const char *name
)
2944 const char *const *p
;
2947 if (target_system_root
[0] != '\0')
2949 length
= strlen (target_system_root
);
2950 if (strncmp (name
, target_system_root
, length
) != 0)
2954 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2955 if (strcmp (name
, *p
) == 0)
2959 #endif /* COLLECT_EXPORT_LIST */
2961 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2962 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2965 /* COFF version to scan the name list of the loaded program for
2966 the symbols g++ uses for static constructors and destructors. */
2969 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2972 LDFILE
*ldptr
= NULL
;
2973 int sym_index
, sym_count
;
2976 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2979 #ifdef COLLECT_EXPORT_LIST
2980 /* We do not need scanning for some standard C libraries. */
2981 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2984 /* On AIX we have a loop, because there is not much difference
2985 between an object and an archive. This trick allows us to
2986 eliminate scan_libraries() function. */
2990 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2991 non-const char * filename parameter, even though it will not
2992 modify that string. So we must cast away const-ness here,
2993 using CONST_CAST to prevent complaints from -Wcast-qual. */
2994 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2996 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2997 fatal_error ("%s: not a COFF file", prog_name
);
2999 if (GCC_CHECK_HDR (ldptr
))
3001 sym_count
= GCC_SYMBOLS (ldptr
);
3002 sym_index
= GCC_SYMZERO (ldptr
);
3004 #ifdef COLLECT_EXPORT_LIST
3005 /* Is current archive member a shared object? */
3006 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
3009 while (sym_index
< sym_count
)
3013 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
3015 sym_index
+= GCC_SYMINC (symbol
);
3017 if (GCC_OK_SYMBOL (symbol
))
3021 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
3022 continue; /* Should never happen. */
3024 #ifdef XCOFF_DEBUGGING_INFO
3025 /* All AIX function names have a duplicate entry
3026 beginning with a dot. */
3031 switch (is_ctor_dtor (name
))
3034 if (! (filter
& SCAN_CTOR
))
3037 add_to_list (&constructors
, name
);
3038 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3039 if (which_pass
== PASS_OBJ
)
3040 add_to_list (&exports
, name
);
3045 if (! (filter
& SCAN_DTOR
))
3048 add_to_list (&destructors
, name
);
3049 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3050 if (which_pass
== PASS_OBJ
)
3051 add_to_list (&exports
, name
);
3055 #ifdef COLLECT_EXPORT_LIST
3057 if (! (filter
& SCAN_INIT
))
3059 #ifndef LD_INIT_SWITCH
3061 add_to_list (&constructors
, name
);
3066 if (! (filter
& SCAN_FINI
))
3068 #ifndef LD_INIT_SWITCH
3070 add_to_list (&destructors
, name
);
3076 if (! (filter
& SCAN_DWEH
))
3079 add_to_list (&frame_tables
, name
);
3080 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3081 if (which_pass
== PASS_OBJ
)
3082 add_to_list (&exports
, name
);
3086 default: /* not a constructor or destructor */
3087 #ifdef COLLECT_EXPORT_LIST
3088 /* Explicitly export all global symbols when
3089 building a shared object on AIX, but do not
3090 re-export symbols from another shared object
3091 and do not export symbols if the user
3092 provides an explicit export list. */
3093 if (shared_obj
&& !is_shared
3094 && which_pass
== PASS_OBJ
&& !export_flag
)
3095 add_to_list (&exports
, name
);
3101 #if !defined(EXTENDED_COFF)
3102 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3103 symbol
.n_scnum
, symbol
.n_sclass
,
3104 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3108 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3109 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3114 #ifdef COLLECT_EXPORT_LIST
3117 /* If archive contains both 32-bit and 64-bit objects,
3118 we want to skip objects in other mode so mismatch normal. */
3120 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3121 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3127 fatal_error ("%s: cannot open as COFF file", prog_name
);
3129 #ifdef COLLECT_EXPORT_LIST
3130 /* On AIX loop continues while there are more members in archive. */
3132 while (ldclose (ldptr
) == FAILURE
);
3134 /* Otherwise we simply close ldptr. */
3135 (void) ldclose(ldptr
);
3138 #endif /* OBJECT_FORMAT_COFF */
3140 #ifdef COLLECT_EXPORT_LIST
3141 /* Given a library name without "lib" prefix, this function
3142 returns a full library name including a path. */
3144 resolve_lib_name (const char *name
)
3148 /* Library extensions for AIX dynamic linking. */
3149 const char * const libexts
[2] = {"a", "so"};
3151 for (i
= 0; libpaths
[i
]; i
++)
3152 if (libpaths
[i
]->max_len
> l
)
3153 l
= libpaths
[i
]->max_len
;
3155 lib_buf
= XNEWVEC (char, l
+ strlen(name
) + 10);
3157 for (i
= 0; libpaths
[i
]; i
++)
3159 struct prefix_list
*list
= libpaths
[i
]->plist
;
3160 for (; list
; list
= list
->next
)
3162 /* The following lines are needed because path_prefix list
3163 may contain directories both with trailing DIR_SEPARATOR and
3166 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen(list
->prefix
)-1]))
3168 for (j
= 0; j
< 2; j
++)
3170 sprintf (lib_buf
, "%s%slib%s.%s",
3171 list
->prefix
, p
, name
,
3172 libexts
[(j
+ aixrtl_flag
) % 2]);
3173 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3174 if (file_exists (lib_buf
))
3176 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3183 fprintf (stderr
, "not found\n");
3185 fatal_error ("library lib%s not found", name
);
3188 #endif /* COLLECT_EXPORT_LIST */
3190 #ifdef COLLECT_RUN_DSYMUTIL
3191 static int flag_dsym
= false;
3192 static int flag_idsym
= false;
3195 process_args (int *argcp
, char **argv
) {
3198 for (i
=0; i
<argc
; ++i
)
3200 if (strcmp (argv
[i
], "-dsym") == 0)
3203 /* Remove the flag, as we handle all processing for it. */
3206 argv
[j
] = argv
[j
+1];
3211 else if (strcmp (argv
[i
], "-idsym") == 0)
3214 /* Remove the flag, as we handle all processing for it. */
3217 argv
[j
] = argv
[j
+1];
3226 do_dsymutil (const char *output_file
) {
3227 const char *dsymutil
= DSYMUTIL
+ 1;
3228 struct pex_obj
*pex
;
3229 char **real_argv
= XCNEWVEC (char *, 3);
3230 const char ** argv
= CONST_CAST2 (const char **, char **,
3234 argv
[1] = output_file
;
3235 argv
[2] = (char *) 0;
3237 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
3238 do_wait (dsymutil
, pex
);
3242 post_ld_pass (bool temp_file
) {
3243 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3246 do_dsymutil (output_file
);
3250 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3251 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }