1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
6 Contributed by Chris Smith (csmith@convex.com).
7 Heavily modified by Michael Meissner (meissner@cygnus.com),
8 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
27 /* Build tables of static constructors and destructors and run ld. */
31 #include "coretypes.h"
34 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
45 #include "collect2-aix.h"
51 /* On certain systems, we have code that works by scanning the object file
52 directly. But this code uses system-specific header files and library
53 functions, so turn it off in a cross-compiler. Likewise, the names of
54 the utilities are not correct for a cross-compiler; we have to hope that
55 cross-versions are in the proper directories. */
57 #ifdef CROSS_DIRECTORY_STRUCTURE
58 #ifndef CROSS_AIX_SUPPORT
59 #undef OBJECT_FORMAT_COFF
62 #undef REAL_LD_FILE_NAME
63 #undef REAL_NM_FILE_NAME
64 #undef REAL_STRIP_FILE_NAME
67 /* If we cannot use a special method, use the ordinary one:
68 run nm to find what symbols are present.
69 In a cross-compiler, this means you need a cross nm,
70 but that is not quite as unpleasant as special headers. */
72 #if !defined (OBJECT_FORMAT_COFF)
73 #define OBJECT_FORMAT_NONE
76 #ifdef OBJECT_FORMAT_COFF
78 #ifndef CROSS_DIRECTORY_STRUCTURE
86 /* Many versions of ldfcn.h define these. */
95 /* Some systems have an ISCOFF macro, but others do not. In some cases
96 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
97 that either do not have an ISCOFF macro in /usr/include or for those
101 #define MY_ISCOFF(X) ISCOFF (X)
104 #endif /* OBJECT_FORMAT_COFF */
106 #ifdef OBJECT_FORMAT_NONE
108 /* Default flags to pass to nm. */
110 #define NM_FLAGS "-n"
113 #endif /* OBJECT_FORMAT_NONE */
115 /* Some systems use __main in a way incompatible with its use in gcc, in these
116 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
117 give the same symbol without quotes for an alternative entry point. */
119 #define NAME__MAIN "__main"
122 /* This must match tree.h. */
123 #define DEFAULT_INIT_PRIORITY 65535
125 #ifndef COLLECT_SHARED_INIT_FUNC
126 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
127 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
129 #ifndef COLLECT_SHARED_FINI_FUNC
130 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
135 #define SCAN_LIBRARIES
139 #define SHLIB_SUFFIX ".so"
143 int do_collecting
= 1;
145 int do_collecting
= 0;
148 /* Cook up an always defined indication of whether we proceed the
149 "EXPORT_LIST" way. */
151 #ifdef COLLECT_EXPORT_LIST
152 #define DO_COLLECT_EXPORT_LIST 1
154 #define DO_COLLECT_EXPORT_LIST 0
157 /* Nonzero if we should suppress the automatic demangling of identifiers
158 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
161 /* Linked lists of constructor and destructor names. */
177 bool vflag
; /* true if -v or --version */
178 static int rflag
; /* true if -r */
179 static int strip_flag
; /* true if -s */
180 static const char *demangle_flag
;
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag
; /* true if -bE */
183 static int aix64_flag
; /* true if -b64 */
184 static int aixrtl_flag
; /* true if -brtl */
188 LTO_MODE_NONE
, /* Not doing LTO. */
189 LTO_MODE_LTO
, /* Normal LTO. */
190 LTO_MODE_WHOPR
/* WHOPR. */
193 /* Current LTO mode. */
194 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
196 bool debug
; /* true if -debug */
197 bool helpflag
; /* true if --help */
199 static int shared_obj
; /* true if -shared */
201 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
202 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
203 #ifdef COLLECT_EXPORT_LIST
204 static const char *export_file
; /* <xxx>.x for AIX export list. */
206 static char **lto_o_files
; /* Output files for LTO. */
207 const char *ldout
; /* File for ld stdout. */
208 const char *lderrout
; /* File for ld stderr. */
209 static const char *output_file
; /* Output file for ld. */
210 static const char *nm_file_name
; /* pathname of nm */
212 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
214 static const char *strip_file_name
; /* pathname of strip */
215 const char *c_file_name
; /* pathname of gcc */
216 static char *initname
, *fininame
; /* names of init and fini funcs */
218 static struct head constructors
; /* list of constructors found */
219 static struct head destructors
; /* list of destructors found */
220 #ifdef COLLECT_EXPORT_LIST
221 static struct head exports
; /* list of exported symbols */
223 static struct head frame_tables
; /* list of frame unwind info tables */
225 static bool at_file_supplied
; /* Whether to use @file arguments */
226 static char *response_file
; /* Name of any current response file */
228 struct obstack temporary_obstack
;
229 char * temporary_firstobj
;
231 /* A string that must be prepended to a target OS path in order to find
232 it on the host system. */
233 #ifdef TARGET_SYSTEM_ROOT
234 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
236 static const char *target_system_root
= "";
239 /* Structure to hold all the directories in which to search for files to
244 const char *prefix
; /* String to prepend to the path. */
245 struct prefix_list
*next
; /* Next in linked list. */
250 struct prefix_list
*plist
; /* List of prefixes to try */
251 int max_len
; /* Max length of a prefix in PLIST */
252 const char *name
; /* Name of this list (used in config stuff) */
255 #ifdef COLLECT_EXPORT_LIST
256 /* Lists to keep libraries to be scanned for global constructors/destructors. */
257 static struct head libs
; /* list of libraries */
258 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
259 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
260 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
261 &libpath_lib_dirs
, NULL
};
264 /* List of names of object files containing LTO information.
265 These are a subset of the object file names appearing on the
266 command line, and must be identical, in the sense of pointer
267 equality, with the names passed to maybe_run_lto_and_relink(). */
271 const char *name
; /* Name of object file. */
272 struct lto_object
*next
; /* Next in linked list. */
275 struct lto_object_list
277 struct lto_object
*first
; /* First list element. */
278 struct lto_object
*last
; /* Last list element. */
281 static struct lto_object_list lto_objects
;
283 /* Special kinds of symbols that a name may denote. */
286 SYM_REGULAR
= 0, /* nothing special */
288 SYM_CTOR
= 1, /* constructor */
289 SYM_DTOR
= 2, /* destructor */
290 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
291 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
292 SYM_DWEH
= 5 /* DWARF exception handling table */
295 static symkind
is_ctor_dtor (const char *);
297 static void handler (int);
298 static char *find_a_file (struct path_prefix
*, const char *);
299 static void add_prefix (struct path_prefix
*, const char *);
300 static void prefix_from_env (const char *, struct path_prefix
*);
301 static void prefix_from_string (const char *, struct path_prefix
*);
302 static void do_wait (const char *, struct pex_obj
*);
303 static void fork_execute (const char *, char **);
304 static void maybe_unlink (const char *);
305 static void maybe_unlink_list (char **);
306 static void add_to_list (struct head
*, const char *);
307 static int extract_init_priority (const char *);
308 static void sort_ids (struct head
*);
309 static void write_list (FILE *, const char *, struct id
*);
310 #ifdef COLLECT_EXPORT_LIST
311 static void dump_list (FILE *, const char *, struct id
*);
314 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
316 static void write_list_with_asm (FILE *, const char *, struct id
*);
317 static void write_c_file (FILE *, const char *);
318 static void write_c_file_stat (FILE *, const char *);
319 #ifndef LD_INIT_SWITCH
320 static void write_c_file_glob (FILE *, const char *);
322 #ifdef SCAN_LIBRARIES
323 static void scan_libraries (const char *);
325 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
326 static int is_in_args (const char *, const char **, const char **);
328 #ifdef COLLECT_EXPORT_LIST
330 static int is_in_list (const char *, struct id
*);
332 static void write_aix_file (FILE *, struct id
*);
333 static char *resolve_lib_name (const char *);
335 static char *extract_string (const char **);
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
);
445 /* Die when sys call fails. */
448 fatal_perror (const char * cmsgid
, ...)
453 va_start (ap
, cmsgid
);
454 fprintf (stderr
, "collect2: ");
455 vfprintf (stderr
, _(cmsgid
), ap
);
456 fprintf (stderr
, ": %s\n", xstrerror (e
));
459 collect_exit (FATAL_EXIT_CODE
);
465 fatal (const char * cmsgid
, ...)
469 va_start (ap
, cmsgid
);
470 fprintf (stderr
, "collect2: ");
471 vfprintf (stderr
, _(cmsgid
), ap
);
472 fprintf (stderr
, "\n");
475 collect_exit (FATAL_EXIT_CODE
);
478 /* Write error message. */
481 error (const char * gmsgid
, ...)
485 va_start (ap
, gmsgid
);
486 fprintf (stderr
, "collect2: ");
487 vfprintf (stderr
, _(gmsgid
), ap
);
488 fprintf (stderr
, "\n");
492 /* In case obstack is linked in, and abort is defined to fancy_abort,
493 provide a default entry. */
496 fancy_abort (const char *file
, int line
, const char *func
)
498 fatal ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
504 if (c_file
!= 0 && c_file
[0])
505 maybe_unlink (c_file
);
507 if (o_file
!= 0 && o_file
[0])
508 maybe_unlink (o_file
);
510 if (ldout
!= 0 && ldout
[0])
511 maybe_unlink (ldout
);
513 if (lderrout
!= 0 && lderrout
[0])
514 maybe_unlink (lderrout
);
516 #ifdef COLLECT_EXPORT_LIST
517 if (export_file
!= 0 && export_file
[0])
518 maybe_unlink (export_file
);
522 maybe_unlink_list (lto_o_files
);
525 maybe_unlink (response_file
);
527 signal (signo
, SIG_DFL
);
533 file_exists (const char *name
)
535 return access (name
, R_OK
) == 0;
538 /* Parse a reasonable subset of shell quoting syntax. */
541 extract_string (const char **pp
)
554 obstack_1grow (&temporary_obstack
, c
);
555 else if (! inside
&& c
== ' ')
557 else if (! inside
&& c
== '\\')
562 obstack_1grow (&temporary_obstack
, c
);
565 obstack_1grow (&temporary_obstack
, '\0');
567 return XOBFINISH (&temporary_obstack
, char *);
571 dump_file (const char *name
, FILE *to
)
573 FILE *stream
= fopen (name
, "r");
580 while (c
= getc (stream
),
581 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
582 obstack_1grow (&temporary_obstack
, c
);
583 if (obstack_object_size (&temporary_obstack
) > 0)
585 const char *word
, *p
;
587 obstack_1grow (&temporary_obstack
, '\0');
588 word
= XOBFINISH (&temporary_obstack
, const char *);
591 ++word
, putc ('.', to
);
593 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
594 p
+= strlen (USER_LABEL_PREFIX
);
596 #ifdef HAVE_LD_DEMANGLE
602 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
610 diff
= strlen (word
) - strlen (result
);
611 while (diff
> 0 && c
== ' ')
612 --diff
, putc (' ', to
);
613 if (diff
< 0 && c
== ' ')
615 while (diff
< 0 && c
== ' ')
616 ++diff
, c
= getc (stream
);
619 /* Make sure we output at least one space, or
620 the demangled symbol name will run into
621 whatever text follows. */
632 obstack_free (&temporary_obstack
, temporary_firstobj
);
641 /* Return the kind of symbol denoted by name S. */
644 is_ctor_dtor (const char *s
)
646 struct names
{ const char *const name
; const int len
; symkind ret
;
647 const int two_underscores
; };
649 const struct names
*p
;
651 const char *orig_s
= s
;
653 static const struct names special
[] = {
654 #ifndef NO_DOLLAR_IN_LABEL
655 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
656 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
658 #ifndef NO_DOT_IN_LABEL
659 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
660 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
661 #endif /* NO_DOT_IN_LABEL */
662 #endif /* NO_DOLLAR_IN_LABEL */
663 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
664 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
665 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
666 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
667 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
668 { NULL
, 0, SYM_REGULAR
, 0 }
671 while ((ch
= *s
) == '_')
677 for (p
= &special
[0]; p
->len
> 0; p
++)
680 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
681 && strncmp(s
, p
->name
, p
->len
) == 0)
689 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
690 and one from the PATH variable. */
692 static struct path_prefix cpath
, path
;
694 #ifdef CROSS_DIRECTORY_STRUCTURE
695 /* This is the name of the target machine. We use it to form the name
696 of the files to execute. */
698 static const char *const target_machine
= TARGET_MACHINE
;
701 /* Search for NAME using prefix list PPREFIX. We only look for executable
704 Return 0 if not found, otherwise return its name, allocated with malloc. */
707 find_a_file (struct path_prefix
*pprefix
, const char *name
)
710 struct prefix_list
*pl
;
711 int len
= pprefix
->max_len
+ strlen (name
) + 1;
714 fprintf (stderr
, "Looking for '%s'\n", name
);
716 #ifdef HOST_EXECUTABLE_SUFFIX
717 len
+= strlen (HOST_EXECUTABLE_SUFFIX
);
720 temp
= XNEWVEC (char, len
);
722 /* Determine the filename to execute (special case for absolute paths). */
724 if (IS_ABSOLUTE_PATH (name
))
726 if (access (name
, X_OK
) == 0)
731 fprintf (stderr
, " - found: absolute path\n");
736 #ifdef HOST_EXECUTABLE_SUFFIX
737 /* Some systems have a suffix for executable files.
738 So try appending that. */
740 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
742 if (access (temp
, X_OK
) == 0)
747 fprintf (stderr
, " - failed to locate using absolute path\n");
750 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
754 strcpy (temp
, pl
->prefix
);
757 if (stat (temp
, &st
) >= 0
758 && ! S_ISDIR (st
.st_mode
)
759 && access (temp
, X_OK
) == 0)
762 #ifdef HOST_EXECUTABLE_SUFFIX
763 /* Some systems have a suffix for executable files.
764 So try appending that. */
765 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
767 if (stat (temp
, &st
) >= 0
768 && ! S_ISDIR (st
.st_mode
)
769 && access (temp
, X_OK
) == 0)
774 if (debug
&& pprefix
->plist
== NULL
)
775 fprintf (stderr
, " - failed: no entries in prefix list\n");
781 /* Add an entry for PREFIX to prefix list PPREFIX. */
784 add_prefix (struct path_prefix
*pprefix
, const char *prefix
)
786 struct prefix_list
*pl
, **prev
;
791 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
796 prev
= &pprefix
->plist
;
798 /* Keep track of the longest prefix. */
800 len
= strlen (prefix
);
801 if (len
> pprefix
->max_len
)
802 pprefix
->max_len
= len
;
804 pl
= XNEW (struct prefix_list
);
805 pl
->prefix
= xstrdup (prefix
);
810 pl
->next
= (struct prefix_list
*) 0;
814 /* Take the value of the environment variable ENV, break it into a path, and
815 add of the entries to PPREFIX. */
818 prefix_from_env (const char *env
, struct path_prefix
*pprefix
)
824 prefix_from_string (p
, pprefix
);
828 prefix_from_string (const char *p
, struct path_prefix
*pprefix
)
830 const char *startp
, *endp
;
831 char *nstore
= XNEWVEC (char, strlen (p
) + 3);
834 fprintf (stderr
, "Convert string '%s' into prefixes, separator = '%c'\n", p
, PATH_SEPARATOR
);
839 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
841 strncpy (nstore
, startp
, endp
-startp
);
844 strcpy (nstore
, "./");
846 else if (! IS_DIR_SEPARATOR (endp
[-1]))
848 nstore
[endp
-startp
] = DIR_SEPARATOR
;
849 nstore
[endp
-startp
+1] = 0;
852 nstore
[endp
-startp
] = 0;
855 fprintf (stderr
, " - add prefix: %s\n", nstore
);
857 add_prefix (pprefix
, nstore
);
860 endp
= startp
= endp
+ 1;
868 #ifdef OBJECT_FORMAT_NONE
870 /* Add an entry for the object file NAME to object file list LIST.
871 New entries are added at the end of the list. The original pointer
872 value of NAME is preserved, i.e., no string copy is performed. */
875 add_lto_object (struct lto_object_list
*list
, const char *name
)
877 struct lto_object
*n
= XNEW (struct lto_object
);
882 list
->last
->next
= n
;
888 #endif /* OBJECT_FORMAT_NONE */
891 /* Perform a link-time recompilation and relink if any of the object
892 files contain LTO info. The linker command line LTO_LD_ARGV
893 represents the linker command that would produce a final executable
894 without the use of LTO. OBJECT_LST is a vector of object file names
895 appearing in LTO_LD_ARGV that are to be considerd for link-time
896 recompilation, where OBJECT is a pointer to the last valid element.
897 (This awkward convention avoids an impedance mismatch with the
898 usage of similarly-named variables in main().) The elements of
899 OBJECT_LST must be identical, i.e., pointer equal, to the
900 corresponding arguments in LTO_LD_ARGV.
902 Upon entry, at least one linker run has been performed without the
903 use of any LTO info that might be present. Any recompilations
904 necessary for template instantiations have been performed, and
905 initializer/finalizer tables have been created if needed and
906 included in the linker command line LTO_LD_ARGV. If any of the
907 object files contain LTO info, we run the LTO back end on all such
908 files, and perform the final link with the LTO back end output
909 substituted for the LTO-optimized files. In some cases, a final
910 link with all link-time generated code has already been performed,
911 so there is no need to relink if no LTO info is found. In other
912 cases, our caller has not produced the final executable, and is
913 relying on us to perform the required link whether LTO info is
914 present or not. In that case, the FORCE argument should be true.
915 Note that the linker command line argument LTO_LD_ARGV passed into
916 this function may be modified in place. */
919 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
920 const char **object
, bool force
)
922 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
924 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
926 while (object_file
< object
)
928 /* If file contains LTO info, add it to the list of LTO objects. */
929 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
931 /* Increment the argument count by the number of object file arguments
932 we will add. An upper bound suffices, so just count all of the
933 object files regardless of whether they contain LTO info. */
937 if (lto_objects
.first
)
940 const char **lto_c_ptr
;
943 struct lto_object
*list
;
944 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
946 const char *prog
= "lto-wrapper";
947 int lto_ld_argv_size
= 0;
948 char **out_lto_ld_argv
;
949 int out_lto_ld_argv_size
;
953 fatal ("COLLECT_LTO_WRAPPER must be set");
957 /* There is at least one object file containing LTO info,
958 so we need to run the LTO back end and relink.
960 To do so we build updated ld arguments with first
961 LTO object replaced by all partitions and other LTO
964 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
965 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
967 *lto_c_ptr
++ = lto_wrapper
;
969 /* Add LTO objects to the wrapper command line. */
970 for (list
= lto_objects
.first
; list
; list
= list
->next
)
971 *lto_c_ptr
++ = list
->name
;
975 /* Run the LTO back end. */
976 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
983 stream
= pex_read_output (pex
, 0);
987 while ((c
= getc (stream
)) != EOF
)
989 obstack_1grow (&temporary_obstack
, c
);
994 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
995 lto_o_files
[num_files
] = NULL
;
996 start
= XOBFINISH (&temporary_obstack
, char *);
997 for (i
= 0; i
< num_files
; ++i
)
1000 while (*end
!= '\n')
1004 lto_o_files
[i
] = xstrdup (start
);
1009 obstack_free (&temporary_obstack
, temporary_firstobj
);
1011 do_wait (prog
, pex
);
1014 /* Compute memory needed for new LD arguments. At most number of original arguemtns
1015 plus number of partitions. */
1016 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
1018 out_lto_ld_argv
= XCNEWVEC(char *, num_files
+ lto_ld_argv_size
+ 1);
1019 out_lto_ld_argv_size
= 0;
1021 /* After running the LTO back end, we will relink, substituting
1022 the LTO output for the object files that we submitted to the
1023 LTO. Here, we modify the linker command line for the relink. */
1025 /* Copy all arguments until we find first LTO file. */
1029 for (list
= lto_objects
.first
; list
; list
= list
->next
)
1030 if (*p
== list
->name
) /* Note test for pointer equality! */
1034 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
1037 /* Now insert all LTO partitions. */
1038 lto_o_ptr
= lto_o_files
;
1040 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
1042 /* ... and copy the rest. */
1045 for (list
= lto_objects
.first
; list
; list
= list
->next
)
1046 if (*p
== list
->name
) /* Note test for pointer equality! */
1049 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
1052 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
1054 /* Run the linker again, this time replacing the object files
1055 optimized by the LTO with the temporary file generated by the LTO. */
1056 fork_execute ("ld", out_lto_ld_argv
);
1059 maybe_unlink_list (lto_o_files
);
1063 /* Our caller is relying on us to do the link
1064 even though there is no LTO back end work to be done. */
1065 fork_execute ("ld", lto_ld_argv
);
1072 main (int argc
, char **argv
)
1074 static const char *const ld_suffix
= "ld";
1075 static const char *const plugin_ld_suffix
= PLUGIN_LD
;
1076 static const char *const real_ld_suffix
= "real-ld";
1077 static const char *const collect_ld_suffix
= "collect-ld";
1078 static const char *const nm_suffix
= "nm";
1079 static const char *const gnm_suffix
= "gnm";
1081 static const char *const ldd_suffix
= LDD_SUFFIX
;
1083 static const char *const strip_suffix
= "strip";
1084 static const char *const gstrip_suffix
= "gstrip";
1086 #ifdef CROSS_DIRECTORY_STRUCTURE
1087 /* If we look for a program in the compiler directories, we just use
1088 the short name, since these directories are already system-specific.
1089 But it we look for a program in the system directories, we need to
1090 qualify the program name with the target machine. */
1092 const char *const full_ld_suffix
=
1093 concat(target_machine
, "-", ld_suffix
, NULL
);
1094 const char *const full_plugin_ld_suffix
=
1095 concat(target_machine
, "-", plugin_ld_suffix
, NULL
);
1096 const char *const full_nm_suffix
=
1097 concat (target_machine
, "-", nm_suffix
, NULL
);
1098 const char *const full_gnm_suffix
=
1099 concat (target_machine
, "-", gnm_suffix
, NULL
);
1101 const char *const full_ldd_suffix
=
1102 concat (target_machine
, "-", ldd_suffix
, NULL
);
1104 const char *const full_strip_suffix
=
1105 concat (target_machine
, "-", strip_suffix
, NULL
);
1106 const char *const full_gstrip_suffix
=
1107 concat (target_machine
, "-", gstrip_suffix
, NULL
);
1109 const char *const full_ld_suffix
= ld_suffix
;
1110 const char *const full_plugin_ld_suffix
= plugin_ld_suffix
;
1111 const char *const full_nm_suffix
= nm_suffix
;
1112 const char *const full_gnm_suffix
= gnm_suffix
;
1114 const char *const full_ldd_suffix
= ldd_suffix
;
1116 const char *const full_strip_suffix
= strip_suffix
;
1117 const char *const full_gstrip_suffix
= gstrip_suffix
;
1118 #endif /* CROSS_DIRECTORY_STRUCTURE */
1122 #ifdef COLLECT_EXPORT_LIST
1125 const char *ld_file_name
;
1131 bool use_plugin
= false;
1133 /* The kinds of symbols we will have to consider when scanning the
1134 outcome of a first pass link. This is ALL to start with, then might
1135 be adjusted before getting to the first pass link per se, typically on
1136 AIX where we perform an early scan of objects and libraries to fetch
1137 the list of global ctors/dtors and make sure they are not garbage
1139 scanfilter ld1_filter
= SCAN_ALL
;
1144 const char **object
;
1149 bool use_verbose
= false;
1152 expandargv (&argc
, &argv
);
1153 if (argv
!= old_argv
)
1154 at_file_supplied
= 1;
1156 num_c_args
= argc
+ 9;
1158 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
1160 /* Suppress demangling by the real linker, which may be broken. */
1161 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1163 #if defined (COLLECT2_HOST_INITIALIZATION)
1164 /* Perform system dependent initialization, if necessary. */
1165 COLLECT2_HOST_INITIALIZATION
;
1169 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1170 receive the signal. A different setting is inheritable */
1171 signal (SIGCHLD
, SIG_DFL
);
1174 /* Unlock the stdio streams. */
1175 unlock_std_streams ();
1177 gcc_init_libintl ();
1179 /* Do not invoke xcalloc before this point, since locale needs to be
1180 set first, in case a diagnostic is issued. */
1182 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
1183 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
1184 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
1185 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
1186 object_lst
= XCNEWVEC (char *, argc
);
1187 object
= CONST_CAST2 (const char **, char **, object_lst
);
1193 /* Parse command line early for instances of -debug. This allows
1194 the debug flag to be set before functions like find_a_file()
1195 are called. We also look for the -flto or -flto-partition=none flag to know
1196 what LTO mode we are in. */
1199 bool no_partition
= false;
1201 for (i
= 1; argv
[i
] != NULL
; i
++)
1203 if (! strcmp (argv
[i
], "-debug"))
1205 else if (! strcmp (argv
[i
], "-flto-partition=none"))
1206 no_partition
= true;
1207 else if ((! strncmp (argv
[i
], "-flto=", 6)
1208 || ! strcmp (argv
[i
], "-flto")) && ! use_plugin
)
1211 lto_mode
= LTO_MODE_WHOPR
;
1213 else if (! strcmp (argv
[i
], "-plugin"))
1217 lto_mode
= LTO_MODE_NONE
;
1219 #ifdef COLLECT_EXPORT_LIST
1220 /* since -brtl, -bexport, -b64 are not position dependent
1221 also check for them here */
1222 if ((argv
[i
][0] == '-') && (argv
[i
][1] == 'b'))
1225 /* We want to disable automatic exports on AIX when user
1226 explicitly puts an export list in command line */
1227 if (arg
[2] == 'E' || strncmp (&arg
[2], "export", 6) == 0)
1229 else if (arg
[2] == '6' && arg
[3] == '4')
1231 else if (arg
[2] == 'r' && arg
[3] == 't' && arg
[4] == 'l')
1238 lto_mode
= LTO_MODE_LTO
;
1241 #ifndef DEFAULT_A_OUT_NAME
1242 output_file
= "a.out";
1244 output_file
= DEFAULT_A_OUT_NAME
;
1247 obstack_begin (&temporary_obstack
, 0);
1248 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1250 #ifndef HAVE_LD_DEMANGLE
1251 current_demangling_style
= auto_demangling
;
1253 p
= getenv ("COLLECT_GCC_OPTIONS");
1256 const char *q
= extract_string (&p
);
1257 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1260 obstack_free (&temporary_obstack
, temporary_firstobj
);
1262 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1263 -fno-exceptions -w -fno-whole-program */
1266 c_argv
= XCNEWVEC (char *, num_c_args
);
1267 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1270 fatal ("no arguments");
1273 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1274 signal (SIGQUIT
, handler
);
1276 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1277 signal (SIGINT
, handler
);
1279 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1280 signal (SIGALRM
, handler
);
1283 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1284 signal (SIGHUP
, handler
);
1286 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1287 signal (SIGSEGV
, handler
);
1289 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1290 signal (SIGBUS
, handler
);
1293 /* Extract COMPILER_PATH and PATH into our prefix list. */
1294 prefix_from_env ("COMPILER_PATH", &cpath
);
1295 prefix_from_env ("PATH", &path
);
1297 /* Try to discover a valid linker/nm/strip to use. */
1299 /* Maybe we know the right file to use (if not cross). */
1301 #ifdef DEFAULT_LINKER
1302 if (access (DEFAULT_LINKER
, X_OK
) == 0)
1303 ld_file_name
= DEFAULT_LINKER
;
1304 if (ld_file_name
== 0)
1306 #ifdef REAL_LD_FILE_NAME
1307 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
);
1308 if (ld_file_name
== 0)
1310 /* Search the (target-specific) compiler dirs for ld'. */
1311 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
);
1312 /* Likewise for `collect-ld'. */
1313 if (ld_file_name
== 0)
1314 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
);
1315 /* Search the compiler directories for `ld'. We have protection against
1316 recursive calls in find_a_file. */
1317 if (ld_file_name
== 0)
1318 ld_file_name
= find_a_file (&cpath
,
1322 /* Search the ordinary system bin directories
1323 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1324 if (ld_file_name
== 0)
1325 ld_file_name
= find_a_file (&path
,
1327 ? full_plugin_ld_suffix
1330 #ifdef REAL_NM_FILE_NAME
1331 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
);
1332 if (nm_file_name
== 0)
1334 nm_file_name
= find_a_file (&cpath
, gnm_suffix
);
1335 if (nm_file_name
== 0)
1336 nm_file_name
= find_a_file (&path
, full_gnm_suffix
);
1337 if (nm_file_name
== 0)
1338 nm_file_name
= find_a_file (&cpath
, nm_suffix
);
1339 if (nm_file_name
== 0)
1340 nm_file_name
= find_a_file (&path
, full_nm_suffix
);
1343 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
);
1344 if (ldd_file_name
== 0)
1345 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
);
1348 #ifdef REAL_STRIP_FILE_NAME
1349 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
);
1350 if (strip_file_name
== 0)
1352 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
);
1353 if (strip_file_name
== 0)
1354 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
);
1355 if (strip_file_name
== 0)
1356 strip_file_name
= find_a_file (&cpath
, strip_suffix
);
1357 if (strip_file_name
== 0)
1358 strip_file_name
= find_a_file (&path
, full_strip_suffix
);
1360 /* Determine the full path name of the C compiler to use. */
1361 c_file_name
= getenv ("COLLECT_GCC");
1362 if (c_file_name
== 0)
1364 #ifdef CROSS_DIRECTORY_STRUCTURE
1365 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1367 c_file_name
= "gcc";
1371 p
= find_a_file (&cpath
, c_file_name
);
1373 /* Here it should be safe to use the system search path since we should have
1374 already qualified the name of the compiler when it is needed. */
1376 p
= find_a_file (&path
, c_file_name
);
1381 *ld1
++ = *ld2
++ = ld_file_name
;
1383 /* Make temp file names. */
1384 c_file
= make_temp_file (".c");
1385 o_file
= make_temp_file (".o");
1386 #ifdef COLLECT_EXPORT_LIST
1387 export_file
= make_temp_file (".x");
1389 ldout
= make_temp_file (".ld");
1390 lderrout
= make_temp_file (".le");
1391 *c_ptr
++ = c_file_name
;
1398 #ifdef COLLECT_EXPORT_LIST
1399 /* Generate a list of directories from LIBPATH. */
1400 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1401 /* Add to this list also two standard directories where
1402 AIX loader always searches for libraries. */
1403 add_prefix (&libpath_lib_dirs
, "/lib");
1404 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1407 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1409 AIX support needs to know if -shared has been specified before
1410 parsing commandline arguments. */
1412 p
= getenv ("COLLECT_GCC_OPTIONS");
1415 const char *q
= extract_string (&p
);
1416 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1417 *c_ptr
++ = xstrdup (q
);
1418 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1419 *c_ptr
++ = xstrdup (q
);
1420 if (strcmp (q
, "-shared") == 0)
1422 if (*q
== '-' && q
[1] == 'B')
1424 *c_ptr
++ = xstrdup (q
);
1427 q
= extract_string (&p
);
1428 *c_ptr
++ = xstrdup (q
);
1431 if (use_verbose
&& *q
== '-' && q
[1] == 'v' && q
[2] == 0)
1433 /* Turn on trace in collect2 if needed. */
1437 obstack_free (&temporary_obstack
, temporary_firstobj
);
1438 *c_ptr
++ = "-fno-profile-arcs";
1439 *c_ptr
++ = "-fno-test-coverage";
1440 *c_ptr
++ = "-fno-branch-probabilities";
1441 *c_ptr
++ = "-fno-exceptions";
1443 *c_ptr
++ = "-fno-whole-program";
1445 /* !!! When GCC calls collect2,
1446 it does not know whether it is calling collect2 or ld.
1447 So collect2 cannot meaningfully understand any options
1448 except those ld understands.
1449 If you propose to make GCC pass some other option,
1450 just imagine what will happen if ld is really ld!!! */
1452 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1453 /* After the first file, put in the c++ rt0. */
1456 #ifdef HAVE_LD_DEMANGLE
1457 if (!demangle_flag
&& !no_demangle
)
1458 demangle_flag
= "--demangle";
1460 *ld1
++ = *ld2
++ = demangle_flag
;
1462 while ((arg
= *++argv
) != (char *) 0)
1464 *ld1
++ = *ld2
++ = arg
;
1471 if (!strcmp (arg
, "-debug"))
1473 /* Already parsed. */
1477 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1480 *ld1
++ = *ld2
++ = *argv
;
1485 if (strncmp (arg
, "-flto", 5) == 0)
1488 /* Do not pass LTO flag to the linker. */
1492 error ("LTO support has not been enabled in this "
1501 /* place o_file BEFORE this argument! */
1507 #ifdef COLLECT_EXPORT_LIST
1509 /* Resolving full library name. */
1510 const char *s
= resolve_lib_name (arg
+2);
1512 /* Saving a full library name. */
1513 add_to_list (&libs
, s
);
1518 #ifdef COLLECT_EXPORT_LIST
1519 /* Saving directories where to search for libraries. */
1521 add_prefix (&cmdline_lib_dirs
, arg
+2);
1524 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1526 if (is_in_args (arg
,
1527 CONST_CAST2 (const char **, char **, ld1_argv
),
1531 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1536 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1538 output_file
= &arg
[2];
1547 if (arg
[2] == '\0' && do_collecting
)
1549 /* We must strip after the nm run, otherwise C++ linking
1550 will not work. Thus we strip in the second ld run, or
1551 else with strip if there is no second ld run. */
1563 if (strcmp (arg
, "--no-demangle") == 0)
1565 demangle_flag
= arg
;
1570 else if (strncmp (arg
, "--demangle", 10) == 0)
1572 demangle_flag
= arg
;
1574 #ifndef HAVE_LD_DEMANGLE
1577 enum demangling_styles style
1578 = cplus_demangle_name_to_style (arg
+11);
1579 if (style
== unknown_demangling
)
1580 error ("unknown demangling style '%s'", arg
+11);
1582 current_demangling_style
= style
;
1588 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1589 target_system_root
= arg
+ 10;
1590 else if (strcmp (arg
, "--version") == 0)
1592 else if (strcmp (arg
, "--help") == 0)
1597 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1598 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1599 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1600 || strcmp (p
, ".obj") == 0))
1609 /* place o_file BEFORE this argument! */
1615 if (p
[1] == 'o' || p
[1] == 'l')
1617 #ifdef COLLECT_EXPORT_LIST
1618 /* libraries can be specified directly, i.e. without -l flag. */
1621 /* Saving a full library name. */
1622 add_to_list (&libs
, arg
);
1628 #ifdef COLLECT_EXPORT_LIST
1629 /* This is added only for debugging purposes. */
1632 fprintf (stderr
, "List of libraries:\n");
1633 dump_list (stderr
, "\t", libs
.first
);
1636 /* The AIX linker will discard static constructors in object files if
1637 nothing else in the file is referenced, so look at them first. Unless
1638 we are building a shared object, ignore the eh frame tables, as we
1639 would otherwise reference them all, hence drag all the corresponding
1640 objects even if nothing else is referenced. */
1642 const char **export_object_lst
1643 = CONST_CAST2 (const char **, char **, object_lst
);
1645 struct id
*list
= libs
.first
;
1647 /* Compute the filter to use from the current one, do scan, then adjust
1648 the "current" filter to remove what we just included here. This will
1649 control whether we need a first pass link later on or not, and what
1650 will remain to be scanned there. */
1652 scanfilter this_filter
= ld1_filter
;
1655 this_filter
&= ~SCAN_DWEH
;
1658 while (export_object_lst
< object
)
1659 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1661 for (; list
; list
= list
->next
)
1662 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1664 ld1_filter
= ld1_filter
& ~this_filter
;
1669 char *buf
= concat ("-bE:", export_file
, NULL
);
1674 exportf
= fopen (export_file
, "w");
1675 if (exportf
== (FILE *) 0)
1676 fatal_perror ("fopen %s", export_file
);
1677 write_aix_file (exportf
, exports
.first
);
1678 if (fclose (exportf
))
1679 fatal_perror ("fclose %s", export_file
);
1684 *c_ptr
= *ld1
= *object
= (char *) 0;
1688 notice ("collect2 version %s", version_string
);
1689 #ifdef TARGET_VERSION
1692 fprintf (stderr
, "\n");
1697 printf ("Usage: collect2 [options]\n");
1698 printf (" Wrap linker and generate constructor code if needed.\n");
1699 printf (" Options:\n");
1700 printf (" -debug Enable debug output\n");
1701 printf (" --help Display this information\n");
1702 printf (" -v, --version Display this program's version number\n");
1704 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1705 printf ("Report bugs: %s\n", bug_report_url
);
1712 fprintf (stderr
, "ld_file_name = %s\n",
1713 (ld_file_name
? ld_file_name
: "not found"));
1714 fprintf (stderr
, "c_file_name = %s\n",
1715 (c_file_name
? c_file_name
: "not found"));
1716 fprintf (stderr
, "nm_file_name = %s\n",
1717 (nm_file_name
? nm_file_name
: "not found"));
1719 fprintf (stderr
, "ldd_file_name = %s\n",
1720 (ldd_file_name
? ldd_file_name
: "not found"));
1722 fprintf (stderr
, "strip_file_name = %s\n",
1723 (strip_file_name
? strip_file_name
: "not found"));
1724 fprintf (stderr
, "c_file = %s\n",
1725 (c_file
? c_file
: "not found"));
1726 fprintf (stderr
, "o_file = %s\n",
1727 (o_file
? o_file
: "not found"));
1729 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1731 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1733 ptr
= getenv ("COLLECT_GCC");
1735 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1737 ptr
= getenv ("COMPILER_PATH");
1739 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1741 ptr
= getenv (LIBRARY_PATH_ENV
);
1743 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1745 fprintf (stderr
, "\n");
1748 /* Load the program, searching all libraries and attempting to provide
1749 undefined symbols from repository information.
1751 If -r or they will be run via some other method, do not build the
1752 constructor or destructor list, just return now. */
1755 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1757 /* Perform the first pass link now, if we're about to exit or if we need
1758 to scan for things we haven't collected yet before pursuing further.
1760 On AIX, the latter typically includes nothing for shared objects or
1761 frame tables for an executable, out of what the required early scan on
1762 objects and libraries has performed above. In the !shared_obj case, we
1763 expect the relevant tables to be dragged together with their associated
1764 functions from precise cross reference insertions by the compiler. */
1766 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1767 do_tlink (ld1_argv
, object_lst
);
1771 #ifdef COLLECT_EXPORT_LIST
1772 /* Make sure we delete the export file we may have created. */
1773 if (export_file
!= 0 && export_file
[0])
1774 maybe_unlink (export_file
);
1776 if (lto_mode
!= LTO_MODE_NONE
)
1777 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1779 maybe_unlink (c_file
);
1780 maybe_unlink (o_file
);
1785 /* Unless we have done it all already, examine the namelist and search for
1786 static constructors and destructors to call. Write the constructor and
1787 destructor tables to a .s file and reload. */
1789 if (ld1_filter
!= SCAN_NOTHING
)
1790 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1792 #ifdef SCAN_LIBRARIES
1793 scan_libraries (output_file
);
1798 notice_translated (ngettext ("%d constructor found\n",
1799 "%d constructors found\n",
1800 constructors
.number
),
1801 constructors
.number
);
1802 notice_translated (ngettext ("%d destructor found\n",
1803 "%d destructors found\n",
1804 destructors
.number
),
1805 destructors
.number
);
1806 notice_translated (ngettext("%d frame table found\n",
1807 "%d frame tables found\n",
1808 frame_tables
.number
),
1809 frame_tables
.number
);
1812 /* If the scan exposed nothing of special interest, there's no need to
1813 generate the glue code and relink so return now. */
1815 if (constructors
.number
== 0 && destructors
.number
== 0
1816 && frame_tables
.number
== 0
1817 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1818 /* If we will be running these functions ourselves, we want to emit
1819 stubs into the shared library so that we do not have to relink
1820 dependent programs when we add static objects. */
1825 /* Do tlink without additional code generation now if we didn't
1826 do it earlier for scanning purposes. */
1827 if (ld1_filter
== SCAN_NOTHING
)
1828 do_tlink (ld1_argv
, object_lst
);
1831 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1833 /* Strip now if it was requested on the command line. */
1836 char **real_strip_argv
= XCNEWVEC (char *, 3);
1837 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1840 strip_argv
[0] = strip_file_name
;
1841 strip_argv
[1] = output_file
;
1842 strip_argv
[2] = (char *) 0;
1843 fork_execute ("strip", real_strip_argv
);
1846 #ifdef COLLECT_EXPORT_LIST
1847 maybe_unlink (export_file
);
1849 maybe_unlink (c_file
);
1850 maybe_unlink (o_file
);
1854 /* Sort ctor and dtor lists by priority. */
1855 sort_ids (&constructors
);
1856 sort_ids (&destructors
);
1858 maybe_unlink(output_file
);
1859 outf
= fopen (c_file
, "w");
1860 if (outf
== (FILE *) 0)
1861 fatal_perror ("fopen %s", c_file
);
1863 write_c_file (outf
, c_file
);
1866 fatal_perror ("fclose %s", c_file
);
1868 /* Tell the linker that we have initializer and finalizer functions. */
1869 #ifdef LD_INIT_SWITCH
1870 #ifdef COLLECT_EXPORT_LIST
1871 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1873 *ld2
++ = LD_INIT_SWITCH
;
1875 *ld2
++ = LD_FINI_SWITCH
;
1880 #ifdef COLLECT_EXPORT_LIST
1883 /* If we did not add export flag to link arguments before, add it to
1884 second link phase now. No new exports should have been added. */
1885 if (! exports
.first
)
1886 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1888 #ifndef LD_INIT_SWITCH
1889 add_to_list (&exports
, initname
);
1890 add_to_list (&exports
, fininame
);
1891 add_to_list (&exports
, "_GLOBAL__DI");
1892 add_to_list (&exports
, "_GLOBAL__DD");
1894 exportf
= fopen (export_file
, "w");
1895 if (exportf
== (FILE *) 0)
1896 fatal_perror ("fopen %s", export_file
);
1897 write_aix_file (exportf
, exports
.first
);
1898 if (fclose (exportf
))
1899 fatal_perror ("fclose %s", export_file
);
1903 /* End of arguments to second link phase. */
1908 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1909 output_file
, c_file
);
1910 write_c_file (stderr
, "stderr");
1911 fprintf (stderr
, "========== end of c_file\n\n");
1912 #ifdef COLLECT_EXPORT_LIST
1913 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1914 write_aix_file (stderr
, exports
.first
);
1915 fprintf (stderr
, "========== end of export_file\n\n");
1919 /* Assemble the constructor and destructor tables.
1920 Link the tables in with the rest of the program. */
1922 fork_execute ("gcc", c_argv
);
1923 #ifdef COLLECT_EXPORT_LIST
1924 /* On AIX we must call tlink because of possible templates resolution. */
1925 do_tlink (ld2_argv
, object_lst
);
1928 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1930 /* Otherwise, simply call ld because tlink is already done. */
1932 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1934 fork_execute ("ld", ld2_argv
);
1936 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1937 constructors/destructors in shared libraries. */
1938 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1941 maybe_unlink (c_file
);
1942 maybe_unlink (o_file
);
1944 #ifdef COLLECT_EXPORT_LIST
1945 maybe_unlink (export_file
);
1952 /* Wait for a process to finish, and exit if a nonzero status is found. */
1955 collect_wait (const char *prog
, struct pex_obj
*pex
)
1959 if (!pex_get_status (pex
, 1, &status
))
1960 fatal_perror ("can't get program status");
1965 if (WIFSIGNALED (status
))
1967 int sig
= WTERMSIG (status
);
1968 error ("%s terminated with signal %d [%s]%s",
1969 prog
, sig
, strsignal(sig
),
1970 WCOREDUMP(status
) ? ", core dumped" : "");
1971 collect_exit (FATAL_EXIT_CODE
);
1974 if (WIFEXITED (status
))
1975 return WEXITSTATUS (status
);
1981 do_wait (const char *prog
, struct pex_obj
*pex
)
1983 int ret
= collect_wait (prog
, pex
);
1986 error ("%s returned %d exit status", prog
, ret
);
1992 unlink (response_file
);
1993 response_file
= NULL
;
1998 /* Execute a program, and wait for the reply. */
2001 collect_execute (const char *prog
, char **argv
, const char *outname
,
2002 const char *errname
, int flags
)
2004 struct pex_obj
*pex
;
2007 char *response_arg
= NULL
;
2008 char *response_argv
[3] ATTRIBUTE_UNUSED
;
2010 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
2012 /* If using @file arguments, create a temporary file and put the
2013 contents of argv into it. Then change argv to an array corresponding
2014 to a single argument @FILE, where FILE is the temporary filename. */
2016 char **current_argv
= argv
+ 1;
2017 char *argv0
= argv
[0];
2021 /* Note: we assume argv contains at least one element; this is
2024 response_file
= make_temp_file ("");
2026 f
= fopen (response_file
, "w");
2029 fatal ("could not open response file %s", response_file
);
2031 status
= writeargv (current_argv
, f
);
2034 fatal ("could not write to response file %s", response_file
);
2036 status
= fclose (f
);
2039 fatal ("could not close response file %s", response_file
);
2041 response_arg
= concat ("@", response_file
, NULL
);
2042 response_argv
[0] = argv0
;
2043 response_argv
[1] = response_arg
;
2044 response_argv
[2] = NULL
;
2046 argv
= response_argv
;
2055 fprintf (stderr
, "%s", argv
[0]);
2057 notice ("[cannot find %s]", prog
);
2059 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2060 fprintf (stderr
, " %s", str
);
2062 fprintf (stderr
, "\n");
2068 /* If we cannot find a program we need, complain error. Do this here
2069 since we might not end up needing something that we could not find. */
2072 fatal ("cannot find '%s'", prog
);
2074 pex
= pex_init (0, "collect2", NULL
);
2076 fatal_perror ("pex_init failed");
2078 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
2085 fatal_perror (errmsg
);
2092 free (response_arg
);
2098 fork_execute (const char *prog
, char **argv
)
2100 struct pex_obj
*pex
;
2102 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
2103 do_wait (prog
, pex
);
2106 /* Unlink a file unless we are debugging. */
2109 maybe_unlink (const char *file
)
2112 unlink_if_ordinary (file
);
2114 notice ("[Leaving %s]\n", file
);
2117 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2120 maybe_unlink_list (char **file_list
)
2122 char **tmp
= file_list
;
2125 maybe_unlink (*(tmp
++));
2129 static long sequence_number
= 0;
2131 /* Add a name to a linked list. */
2134 add_to_list (struct head
*head_ptr
, const char *name
)
2137 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2139 strcpy (newid
->name
, name
);
2141 if (head_ptr
->first
)
2142 head_ptr
->last
->next
= newid
;
2144 head_ptr
->first
= newid
;
2146 /* Check for duplicate symbols. */
2147 for (p
= head_ptr
->first
;
2148 strcmp (name
, p
->name
) != 0;
2153 head_ptr
->last
->next
= 0;
2158 newid
->sequence
= ++sequence_number
;
2159 head_ptr
->last
= newid
;
2163 /* Grab the init priority number from an init function name that
2164 looks like "_GLOBAL_.I.12345.foo". */
2167 extract_init_priority (const char *name
)
2171 while (name
[pos
] == '_')
2173 pos
+= 10; /* strlen ("GLOBAL__X_") */
2175 /* Extract init_p number from ctor/dtor name. */
2176 pri
= atoi (name
+ pos
);
2177 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2180 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2181 ctors will be run from right to left, dtors from left to right. */
2184 sort_ids (struct head
*head_ptr
)
2186 /* id holds the current element to insert. id_next holds the next
2187 element to insert. id_ptr iterates through the already sorted elements
2188 looking for the place to insert id. */
2189 struct id
*id
, *id_next
, **id_ptr
;
2191 id
= head_ptr
->first
;
2193 /* We don't have any sorted elements yet. */
2194 head_ptr
->first
= NULL
;
2196 for (; id
; id
= id_next
)
2199 id
->sequence
= extract_init_priority (id
->name
);
2201 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2203 /* If the sequence numbers are the same, we put the id from the
2204 file later on the command line later in the list. */
2205 || id
->sequence
> (*id_ptr
)->sequence
2206 /* Hack: do lexical compare, too.
2207 || (id->sequence == (*id_ptr)->sequence
2208 && strcmp (id->name, (*id_ptr)->name) > 0) */
2217 /* Now set the sequence numbers properly so write_c_file works. */
2218 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2219 id
->sequence
= ++sequence_number
;
2222 /* Write: `prefix', the names on list LIST, `suffix'. */
2225 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2229 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2234 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2235 /* Given a STRING, return nonzero if it occurs in the list in range
2236 [ARGS_BEGIN,ARGS_END). */
2239 is_in_args (const char *string
, const char **args_begin
,
2240 const char **args_end
)
2242 const char **args_pointer
;
2243 for (args_pointer
= args_begin
; args_pointer
!= args_end
; ++args_pointer
)
2244 if (strcmp (string
, *args_pointer
) == 0)
2248 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2250 #ifdef COLLECT_EXPORT_LIST
2251 /* This function is really used only on AIX, but may be useful. */
2254 is_in_list (const char *prefix
, struct id
*list
)
2258 if (!strcmp (prefix
, list
->name
)) return 1;
2264 #endif /* COLLECT_EXPORT_LIST */
2266 /* Added for debugging purpose. */
2267 #ifdef COLLECT_EXPORT_LIST
2269 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2273 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2281 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2285 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2292 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2296 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2297 prefix
, list
->sequence
, list
->name
);
2302 /* Write out the constructor and destructor tables statically (for a shared
2303 object), along with the functions to execute them. */
2306 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2310 int frames
= (frame_tables
.number
> 0);
2312 /* Figure out name of output_file, stripping off .so version. */
2313 p
= strrchr (output_file
, '/');
2329 if (strncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2331 q
+= strlen (SHLIB_SUFFIX
);
2338 /* q points to null at end of the string (or . of the .so version) */
2339 prefix
= XNEWVEC (char, q
- p
+ 1);
2340 strncpy (prefix
, p
, q
- p
);
2342 for (r
= prefix
; *r
; r
++)
2343 if (!ISALNUM ((unsigned char)*r
))
2346 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2347 output_file
, prefix
);
2349 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2350 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2354 /* Write the tables as C code. */
2356 fprintf (stream
, "static int count;\n");
2357 fprintf (stream
, "typedef void entry_pt();\n");
2358 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2362 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2364 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2365 write_list (stream
, "\t\t&", frame_tables
.first
);
2366 fprintf (stream
, "\t0\n};\n");
2368 /* This must match what's in frame.h. */
2369 fprintf (stream
, "struct object {\n");
2370 fprintf (stream
, " void *pc_begin;\n");
2371 fprintf (stream
, " void *pc_end;\n");
2372 fprintf (stream
, " void *fde_begin;\n");
2373 fprintf (stream
, " void *fde_array;\n");
2374 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2375 fprintf (stream
, " struct object *next;\n");
2376 fprintf (stream
, "};\n");
2378 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2379 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2381 fprintf (stream
, "static void reg_frame () {\n");
2382 fprintf (stream
, "\tstatic struct object ob;\n");
2383 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2384 fprintf (stream
, "\t}\n");
2386 fprintf (stream
, "static void dereg_frame () {\n");
2387 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2388 fprintf (stream
, "\t}\n");
2391 fprintf (stream
, "void %s() {\n", initname
);
2392 if (constructors
.number
> 0 || frames
)
2394 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2395 write_list (stream
, "\t\t", constructors
.first
);
2397 fprintf (stream
, "\treg_frame,\n");
2398 fprintf (stream
, "\t};\n");
2399 fprintf (stream
, "\tentry_pt **p;\n");
2400 fprintf (stream
, "\tif (count++ != 0) return;\n");
2401 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2402 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2405 fprintf (stream
, "\t++count;\n");
2406 fprintf (stream
, "}\n");
2407 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2408 fprintf (stream
, "void %s() {\n", fininame
);
2409 if (destructors
.number
> 0 || frames
)
2411 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2412 write_list (stream
, "\t\t", destructors
.first
);
2414 fprintf (stream
, "\tdereg_frame,\n");
2415 fprintf (stream
, "\t};\n");
2416 fprintf (stream
, "\tentry_pt **p;\n");
2417 fprintf (stream
, "\tif (--count != 0) return;\n");
2418 fprintf (stream
, "\tp = dtors;\n");
2419 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2420 destructors
.number
+ frames
);
2422 fprintf (stream
, "}\n");
2426 COLLECT_SHARED_INIT_FUNC(stream
, initname
);
2427 COLLECT_SHARED_FINI_FUNC(stream
, fininame
);
2431 /* Write the constructor/destructor tables. */
2433 #ifndef LD_INIT_SWITCH
2435 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2437 /* Write the tables as C code. */
2439 int frames
= (frame_tables
.number
> 0);
2441 fprintf (stream
, "typedef void entry_pt();\n\n");
2443 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2447 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2449 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2450 write_list (stream
, "\t\t&", frame_tables
.first
);
2451 fprintf (stream
, "\t0\n};\n");
2453 /* This must match what's in frame.h. */
2454 fprintf (stream
, "struct object {\n");
2455 fprintf (stream
, " void *pc_begin;\n");
2456 fprintf (stream
, " void *pc_end;\n");
2457 fprintf (stream
, " void *fde_begin;\n");
2458 fprintf (stream
, " void *fde_array;\n");
2459 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2460 fprintf (stream
, " struct object *next;\n");
2461 fprintf (stream
, "};\n");
2463 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2464 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2466 fprintf (stream
, "static void reg_frame () {\n");
2467 fprintf (stream
, "\tstatic struct object ob;\n");
2468 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2469 fprintf (stream
, "\t}\n");
2471 fprintf (stream
, "static void dereg_frame () {\n");
2472 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2473 fprintf (stream
, "\t}\n");
2476 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2477 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2478 write_list (stream
, "\t", constructors
.first
);
2480 fprintf (stream
, "\treg_frame,\n");
2481 fprintf (stream
, "\t0\n};\n\n");
2483 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2485 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2486 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2487 write_list (stream
, "\t", destructors
.first
);
2489 fprintf (stream
, "\tdereg_frame,\n");
2490 fprintf (stream
, "\t0\n};\n\n");
2492 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2493 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2495 #endif /* ! LD_INIT_SWITCH */
2498 write_c_file (FILE *stream
, const char *name
)
2500 #ifndef LD_INIT_SWITCH
2502 write_c_file_glob (stream
, name
);
2505 write_c_file_stat (stream
, name
);
2508 #ifdef COLLECT_EXPORT_LIST
2510 write_aix_file (FILE *stream
, struct id
*list
)
2512 for (; list
; list
= list
->next
)
2514 fputs (list
->name
, stream
);
2515 putc ('\n', stream
);
2520 #ifdef OBJECT_FORMAT_NONE
2522 /* Check to make sure the file is an LTO object file. */
2525 maybe_lto_object_file (const char *prog_name
)
2528 unsigned char buf
[4];
2531 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2532 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2533 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2534 static unsigned char machomagic
[4][4] = {
2535 { 0xcf, 0xfa, 0xed, 0xfe },
2536 { 0xce, 0xfa, 0xed, 0xfe },
2537 { 0xfe, 0xed, 0xfa, 0xcf },
2538 { 0xfe, 0xed, 0xfa, 0xce }
2541 f
= fopen (prog_name
, "rb");
2544 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2548 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2549 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2550 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2552 for (i
= 0; i
< 4; i
++)
2553 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2559 /* Generic version to scan the name list of the loaded program for
2560 the symbols g++ uses for static constructors and destructors. */
2563 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2566 void (*int_handler
) (int);
2568 void (*quit_handler
) (int);
2570 char *real_nm_argv
[4];
2571 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2573 struct pex_obj
*pex
;
2580 if (which_pass
== PASS_SECOND
)
2583 /* LTO objects must be in a known format. This check prevents
2584 us from accepting an archive containing LTO objects, which
2585 gcc cannnot currently handle. */
2586 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2589 /* If we do not have an `nm', complain. */
2590 if (nm_file_name
== 0)
2591 fatal ("cannot find 'nm'");
2593 nm_argv
[argc
++] = nm_file_name
;
2594 if (NM_FLAGS
[0] != '\0')
2595 nm_argv
[argc
++] = NM_FLAGS
;
2597 nm_argv
[argc
++] = prog_name
;
2598 nm_argv
[argc
++] = (char *) 0;
2600 /* Trace if needed. */
2603 const char **p_argv
;
2606 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2607 fprintf (stderr
, " %s", str
);
2609 fprintf (stderr
, "\n");
2615 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2617 fatal_perror ("pex_init failed");
2619 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2626 fatal_perror (errmsg
);
2632 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2634 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2637 inf
= pex_read_output (pex
, 0);
2639 fatal_perror ("can't open nm output");
2643 if (which_pass
== PASS_LTOINFO
)
2644 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2646 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2649 /* Read each line of nm output. */
2650 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2656 fprintf (stderr
, "\t%s\n", buf
);
2658 if (which_pass
== PASS_LTOINFO
)
2663 /* Look for the LTO info marker symbol, and add filename to
2664 the LTO objects list if found. */
2665 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2666 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2667 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2668 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2670 add_lto_object (<o_objects
, prog_name
);
2672 /* We need to read all the input, so we can't just
2673 return here. But we can avoid useless work. */
2682 /* If it contains a constructor or destructor name, add the name
2683 to the appropriate list unless this is a kind of symbol we're
2684 not supposed to even consider. */
2686 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2687 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2694 /* Find the end of the symbol name.
2695 Do not include `|', because Encore nm can tack that on the end. */
2696 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2702 switch (is_ctor_dtor (name
))
2705 if (! (filter
& SCAN_CTOR
))
2707 if (which_pass
!= PASS_LIB
)
2708 add_to_list (&constructors
, name
);
2712 if (! (filter
& SCAN_DTOR
))
2714 if (which_pass
!= PASS_LIB
)
2715 add_to_list (&destructors
, name
);
2719 if (! (filter
& SCAN_INIT
))
2721 if (which_pass
!= PASS_LIB
)
2722 fatal ("init function found in object %s", prog_name
);
2723 #ifndef LD_INIT_SWITCH
2724 add_to_list (&constructors
, name
);
2729 if (! (filter
& SCAN_FINI
))
2731 if (which_pass
!= PASS_LIB
)
2732 fatal ("fini function found in object %s", prog_name
);
2733 #ifndef LD_FINI_SWITCH
2734 add_to_list (&destructors
, name
);
2739 if (! (filter
& SCAN_DWEH
))
2741 if (which_pass
!= PASS_LIB
)
2742 add_to_list (&frame_tables
, name
);
2745 default: /* not a constructor or destructor */
2751 fprintf (stderr
, "\n");
2753 do_wait (nm_file_name
, pex
);
2755 signal (SIGINT
, int_handler
);
2757 signal (SIGQUIT
, quit_handler
);
2763 /* Use the List Dynamic Dependencies program to find shared libraries that
2764 the output file depends upon and their initialization/finalization
2765 routines, if any. */
2768 scan_libraries (const char *prog_name
)
2770 static struct head libraries
; /* list of shared libraries found */
2772 void (*int_handler
) (int);
2774 void (*quit_handler
) (int);
2776 char *real_ldd_argv
[4];
2777 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2779 struct pex_obj
*pex
;
2785 /* If we do not have an `ldd', complain. */
2786 if (ldd_file_name
== 0)
2788 error ("cannot find 'ldd'");
2792 ldd_argv
[argc
++] = ldd_file_name
;
2793 ldd_argv
[argc
++] = prog_name
;
2794 ldd_argv
[argc
++] = (char *) 0;
2796 /* Trace if needed. */
2799 const char **p_argv
;
2802 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2803 fprintf (stderr
, " %s", str
);
2805 fprintf (stderr
, "\n");
2811 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2813 fatal_perror ("pex_init failed");
2815 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2821 fatal_perror (errmsg
);
2827 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2829 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2832 inf
= pex_read_output (pex
, 0);
2834 fatal_perror ("can't open ldd output");
2837 notice ("\nldd output with constructors/destructors.\n");
2839 /* Read each line of ldd output. */
2840 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2843 char *name
, *end
, *p
= buf
;
2845 /* Extract names of libraries and add to list. */
2846 PARSE_LDD_OUTPUT (p
);
2851 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2852 fatal ("dynamic dependency %s not found", buf
);
2854 /* Find the end of the symbol name. */
2856 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2861 if (access (name
, R_OK
) == 0)
2862 add_to_list (&libraries
, name
);
2864 fatal ("unable to open dynamic dependency '%s'", buf
);
2867 fprintf (stderr
, "\t%s\n", buf
);
2870 fprintf (stderr
, "\n");
2872 do_wait (ldd_file_name
, pex
);
2874 signal (SIGINT
, int_handler
);
2876 signal (SIGQUIT
, quit_handler
);
2879 /* Now iterate through the library list adding their symbols to
2881 for (list
= libraries
.first
; list
; list
= list
->next
)
2882 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2885 #endif /* LDD_SUFFIX */
2887 #endif /* OBJECT_FORMAT_NONE */
2891 * COFF specific stuff.
2894 #ifdef OBJECT_FORMAT_COFF
2896 #if defined (EXTENDED_COFF)
2898 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2899 # define GCC_SYMENT SYMR
2900 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2901 # define GCC_SYMINC(X) (1)
2902 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2903 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2907 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2908 # define GCC_SYMENT SYMENT
2909 # if defined (C_WEAKEXT)
2910 # define GCC_OK_SYMBOL(X) \
2911 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2912 ((X).n_scnum > N_UNDEF) && \
2914 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2915 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2916 # define GCC_UNDEF_SYMBOL(X) \
2917 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2918 ((X).n_scnum == N_UNDEF))
2920 # define GCC_OK_SYMBOL(X) \
2921 (((X).n_sclass == C_EXT) && \
2922 ((X).n_scnum > N_UNDEF) && \
2924 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2925 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2926 # define GCC_UNDEF_SYMBOL(X) \
2927 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2929 # define GCC_SYMINC(X) ((X).n_numaux+1)
2930 # define GCC_SYMZERO(X) 0
2932 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2933 #if TARGET_AIX_VERSION >= 51
2934 # define GCC_CHECK_HDR(X) \
2935 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2936 || (HEADER (X).f_magic == 0767 && aix64_flag))
2938 # define GCC_CHECK_HDR(X) \
2939 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2940 || (HEADER (X).f_magic == 0757 && aix64_flag))
2945 #ifdef COLLECT_EXPORT_LIST
2946 /* Array of standard AIX libraries which should not
2947 be scanned for ctors/dtors. */
2948 static const char *const aix_std_libs
[] = {
2956 "/usr/lib/libc_r.a",
2957 "/usr/lib/libm_r.a",
2958 "/usr/lib/threads/libc.a",
2959 "/usr/ccs/lib/libc.a",
2960 "/usr/ccs/lib/libm.a",
2961 "/usr/ccs/lib/libc_r.a",
2962 "/usr/ccs/lib/libm_r.a",
2966 /* This function checks the filename and returns 1
2967 if this name matches the location of a standard AIX library. */
2968 static int ignore_library (const char *);
2970 ignore_library (const char *name
)
2972 const char *const *p
;
2975 if (target_system_root
[0] != '\0')
2977 length
= strlen (target_system_root
);
2978 if (strncmp (name
, target_system_root
, length
) != 0)
2982 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2983 if (strcmp (name
, *p
) == 0)
2987 #endif /* COLLECT_EXPORT_LIST */
2989 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2990 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2993 /* COFF version to scan the name list of the loaded program for
2994 the symbols g++ uses for static constructors and destructors. */
2997 scan_prog_file (const char *prog_name
, scanpass which_pass
,
3000 LDFILE
*ldptr
= NULL
;
3001 int sym_index
, sym_count
;
3004 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
3007 #ifdef COLLECT_EXPORT_LIST
3008 /* We do not need scanning for some standard C libraries. */
3009 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
3012 /* On AIX we have a loop, because there is not much difference
3013 between an object and an archive. This trick allows us to
3014 eliminate scan_libraries() function. */
3018 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3019 non-const char * filename parameter, even though it will not
3020 modify that string. So we must cast away const-ness here,
3021 using CONST_CAST to prevent complaints from -Wcast-qual. */
3022 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
3024 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
3025 fatal ("%s: not a COFF file", prog_name
);
3027 if (GCC_CHECK_HDR (ldptr
))
3029 sym_count
= GCC_SYMBOLS (ldptr
);
3030 sym_index
= GCC_SYMZERO (ldptr
);
3032 #ifdef COLLECT_EXPORT_LIST
3033 /* Is current archive member a shared object? */
3034 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
3037 while (sym_index
< sym_count
)
3041 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
3043 sym_index
+= GCC_SYMINC (symbol
);
3045 if (GCC_OK_SYMBOL (symbol
))
3049 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
3050 continue; /* Should never happen. */
3052 #ifdef XCOFF_DEBUGGING_INFO
3053 /* All AIX function names have a duplicate entry
3054 beginning with a dot. */
3059 switch (is_ctor_dtor (name
))
3062 if (! (filter
& SCAN_CTOR
))
3065 add_to_list (&constructors
, name
);
3066 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3067 if (which_pass
== PASS_OBJ
)
3068 add_to_list (&exports
, name
);
3073 if (! (filter
& SCAN_DTOR
))
3076 add_to_list (&destructors
, name
);
3077 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3078 if (which_pass
== PASS_OBJ
)
3079 add_to_list (&exports
, name
);
3083 #ifdef COLLECT_EXPORT_LIST
3085 if (! (filter
& SCAN_INIT
))
3087 #ifndef LD_INIT_SWITCH
3089 add_to_list (&constructors
, name
);
3094 if (! (filter
& SCAN_FINI
))
3096 #ifndef LD_INIT_SWITCH
3098 add_to_list (&destructors
, name
);
3104 if (! (filter
& SCAN_DWEH
))
3107 add_to_list (&frame_tables
, name
);
3108 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3109 if (which_pass
== PASS_OBJ
)
3110 add_to_list (&exports
, name
);
3114 default: /* not a constructor or destructor */
3115 #ifdef COLLECT_EXPORT_LIST
3116 /* Explicitly export all global symbols when
3117 building a shared object on AIX, but do not
3118 re-export symbols from another shared object
3119 and do not export symbols if the user
3120 provides an explicit export list. */
3121 if (shared_obj
&& !is_shared
3122 && which_pass
== PASS_OBJ
&& !export_flag
)
3123 add_to_list (&exports
, name
);
3129 #if !defined(EXTENDED_COFF)
3130 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3131 symbol
.n_scnum
, symbol
.n_sclass
,
3132 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3136 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3137 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3142 #ifdef COLLECT_EXPORT_LIST
3145 /* If archive contains both 32-bit and 64-bit objects,
3146 we want to skip objects in other mode so mismatch normal. */
3148 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3149 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3155 fatal ("%s: cannot open as COFF file", prog_name
);
3157 #ifdef COLLECT_EXPORT_LIST
3158 /* On AIX loop continues while there are more members in archive. */
3160 while (ldclose (ldptr
) == FAILURE
);
3162 /* Otherwise we simply close ldptr. */
3163 (void) ldclose(ldptr
);
3166 #endif /* OBJECT_FORMAT_COFF */
3168 #ifdef COLLECT_EXPORT_LIST
3169 /* Given a library name without "lib" prefix, this function
3170 returns a full library name including a path. */
3172 resolve_lib_name (const char *name
)
3176 /* Library extensions for AIX dynamic linking. */
3177 const char * const libexts
[2] = {"a", "so"};
3179 for (i
= 0; libpaths
[i
]; i
++)
3180 if (libpaths
[i
]->max_len
> l
)
3181 l
= libpaths
[i
]->max_len
;
3183 lib_buf
= XNEWVEC (char, l
+ strlen(name
) + 10);
3185 for (i
= 0; libpaths
[i
]; i
++)
3187 struct prefix_list
*list
= libpaths
[i
]->plist
;
3188 for (; list
; list
= list
->next
)
3190 /* The following lines are needed because path_prefix list
3191 may contain directories both with trailing '/' and
3194 if (list
->prefix
[strlen(list
->prefix
)-1] != '/')
3196 for (j
= 0; j
< 2; j
++)
3198 sprintf (lib_buf
, "%s%slib%s.%s",
3199 list
->prefix
, p
, name
,
3200 libexts
[(j
+ aixrtl_flag
) % 2]);
3201 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3202 if (file_exists (lib_buf
))
3204 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3211 fprintf (stderr
, "not found\n");
3213 fatal ("library lib%s not found", name
);
3216 #endif /* COLLECT_EXPORT_LIST */