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
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 #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 int vflag
; /* true if -v */
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 int debug
; /* true if -debug */
198 static int shared_obj
; /* true if -shared */
200 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
201 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
202 #ifdef COLLECT_EXPORT_LIST
203 static const char *export_file
; /* <xxx>.x for AIX export list. */
205 static char **lto_o_files
; /* Output files for LTO. */
206 const char *ldout
; /* File for ld stdout. */
207 const char *lderrout
; /* File for ld stderr. */
208 static const char *output_file
; /* Output file for ld. */
209 static const char *nm_file_name
; /* pathname of nm */
211 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
213 static const char *strip_file_name
; /* pathname of strip */
214 const char *c_file_name
; /* pathname of gcc */
215 static char *initname
, *fininame
; /* names of init and fini funcs */
217 static struct head constructors
; /* list of constructors found */
218 static struct head destructors
; /* list of destructors found */
219 #ifdef COLLECT_EXPORT_LIST
220 static struct head exports
; /* list of exported symbols */
222 static struct head frame_tables
; /* list of frame unwind info tables */
224 static bool at_file_supplied
; /* Whether to use @file arguments */
225 static char *response_file
; /* Name of any current response file */
227 struct obstack temporary_obstack
;
228 char * temporary_firstobj
;
230 /* A string that must be prepended to a target OS path in order to find
231 it on the host system. */
232 #ifdef TARGET_SYSTEM_ROOT
233 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
235 static const char *target_system_root
= "";
238 /* Structure to hold all the directories in which to search for files to
243 const char *prefix
; /* String to prepend to the path. */
244 struct prefix_list
*next
; /* Next in linked list. */
249 struct prefix_list
*plist
; /* List of prefixes to try */
250 int max_len
; /* Max length of a prefix in PLIST */
251 const char *name
; /* Name of this list (used in config stuff) */
254 #ifdef COLLECT_EXPORT_LIST
255 /* Lists to keep libraries to be scanned for global constructors/destructors. */
256 static struct head libs
; /* list of libraries */
257 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
258 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
259 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
260 &libpath_lib_dirs
, NULL
};
263 /* List of names of object files containing LTO information.
264 These are a subset of the object file names appearing on the
265 command line, and must be identical, in the sense of pointer
266 equality, with the names passed to maybe_run_lto_and_relink(). */
270 const char *name
; /* Name of object file. */
271 struct lto_object
*next
; /* Next in linked list. */
274 struct lto_object_list
276 struct lto_object
*first
; /* First list element. */
277 struct lto_object
*last
; /* Last list element. */
280 static struct lto_object_list lto_objects
;
282 /* Special kinds of symbols that a name may denote. */
285 SYM_REGULAR
= 0, /* nothing special */
287 SYM_CTOR
= 1, /* constructor */
288 SYM_DTOR
= 2, /* destructor */
289 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
290 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
291 SYM_DWEH
= 5 /* DWARF exception handling table */
294 static symkind
is_ctor_dtor (const char *);
296 static void handler (int);
297 static char *find_a_file (struct path_prefix
*, const char *);
298 static void add_prefix (struct path_prefix
*, const char *);
299 static void prefix_from_env (const char *, struct path_prefix
*);
300 static void prefix_from_string (const char *, struct path_prefix
*);
301 static void do_wait (const char *, struct pex_obj
*);
302 static void fork_execute (const char *, char **);
303 static void maybe_unlink (const char *);
304 static void maybe_unlink_list (char **);
305 static void add_to_list (struct head
*, const char *);
306 static int extract_init_priority (const char *);
307 static void sort_ids (struct head
*);
308 static void write_list (FILE *, const char *, struct id
*);
309 #ifdef COLLECT_EXPORT_LIST
310 static void dump_list (FILE *, const char *, struct id
*);
313 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
315 static void write_list_with_asm (FILE *, const char *, struct id
*);
316 static void write_c_file (FILE *, const char *);
317 static void write_c_file_stat (FILE *, const char *);
318 #ifndef LD_INIT_SWITCH
319 static void write_c_file_glob (FILE *, const char *);
321 #ifdef SCAN_LIBRARIES
322 static void scan_libraries (const char *);
324 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
325 static int is_in_args (const char *, const char **, const char **);
327 #ifdef COLLECT_EXPORT_LIST
329 static int is_in_list (const char *, struct id
*);
331 static void write_aix_file (FILE *, struct id
*);
332 static char *resolve_lib_name (const char *);
334 static char *extract_string (const char **);
336 /* Enumerations describing which pass this is for scanning the
340 PASS_FIRST
, /* without constructors */
341 PASS_OBJ
, /* individual objects */
342 PASS_LIB
, /* looking for shared libraries */
343 PASS_SECOND
, /* with constructors linked in */
344 PASS_LTOINFO
/* looking for objects with LTO info */
347 /* ... and which kinds of symbols are to be considered. */
349 enum scanfilter_masks
{
352 SCAN_CTOR
= 1 << SYM_CTOR
,
353 SCAN_DTOR
= 1 << SYM_DTOR
,
354 SCAN_INIT
= 1 << SYM_INIT
,
355 SCAN_FINI
= 1 << SYM_FINI
,
356 SCAN_DWEH
= 1 << SYM_DWEH
,
360 /* This type is used for parameters and variables which hold
361 combinations of the flags in enum scanfilter_masks. */
362 typedef int scanfilter
;
364 /* Scan the name list of the loaded program for the symbols g++ uses for
365 static constructors and destructors.
367 The SCANPASS argument tells which collect processing pass this is for and
368 the SCANFILTER argument tells which kinds of symbols to consider in this
369 pass. Symbols of a special kind not in the filter mask are considered as
372 The constructor table begins at __CTOR_LIST__ and contains a count of the
373 number of pointers (or -1 if the constructors are built in a separate
374 section by the linker), followed by the pointers to the constructor
375 functions, terminated with a null pointer. The destructor table has the
376 same format, and begins at __DTOR_LIST__. */
378 static void scan_prog_file (const char *, scanpass
, scanfilter
);
381 /* Delete tempfiles and exit function. */
384 collect_exit (int status
)
386 if (c_file
!= 0 && c_file
[0])
387 maybe_unlink (c_file
);
389 if (o_file
!= 0 && o_file
[0])
390 maybe_unlink (o_file
);
392 #ifdef COLLECT_EXPORT_LIST
393 if (export_file
!= 0 && export_file
[0])
394 maybe_unlink (export_file
);
398 maybe_unlink_list (lto_o_files
);
400 if (ldout
!= 0 && ldout
[0])
402 dump_file (ldout
, stdout
);
403 maybe_unlink (ldout
);
406 if (lderrout
!= 0 && lderrout
[0])
408 dump_file (lderrout
, stderr
);
409 maybe_unlink (lderrout
);
412 if (status
!= 0 && output_file
!= 0 && output_file
[0])
413 maybe_unlink (output_file
);
416 maybe_unlink (response_file
);
422 /* Notify user of a non-error. */
424 notice (const char *cmsgid
, ...)
428 va_start (ap
, cmsgid
);
429 vfprintf (stderr
, _(cmsgid
), ap
);
433 /* Die when sys call fails. */
436 fatal_perror (const char * cmsgid
, ...)
441 va_start (ap
, cmsgid
);
442 fprintf (stderr
, "collect2: ");
443 vfprintf (stderr
, _(cmsgid
), ap
);
444 fprintf (stderr
, ": %s\n", xstrerror (e
));
447 collect_exit (FATAL_EXIT_CODE
);
453 fatal (const char * cmsgid
, ...)
457 va_start (ap
, cmsgid
);
458 fprintf (stderr
, "collect2: ");
459 vfprintf (stderr
, _(cmsgid
), ap
);
460 fprintf (stderr
, "\n");
463 collect_exit (FATAL_EXIT_CODE
);
466 /* Write error message. */
469 error (const char * gmsgid
, ...)
473 va_start (ap
, gmsgid
);
474 fprintf (stderr
, "collect2: ");
475 vfprintf (stderr
, _(gmsgid
), ap
);
476 fprintf (stderr
, "\n");
480 /* In case obstack is linked in, and abort is defined to fancy_abort,
481 provide a default entry. */
484 fancy_abort (const char *file
, int line
, const char *func
)
486 fatal ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
492 if (c_file
!= 0 && c_file
[0])
493 maybe_unlink (c_file
);
495 if (o_file
!= 0 && o_file
[0])
496 maybe_unlink (o_file
);
498 if (ldout
!= 0 && ldout
[0])
499 maybe_unlink (ldout
);
501 if (lderrout
!= 0 && lderrout
[0])
502 maybe_unlink (lderrout
);
504 #ifdef COLLECT_EXPORT_LIST
505 if (export_file
!= 0 && export_file
[0])
506 maybe_unlink (export_file
);
510 maybe_unlink_list (lto_o_files
);
513 maybe_unlink (response_file
);
515 signal (signo
, SIG_DFL
);
521 file_exists (const char *name
)
523 return access (name
, R_OK
) == 0;
526 /* Parse a reasonable subset of shell quoting syntax. */
529 extract_string (const char **pp
)
542 obstack_1grow (&temporary_obstack
, c
);
543 else if (! inside
&& c
== ' ')
545 else if (! inside
&& c
== '\\')
550 obstack_1grow (&temporary_obstack
, c
);
553 obstack_1grow (&temporary_obstack
, '\0');
555 return XOBFINISH (&temporary_obstack
, char *);
559 dump_file (const char *name
, FILE *to
)
561 FILE *stream
= fopen (name
, "r");
568 while (c
= getc (stream
),
569 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
570 obstack_1grow (&temporary_obstack
, c
);
571 if (obstack_object_size (&temporary_obstack
) > 0)
573 const char *word
, *p
;
575 obstack_1grow (&temporary_obstack
, '\0');
576 word
= XOBFINISH (&temporary_obstack
, const char *);
579 ++word
, putc ('.', to
);
581 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
582 p
+= strlen (USER_LABEL_PREFIX
);
584 #ifdef HAVE_LD_DEMANGLE
590 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
598 diff
= strlen (word
) - strlen (result
);
599 while (diff
> 0 && c
== ' ')
600 --diff
, putc (' ', to
);
601 if (diff
< 0 && c
== ' ')
603 while (diff
< 0 && c
== ' ')
604 ++diff
, c
= getc (stream
);
607 /* Make sure we output at least one space, or
608 the demangled symbol name will run into
609 whatever text follows. */
620 obstack_free (&temporary_obstack
, temporary_firstobj
);
629 /* Return the kind of symbol denoted by name S. */
632 is_ctor_dtor (const char *s
)
634 struct names
{ const char *const name
; const int len
; symkind ret
;
635 const int two_underscores
; };
637 const struct names
*p
;
639 const char *orig_s
= s
;
641 static const struct names special
[] = {
642 #ifndef NO_DOLLAR_IN_LABEL
643 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
644 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
646 #ifndef NO_DOT_IN_LABEL
647 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
648 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
649 #endif /* NO_DOT_IN_LABEL */
650 #endif /* NO_DOLLAR_IN_LABEL */
651 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
652 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
653 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
654 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
655 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
656 { NULL
, 0, SYM_REGULAR
, 0 }
659 while ((ch
= *s
) == '_')
665 for (p
= &special
[0]; p
->len
> 0; p
++)
668 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
669 && strncmp(s
, p
->name
, p
->len
) == 0)
677 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
678 and one from the PATH variable. */
680 static struct path_prefix cpath
, path
;
682 #ifdef CROSS_DIRECTORY_STRUCTURE
683 /* This is the name of the target machine. We use it to form the name
684 of the files to execute. */
686 static const char *const target_machine
= TARGET_MACHINE
;
689 /* Search for NAME using prefix list PPREFIX. We only look for executable
692 Return 0 if not found, otherwise return its name, allocated with malloc. */
695 find_a_file (struct path_prefix
*pprefix
, const char *name
)
698 struct prefix_list
*pl
;
699 int len
= pprefix
->max_len
+ strlen (name
) + 1;
702 fprintf (stderr
, "Looking for '%s'\n", name
);
704 #ifdef HOST_EXECUTABLE_SUFFIX
705 len
+= strlen (HOST_EXECUTABLE_SUFFIX
);
708 temp
= XNEWVEC (char, len
);
710 /* Determine the filename to execute (special case for absolute paths). */
712 if (IS_ABSOLUTE_PATH (name
))
714 if (access (name
, X_OK
) == 0)
719 fprintf (stderr
, " - found: absolute path\n");
724 #ifdef HOST_EXECUTABLE_SUFFIX
725 /* Some systems have a suffix for executable files.
726 So try appending that. */
728 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
730 if (access (temp
, X_OK
) == 0)
735 fprintf (stderr
, " - failed to locate using absolute path\n");
738 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
742 strcpy (temp
, pl
->prefix
);
745 if (stat (temp
, &st
) >= 0
746 && ! S_ISDIR (st
.st_mode
)
747 && access (temp
, X_OK
) == 0)
750 #ifdef HOST_EXECUTABLE_SUFFIX
751 /* Some systems have a suffix for executable files.
752 So try appending that. */
753 strcat (temp
, HOST_EXECUTABLE_SUFFIX
);
755 if (stat (temp
, &st
) >= 0
756 && ! S_ISDIR (st
.st_mode
)
757 && access (temp
, X_OK
) == 0)
762 if (debug
&& pprefix
->plist
== NULL
)
763 fprintf (stderr
, " - failed: no entries in prefix list\n");
769 /* Add an entry for PREFIX to prefix list PPREFIX. */
772 add_prefix (struct path_prefix
*pprefix
, const char *prefix
)
774 struct prefix_list
*pl
, **prev
;
779 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
784 prev
= &pprefix
->plist
;
786 /* Keep track of the longest prefix. */
788 len
= strlen (prefix
);
789 if (len
> pprefix
->max_len
)
790 pprefix
->max_len
= len
;
792 pl
= XNEW (struct prefix_list
);
793 pl
->prefix
= xstrdup (prefix
);
798 pl
->next
= (struct prefix_list
*) 0;
802 /* Take the value of the environment variable ENV, break it into a path, and
803 add of the entries to PPREFIX. */
806 prefix_from_env (const char *env
, struct path_prefix
*pprefix
)
809 GET_ENVIRONMENT (p
, env
);
812 prefix_from_string (p
, pprefix
);
816 prefix_from_string (const char *p
, struct path_prefix
*pprefix
)
818 const char *startp
, *endp
;
819 char *nstore
= XNEWVEC (char, strlen (p
) + 3);
822 fprintf (stderr
, "Convert string '%s' into prefixes, separator = '%c'\n", p
, PATH_SEPARATOR
);
827 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
829 strncpy (nstore
, startp
, endp
-startp
);
832 strcpy (nstore
, "./");
834 else if (! IS_DIR_SEPARATOR (endp
[-1]))
836 nstore
[endp
-startp
] = DIR_SEPARATOR
;
837 nstore
[endp
-startp
+1] = 0;
840 nstore
[endp
-startp
] = 0;
843 fprintf (stderr
, " - add prefix: %s\n", nstore
);
845 add_prefix (pprefix
, nstore
);
848 endp
= startp
= endp
+ 1;
856 #ifdef OBJECT_FORMAT_NONE
858 /* Add an entry for the object file NAME to object file list LIST.
859 New entries are added at the end of the list. The original pointer
860 value of NAME is preserved, i.e., no string copy is performed. */
863 add_lto_object (struct lto_object_list
*list
, const char *name
)
865 struct lto_object
*n
= XNEW (struct lto_object
);
870 list
->last
->next
= n
;
876 #endif /* OBJECT_FORMAT_NONE */
879 /* Perform a link-time recompilation and relink if any of the object
880 files contain LTO info. The linker command line LTO_LD_ARGV
881 represents the linker command that would produce a final executable
882 without the use of LTO. OBJECT_LST is a vector of object file names
883 appearing in LTO_LD_ARGV that are to be considerd for link-time
884 recompilation, where OBJECT is a pointer to the last valid element.
885 (This awkward convention avoids an impedance mismatch with the
886 usage of similarly-named variables in main().) The elements of
887 OBJECT_LST must be identical, i.e., pointer equal, to the
888 corresponding arguments in LTO_LD_ARGV.
890 Upon entry, at least one linker run has been performed without the
891 use of any LTO info that might be present. Any recompilations
892 necessary for template instantiations have been performed, and
893 initializer/finalizer tables have been created if needed and
894 included in the linker command line LTO_LD_ARGV. If any of the
895 object files contain LTO info, we run the LTO back end on all such
896 files, and perform the final link with the LTO back end output
897 substituted for the LTO-optimized files. In some cases, a final
898 link with all link-time generated code has already been performed,
899 so there is no need to relink if no LTO info is found. In other
900 cases, our caller has not produced the final executable, and is
901 relying on us to perform the required link whether LTO info is
902 present or not. In that case, the FORCE argument should be true.
903 Note that the linker command line argument LTO_LD_ARGV passed into
904 this function may be modified in place. */
907 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
908 const char **object
, bool force
)
910 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
912 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
914 while (object_file
< object
)
916 /* If file contains LTO info, add it to the list of LTO objects. */
917 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
919 /* Increment the argument count by the number of object file arguments
920 we will add. An upper bound suffices, so just count all of the
921 object files regardless of whether they contain LTO info. */
925 if (lto_objects
.first
)
929 const char **lto_c_ptr
;
931 const char **p
, **q
, **r
;
932 const char **lto_o_ptr
;
933 struct lto_object
*list
;
934 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
936 const char *prog
= "lto-wrapper";
939 fatal ("COLLECT_LTO_WRAPPER must be set.");
941 /* There is at least one object file containing LTO info,
942 so we need to run the LTO back end and relink. */
944 /* Get compiler options passed down from the parent `gcc' command.
945 These must be passed to the LTO back end. */
946 opts
= getenv ("COLLECT_GCC_OPTIONS");
948 /* Increment the argument count by the number of inherited options.
949 Some arguments may be filtered out later. Again, an upper bound
956 extract_string (&cp
);
959 obstack_free (&temporary_obstack
, temporary_firstobj
);
964 /* Increment the argument count by the number of initial
965 arguments added below. */
968 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
969 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
971 *lto_c_ptr
++ = lto_wrapper
;
972 *lto_c_ptr
++ = c_file_name
;
978 const char *s
= extract_string (&cp
);
980 /* Pass the option or argument to the wrapper. */
981 *lto_c_ptr
++ = xstrdup (s
);
983 obstack_free (&temporary_obstack
, temporary_firstobj
);
986 *lto_c_ptr
++ = xstrdup ("-debug");
988 /* Add LTO objects to the wrapper command line. */
989 for (list
= lto_objects
.first
; list
; list
= list
->next
)
990 *lto_c_ptr
++ = list
->name
;
994 /* Save intermediate WPA files in lto1 if debug. */
996 putenv (xstrdup ("WPA_SAVE_LTRANS=1"));
998 /* Run the LTO back end. */
999 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
1003 size_t i
, num_files
;
1006 stream
= pex_read_output (pex
, 0);
1007 gcc_assert (stream
);
1010 while ((c
= getc (stream
)) != EOF
)
1012 obstack_1grow (&temporary_obstack
, c
);
1017 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
1018 lto_o_files
[num_files
] = NULL
;
1019 start
= XOBFINISH (&temporary_obstack
, char *);
1020 for (i
= 0; i
< num_files
; ++i
)
1023 while (*end
!= '\n')
1027 lto_o_files
[i
] = xstrdup (start
);
1032 obstack_free (&temporary_obstack
, temporary_firstobj
);
1034 do_wait (prog
, pex
);
1037 /* After running the LTO back end, we will relink, substituting
1038 the LTO output for the object files that we submitted to the
1039 LTO. Here, we modify the linker command line for the relink. */
1040 p
= CONST_CAST2 (const char **, char **, lto_ld_argv
);
1041 lto_o_ptr
= CONST_CAST2 (const char **, char **, lto_o_files
);
1045 for (list
= lto_objects
.first
; list
; list
= list
->next
)
1047 if (*p
== list
->name
) /* Note test for pointer equality! */
1049 /* Excise argument from linker command line. */
1052 /* Replace first argument with LTO output file. */
1053 *p
++ = *lto_o_ptr
++;
1057 /* Move following arguments one position earlier,
1058 overwriting the current argument. */
1066 /* No need to continue searching the LTO object list. */
1071 /* If we didn't find a match, move on to the next argument.
1072 Otherwise, P has been set to the correct argument position
1073 at which to continue. */
1077 /* The code above assumes we will never have more lto output files than
1078 input files. Otherwise, we need to resize lto_ld_argv. Check this
1081 fatal ("too many lto output files");
1083 /* Run the linker again, this time replacing the object files
1084 optimized by the LTO with the temporary file generated by the LTO. */
1085 fork_execute ("ld", lto_ld_argv
);
1087 maybe_unlink_list (lto_o_files
);
1091 /* Our caller is relying on us to do the link
1092 even though there is no LTO back end work to be done. */
1093 fork_execute ("ld", lto_ld_argv
);
1100 main (int argc
, char **argv
)
1102 static const char *const ld_suffix
= "ld";
1103 static const char *const real_ld_suffix
= "real-ld";
1104 static const char *const collect_ld_suffix
= "collect-ld";
1105 static const char *const nm_suffix
= "nm";
1106 static const char *const gnm_suffix
= "gnm";
1108 static const char *const ldd_suffix
= LDD_SUFFIX
;
1110 static const char *const strip_suffix
= "strip";
1111 static const char *const gstrip_suffix
= "gstrip";
1113 #ifdef CROSS_DIRECTORY_STRUCTURE
1114 /* If we look for a program in the compiler directories, we just use
1115 the short name, since these directories are already system-specific.
1116 But it we look for a program in the system directories, we need to
1117 qualify the program name with the target machine. */
1119 const char *const full_ld_suffix
=
1120 concat(target_machine
, "-", ld_suffix
, NULL
);
1121 const char *const full_nm_suffix
=
1122 concat (target_machine
, "-", nm_suffix
, NULL
);
1123 const char *const full_gnm_suffix
=
1124 concat (target_machine
, "-", gnm_suffix
, NULL
);
1126 const char *const full_ldd_suffix
=
1127 concat (target_machine
, "-", ldd_suffix
, NULL
);
1129 const char *const full_strip_suffix
=
1130 concat (target_machine
, "-", strip_suffix
, NULL
);
1131 const char *const full_gstrip_suffix
=
1132 concat (target_machine
, "-", gstrip_suffix
, NULL
);
1134 const char *const full_ld_suffix
= ld_suffix
;
1135 const char *const full_nm_suffix
= nm_suffix
;
1136 const char *const full_gnm_suffix
= gnm_suffix
;
1138 const char *const full_ldd_suffix
= ldd_suffix
;
1140 const char *const full_strip_suffix
= strip_suffix
;
1141 const char *const full_gstrip_suffix
= gstrip_suffix
;
1142 #endif /* CROSS_DIRECTORY_STRUCTURE */
1146 #ifdef COLLECT_EXPORT_LIST
1149 const char *ld_file_name
;
1156 /* The kinds of symbols we will have to consider when scanning the
1157 outcome of a first pass link. This is ALL to start with, then might
1158 be adjusted before getting to the first pass link per se, typically on
1159 AIX where we perform an early scan of objects and libraries to fetch
1160 the list of global ctors/dtors and make sure they are not garbage
1162 scanfilter ld1_filter
= SCAN_ALL
;
1167 const char **object
;
1173 expandargv (&argc
, &argv
);
1174 if (argv
!= old_argv
)
1175 at_file_supplied
= 1;
1177 num_c_args
= argc
+ 9;
1179 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
1181 /* Suppress demangling by the real linker, which may be broken. */
1182 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
1184 #if defined (COLLECT2_HOST_INITIALIZATION)
1185 /* Perform system dependent initialization, if necessary. */
1186 COLLECT2_HOST_INITIALIZATION
;
1190 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1191 receive the signal. A different setting is inheritable */
1192 signal (SIGCHLD
, SIG_DFL
);
1195 /* Unlock the stdio streams. */
1196 unlock_std_streams ();
1198 gcc_init_libintl ();
1200 /* Do not invoke xcalloc before this point, since locale needs to be
1201 set first, in case a diagnostic is issued. */
1203 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
1204 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
1205 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
1206 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
1207 object_lst
= XCNEWVEC (char *, argc
);
1208 object
= CONST_CAST2 (const char **, char **, object_lst
);
1214 /* Parse command line early for instances of -debug. This allows
1215 the debug flag to be set before functions like find_a_file()
1216 are called. We also look for the -flto or -fwhopr flag to know
1217 what LTO mode we are in. */
1220 bool use_plugin
= false;
1222 for (i
= 1; argv
[i
] != NULL
; i
++)
1224 if (! strcmp (argv
[i
], "-debug"))
1226 else if (! strcmp (argv
[i
], "-flto") && ! use_plugin
)
1227 lto_mode
= LTO_MODE_LTO
;
1228 else if (! strcmp (argv
[i
], "-fwhopr") && ! use_plugin
)
1229 lto_mode
= LTO_MODE_WHOPR
;
1230 else if (! strcmp (argv
[i
], "-plugin"))
1233 lto_mode
= LTO_MODE_NONE
;
1235 #ifdef COLLECT_EXPORT_LIST
1236 /* since -brtl, -bexport, -b64 are not position dependent
1237 also check for them here */
1238 if ((argv
[i
][0] == '-') && (argv
[i
][1] == 'b'))
1241 /* We want to disable automatic exports on AIX when user
1242 explicitly puts an export list in command line */
1243 if (arg
[2] == 'E' || strncmp (&arg
[2], "export", 6) == 0)
1245 else if (arg
[2] == '6' && arg
[3] == '4')
1247 else if (arg
[2] == 'r' && arg
[3] == 't' && arg
[4] == 'l')
1255 #ifndef DEFAULT_A_OUT_NAME
1256 output_file
= "a.out";
1258 output_file
= DEFAULT_A_OUT_NAME
;
1261 obstack_begin (&temporary_obstack
, 0);
1262 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1264 #ifndef HAVE_LD_DEMANGLE
1265 current_demangling_style
= auto_demangling
;
1267 p
= getenv ("COLLECT_GCC_OPTIONS");
1270 const char *q
= extract_string (&p
);
1271 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1274 obstack_free (&temporary_obstack
, temporary_firstobj
);
1276 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1277 -fno-exceptions -w -fno-whole-program */
1280 c_argv
= XCNEWVEC (char *, num_c_args
);
1281 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1284 fatal ("no arguments");
1287 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1288 signal (SIGQUIT
, handler
);
1290 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1291 signal (SIGINT
, handler
);
1293 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1294 signal (SIGALRM
, handler
);
1297 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1298 signal (SIGHUP
, handler
);
1300 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1301 signal (SIGSEGV
, handler
);
1303 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1304 signal (SIGBUS
, handler
);
1307 /* Extract COMPILER_PATH and PATH into our prefix list. */
1308 prefix_from_env ("COMPILER_PATH", &cpath
);
1309 prefix_from_env ("PATH", &path
);
1311 /* Try to discover a valid linker/nm/strip to use. */
1313 /* Maybe we know the right file to use (if not cross). */
1315 #ifdef DEFAULT_LINKER
1316 if (access (DEFAULT_LINKER
, X_OK
) == 0)
1317 ld_file_name
= DEFAULT_LINKER
;
1318 if (ld_file_name
== 0)
1320 #ifdef REAL_LD_FILE_NAME
1321 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
);
1322 if (ld_file_name
== 0)
1324 /* Search the (target-specific) compiler dirs for ld'. */
1325 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
);
1326 /* Likewise for `collect-ld'. */
1327 if (ld_file_name
== 0)
1328 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
);
1329 /* Search the compiler directories for `ld'. We have protection against
1330 recursive calls in find_a_file. */
1331 if (ld_file_name
== 0)
1332 ld_file_name
= find_a_file (&cpath
, ld_suffix
);
1333 /* Search the ordinary system bin directories
1334 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1335 if (ld_file_name
== 0)
1336 ld_file_name
= find_a_file (&path
, full_ld_suffix
);
1338 #ifdef REAL_NM_FILE_NAME
1339 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
);
1340 if (nm_file_name
== 0)
1342 nm_file_name
= find_a_file (&cpath
, gnm_suffix
);
1343 if (nm_file_name
== 0)
1344 nm_file_name
= find_a_file (&path
, full_gnm_suffix
);
1345 if (nm_file_name
== 0)
1346 nm_file_name
= find_a_file (&cpath
, nm_suffix
);
1347 if (nm_file_name
== 0)
1348 nm_file_name
= find_a_file (&path
, full_nm_suffix
);
1351 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
);
1352 if (ldd_file_name
== 0)
1353 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
);
1356 #ifdef REAL_STRIP_FILE_NAME
1357 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
);
1358 if (strip_file_name
== 0)
1360 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
);
1361 if (strip_file_name
== 0)
1362 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
);
1363 if (strip_file_name
== 0)
1364 strip_file_name
= find_a_file (&cpath
, strip_suffix
);
1365 if (strip_file_name
== 0)
1366 strip_file_name
= find_a_file (&path
, full_strip_suffix
);
1368 /* Determine the full path name of the C compiler to use. */
1369 c_file_name
= getenv ("COLLECT_GCC");
1370 if (c_file_name
== 0)
1372 #ifdef CROSS_DIRECTORY_STRUCTURE
1373 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1375 c_file_name
= "gcc";
1379 p
= find_a_file (&cpath
, c_file_name
);
1381 /* Here it should be safe to use the system search path since we should have
1382 already qualified the name of the compiler when it is needed. */
1384 p
= find_a_file (&path
, c_file_name
);
1389 *ld1
++ = *ld2
++ = ld_file_name
;
1391 /* Make temp file names. */
1392 c_file
= make_temp_file (".c");
1393 o_file
= make_temp_file (".o");
1394 #ifdef COLLECT_EXPORT_LIST
1395 export_file
= make_temp_file (".x");
1397 ldout
= make_temp_file (".ld");
1398 lderrout
= make_temp_file (".le");
1399 *c_ptr
++ = c_file_name
;
1406 #ifdef COLLECT_EXPORT_LIST
1407 /* Generate a list of directories from LIBPATH. */
1408 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1409 /* Add to this list also two standard directories where
1410 AIX loader always searches for libraries. */
1411 add_prefix (&libpath_lib_dirs
, "/lib");
1412 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1415 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1417 AIX support needs to know if -shared has been specified before
1418 parsing commandline arguments. */
1420 p
= getenv ("COLLECT_GCC_OPTIONS");
1423 const char *q
= extract_string (&p
);
1424 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1425 *c_ptr
++ = xstrdup (q
);
1426 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1427 *c_ptr
++ = xstrdup (q
);
1428 if (strcmp (q
, "-shared") == 0)
1430 if (*q
== '-' && q
[1] == 'B')
1432 *c_ptr
++ = xstrdup (q
);
1435 q
= extract_string (&p
);
1436 *c_ptr
++ = xstrdup (q
);
1440 obstack_free (&temporary_obstack
, temporary_firstobj
);
1441 *c_ptr
++ = "-fno-profile-arcs";
1442 *c_ptr
++ = "-fno-test-coverage";
1443 *c_ptr
++ = "-fno-branch-probabilities";
1444 *c_ptr
++ = "-fno-exceptions";
1446 *c_ptr
++ = "-fno-whole-program";
1448 /* !!! When GCC calls collect2,
1449 it does not know whether it is calling collect2 or ld.
1450 So collect2 cannot meaningfully understand any options
1451 except those ld understands.
1452 If you propose to make GCC pass some other option,
1453 just imagine what will happen if ld is really ld!!! */
1455 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1456 /* After the first file, put in the c++ rt0. */
1459 #ifdef HAVE_LD_DEMANGLE
1460 if (!demangle_flag
&& !no_demangle
)
1461 demangle_flag
= "--demangle";
1463 *ld1
++ = *ld2
++ = demangle_flag
;
1465 while ((arg
= *++argv
) != (char *) 0)
1467 *ld1
++ = *ld2
++ = arg
;
1474 if (!strcmp (arg
, "-debug"))
1476 /* Already parsed. */
1480 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1483 *ld1
++ = *ld2
++ = *argv
;
1488 if (strcmp (arg
, "-flto") == 0 || strcmp (arg
, "-fwhopr") == 0)
1491 /* Do not pass LTO flag to the linker. */
1495 error ("LTO support has not been enabled in this "
1504 /* place o_file BEFORE this argument! */
1510 #ifdef COLLECT_EXPORT_LIST
1512 /* Resolving full library name. */
1513 const char *s
= resolve_lib_name (arg
+2);
1515 /* Saving a full library name. */
1516 add_to_list (&libs
, s
);
1521 #ifdef COLLECT_EXPORT_LIST
1522 /* Saving directories where to search for libraries. */
1524 add_prefix (&cmdline_lib_dirs
, arg
+2);
1527 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1529 if (is_in_args (arg
,
1530 CONST_CAST2 (const char **, char **, ld1_argv
),
1534 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1539 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1541 #ifdef SWITCHES_NEED_SPACES
1542 && ! strchr (SWITCHES_NEED_SPACES
, arg
[1])
1546 output_file
= &arg
[2];
1555 if (arg
[2] == '\0' && do_collecting
)
1557 /* We must strip after the nm run, otherwise C++ linking
1558 will not work. Thus we strip in the second ld run, or
1559 else with strip if there is no second ld run. */
1571 if (strcmp (arg
, "--no-demangle") == 0)
1573 demangle_flag
= arg
;
1578 else if (strncmp (arg
, "--demangle", 10) == 0)
1580 demangle_flag
= arg
;
1582 #ifndef HAVE_LD_DEMANGLE
1585 enum demangling_styles style
1586 = cplus_demangle_name_to_style (arg
+11);
1587 if (style
== unknown_demangling
)
1588 error ("unknown demangling style '%s'", arg
+11);
1590 current_demangling_style
= style
;
1596 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1597 target_system_root
= arg
+ 10;
1601 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1602 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1603 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1604 || strcmp (p
, ".obj") == 0))
1613 /* place o_file BEFORE this argument! */
1619 if (p
[1] == 'o' || p
[1] == 'l')
1621 #ifdef COLLECT_EXPORT_LIST
1622 /* libraries can be specified directly, i.e. without -l flag. */
1625 /* Saving a full library name. */
1626 add_to_list (&libs
, arg
);
1632 #ifdef COLLECT_EXPORT_LIST
1633 /* This is added only for debugging purposes. */
1636 fprintf (stderr
, "List of libraries:\n");
1637 dump_list (stderr
, "\t", libs
.first
);
1640 /* The AIX linker will discard static constructors in object files if
1641 nothing else in the file is referenced, so look at them first. Unless
1642 we are building a shared object, ignore the eh frame tables, as we
1643 would otherwise reference them all, hence drag all the corresponding
1644 objects even if nothing else is referenced. */
1646 const char **export_object_lst
1647 = CONST_CAST2 (const char **, char **, object_lst
);
1649 struct id
*list
= libs
.first
;
1651 /* Compute the filter to use from the current one, do scan, then adjust
1652 the "current" filter to remove what we just included here. This will
1653 control whether we need a first pass link later on or not, and what
1654 will remain to be scanned there. */
1656 scanfilter this_filter
1657 = shared_obj
? ld1_filter
: (ld1_filter
& ~SCAN_DWEH
);
1659 while (export_object_lst
< object
)
1660 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1662 for (; list
; list
= list
->next
)
1663 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1665 ld1_filter
= ld1_filter
& ~this_filter
;
1670 char *buf
= concat ("-bE:", export_file
, NULL
);
1675 exportf
= fopen (export_file
, "w");
1676 if (exportf
== (FILE *) 0)
1677 fatal_perror ("fopen %s", export_file
);
1678 write_aix_file (exportf
, exports
.first
);
1679 if (fclose (exportf
))
1680 fatal_perror ("fclose %s", export_file
);
1685 *c_ptr
= *ld1
= *object
= (char *) 0;
1689 notice ("collect2 version %s", version_string
);
1690 #ifdef TARGET_VERSION
1693 fprintf (stderr
, "\n");
1699 fprintf (stderr
, "ld_file_name = %s\n",
1700 (ld_file_name
? ld_file_name
: "not found"));
1701 fprintf (stderr
, "c_file_name = %s\n",
1702 (c_file_name
? c_file_name
: "not found"));
1703 fprintf (stderr
, "nm_file_name = %s\n",
1704 (nm_file_name
? nm_file_name
: "not found"));
1706 fprintf (stderr
, "ldd_file_name = %s\n",
1707 (ldd_file_name
? ldd_file_name
: "not found"));
1709 fprintf (stderr
, "strip_file_name = %s\n",
1710 (strip_file_name
? strip_file_name
: "not found"));
1711 fprintf (stderr
, "c_file = %s\n",
1712 (c_file
? c_file
: "not found"));
1713 fprintf (stderr
, "o_file = %s\n",
1714 (o_file
? o_file
: "not found"));
1716 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1718 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1720 ptr
= getenv ("COLLECT_GCC");
1722 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1724 ptr
= getenv ("COMPILER_PATH");
1726 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1728 ptr
= getenv (LIBRARY_PATH_ENV
);
1730 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1732 fprintf (stderr
, "\n");
1735 /* Load the program, searching all libraries and attempting to provide
1736 undefined symbols from repository information.
1738 If -r or they will be run via some other method, do not build the
1739 constructor or destructor list, just return now. */
1742 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1744 /* Perform the first pass link now, if we're about to exit or if we need
1745 to scan for things we haven't collected yet before pursuing further.
1747 On AIX, the latter typically includes nothing for shared objects or
1748 frame tables for an executable, out of what the required early scan on
1749 objects and libraries has performed above. In the !shared_obj case, we
1750 expect the relevant tables to be dragged together with their associated
1751 functions from precise cross reference insertions by the compiler. */
1753 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1754 do_tlink (ld1_argv
, object_lst
);
1758 #ifdef COLLECT_EXPORT_LIST
1759 /* Make sure we delete the export file we may have created. */
1760 if (export_file
!= 0 && export_file
[0])
1761 maybe_unlink (export_file
);
1764 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1766 maybe_unlink (c_file
);
1767 maybe_unlink (o_file
);
1772 /* Unless we have done it all already, examine the namelist and search for
1773 static constructors and destructors to call. Write the constructor and
1774 destructor tables to a .s file and reload. */
1776 if (ld1_filter
!= SCAN_NOTHING
)
1777 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1779 #ifdef SCAN_LIBRARIES
1780 scan_libraries (output_file
);
1785 notice ("%d constructor(s) found\n", constructors
.number
);
1786 notice ("%d destructor(s) found\n", destructors
.number
);
1787 notice ("%d frame table(s) found\n", frame_tables
.number
);
1790 /* If the scan exposed nothing of special interest, there's no need to
1791 generate the glue code and relink so return now. */
1793 if (constructors
.number
== 0 && destructors
.number
== 0
1794 && frame_tables
.number
== 0
1795 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1796 /* If we will be running these functions ourselves, we want to emit
1797 stubs into the shared library so that we do not have to relink
1798 dependent programs when we add static objects. */
1803 /* Do tlink without additional code generation now if we didn't
1804 do it earlier for scanning purposes. */
1805 if (ld1_filter
== SCAN_NOTHING
)
1806 do_tlink (ld1_argv
, object_lst
);
1809 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1811 /* Strip now if it was requested on the command line. */
1814 char **real_strip_argv
= XCNEWVEC (char *, 3);
1815 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1818 strip_argv
[0] = strip_file_name
;
1819 strip_argv
[1] = output_file
;
1820 strip_argv
[2] = (char *) 0;
1821 fork_execute ("strip", real_strip_argv
);
1824 #ifdef COLLECT_EXPORT_LIST
1825 maybe_unlink (export_file
);
1827 maybe_unlink (c_file
);
1828 maybe_unlink (o_file
);
1832 /* Sort ctor and dtor lists by priority. */
1833 sort_ids (&constructors
);
1834 sort_ids (&destructors
);
1836 maybe_unlink(output_file
);
1837 outf
= fopen (c_file
, "w");
1838 if (outf
== (FILE *) 0)
1839 fatal_perror ("fopen %s", c_file
);
1841 write_c_file (outf
, c_file
);
1844 fatal_perror ("fclose %s", c_file
);
1846 /* Tell the linker that we have initializer and finalizer functions. */
1847 #ifdef LD_INIT_SWITCH
1848 #ifdef COLLECT_EXPORT_LIST
1849 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1851 *ld2
++ = LD_INIT_SWITCH
;
1853 *ld2
++ = LD_FINI_SWITCH
;
1858 #ifdef COLLECT_EXPORT_LIST
1861 /* If we did not add export flag to link arguments before, add it to
1862 second link phase now. No new exports should have been added. */
1863 if (! exports
.first
)
1864 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1866 #ifndef LD_INIT_SWITCH
1867 add_to_list (&exports
, initname
);
1868 add_to_list (&exports
, fininame
);
1869 add_to_list (&exports
, "_GLOBAL__DI");
1870 add_to_list (&exports
, "_GLOBAL__DD");
1872 exportf
= fopen (export_file
, "w");
1873 if (exportf
== (FILE *) 0)
1874 fatal_perror ("fopen %s", export_file
);
1875 write_aix_file (exportf
, exports
.first
);
1876 if (fclose (exportf
))
1877 fatal_perror ("fclose %s", export_file
);
1881 /* End of arguments to second link phase. */
1886 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1887 output_file
, c_file
);
1888 write_c_file (stderr
, "stderr");
1889 fprintf (stderr
, "========== end of c_file\n\n");
1890 #ifdef COLLECT_EXPORT_LIST
1891 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1892 write_aix_file (stderr
, exports
.first
);
1893 fprintf (stderr
, "========== end of export_file\n\n");
1897 /* Assemble the constructor and destructor tables.
1898 Link the tables in with the rest of the program. */
1900 fork_execute ("gcc", c_argv
);
1901 #ifdef COLLECT_EXPORT_LIST
1902 /* On AIX we must call tlink because of possible templates resolution. */
1903 do_tlink (ld2_argv
, object_lst
);
1906 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1908 /* Otherwise, simply call ld because tlink is already done. */
1910 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1912 fork_execute ("ld", ld2_argv
);
1914 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1915 constructors/destructors in shared libraries. */
1916 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1919 maybe_unlink (c_file
);
1920 maybe_unlink (o_file
);
1922 #ifdef COLLECT_EXPORT_LIST
1923 maybe_unlink (export_file
);
1930 /* Wait for a process to finish, and exit if a nonzero status is found. */
1933 collect_wait (const char *prog
, struct pex_obj
*pex
)
1937 if (!pex_get_status (pex
, 1, &status
))
1938 fatal_perror ("can't get program status");
1943 if (WIFSIGNALED (status
))
1945 int sig
= WTERMSIG (status
);
1946 error ("%s terminated with signal %d [%s]%s",
1947 prog
, sig
, strsignal(sig
),
1948 WCOREDUMP(status
) ? ", core dumped" : "");
1949 collect_exit (FATAL_EXIT_CODE
);
1952 if (WIFEXITED (status
))
1953 return WEXITSTATUS (status
);
1959 do_wait (const char *prog
, struct pex_obj
*pex
)
1961 int ret
= collect_wait (prog
, pex
);
1964 error ("%s returned %d exit status", prog
, ret
);
1970 unlink (response_file
);
1971 response_file
= NULL
;
1976 /* Execute a program, and wait for the reply. */
1979 collect_execute (const char *prog
, char **argv
, const char *outname
,
1980 const char *errname
, int flags
)
1982 struct pex_obj
*pex
;
1985 char *response_arg
= NULL
;
1986 char *response_argv
[3] ATTRIBUTE_UNUSED
;
1988 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
1990 /* If using @file arguments, create a temporary file and put the
1991 contents of argv into it. Then change argv to an array corresponding
1992 to a single argument @FILE, where FILE is the temporary filename. */
1994 char **current_argv
= argv
+ 1;
1995 char *argv0
= argv
[0];
1999 /* Note: we assume argv contains at least one element; this is
2002 response_file
= make_temp_file ("");
2004 f
= fopen (response_file
, "w");
2007 fatal ("could not open response file %s", response_file
);
2009 status
= writeargv (current_argv
, f
);
2012 fatal ("could not write to response file %s", response_file
);
2014 status
= fclose (f
);
2017 fatal ("could not close response file %s", response_file
);
2019 response_arg
= concat ("@", response_file
, NULL
);
2020 response_argv
[0] = argv0
;
2021 response_argv
[1] = response_arg
;
2022 response_argv
[2] = NULL
;
2024 argv
= response_argv
;
2033 fprintf (stderr
, "%s", argv
[0]);
2035 notice ("[cannot find %s]", prog
);
2037 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2038 fprintf (stderr
, " %s", str
);
2040 fprintf (stderr
, "\n");
2046 /* If we cannot find a program we need, complain error. Do this here
2047 since we might not end up needing something that we could not find. */
2050 fatal ("cannot find '%s'", prog
);
2052 pex
= pex_init (0, "collect2", NULL
);
2054 fatal_perror ("pex_init failed");
2056 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
2063 fatal_perror (errmsg
);
2070 free (response_arg
);
2076 fork_execute (const char *prog
, char **argv
)
2078 struct pex_obj
*pex
;
2080 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
2081 do_wait (prog
, pex
);
2084 /* Unlink a file unless we are debugging. */
2087 maybe_unlink (const char *file
)
2090 unlink_if_ordinary (file
);
2092 notice ("[Leaving %s]\n", file
);
2095 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2098 maybe_unlink_list (char **file_list
)
2100 char **tmp
= file_list
;
2103 maybe_unlink (*(tmp
++));
2107 static long sequence_number
= 0;
2109 /* Add a name to a linked list. */
2112 add_to_list (struct head
*head_ptr
, const char *name
)
2115 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2117 strcpy (newid
->name
, name
);
2119 if (head_ptr
->first
)
2120 head_ptr
->last
->next
= newid
;
2122 head_ptr
->first
= newid
;
2124 /* Check for duplicate symbols. */
2125 for (p
= head_ptr
->first
;
2126 strcmp (name
, p
->name
) != 0;
2131 head_ptr
->last
->next
= 0;
2136 newid
->sequence
= ++sequence_number
;
2137 head_ptr
->last
= newid
;
2141 /* Grab the init priority number from an init function name that
2142 looks like "_GLOBAL_.I.12345.foo". */
2145 extract_init_priority (const char *name
)
2149 while (name
[pos
] == '_')
2151 pos
+= 10; /* strlen ("GLOBAL__X_") */
2153 /* Extract init_p number from ctor/dtor name. */
2154 pri
= atoi (name
+ pos
);
2155 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2158 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2159 ctors will be run from right to left, dtors from left to right. */
2162 sort_ids (struct head
*head_ptr
)
2164 /* id holds the current element to insert. id_next holds the next
2165 element to insert. id_ptr iterates through the already sorted elements
2166 looking for the place to insert id. */
2167 struct id
*id
, *id_next
, **id_ptr
;
2169 id
= head_ptr
->first
;
2171 /* We don't have any sorted elements yet. */
2172 head_ptr
->first
= NULL
;
2174 for (; id
; id
= id_next
)
2177 id
->sequence
= extract_init_priority (id
->name
);
2179 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2181 /* If the sequence numbers are the same, we put the id from the
2182 file later on the command line later in the list. */
2183 || id
->sequence
> (*id_ptr
)->sequence
2184 /* Hack: do lexical compare, too.
2185 || (id->sequence == (*id_ptr)->sequence
2186 && strcmp (id->name, (*id_ptr)->name) > 0) */
2195 /* Now set the sequence numbers properly so write_c_file works. */
2196 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2197 id
->sequence
= ++sequence_number
;
2200 /* Write: `prefix', the names on list LIST, `suffix'. */
2203 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2207 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2212 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2213 /* Given a STRING, return nonzero if it occurs in the list in range
2214 [ARGS_BEGIN,ARGS_END). */
2217 is_in_args (const char *string
, const char **args_begin
,
2218 const char **args_end
)
2220 const char **args_pointer
;
2221 for (args_pointer
= args_begin
; args_pointer
!= args_end
; ++args_pointer
)
2222 if (strcmp (string
, *args_pointer
) == 0)
2226 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2228 #ifdef COLLECT_EXPORT_LIST
2229 /* This function is really used only on AIX, but may be useful. */
2232 is_in_list (const char *prefix
, struct id
*list
)
2236 if (!strcmp (prefix
, list
->name
)) return 1;
2242 #endif /* COLLECT_EXPORT_LIST */
2244 /* Added for debugging purpose. */
2245 #ifdef COLLECT_EXPORT_LIST
2247 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2251 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2259 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2263 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2270 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2274 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2275 prefix
, list
->sequence
, list
->name
);
2280 /* Write out the constructor and destructor tables statically (for a shared
2281 object), along with the functions to execute them. */
2284 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2288 int frames
= (frame_tables
.number
> 0);
2290 /* Figure out name of output_file, stripping off .so version. */
2291 p
= strrchr (output_file
, '/');
2307 if (strncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2309 q
+= strlen (SHLIB_SUFFIX
);
2316 /* q points to null at end of the string (or . of the .so version) */
2317 prefix
= XNEWVEC (char, q
- p
+ 1);
2318 strncpy (prefix
, p
, q
- p
);
2320 for (r
= prefix
; *r
; r
++)
2321 if (!ISALNUM ((unsigned char)*r
))
2324 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2325 output_file
, prefix
);
2327 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2328 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2332 /* Write the tables as C code. */
2334 fprintf (stream
, "static int count;\n");
2335 fprintf (stream
, "typedef void entry_pt();\n");
2336 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2340 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2342 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2343 write_list (stream
, "\t\t&", frame_tables
.first
);
2344 fprintf (stream
, "\t0\n};\n");
2346 /* This must match what's in frame.h. */
2347 fprintf (stream
, "struct object {\n");
2348 fprintf (stream
, " void *pc_begin;\n");
2349 fprintf (stream
, " void *pc_end;\n");
2350 fprintf (stream
, " void *fde_begin;\n");
2351 fprintf (stream
, " void *fde_array;\n");
2352 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2353 fprintf (stream
, " struct object *next;\n");
2354 fprintf (stream
, "};\n");
2356 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2357 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2359 fprintf (stream
, "static void reg_frame () {\n");
2360 fprintf (stream
, "\tstatic struct object ob;\n");
2361 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2362 fprintf (stream
, "\t}\n");
2364 fprintf (stream
, "static void dereg_frame () {\n");
2365 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2366 fprintf (stream
, "\t}\n");
2369 fprintf (stream
, "void %s() {\n", initname
);
2370 if (constructors
.number
> 0 || frames
)
2372 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2373 write_list (stream
, "\t\t", constructors
.first
);
2375 fprintf (stream
, "\treg_frame,\n");
2376 fprintf (stream
, "\t};\n");
2377 fprintf (stream
, "\tentry_pt **p;\n");
2378 fprintf (stream
, "\tif (count++ != 0) return;\n");
2379 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2380 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2383 fprintf (stream
, "\t++count;\n");
2384 fprintf (stream
, "}\n");
2385 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2386 fprintf (stream
, "void %s() {\n", fininame
);
2387 if (destructors
.number
> 0 || frames
)
2389 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2390 write_list (stream
, "\t\t", destructors
.first
);
2392 fprintf (stream
, "\tdereg_frame,\n");
2393 fprintf (stream
, "\t};\n");
2394 fprintf (stream
, "\tentry_pt **p;\n");
2395 fprintf (stream
, "\tif (--count != 0) return;\n");
2396 fprintf (stream
, "\tp = dtors;\n");
2397 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2398 destructors
.number
+ frames
);
2400 fprintf (stream
, "}\n");
2404 COLLECT_SHARED_INIT_FUNC(stream
, initname
);
2405 COLLECT_SHARED_FINI_FUNC(stream
, fininame
);
2409 /* Write the constructor/destructor tables. */
2411 #ifndef LD_INIT_SWITCH
2413 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2415 /* Write the tables as C code. */
2417 int frames
= (frame_tables
.number
> 0);
2419 fprintf (stream
, "typedef void entry_pt();\n\n");
2421 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2425 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2427 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2428 write_list (stream
, "\t\t&", frame_tables
.first
);
2429 fprintf (stream
, "\t0\n};\n");
2431 /* This must match what's in frame.h. */
2432 fprintf (stream
, "struct object {\n");
2433 fprintf (stream
, " void *pc_begin;\n");
2434 fprintf (stream
, " void *pc_end;\n");
2435 fprintf (stream
, " void *fde_begin;\n");
2436 fprintf (stream
, " void *fde_array;\n");
2437 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2438 fprintf (stream
, " struct object *next;\n");
2439 fprintf (stream
, "};\n");
2441 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2442 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2444 fprintf (stream
, "static void reg_frame () {\n");
2445 fprintf (stream
, "\tstatic struct object ob;\n");
2446 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2447 fprintf (stream
, "\t}\n");
2449 fprintf (stream
, "static void dereg_frame () {\n");
2450 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2451 fprintf (stream
, "\t}\n");
2454 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2455 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2456 write_list (stream
, "\t", constructors
.first
);
2458 fprintf (stream
, "\treg_frame,\n");
2459 fprintf (stream
, "\t0\n};\n\n");
2461 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2463 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2464 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2465 write_list (stream
, "\t", destructors
.first
);
2467 fprintf (stream
, "\tdereg_frame,\n");
2468 fprintf (stream
, "\t0\n};\n\n");
2470 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2471 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2473 #endif /* ! LD_INIT_SWITCH */
2476 write_c_file (FILE *stream
, const char *name
)
2478 #ifndef LD_INIT_SWITCH
2480 write_c_file_glob (stream
, name
);
2483 write_c_file_stat (stream
, name
);
2486 #ifdef COLLECT_EXPORT_LIST
2488 write_aix_file (FILE *stream
, struct id
*list
)
2490 for (; list
; list
= list
->next
)
2492 fputs (list
->name
, stream
);
2493 putc ('\n', stream
);
2498 #ifdef OBJECT_FORMAT_NONE
2500 /* Check to make sure the file is an ELF file. LTO objects must
2501 be in ELF format. */
2504 is_elf (const char *prog_name
)
2508 static char magic
[4] = { 0x7f, 'E', 'L', 'F' };
2510 f
= fopen (prog_name
, "r");
2513 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2516 return memcmp (buf
, magic
, sizeof (magic
)) == 0;
2519 /* Generic version to scan the name list of the loaded program for
2520 the symbols g++ uses for static constructors and destructors. */
2523 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2526 void (*int_handler
) (int);
2528 void (*quit_handler
) (int);
2530 char *real_nm_argv
[4];
2531 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2533 struct pex_obj
*pex
;
2540 if (which_pass
== PASS_SECOND
)
2543 /* LTO objects must be in ELF format. This check prevents
2544 us from accepting an archive containing LTO objects, which
2545 gcc cannnot currently handle. */
2546 if (which_pass
== PASS_LTOINFO
&& !is_elf (prog_name
))
2549 /* If we do not have an `nm', complain. */
2550 if (nm_file_name
== 0)
2551 fatal ("cannot find 'nm'");
2553 nm_argv
[argc
++] = nm_file_name
;
2554 if (NM_FLAGS
[0] != '\0')
2555 nm_argv
[argc
++] = NM_FLAGS
;
2557 nm_argv
[argc
++] = prog_name
;
2558 nm_argv
[argc
++] = (char *) 0;
2560 /* Trace if needed. */
2563 const char **p_argv
;
2566 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2567 fprintf (stderr
, " %s", str
);
2569 fprintf (stderr
, "\n");
2575 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2577 fatal_perror ("pex_init failed");
2579 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2586 fatal_perror (errmsg
);
2592 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2594 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2597 inf
= pex_read_output (pex
, 0);
2599 fatal_perror ("can't open nm output");
2603 if (which_pass
== PASS_LTOINFO
)
2604 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2606 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2609 /* Read each line of nm output. */
2610 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2616 fprintf (stderr
, "\t%s\n", buf
);
2618 if (which_pass
== PASS_LTOINFO
)
2623 /* Look for the LTO info marker symbol, and add filename to
2624 the LTO objects list if found. */
2625 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2627 && (strncmp (p
+1 , "gnu_lto_v1", 10) == 0)
2630 add_lto_object (<o_objects
, prog_name
);
2632 /* We need to read all the input, so we can't just
2633 return here. But we can avoid useless work. */
2642 /* If it contains a constructor or destructor name, add the name
2643 to the appropriate list unless this is a kind of symbol we're
2644 not supposed to even consider. */
2646 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2647 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2654 /* Find the end of the symbol name.
2655 Do not include `|', because Encore nm can tack that on the end. */
2656 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2662 switch (is_ctor_dtor (name
))
2665 if (! (filter
& SCAN_CTOR
))
2667 if (which_pass
!= PASS_LIB
)
2668 add_to_list (&constructors
, name
);
2672 if (! (filter
& SCAN_DTOR
))
2674 if (which_pass
!= PASS_LIB
)
2675 add_to_list (&destructors
, name
);
2679 if (! (filter
& SCAN_INIT
))
2681 if (which_pass
!= PASS_LIB
)
2682 fatal ("init function found in object %s", prog_name
);
2683 #ifndef LD_INIT_SWITCH
2684 add_to_list (&constructors
, name
);
2689 if (! (filter
& SCAN_FINI
))
2691 if (which_pass
!= PASS_LIB
)
2692 fatal ("fini function found in object %s", prog_name
);
2693 #ifndef LD_FINI_SWITCH
2694 add_to_list (&destructors
, name
);
2699 if (! (filter
& SCAN_DWEH
))
2701 if (which_pass
!= PASS_LIB
)
2702 add_to_list (&frame_tables
, name
);
2705 default: /* not a constructor or destructor */
2711 fprintf (stderr
, "\n");
2713 do_wait (nm_file_name
, pex
);
2715 signal (SIGINT
, int_handler
);
2717 signal (SIGQUIT
, quit_handler
);
2723 /* Use the List Dynamic Dependencies program to find shared libraries that
2724 the output file depends upon and their initialization/finalization
2725 routines, if any. */
2728 scan_libraries (const char *prog_name
)
2730 static struct head libraries
; /* list of shared libraries found */
2732 void (*int_handler
) (int);
2734 void (*quit_handler
) (int);
2736 char *real_ldd_argv
[4];
2737 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2739 struct pex_obj
*pex
;
2745 /* If we do not have an `ldd', complain. */
2746 if (ldd_file_name
== 0)
2748 error ("cannot find 'ldd'");
2752 ldd_argv
[argc
++] = ldd_file_name
;
2753 ldd_argv
[argc
++] = prog_name
;
2754 ldd_argv
[argc
++] = (char *) 0;
2756 /* Trace if needed. */
2759 const char **p_argv
;
2762 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2763 fprintf (stderr
, " %s", str
);
2765 fprintf (stderr
, "\n");
2771 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2773 fatal_perror ("pex_init failed");
2775 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2781 fatal_perror (errmsg
);
2787 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2789 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2792 inf
= pex_read_output (pex
, 0);
2794 fatal_perror ("can't open ldd output");
2797 notice ("\nldd output with constructors/destructors.\n");
2799 /* Read each line of ldd output. */
2800 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2803 char *name
, *end
, *p
= buf
;
2805 /* Extract names of libraries and add to list. */
2806 PARSE_LDD_OUTPUT (p
);
2811 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2812 fatal ("dynamic dependency %s not found", buf
);
2814 /* Find the end of the symbol name. */
2816 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2821 if (access (name
, R_OK
) == 0)
2822 add_to_list (&libraries
, name
);
2824 fatal ("unable to open dynamic dependency '%s'", buf
);
2827 fprintf (stderr
, "\t%s\n", buf
);
2830 fprintf (stderr
, "\n");
2832 do_wait (ldd_file_name
, pex
);
2834 signal (SIGINT
, int_handler
);
2836 signal (SIGQUIT
, quit_handler
);
2839 /* Now iterate through the library list adding their symbols to
2841 for (list
= libraries
.first
; list
; list
= list
->next
)
2842 scan_prog_file (list
->name
, PASS_LIB
);
2845 #endif /* LDD_SUFFIX */
2847 #endif /* OBJECT_FORMAT_NONE */
2851 * COFF specific stuff.
2854 #ifdef OBJECT_FORMAT_COFF
2856 #if defined (EXTENDED_COFF)
2858 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2859 # define GCC_SYMENT SYMR
2860 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2861 # define GCC_SYMINC(X) (1)
2862 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2863 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2867 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2868 # define GCC_SYMENT SYMENT
2869 # if defined (C_WEAKEXT)
2870 # define GCC_OK_SYMBOL(X) \
2871 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2872 ((X).n_scnum > N_UNDEF) && \
2874 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2875 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2876 # define GCC_UNDEF_SYMBOL(X) \
2877 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2878 ((X).n_scnum == N_UNDEF))
2880 # define GCC_OK_SYMBOL(X) \
2881 (((X).n_sclass == C_EXT) && \
2882 ((X).n_scnum > N_UNDEF) && \
2884 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2885 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2886 # define GCC_UNDEF_SYMBOL(X) \
2887 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2889 # define GCC_SYMINC(X) ((X).n_numaux+1)
2890 # define GCC_SYMZERO(X) 0
2892 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2893 #if TARGET_AIX_VERSION >= 51
2894 # define GCC_CHECK_HDR(X) \
2895 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2896 || (HEADER (X).f_magic == 0767 && aix64_flag))
2898 # define GCC_CHECK_HDR(X) \
2899 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2900 || (HEADER (X).f_magic == 0757 && aix64_flag))
2905 #ifdef COLLECT_EXPORT_LIST
2906 /* Array of standard AIX libraries which should not
2907 be scanned for ctors/dtors. */
2908 static const char *const aix_std_libs
[] = {
2916 "/usr/lib/libc_r.a",
2917 "/usr/lib/libm_r.a",
2918 "/usr/lib/threads/libc.a",
2919 "/usr/ccs/lib/libc.a",
2920 "/usr/ccs/lib/libm.a",
2921 "/usr/ccs/lib/libc_r.a",
2922 "/usr/ccs/lib/libm_r.a",
2926 /* This function checks the filename and returns 1
2927 if this name matches the location of a standard AIX library. */
2928 static int ignore_library (const char *);
2930 ignore_library (const char *name
)
2932 const char *const *p
;
2935 if (target_system_root
[0] != '\0')
2937 length
= strlen (target_system_root
);
2938 if (strncmp (name
, target_system_root
, length
) != 0)
2942 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2943 if (strcmp (name
, *p
) == 0)
2947 #endif /* COLLECT_EXPORT_LIST */
2949 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2950 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2953 /* COFF version to scan the name list of the loaded program for
2954 the symbols g++ uses for static constructors and destructors. */
2957 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2960 LDFILE
*ldptr
= NULL
;
2961 int sym_index
, sym_count
;
2964 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2967 #ifdef COLLECT_EXPORT_LIST
2968 /* We do not need scanning for some standard C libraries. */
2969 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2972 /* On AIX we have a loop, because there is not much difference
2973 between an object and an archive. This trick allows us to
2974 eliminate scan_libraries() function. */
2978 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2979 non-const char * filename parameter, even though it will not
2980 modify that string. So we must cast away const-ness here,
2981 using CONST_CAST to prevent complaints from -Wcast-qual. */
2982 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2984 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2985 fatal ("%s: not a COFF file", prog_name
);
2987 if (GCC_CHECK_HDR (ldptr
))
2989 sym_count
= GCC_SYMBOLS (ldptr
);
2990 sym_index
= GCC_SYMZERO (ldptr
);
2992 #ifdef COLLECT_EXPORT_LIST
2993 /* Is current archive member a shared object? */
2994 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2997 while (sym_index
< sym_count
)
3001 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
3003 sym_index
+= GCC_SYMINC (symbol
);
3005 if (GCC_OK_SYMBOL (symbol
))
3009 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
3010 continue; /* Should never happen. */
3012 #ifdef XCOFF_DEBUGGING_INFO
3013 /* All AIX function names have a duplicate entry
3014 beginning with a dot. */
3019 switch (is_ctor_dtor (name
))
3022 if (! (filter
& SCAN_CTOR
))
3025 add_to_list (&constructors
, name
);
3026 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3027 if (which_pass
== PASS_OBJ
)
3028 add_to_list (&exports
, name
);
3033 if (! (filter
& SCAN_DTOR
))
3036 add_to_list (&destructors
, name
);
3037 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3038 if (which_pass
== PASS_OBJ
)
3039 add_to_list (&exports
, name
);
3043 #ifdef COLLECT_EXPORT_LIST
3045 if (! (filter
& SCAN_INIT
))
3047 #ifndef LD_INIT_SWITCH
3049 add_to_list (&constructors
, name
);
3054 if (! (filter
& SCAN_FINI
))
3056 #ifndef LD_INIT_SWITCH
3058 add_to_list (&destructors
, name
);
3064 if (! (filter
& SCAN_DWEH
))
3067 add_to_list (&frame_tables
, name
);
3068 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3069 if (which_pass
== PASS_OBJ
)
3070 add_to_list (&exports
, name
);
3074 default: /* not a constructor or destructor */
3075 #ifdef COLLECT_EXPORT_LIST
3076 /* Explicitly export all global symbols when
3077 building a shared object on AIX, but do not
3078 re-export symbols from another shared object
3079 and do not export symbols if the user
3080 provides an explicit export list. */
3081 if (shared_obj
&& !is_shared
3082 && which_pass
== PASS_OBJ
&& !export_flag
)
3083 add_to_list (&exports
, name
);
3089 #if !defined(EXTENDED_COFF)
3090 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3091 symbol
.n_scnum
, symbol
.n_sclass
,
3092 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3096 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3097 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3102 #ifdef COLLECT_EXPORT_LIST
3105 /* If archive contains both 32-bit and 64-bit objects,
3106 we want to skip objects in other mode so mismatch normal. */
3108 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3109 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3115 fatal ("%s: cannot open as COFF file", prog_name
);
3117 #ifdef COLLECT_EXPORT_LIST
3118 /* On AIX loop continues while there are more members in archive. */
3120 while (ldclose (ldptr
) == FAILURE
);
3122 /* Otherwise we simply close ldptr. */
3123 (void) ldclose(ldptr
);
3126 #endif /* OBJECT_FORMAT_COFF */
3128 #ifdef COLLECT_EXPORT_LIST
3129 /* Given a library name without "lib" prefix, this function
3130 returns a full library name including a path. */
3132 resolve_lib_name (const char *name
)
3136 /* Library extensions for AIX dynamic linking. */
3137 const char * const libexts
[2] = {"a", "so"};
3139 for (i
= 0; libpaths
[i
]; i
++)
3140 if (libpaths
[i
]->max_len
> l
)
3141 l
= libpaths
[i
]->max_len
;
3143 lib_buf
= XNEWVEC (char, l
+ strlen(name
) + 10);
3145 for (i
= 0; libpaths
[i
]; i
++)
3147 struct prefix_list
*list
= libpaths
[i
]->plist
;
3148 for (; list
; list
= list
->next
)
3150 /* The following lines are needed because path_prefix list
3151 may contain directories both with trailing '/' and
3154 if (list
->prefix
[strlen(list
->prefix
)-1] != '/')
3156 for (j
= 0; j
< 2; j
++)
3158 sprintf (lib_buf
, "%s%slib%s.%s",
3159 list
->prefix
, p
, name
,
3160 libexts
[(j
+ aixrtl_flag
) % 2]);
3161 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3162 if (file_exists (lib_buf
))
3164 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3171 fprintf (stderr
, "not found\n");
3173 fatal ("library lib%s not found", name
);
3176 #endif /* COLLECT_EXPORT_LIST */