1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
29 #include "coretypes.h"
31 #include "filenames.h"
32 #include "file-find.h"
34 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
45 #include "collect2-aix.h"
46 #include "diagnostic.h"
52 /* On certain systems, we have code that works by scanning the object file
53 directly. But this code uses system-specific header files and library
54 functions, so turn it off in a cross-compiler. Likewise, the names of
55 the utilities are not correct for a cross-compiler; we have to hope that
56 cross-versions are in the proper directories. */
58 #ifdef CROSS_DIRECTORY_STRUCTURE
59 #ifndef CROSS_AIX_SUPPORT
60 #undef OBJECT_FORMAT_COFF
63 #undef REAL_LD_FILE_NAME
64 #undef REAL_NM_FILE_NAME
65 #undef REAL_STRIP_FILE_NAME
68 /* If we cannot use a special method, use the ordinary one:
69 run nm to find what symbols are present.
70 In a cross-compiler, this means you need a cross nm,
71 but that is not quite as unpleasant as special headers. */
73 #if !defined (OBJECT_FORMAT_COFF)
74 #define OBJECT_FORMAT_NONE
77 #ifdef OBJECT_FORMAT_COFF
79 #ifndef CROSS_DIRECTORY_STRUCTURE
87 /* Many versions of ldfcn.h define these. */
96 /* Some systems have an ISCOFF macro, but others do not. In some cases
97 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
98 that either do not have an ISCOFF macro in /usr/include or for those
102 #define MY_ISCOFF(X) ISCOFF (X)
105 #endif /* OBJECT_FORMAT_COFF */
107 #ifdef OBJECT_FORMAT_NONE
109 /* Default flags to pass to nm. */
111 #define NM_FLAGS "-n"
114 #endif /* OBJECT_FORMAT_NONE */
116 /* Some systems use __main in a way incompatible with its use in gcc, in these
117 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
118 give the same symbol without quotes for an alternative entry point. */
120 #define NAME__MAIN "__main"
123 /* This must match tree.h. */
124 #define DEFAULT_INIT_PRIORITY 65535
126 #ifndef COLLECT_SHARED_INIT_FUNC
127 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
128 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
130 #ifndef COLLECT_SHARED_FINI_FUNC
131 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
132 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
136 #define SCAN_LIBRARIES
140 #define SHLIB_SUFFIX ".so"
144 int do_collecting
= 1;
146 int do_collecting
= 0;
149 /* Cook up an always defined indication of whether we proceed the
150 "EXPORT_LIST" way. */
152 #ifdef COLLECT_EXPORT_LIST
153 #define DO_COLLECT_EXPORT_LIST 1
155 #define DO_COLLECT_EXPORT_LIST 0
158 /* Nonzero if we should suppress the automatic demangling of identifiers
159 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
162 /* Linked lists of constructor and destructor names. */
178 bool vflag
; /* true if -v or --version */
179 static int rflag
; /* true if -r */
180 static int strip_flag
; /* true if -s */
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 */
185 static int aixlazy_flag
; /* true if -blazy */
189 LTO_MODE_NONE
, /* Not doing LTO. */
190 LTO_MODE_LTO
, /* Normal LTO. */
191 LTO_MODE_WHOPR
/* WHOPR. */
194 /* Current LTO mode. */
196 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
198 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
201 bool debug
; /* true if -debug */
202 bool helpflag
; /* true if --help */
204 static int shared_obj
; /* true if -shared */
206 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
207 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
208 #ifdef COLLECT_EXPORT_LIST
209 static const char *export_file
; /* <xxx>.x for AIX export list. */
211 static char **lto_o_files
; /* Output files for LTO. */
212 const char *ldout
; /* File for ld stdout. */
213 const char *lderrout
; /* File for ld stderr. */
214 static const char *output_file
; /* Output file for ld. */
215 static const char *nm_file_name
; /* pathname of nm */
217 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
219 static const char *strip_file_name
; /* pathname of strip */
220 const char *c_file_name
; /* pathname of gcc */
221 static char *initname
, *fininame
; /* names of init and fini funcs */
224 #ifdef TARGET_AIX_VERSION
225 static char *aix_shared_initname
;
226 static char *aix_shared_fininame
; /* init/fini names as per the scheme
227 described in config/rs6000/aix.h */
230 static struct head constructors
; /* list of constructors found */
231 static struct head destructors
; /* list of destructors found */
232 #ifdef COLLECT_EXPORT_LIST
233 static struct head exports
; /* list of exported symbols */
235 static struct head frame_tables
; /* list of frame unwind info tables */
237 static bool at_file_supplied
; /* Whether to use @file arguments */
238 static char *response_file
; /* Name of any current response file */
240 struct obstack temporary_obstack
;
241 char * temporary_firstobj
;
243 /* A string that must be prepended to a target OS path in order to find
244 it on the host system. */
245 #ifdef TARGET_SYSTEM_ROOT
246 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
248 static const char *target_system_root
= "";
251 /* Whether we may unlink the output file, which should be set as soon as we
252 know we have successfully produced it. This is typically useful to prevent
253 blindly attempting to unlink a read-only output that the target linker
254 would leave untouched. */
255 bool may_unlink_output_file
= false;
257 #ifdef COLLECT_EXPORT_LIST
258 /* Lists to keep libraries to be scanned for global constructors/destructors. */
259 static struct head libs
; /* list of libraries */
260 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
261 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
262 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
263 &libpath_lib_dirs
, NULL
};
266 /* List of names of object files containing LTO information.
267 These are a subset of the object file names appearing on the
268 command line, and must be identical, in the sense of pointer
269 equality, with the names passed to maybe_run_lto_and_relink(). */
273 const char *name
; /* Name of object file. */
274 struct lto_object
*next
; /* Next in linked list. */
277 struct lto_object_list
279 struct lto_object
*first
; /* First list element. */
280 struct lto_object
*last
; /* Last list element. */
283 static struct lto_object_list lto_objects
;
285 /* Special kinds of symbols that a name may denote. */
288 SYM_REGULAR
= 0, /* nothing special */
290 SYM_CTOR
= 1, /* constructor */
291 SYM_DTOR
= 2, /* destructor */
292 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
293 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
294 SYM_DWEH
= 5, /* DWARF exception handling table */
299 static symkind
is_ctor_dtor (const char *);
301 static void handler (int);
302 static void do_wait (const char *, struct pex_obj
*);
303 static void fork_execute (const char *, char **);
304 static void maybe_unlink (const char *);
305 static void maybe_unlink_list (char **);
306 static void add_to_list (struct head
*, const char *);
307 static int extract_init_priority (const char *);
308 static void sort_ids (struct head
*);
309 static void write_list (FILE *, const char *, struct id
*);
310 #ifdef COLLECT_EXPORT_LIST
311 static void dump_list (FILE *, const char *, struct id
*);
314 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
316 static void write_list_with_asm (FILE *, const char *, struct id
*);
317 static void write_c_file (FILE *, const char *);
318 static void write_c_file_stat (FILE *, const char *);
319 #ifndef LD_INIT_SWITCH
320 static void write_c_file_glob (FILE *, const char *);
322 #ifdef SCAN_LIBRARIES
323 static void scan_libraries (const char *);
325 #ifdef COLLECT_EXPORT_LIST
327 static int is_in_list (const char *, struct id
*);
329 static void write_aix_file (FILE *, struct id
*);
330 static char *resolve_lib_name (const char *);
332 static char *extract_string (const char **);
333 static void post_ld_pass (bool);
334 static void process_args (int *argcp
, char **argv
);
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
,
357 SCAN_AIXI
= 1 << SYM_AIXI
,
358 SCAN_AIXD
= 1 << SYM_AIXD
,
362 /* This type is used for parameters and variables which hold
363 combinations of the flags in enum scanfilter_masks. */
364 typedef int scanfilter
;
366 /* Scan the name list of the loaded program for the symbols g++ uses for
367 static constructors and destructors.
369 The SCANPASS argument tells which collect processing pass this is for and
370 the SCANFILTER argument tells which kinds of symbols to consider in this
371 pass. Symbols of a special kind not in the filter mask are considered as
374 The constructor table begins at __CTOR_LIST__ and contains a count of the
375 number of pointers (or -1 if the constructors are built in a separate
376 section by the linker), followed by the pointers to the constructor
377 functions, terminated with a null pointer. The destructor table has the
378 same format, and begins at __DTOR_LIST__. */
380 static void scan_prog_file (const char *, scanpass
, scanfilter
);
383 /* Delete tempfiles and exit function. */
386 collect_atexit (void)
388 if (c_file
!= 0 && c_file
[0])
389 maybe_unlink (c_file
);
391 if (o_file
!= 0 && o_file
[0])
392 maybe_unlink (o_file
);
394 #ifdef COLLECT_EXPORT_LIST
395 if (export_file
!= 0 && export_file
[0])
396 maybe_unlink (export_file
);
400 maybe_unlink_list (lto_o_files
);
402 if (ldout
!= 0 && ldout
[0])
404 dump_ld_file (ldout
, stdout
);
405 maybe_unlink (ldout
);
408 if (lderrout
!= 0 && lderrout
[0])
410 dump_ld_file (lderrout
, stderr
);
411 maybe_unlink (lderrout
);
415 maybe_unlink (response_file
);
419 /* Notify user of a non-error. */
421 notice (const char *cmsgid
, ...)
425 va_start (ap
, cmsgid
);
426 vfprintf (stderr
, _(cmsgid
), ap
);
430 /* Notify user of a non-error, without translating the format string. */
432 notice_translated (const char *cmsgid
, ...)
436 va_start (ap
, cmsgid
);
437 vfprintf (stderr
, cmsgid
, ap
);
444 if (c_file
!= 0 && c_file
[0])
445 maybe_unlink (c_file
);
447 if (o_file
!= 0 && o_file
[0])
448 maybe_unlink (o_file
);
450 if (ldout
!= 0 && ldout
[0])
451 maybe_unlink (ldout
);
453 if (lderrout
!= 0 && lderrout
[0])
454 maybe_unlink (lderrout
);
456 #ifdef COLLECT_EXPORT_LIST
457 if (export_file
!= 0 && export_file
[0])
458 maybe_unlink (export_file
);
462 maybe_unlink_list (lto_o_files
);
465 maybe_unlink (response_file
);
467 signal (signo
, SIG_DFL
);
473 file_exists (const char *name
)
475 return access (name
, R_OK
) == 0;
478 /* Parse a reasonable subset of shell quoting syntax. */
481 extract_string (const char **pp
)
494 obstack_1grow (&temporary_obstack
, c
);
495 else if (! inside
&& c
== ' ')
497 else if (! inside
&& c
== '\\')
502 obstack_1grow (&temporary_obstack
, c
);
505 obstack_1grow (&temporary_obstack
, '\0');
507 return XOBFINISH (&temporary_obstack
, char *);
511 dump_ld_file (const char *name
, FILE *to
)
513 FILE *stream
= fopen (name
, "r");
520 while (c
= getc (stream
),
521 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
522 obstack_1grow (&temporary_obstack
, c
);
523 if (obstack_object_size (&temporary_obstack
) > 0)
525 const char *word
, *p
;
527 obstack_1grow (&temporary_obstack
, '\0');
528 word
= XOBFINISH (&temporary_obstack
, const char *);
531 ++word
, putc ('.', to
);
533 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
534 p
+= strlen (USER_LABEL_PREFIX
);
536 #ifdef HAVE_LD_DEMANGLE
542 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
550 diff
= strlen (word
) - strlen (result
);
551 while (diff
> 0 && c
== ' ')
552 --diff
, putc (' ', to
);
553 if (diff
< 0 && c
== ' ')
555 while (diff
< 0 && c
== ' ')
556 ++diff
, c
= getc (stream
);
559 /* Make sure we output at least one space, or
560 the demangled symbol name will run into
561 whatever text follows. */
572 obstack_free (&temporary_obstack
, temporary_firstobj
);
581 /* Return the kind of symbol denoted by name S. */
584 is_ctor_dtor (const char *s
)
586 struct names
{ const char *const name
; const int len
; symkind ret
;
587 const int two_underscores
; };
589 const struct names
*p
;
591 const char *orig_s
= s
;
593 static const struct names special
[] = {
594 #ifndef NO_DOLLAR_IN_LABEL
595 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
596 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
598 #ifndef NO_DOT_IN_LABEL
599 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
600 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
601 #endif /* NO_DOT_IN_LABEL */
602 #endif /* NO_DOLLAR_IN_LABEL */
603 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
604 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
605 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
606 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
607 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
608 #ifdef TARGET_AIX_VERSION
609 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
610 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
612 { NULL
, 0, SYM_REGULAR
, 0 }
615 while ((ch
= *s
) == '_')
621 for (p
= &special
[0]; p
->len
> 0; p
++)
624 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
625 && strncmp (s
, p
->name
, p
->len
) == 0)
633 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
634 and one from the PATH variable. */
636 static struct path_prefix cpath
, path
;
638 #ifdef CROSS_DIRECTORY_STRUCTURE
639 /* This is the name of the target machine. We use it to form the name
640 of the files to execute. */
642 static const char *const target_machine
= TARGET_MACHINE
;
645 /* Search for NAME using prefix list PPREFIX. We only look for executable
648 Return 0 if not found, otherwise return its name, allocated with malloc. */
650 #ifdef OBJECT_FORMAT_NONE
652 /* Add an entry for the object file NAME to object file list LIST.
653 New entries are added at the end of the list. The original pointer
654 value of NAME is preserved, i.e., no string copy is performed. */
657 add_lto_object (struct lto_object_list
*list
, const char *name
)
659 struct lto_object
*n
= XNEW (struct lto_object
);
664 list
->last
->next
= n
;
670 #endif /* OBJECT_FORMAT_NONE */
673 /* Perform a link-time recompilation and relink if any of the object
674 files contain LTO info. The linker command line LTO_LD_ARGV
675 represents the linker command that would produce a final executable
676 without the use of LTO. OBJECT_LST is a vector of object file names
677 appearing in LTO_LD_ARGV that are to be considered for link-time
678 recompilation, where OBJECT is a pointer to the last valid element.
679 (This awkward convention avoids an impedance mismatch with the
680 usage of similarly-named variables in main().) The elements of
681 OBJECT_LST must be identical, i.e., pointer equal, to the
682 corresponding arguments in LTO_LD_ARGV.
684 Upon entry, at least one linker run has been performed without the
685 use of any LTO info that might be present. Any recompilations
686 necessary for template instantiations have been performed, and
687 initializer/finalizer tables have been created if needed and
688 included in the linker command line LTO_LD_ARGV. If any of the
689 object files contain LTO info, we run the LTO back end on all such
690 files, and perform the final link with the LTO back end output
691 substituted for the LTO-optimized files. In some cases, a final
692 link with all link-time generated code has already been performed,
693 so there is no need to relink if no LTO info is found. In other
694 cases, our caller has not produced the final executable, and is
695 relying on us to perform the required link whether LTO info is
696 present or not. In that case, the FORCE argument should be true.
697 Note that the linker command line argument LTO_LD_ARGV passed into
698 this function may be modified in place. */
701 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
702 const char **object
, bool force
)
704 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
706 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
708 while (object_file
< object
)
710 /* If file contains LTO info, add it to the list of LTO objects. */
711 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
713 /* Increment the argument count by the number of object file arguments
714 we will add. An upper bound suffices, so just count all of the
715 object files regardless of whether they contain LTO info. */
719 if (lto_objects
.first
)
722 const char **lto_c_ptr
;
725 struct lto_object
*list
;
726 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
728 const char *prog
= "lto-wrapper";
729 int lto_ld_argv_size
= 0;
730 char **out_lto_ld_argv
;
731 int out_lto_ld_argv_size
;
735 fatal_error ("COLLECT_LTO_WRAPPER must be set");
739 /* There is at least one object file containing LTO info,
740 so we need to run the LTO back end and relink.
742 To do so we build updated ld arguments with first
743 LTO object replaced by all partitions and other LTO
746 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
747 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
749 *lto_c_ptr
++ = lto_wrapper
;
751 /* Add LTO objects to the wrapper command line. */
752 for (list
= lto_objects
.first
; list
; list
= list
->next
)
753 *lto_c_ptr
++ = list
->name
;
757 /* Run the LTO back end. */
758 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
765 stream
= pex_read_output (pex
, 0);
769 while ((c
= getc (stream
)) != EOF
)
771 obstack_1grow (&temporary_obstack
, c
);
776 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
777 lto_o_files
[num_files
] = NULL
;
778 start
= XOBFINISH (&temporary_obstack
, char *);
779 for (i
= 0; i
< num_files
; ++i
)
786 lto_o_files
[i
] = xstrdup (start
);
791 obstack_free (&temporary_obstack
, temporary_firstobj
);
796 /* Compute memory needed for new LD arguments. At most number of original arguemtns
797 plus number of partitions. */
798 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
800 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
801 out_lto_ld_argv_size
= 0;
803 /* After running the LTO back end, we will relink, substituting
804 the LTO output for the object files that we submitted to the
805 LTO. Here, we modify the linker command line for the relink. */
807 /* Copy all arguments until we find first LTO file. */
811 for (list
= lto_objects
.first
; list
; list
= list
->next
)
812 if (*p
== list
->name
) /* Note test for pointer equality! */
816 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
819 /* Now insert all LTO partitions. */
820 lto_o_ptr
= lto_o_files
;
822 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
824 /* ... and copy the rest. */
827 for (list
= lto_objects
.first
; list
; list
= list
->next
)
828 if (*p
== list
->name
) /* Note test for pointer equality! */
831 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
834 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
836 /* Run the linker again, this time replacing the object files
837 optimized by the LTO with the temporary file generated by the LTO. */
838 fork_execute ("ld", out_lto_ld_argv
);
842 maybe_unlink_list (lto_o_files
);
846 /* Our caller is relying on us to do the link
847 even though there is no LTO back end work to be done. */
848 fork_execute ("ld", lto_ld_argv
);
849 post_ld_pass (false);
856 main (int argc
, char **argv
)
866 } selected_linker
= USE_DEFAULT_LD
;
867 static const char *const ld_suffixes
[USE_LD_MAX
] =
875 static const char *const real_ld_suffix
= "real-ld";
876 static const char *const collect_ld_suffix
= "collect-ld";
877 static const char *const nm_suffix
= "nm";
878 static const char *const gnm_suffix
= "gnm";
880 static const char *const ldd_suffix
= LDD_SUFFIX
;
882 static const char *const strip_suffix
= "strip";
883 static const char *const gstrip_suffix
= "gstrip";
885 const char *full_ld_suffixes
[USE_LD_MAX
];
886 #ifdef CROSS_DIRECTORY_STRUCTURE
887 /* If we look for a program in the compiler directories, we just use
888 the short name, since these directories are already system-specific.
889 But it we look for a program in the system directories, we need to
890 qualify the program name with the target machine. */
892 const char *const full_nm_suffix
=
893 concat (target_machine
, "-", nm_suffix
, NULL
);
894 const char *const full_gnm_suffix
=
895 concat (target_machine
, "-", gnm_suffix
, NULL
);
897 const char *const full_ldd_suffix
=
898 concat (target_machine
, "-", ldd_suffix
, NULL
);
900 const char *const full_strip_suffix
=
901 concat (target_machine
, "-", strip_suffix
, NULL
);
902 const char *const full_gstrip_suffix
=
903 concat (target_machine
, "-", gstrip_suffix
, NULL
);
906 const char *const full_ldd_suffix
= ldd_suffix
;
908 const char *const full_nm_suffix
= nm_suffix
;
909 const char *const full_gnm_suffix
= gnm_suffix
;
910 const char *const full_strip_suffix
= strip_suffix
;
911 const char *const full_gstrip_suffix
= gstrip_suffix
;
912 #endif /* CROSS_DIRECTORY_STRUCTURE */
916 #ifdef COLLECT_EXPORT_LIST
919 const char *ld_file_name
;
925 bool use_plugin
= false;
926 bool use_collect_ld
= false;
928 /* The kinds of symbols we will have to consider when scanning the
929 outcome of a first pass link. This is ALL to start with, then might
930 be adjusted before getting to the first pass link per se, typically on
931 AIX where we perform an early scan of objects and libraries to fetch
932 the list of global ctors/dtors and make sure they are not garbage
934 scanfilter ld1_filter
= SCAN_ALL
;
940 #ifdef TARGET_AIX_VERSION
941 int object_nbr
= argc
;
948 for (i
= 0; i
< USE_LD_MAX
; i
++)
950 #ifdef CROSS_DIRECTORY_STRUCTURE
951 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
956 p
= argv
[0] + strlen (argv
[0]);
957 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
961 xmalloc_set_program_name (progname
);
964 expandargv (&argc
, &argv
);
965 if (argv
!= old_argv
)
966 at_file_supplied
= 1;
968 process_args (&argc
, argv
);
970 num_c_args
= argc
+ 9;
972 #ifndef HAVE_LD_DEMANGLE
973 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
975 /* Suppress demangling by the real linker, which may be broken. */
976 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
979 #if defined (COLLECT2_HOST_INITIALIZATION)
980 /* Perform system dependent initialization, if necessary. */
981 COLLECT2_HOST_INITIALIZATION
;
985 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
986 receive the signal. A different setting is inheritable */
987 signal (SIGCHLD
, SIG_DFL
);
990 if (atexit (collect_atexit
) != 0)
991 fatal_error ("atexit failed");
993 /* Unlock the stdio streams. */
994 unlock_std_streams ();
998 diagnostic_initialize (global_dc
, 0);
1000 /* Do not invoke xcalloc before this point, since locale needs to be
1001 set first, in case a diagnostic is issued. */
1003 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
1004 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
1005 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
1006 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
1007 object_lst
= XCNEWVEC (char *, argc
);
1008 object
= CONST_CAST2 (const char **, char **, object_lst
);
1014 /* Parse command line early for instances of -debug. This allows
1015 the debug flag to be set before functions like find_a_file()
1016 are called. We also look for the -flto or -flto-partition=none flag to know
1017 what LTO mode we are in. */
1019 bool no_partition
= false;
1021 for (i
= 1; argv
[i
] != NULL
; i
++)
1023 if (! strcmp (argv
[i
], "-debug"))
1025 else if (! strcmp (argv
[i
], "-flto-partition=none"))
1026 no_partition
= true;
1027 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1028 lto_mode
= LTO_MODE_NONE
;
1029 else if (! strcmp (argv
[i
], "-plugin"))
1032 if (selected_linker
== USE_DEFAULT_LD
)
1033 selected_linker
= USE_PLUGIN_LD
;
1035 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1036 selected_linker
= USE_BFD_LD
;
1037 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1038 selected_linker
= USE_GOLD_LD
;
1039 else if (strcmp (argv
[i
], "-fuse-ld=mcld") == 0)
1040 selected_linker
= USE_MCLD_LD
;
1042 #ifdef COLLECT_EXPORT_LIST
1043 /* These flags are position independent, although their order
1044 is important - subsequent flags override earlier ones. */
1045 else if (strcmp (argv
[i
], "-b64") == 0)
1047 /* -bexport:filename always needs the :filename */
1048 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1049 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1051 else if (strcmp (argv
[i
], "-brtl") == 0
1052 || strcmp (argv
[i
], "-bsvr4") == 0
1053 || strcmp (argv
[i
], "-G") == 0)
1055 else if (strcmp (argv
[i
], "-bnortl") == 0)
1057 else if (strcmp (argv
[i
], "-blazy") == 0)
1062 find_file_set_debug (debug
);
1064 lto_mode
= LTO_MODE_NONE
;
1065 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1066 lto_mode
= LTO_MODE_LTO
;
1069 #ifndef DEFAULT_A_OUT_NAME
1070 output_file
= "a.out";
1072 output_file
= DEFAULT_A_OUT_NAME
;
1075 obstack_begin (&temporary_obstack
, 0);
1076 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1078 #ifndef HAVE_LD_DEMANGLE
1079 current_demangling_style
= auto_demangling
;
1081 p
= getenv ("COLLECT_GCC_OPTIONS");
1084 const char *q
= extract_string (&p
);
1085 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1088 obstack_free (&temporary_obstack
, temporary_firstobj
);
1090 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1091 -fno-exceptions -w -fno-whole-program */
1094 c_argv
= XCNEWVEC (char *, num_c_args
);
1095 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1098 fatal_error ("no arguments");
1101 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1102 signal (SIGQUIT
, handler
);
1104 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1105 signal (SIGINT
, handler
);
1107 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1108 signal (SIGALRM
, handler
);
1111 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1112 signal (SIGHUP
, handler
);
1114 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1115 signal (SIGSEGV
, handler
);
1117 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1118 signal (SIGBUS
, handler
);
1121 /* Extract COMPILER_PATH and PATH into our prefix list. */
1122 prefix_from_env ("COMPILER_PATH", &cpath
);
1123 prefix_from_env ("PATH", &path
);
1125 /* Try to discover a valid linker/nm/strip to use. */
1127 /* Maybe we know the right file to use (if not cross). */
1129 #ifdef DEFAULT_LINKER
1130 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
)
1133 # ifdef HOST_EXECUTABLE_SUFFIX
1134 int len
= (sizeof (DEFAULT_LINKER
)
1135 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1139 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1140 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1141 HOST_EXECUTABLE_SUFFIX. */
1142 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1144 default_linker
[len
] = '\0';
1145 linker_name
= concat (default_linker
,
1146 &ld_suffixes
[selected_linker
][2],
1147 HOST_EXECUTABLE_SUFFIX
, NULL
);
1150 if (linker_name
== NULL
)
1152 linker_name
= concat (DEFAULT_LINKER
,
1153 &ld_suffixes
[selected_linker
][2],
1155 if (access (linker_name
, X_OK
) == 0)
1156 ld_file_name
= linker_name
;
1158 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1159 ld_file_name
= DEFAULT_LINKER
;
1160 if (ld_file_name
== 0)
1162 #ifdef REAL_LD_FILE_NAME
1163 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1164 if (ld_file_name
== 0)
1166 /* Search the (target-specific) compiler dirs for ld'. */
1167 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1168 /* Likewise for `collect-ld'. */
1169 if (ld_file_name
== 0)
1171 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1172 use_collect_ld
= ld_file_name
!= 0;
1174 /* Search the compiler directories for `ld'. We have protection against
1175 recursive calls in find_a_file. */
1176 if (ld_file_name
== 0)
1177 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1178 /* Search the ordinary system bin directories
1179 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1180 if (ld_file_name
== 0)
1181 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1183 #ifdef REAL_NM_FILE_NAME
1184 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1185 if (nm_file_name
== 0)
1187 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1188 if (nm_file_name
== 0)
1189 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1190 if (nm_file_name
== 0)
1191 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1192 if (nm_file_name
== 0)
1193 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1196 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1197 if (ldd_file_name
== 0)
1198 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1201 #ifdef REAL_STRIP_FILE_NAME
1202 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1203 if (strip_file_name
== 0)
1205 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1206 if (strip_file_name
== 0)
1207 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1208 if (strip_file_name
== 0)
1209 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1210 if (strip_file_name
== 0)
1211 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1213 /* Determine the full path name of the C compiler to use. */
1214 c_file_name
= getenv ("COLLECT_GCC");
1215 if (c_file_name
== 0)
1217 #ifdef CROSS_DIRECTORY_STRUCTURE
1218 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1220 c_file_name
= "gcc";
1224 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1226 /* Here it should be safe to use the system search path since we should have
1227 already qualified the name of the compiler when it is needed. */
1229 p
= find_a_file (&path
, c_file_name
, X_OK
);
1234 *ld1
++ = *ld2
++ = ld_file_name
;
1236 /* Make temp file names. */
1237 c_file
= make_temp_file (".c");
1238 o_file
= make_temp_file (".o");
1239 #ifdef COLLECT_EXPORT_LIST
1240 export_file
= make_temp_file (".x");
1244 ldout
= make_temp_file (".ld");
1245 lderrout
= make_temp_file (".le");
1247 *c_ptr
++ = c_file_name
;
1254 #ifdef COLLECT_EXPORT_LIST
1255 /* Generate a list of directories from LIBPATH. */
1256 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1257 /* Add to this list also two standard directories where
1258 AIX loader always searches for libraries. */
1259 add_prefix (&libpath_lib_dirs
, "/lib");
1260 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1263 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1265 AIX support needs to know if -shared has been specified before
1266 parsing commandline arguments. */
1268 p
= getenv ("COLLECT_GCC_OPTIONS");
1271 const char *q
= extract_string (&p
);
1272 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1273 *c_ptr
++ = xstrdup (q
);
1274 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1275 *c_ptr
++ = xstrdup (q
);
1276 if (strcmp (q
, "-shared") == 0)
1278 if (*q
== '-' && q
[1] == 'B')
1280 *c_ptr
++ = xstrdup (q
);
1283 q
= extract_string (&p
);
1284 *c_ptr
++ = xstrdup (q
);
1288 obstack_free (&temporary_obstack
, temporary_firstobj
);
1289 *c_ptr
++ = "-fno-profile-arcs";
1290 *c_ptr
++ = "-fno-test-coverage";
1291 *c_ptr
++ = "-fno-branch-probabilities";
1292 *c_ptr
++ = "-fno-exceptions";
1294 *c_ptr
++ = "-fno-whole-program";
1296 /* !!! When GCC calls collect2,
1297 it does not know whether it is calling collect2 or ld.
1298 So collect2 cannot meaningfully understand any options
1299 except those ld understands.
1300 If you propose to make GCC pass some other option,
1301 just imagine what will happen if ld is really ld!!! */
1303 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1304 /* After the first file, put in the c++ rt0. */
1307 while ((arg
= *++argv
) != (char *) 0)
1309 *ld1
++ = *ld2
++ = arg
;
1316 if (!strcmp (arg
, "-debug"))
1318 /* Already parsed. */
1322 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1325 *ld1
++ = *ld2
++ = *argv
;
1330 if (strncmp (arg
, "-flto", 5) == 0)
1333 /* Do not pass LTO flag to the linker. */
1337 error ("LTO support has not been enabled in this "
1341 else if (!use_collect_ld
1342 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1344 /* Do not pass -fuse-ld={bfd|gold|mcld} to the linker. */
1348 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1350 /* Do not pass -fno-lto to the linker. */
1354 #ifdef TARGET_AIX_VERSION
1357 /* File containing a list of input files to process. */
1360 char buf
[MAXPATHLEN
+ 2];
1361 /* Number of additionnal object files. */
1363 /* Maximum of additionnal object files before vector
1366 const char *list_filename
= arg
+ 2;
1368 /* Accept -fFILENAME and -f FILENAME. */
1369 if (*list_filename
== '\0' && argv
[1])
1372 list_filename
= *argv
;
1373 *ld1
++ = *ld2
++ = *argv
;
1376 stream
= fopen (list_filename
, "r");
1378 fatal_error ("can't open %s: %m", list_filename
);
1380 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1382 /* Remove end of line. */
1383 int len
= strlen (buf
);
1384 if (len
>= 1 && buf
[len
- 1] =='\n')
1385 buf
[len
- 1] = '\0';
1387 /* Put on object vector.
1388 Note: we only expanse vector here, so we must keep
1389 extra space for remaining arguments. */
1390 if (add_nbr
>= add_max
)
1393 object
- CONST_CAST2 (const char **, char **,
1395 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1396 object_lst
= XRESIZEVEC (char *, object_lst
,
1397 object_nbr
+ add_max
);
1398 object
= CONST_CAST2 (const char **, char **,
1400 object_nbr
+= add_max
;
1402 *object
++ = xstrdup (buf
);
1413 /* place o_file BEFORE this argument! */
1419 #ifdef COLLECT_EXPORT_LIST
1421 /* Resolving full library name. */
1422 const char *s
= resolve_lib_name (arg
+2);
1424 /* Saving a full library name. */
1425 add_to_list (&libs
, s
);
1430 #ifdef COLLECT_EXPORT_LIST
1431 /* Saving directories where to search for libraries. */
1433 add_prefix (&cmdline_lib_dirs
, arg
+2);
1439 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1441 output_file
= &arg
[2];
1450 if (arg
[2] == '\0' && do_collecting
)
1452 /* We must strip after the nm run, otherwise C++ linking
1453 will not work. Thus we strip in the second ld run, or
1454 else with strip if there is no second ld run. */
1466 if (strcmp (arg
, "--no-demangle") == 0)
1468 #ifndef HAVE_LD_DEMANGLE
1474 else if (strncmp (arg
, "--demangle", 10) == 0)
1476 #ifndef HAVE_LD_DEMANGLE
1480 enum demangling_styles style
1481 = cplus_demangle_name_to_style (arg
+11);
1482 if (style
== unknown_demangling
)
1483 error ("unknown demangling style '%s'", arg
+11);
1485 current_demangling_style
= style
;
1491 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1492 target_system_root
= arg
+ 10;
1493 else if (strcmp (arg
, "--version") == 0)
1495 else if (strcmp (arg
, "--help") == 0)
1500 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1501 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1502 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1503 || strcmp (p
, ".obj") == 0))
1512 /* place o_file BEFORE this argument! */
1518 if (p
[1] == 'o' || p
[1] == 'l')
1520 #ifdef COLLECT_EXPORT_LIST
1521 /* libraries can be specified directly, i.e. without -l flag. */
1524 /* Saving a full library name. */
1525 add_to_list (&libs
, arg
);
1531 #ifdef COLLECT_EXPORT_LIST
1532 /* This is added only for debugging purposes. */
1535 fprintf (stderr
, "List of libraries:\n");
1536 dump_list (stderr
, "\t", libs
.first
);
1539 /* The AIX linker will discard static constructors in object files if
1540 nothing else in the file is referenced, so look at them first. Unless
1541 we are building a shared object, ignore the eh frame tables, as we
1542 would otherwise reference them all, hence drag all the corresponding
1543 objects even if nothing else is referenced. */
1545 const char **export_object_lst
1546 = CONST_CAST2 (const char **, char **, object_lst
);
1548 struct id
*list
= libs
.first
;
1550 /* Compute the filter to use from the current one, do scan, then adjust
1551 the "current" filter to remove what we just included here. This will
1552 control whether we need a first pass link later on or not, and what
1553 will remain to be scanned there. */
1555 scanfilter this_filter
= ld1_filter
;
1558 this_filter
&= ~SCAN_DWEH
;
1561 while (export_object_lst
< object
)
1562 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1564 for (; list
; list
= list
->next
)
1565 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1567 ld1_filter
= ld1_filter
& ~this_filter
;
1572 char *buf
= concat ("-bE:", export_file
, NULL
);
1577 exportf
= fopen (export_file
, "w");
1578 if (exportf
== (FILE *) 0)
1579 fatal_error ("fopen %s: %m", export_file
);
1580 write_aix_file (exportf
, exports
.first
);
1581 if (fclose (exportf
))
1582 fatal_error ("fclose %s: %m", export_file
);
1587 *c_ptr
= *ld1
= *object
= (char *) 0;
1590 notice ("collect2 version %s\n", version_string
);
1594 printf ("Usage: collect2 [options]\n");
1595 printf (" Wrap linker and generate constructor code if needed.\n");
1596 printf (" Options:\n");
1597 printf (" -debug Enable debug output\n");
1598 printf (" --help Display this information\n");
1599 printf (" -v, --version Display this program's version number\n");
1601 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1602 printf ("Report bugs: %s\n", bug_report_url
);
1609 fprintf (stderr
, "ld_file_name = %s\n",
1610 (ld_file_name
? ld_file_name
: "not found"));
1611 fprintf (stderr
, "c_file_name = %s\n",
1612 (c_file_name
? c_file_name
: "not found"));
1613 fprintf (stderr
, "nm_file_name = %s\n",
1614 (nm_file_name
? nm_file_name
: "not found"));
1616 fprintf (stderr
, "ldd_file_name = %s\n",
1617 (ldd_file_name
? ldd_file_name
: "not found"));
1619 fprintf (stderr
, "strip_file_name = %s\n",
1620 (strip_file_name
? strip_file_name
: "not found"));
1621 fprintf (stderr
, "c_file = %s\n",
1622 (c_file
? c_file
: "not found"));
1623 fprintf (stderr
, "o_file = %s\n",
1624 (o_file
? o_file
: "not found"));
1626 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1628 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1630 ptr
= getenv ("COLLECT_GCC");
1632 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1634 ptr
= getenv ("COMPILER_PATH");
1636 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1638 ptr
= getenv (LIBRARY_PATH_ENV
);
1640 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1642 fprintf (stderr
, "\n");
1645 /* Load the program, searching all libraries and attempting to provide
1646 undefined symbols from repository information.
1648 If -r or they will be run via some other method, do not build the
1649 constructor or destructor list, just return now. */
1652 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1654 /* Perform the first pass link now, if we're about to exit or if we need
1655 to scan for things we haven't collected yet before pursuing further.
1657 On AIX, the latter typically includes nothing for shared objects or
1658 frame tables for an executable, out of what the required early scan on
1659 objects and libraries has performed above. In the !shared_obj case, we
1660 expect the relevant tables to be dragged together with their associated
1661 functions from precise cross reference insertions by the compiler. */
1663 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1664 do_tlink (ld1_argv
, object_lst
);
1668 #ifdef COLLECT_EXPORT_LIST
1669 /* Make sure we delete the export file we may have created. */
1670 if (export_file
!= 0 && export_file
[0])
1671 maybe_unlink (export_file
);
1673 if (lto_mode
!= LTO_MODE_NONE
)
1674 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1676 post_ld_pass (false);
1678 maybe_unlink (c_file
);
1679 maybe_unlink (o_file
);
1684 /* Unless we have done it all already, examine the namelist and search for
1685 static constructors and destructors to call. Write the constructor and
1686 destructor tables to a .s file and reload. */
1688 if (ld1_filter
!= SCAN_NOTHING
)
1689 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1691 #ifdef SCAN_LIBRARIES
1692 scan_libraries (output_file
);
1697 notice_translated (ngettext ("%d constructor found\n",
1698 "%d constructors found\n",
1699 constructors
.number
),
1700 constructors
.number
);
1701 notice_translated (ngettext ("%d destructor found\n",
1702 "%d destructors found\n",
1703 destructors
.number
),
1704 destructors
.number
);
1705 notice_translated (ngettext ("%d frame table found\n",
1706 "%d frame tables found\n",
1707 frame_tables
.number
),
1708 frame_tables
.number
);
1711 /* If the scan exposed nothing of special interest, there's no need to
1712 generate the glue code and relink so return now. */
1714 if (constructors
.number
== 0 && destructors
.number
== 0
1715 && frame_tables
.number
== 0
1716 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1717 /* If we will be running these functions ourselves, we want to emit
1718 stubs into the shared library so that we do not have to relink
1719 dependent programs when we add static objects. */
1724 /* Do tlink without additional code generation now if we didn't
1725 do it earlier for scanning purposes. */
1726 if (ld1_filter
== SCAN_NOTHING
)
1727 do_tlink (ld1_argv
, object_lst
);
1730 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1732 /* Strip now if it was requested on the command line. */
1735 char **real_strip_argv
= XCNEWVEC (char *, 3);
1736 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1739 strip_argv
[0] = strip_file_name
;
1740 strip_argv
[1] = output_file
;
1741 strip_argv
[2] = (char *) 0;
1742 fork_execute ("strip", real_strip_argv
);
1745 #ifdef COLLECT_EXPORT_LIST
1746 maybe_unlink (export_file
);
1748 post_ld_pass (false);
1750 maybe_unlink (c_file
);
1751 maybe_unlink (o_file
);
1755 /* Sort ctor and dtor lists by priority. */
1756 sort_ids (&constructors
);
1757 sort_ids (&destructors
);
1759 maybe_unlink (output_file
);
1760 outf
= fopen (c_file
, "w");
1761 if (outf
== (FILE *) 0)
1762 fatal_error ("fopen %s: %m", c_file
);
1764 write_c_file (outf
, c_file
);
1767 fatal_error ("fclose %s: %m", c_file
);
1769 /* Tell the linker that we have initializer and finalizer functions. */
1770 #ifdef LD_INIT_SWITCH
1771 #ifdef COLLECT_EXPORT_LIST
1772 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1774 *ld2
++ = LD_INIT_SWITCH
;
1776 *ld2
++ = LD_FINI_SWITCH
;
1781 #ifdef COLLECT_EXPORT_LIST
1784 /* If we did not add export flag to link arguments before, add it to
1785 second link phase now. No new exports should have been added. */
1786 if (! exports
.first
)
1787 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1789 #ifdef TARGET_AIX_VERSION
1790 add_to_list (&exports
, aix_shared_initname
);
1791 add_to_list (&exports
, aix_shared_fininame
);
1794 #ifndef LD_INIT_SWITCH
1795 add_to_list (&exports
, initname
);
1796 add_to_list (&exports
, fininame
);
1797 add_to_list (&exports
, "_GLOBAL__DI");
1798 add_to_list (&exports
, "_GLOBAL__DD");
1800 exportf
= fopen (export_file
, "w");
1801 if (exportf
== (FILE *) 0)
1802 fatal_error ("fopen %s: %m", export_file
);
1803 write_aix_file (exportf
, exports
.first
);
1804 if (fclose (exportf
))
1805 fatal_error ("fclose %s: %m", export_file
);
1809 /* End of arguments to second link phase. */
1814 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1815 output_file
, c_file
);
1816 write_c_file (stderr
, "stderr");
1817 fprintf (stderr
, "========== end of c_file\n\n");
1818 #ifdef COLLECT_EXPORT_LIST
1819 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1820 write_aix_file (stderr
, exports
.first
);
1821 fprintf (stderr
, "========== end of export_file\n\n");
1825 /* Assemble the constructor and destructor tables.
1826 Link the tables in with the rest of the program. */
1828 fork_execute ("gcc", c_argv
);
1829 #ifdef COLLECT_EXPORT_LIST
1830 /* On AIX we must call tlink because of possible templates resolution. */
1831 do_tlink (ld2_argv
, object_lst
);
1834 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1836 /* Otherwise, simply call ld because tlink is already done. */
1838 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1841 fork_execute ("ld", ld2_argv
);
1842 post_ld_pass (false);
1845 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1846 constructors/destructors in shared libraries. */
1847 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1850 maybe_unlink (c_file
);
1851 maybe_unlink (o_file
);
1853 #ifdef COLLECT_EXPORT_LIST
1854 maybe_unlink (export_file
);
1861 /* Wait for a process to finish, and exit if a nonzero status is found. */
1864 collect_wait (const char *prog
, struct pex_obj
*pex
)
1868 if (!pex_get_status (pex
, 1, &status
))
1869 fatal_error ("can't get program status: %m");
1874 if (WIFSIGNALED (status
))
1876 int sig
= WTERMSIG (status
);
1877 error ("%s terminated with signal %d [%s]%s",
1878 prog
, sig
, strsignal (sig
),
1879 WCOREDUMP (status
) ? ", core dumped" : "");
1880 exit (FATAL_EXIT_CODE
);
1883 if (WIFEXITED (status
))
1884 return WEXITSTATUS (status
);
1890 do_wait (const char *prog
, struct pex_obj
*pex
)
1892 int ret
= collect_wait (prog
, pex
);
1895 error ("%s returned %d exit status", prog
, ret
);
1901 unlink (response_file
);
1902 response_file
= NULL
;
1907 /* Execute a program, and wait for the reply. */
1910 collect_execute (const char *prog
, char **argv
, const char *outname
,
1911 const char *errname
, int flags
)
1913 struct pex_obj
*pex
;
1916 char *response_arg
= NULL
;
1917 char *response_argv
[3] ATTRIBUTE_UNUSED
;
1919 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
1921 /* If using @file arguments, create a temporary file and put the
1922 contents of argv into it. Then change argv to an array corresponding
1923 to a single argument @FILE, where FILE is the temporary filename. */
1925 char **current_argv
= argv
+ 1;
1926 char *argv0
= argv
[0];
1930 /* Note: we assume argv contains at least one element; this is
1933 response_file
= make_temp_file ("");
1935 f
= fopen (response_file
, "w");
1938 fatal_error ("could not open response file %s", response_file
);
1940 status
= writeargv (current_argv
, f
);
1943 fatal_error ("could not write to response file %s", response_file
);
1945 status
= fclose (f
);
1948 fatal_error ("could not close response file %s", response_file
);
1950 response_arg
= concat ("@", response_file
, NULL
);
1951 response_argv
[0] = argv0
;
1952 response_argv
[1] = response_arg
;
1953 response_argv
[2] = NULL
;
1955 argv
= response_argv
;
1964 fprintf (stderr
, "%s", argv
[0]);
1966 notice ("[cannot find %s]", prog
);
1968 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
1969 fprintf (stderr
, " %s", str
);
1971 fprintf (stderr
, "\n");
1977 /* If we cannot find a program we need, complain error. Do this here
1978 since we might not end up needing something that we could not find. */
1981 fatal_error ("cannot find '%s'", prog
);
1983 pex
= pex_init (0, "collect2", NULL
);
1985 fatal_error ("pex_init failed: %m");
1987 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
1994 fatal_error ("%s: %m", _(errmsg
));
1997 fatal_error (errmsg
);
2000 free (response_arg
);
2006 fork_execute (const char *prog
, char **argv
)
2008 struct pex_obj
*pex
;
2010 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
2011 do_wait (prog
, pex
);
2014 /* Unlink FILE unless we are debugging or this is the output_file
2015 and we may not unlink it. */
2018 maybe_unlink (const char *file
)
2022 notice ("[Leaving %s]\n", file
);
2026 if (file
== output_file
&& !may_unlink_output_file
)
2029 unlink_if_ordinary (file
);
2032 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2035 maybe_unlink_list (char **file_list
)
2037 char **tmp
= file_list
;
2040 maybe_unlink (*(tmp
++));
2044 static long sequence_number
= 0;
2046 /* Add a name to a linked list. */
2049 add_to_list (struct head
*head_ptr
, const char *name
)
2052 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2054 strcpy (newid
->name
, name
);
2056 if (head_ptr
->first
)
2057 head_ptr
->last
->next
= newid
;
2059 head_ptr
->first
= newid
;
2061 /* Check for duplicate symbols. */
2062 for (p
= head_ptr
->first
;
2063 strcmp (name
, p
->name
) != 0;
2068 head_ptr
->last
->next
= 0;
2073 newid
->sequence
= ++sequence_number
;
2074 head_ptr
->last
= newid
;
2078 /* Grab the init priority number from an init function name that
2079 looks like "_GLOBAL_.I.12345.foo". */
2082 extract_init_priority (const char *name
)
2086 #ifdef TARGET_AIX_VERSION
2087 /* Run dependent module initializers before any constructors in this
2089 switch (is_ctor_dtor (name
))
2099 while (name
[pos
] == '_')
2101 pos
+= 10; /* strlen ("GLOBAL__X_") */
2103 /* Extract init_p number from ctor/dtor name. */
2104 pri
= atoi (name
+ pos
);
2105 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2108 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2109 ctors will be run from right to left, dtors from left to right. */
2112 sort_ids (struct head
*head_ptr
)
2114 /* id holds the current element to insert. id_next holds the next
2115 element to insert. id_ptr iterates through the already sorted elements
2116 looking for the place to insert id. */
2117 struct id
*id
, *id_next
, **id_ptr
;
2119 id
= head_ptr
->first
;
2121 /* We don't have any sorted elements yet. */
2122 head_ptr
->first
= NULL
;
2124 for (; id
; id
= id_next
)
2127 id
->sequence
= extract_init_priority (id
->name
);
2129 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2131 /* If the sequence numbers are the same, we put the id from the
2132 file later on the command line later in the list. */
2133 || id
->sequence
> (*id_ptr
)->sequence
2134 /* Hack: do lexical compare, too.
2135 || (id->sequence == (*id_ptr)->sequence
2136 && strcmp (id->name, (*id_ptr)->name) > 0) */
2145 /* Now set the sequence numbers properly so write_c_file works. */
2146 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2147 id
->sequence
= ++sequence_number
;
2150 /* Write: `prefix', the names on list LIST, `suffix'. */
2153 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2157 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2162 #ifdef COLLECT_EXPORT_LIST
2163 /* This function is really used only on AIX, but may be useful. */
2166 is_in_list (const char *prefix
, struct id
*list
)
2170 if (!strcmp (prefix
, list
->name
)) return 1;
2176 #endif /* COLLECT_EXPORT_LIST */
2178 /* Added for debugging purpose. */
2179 #ifdef COLLECT_EXPORT_LIST
2181 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2185 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2193 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2197 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2204 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2208 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2209 prefix
, list
->sequence
, list
->name
);
2214 /* Write out the constructor and destructor tables statically (for a shared
2215 object), along with the functions to execute them. */
2218 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2222 int frames
= (frame_tables
.number
> 0);
2224 /* Figure out name of output_file, stripping off .so version. */
2225 q
= p
= lbasename (output_file
);
2237 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2239 q
+= strlen (SHLIB_SUFFIX
);
2246 /* q points to null at end of the string (or . of the .so version) */
2247 prefix
= XNEWVEC (char, q
- p
+ 1);
2248 strncpy (prefix
, p
, q
- p
);
2250 for (r
= prefix
; *r
; r
++)
2251 if (!ISALNUM ((unsigned char)*r
))
2254 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2255 output_file
, prefix
);
2257 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2258 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2259 #ifdef TARGET_AIX_VERSION
2260 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2261 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2266 /* Write the tables as C code. */
2268 /* This count variable is used to prevent multiple calls to the
2269 constructors/destructors.
2270 This guard against multiple calls is important on AIX as the initfini
2271 functions are deliberately invoked multiple times as part of the
2272 mechanisms GCC uses to order constructors across different dependent
2273 shared libraries (see config/rs6000/aix.h).
2275 fprintf (stream
, "static int count;\n");
2276 fprintf (stream
, "typedef void entry_pt();\n");
2277 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2281 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2283 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2284 write_list (stream
, "\t\t&", frame_tables
.first
);
2285 fprintf (stream
, "\t0\n};\n");
2287 /* This must match what's in frame.h. */
2288 fprintf (stream
, "struct object {\n");
2289 fprintf (stream
, " void *pc_begin;\n");
2290 fprintf (stream
, " void *pc_end;\n");
2291 fprintf (stream
, " void *fde_begin;\n");
2292 fprintf (stream
, " void *fde_array;\n");
2293 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2294 fprintf (stream
, " struct object *next;\n");
2295 fprintf (stream
, "};\n");
2297 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2298 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2300 fprintf (stream
, "static void reg_frame () {\n");
2301 fprintf (stream
, "\tstatic struct object ob;\n");
2302 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2303 fprintf (stream
, "\t}\n");
2305 fprintf (stream
, "static void dereg_frame () {\n");
2306 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2307 fprintf (stream
, "\t}\n");
2310 fprintf (stream
, "void %s() {\n", initname
);
2311 if (constructors
.number
> 0 || frames
)
2313 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2314 write_list (stream
, "\t\t", constructors
.first
);
2316 fprintf (stream
, "\treg_frame,\n");
2317 fprintf (stream
, "\t};\n");
2318 fprintf (stream
, "\tentry_pt **p;\n");
2319 fprintf (stream
, "\tif (count++ != 0) return;\n");
2320 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2321 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2324 fprintf (stream
, "\t++count;\n");
2325 fprintf (stream
, "}\n");
2326 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2327 fprintf (stream
, "void %s() {\n", fininame
);
2328 if (destructors
.number
> 0 || frames
)
2330 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2331 write_list (stream
, "\t\t", destructors
.first
);
2333 fprintf (stream
, "\tdereg_frame,\n");
2334 fprintf (stream
, "\t};\n");
2335 fprintf (stream
, "\tentry_pt **p;\n");
2336 fprintf (stream
, "\tif (--count != 0) return;\n");
2337 fprintf (stream
, "\tp = dtors;\n");
2338 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2339 destructors
.number
+ frames
);
2341 fprintf (stream
, "}\n");
2345 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2346 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2350 /* Write the constructor/destructor tables. */
2352 #ifndef LD_INIT_SWITCH
2354 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2356 /* Write the tables as C code. */
2358 int frames
= (frame_tables
.number
> 0);
2360 fprintf (stream
, "typedef void entry_pt();\n\n");
2362 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2366 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2368 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2369 write_list (stream
, "\t\t&", frame_tables
.first
);
2370 fprintf (stream
, "\t0\n};\n");
2372 /* This must match what's in frame.h. */
2373 fprintf (stream
, "struct object {\n");
2374 fprintf (stream
, " void *pc_begin;\n");
2375 fprintf (stream
, " void *pc_end;\n");
2376 fprintf (stream
, " void *fde_begin;\n");
2377 fprintf (stream
, " void *fde_array;\n");
2378 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2379 fprintf (stream
, " struct object *next;\n");
2380 fprintf (stream
, "};\n");
2382 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2383 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2385 fprintf (stream
, "static void reg_frame () {\n");
2386 fprintf (stream
, "\tstatic struct object ob;\n");
2387 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2388 fprintf (stream
, "\t}\n");
2390 fprintf (stream
, "static void dereg_frame () {\n");
2391 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2392 fprintf (stream
, "\t}\n");
2395 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2396 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2397 write_list (stream
, "\t", constructors
.first
);
2399 fprintf (stream
, "\treg_frame,\n");
2400 fprintf (stream
, "\t0\n};\n\n");
2402 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2404 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2405 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2406 write_list (stream
, "\t", destructors
.first
);
2408 fprintf (stream
, "\tdereg_frame,\n");
2409 fprintf (stream
, "\t0\n};\n\n");
2411 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2412 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2414 #endif /* ! LD_INIT_SWITCH */
2417 write_c_file (FILE *stream
, const char *name
)
2419 #ifndef LD_INIT_SWITCH
2421 write_c_file_glob (stream
, name
);
2424 write_c_file_stat (stream
, name
);
2427 #ifdef COLLECT_EXPORT_LIST
2429 write_aix_file (FILE *stream
, struct id
*list
)
2431 for (; list
; list
= list
->next
)
2433 fputs (list
->name
, stream
);
2434 putc ('\n', stream
);
2439 #ifdef OBJECT_FORMAT_NONE
2441 /* Check to make sure the file is an LTO object file. */
2444 maybe_lto_object_file (const char *prog_name
)
2447 unsigned char buf
[4];
2450 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2451 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2452 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2453 static unsigned char machomagic
[4][4] = {
2454 { 0xcf, 0xfa, 0xed, 0xfe },
2455 { 0xce, 0xfa, 0xed, 0xfe },
2456 { 0xfe, 0xed, 0xfa, 0xcf },
2457 { 0xfe, 0xed, 0xfa, 0xce }
2460 f
= fopen (prog_name
, "rb");
2463 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2467 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2468 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2469 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2471 for (i
= 0; i
< 4; i
++)
2472 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2478 /* Generic version to scan the name list of the loaded program for
2479 the symbols g++ uses for static constructors and destructors. */
2482 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2485 void (*int_handler
) (int);
2487 void (*quit_handler
) (int);
2489 char *real_nm_argv
[4];
2490 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2492 struct pex_obj
*pex
;
2499 if (which_pass
== PASS_SECOND
)
2502 /* LTO objects must be in a known format. This check prevents
2503 us from accepting an archive containing LTO objects, which
2504 gcc cannot currently handle. */
2505 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2508 /* If we do not have an `nm', complain. */
2509 if (nm_file_name
== 0)
2510 fatal_error ("cannot find 'nm'");
2512 nm_argv
[argc
++] = nm_file_name
;
2513 if (NM_FLAGS
[0] != '\0')
2514 nm_argv
[argc
++] = NM_FLAGS
;
2516 nm_argv
[argc
++] = prog_name
;
2517 nm_argv
[argc
++] = (char *) 0;
2519 /* Trace if needed. */
2522 const char **p_argv
;
2525 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2526 fprintf (stderr
, " %s", str
);
2528 fprintf (stderr
, "\n");
2534 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2536 fatal_error ("pex_init failed: %m");
2538 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2545 fatal_error ("%s: %m", _(errmsg
));
2548 fatal_error (errmsg
);
2551 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2553 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2556 inf
= pex_read_output (pex
, 0);
2558 fatal_error ("can't open nm output: %m");
2562 if (which_pass
== PASS_LTOINFO
)
2563 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2565 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2568 /* Read each line of nm output. */
2569 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2575 fprintf (stderr
, "\t%s\n", buf
);
2577 if (which_pass
== PASS_LTOINFO
)
2582 /* Look for the LTO info marker symbol, and add filename to
2583 the LTO objects list if found. */
2584 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2585 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2586 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2587 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2589 add_lto_object (<o_objects
, prog_name
);
2591 /* We need to read all the input, so we can't just
2592 return here. But we can avoid useless work. */
2601 /* If it contains a constructor or destructor name, add the name
2602 to the appropriate list unless this is a kind of symbol we're
2603 not supposed to even consider. */
2605 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2606 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2613 /* Find the end of the symbol name.
2614 Do not include `|', because Encore nm can tack that on the end. */
2615 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2622 switch (is_ctor_dtor (name
))
2625 if (! (filter
& SCAN_CTOR
))
2627 if (which_pass
!= PASS_LIB
)
2628 add_to_list (&constructors
, name
);
2632 if (! (filter
& SCAN_DTOR
))
2634 if (which_pass
!= PASS_LIB
)
2635 add_to_list (&destructors
, name
);
2639 if (! (filter
& SCAN_INIT
))
2641 if (which_pass
!= PASS_LIB
)
2642 fatal_error ("init function found in object %s", prog_name
);
2643 #ifndef LD_INIT_SWITCH
2644 add_to_list (&constructors
, name
);
2649 if (! (filter
& SCAN_FINI
))
2651 if (which_pass
!= PASS_LIB
)
2652 fatal_error ("fini function found in object %s", prog_name
);
2653 #ifndef LD_FINI_SWITCH
2654 add_to_list (&destructors
, name
);
2659 if (! (filter
& SCAN_DWEH
))
2661 if (which_pass
!= PASS_LIB
)
2662 add_to_list (&frame_tables
, name
);
2665 default: /* not a constructor or destructor */
2671 fprintf (stderr
, "\n");
2673 do_wait (nm_file_name
, pex
);
2675 signal (SIGINT
, int_handler
);
2677 signal (SIGQUIT
, quit_handler
);
2683 /* Use the List Dynamic Dependencies program to find shared libraries that
2684 the output file depends upon and their initialization/finalization
2685 routines, if any. */
2688 scan_libraries (const char *prog_name
)
2690 static struct head libraries
; /* list of shared libraries found */
2692 void (*int_handler
) (int);
2694 void (*quit_handler
) (int);
2696 char *real_ldd_argv
[4];
2697 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2699 struct pex_obj
*pex
;
2705 /* If we do not have an `ldd', complain. */
2706 if (ldd_file_name
== 0)
2708 error ("cannot find 'ldd'");
2712 ldd_argv
[argc
++] = ldd_file_name
;
2713 ldd_argv
[argc
++] = prog_name
;
2714 ldd_argv
[argc
++] = (char *) 0;
2716 /* Trace if needed. */
2719 const char **p_argv
;
2722 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2723 fprintf (stderr
, " %s", str
);
2725 fprintf (stderr
, "\n");
2731 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2733 fatal_error ("pex_init failed: %m");
2735 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2741 fatal_error ("%s: %m", _(errmsg
));
2744 fatal_error (errmsg
);
2747 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2749 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2752 inf
= pex_read_output (pex
, 0);
2754 fatal_error ("can't open ldd output: %m");
2757 notice ("\nldd output with constructors/destructors.\n");
2759 /* Read each line of ldd output. */
2760 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2763 char *name
, *end
, *p
= buf
;
2765 /* Extract names of libraries and add to list. */
2766 PARSE_LDD_OUTPUT (p
);
2771 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2772 fatal_error ("dynamic dependency %s not found", buf
);
2774 /* Find the end of the symbol name. */
2776 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2781 if (access (name
, R_OK
) == 0)
2782 add_to_list (&libraries
, name
);
2784 fatal_error ("unable to open dynamic dependency '%s'", buf
);
2787 fprintf (stderr
, "\t%s\n", buf
);
2790 fprintf (stderr
, "\n");
2792 do_wait (ldd_file_name
, pex
);
2794 signal (SIGINT
, int_handler
);
2796 signal (SIGQUIT
, quit_handler
);
2799 /* Now iterate through the library list adding their symbols to
2801 for (list
= libraries
.first
; list
; list
= list
->next
)
2802 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2805 #endif /* LDD_SUFFIX */
2807 #endif /* OBJECT_FORMAT_NONE */
2811 * COFF specific stuff.
2814 #ifdef OBJECT_FORMAT_COFF
2816 #if defined (EXTENDED_COFF)
2818 # define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax)
2819 # define GCC_SYMENT SYMR
2820 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2821 # define GCC_SYMINC(X) (1)
2822 # define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
2823 # define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
2827 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2828 # define GCC_SYMENT SYMENT
2829 # if defined (C_WEAKEXT)
2830 # define GCC_OK_SYMBOL(X) \
2831 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2832 ((X).n_scnum > N_UNDEF) && \
2834 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2835 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2836 # define GCC_UNDEF_SYMBOL(X) \
2837 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2838 ((X).n_scnum == N_UNDEF))
2840 # define GCC_OK_SYMBOL(X) \
2841 (((X).n_sclass == C_EXT) && \
2842 ((X).n_scnum > N_UNDEF) && \
2844 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2845 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2846 # define GCC_UNDEF_SYMBOL(X) \
2847 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2849 # define GCC_SYMINC(X) ((X).n_numaux+1)
2850 # define GCC_SYMZERO(X) 0
2852 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2853 #if TARGET_AIX_VERSION >= 51
2854 # define GCC_CHECK_HDR(X) \
2855 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2856 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2857 && !(HEADER (X).f_flags & F_LOADONLY))
2859 # define GCC_CHECK_HDR(X) \
2860 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2861 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2862 && !(HEADER (X).f_flags & F_LOADONLY))
2867 #ifdef COLLECT_EXPORT_LIST
2868 /* Array of standard AIX libraries which should not
2869 be scanned for ctors/dtors. */
2870 static const char *const aix_std_libs
[] = {
2878 "/usr/lib/libc_r.a",
2879 "/usr/lib/libm_r.a",
2880 "/usr/lib/threads/libc.a",
2881 "/usr/ccs/lib/libc.a",
2882 "/usr/ccs/lib/libm.a",
2883 "/usr/ccs/lib/libc_r.a",
2884 "/usr/ccs/lib/libm_r.a",
2888 /* This function checks the filename and returns 1
2889 if this name matches the location of a standard AIX library. */
2890 static int ignore_library (const char *);
2892 ignore_library (const char *name
)
2894 const char *const *p
;
2897 if (target_system_root
[0] != '\0')
2899 length
= strlen (target_system_root
);
2900 if (strncmp (name
, target_system_root
, length
) != 0)
2904 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2905 if (strcmp (name
, *p
) == 0)
2909 #endif /* COLLECT_EXPORT_LIST */
2911 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2912 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2915 /* COFF version to scan the name list of the loaded program for
2916 the symbols g++ uses for static constructors and destructors. */
2919 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2922 LDFILE
*ldptr
= NULL
;
2923 int sym_index
, sym_count
;
2926 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2929 #ifdef COLLECT_EXPORT_LIST
2930 /* We do not need scanning for some standard C libraries. */
2931 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2934 /* On AIX we have a loop, because there is not much difference
2935 between an object and an archive. This trick allows us to
2936 eliminate scan_libraries() function. */
2940 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2941 non-const char * filename parameter, even though it will not
2942 modify that string. So we must cast away const-ness here,
2943 using CONST_CAST to prevent complaints from -Wcast-qual. */
2944 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2946 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2947 fatal_error ("%s: not a COFF file", prog_name
);
2949 if (GCC_CHECK_HDR (ldptr
))
2951 sym_count
= GCC_SYMBOLS (ldptr
);
2952 sym_index
= GCC_SYMZERO (ldptr
);
2954 #ifdef COLLECT_EXPORT_LIST
2955 /* Is current archive member a shared object? */
2956 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2959 while (sym_index
< sym_count
)
2963 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2965 sym_index
+= GCC_SYMINC (symbol
);
2967 if (GCC_OK_SYMBOL (symbol
))
2971 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2972 continue; /* Should never happen. */
2974 #ifdef XCOFF_DEBUGGING_INFO
2975 /* All AIX function names have a duplicate entry
2976 beginning with a dot. */
2981 switch (is_ctor_dtor (name
))
2983 #if TARGET_AIX_VERSION
2984 /* Add AIX shared library initalisers/finalisers
2985 to the constructors/destructors list of the
2988 if (! (filter
& SCAN_CTOR
))
2990 if (is_shared
&& !aixlazy_flag
)
2991 add_to_list (&constructors
, name
);
2995 if (! (filter
& SCAN_DTOR
))
2997 if (is_shared
&& !aixlazy_flag
)
2998 add_to_list (&destructors
, name
);
3003 if (! (filter
& SCAN_CTOR
))
3006 add_to_list (&constructors
, name
);
3007 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3008 if (which_pass
== PASS_OBJ
)
3009 add_to_list (&exports
, name
);
3014 if (! (filter
& SCAN_DTOR
))
3017 add_to_list (&destructors
, name
);
3018 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3019 if (which_pass
== PASS_OBJ
)
3020 add_to_list (&exports
, name
);
3024 #ifdef COLLECT_EXPORT_LIST
3026 if (! (filter
& SCAN_INIT
))
3028 #ifndef LD_INIT_SWITCH
3030 add_to_list (&constructors
, name
);
3035 if (! (filter
& SCAN_FINI
))
3037 #ifndef LD_INIT_SWITCH
3039 add_to_list (&destructors
, name
);
3045 if (! (filter
& SCAN_DWEH
))
3048 add_to_list (&frame_tables
, name
);
3049 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3050 if (which_pass
== PASS_OBJ
)
3051 add_to_list (&exports
, name
);
3055 default: /* not a constructor or destructor */
3056 #ifdef COLLECT_EXPORT_LIST
3057 /* Explicitly export all global symbols when
3058 building a shared object on AIX, but do not
3059 re-export symbols from another shared object
3060 and do not export symbols if the user
3061 provides an explicit export list. */
3062 if (shared_obj
&& !is_shared
3063 && which_pass
== PASS_OBJ
&& !export_flag
)
3064 add_to_list (&exports
, name
);
3070 #if !defined(EXTENDED_COFF)
3071 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3072 symbol
.n_scnum
, symbol
.n_sclass
,
3073 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3077 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3078 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3083 #ifdef COLLECT_EXPORT_LIST
3086 /* If archive contains both 32-bit and 64-bit objects,
3087 we want to skip objects in other mode so mismatch normal. */
3089 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3090 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3096 fatal_error ("%s: cannot open as COFF file", prog_name
);
3098 #ifdef COLLECT_EXPORT_LIST
3099 /* On AIX loop continues while there are more members in archive. */
3101 while (ldclose (ldptr
) == FAILURE
);
3103 /* Otherwise we simply close ldptr. */
3104 (void) ldclose (ldptr
);
3107 #endif /* OBJECT_FORMAT_COFF */
3109 #ifdef COLLECT_EXPORT_LIST
3110 /* Given a library name without "lib" prefix, this function
3111 returns a full library name including a path. */
3113 resolve_lib_name (const char *name
)
3117 /* Library extensions for AIX dynamic linking. */
3118 const char * const libexts
[2] = {"a", "so"};
3120 for (i
= 0; libpaths
[i
]; i
++)
3121 if (libpaths
[i
]->max_len
> l
)
3122 l
= libpaths
[i
]->max_len
;
3124 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
3126 for (i
= 0; libpaths
[i
]; i
++)
3128 struct prefix_list
*list
= libpaths
[i
]->plist
;
3129 for (; list
; list
= list
->next
)
3131 /* The following lines are needed because path_prefix list
3132 may contain directories both with trailing DIR_SEPARATOR and
3135 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
3137 for (j
= 0; j
< 2; j
++)
3139 sprintf (lib_buf
, "%s%slib%s.%s",
3140 list
->prefix
, p
, name
,
3141 libexts
[(j
+ aixrtl_flag
) % 2]);
3142 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3143 if (file_exists (lib_buf
))
3145 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3152 fprintf (stderr
, "not found\n");
3154 fatal_error ("library lib%s not found", name
);
3157 #endif /* COLLECT_EXPORT_LIST */
3159 #ifdef COLLECT_RUN_DSYMUTIL
3160 static int flag_dsym
= false;
3161 static int flag_idsym
= false;
3164 process_args (int *argcp
, char **argv
) {
3167 for (i
=0; i
<argc
; ++i
)
3169 if (strcmp (argv
[i
], "-dsym") == 0)
3172 /* Remove the flag, as we handle all processing for it. */
3175 argv
[j
] = argv
[j
+1];
3180 else if (strcmp (argv
[i
], "-idsym") == 0)
3183 /* Remove the flag, as we handle all processing for it. */
3186 argv
[j
] = argv
[j
+1];
3195 do_dsymutil (const char *output_file
) {
3196 const char *dsymutil
= DSYMUTIL
+ 1;
3197 struct pex_obj
*pex
;
3198 char **real_argv
= XCNEWVEC (char *, 3);
3199 const char ** argv
= CONST_CAST2 (const char **, char **,
3203 argv
[1] = output_file
;
3204 argv
[2] = (char *) 0;
3206 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
3207 do_wait (dsymutil
, pex
);
3211 post_ld_pass (bool temp_file
) {
3212 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3215 do_dsymutil (output_file
);
3219 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3220 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }