1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
5 Free Software Foundation, Inc.
6 Contributed by Chris Smith (csmith@convex.com).
7 Heavily modified by Michael Meissner (meissner@cygnus.com),
8 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
27 /* Build tables of static constructors and destructors and run ld. */
31 #include "coretypes.h"
33 #include "filenames.h"
34 #include "file-find.h"
36 /* TARGET_64BIT may be defined to use driver specific functionality. */
38 #define TARGET_64BIT TARGET_64BIT_DEFAULT
40 #ifndef LIBRARY_PATH_ENV
41 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
47 #include "collect2-aix.h"
48 #include "diagnostic.h"
54 /* On certain systems, we have code that works by scanning the object file
55 directly. But this code uses system-specific header files and library
56 functions, so turn it off in a cross-compiler. Likewise, the names of
57 the utilities are not correct for a cross-compiler; we have to hope that
58 cross-versions are in the proper directories. */
60 #ifdef CROSS_DIRECTORY_STRUCTURE
61 #ifndef CROSS_AIX_SUPPORT
62 #undef OBJECT_FORMAT_COFF
65 #undef REAL_LD_FILE_NAME
66 #undef REAL_NM_FILE_NAME
67 #undef REAL_STRIP_FILE_NAME
70 /* If we cannot use a special method, use the ordinary one:
71 run nm to find what symbols are present.
72 In a cross-compiler, this means you need a cross nm,
73 but that is not quite as unpleasant as special headers. */
75 #if !defined (OBJECT_FORMAT_COFF)
76 #define OBJECT_FORMAT_NONE
79 #ifdef OBJECT_FORMAT_COFF
81 #ifndef CROSS_DIRECTORY_STRUCTURE
89 /* Many versions of ldfcn.h define these. */
98 /* Some systems have an ISCOFF macro, but others do not. In some cases
99 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
100 that either do not have an ISCOFF macro in /usr/include or for those
101 where it is wrong. */
104 #define MY_ISCOFF(X) ISCOFF (X)
107 #endif /* OBJECT_FORMAT_COFF */
109 #ifdef OBJECT_FORMAT_NONE
111 /* Default flags to pass to nm. */
113 #define NM_FLAGS "-n"
116 #endif /* OBJECT_FORMAT_NONE */
118 /* Some systems use __main in a way incompatible with its use in gcc, in these
119 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
120 give the same symbol without quotes for an alternative entry point. */
122 #define NAME__MAIN "__main"
125 /* This must match tree.h. */
126 #define DEFAULT_INIT_PRIORITY 65535
128 #ifndef COLLECT_SHARED_INIT_FUNC
129 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
130 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
132 #ifndef COLLECT_SHARED_FINI_FUNC
133 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
134 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
138 #define SCAN_LIBRARIES
142 #define SHLIB_SUFFIX ".so"
146 int do_collecting
= 1;
148 int do_collecting
= 0;
151 /* Cook up an always defined indication of whether we proceed the
152 "EXPORT_LIST" way. */
154 #ifdef COLLECT_EXPORT_LIST
155 #define DO_COLLECT_EXPORT_LIST 1
157 #define DO_COLLECT_EXPORT_LIST 0
160 /* Nonzero if we should suppress the automatic demangling of identifiers
161 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
164 /* Linked lists of constructor and destructor names. */
180 bool vflag
; /* true if -v or --version */
181 static int rflag
; /* true if -r */
182 static int strip_flag
; /* true if -s */
183 #ifdef COLLECT_EXPORT_LIST
184 static int export_flag
; /* true if -bE */
185 static int aix64_flag
; /* true if -b64 */
186 static int aixrtl_flag
; /* true if -brtl */
190 LTO_MODE_NONE
, /* Not doing LTO. */
191 LTO_MODE_LTO
, /* Normal LTO. */
192 LTO_MODE_WHOPR
/* WHOPR. */
195 /* Current LTO mode. */
196 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
198 bool debug
; /* true if -debug */
199 bool helpflag
; /* true if --help */
201 static int shared_obj
; /* true if -shared */
203 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
204 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
205 #ifdef COLLECT_EXPORT_LIST
206 static const char *export_file
; /* <xxx>.x for AIX export list. */
208 static char **lto_o_files
; /* Output files for LTO. */
209 const char *ldout
; /* File for ld stdout. */
210 const char *lderrout
; /* File for ld stderr. */
211 static const char *output_file
; /* Output file for ld. */
212 static const char *nm_file_name
; /* pathname of nm */
214 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
216 static const char *strip_file_name
; /* pathname of strip */
217 const char *c_file_name
; /* pathname of gcc */
218 static char *initname
, *fininame
; /* names of init and fini funcs */
220 static struct head constructors
; /* list of constructors found */
221 static struct head destructors
; /* list of destructors found */
222 #ifdef COLLECT_EXPORT_LIST
223 static struct head exports
; /* list of exported symbols */
225 static struct head frame_tables
; /* list of frame unwind info tables */
227 static bool at_file_supplied
; /* Whether to use @file arguments */
228 static char *response_file
; /* Name of any current response file */
230 struct obstack temporary_obstack
;
231 char * temporary_firstobj
;
233 /* A string that must be prepended to a target OS path in order to find
234 it on the host system. */
235 #ifdef TARGET_SYSTEM_ROOT
236 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
238 static const char *target_system_root
= "";
241 /* Whether we may unlink the output file, which should be set as soon as we
242 know we have successfully produced it. This is typically useful to prevent
243 blindly attempting to unlink a read-only output that the target linker
244 would leave untouched. */
245 bool may_unlink_output_file
= false;
247 #ifdef COLLECT_EXPORT_LIST
248 /* Lists to keep libraries to be scanned for global constructors/destructors. */
249 static struct head libs
; /* list of libraries */
250 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
251 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
252 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
253 &libpath_lib_dirs
, NULL
};
256 /* List of names of object files containing LTO information.
257 These are a subset of the object file names appearing on the
258 command line, and must be identical, in the sense of pointer
259 equality, with the names passed to maybe_run_lto_and_relink(). */
263 const char *name
; /* Name of object file. */
264 struct lto_object
*next
; /* Next in linked list. */
267 struct lto_object_list
269 struct lto_object
*first
; /* First list element. */
270 struct lto_object
*last
; /* Last list element. */
273 static struct lto_object_list lto_objects
;
275 /* Special kinds of symbols that a name may denote. */
278 SYM_REGULAR
= 0, /* nothing special */
280 SYM_CTOR
= 1, /* constructor */
281 SYM_DTOR
= 2, /* destructor */
282 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
283 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
284 SYM_DWEH
= 5 /* DWARF exception handling table */
287 static symkind
is_ctor_dtor (const char *);
289 static void handler (int);
290 static void do_wait (const char *, struct pex_obj
*);
291 static void fork_execute (const char *, char **);
292 static void maybe_unlink (const char *);
293 static void maybe_unlink_list (char **);
294 static void add_to_list (struct head
*, const char *);
295 static int extract_init_priority (const char *);
296 static void sort_ids (struct head
*);
297 static void write_list (FILE *, const char *, struct id
*);
298 #ifdef COLLECT_EXPORT_LIST
299 static void dump_list (FILE *, const char *, struct id
*);
302 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
304 static void write_list_with_asm (FILE *, const char *, struct id
*);
305 static void write_c_file (FILE *, const char *);
306 static void write_c_file_stat (FILE *, const char *);
307 #ifndef LD_INIT_SWITCH
308 static void write_c_file_glob (FILE *, const char *);
310 #ifdef SCAN_LIBRARIES
311 static void scan_libraries (const char *);
313 #ifdef COLLECT_EXPORT_LIST
315 static int is_in_list (const char *, struct id
*);
317 static void write_aix_file (FILE *, struct id
*);
318 static char *resolve_lib_name (const char *);
320 static char *extract_string (const char **);
321 static void post_ld_pass (bool);
322 static void process_args (int *argcp
, char **argv
);
324 /* Enumerations describing which pass this is for scanning the
328 PASS_FIRST
, /* without constructors */
329 PASS_OBJ
, /* individual objects */
330 PASS_LIB
, /* looking for shared libraries */
331 PASS_SECOND
, /* with constructors linked in */
332 PASS_LTOINFO
/* looking for objects with LTO info */
335 /* ... and which kinds of symbols are to be considered. */
337 enum scanfilter_masks
{
340 SCAN_CTOR
= 1 << SYM_CTOR
,
341 SCAN_DTOR
= 1 << SYM_DTOR
,
342 SCAN_INIT
= 1 << SYM_INIT
,
343 SCAN_FINI
= 1 << SYM_FINI
,
344 SCAN_DWEH
= 1 << SYM_DWEH
,
348 /* This type is used for parameters and variables which hold
349 combinations of the flags in enum scanfilter_masks. */
350 typedef int scanfilter
;
352 /* Scan the name list of the loaded program for the symbols g++ uses for
353 static constructors and destructors.
355 The SCANPASS argument tells which collect processing pass this is for and
356 the SCANFILTER argument tells which kinds of symbols to consider in this
357 pass. Symbols of a special kind not in the filter mask are considered as
360 The constructor table begins at __CTOR_LIST__ and contains a count of the
361 number of pointers (or -1 if the constructors are built in a separate
362 section by the linker), followed by the pointers to the constructor
363 functions, terminated with a null pointer. The destructor table has the
364 same format, and begins at __DTOR_LIST__. */
366 static void scan_prog_file (const char *, scanpass
, scanfilter
);
369 /* Delete tempfiles and exit function. */
372 collect_exit (int status
)
374 if (c_file
!= 0 && c_file
[0])
375 maybe_unlink (c_file
);
377 if (o_file
!= 0 && o_file
[0])
378 maybe_unlink (o_file
);
380 #ifdef COLLECT_EXPORT_LIST
381 if (export_file
!= 0 && export_file
[0])
382 maybe_unlink (export_file
);
386 maybe_unlink_list (lto_o_files
);
388 if (ldout
!= 0 && ldout
[0])
390 dump_ld_file (ldout
, stdout
);
391 maybe_unlink (ldout
);
394 if (lderrout
!= 0 && lderrout
[0])
396 dump_ld_file (lderrout
, stderr
);
397 maybe_unlink (lderrout
);
400 if (status
!= 0 && output_file
!= 0 && output_file
[0])
401 maybe_unlink (output_file
);
404 maybe_unlink (response_file
);
410 /* Notify user of a non-error. */
412 notice (const char *cmsgid
, ...)
416 va_start (ap
, cmsgid
);
417 vfprintf (stderr
, _(cmsgid
), ap
);
421 /* Notify user of a non-error, without translating the format string. */
423 notice_translated (const char *cmsgid
, ...)
427 va_start (ap
, cmsgid
);
428 vfprintf (stderr
, cmsgid
, ap
);
435 if (c_file
!= 0 && c_file
[0])
436 maybe_unlink (c_file
);
438 if (o_file
!= 0 && o_file
[0])
439 maybe_unlink (o_file
);
441 if (ldout
!= 0 && ldout
[0])
442 maybe_unlink (ldout
);
444 if (lderrout
!= 0 && lderrout
[0])
445 maybe_unlink (lderrout
);
447 #ifdef COLLECT_EXPORT_LIST
448 if (export_file
!= 0 && export_file
[0])
449 maybe_unlink (export_file
);
453 maybe_unlink_list (lto_o_files
);
456 maybe_unlink (response_file
);
458 signal (signo
, SIG_DFL
);
464 file_exists (const char *name
)
466 return access (name
, R_OK
) == 0;
469 /* Parse a reasonable subset of shell quoting syntax. */
472 extract_string (const char **pp
)
485 obstack_1grow (&temporary_obstack
, c
);
486 else if (! inside
&& c
== ' ')
488 else if (! inside
&& c
== '\\')
493 obstack_1grow (&temporary_obstack
, c
);
496 obstack_1grow (&temporary_obstack
, '\0');
498 return XOBFINISH (&temporary_obstack
, char *);
502 dump_ld_file (const char *name
, FILE *to
)
504 FILE *stream
= fopen (name
, "r");
511 while (c
= getc (stream
),
512 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
513 obstack_1grow (&temporary_obstack
, c
);
514 if (obstack_object_size (&temporary_obstack
) > 0)
516 const char *word
, *p
;
518 obstack_1grow (&temporary_obstack
, '\0');
519 word
= XOBFINISH (&temporary_obstack
, const char *);
522 ++word
, putc ('.', to
);
524 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
525 p
+= strlen (USER_LABEL_PREFIX
);
527 #ifdef HAVE_LD_DEMANGLE
533 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
541 diff
= strlen (word
) - strlen (result
);
542 while (diff
> 0 && c
== ' ')
543 --diff
, putc (' ', to
);
544 if (diff
< 0 && c
== ' ')
546 while (diff
< 0 && c
== ' ')
547 ++diff
, c
= getc (stream
);
550 /* Make sure we output at least one space, or
551 the demangled symbol name will run into
552 whatever text follows. */
563 obstack_free (&temporary_obstack
, temporary_firstobj
);
572 /* Return the kind of symbol denoted by name S. */
575 is_ctor_dtor (const char *s
)
577 struct names
{ const char *const name
; const int len
; symkind ret
;
578 const int two_underscores
; };
580 const struct names
*p
;
582 const char *orig_s
= s
;
584 static const struct names special
[] = {
585 #ifndef NO_DOLLAR_IN_LABEL
586 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
587 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
589 #ifndef NO_DOT_IN_LABEL
590 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
591 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
592 #endif /* NO_DOT_IN_LABEL */
593 #endif /* NO_DOLLAR_IN_LABEL */
594 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
595 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
596 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
597 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
598 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
599 { NULL
, 0, SYM_REGULAR
, 0 }
602 while ((ch
= *s
) == '_')
608 for (p
= &special
[0]; p
->len
> 0; p
++)
611 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
612 && strncmp(s
, p
->name
, p
->len
) == 0)
620 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
621 and one from the PATH variable. */
623 static struct path_prefix cpath
, path
;
625 #ifdef CROSS_DIRECTORY_STRUCTURE
626 /* This is the name of the target machine. We use it to form the name
627 of the files to execute. */
629 static const char *const target_machine
= TARGET_MACHINE
;
632 /* Search for NAME using prefix list PPREFIX. We only look for executable
635 Return 0 if not found, otherwise return its name, allocated with malloc. */
637 #ifdef OBJECT_FORMAT_NONE
639 /* Add an entry for the object file NAME to object file list LIST.
640 New entries are added at the end of the list. The original pointer
641 value of NAME is preserved, i.e., no string copy is performed. */
644 add_lto_object (struct lto_object_list
*list
, const char *name
)
646 struct lto_object
*n
= XNEW (struct lto_object
);
651 list
->last
->next
= n
;
657 #endif /* OBJECT_FORMAT_NONE */
660 /* Perform a link-time recompilation and relink if any of the object
661 files contain LTO info. The linker command line LTO_LD_ARGV
662 represents the linker command that would produce a final executable
663 without the use of LTO. OBJECT_LST is a vector of object file names
664 appearing in LTO_LD_ARGV that are to be considered for link-time
665 recompilation, where OBJECT is a pointer to the last valid element.
666 (This awkward convention avoids an impedance mismatch with the
667 usage of similarly-named variables in main().) The elements of
668 OBJECT_LST must be identical, i.e., pointer equal, to the
669 corresponding arguments in LTO_LD_ARGV.
671 Upon entry, at least one linker run has been performed without the
672 use of any LTO info that might be present. Any recompilations
673 necessary for template instantiations have been performed, and
674 initializer/finalizer tables have been created if needed and
675 included in the linker command line LTO_LD_ARGV. If any of the
676 object files contain LTO info, we run the LTO back end on all such
677 files, and perform the final link with the LTO back end output
678 substituted for the LTO-optimized files. In some cases, a final
679 link with all link-time generated code has already been performed,
680 so there is no need to relink if no LTO info is found. In other
681 cases, our caller has not produced the final executable, and is
682 relying on us to perform the required link whether LTO info is
683 present or not. In that case, the FORCE argument should be true.
684 Note that the linker command line argument LTO_LD_ARGV passed into
685 this function may be modified in place. */
688 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
689 const char **object
, bool force
)
691 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
693 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
695 while (object_file
< object
)
697 /* If file contains LTO info, add it to the list of LTO objects. */
698 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
700 /* Increment the argument count by the number of object file arguments
701 we will add. An upper bound suffices, so just count all of the
702 object files regardless of whether they contain LTO info. */
706 if (lto_objects
.first
)
709 const char **lto_c_ptr
;
712 struct lto_object
*list
;
713 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
715 const char *prog
= "lto-wrapper";
716 int lto_ld_argv_size
= 0;
717 char **out_lto_ld_argv
;
718 int out_lto_ld_argv_size
;
722 fatal_error ("COLLECT_LTO_WRAPPER must be set");
726 /* There is at least one object file containing LTO info,
727 so we need to run the LTO back end and relink.
729 To do so we build updated ld arguments with first
730 LTO object replaced by all partitions and other LTO
733 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
734 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
736 *lto_c_ptr
++ = lto_wrapper
;
738 /* Add LTO objects to the wrapper command line. */
739 for (list
= lto_objects
.first
; list
; list
= list
->next
)
740 *lto_c_ptr
++ = list
->name
;
744 /* Run the LTO back end. */
745 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
752 stream
= pex_read_output (pex
, 0);
756 while ((c
= getc (stream
)) != EOF
)
758 obstack_1grow (&temporary_obstack
, c
);
763 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
764 lto_o_files
[num_files
] = NULL
;
765 start
= XOBFINISH (&temporary_obstack
, char *);
766 for (i
= 0; i
< num_files
; ++i
)
773 lto_o_files
[i
] = xstrdup (start
);
778 obstack_free (&temporary_obstack
, temporary_firstobj
);
783 /* Compute memory needed for new LD arguments. At most number of original arguemtns
784 plus number of partitions. */
785 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
787 out_lto_ld_argv
= XCNEWVEC(char *, num_files
+ lto_ld_argv_size
+ 1);
788 out_lto_ld_argv_size
= 0;
790 /* After running the LTO back end, we will relink, substituting
791 the LTO output for the object files that we submitted to the
792 LTO. Here, we modify the linker command line for the relink. */
794 /* Copy all arguments until we find first LTO file. */
798 for (list
= lto_objects
.first
; list
; list
= list
->next
)
799 if (*p
== list
->name
) /* Note test for pointer equality! */
803 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
806 /* Now insert all LTO partitions. */
807 lto_o_ptr
= lto_o_files
;
809 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
811 /* ... and copy the rest. */
814 for (list
= lto_objects
.first
; list
; list
= list
->next
)
815 if (*p
== list
->name
) /* Note test for pointer equality! */
818 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
821 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
823 /* Run the linker again, this time replacing the object files
824 optimized by the LTO with the temporary file generated by the LTO. */
825 fork_execute ("ld", out_lto_ld_argv
);
829 maybe_unlink_list (lto_o_files
);
833 /* Our caller is relying on us to do the link
834 even though there is no LTO back end work to be done. */
835 fork_execute ("ld", lto_ld_argv
);
836 post_ld_pass (false);
843 main (int argc
, char **argv
)
852 } selected_linker
= USE_DEFAULT_LD
;
853 static const char *const ld_suffixes
[USE_LD_MAX
] =
860 static const char *const real_ld_suffix
= "real-ld";
861 static const char *const collect_ld_suffix
= "collect-ld";
862 static const char *const nm_suffix
= "nm";
863 static const char *const gnm_suffix
= "gnm";
865 static const char *const ldd_suffix
= LDD_SUFFIX
;
867 static const char *const strip_suffix
= "strip";
868 static const char *const gstrip_suffix
= "gstrip";
870 const char *full_ld_suffixes
[USE_LD_MAX
];
871 #ifdef CROSS_DIRECTORY_STRUCTURE
872 /* If we look for a program in the compiler directories, we just use
873 the short name, since these directories are already system-specific.
874 But it we look for a program in the system directories, we need to
875 qualify the program name with the target machine. */
877 const char *const full_nm_suffix
=
878 concat (target_machine
, "-", nm_suffix
, NULL
);
879 const char *const full_gnm_suffix
=
880 concat (target_machine
, "-", gnm_suffix
, NULL
);
882 const char *const full_ldd_suffix
=
883 concat (target_machine
, "-", ldd_suffix
, NULL
);
885 const char *const full_strip_suffix
=
886 concat (target_machine
, "-", strip_suffix
, NULL
);
887 const char *const full_gstrip_suffix
=
888 concat (target_machine
, "-", gstrip_suffix
, NULL
);
891 const char *const full_ldd_suffix
= ldd_suffix
;
893 const char *const full_nm_suffix
= nm_suffix
;
894 const char *const full_gnm_suffix
= gnm_suffix
;
895 const char *const full_strip_suffix
= strip_suffix
;
896 const char *const full_gstrip_suffix
= gstrip_suffix
;
897 #endif /* CROSS_DIRECTORY_STRUCTURE */
901 #ifdef COLLECT_EXPORT_LIST
904 const char *ld_file_name
;
910 bool use_plugin
= false;
911 bool use_collect_ld
= false;
913 /* The kinds of symbols we will have to consider when scanning the
914 outcome of a first pass link. This is ALL to start with, then might
915 be adjusted before getting to the first pass link per se, typically on
916 AIX where we perform an early scan of objects and libraries to fetch
917 the list of global ctors/dtors and make sure they are not garbage
919 scanfilter ld1_filter
= SCAN_ALL
;
925 #ifdef TARGET_AIX_VERSION
926 int object_nbr
= argc
;
933 for (i
= 0; i
< USE_LD_MAX
; i
++)
935 #ifdef CROSS_DIRECTORY_STRUCTURE
936 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
941 p
= argv
[0] + strlen (argv
[0]);
942 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
946 xmalloc_set_program_name (progname
);
949 expandargv (&argc
, &argv
);
950 if (argv
!= old_argv
)
951 at_file_supplied
= 1;
953 process_args (&argc
, argv
);
955 num_c_args
= argc
+ 9;
957 #ifndef HAVE_LD_DEMANGLE
958 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
960 /* Suppress demangling by the real linker, which may be broken. */
961 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
964 #if defined (COLLECT2_HOST_INITIALIZATION)
965 /* Perform system dependent initialization, if necessary. */
966 COLLECT2_HOST_INITIALIZATION
;
970 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
971 receive the signal. A different setting is inheritable */
972 signal (SIGCHLD
, SIG_DFL
);
975 /* Unlock the stdio streams. */
976 unlock_std_streams ();
980 diagnostic_initialize (global_dc
, 0);
982 /* Do not invoke xcalloc before this point, since locale needs to be
983 set first, in case a diagnostic is issued. */
985 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
986 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
987 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
988 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
989 object_lst
= XCNEWVEC (char *, argc
);
990 object
= CONST_CAST2 (const char **, char **, object_lst
);
996 /* Parse command line early for instances of -debug. This allows
997 the debug flag to be set before functions like find_a_file()
998 are called. We also look for the -flto or -flto-partition=none flag to know
999 what LTO mode we are in. */
1001 bool no_partition
= false;
1003 for (i
= 1; argv
[i
] != NULL
; i
++)
1005 if (! strcmp (argv
[i
], "-debug"))
1007 else if (! strcmp (argv
[i
], "-flto-partition=none"))
1008 no_partition
= true;
1009 else if ((! strncmp (argv
[i
], "-flto=", 6)
1010 || ! strcmp (argv
[i
], "-flto")) && ! use_plugin
)
1011 lto_mode
= LTO_MODE_WHOPR
;
1012 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1013 lto_mode
= LTO_MODE_NONE
;
1014 else if (! strcmp (argv
[i
], "-plugin"))
1017 lto_mode
= LTO_MODE_NONE
;
1018 if (selected_linker
== USE_DEFAULT_LD
)
1019 selected_linker
= USE_PLUGIN_LD
;
1021 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1022 selected_linker
= USE_BFD_LD
;
1023 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1024 selected_linker
= USE_GOLD_LD
;
1026 #ifdef COLLECT_EXPORT_LIST
1027 /* since -brtl, -bexport, -b64 are not position dependent
1028 also check for them here */
1029 if ((argv
[i
][0] == '-') && (argv
[i
][1] == 'b'))
1032 /* We want to disable automatic exports on AIX when user
1033 explicitly puts an export list in command line */
1034 if (arg
[2] == 'E' || strncmp (&arg
[2], "export", 6) == 0)
1036 else if (arg
[2] == '6' && arg
[3] == '4')
1038 else if (arg
[2] == 'r' && arg
[3] == 't' && arg
[4] == 'l')
1044 find_file_set_debug (debug
);
1045 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1046 lto_mode
= LTO_MODE_LTO
;
1049 #ifndef DEFAULT_A_OUT_NAME
1050 output_file
= "a.out";
1052 output_file
= DEFAULT_A_OUT_NAME
;
1055 obstack_begin (&temporary_obstack
, 0);
1056 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1058 #ifndef HAVE_LD_DEMANGLE
1059 current_demangling_style
= auto_demangling
;
1061 p
= getenv ("COLLECT_GCC_OPTIONS");
1064 const char *q
= extract_string (&p
);
1065 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1068 obstack_free (&temporary_obstack
, temporary_firstobj
);
1070 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1071 -fno-exceptions -w -fno-whole-program */
1074 c_argv
= XCNEWVEC (char *, num_c_args
);
1075 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1078 fatal_error ("no arguments");
1081 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1082 signal (SIGQUIT
, handler
);
1084 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1085 signal (SIGINT
, handler
);
1087 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1088 signal (SIGALRM
, handler
);
1091 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1092 signal (SIGHUP
, handler
);
1094 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1095 signal (SIGSEGV
, handler
);
1097 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1098 signal (SIGBUS
, handler
);
1101 /* Extract COMPILER_PATH and PATH into our prefix list. */
1102 prefix_from_env ("COMPILER_PATH", &cpath
);
1103 prefix_from_env ("PATH", &path
);
1105 /* Try to discover a valid linker/nm/strip to use. */
1107 /* Maybe we know the right file to use (if not cross). */
1109 #ifdef DEFAULT_LINKER
1110 if (access (DEFAULT_LINKER
, X_OK
) == 0)
1111 ld_file_name
= DEFAULT_LINKER
;
1112 if (ld_file_name
== 0)
1114 #ifdef REAL_LD_FILE_NAME
1115 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
);
1116 if (ld_file_name
== 0)
1118 /* Search the (target-specific) compiler dirs for ld'. */
1119 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
);
1120 /* Likewise for `collect-ld'. */
1121 if (ld_file_name
== 0)
1123 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
);
1124 use_collect_ld
= ld_file_name
!= 0;
1126 /* Search the compiler directories for `ld'. We have protection against
1127 recursive calls in find_a_file. */
1128 if (ld_file_name
== 0)
1129 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
]);
1130 /* Search the ordinary system bin directories
1131 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1132 if (ld_file_name
== 0)
1133 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
]);
1135 #ifdef REAL_NM_FILE_NAME
1136 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
);
1137 if (nm_file_name
== 0)
1139 nm_file_name
= find_a_file (&cpath
, gnm_suffix
);
1140 if (nm_file_name
== 0)
1141 nm_file_name
= find_a_file (&path
, full_gnm_suffix
);
1142 if (nm_file_name
== 0)
1143 nm_file_name
= find_a_file (&cpath
, nm_suffix
);
1144 if (nm_file_name
== 0)
1145 nm_file_name
= find_a_file (&path
, full_nm_suffix
);
1148 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
);
1149 if (ldd_file_name
== 0)
1150 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
);
1153 #ifdef REAL_STRIP_FILE_NAME
1154 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
);
1155 if (strip_file_name
== 0)
1157 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
);
1158 if (strip_file_name
== 0)
1159 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
);
1160 if (strip_file_name
== 0)
1161 strip_file_name
= find_a_file (&cpath
, strip_suffix
);
1162 if (strip_file_name
== 0)
1163 strip_file_name
= find_a_file (&path
, full_strip_suffix
);
1165 /* Determine the full path name of the C compiler to use. */
1166 c_file_name
= getenv ("COLLECT_GCC");
1167 if (c_file_name
== 0)
1169 #ifdef CROSS_DIRECTORY_STRUCTURE
1170 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1172 c_file_name
= "gcc";
1176 p
= find_a_file (&cpath
, c_file_name
);
1178 /* Here it should be safe to use the system search path since we should have
1179 already qualified the name of the compiler when it is needed. */
1181 p
= find_a_file (&path
, c_file_name
);
1186 *ld1
++ = *ld2
++ = ld_file_name
;
1188 /* Make temp file names. */
1189 c_file
= make_temp_file (".c");
1190 o_file
= make_temp_file (".o");
1191 #ifdef COLLECT_EXPORT_LIST
1192 export_file
= make_temp_file (".x");
1194 ldout
= make_temp_file (".ld");
1195 lderrout
= make_temp_file (".le");
1196 *c_ptr
++ = c_file_name
;
1203 #ifdef COLLECT_EXPORT_LIST
1204 /* Generate a list of directories from LIBPATH. */
1205 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1206 /* Add to this list also two standard directories where
1207 AIX loader always searches for libraries. */
1208 add_prefix (&libpath_lib_dirs
, "/lib");
1209 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1212 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1214 AIX support needs to know if -shared has been specified before
1215 parsing commandline arguments. */
1217 p
= getenv ("COLLECT_GCC_OPTIONS");
1220 const char *q
= extract_string (&p
);
1221 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1222 *c_ptr
++ = xstrdup (q
);
1223 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1224 *c_ptr
++ = xstrdup (q
);
1225 if (strcmp (q
, "-shared") == 0)
1227 if (*q
== '-' && q
[1] == 'B')
1229 *c_ptr
++ = xstrdup (q
);
1232 q
= extract_string (&p
);
1233 *c_ptr
++ = xstrdup (q
);
1237 obstack_free (&temporary_obstack
, temporary_firstobj
);
1238 *c_ptr
++ = "-fno-profile-arcs";
1239 *c_ptr
++ = "-fno-test-coverage";
1240 *c_ptr
++ = "-fno-branch-probabilities";
1241 *c_ptr
++ = "-fno-exceptions";
1243 *c_ptr
++ = "-fno-whole-program";
1245 /* !!! When GCC calls collect2,
1246 it does not know whether it is calling collect2 or ld.
1247 So collect2 cannot meaningfully understand any options
1248 except those ld understands.
1249 If you propose to make GCC pass some other option,
1250 just imagine what will happen if ld is really ld!!! */
1252 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1253 /* After the first file, put in the c++ rt0. */
1256 while ((arg
= *++argv
) != (char *) 0)
1258 *ld1
++ = *ld2
++ = arg
;
1265 if (!strcmp (arg
, "-debug"))
1267 /* Already parsed. */
1271 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1274 *ld1
++ = *ld2
++ = *argv
;
1279 if (strncmp (arg
, "-flto", 5) == 0)
1282 /* Do not pass LTO flag to the linker. */
1286 error ("LTO support has not been enabled in this "
1290 else if (!use_collect_ld
1291 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1293 /* Do not pass -fuse-ld={bfd|gold} to the linker. */
1297 #ifdef TARGET_AIX_VERSION
1300 /* File containing a list of input files to process. */
1303 char buf
[MAXPATHLEN
+ 2];
1304 /* Number of additionnal object files. */
1306 /* Maximum of additionnal object files before vector
1309 const char *list_filename
= arg
+ 2;
1311 /* Accept -fFILENAME and -f FILENAME. */
1312 if (*list_filename
== '\0' && argv
[1])
1315 list_filename
= *argv
;
1316 *ld1
++ = *ld2
++ = *argv
;
1319 stream
= fopen (list_filename
, "r");
1321 fatal_error ("can't open %s: %m", list_filename
);
1323 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1325 /* Remove end of line. */
1326 int len
= strlen (buf
);
1327 if (len
>= 1 && buf
[len
- 1] =='\n')
1328 buf
[len
- 1] = '\0';
1330 /* Put on object vector.
1331 Note: we only expanse vector here, so we must keep
1332 extra space for remaining arguments. */
1333 if (add_nbr
>= add_max
)
1336 object
- CONST_CAST2 (const char **, char **,
1338 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1339 object_lst
= XRESIZEVEC (char *, object_lst
,
1340 object_nbr
+ add_max
);
1341 object
= CONST_CAST2 (const char **, char **,
1343 object_nbr
+= add_max
;
1345 *object
++ = xstrdup (buf
);
1356 /* place o_file BEFORE this argument! */
1362 #ifdef COLLECT_EXPORT_LIST
1364 /* Resolving full library name. */
1365 const char *s
= resolve_lib_name (arg
+2);
1367 /* Saving a full library name. */
1368 add_to_list (&libs
, s
);
1373 #ifdef COLLECT_EXPORT_LIST
1374 /* Saving directories where to search for libraries. */
1376 add_prefix (&cmdline_lib_dirs
, arg
+2);
1382 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1384 output_file
= &arg
[2];
1393 if (arg
[2] == '\0' && do_collecting
)
1395 /* We must strip after the nm run, otherwise C++ linking
1396 will not work. Thus we strip in the second ld run, or
1397 else with strip if there is no second ld run. */
1409 if (strcmp (arg
, "--no-demangle") == 0)
1411 #ifndef HAVE_LD_DEMANGLE
1417 else if (strncmp (arg
, "--demangle", 10) == 0)
1419 #ifndef HAVE_LD_DEMANGLE
1423 enum demangling_styles style
1424 = cplus_demangle_name_to_style (arg
+11);
1425 if (style
== unknown_demangling
)
1426 error ("unknown demangling style '%s'", arg
+11);
1428 current_demangling_style
= style
;
1434 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1435 target_system_root
= arg
+ 10;
1436 else if (strcmp (arg
, "--version") == 0)
1438 else if (strcmp (arg
, "--help") == 0)
1443 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1444 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1445 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1446 || strcmp (p
, ".obj") == 0))
1455 /* place o_file BEFORE this argument! */
1461 if (p
[1] == 'o' || p
[1] == 'l')
1463 #ifdef COLLECT_EXPORT_LIST
1464 /* libraries can be specified directly, i.e. without -l flag. */
1467 /* Saving a full library name. */
1468 add_to_list (&libs
, arg
);
1474 #ifdef COLLECT_EXPORT_LIST
1475 /* This is added only for debugging purposes. */
1478 fprintf (stderr
, "List of libraries:\n");
1479 dump_list (stderr
, "\t", libs
.first
);
1482 /* The AIX linker will discard static constructors in object files if
1483 nothing else in the file is referenced, so look at them first. Unless
1484 we are building a shared object, ignore the eh frame tables, as we
1485 would otherwise reference them all, hence drag all the corresponding
1486 objects even if nothing else is referenced. */
1488 const char **export_object_lst
1489 = CONST_CAST2 (const char **, char **, object_lst
);
1491 struct id
*list
= libs
.first
;
1493 /* Compute the filter to use from the current one, do scan, then adjust
1494 the "current" filter to remove what we just included here. This will
1495 control whether we need a first pass link later on or not, and what
1496 will remain to be scanned there. */
1498 scanfilter this_filter
= ld1_filter
;
1501 this_filter
&= ~SCAN_DWEH
;
1504 while (export_object_lst
< object
)
1505 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1507 for (; list
; list
= list
->next
)
1508 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1510 ld1_filter
= ld1_filter
& ~this_filter
;
1515 char *buf
= concat ("-bE:", export_file
, NULL
);
1520 exportf
= fopen (export_file
, "w");
1521 if (exportf
== (FILE *) 0)
1522 fatal_error ("fopen %s: %m", export_file
);
1523 write_aix_file (exportf
, exports
.first
);
1524 if (fclose (exportf
))
1525 fatal_error ("fclose %s: %m", export_file
);
1530 *c_ptr
= *ld1
= *object
= (char *) 0;
1533 notice ("collect2 version %s\n", version_string
);
1537 printf ("Usage: collect2 [options]\n");
1538 printf (" Wrap linker and generate constructor code if needed.\n");
1539 printf (" Options:\n");
1540 printf (" -debug Enable debug output\n");
1541 printf (" --help Display this information\n");
1542 printf (" -v, --version Display this program's version number\n");
1544 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1545 printf ("Report bugs: %s\n", bug_report_url
);
1552 fprintf (stderr
, "ld_file_name = %s\n",
1553 (ld_file_name
? ld_file_name
: "not found"));
1554 fprintf (stderr
, "c_file_name = %s\n",
1555 (c_file_name
? c_file_name
: "not found"));
1556 fprintf (stderr
, "nm_file_name = %s\n",
1557 (nm_file_name
? nm_file_name
: "not found"));
1559 fprintf (stderr
, "ldd_file_name = %s\n",
1560 (ldd_file_name
? ldd_file_name
: "not found"));
1562 fprintf (stderr
, "strip_file_name = %s\n",
1563 (strip_file_name
? strip_file_name
: "not found"));
1564 fprintf (stderr
, "c_file = %s\n",
1565 (c_file
? c_file
: "not found"));
1566 fprintf (stderr
, "o_file = %s\n",
1567 (o_file
? o_file
: "not found"));
1569 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1571 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1573 ptr
= getenv ("COLLECT_GCC");
1575 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1577 ptr
= getenv ("COMPILER_PATH");
1579 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1581 ptr
= getenv (LIBRARY_PATH_ENV
);
1583 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1585 fprintf (stderr
, "\n");
1588 /* Load the program, searching all libraries and attempting to provide
1589 undefined symbols from repository information.
1591 If -r or they will be run via some other method, do not build the
1592 constructor or destructor list, just return now. */
1595 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1597 /* Perform the first pass link now, if we're about to exit or if we need
1598 to scan for things we haven't collected yet before pursuing further.
1600 On AIX, the latter typically includes nothing for shared objects or
1601 frame tables for an executable, out of what the required early scan on
1602 objects and libraries has performed above. In the !shared_obj case, we
1603 expect the relevant tables to be dragged together with their associated
1604 functions from precise cross reference insertions by the compiler. */
1606 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1607 do_tlink (ld1_argv
, object_lst
);
1611 #ifdef COLLECT_EXPORT_LIST
1612 /* Make sure we delete the export file we may have created. */
1613 if (export_file
!= 0 && export_file
[0])
1614 maybe_unlink (export_file
);
1616 if (lto_mode
!= LTO_MODE_NONE
)
1617 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1619 post_ld_pass (false);
1621 maybe_unlink (c_file
);
1622 maybe_unlink (o_file
);
1627 /* Unless we have done it all already, examine the namelist and search for
1628 static constructors and destructors to call. Write the constructor and
1629 destructor tables to a .s file and reload. */
1631 if (ld1_filter
!= SCAN_NOTHING
)
1632 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1634 #ifdef SCAN_LIBRARIES
1635 scan_libraries (output_file
);
1640 notice_translated (ngettext ("%d constructor found\n",
1641 "%d constructors found\n",
1642 constructors
.number
),
1643 constructors
.number
);
1644 notice_translated (ngettext ("%d destructor found\n",
1645 "%d destructors found\n",
1646 destructors
.number
),
1647 destructors
.number
);
1648 notice_translated (ngettext("%d frame table found\n",
1649 "%d frame tables found\n",
1650 frame_tables
.number
),
1651 frame_tables
.number
);
1654 /* If the scan exposed nothing of special interest, there's no need to
1655 generate the glue code and relink so return now. */
1657 if (constructors
.number
== 0 && destructors
.number
== 0
1658 && frame_tables
.number
== 0
1659 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1660 /* If we will be running these functions ourselves, we want to emit
1661 stubs into the shared library so that we do not have to relink
1662 dependent programs when we add static objects. */
1667 /* Do tlink without additional code generation now if we didn't
1668 do it earlier for scanning purposes. */
1669 if (ld1_filter
== SCAN_NOTHING
)
1670 do_tlink (ld1_argv
, object_lst
);
1673 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1675 /* Strip now if it was requested on the command line. */
1678 char **real_strip_argv
= XCNEWVEC (char *, 3);
1679 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1682 strip_argv
[0] = strip_file_name
;
1683 strip_argv
[1] = output_file
;
1684 strip_argv
[2] = (char *) 0;
1685 fork_execute ("strip", real_strip_argv
);
1688 #ifdef COLLECT_EXPORT_LIST
1689 maybe_unlink (export_file
);
1691 post_ld_pass (false);
1693 maybe_unlink (c_file
);
1694 maybe_unlink (o_file
);
1698 /* Sort ctor and dtor lists by priority. */
1699 sort_ids (&constructors
);
1700 sort_ids (&destructors
);
1702 maybe_unlink(output_file
);
1703 outf
= fopen (c_file
, "w");
1704 if (outf
== (FILE *) 0)
1705 fatal_error ("fopen %s: %m", c_file
);
1707 write_c_file (outf
, c_file
);
1710 fatal_error ("fclose %s: %m", c_file
);
1712 /* Tell the linker that we have initializer and finalizer functions. */
1713 #ifdef LD_INIT_SWITCH
1714 #ifdef COLLECT_EXPORT_LIST
1715 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1717 *ld2
++ = LD_INIT_SWITCH
;
1719 *ld2
++ = LD_FINI_SWITCH
;
1724 #ifdef COLLECT_EXPORT_LIST
1727 /* If we did not add export flag to link arguments before, add it to
1728 second link phase now. No new exports should have been added. */
1729 if (! exports
.first
)
1730 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1732 #ifndef LD_INIT_SWITCH
1733 add_to_list (&exports
, initname
);
1734 add_to_list (&exports
, fininame
);
1735 add_to_list (&exports
, "_GLOBAL__DI");
1736 add_to_list (&exports
, "_GLOBAL__DD");
1738 exportf
= fopen (export_file
, "w");
1739 if (exportf
== (FILE *) 0)
1740 fatal_error ("fopen %s: %m", export_file
);
1741 write_aix_file (exportf
, exports
.first
);
1742 if (fclose (exportf
))
1743 fatal_error ("fclose %s: %m", export_file
);
1747 /* End of arguments to second link phase. */
1752 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1753 output_file
, c_file
);
1754 write_c_file (stderr
, "stderr");
1755 fprintf (stderr
, "========== end of c_file\n\n");
1756 #ifdef COLLECT_EXPORT_LIST
1757 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1758 write_aix_file (stderr
, exports
.first
);
1759 fprintf (stderr
, "========== end of export_file\n\n");
1763 /* Assemble the constructor and destructor tables.
1764 Link the tables in with the rest of the program. */
1766 fork_execute ("gcc", c_argv
);
1767 #ifdef COLLECT_EXPORT_LIST
1768 /* On AIX we must call tlink because of possible templates resolution. */
1769 do_tlink (ld2_argv
, object_lst
);
1772 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1774 /* Otherwise, simply call ld because tlink is already done. */
1776 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1779 fork_execute ("ld", ld2_argv
);
1780 post_ld_pass (false);
1783 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1784 constructors/destructors in shared libraries. */
1785 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1788 maybe_unlink (c_file
);
1789 maybe_unlink (o_file
);
1791 #ifdef COLLECT_EXPORT_LIST
1792 maybe_unlink (export_file
);
1799 /* Wait for a process to finish, and exit if a nonzero status is found. */
1802 collect_wait (const char *prog
, struct pex_obj
*pex
)
1806 if (!pex_get_status (pex
, 1, &status
))
1807 fatal_error ("can't get program status: %m");
1812 if (WIFSIGNALED (status
))
1814 int sig
= WTERMSIG (status
);
1815 error ("%s terminated with signal %d [%s]%s",
1816 prog
, sig
, strsignal(sig
),
1817 WCOREDUMP(status
) ? ", core dumped" : "");
1818 collect_exit (FATAL_EXIT_CODE
);
1821 if (WIFEXITED (status
))
1822 return WEXITSTATUS (status
);
1828 do_wait (const char *prog
, struct pex_obj
*pex
)
1830 int ret
= collect_wait (prog
, pex
);
1833 error ("%s returned %d exit status", prog
, ret
);
1839 unlink (response_file
);
1840 response_file
= NULL
;
1845 /* Execute a program, and wait for the reply. */
1848 collect_execute (const char *prog
, char **argv
, const char *outname
,
1849 const char *errname
, int flags
)
1851 struct pex_obj
*pex
;
1854 char *response_arg
= NULL
;
1855 char *response_argv
[3] ATTRIBUTE_UNUSED
;
1857 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
1859 /* If using @file arguments, create a temporary file and put the
1860 contents of argv into it. Then change argv to an array corresponding
1861 to a single argument @FILE, where FILE is the temporary filename. */
1863 char **current_argv
= argv
+ 1;
1864 char *argv0
= argv
[0];
1868 /* Note: we assume argv contains at least one element; this is
1871 response_file
= make_temp_file ("");
1873 f
= fopen (response_file
, "w");
1876 fatal_error ("could not open response file %s", response_file
);
1878 status
= writeargv (current_argv
, f
);
1881 fatal_error ("could not write to response file %s", response_file
);
1883 status
= fclose (f
);
1886 fatal_error ("could not close response file %s", response_file
);
1888 response_arg
= concat ("@", response_file
, NULL
);
1889 response_argv
[0] = argv0
;
1890 response_argv
[1] = response_arg
;
1891 response_argv
[2] = NULL
;
1893 argv
= response_argv
;
1902 fprintf (stderr
, "%s", argv
[0]);
1904 notice ("[cannot find %s]", prog
);
1906 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
1907 fprintf (stderr
, " %s", str
);
1909 fprintf (stderr
, "\n");
1915 /* If we cannot find a program we need, complain error. Do this here
1916 since we might not end up needing something that we could not find. */
1919 fatal_error ("cannot find '%s'", prog
);
1921 pex
= pex_init (0, "collect2", NULL
);
1923 fatal_error ("pex_init failed: %m");
1925 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
1932 fatal_error ("%s: %m", _(errmsg
));
1935 fatal_error (errmsg
);
1938 free (response_arg
);
1944 fork_execute (const char *prog
, char **argv
)
1946 struct pex_obj
*pex
;
1948 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
1949 do_wait (prog
, pex
);
1952 /* Unlink FILE unless we are debugging or this is the output_file
1953 and we may not unlink it. */
1956 maybe_unlink (const char *file
)
1960 notice ("[Leaving %s]\n", file
);
1964 if (file
== output_file
&& !may_unlink_output_file
)
1967 unlink_if_ordinary (file
);
1970 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1973 maybe_unlink_list (char **file_list
)
1975 char **tmp
= file_list
;
1978 maybe_unlink (*(tmp
++));
1982 static long sequence_number
= 0;
1984 /* Add a name to a linked list. */
1987 add_to_list (struct head
*head_ptr
, const char *name
)
1990 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1992 strcpy (newid
->name
, name
);
1994 if (head_ptr
->first
)
1995 head_ptr
->last
->next
= newid
;
1997 head_ptr
->first
= newid
;
1999 /* Check for duplicate symbols. */
2000 for (p
= head_ptr
->first
;
2001 strcmp (name
, p
->name
) != 0;
2006 head_ptr
->last
->next
= 0;
2011 newid
->sequence
= ++sequence_number
;
2012 head_ptr
->last
= newid
;
2016 /* Grab the init priority number from an init function name that
2017 looks like "_GLOBAL_.I.12345.foo". */
2020 extract_init_priority (const char *name
)
2024 while (name
[pos
] == '_')
2026 pos
+= 10; /* strlen ("GLOBAL__X_") */
2028 /* Extract init_p number from ctor/dtor name. */
2029 pri
= atoi (name
+ pos
);
2030 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2033 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2034 ctors will be run from right to left, dtors from left to right. */
2037 sort_ids (struct head
*head_ptr
)
2039 /* id holds the current element to insert. id_next holds the next
2040 element to insert. id_ptr iterates through the already sorted elements
2041 looking for the place to insert id. */
2042 struct id
*id
, *id_next
, **id_ptr
;
2044 id
= head_ptr
->first
;
2046 /* We don't have any sorted elements yet. */
2047 head_ptr
->first
= NULL
;
2049 for (; id
; id
= id_next
)
2052 id
->sequence
= extract_init_priority (id
->name
);
2054 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2056 /* If the sequence numbers are the same, we put the id from the
2057 file later on the command line later in the list. */
2058 || id
->sequence
> (*id_ptr
)->sequence
2059 /* Hack: do lexical compare, too.
2060 || (id->sequence == (*id_ptr)->sequence
2061 && strcmp (id->name, (*id_ptr)->name) > 0) */
2070 /* Now set the sequence numbers properly so write_c_file works. */
2071 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2072 id
->sequence
= ++sequence_number
;
2075 /* Write: `prefix', the names on list LIST, `suffix'. */
2078 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2082 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2087 #ifdef COLLECT_EXPORT_LIST
2088 /* This function is really used only on AIX, but may be useful. */
2091 is_in_list (const char *prefix
, struct id
*list
)
2095 if (!strcmp (prefix
, list
->name
)) return 1;
2101 #endif /* COLLECT_EXPORT_LIST */
2103 /* Added for debugging purpose. */
2104 #ifdef COLLECT_EXPORT_LIST
2106 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2110 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2118 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2122 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2129 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2133 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2134 prefix
, list
->sequence
, list
->name
);
2139 /* Write out the constructor and destructor tables statically (for a shared
2140 object), along with the functions to execute them. */
2143 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2147 int frames
= (frame_tables
.number
> 0);
2149 /* Figure out name of output_file, stripping off .so version. */
2150 q
= p
= lbasename (output_file
);
2162 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2164 q
+= strlen (SHLIB_SUFFIX
);
2171 /* q points to null at end of the string (or . of the .so version) */
2172 prefix
= XNEWVEC (char, q
- p
+ 1);
2173 strncpy (prefix
, p
, q
- p
);
2175 for (r
= prefix
; *r
; r
++)
2176 if (!ISALNUM ((unsigned char)*r
))
2179 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2180 output_file
, prefix
);
2182 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2183 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2187 /* Write the tables as C code. */
2189 fprintf (stream
, "static int count;\n");
2190 fprintf (stream
, "typedef void entry_pt();\n");
2191 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2195 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2197 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2198 write_list (stream
, "\t\t&", frame_tables
.first
);
2199 fprintf (stream
, "\t0\n};\n");
2201 /* This must match what's in frame.h. */
2202 fprintf (stream
, "struct object {\n");
2203 fprintf (stream
, " void *pc_begin;\n");
2204 fprintf (stream
, " void *pc_end;\n");
2205 fprintf (stream
, " void *fde_begin;\n");
2206 fprintf (stream
, " void *fde_array;\n");
2207 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2208 fprintf (stream
, " struct object *next;\n");
2209 fprintf (stream
, "};\n");
2211 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2212 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2214 fprintf (stream
, "static void reg_frame () {\n");
2215 fprintf (stream
, "\tstatic struct object ob;\n");
2216 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2217 fprintf (stream
, "\t}\n");
2219 fprintf (stream
, "static void dereg_frame () {\n");
2220 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2221 fprintf (stream
, "\t}\n");
2224 fprintf (stream
, "void %s() {\n", initname
);
2225 if (constructors
.number
> 0 || frames
)
2227 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2228 write_list (stream
, "\t\t", constructors
.first
);
2230 fprintf (stream
, "\treg_frame,\n");
2231 fprintf (stream
, "\t};\n");
2232 fprintf (stream
, "\tentry_pt **p;\n");
2233 fprintf (stream
, "\tif (count++ != 0) return;\n");
2234 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2235 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2238 fprintf (stream
, "\t++count;\n");
2239 fprintf (stream
, "}\n");
2240 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2241 fprintf (stream
, "void %s() {\n", fininame
);
2242 if (destructors
.number
> 0 || frames
)
2244 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2245 write_list (stream
, "\t\t", destructors
.first
);
2247 fprintf (stream
, "\tdereg_frame,\n");
2248 fprintf (stream
, "\t};\n");
2249 fprintf (stream
, "\tentry_pt **p;\n");
2250 fprintf (stream
, "\tif (--count != 0) return;\n");
2251 fprintf (stream
, "\tp = dtors;\n");
2252 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2253 destructors
.number
+ frames
);
2255 fprintf (stream
, "}\n");
2259 COLLECT_SHARED_INIT_FUNC(stream
, initname
);
2260 COLLECT_SHARED_FINI_FUNC(stream
, fininame
);
2264 /* Write the constructor/destructor tables. */
2266 #ifndef LD_INIT_SWITCH
2268 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2270 /* Write the tables as C code. */
2272 int frames
= (frame_tables
.number
> 0);
2274 fprintf (stream
, "typedef void entry_pt();\n\n");
2276 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2280 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2282 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2283 write_list (stream
, "\t\t&", frame_tables
.first
);
2284 fprintf (stream
, "\t0\n};\n");
2286 /* This must match what's in frame.h. */
2287 fprintf (stream
, "struct object {\n");
2288 fprintf (stream
, " void *pc_begin;\n");
2289 fprintf (stream
, " void *pc_end;\n");
2290 fprintf (stream
, " void *fde_begin;\n");
2291 fprintf (stream
, " void *fde_array;\n");
2292 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2293 fprintf (stream
, " struct object *next;\n");
2294 fprintf (stream
, "};\n");
2296 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2297 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2299 fprintf (stream
, "static void reg_frame () {\n");
2300 fprintf (stream
, "\tstatic struct object ob;\n");
2301 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2302 fprintf (stream
, "\t}\n");
2304 fprintf (stream
, "static void dereg_frame () {\n");
2305 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2306 fprintf (stream
, "\t}\n");
2309 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2310 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2311 write_list (stream
, "\t", constructors
.first
);
2313 fprintf (stream
, "\treg_frame,\n");
2314 fprintf (stream
, "\t0\n};\n\n");
2316 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2318 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2319 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2320 write_list (stream
, "\t", destructors
.first
);
2322 fprintf (stream
, "\tdereg_frame,\n");
2323 fprintf (stream
, "\t0\n};\n\n");
2325 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2326 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2328 #endif /* ! LD_INIT_SWITCH */
2331 write_c_file (FILE *stream
, const char *name
)
2333 #ifndef LD_INIT_SWITCH
2335 write_c_file_glob (stream
, name
);
2338 write_c_file_stat (stream
, name
);
2341 #ifdef COLLECT_EXPORT_LIST
2343 write_aix_file (FILE *stream
, struct id
*list
)
2345 for (; list
; list
= list
->next
)
2347 fputs (list
->name
, stream
);
2348 putc ('\n', stream
);
2353 #ifdef OBJECT_FORMAT_NONE
2355 /* Check to make sure the file is an LTO object file. */
2358 maybe_lto_object_file (const char *prog_name
)
2361 unsigned char buf
[4];
2364 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2365 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2366 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2367 static unsigned char machomagic
[4][4] = {
2368 { 0xcf, 0xfa, 0xed, 0xfe },
2369 { 0xce, 0xfa, 0xed, 0xfe },
2370 { 0xfe, 0xed, 0xfa, 0xcf },
2371 { 0xfe, 0xed, 0xfa, 0xce }
2374 f
= fopen (prog_name
, "rb");
2377 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2381 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2382 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2383 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2385 for (i
= 0; i
< 4; i
++)
2386 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2392 /* Generic version to scan the name list of the loaded program for
2393 the symbols g++ uses for static constructors and destructors. */
2396 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2399 void (*int_handler
) (int);
2401 void (*quit_handler
) (int);
2403 char *real_nm_argv
[4];
2404 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2406 struct pex_obj
*pex
;
2413 if (which_pass
== PASS_SECOND
)
2416 /* LTO objects must be in a known format. This check prevents
2417 us from accepting an archive containing LTO objects, which
2418 gcc cannot currently handle. */
2419 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2422 /* If we do not have an `nm', complain. */
2423 if (nm_file_name
== 0)
2424 fatal_error ("cannot find 'nm'");
2426 nm_argv
[argc
++] = nm_file_name
;
2427 if (NM_FLAGS
[0] != '\0')
2428 nm_argv
[argc
++] = NM_FLAGS
;
2430 nm_argv
[argc
++] = prog_name
;
2431 nm_argv
[argc
++] = (char *) 0;
2433 /* Trace if needed. */
2436 const char **p_argv
;
2439 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2440 fprintf (stderr
, " %s", str
);
2442 fprintf (stderr
, "\n");
2448 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2450 fatal_error ("pex_init failed: %m");
2452 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2459 fatal_error ("%s: %m", _(errmsg
));
2462 fatal_error (errmsg
);
2465 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2467 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2470 inf
= pex_read_output (pex
, 0);
2472 fatal_error ("can't open nm output: %m");
2476 if (which_pass
== PASS_LTOINFO
)
2477 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2479 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2482 /* Read each line of nm output. */
2483 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2489 fprintf (stderr
, "\t%s\n", buf
);
2491 if (which_pass
== PASS_LTOINFO
)
2496 /* Look for the LTO info marker symbol, and add filename to
2497 the LTO objects list if found. */
2498 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2499 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2500 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2501 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2503 add_lto_object (<o_objects
, prog_name
);
2505 /* We need to read all the input, so we can't just
2506 return here. But we can avoid useless work. */
2515 /* If it contains a constructor or destructor name, add the name
2516 to the appropriate list unless this is a kind of symbol we're
2517 not supposed to even consider. */
2519 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2520 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2527 /* Find the end of the symbol name.
2528 Do not include `|', because Encore nm can tack that on the end. */
2529 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2535 switch (is_ctor_dtor (name
))
2538 if (! (filter
& SCAN_CTOR
))
2540 if (which_pass
!= PASS_LIB
)
2541 add_to_list (&constructors
, name
);
2545 if (! (filter
& SCAN_DTOR
))
2547 if (which_pass
!= PASS_LIB
)
2548 add_to_list (&destructors
, name
);
2552 if (! (filter
& SCAN_INIT
))
2554 if (which_pass
!= PASS_LIB
)
2555 fatal_error ("init function found in object %s", prog_name
);
2556 #ifndef LD_INIT_SWITCH
2557 add_to_list (&constructors
, name
);
2562 if (! (filter
& SCAN_FINI
))
2564 if (which_pass
!= PASS_LIB
)
2565 fatal_error ("fini function found in object %s", prog_name
);
2566 #ifndef LD_FINI_SWITCH
2567 add_to_list (&destructors
, name
);
2572 if (! (filter
& SCAN_DWEH
))
2574 if (which_pass
!= PASS_LIB
)
2575 add_to_list (&frame_tables
, name
);
2578 default: /* not a constructor or destructor */
2584 fprintf (stderr
, "\n");
2586 do_wait (nm_file_name
, pex
);
2588 signal (SIGINT
, int_handler
);
2590 signal (SIGQUIT
, quit_handler
);
2596 /* Use the List Dynamic Dependencies program to find shared libraries that
2597 the output file depends upon and their initialization/finalization
2598 routines, if any. */
2601 scan_libraries (const char *prog_name
)
2603 static struct head libraries
; /* list of shared libraries found */
2605 void (*int_handler
) (int);
2607 void (*quit_handler
) (int);
2609 char *real_ldd_argv
[4];
2610 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2612 struct pex_obj
*pex
;
2618 /* If we do not have an `ldd', complain. */
2619 if (ldd_file_name
== 0)
2621 error ("cannot find 'ldd'");
2625 ldd_argv
[argc
++] = ldd_file_name
;
2626 ldd_argv
[argc
++] = prog_name
;
2627 ldd_argv
[argc
++] = (char *) 0;
2629 /* Trace if needed. */
2632 const char **p_argv
;
2635 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2636 fprintf (stderr
, " %s", str
);
2638 fprintf (stderr
, "\n");
2644 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2646 fatal_error ("pex_init failed: %m");
2648 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2654 fatal_error ("%s: %m", _(errmsg
));
2657 fatal_error (errmsg
);
2660 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2662 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2665 inf
= pex_read_output (pex
, 0);
2667 fatal_error ("can't open ldd output: %m");
2670 notice ("\nldd output with constructors/destructors.\n");
2672 /* Read each line of ldd output. */
2673 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2676 char *name
, *end
, *p
= buf
;
2678 /* Extract names of libraries and add to list. */
2679 PARSE_LDD_OUTPUT (p
);
2684 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2685 fatal_error ("dynamic dependency %s not found", buf
);
2687 /* Find the end of the symbol name. */
2689 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2694 if (access (name
, R_OK
) == 0)
2695 add_to_list (&libraries
, name
);
2697 fatal_error ("unable to open dynamic dependency '%s'", buf
);
2700 fprintf (stderr
, "\t%s\n", buf
);
2703 fprintf (stderr
, "\n");
2705 do_wait (ldd_file_name
, pex
);
2707 signal (SIGINT
, int_handler
);
2709 signal (SIGQUIT
, quit_handler
);
2712 /* Now iterate through the library list adding their symbols to
2714 for (list
= libraries
.first
; list
; list
= list
->next
)
2715 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2718 #endif /* LDD_SUFFIX */
2720 #endif /* OBJECT_FORMAT_NONE */
2724 * COFF specific stuff.
2727 #ifdef OBJECT_FORMAT_COFF
2729 #if defined (EXTENDED_COFF)
2731 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2732 # define GCC_SYMENT SYMR
2733 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2734 # define GCC_SYMINC(X) (1)
2735 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2736 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2740 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2741 # define GCC_SYMENT SYMENT
2742 # if defined (C_WEAKEXT)
2743 # define GCC_OK_SYMBOL(X) \
2744 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2745 ((X).n_scnum > N_UNDEF) && \
2747 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2748 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2749 # define GCC_UNDEF_SYMBOL(X) \
2750 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2751 ((X).n_scnum == N_UNDEF))
2753 # define GCC_OK_SYMBOL(X) \
2754 (((X).n_sclass == C_EXT) && \
2755 ((X).n_scnum > N_UNDEF) && \
2757 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2758 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2759 # define GCC_UNDEF_SYMBOL(X) \
2760 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2762 # define GCC_SYMINC(X) ((X).n_numaux+1)
2763 # define GCC_SYMZERO(X) 0
2765 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2766 #if TARGET_AIX_VERSION >= 51
2767 # define GCC_CHECK_HDR(X) \
2768 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2769 || (HEADER (X).f_magic == 0767 && aix64_flag))
2771 # define GCC_CHECK_HDR(X) \
2772 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2773 || (HEADER (X).f_magic == 0757 && aix64_flag))
2778 #ifdef COLLECT_EXPORT_LIST
2779 /* Array of standard AIX libraries which should not
2780 be scanned for ctors/dtors. */
2781 static const char *const aix_std_libs
[] = {
2789 "/usr/lib/libc_r.a",
2790 "/usr/lib/libm_r.a",
2791 "/usr/lib/threads/libc.a",
2792 "/usr/ccs/lib/libc.a",
2793 "/usr/ccs/lib/libm.a",
2794 "/usr/ccs/lib/libc_r.a",
2795 "/usr/ccs/lib/libm_r.a",
2799 /* This function checks the filename and returns 1
2800 if this name matches the location of a standard AIX library. */
2801 static int ignore_library (const char *);
2803 ignore_library (const char *name
)
2805 const char *const *p
;
2808 if (target_system_root
[0] != '\0')
2810 length
= strlen (target_system_root
);
2811 if (strncmp (name
, target_system_root
, length
) != 0)
2815 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2816 if (strcmp (name
, *p
) == 0)
2820 #endif /* COLLECT_EXPORT_LIST */
2822 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2823 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2826 /* COFF version to scan the name list of the loaded program for
2827 the symbols g++ uses for static constructors and destructors. */
2830 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2833 LDFILE
*ldptr
= NULL
;
2834 int sym_index
, sym_count
;
2837 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2840 #ifdef COLLECT_EXPORT_LIST
2841 /* We do not need scanning for some standard C libraries. */
2842 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2845 /* On AIX we have a loop, because there is not much difference
2846 between an object and an archive. This trick allows us to
2847 eliminate scan_libraries() function. */
2851 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2852 non-const char * filename parameter, even though it will not
2853 modify that string. So we must cast away const-ness here,
2854 using CONST_CAST to prevent complaints from -Wcast-qual. */
2855 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2857 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2858 fatal_error ("%s: not a COFF file", prog_name
);
2860 if (GCC_CHECK_HDR (ldptr
))
2862 sym_count
= GCC_SYMBOLS (ldptr
);
2863 sym_index
= GCC_SYMZERO (ldptr
);
2865 #ifdef COLLECT_EXPORT_LIST
2866 /* Is current archive member a shared object? */
2867 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2870 while (sym_index
< sym_count
)
2874 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2876 sym_index
+= GCC_SYMINC (symbol
);
2878 if (GCC_OK_SYMBOL (symbol
))
2882 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2883 continue; /* Should never happen. */
2885 #ifdef XCOFF_DEBUGGING_INFO
2886 /* All AIX function names have a duplicate entry
2887 beginning with a dot. */
2892 switch (is_ctor_dtor (name
))
2895 if (! (filter
& SCAN_CTOR
))
2898 add_to_list (&constructors
, name
);
2899 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2900 if (which_pass
== PASS_OBJ
)
2901 add_to_list (&exports
, name
);
2906 if (! (filter
& SCAN_DTOR
))
2909 add_to_list (&destructors
, name
);
2910 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2911 if (which_pass
== PASS_OBJ
)
2912 add_to_list (&exports
, name
);
2916 #ifdef COLLECT_EXPORT_LIST
2918 if (! (filter
& SCAN_INIT
))
2920 #ifndef LD_INIT_SWITCH
2922 add_to_list (&constructors
, name
);
2927 if (! (filter
& SCAN_FINI
))
2929 #ifndef LD_INIT_SWITCH
2931 add_to_list (&destructors
, name
);
2937 if (! (filter
& SCAN_DWEH
))
2940 add_to_list (&frame_tables
, name
);
2941 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2942 if (which_pass
== PASS_OBJ
)
2943 add_to_list (&exports
, name
);
2947 default: /* not a constructor or destructor */
2948 #ifdef COLLECT_EXPORT_LIST
2949 /* Explicitly export all global symbols when
2950 building a shared object on AIX, but do not
2951 re-export symbols from another shared object
2952 and do not export symbols if the user
2953 provides an explicit export list. */
2954 if (shared_obj
&& !is_shared
2955 && which_pass
== PASS_OBJ
&& !export_flag
)
2956 add_to_list (&exports
, name
);
2962 #if !defined(EXTENDED_COFF)
2963 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2964 symbol
.n_scnum
, symbol
.n_sclass
,
2965 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2969 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2970 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
2975 #ifdef COLLECT_EXPORT_LIST
2978 /* If archive contains both 32-bit and 64-bit objects,
2979 we want to skip objects in other mode so mismatch normal. */
2981 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2982 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2988 fatal_error ("%s: cannot open as COFF file", prog_name
);
2990 #ifdef COLLECT_EXPORT_LIST
2991 /* On AIX loop continues while there are more members in archive. */
2993 while (ldclose (ldptr
) == FAILURE
);
2995 /* Otherwise we simply close ldptr. */
2996 (void) ldclose(ldptr
);
2999 #endif /* OBJECT_FORMAT_COFF */
3001 #ifdef COLLECT_EXPORT_LIST
3002 /* Given a library name without "lib" prefix, this function
3003 returns a full library name including a path. */
3005 resolve_lib_name (const char *name
)
3009 /* Library extensions for AIX dynamic linking. */
3010 const char * const libexts
[2] = {"a", "so"};
3012 for (i
= 0; libpaths
[i
]; i
++)
3013 if (libpaths
[i
]->max_len
> l
)
3014 l
= libpaths
[i
]->max_len
;
3016 lib_buf
= XNEWVEC (char, l
+ strlen(name
) + 10);
3018 for (i
= 0; libpaths
[i
]; i
++)
3020 struct prefix_list
*list
= libpaths
[i
]->plist
;
3021 for (; list
; list
= list
->next
)
3023 /* The following lines are needed because path_prefix list
3024 may contain directories both with trailing DIR_SEPARATOR and
3027 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen(list
->prefix
)-1]))
3029 for (j
= 0; j
< 2; j
++)
3031 sprintf (lib_buf
, "%s%slib%s.%s",
3032 list
->prefix
, p
, name
,
3033 libexts
[(j
+ aixrtl_flag
) % 2]);
3034 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3035 if (file_exists (lib_buf
))
3037 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3044 fprintf (stderr
, "not found\n");
3046 fatal_error ("library lib%s not found", name
);
3049 #endif /* COLLECT_EXPORT_LIST */
3051 #ifdef COLLECT_RUN_DSYMUTIL
3052 static int flag_dsym
= false;
3053 static int flag_idsym
= false;
3056 process_args (int *argcp
, char **argv
) {
3059 for (i
=0; i
<argc
; ++i
)
3061 if (strcmp (argv
[i
], "-dsym") == 0)
3064 /* Remove the flag, as we handle all processing for it. */
3067 argv
[j
] = argv
[j
+1];
3072 else if (strcmp (argv
[i
], "-idsym") == 0)
3075 /* Remove the flag, as we handle all processing for it. */
3078 argv
[j
] = argv
[j
+1];
3087 do_dsymutil (const char *output_file
) {
3088 const char *dsymutil
= DSYMUTIL
+ 1;
3089 struct pex_obj
*pex
;
3090 char **real_argv
= XCNEWVEC (char *, 3);
3091 const char ** argv
= CONST_CAST2 (const char **, char **,
3095 argv
[1] = output_file
;
3096 argv
[2] = (char *) 0;
3098 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
3099 do_wait (dsymutil
, pex
);
3103 post_ld_pass (bool temp_file
) {
3104 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3107 do_dsymutil (output_file
);
3111 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3112 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }