1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
6 Contributed by Chris Smith (csmith@convex.com).
7 Heavily modified by Michael Meissner (meissner@cygnus.com),
8 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
27 /* Build tables of static constructors and destructors and run ld. */
31 #include "coretypes.h"
34 #if ! defined( SIGCHLD ) && defined( SIGCLD )
35 # define SIGCHLD SIGCLD
38 /* TARGET_64BIT may be defined to use driver specific functionality. */
40 #define TARGET_64BIT TARGET_64BIT_DEFAULT
42 #ifndef LIBRARY_PATH_ENV
43 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
49 #include "collect2-aix.h"
55 /* On certain systems, we have code that works by scanning the object file
56 directly. But this code uses system-specific header files and library
57 functions, so turn it off in a cross-compiler. Likewise, the names of
58 the utilities are not correct for a cross-compiler; we have to hope that
59 cross-versions are in the proper directories. */
61 #ifdef CROSS_DIRECTORY_STRUCTURE
62 #ifndef CROSS_AIX_SUPPORT
63 #undef OBJECT_FORMAT_COFF
66 #undef REAL_LD_FILE_NAME
67 #undef REAL_NM_FILE_NAME
68 #undef REAL_STRIP_FILE_NAME
71 /* If we cannot use a special method, use the ordinary one:
72 run nm to find what symbols are present.
73 In a cross-compiler, this means you need a cross nm,
74 but that is not quite as unpleasant as special headers. */
76 #if !defined (OBJECT_FORMAT_COFF)
77 #define OBJECT_FORMAT_NONE
80 #ifdef OBJECT_FORMAT_COFF
82 #ifndef CROSS_DIRECTORY_STRUCTURE
90 /* Many versions of ldfcn.h define these. */
99 /* Some systems have an ISCOFF macro, but others do not. In some cases
100 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
101 that either do not have an ISCOFF macro in /usr/include or for those
102 where it is wrong. */
105 #define MY_ISCOFF(X) ISCOFF (X)
108 #endif /* OBJECT_FORMAT_COFF */
110 #ifdef OBJECT_FORMAT_NONE
112 /* Default flags to pass to nm. */
114 #define NM_FLAGS "-n"
117 #endif /* OBJECT_FORMAT_NONE */
119 /* Some systems use __main in a way incompatible with its use in gcc, in these
120 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
121 give the same symbol without quotes for an alternative entry point. */
123 #define NAME__MAIN "__main"
126 /* This must match tree.h. */
127 #define DEFAULT_INIT_PRIORITY 65535
129 #ifndef COLLECT_SHARED_INIT_FUNC
130 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
133 #ifndef COLLECT_SHARED_FINI_FUNC
134 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
135 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
139 #define SCAN_LIBRARIES
143 #define SHLIB_SUFFIX ".so"
147 int do_collecting
= 1;
149 int do_collecting
= 0;
152 /* Cook up an always defined indication of whether we proceed the
153 "EXPORT_LIST" way. */
155 #ifdef COLLECT_EXPORT_LIST
156 #define DO_COLLECT_EXPORT_LIST 1
158 #define DO_COLLECT_EXPORT_LIST 0
161 /* Nonzero if we should suppress the automatic demangling of identifiers
162 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
165 /* Linked lists of constructor and destructor names. */
181 bool vflag
; /* true if -v or --version */
182 static int rflag
; /* true if -r */
183 static int strip_flag
; /* true if -s */
184 static const char *demangle_flag
;
185 #ifdef COLLECT_EXPORT_LIST
186 static int export_flag
; /* true if -bE */
187 static int aix64_flag
; /* true if -b64 */
188 static int aixrtl_flag
; /* true if -brtl */
192 LTO_MODE_NONE
, /* Not doing LTO. */
193 LTO_MODE_LTO
, /* Normal LTO. */
194 LTO_MODE_WHOPR
/* WHOPR. */
197 /* Current LTO mode. */
198 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
200 bool debug
; /* true if -debug */
201 bool helpflag
; /* true if --help */
203 static int shared_obj
; /* true if -shared */
205 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
206 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
207 #ifdef COLLECT_EXPORT_LIST
208 static const char *export_file
; /* <xxx>.x for AIX export list. */
210 static char **lto_o_files
; /* Output files for LTO. */
211 const char *ldout
; /* File for ld stdout. */
212 const char *lderrout
; /* File for ld stderr. */
213 static const char *output_file
; /* Output file for ld. */
214 static const char *nm_file_name
; /* pathname of nm */
216 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
218 static const char *strip_file_name
; /* pathname of strip */
219 const char *c_file_name
; /* pathname of gcc */
220 static char *initname
, *fininame
; /* names of init and fini funcs */
222 static struct head constructors
; /* list of constructors found */
223 static struct head destructors
; /* list of destructors found */
224 #ifdef COLLECT_EXPORT_LIST
225 static struct head exports
; /* list of exported symbols */
227 static struct head frame_tables
; /* list of frame unwind info tables */
229 static bool at_file_supplied
; /* Whether to use @file arguments */
230 static char *response_file
; /* Name of any current response file */
232 struct obstack temporary_obstack
;
233 char * temporary_firstobj
;
235 /* A string that must be prepended to a target OS path in order to find
236 it on the host system. */
237 #ifdef TARGET_SYSTEM_ROOT
238 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
240 static const char *target_system_root
= "";
243 /* Structure to hold all the directories in which to search for files to
248 const char *prefix
; /* String to prepend to the path. */
249 struct prefix_list
*next
; /* Next in linked list. */
254 struct prefix_list
*plist
; /* List of prefixes to try */
255 int max_len
; /* Max length of a prefix in PLIST */
256 const char *name
; /* Name of this list (used in config stuff) */
259 #ifdef COLLECT_EXPORT_LIST
260 /* Lists to keep libraries to be scanned for global constructors/destructors. */
261 static struct head libs
; /* list of libraries */
262 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
263 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
264 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
265 &libpath_lib_dirs
, NULL
};
268 /* List of names of object files containing LTO information.
269 These are a subset of the object file names appearing on the
270 command line, and must be identical, in the sense of pointer
271 equality, with the names passed to maybe_run_lto_and_relink(). */
275 const char *name
; /* Name of object file. */
276 struct lto_object
*next
; /* Next in linked list. */
279 struct lto_object_list
281 struct lto_object
*first
; /* First list element. */
282 struct lto_object
*last
; /* Last list element. */
285 static struct lto_object_list lto_objects
;
287 /* Special kinds of symbols that a name may denote. */
290 SYM_REGULAR
= 0, /* nothing special */
292 SYM_CTOR
= 1, /* constructor */
293 SYM_DTOR
= 2, /* destructor */
294 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
295 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
296 SYM_DWEH
= 5 /* DWARF exception handling table */
299 static symkind
is_ctor_dtor (const char *);
301 static void handler (int);
302 static char *find_a_file (struct path_prefix
*, const char *);
303 static void add_prefix (struct path_prefix
*, const char *);
304 static void prefix_from_env (const char *, struct path_prefix
*);
305 static void prefix_from_string (const char *, struct path_prefix
*);
306 static void do_wait (const char *, struct pex_obj
*);
307 static void fork_execute (const char *, char **);
308 static void maybe_unlink (const char *);
309 static void maybe_unlink_list (char **);
310 static void add_to_list (struct head
*, const char *);
311 static int extract_init_priority (const char *);
312 static void sort_ids (struct head
*);
313 static void write_list (FILE *, const char *, struct id
*);
314 #ifdef COLLECT_EXPORT_LIST
315 static void dump_list (FILE *, const char *, struct id
*);
318 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
320 static void write_list_with_asm (FILE *, const char *, struct id
*);
321 static void write_c_file (FILE *, const char *);
322 static void write_c_file_stat (FILE *, const char *);
323 #ifndef LD_INIT_SWITCH
324 static void write_c_file_glob (FILE *, const char *);
326 #ifdef SCAN_LIBRARIES
327 static void scan_libraries (const char *);
329 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
330 static int is_in_args (const char *, const char **, const char **);
332 #ifdef COLLECT_EXPORT_LIST
334 static int is_in_list (const char *, struct id
*);
336 static void write_aix_file (FILE *, struct id
*);
337 static char *resolve_lib_name (const char *);
339 static char *extract_string (const char **);
341 /* Enumerations describing which pass this is for scanning the
345 PASS_FIRST
, /* without constructors */
346 PASS_OBJ
, /* individual objects */
347 PASS_LIB
, /* looking for shared libraries */
348 PASS_SECOND
, /* with constructors linked in */
349 PASS_LTOINFO
/* looking for objects with LTO info */
352 /* ... and which kinds of symbols are to be considered. */
354 enum scanfilter_masks
{
357 SCAN_CTOR
= 1 << SYM_CTOR
,
358 SCAN_DTOR
= 1 << SYM_DTOR
,
359 SCAN_INIT
= 1 << SYM_INIT
,
360 SCAN_FINI
= 1 << SYM_FINI
,
361 SCAN_DWEH
= 1 << SYM_DWEH
,
365 /* This type is used for parameters and variables which hold
366 combinations of the flags in enum scanfilter_masks. */
367 typedef int scanfilter
;
369 /* Scan the name list of the loaded program for the symbols g++ uses for
370 static constructors and destructors.
372 The SCANPASS argument tells which collect processing pass this is for and
373 the SCANFILTER argument tells which kinds of symbols to consider in this
374 pass. Symbols of a special kind not in the filter mask are considered as
377 The constructor table begins at __CTOR_LIST__ and contains a count of the
378 number of pointers (or -1 if the constructors are built in a separate
379 section by the linker), followed by the pointers to the constructor
380 functions, terminated with a null pointer. The destructor table has the
381 same format, and begins at __DTOR_LIST__. */
383 static void scan_prog_file (const char *, scanpass
, scanfilter
);
386 /* Delete tempfiles and exit function. */
389 collect_exit (int status
)
391 if (c_file
!= 0 && c_file
[0])
392 maybe_unlink (c_file
);
394 if (o_file
!= 0 && o_file
[0])
395 maybe_unlink (o_file
);
397 #ifdef COLLECT_EXPORT_LIST
398 if (export_file
!= 0 && export_file
[0])
399 maybe_unlink (export_file
);
403 maybe_unlink_list (lto_o_files
);
405 if (ldout
!= 0 && ldout
[0])
407 dump_file (ldout
, stdout
);
408 maybe_unlink (ldout
);
411 if (lderrout
!= 0 && lderrout
[0])
413 dump_file (lderrout
, stderr
);
414 maybe_unlink (lderrout
);
417 if (status
!= 0 && output_file
!= 0 && output_file
[0])
418 maybe_unlink (output_file
);
421 maybe_unlink (response_file
);
427 /* Notify user of a non-error. */
429 notice (const char *cmsgid
, ...)
433 va_start (ap
, cmsgid
);
434 vfprintf (stderr
, _(cmsgid
), ap
);
438 /* Notify user of a non-error, without translating the format string. */
440 notice_translated (const char *cmsgid
, ...)
444 va_start (ap
, cmsgid
);
445 vfprintf (stderr
, cmsgid
, ap
);
449 /* Die when sys call fails. */
452 fatal_perror (const char * cmsgid
, ...)
457 va_start (ap
, cmsgid
);
458 fprintf (stderr
, "collect2: ");
459 vfprintf (stderr
, _(cmsgid
), ap
);
460 fprintf (stderr
, ": %s\n", xstrerror (e
));
463 collect_exit (FATAL_EXIT_CODE
);
469 fatal (const char * cmsgid
, ...)
473 va_start (ap
, cmsgid
);
474 fprintf (stderr
, "collect2: ");
475 vfprintf (stderr
, _(cmsgid
), ap
);
476 fprintf (stderr
, "\n");
479 collect_exit (FATAL_EXIT_CODE
);
482 /* Write error message. */
485 error (const char * gmsgid
, ...)
489 va_start (ap
, gmsgid
);
490 fprintf (stderr
, "collect2: ");
491 vfprintf (stderr
, _(gmsgid
), ap
);
492 fprintf (stderr
, "\n");
496 /* In case obstack is linked in, and abort is defined to fancy_abort,
497 provide a default entry. */
500 fancy_abort (const char *file
, int line
, const char *func
)
502 fatal ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
508 if (c_file
!= 0 && c_file
[0])
509 maybe_unlink (c_file
);
511 if (o_file
!= 0 && o_file
[0])
512 maybe_unlink (o_file
);
514 if (ldout
!= 0 && ldout
[0])
515 maybe_unlink (ldout
);
517 if (lderrout
!= 0 && lderrout
[0])
518 maybe_unlink (lderrout
);
520 #ifdef COLLECT_EXPORT_LIST
521 if (export_file
!= 0 && export_file
[0])
522 maybe_unlink (export_file
);
526 maybe_unlink_list (lto_o_files
);
529 maybe_unlink (response_file
);
531 signal (signo
, SIG_DFL
);
537 file_exists (const char *name
)
539 return access (name
, R_OK
) == 0;
542 /* Parse a reasonable subset of shell quoting syntax. */
545 extract_string (const char **pp
)
558 obstack_1grow (&temporary_obstack
, c
);
559 else if (! inside
&& c
== ' ')
561 else if (! inside
&& c
== '\\')
566 obstack_1grow (&temporary_obstack
, c
);
569 obstack_1grow (&temporary_obstack
, '\0');
571 return XOBFINISH (&temporary_obstack
, char *);
575 dump_file (const char *name
, FILE *to
)
577 FILE *stream
= fopen (name
, "r");
584 while (c
= getc (stream
),
585 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
586 obstack_1grow (&temporary_obstack
, c
);
587 if (obstack_object_size (&temporary_obstack
) > 0)
589 const char *word
, *p
;
591 obstack_1grow (&temporary_obstack
, '\0');
592 word
= XOBFINISH (&temporary_obstack
, const char *);
595 ++word
, putc ('.', to
);
597 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
598 p
+= strlen (USER_LABEL_PREFIX
);
600 #ifdef HAVE_LD_DEMANGLE
606 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
614 diff
= strlen (word
) - strlen (result
);
615 while (diff
> 0 && c
== ' ')
616 --diff
, putc (' ', to
);
617 if (diff
< 0 && c
== ' ')
619 while (diff
< 0 && c
== ' ')
620 ++diff
, c
= getc (stream
);
623 /* Make sure we output at least one space, or
624 the demangled symbol name will run into
625 whatever text follows. */
636 obstack_free (&temporary_obstack
, temporary_firstobj
);
645 /* Return the kind of symbol denoted by name S. */
648 is_ctor_dtor (const char *s
)
650 struct names
{ const char *const name
; const int len
; symkind ret
;
651 const int two_underscores
; };
653 const struct names
*p
;
655 const char *orig_s
= s
;
657 static const struct names special
[] = {
658 #ifndef NO_DOLLAR_IN_LABEL
659 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
660 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
662 #ifndef NO_DOT_IN_LABEL
663 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
664 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
665 #endif /* NO_DOT_IN_LABEL */
666 #endif /* NO_DOLLAR_IN_LABEL */
667 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
668 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
669 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
670 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
671 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
672 { NULL
, 0, SYM_REGULAR
, 0 }
675 while ((ch
= *s
) == '_')
681 for (p
= &special
[0]; p
->len
> 0; p
++)
684 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
685 && strncmp(s
, p
->name
, p
->len
) == 0)
693 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
694 and one from the PATH variable. */
696 static struct path_prefix cpath
, path
;
698 #ifdef CROSS_DIRECTORY_STRUCTURE
699 /* This is the name of the target machine. We use it to form the name
700 of the files to execute. */
702 static const char *const target_machine
= TARGET_MACHINE
;
705 /* Search for NAME using prefix list PPREFIX. We only look for executable
708 Return 0 if not found, otherwise return its name, allocated with malloc. */
711 find_a_file (struct path_prefix
*pprefix
, const char *name
)
714 struct prefix_list
*pl
;
715 int len
= pprefix
->max_len
+ strlen (name
) + 1;
718 fprintf (stderr
, "Looking for '%s'\n", name
);
720 #ifdef HOST_EXECUTABLE_SUFFIX
721 len
+= strlen (HOST_EXECUTABLE_SUFFIX
);
724 temp
= XNEWVEC (char, len
);
726 /* Determine the filename to execute (special case for absolute paths). */
728 if (IS_ABSOLUTE_PATH (name
))
730 if (access (name
, X_OK
) == 0)
735 fprintf (stderr
, " - found: absolute path\n");
740 #ifdef HOST_EXECUTABLE_SUFFIX
741 /* Some systems have a suffix for executable files.
742 So try appending that. */
744 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
746 if (access (temp
, X_OK
) == 0)
751 fprintf (stderr
, " - failed to locate using absolute path\n");
754 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
758 strcpy (temp
, pl
->prefix
);
761 if (stat (temp
, &st
) >= 0
762 && ! S_ISDIR (st
.st_mode
)
763 && access (temp
, X_OK
) == 0)
766 #ifdef HOST_EXECUTABLE_SUFFIX
767 /* Some systems have a suffix for executable files.
768 So try appending that. */
769 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
771 if (stat (temp
, &st
) >= 0
772 && ! S_ISDIR (st
.st_mode
)
773 && access (temp
, X_OK
) == 0)
778 if (debug
&& pprefix
->plist
== NULL
)
779 fprintf (stderr
, " - failed: no entries in prefix list\n");
785 /* Add an entry for PREFIX to prefix list PPREFIX. */
788 add_prefix (struct path_prefix
*pprefix
, const char *prefix
)
790 struct prefix_list
*pl
, **prev
;
795 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
800 prev
= &pprefix
->plist
;
802 /* Keep track of the longest prefix. */
804 len
= strlen (prefix
);
805 if (len
> pprefix
->max_len
)
806 pprefix
->max_len
= len
;
808 pl
= XNEW (struct prefix_list
);
809 pl
->prefix
= xstrdup (prefix
);
814 pl
->next
= (struct prefix_list
*) 0;
818 /* Take the value of the environment variable ENV, break it into a path, and
819 add of the entries to PPREFIX. */
822 prefix_from_env (const char *env
, struct path_prefix
*pprefix
)
825 GET_ENVIRONMENT (p
, env
);
828 prefix_from_string (p
, pprefix
);
832 prefix_from_string (const char *p
, struct path_prefix
*pprefix
)
834 const char *startp
, *endp
;
835 char *nstore
= XNEWVEC (char, strlen (p
) + 3);
838 fprintf (stderr
, "Convert string '%s' into prefixes, separator = '%c'\n", p
, PATH_SEPARATOR
);
843 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
845 strncpy (nstore
, startp
, endp
-startp
);
848 strcpy (nstore
, "./");
850 else if (! IS_DIR_SEPARATOR (endp
[-1]))
852 nstore
[endp
-startp
] = DIR_SEPARATOR
;
853 nstore
[endp
-startp
+1] = 0;
856 nstore
[endp
-startp
] = 0;
859 fprintf (stderr
, " - add prefix: %s\n", nstore
);
861 add_prefix (pprefix
, nstore
);
864 endp
= startp
= endp
+ 1;
872 #ifdef OBJECT_FORMAT_NONE
874 /* Add an entry for the object file NAME to object file list LIST.
875 New entries are added at the end of the list. The original pointer
876 value of NAME is preserved, i.e., no string copy is performed. */
879 add_lto_object (struct lto_object_list
*list
, const char *name
)
881 struct lto_object
*n
= XNEW (struct lto_object
);
886 list
->last
->next
= n
;
892 #endif /* OBJECT_FORMAT_NONE */
895 /* Perform a link-time recompilation and relink if any of the object
896 files contain LTO info. The linker command line LTO_LD_ARGV
897 represents the linker command that would produce a final executable
898 without the use of LTO. OBJECT_LST is a vector of object file names
899 appearing in LTO_LD_ARGV that are to be considerd for link-time
900 recompilation, where OBJECT is a pointer to the last valid element.
901 (This awkward convention avoids an impedance mismatch with the
902 usage of similarly-named variables in main().) The elements of
903 OBJECT_LST must be identical, i.e., pointer equal, to the
904 corresponding arguments in LTO_LD_ARGV.
906 Upon entry, at least one linker run has been performed without the
907 use of any LTO info that might be present. Any recompilations
908 necessary for template instantiations have been performed, and
909 initializer/finalizer tables have been created if needed and
910 included in the linker command line LTO_LD_ARGV. If any of the
911 object files contain LTO info, we run the LTO back end on all such
912 files, and perform the final link with the LTO back end output
913 substituted for the LTO-optimized files. In some cases, a final
914 link with all link-time generated code has already been performed,
915 so there is no need to relink if no LTO info is found. In other
916 cases, our caller has not produced the final executable, and is
917 relying on us to perform the required link whether LTO info is
918 present or not. In that case, the FORCE argument should be true.
919 Note that the linker command line argument LTO_LD_ARGV passed into
920 this function may be modified in place. */
923 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
924 const char **object
, bool force
)
926 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
928 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
930 while (object_file
< object
)
932 /* If file contains LTO info, add it to the list of LTO objects. */
933 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
935 /* Increment the argument count by the number of object file arguments
936 we will add. An upper bound suffices, so just count all of the
937 object files regardless of whether they contain LTO info. */
941 if (lto_objects
.first
)
944 const char **lto_c_ptr
;
945 const char **p
, **q
, **r
;
946 const char **lto_o_ptr
;
947 struct lto_object
*list
;
948 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
950 const char *prog
= "lto-wrapper";
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 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
961 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
963 *lto_c_ptr
++ = lto_wrapper
;
965 /* Add LTO objects to the wrapper command line. */
966 for (list
= lto_objects
.first
; list
; list
= list
->next
)
967 *lto_c_ptr
++ = list
->name
;
971 /* Run the LTO back end. */
972 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
979 stream
= pex_read_output (pex
, 0);
983 while ((c
= getc (stream
)) != EOF
)
985 obstack_1grow (&temporary_obstack
, c
);
990 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
991 lto_o_files
[num_files
] = NULL
;
992 start
= XOBFINISH (&temporary_obstack
, char *);
993 for (i
= 0; i
< num_files
; ++i
)
1000 lto_o_files
[i
] = xstrdup (start
);
1005 obstack_free (&temporary_obstack
, temporary_firstobj
);
1007 do_wait (prog
, pex
);
1010 /* After running the LTO back end, we will relink, substituting
1011 the LTO output for the object files that we submitted to the
1012 LTO. Here, we modify the linker command line for the relink. */
1013 p
= CONST_CAST2 (const char **, char **, lto_ld_argv
);
1014 lto_o_ptr
= CONST_CAST2 (const char **, char **, lto_o_files
);
1018 for (list
= lto_objects
.first
; list
; list
= list
->next
)
1020 if (*p
== list
->name
) /* Note test for pointer equality! */
1022 /* Excise argument from linker command line. */
1025 /* Replace first argument with LTO output file. */
1026 *p
++ = *lto_o_ptr
++;
1030 /* Move following arguments one position earlier,
1031 overwriting the current argument. */
1039 /* No need to continue searching the LTO object list. */
1044 /* If we didn't find a match, move on to the next argument.
1045 Otherwise, P has been set to the correct argument position
1046 at which to continue. */
1050 /* The code above assumes we will never have more lto output files than
1051 input files. Otherwise, we need to resize lto_ld_argv. Check this
1054 fatal ("too many lto output files");
1056 /* Run the linker again, this time replacing the object files
1057 optimized by the LTO with the temporary file generated by the LTO. */
1058 fork_execute ("ld", lto_ld_argv
);
1060 maybe_unlink_list (lto_o_files
);
1064 /* Our caller is relying on us to do the link
1065 even though there is no LTO back end work to be done. */
1066 fork_execute ("ld", lto_ld_argv
);
1073 main (int argc
, char **argv
)
1075 static const char *const ld_suffix
= "ld";
1076 static const char *const plugin_ld_suffix
= PLUGIN_LD
;
1077 static const char *const real_ld_suffix
= "real-ld";
1078 static const char *const collect_ld_suffix
= "collect-ld";
1079 static const char *const nm_suffix
= "nm";
1080 static const char *const gnm_suffix
= "gnm";
1082 static const char *const ldd_suffix
= LDD_SUFFIX
;
1084 static const char *const strip_suffix
= "strip";
1085 static const char *const gstrip_suffix
= "gstrip";
1087 #ifdef CROSS_DIRECTORY_STRUCTURE
1088 /* If we look for a program in the compiler directories, we just use
1089 the short name, since these directories are already system-specific.
1090 But it we look for a program in the system directories, we need to
1091 qualify the program name with the target machine. */
1093 const char *const full_ld_suffix
=
1094 concat(target_machine
, "-", ld_suffix
, NULL
);
1095 const char *const full_plugin_ld_suffix
=
1096 concat(target_machine
, "-", plugin_ld_suffix
, NULL
);
1097 const char *const full_nm_suffix
=
1098 concat (target_machine
, "-", nm_suffix
, NULL
);
1099 const char *const full_gnm_suffix
=
1100 concat (target_machine
, "-", gnm_suffix
, NULL
);
1102 const char *const full_ldd_suffix
=
1103 concat (target_machine
, "-", ldd_suffix
, NULL
);
1105 const char *const full_strip_suffix
=
1106 concat (target_machine
, "-", strip_suffix
, NULL
);
1107 const char *const full_gstrip_suffix
=
1108 concat (target_machine
, "-", gstrip_suffix
, NULL
);
1110 const char *const full_ld_suffix
= ld_suffix
;
1111 const char *const full_plugin_ld_suffix
= plugin_ld_suffix
;
1112 const char *const full_nm_suffix
= nm_suffix
;
1113 const char *const full_gnm_suffix
= gnm_suffix
;
1115 const char *const full_ldd_suffix
= ldd_suffix
;
1117 const char *const full_strip_suffix
= strip_suffix
;
1118 const char *const full_gstrip_suffix
= gstrip_suffix
;
1119 #endif /* CROSS_DIRECTORY_STRUCTURE */
1123 #ifdef COLLECT_EXPORT_LIST
1126 const char *ld_file_name
;
1132 bool use_plugin
= false;
1134 /* The kinds of symbols we will have to consider when scanning the
1135 outcome of a first pass link. This is ALL to start with, then might
1136 be adjusted before getting to the first pass link per se, typically on
1137 AIX where we perform an early scan of objects and libraries to fetch
1138 the list of global ctors/dtors and make sure they are not garbage
1140 scanfilter ld1_filter
= SCAN_ALL
;
1145 const char **object
;
1150 bool use_verbose
= false;
1153 expandargv (&argc
, &argv
);
1154 if (argv
!= old_argv
)
1155 at_file_supplied
= 1;
1157 num_c_args
= argc
+ 9;
1159 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
1161 /* Suppress demangling by the real linker, which may be broken. */
1162 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1164 #if defined (COLLECT2_HOST_INITIALIZATION)
1165 /* Perform system dependent initialization, if necessary. */
1166 COLLECT2_HOST_INITIALIZATION
;
1170 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1171 receive the signal. A different setting is inheritable */
1172 signal (SIGCHLD
, SIG_DFL
);
1175 /* Unlock the stdio streams. */
1176 unlock_std_streams ();
1178 gcc_init_libintl ();
1180 /* Do not invoke xcalloc before this point, since locale needs to be
1181 set first, in case a diagnostic is issued. */
1183 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
1184 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
1185 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
1186 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
1187 object_lst
= XCNEWVEC (char *, argc
);
1188 object
= CONST_CAST2 (const char **, char **, object_lst
);
1194 /* Parse command line early for instances of -debug. This allows
1195 the debug flag to be set before functions like find_a_file()
1196 are called. We also look for the -flto or -fwhopr flag to know
1197 what LTO mode we are in. */
1201 for (i
= 1; argv
[i
] != NULL
; i
++)
1203 if (! strcmp (argv
[i
], "-debug"))
1205 else if (! strcmp (argv
[i
], "-flto") && ! use_plugin
)
1208 lto_mode
= LTO_MODE_LTO
;
1210 else if (! strncmp (argv
[i
], "-fwhopr", 7) && ! use_plugin
)
1213 lto_mode
= LTO_MODE_WHOPR
;
1215 else if (! strcmp (argv
[i
], "-plugin"))
1219 lto_mode
= LTO_MODE_NONE
;
1221 #ifdef COLLECT_EXPORT_LIST
1222 /* since -brtl, -bexport, -b64 are not position dependent
1223 also check for them here */
1224 if ((argv
[i
][0] == '-') && (argv
[i
][1] == 'b'))
1227 /* We want to disable automatic exports on AIX when user
1228 explicitly puts an export list in command line */
1229 if (arg
[2] == 'E' || strncmp (&arg
[2], "export", 6) == 0)
1231 else if (arg
[2] == '6' && arg
[3] == '4')
1233 else if (arg
[2] == 'r' && arg
[3] == 't' && arg
[4] == 'l')
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 (strcmp (arg
, "-flto") == 0
1486 || strncmp (arg
, "-fwhopr", 7) == 0)
1489 /* Do not pass LTO flag to the linker. */
1493 error ("LTO support has not been enabled in this "
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);
1525 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1527 if (is_in_args (arg
,
1528 CONST_CAST2 (const char **, char **, ld1_argv
),
1532 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1537 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1539 #ifdef SWITCHES_NEED_SPACES
1540 && ! strchr (SWITCHES_NEED_SPACES
, arg
[1])
1544 output_file
= &arg
[2];
1553 if (arg
[2] == '\0' && do_collecting
)
1555 /* We must strip after the nm run, otherwise C++ linking
1556 will not work. Thus we strip in the second ld run, or
1557 else with strip if there is no second ld run. */
1569 if (strcmp (arg
, "--no-demangle") == 0)
1571 demangle_flag
= arg
;
1576 else if (strncmp (arg
, "--demangle", 10) == 0)
1578 demangle_flag
= arg
;
1580 #ifndef HAVE_LD_DEMANGLE
1583 enum demangling_styles style
1584 = cplus_demangle_name_to_style (arg
+11);
1585 if (style
== unknown_demangling
)
1586 error ("unknown demangling style '%s'", arg
+11);
1588 current_demangling_style
= style
;
1594 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1595 target_system_root
= arg
+ 10;
1596 else if (strncmp (arg
, "--version", 9) == 0)
1598 else if (strncmp (arg
, "--help", 9) == 0)
1603 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1604 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1605 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1606 || strcmp (p
, ".obj") == 0))
1615 /* place o_file BEFORE this argument! */
1621 if (p
[1] == 'o' || p
[1] == 'l')
1623 #ifdef COLLECT_EXPORT_LIST
1624 /* libraries can be specified directly, i.e. without -l flag. */
1627 /* Saving a full library name. */
1628 add_to_list (&libs
, arg
);
1634 #ifdef COLLECT_EXPORT_LIST
1635 /* This is added only for debugging purposes. */
1638 fprintf (stderr
, "List of libraries:\n");
1639 dump_list (stderr
, "\t", libs
.first
);
1642 /* The AIX linker will discard static constructors in object files if
1643 nothing else in the file is referenced, so look at them first. Unless
1644 we are building a shared object, ignore the eh frame tables, as we
1645 would otherwise reference them all, hence drag all the corresponding
1646 objects even if nothing else is referenced. */
1648 const char **export_object_lst
1649 = CONST_CAST2 (const char **, char **, object_lst
);
1651 struct id
*list
= libs
.first
;
1653 /* Compute the filter to use from the current one, do scan, then adjust
1654 the "current" filter to remove what we just included here. This will
1655 control whether we need a first pass link later on or not, and what
1656 will remain to be scanned there. */
1658 scanfilter this_filter
= ld1_filter
;
1661 this_filter
&= ~SCAN_DWEH
;
1664 while (export_object_lst
< object
)
1665 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1667 for (; list
; list
= list
->next
)
1668 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1670 ld1_filter
= ld1_filter
& ~this_filter
;
1675 char *buf
= concat ("-bE:", export_file
, NULL
);
1680 exportf
= fopen (export_file
, "w");
1681 if (exportf
== (FILE *) 0)
1682 fatal_perror ("fopen %s", export_file
);
1683 write_aix_file (exportf
, exports
.first
);
1684 if (fclose (exportf
))
1685 fatal_perror ("fclose %s", export_file
);
1690 *c_ptr
= *ld1
= *object
= (char *) 0;
1694 notice ("collect2 version %s", version_string
);
1695 #ifdef TARGET_VERSION
1698 fprintf (stderr
, "\n");
1703 fprintf (stderr
, "Usage: collect2 [options]\n");
1704 fprintf (stderr
, " Wrap linker and generate constructor code if needed.\n");
1705 fprintf (stderr
, " Options:\n");
1706 fprintf (stderr
, " -debug Enable debug output\n");
1707 fprintf (stderr
, " --help Display this information\n");
1708 fprintf (stderr
, " -v, --version Display this program's version number\n");
1709 fprintf (stderr
, "Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1710 fprintf (stderr
, "Report bugs: %s\n", bug_report_url
);
1718 fprintf (stderr
, "ld_file_name = %s\n",
1719 (ld_file_name
? ld_file_name
: "not found"));
1720 fprintf (stderr
, "c_file_name = %s\n",
1721 (c_file_name
? c_file_name
: "not found"));
1722 fprintf (stderr
, "nm_file_name = %s\n",
1723 (nm_file_name
? nm_file_name
: "not found"));
1725 fprintf (stderr
, "ldd_file_name = %s\n",
1726 (ldd_file_name
? ldd_file_name
: "not found"));
1728 fprintf (stderr
, "strip_file_name = %s\n",
1729 (strip_file_name
? strip_file_name
: "not found"));
1730 fprintf (stderr
, "c_file = %s\n",
1731 (c_file
? c_file
: "not found"));
1732 fprintf (stderr
, "o_file = %s\n",
1733 (o_file
? o_file
: "not found"));
1735 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1737 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1739 ptr
= getenv ("COLLECT_GCC");
1741 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1743 ptr
= getenv ("COMPILER_PATH");
1745 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1747 ptr
= getenv (LIBRARY_PATH_ENV
);
1749 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1751 fprintf (stderr
, "\n");
1754 /* Load the program, searching all libraries and attempting to provide
1755 undefined symbols from repository information.
1757 If -r or they will be run via some other method, do not build the
1758 constructor or destructor list, just return now. */
1761 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1763 /* Perform the first pass link now, if we're about to exit or if we need
1764 to scan for things we haven't collected yet before pursuing further.
1766 On AIX, the latter typically includes nothing for shared objects or
1767 frame tables for an executable, out of what the required early scan on
1768 objects and libraries has performed above. In the !shared_obj case, we
1769 expect the relevant tables to be dragged together with their associated
1770 functions from precise cross reference insertions by the compiler. */
1772 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1773 do_tlink (ld1_argv
, object_lst
);
1777 #ifdef COLLECT_EXPORT_LIST
1778 /* Make sure we delete the export file we may have created. */
1779 if (export_file
!= 0 && export_file
[0])
1780 maybe_unlink (export_file
);
1782 if (lto_mode
!= LTO_MODE_NONE
)
1783 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1785 maybe_unlink (c_file
);
1786 maybe_unlink (o_file
);
1791 /* Unless we have done it all already, examine the namelist and search for
1792 static constructors and destructors to call. Write the constructor and
1793 destructor tables to a .s file and reload. */
1795 if (ld1_filter
!= SCAN_NOTHING
)
1796 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1798 #ifdef SCAN_LIBRARIES
1799 scan_libraries (output_file
);
1804 notice_translated (ngettext ("%d constructor found\n",
1805 "%d constructors found\n",
1806 constructors
.number
),
1807 constructors
.number
);
1808 notice_translated (ngettext ("%d destructor found\n",
1809 "%d destructors found\n",
1810 destructors
.number
),
1811 destructors
.number
);
1812 notice_translated (ngettext("%d frame table found\n",
1813 "%d frame tables found\n",
1814 frame_tables
.number
),
1815 frame_tables
.number
);
1818 /* If the scan exposed nothing of special interest, there's no need to
1819 generate the glue code and relink so return now. */
1821 if (constructors
.number
== 0 && destructors
.number
== 0
1822 && frame_tables
.number
== 0
1823 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1824 /* If we will be running these functions ourselves, we want to emit
1825 stubs into the shared library so that we do not have to relink
1826 dependent programs when we add static objects. */
1831 /* Do tlink without additional code generation now if we didn't
1832 do it earlier for scanning purposes. */
1833 if (ld1_filter
== SCAN_NOTHING
)
1834 do_tlink (ld1_argv
, object_lst
);
1837 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1839 /* Strip now if it was requested on the command line. */
1842 char **real_strip_argv
= XCNEWVEC (char *, 3);
1843 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1846 strip_argv
[0] = strip_file_name
;
1847 strip_argv
[1] = output_file
;
1848 strip_argv
[2] = (char *) 0;
1849 fork_execute ("strip", real_strip_argv
);
1852 #ifdef COLLECT_EXPORT_LIST
1853 maybe_unlink (export_file
);
1855 maybe_unlink (c_file
);
1856 maybe_unlink (o_file
);
1860 /* Sort ctor and dtor lists by priority. */
1861 sort_ids (&constructors
);
1862 sort_ids (&destructors
);
1864 maybe_unlink(output_file
);
1865 outf
= fopen (c_file
, "w");
1866 if (outf
== (FILE *) 0)
1867 fatal_perror ("fopen %s", c_file
);
1869 write_c_file (outf
, c_file
);
1872 fatal_perror ("fclose %s", c_file
);
1874 /* Tell the linker that we have initializer and finalizer functions. */
1875 #ifdef LD_INIT_SWITCH
1876 #ifdef COLLECT_EXPORT_LIST
1877 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1879 *ld2
++ = LD_INIT_SWITCH
;
1881 *ld2
++ = LD_FINI_SWITCH
;
1886 #ifdef COLLECT_EXPORT_LIST
1889 /* If we did not add export flag to link arguments before, add it to
1890 second link phase now. No new exports should have been added. */
1891 if (! exports
.first
)
1892 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1894 #ifndef LD_INIT_SWITCH
1895 add_to_list (&exports
, initname
);
1896 add_to_list (&exports
, fininame
);
1897 add_to_list (&exports
, "_GLOBAL__DI");
1898 add_to_list (&exports
, "_GLOBAL__DD");
1900 exportf
= fopen (export_file
, "w");
1901 if (exportf
== (FILE *) 0)
1902 fatal_perror ("fopen %s", export_file
);
1903 write_aix_file (exportf
, exports
.first
);
1904 if (fclose (exportf
))
1905 fatal_perror ("fclose %s", export_file
);
1909 /* End of arguments to second link phase. */
1914 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1915 output_file
, c_file
);
1916 write_c_file (stderr
, "stderr");
1917 fprintf (stderr
, "========== end of c_file\n\n");
1918 #ifdef COLLECT_EXPORT_LIST
1919 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1920 write_aix_file (stderr
, exports
.first
);
1921 fprintf (stderr
, "========== end of export_file\n\n");
1925 /* Assemble the constructor and destructor tables.
1926 Link the tables in with the rest of the program. */
1928 fork_execute ("gcc", c_argv
);
1929 #ifdef COLLECT_EXPORT_LIST
1930 /* On AIX we must call tlink because of possible templates resolution. */
1931 do_tlink (ld2_argv
, object_lst
);
1934 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1936 /* Otherwise, simply call ld because tlink is already done. */
1938 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1940 fork_execute ("ld", ld2_argv
);
1942 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1943 constructors/destructors in shared libraries. */
1944 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1947 maybe_unlink (c_file
);
1948 maybe_unlink (o_file
);
1950 #ifdef COLLECT_EXPORT_LIST
1951 maybe_unlink (export_file
);
1958 /* Wait for a process to finish, and exit if a nonzero status is found. */
1961 collect_wait (const char *prog
, struct pex_obj
*pex
)
1965 if (!pex_get_status (pex
, 1, &status
))
1966 fatal_perror ("can't get program status");
1971 if (WIFSIGNALED (status
))
1973 int sig
= WTERMSIG (status
);
1974 error ("%s terminated with signal %d [%s]%s",
1975 prog
, sig
, strsignal(sig
),
1976 WCOREDUMP(status
) ? ", core dumped" : "");
1977 collect_exit (FATAL_EXIT_CODE
);
1980 if (WIFEXITED (status
))
1981 return WEXITSTATUS (status
);
1987 do_wait (const char *prog
, struct pex_obj
*pex
)
1989 int ret
= collect_wait (prog
, pex
);
1992 error ("%s returned %d exit status", prog
, ret
);
1998 unlink (response_file
);
1999 response_file
= NULL
;
2004 /* Execute a program, and wait for the reply. */
2007 collect_execute (const char *prog
, char **argv
, const char *outname
,
2008 const char *errname
, int flags
)
2010 struct pex_obj
*pex
;
2013 char *response_arg
= NULL
;
2014 char *response_argv
[3] ATTRIBUTE_UNUSED
;
2016 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
2018 /* If using @file arguments, create a temporary file and put the
2019 contents of argv into it. Then change argv to an array corresponding
2020 to a single argument @FILE, where FILE is the temporary filename. */
2022 char **current_argv
= argv
+ 1;
2023 char *argv0
= argv
[0];
2027 /* Note: we assume argv contains at least one element; this is
2030 response_file
= make_temp_file ("");
2032 f
= fopen (response_file
, "w");
2035 fatal ("could not open response file %s", response_file
);
2037 status
= writeargv (current_argv
, f
);
2040 fatal ("could not write to response file %s", response_file
);
2042 status
= fclose (f
);
2045 fatal ("could not close response file %s", response_file
);
2047 response_arg
= concat ("@", response_file
, NULL
);
2048 response_argv
[0] = argv0
;
2049 response_argv
[1] = response_arg
;
2050 response_argv
[2] = NULL
;
2052 argv
= response_argv
;
2061 fprintf (stderr
, "%s", argv
[0]);
2063 notice ("[cannot find %s]", prog
);
2065 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2066 fprintf (stderr
, " %s", str
);
2068 fprintf (stderr
, "\n");
2074 /* If we cannot find a program we need, complain error. Do this here
2075 since we might not end up needing something that we could not find. */
2078 fatal ("cannot find '%s'", prog
);
2080 pex
= pex_init (0, "collect2", NULL
);
2082 fatal_perror ("pex_init failed");
2084 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
2091 fatal_perror (errmsg
);
2098 free (response_arg
);
2104 fork_execute (const char *prog
, char **argv
)
2106 struct pex_obj
*pex
;
2108 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
2109 do_wait (prog
, pex
);
2112 /* Unlink a file unless we are debugging. */
2115 maybe_unlink (const char *file
)
2118 unlink_if_ordinary (file
);
2120 notice ("[Leaving %s]\n", file
);
2123 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2126 maybe_unlink_list (char **file_list
)
2128 char **tmp
= file_list
;
2131 maybe_unlink (*(tmp
++));
2135 static long sequence_number
= 0;
2137 /* Add a name to a linked list. */
2140 add_to_list (struct head
*head_ptr
, const char *name
)
2143 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2145 strcpy (newid
->name
, name
);
2147 if (head_ptr
->first
)
2148 head_ptr
->last
->next
= newid
;
2150 head_ptr
->first
= newid
;
2152 /* Check for duplicate symbols. */
2153 for (p
= head_ptr
->first
;
2154 strcmp (name
, p
->name
) != 0;
2159 head_ptr
->last
->next
= 0;
2164 newid
->sequence
= ++sequence_number
;
2165 head_ptr
->last
= newid
;
2169 /* Grab the init priority number from an init function name that
2170 looks like "_GLOBAL_.I.12345.foo". */
2173 extract_init_priority (const char *name
)
2177 while (name
[pos
] == '_')
2179 pos
+= 10; /* strlen ("GLOBAL__X_") */
2181 /* Extract init_p number from ctor/dtor name. */
2182 pri
= atoi (name
+ pos
);
2183 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2186 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2187 ctors will be run from right to left, dtors from left to right. */
2190 sort_ids (struct head
*head_ptr
)
2192 /* id holds the current element to insert. id_next holds the next
2193 element to insert. id_ptr iterates through the already sorted elements
2194 looking for the place to insert id. */
2195 struct id
*id
, *id_next
, **id_ptr
;
2197 id
= head_ptr
->first
;
2199 /* We don't have any sorted elements yet. */
2200 head_ptr
->first
= NULL
;
2202 for (; id
; id
= id_next
)
2205 id
->sequence
= extract_init_priority (id
->name
);
2207 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2209 /* If the sequence numbers are the same, we put the id from the
2210 file later on the command line later in the list. */
2211 || id
->sequence
> (*id_ptr
)->sequence
2212 /* Hack: do lexical compare, too.
2213 || (id->sequence == (*id_ptr)->sequence
2214 && strcmp (id->name, (*id_ptr)->name) > 0) */
2223 /* Now set the sequence numbers properly so write_c_file works. */
2224 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2225 id
->sequence
= ++sequence_number
;
2228 /* Write: `prefix', the names on list LIST, `suffix'. */
2231 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2235 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2240 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2241 /* Given a STRING, return nonzero if it occurs in the list in range
2242 [ARGS_BEGIN,ARGS_END). */
2245 is_in_args (const char *string
, const char **args_begin
,
2246 const char **args_end
)
2248 const char **args_pointer
;
2249 for (args_pointer
= args_begin
; args_pointer
!= args_end
; ++args_pointer
)
2250 if (strcmp (string
, *args_pointer
) == 0)
2254 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2256 #ifdef COLLECT_EXPORT_LIST
2257 /* This function is really used only on AIX, but may be useful. */
2260 is_in_list (const char *prefix
, struct id
*list
)
2264 if (!strcmp (prefix
, list
->name
)) return 1;
2270 #endif /* COLLECT_EXPORT_LIST */
2272 /* Added for debugging purpose. */
2273 #ifdef COLLECT_EXPORT_LIST
2275 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2279 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2287 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2291 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2298 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2302 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2303 prefix
, list
->sequence
, list
->name
);
2308 /* Write out the constructor and destructor tables statically (for a shared
2309 object), along with the functions to execute them. */
2312 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2316 int frames
= (frame_tables
.number
> 0);
2318 /* Figure out name of output_file, stripping off .so version. */
2319 p
= strrchr (output_file
, '/');
2335 if (strncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2337 q
+= strlen (SHLIB_SUFFIX
);
2344 /* q points to null at end of the string (or . of the .so version) */
2345 prefix
= XNEWVEC (char, q
- p
+ 1);
2346 strncpy (prefix
, p
, q
- p
);
2348 for (r
= prefix
; *r
; r
++)
2349 if (!ISALNUM ((unsigned char)*r
))
2352 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2353 output_file
, prefix
);
2355 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2356 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2360 /* Write the tables as C code. */
2362 fprintf (stream
, "static int count;\n");
2363 fprintf (stream
, "typedef void entry_pt();\n");
2364 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2368 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2370 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2371 write_list (stream
, "\t\t&", frame_tables
.first
);
2372 fprintf (stream
, "\t0\n};\n");
2374 /* This must match what's in frame.h. */
2375 fprintf (stream
, "struct object {\n");
2376 fprintf (stream
, " void *pc_begin;\n");
2377 fprintf (stream
, " void *pc_end;\n");
2378 fprintf (stream
, " void *fde_begin;\n");
2379 fprintf (stream
, " void *fde_array;\n");
2380 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2381 fprintf (stream
, " struct object *next;\n");
2382 fprintf (stream
, "};\n");
2384 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2385 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2387 fprintf (stream
, "static void reg_frame () {\n");
2388 fprintf (stream
, "\tstatic struct object ob;\n");
2389 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2390 fprintf (stream
, "\t}\n");
2392 fprintf (stream
, "static void dereg_frame () {\n");
2393 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2394 fprintf (stream
, "\t}\n");
2397 fprintf (stream
, "void %s() {\n", initname
);
2398 if (constructors
.number
> 0 || frames
)
2400 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2401 write_list (stream
, "\t\t", constructors
.first
);
2403 fprintf (stream
, "\treg_frame,\n");
2404 fprintf (stream
, "\t};\n");
2405 fprintf (stream
, "\tentry_pt **p;\n");
2406 fprintf (stream
, "\tif (count++ != 0) return;\n");
2407 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2408 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2411 fprintf (stream
, "\t++count;\n");
2412 fprintf (stream
, "}\n");
2413 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2414 fprintf (stream
, "void %s() {\n", fininame
);
2415 if (destructors
.number
> 0 || frames
)
2417 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2418 write_list (stream
, "\t\t", destructors
.first
);
2420 fprintf (stream
, "\tdereg_frame,\n");
2421 fprintf (stream
, "\t};\n");
2422 fprintf (stream
, "\tentry_pt **p;\n");
2423 fprintf (stream
, "\tif (--count != 0) return;\n");
2424 fprintf (stream
, "\tp = dtors;\n");
2425 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2426 destructors
.number
+ frames
);
2428 fprintf (stream
, "}\n");
2432 COLLECT_SHARED_INIT_FUNC(stream
, initname
);
2433 COLLECT_SHARED_FINI_FUNC(stream
, fininame
);
2437 /* Write the constructor/destructor tables. */
2439 #ifndef LD_INIT_SWITCH
2441 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2443 /* Write the tables as C code. */
2445 int frames
= (frame_tables
.number
> 0);
2447 fprintf (stream
, "typedef void entry_pt();\n\n");
2449 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2453 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2455 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2456 write_list (stream
, "\t\t&", frame_tables
.first
);
2457 fprintf (stream
, "\t0\n};\n");
2459 /* This must match what's in frame.h. */
2460 fprintf (stream
, "struct object {\n");
2461 fprintf (stream
, " void *pc_begin;\n");
2462 fprintf (stream
, " void *pc_end;\n");
2463 fprintf (stream
, " void *fde_begin;\n");
2464 fprintf (stream
, " void *fde_array;\n");
2465 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2466 fprintf (stream
, " struct object *next;\n");
2467 fprintf (stream
, "};\n");
2469 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2470 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2472 fprintf (stream
, "static void reg_frame () {\n");
2473 fprintf (stream
, "\tstatic struct object ob;\n");
2474 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2475 fprintf (stream
, "\t}\n");
2477 fprintf (stream
, "static void dereg_frame () {\n");
2478 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2479 fprintf (stream
, "\t}\n");
2482 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2483 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2484 write_list (stream
, "\t", constructors
.first
);
2486 fprintf (stream
, "\treg_frame,\n");
2487 fprintf (stream
, "\t0\n};\n\n");
2489 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2491 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2492 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2493 write_list (stream
, "\t", destructors
.first
);
2495 fprintf (stream
, "\tdereg_frame,\n");
2496 fprintf (stream
, "\t0\n};\n\n");
2498 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2499 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2501 #endif /* ! LD_INIT_SWITCH */
2504 write_c_file (FILE *stream
, const char *name
)
2506 #ifndef LD_INIT_SWITCH
2508 write_c_file_glob (stream
, name
);
2511 write_c_file_stat (stream
, name
);
2514 #ifdef COLLECT_EXPORT_LIST
2516 write_aix_file (FILE *stream
, struct id
*list
)
2518 for (; list
; list
= list
->next
)
2520 fputs (list
->name
, stream
);
2521 putc ('\n', stream
);
2526 #ifdef OBJECT_FORMAT_NONE
2528 /* Check to make sure the file is an LTO object file. */
2531 maybe_lto_object_file (const char *prog_name
)
2534 unsigned char buf
[4];
2537 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2538 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2539 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2540 static unsigned char machomagic
[4][4] = {
2541 { 0xcf, 0xfa, 0xed, 0xfe },
2542 { 0xce, 0xfa, 0xed, 0xfe },
2543 { 0xfe, 0xed, 0xfa, 0xcf },
2544 { 0xfe, 0xed, 0xfa, 0xce }
2547 f
= fopen (prog_name
, "rb");
2550 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2554 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2555 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2556 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2558 for (i
= 0; i
< 4; i
++)
2559 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2565 /* Generic version to scan the name list of the loaded program for
2566 the symbols g++ uses for static constructors and destructors. */
2569 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2572 void (*int_handler
) (int);
2574 void (*quit_handler
) (int);
2576 char *real_nm_argv
[4];
2577 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2579 struct pex_obj
*pex
;
2586 if (which_pass
== PASS_SECOND
)
2589 /* LTO objects must be in a known format. This check prevents
2590 us from accepting an archive containing LTO objects, which
2591 gcc cannnot currently handle. */
2592 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2595 /* If we do not have an `nm', complain. */
2596 if (nm_file_name
== 0)
2597 fatal ("cannot find 'nm'");
2599 nm_argv
[argc
++] = nm_file_name
;
2600 if (NM_FLAGS
[0] != '\0')
2601 nm_argv
[argc
++] = NM_FLAGS
;
2603 nm_argv
[argc
++] = prog_name
;
2604 nm_argv
[argc
++] = (char *) 0;
2606 /* Trace if needed. */
2609 const char **p_argv
;
2612 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2613 fprintf (stderr
, " %s", str
);
2615 fprintf (stderr
, "\n");
2621 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2623 fatal_perror ("pex_init failed");
2625 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2632 fatal_perror (errmsg
);
2638 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2640 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2643 inf
= pex_read_output (pex
, 0);
2645 fatal_perror ("can't open nm output");
2649 if (which_pass
== PASS_LTOINFO
)
2650 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2652 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2655 /* Read each line of nm output. */
2656 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2662 fprintf (stderr
, "\t%s\n", buf
);
2664 if (which_pass
== PASS_LTOINFO
)
2669 /* Look for the LTO info marker symbol, and add filename to
2670 the LTO objects list if found. */
2671 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2672 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2673 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2674 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2676 add_lto_object (<o_objects
, prog_name
);
2678 /* We need to read all the input, so we can't just
2679 return here. But we can avoid useless work. */
2688 /* If it contains a constructor or destructor name, add the name
2689 to the appropriate list unless this is a kind of symbol we're
2690 not supposed to even consider. */
2692 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2693 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2700 /* Find the end of the symbol name.
2701 Do not include `|', because Encore nm can tack that on the end. */
2702 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2708 switch (is_ctor_dtor (name
))
2711 if (! (filter
& SCAN_CTOR
))
2713 if (which_pass
!= PASS_LIB
)
2714 add_to_list (&constructors
, name
);
2718 if (! (filter
& SCAN_DTOR
))
2720 if (which_pass
!= PASS_LIB
)
2721 add_to_list (&destructors
, name
);
2725 if (! (filter
& SCAN_INIT
))
2727 if (which_pass
!= PASS_LIB
)
2728 fatal ("init function found in object %s", prog_name
);
2729 #ifndef LD_INIT_SWITCH
2730 add_to_list (&constructors
, name
);
2735 if (! (filter
& SCAN_FINI
))
2737 if (which_pass
!= PASS_LIB
)
2738 fatal ("fini function found in object %s", prog_name
);
2739 #ifndef LD_FINI_SWITCH
2740 add_to_list (&destructors
, name
);
2745 if (! (filter
& SCAN_DWEH
))
2747 if (which_pass
!= PASS_LIB
)
2748 add_to_list (&frame_tables
, name
);
2751 default: /* not a constructor or destructor */
2757 fprintf (stderr
, "\n");
2759 do_wait (nm_file_name
, pex
);
2761 signal (SIGINT
, int_handler
);
2763 signal (SIGQUIT
, quit_handler
);
2769 /* Use the List Dynamic Dependencies program to find shared libraries that
2770 the output file depends upon and their initialization/finalization
2771 routines, if any. */
2774 scan_libraries (const char *prog_name
)
2776 static struct head libraries
; /* list of shared libraries found */
2778 void (*int_handler
) (int);
2780 void (*quit_handler
) (int);
2782 char *real_ldd_argv
[4];
2783 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2785 struct pex_obj
*pex
;
2791 /* If we do not have an `ldd', complain. */
2792 if (ldd_file_name
== 0)
2794 error ("cannot find 'ldd'");
2798 ldd_argv
[argc
++] = ldd_file_name
;
2799 ldd_argv
[argc
++] = prog_name
;
2800 ldd_argv
[argc
++] = (char *) 0;
2802 /* Trace if needed. */
2805 const char **p_argv
;
2808 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2809 fprintf (stderr
, " %s", str
);
2811 fprintf (stderr
, "\n");
2817 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2819 fatal_perror ("pex_init failed");
2821 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2827 fatal_perror (errmsg
);
2833 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2835 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2838 inf
= pex_read_output (pex
, 0);
2840 fatal_perror ("can't open ldd output");
2843 notice ("\nldd output with constructors/destructors.\n");
2845 /* Read each line of ldd output. */
2846 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2849 char *name
, *end
, *p
= buf
;
2851 /* Extract names of libraries and add to list. */
2852 PARSE_LDD_OUTPUT (p
);
2857 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2858 fatal ("dynamic dependency %s not found", buf
);
2860 /* Find the end of the symbol name. */
2862 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2867 if (access (name
, R_OK
) == 0)
2868 add_to_list (&libraries
, name
);
2870 fatal ("unable to open dynamic dependency '%s'", buf
);
2873 fprintf (stderr
, "\t%s\n", buf
);
2876 fprintf (stderr
, "\n");
2878 do_wait (ldd_file_name
, pex
);
2880 signal (SIGINT
, int_handler
);
2882 signal (SIGQUIT
, quit_handler
);
2885 /* Now iterate through the library list adding their symbols to
2887 for (list
= libraries
.first
; list
; list
= list
->next
)
2888 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2891 #endif /* LDD_SUFFIX */
2893 #endif /* OBJECT_FORMAT_NONE */
2897 * COFF specific stuff.
2900 #ifdef OBJECT_FORMAT_COFF
2902 #if defined (EXTENDED_COFF)
2904 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2905 # define GCC_SYMENT SYMR
2906 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2907 # define GCC_SYMINC(X) (1)
2908 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2909 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2913 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2914 # define GCC_SYMENT SYMENT
2915 # if defined (C_WEAKEXT)
2916 # define GCC_OK_SYMBOL(X) \
2917 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2918 ((X).n_scnum > N_UNDEF) && \
2920 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2921 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2922 # define GCC_UNDEF_SYMBOL(X) \
2923 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2924 ((X).n_scnum == N_UNDEF))
2926 # define GCC_OK_SYMBOL(X) \
2927 (((X).n_sclass == C_EXT) && \
2928 ((X).n_scnum > N_UNDEF) && \
2930 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2931 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2932 # define GCC_UNDEF_SYMBOL(X) \
2933 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2935 # define GCC_SYMINC(X) ((X).n_numaux+1)
2936 # define GCC_SYMZERO(X) 0
2938 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2939 #if TARGET_AIX_VERSION >= 51
2940 # define GCC_CHECK_HDR(X) \
2941 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2942 || (HEADER (X).f_magic == 0767 && aix64_flag))
2944 # define GCC_CHECK_HDR(X) \
2945 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2946 || (HEADER (X).f_magic == 0757 && aix64_flag))
2951 #ifdef COLLECT_EXPORT_LIST
2952 /* Array of standard AIX libraries which should not
2953 be scanned for ctors/dtors. */
2954 static const char *const aix_std_libs
[] = {
2962 "/usr/lib/libc_r.a",
2963 "/usr/lib/libm_r.a",
2964 "/usr/lib/threads/libc.a",
2965 "/usr/ccs/lib/libc.a",
2966 "/usr/ccs/lib/libm.a",
2967 "/usr/ccs/lib/libc_r.a",
2968 "/usr/ccs/lib/libm_r.a",
2972 /* This function checks the filename and returns 1
2973 if this name matches the location of a standard AIX library. */
2974 static int ignore_library (const char *);
2976 ignore_library (const char *name
)
2978 const char *const *p
;
2981 if (target_system_root
[0] != '\0')
2983 length
= strlen (target_system_root
);
2984 if (strncmp (name
, target_system_root
, length
) != 0)
2988 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2989 if (strcmp (name
, *p
) == 0)
2993 #endif /* COLLECT_EXPORT_LIST */
2995 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2996 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2999 /* COFF version to scan the name list of the loaded program for
3000 the symbols g++ uses for static constructors and destructors. */
3003 scan_prog_file (const char *prog_name
, scanpass which_pass
,
3006 LDFILE
*ldptr
= NULL
;
3007 int sym_index
, sym_count
;
3010 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
3013 #ifdef COLLECT_EXPORT_LIST
3014 /* We do not need scanning for some standard C libraries. */
3015 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
3018 /* On AIX we have a loop, because there is not much difference
3019 between an object and an archive. This trick allows us to
3020 eliminate scan_libraries() function. */
3024 /* Some platforms (e.g. OSF4) declare ldopen as taking a
3025 non-const char * filename parameter, even though it will not
3026 modify that string. So we must cast away const-ness here,
3027 using CONST_CAST to prevent complaints from -Wcast-qual. */
3028 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
3030 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
3031 fatal ("%s: not a COFF file", prog_name
);
3033 if (GCC_CHECK_HDR (ldptr
))
3035 sym_count
= GCC_SYMBOLS (ldptr
);
3036 sym_index
= GCC_SYMZERO (ldptr
);
3038 #ifdef COLLECT_EXPORT_LIST
3039 /* Is current archive member a shared object? */
3040 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
3043 while (sym_index
< sym_count
)
3047 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
3049 sym_index
+= GCC_SYMINC (symbol
);
3051 if (GCC_OK_SYMBOL (symbol
))
3055 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
3056 continue; /* Should never happen. */
3058 #ifdef XCOFF_DEBUGGING_INFO
3059 /* All AIX function names have a duplicate entry
3060 beginning with a dot. */
3065 switch (is_ctor_dtor (name
))
3068 if (! (filter
& SCAN_CTOR
))
3071 add_to_list (&constructors
, name
);
3072 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3073 if (which_pass
== PASS_OBJ
)
3074 add_to_list (&exports
, name
);
3079 if (! (filter
& SCAN_DTOR
))
3082 add_to_list (&destructors
, name
);
3083 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3084 if (which_pass
== PASS_OBJ
)
3085 add_to_list (&exports
, name
);
3089 #ifdef COLLECT_EXPORT_LIST
3091 if (! (filter
& SCAN_INIT
))
3093 #ifndef LD_INIT_SWITCH
3095 add_to_list (&constructors
, name
);
3100 if (! (filter
& SCAN_FINI
))
3102 #ifndef LD_INIT_SWITCH
3104 add_to_list (&destructors
, name
);
3110 if (! (filter
& SCAN_DWEH
))
3113 add_to_list (&frame_tables
, name
);
3114 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3115 if (which_pass
== PASS_OBJ
)
3116 add_to_list (&exports
, name
);
3120 default: /* not a constructor or destructor */
3121 #ifdef COLLECT_EXPORT_LIST
3122 /* Explicitly export all global symbols when
3123 building a shared object on AIX, but do not
3124 re-export symbols from another shared object
3125 and do not export symbols if the user
3126 provides an explicit export list. */
3127 if (shared_obj
&& !is_shared
3128 && which_pass
== PASS_OBJ
&& !export_flag
)
3129 add_to_list (&exports
, name
);
3135 #if !defined(EXTENDED_COFF)
3136 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3137 symbol
.n_scnum
, symbol
.n_sclass
,
3138 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3142 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3143 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3148 #ifdef COLLECT_EXPORT_LIST
3151 /* If archive contains both 32-bit and 64-bit objects,
3152 we want to skip objects in other mode so mismatch normal. */
3154 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3155 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3161 fatal ("%s: cannot open as COFF file", prog_name
);
3163 #ifdef COLLECT_EXPORT_LIST
3164 /* On AIX loop continues while there are more members in archive. */
3166 while (ldclose (ldptr
) == FAILURE
);
3168 /* Otherwise we simply close ldptr. */
3169 (void) ldclose(ldptr
);
3172 #endif /* OBJECT_FORMAT_COFF */
3174 #ifdef COLLECT_EXPORT_LIST
3175 /* Given a library name without "lib" prefix, this function
3176 returns a full library name including a path. */
3178 resolve_lib_name (const char *name
)
3182 /* Library extensions for AIX dynamic linking. */
3183 const char * const libexts
[2] = {"a", "so"};
3185 for (i
= 0; libpaths
[i
]; i
++)
3186 if (libpaths
[i
]->max_len
> l
)
3187 l
= libpaths
[i
]->max_len
;
3189 lib_buf
= XNEWVEC (char, l
+ strlen(name
) + 10);
3191 for (i
= 0; libpaths
[i
]; i
++)
3193 struct prefix_list
*list
= libpaths
[i
]->plist
;
3194 for (; list
; list
= list
->next
)
3196 /* The following lines are needed because path_prefix list
3197 may contain directories both with trailing '/' and
3200 if (list
->prefix
[strlen(list
->prefix
)-1] != '/')
3202 for (j
= 0; j
< 2; j
++)
3204 sprintf (lib_buf
, "%s%slib%s.%s",
3205 list
->prefix
, p
, name
,
3206 libexts
[(j
+ aixrtl_flag
) % 2]);
3207 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3208 if (file_exists (lib_buf
))
3210 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3217 fprintf (stderr
, "not found\n");
3219 fatal ("library lib%s not found", name
);
3222 #endif /* COLLECT_EXPORT_LIST */