1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2019 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"
33 #include "simple-object.h"
34 #include "lto-section-names.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 "collect-utils.h"
49 #include "diagnostic.h"
55 /* On certain systems, we have code that works by scanning the object file
56 directly. But this code uses system-specific header files and library
57 functions, so turn it off in a cross-compiler. Likewise, the names of
58 the utilities are not correct for a cross-compiler; we have to hope that
59 cross-versions are in the proper directories. */
61 #ifdef CROSS_DIRECTORY_STRUCTURE
62 #ifndef CROSS_AIX_SUPPORT
63 #undef OBJECT_FORMAT_COFF
66 #undef REAL_LD_FILE_NAME
67 #undef REAL_NM_FILE_NAME
68 #undef REAL_STRIP_FILE_NAME
71 /* If we cannot use a special method, use the ordinary one:
72 run nm to find what symbols are present.
73 In a cross-compiler, this means you need a cross nm,
74 but that is not quite as unpleasant as special headers. */
76 #if !defined (OBJECT_FORMAT_COFF)
77 #define OBJECT_FORMAT_NONE
80 #ifdef OBJECT_FORMAT_COFF
82 #ifndef CROSS_DIRECTORY_STRUCTURE
90 /* Many versions of ldfcn.h define these. */
99 /* Some systems have an ISCOFF macro, but others do not. In some cases
100 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
101 that either do not have an ISCOFF macro in /usr/include or for those
102 where it is wrong. */
105 #define MY_ISCOFF(X) ISCOFF (X)
108 #endif /* OBJECT_FORMAT_COFF */
110 #ifdef OBJECT_FORMAT_NONE
112 /* Default flags to pass to nm. */
114 #define NM_FLAGS "-n"
117 #endif /* OBJECT_FORMAT_NONE */
119 /* Some systems use __main in a way incompatible with its use in gcc, in these
120 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
121 give the same symbol without quotes for an alternative entry point. */
123 #define NAME__MAIN "__main"
126 /* This must match tree.h. */
127 #define DEFAULT_INIT_PRIORITY 65535
129 #ifndef COLLECT_SHARED_INIT_FUNC
130 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
133 #ifndef COLLECT_SHARED_FINI_FUNC
134 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
135 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
139 #define SCAN_LIBRARIES
143 #define SHLIB_SUFFIX ".so"
147 int do_collecting
= 1;
149 int do_collecting
= 0;
152 /* Cook up an always defined indication of whether we proceed the
153 "EXPORT_LIST" way. */
155 #ifdef COLLECT_EXPORT_LIST
156 #define DO_COLLECT_EXPORT_LIST 1
158 #define DO_COLLECT_EXPORT_LIST 0
161 /* Nonzero if we should suppress the automatic demangling of identifiers
162 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
165 /* Linked lists of constructor and destructor names. */
181 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 */
187 static int aixlazy_flag
; /* true if -blazy */
191 LTO_MODE_NONE
, /* Not doing LTO. */
192 LTO_MODE_LTO
, /* Normal LTO. */
193 LTO_MODE_WHOPR
/* WHOPR. */
196 /* Current LTO mode. */
198 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
200 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
203 bool helpflag
; /* true if --help */
205 static int shared_obj
; /* true if -shared */
206 static int static_obj
; /* true if -static */
208 static char *c_file
; /* <xxx>.c for constructor/destructor list. */
209 static char *o_file
; /* <xxx>.o for constructor/destructor list. */
210 #ifdef COLLECT_EXPORT_LIST
211 static const char *export_file
; /* <xxx>.x for AIX export list. */
213 static char **lto_o_files
; /* Output files for LTO. */
214 const char *ldout
; /* File for ld stdout. */
215 const char *lderrout
; /* File for ld stderr. */
216 static const char *output_file
; /* Output file for ld. */
217 static const char *nm_file_name
; /* pathname of nm */
219 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
221 static const char *strip_file_name
; /* pathname of strip */
222 const char *c_file_name
; /* pathname of gcc */
223 static char *initname
, *fininame
; /* names of init and fini funcs */
226 #ifdef TARGET_AIX_VERSION
227 static char *aix_shared_initname
;
228 static char *aix_shared_fininame
; /* init/fini names as per the scheme
229 described in config/rs6000/aix.h */
232 static struct head constructors
; /* list of constructors found */
233 static struct head destructors
; /* list of destructors found */
234 #ifdef COLLECT_EXPORT_LIST
235 static struct head exports
; /* list of exported symbols */
237 static struct head frame_tables
; /* list of frame unwind info tables */
239 bool at_file_supplied
; /* Whether to use @file arguments */
241 struct obstack temporary_obstack
;
242 char * temporary_firstobj
;
244 /* A string that must be prepended to a target OS path in order to find
245 it on the host system. */
246 #ifdef TARGET_SYSTEM_ROOT
247 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
249 static const char *target_system_root
= "";
252 /* Whether we may unlink the output file, which should be set as soon as we
253 know we have successfully produced it. This is typically useful to prevent
254 blindly attempting to unlink a read-only output that the target linker
255 would leave untouched. */
256 bool may_unlink_output_file
= false;
258 #ifdef COLLECT_EXPORT_LIST
259 /* Lists to keep libraries to be scanned for global constructors/destructors. */
260 static struct head libs
; /* list of libraries */
261 static struct head static_libs
; /* list of statically linked libraries */
262 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
263 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
264 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
265 &libpath_lib_dirs
, NULL
};
268 /* List of names of object files containing LTO information.
269 These are a subset of the object file names appearing on the
270 command line, and must be identical, in the sense of pointer
271 equality, with the names passed to maybe_run_lto_and_relink(). */
275 const char *name
; /* Name of object file. */
276 struct lto_object
*next
; /* Next in linked list. */
279 struct lto_object_list
281 struct lto_object
*first
; /* First list element. */
282 struct lto_object
*last
; /* Last list element. */
285 static struct lto_object_list lto_objects
;
287 /* Special kinds of symbols that a name may denote. */
290 SYM_REGULAR
= 0, /* nothing special */
292 SYM_CTOR
= 1, /* constructor */
293 SYM_DTOR
= 2, /* destructor */
294 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
295 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
296 SYM_DWEH
= 5, /* DWARF exception handling table */
301 const char tool_name
[] = "collect2";
303 static symkind
is_ctor_dtor (const char *);
305 static void handler (int);
306 static void maybe_unlink_list (char **);
307 static void add_to_list (struct head
*, const char *);
308 static int extract_init_priority (const char *);
309 static void sort_ids (struct head
*);
310 static void write_list (FILE *, const char *, struct id
*);
311 #ifdef COLLECT_EXPORT_LIST
312 static void dump_list (FILE *, const char *, struct id
*);
315 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
317 static void write_list_with_asm (FILE *, const char *, struct id
*);
318 static void write_c_file (FILE *, const char *);
319 static void write_c_file_stat (FILE *, const char *);
320 #ifndef LD_INIT_SWITCH
321 static void write_c_file_glob (FILE *, const char *);
323 #ifdef SCAN_LIBRARIES
324 static void scan_libraries (const char *);
326 #ifdef COLLECT_EXPORT_LIST
327 static int is_in_list (const char *, struct id
*);
328 static void write_aix_file (FILE *, struct id
*);
329 static char *resolve_lib_name (const char *);
331 static char *extract_string (const char **);
332 static void post_ld_pass (bool);
333 static void process_args (int *argcp
, char **argv
);
335 /* Enumerations describing which pass this is for scanning the
339 PASS_FIRST
, /* without constructors */
340 PASS_OBJ
, /* individual objects */
341 PASS_LIB
, /* looking for shared libraries */
342 PASS_SECOND
, /* with constructors linked in */
343 PASS_LTOINFO
/* looking for objects with LTO info */
346 /* ... and which kinds of symbols are to be considered. */
348 enum scanfilter_masks
{
351 SCAN_CTOR
= 1 << SYM_CTOR
,
352 SCAN_DTOR
= 1 << SYM_DTOR
,
353 SCAN_INIT
= 1 << SYM_INIT
,
354 SCAN_FINI
= 1 << SYM_FINI
,
355 SCAN_DWEH
= 1 << SYM_DWEH
,
356 SCAN_AIXI
= 1 << SYM_AIXI
,
357 SCAN_AIXD
= 1 << SYM_AIXD
,
361 /* This type is used for parameters and variables which hold
362 combinations of the flags in enum scanfilter_masks. */
363 typedef int scanfilter
;
365 /* Scan the name list of the loaded program for the symbols g++ uses for
366 static constructors and destructors.
368 The SCANPASS argument tells which collect processing pass this is for and
369 the SCANFILTER argument tells which kinds of symbols to consider in this
370 pass. Symbols of a special kind not in the filter mask are considered as
373 The constructor table begins at __CTOR_LIST__ and contains a count of the
374 number of pointers (or -1 if the constructors are built in a separate
375 section by the linker), followed by the pointers to the constructor
376 functions, terminated with a null pointer. The destructor table has the
377 same format, and begins at __DTOR_LIST__. */
379 static void scan_prog_file (const char *, scanpass
, scanfilter
);
382 /* Delete tempfiles and exit function. */
385 tool_cleanup (bool from_signal
)
387 if (c_file
!= 0 && c_file
[0])
388 maybe_unlink (c_file
);
390 if (o_file
!= 0 && o_file
[0])
391 maybe_unlink (o_file
);
393 #ifdef COLLECT_EXPORT_LIST
394 if (export_file
!= 0 && export_file
[0])
395 maybe_unlink (export_file
);
399 maybe_unlink_list (lto_o_files
);
401 if (ldout
!= 0 && ldout
[0])
404 dump_ld_file (ldout
, stdout
);
405 maybe_unlink (ldout
);
408 if (lderrout
!= 0 && lderrout
[0])
411 dump_ld_file (lderrout
, stderr
);
412 maybe_unlink (lderrout
);
417 collect_atexit (void)
419 tool_cleanup (false);
427 signal (signo
, SIG_DFL
);
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
);
442 file_exists (const char *name
)
444 return access (name
, R_OK
) == 0;
447 /* Parse a reasonable subset of shell quoting syntax. */
450 extract_string (const char **pp
)
463 obstack_1grow (&temporary_obstack
, c
);
464 else if (! inside
&& c
== ' ')
466 else if (! inside
&& c
== '\\')
471 obstack_1grow (&temporary_obstack
, c
);
474 obstack_1grow (&temporary_obstack
, '\0');
476 return XOBFINISH (&temporary_obstack
, char *);
480 dump_ld_file (const char *name
, FILE *to
)
482 FILE *stream
= fopen (name
, "r");
489 while (c
= getc (stream
),
490 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
491 obstack_1grow (&temporary_obstack
, c
);
492 if (obstack_object_size (&temporary_obstack
) > 0)
494 const char *word
, *p
;
496 obstack_1grow (&temporary_obstack
, '\0');
497 word
= XOBFINISH (&temporary_obstack
, const char *);
500 ++word
, putc ('.', to
);
502 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
503 p
+= strlen (USER_LABEL_PREFIX
);
505 #ifdef HAVE_LD_DEMANGLE
511 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
519 diff
= strlen (word
) - strlen (result
);
520 while (diff
> 0 && c
== ' ')
521 --diff
, putc (' ', to
);
522 if (diff
< 0 && c
== ' ')
524 while (diff
< 0 && c
== ' ')
525 ++diff
, c
= getc (stream
);
528 /* Make sure we output at least one space, or
529 the demangled symbol name will run into
530 whatever text follows. */
541 obstack_free (&temporary_obstack
, temporary_firstobj
);
550 /* Return the kind of symbol denoted by name S. */
553 is_ctor_dtor (const char *s
)
555 struct names
{ const char *const name
; const int len
; symkind ret
;
556 const int two_underscores
; };
558 const struct names
*p
;
560 const char *orig_s
= s
;
562 static const struct names special
[] = {
563 #ifndef NO_DOLLAR_IN_LABEL
564 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
565 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
567 #ifndef NO_DOT_IN_LABEL
568 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
569 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
570 #endif /* NO_DOT_IN_LABEL */
571 #endif /* NO_DOLLAR_IN_LABEL */
572 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
573 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
574 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
575 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
576 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
577 #ifdef TARGET_AIX_VERSION
578 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
579 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
581 { NULL
, 0, SYM_REGULAR
, 0 }
584 while ((ch
= *s
) == '_')
590 for (p
= &special
[0]; p
->len
> 0; p
++)
593 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
594 && strncmp (s
, p
->name
, p
->len
) == 0)
602 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
603 and one from the PATH variable. */
605 static struct path_prefix cpath
, path
;
607 #ifdef CROSS_DIRECTORY_STRUCTURE
608 /* This is the name of the target machine. We use it to form the name
609 of the files to execute. */
611 static const char *const target_machine
= TARGET_MACHINE
;
614 /* Search for NAME using prefix list PPREFIX. We only look for executable
617 Return 0 if not found, otherwise return its name, allocated with malloc. */
619 #if defined (OBJECT_FORMAT_NONE) || defined (OBJECT_FORMAT_COFF)
621 /* Add an entry for the object file NAME to object file list LIST.
622 New entries are added at the end of the list. The original pointer
623 value of NAME is preserved, i.e., no string copy is performed. */
626 add_lto_object (struct lto_object_list
*list
, const char *name
)
628 struct lto_object
*n
= XNEW (struct lto_object
);
633 list
->last
->next
= n
;
642 /* Perform a link-time recompilation and relink if any of the object
643 files contain LTO info. The linker command line LTO_LD_ARGV
644 represents the linker command that would produce a final executable
645 without the use of LTO. OBJECT_LST is a vector of object file names
646 appearing in LTO_LD_ARGV that are to be considered for link-time
647 recompilation, where OBJECT is a pointer to the last valid element.
648 (This awkward convention avoids an impedance mismatch with the
649 usage of similarly-named variables in main().) The elements of
650 OBJECT_LST must be identical, i.e., pointer equal, to the
651 corresponding arguments in LTO_LD_ARGV.
653 Upon entry, at least one linker run has been performed without the
654 use of any LTO info that might be present. Any recompilations
655 necessary for template instantiations have been performed, and
656 initializer/finalizer tables have been created if needed and
657 included in the linker command line LTO_LD_ARGV. If any of the
658 object files contain LTO info, we run the LTO back end on all such
659 files, and perform the final link with the LTO back end output
660 substituted for the LTO-optimized files. In some cases, a final
661 link with all link-time generated code has already been performed,
662 so there is no need to relink if no LTO info is found. In other
663 cases, our caller has not produced the final executable, and is
664 relying on us to perform the required link whether LTO info is
665 present or not. In that case, the FORCE argument should be true.
666 Note that the linker command line argument LTO_LD_ARGV passed into
667 this function may be modified in place. */
670 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
671 const char **object
, bool force
)
673 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
675 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
677 while (object_file
< object
)
679 /* If file contains LTO info, add it to the list of LTO objects. */
680 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
682 /* Increment the argument count by the number of object file arguments
683 we will add. An upper bound suffices, so just count all of the
684 object files regardless of whether they contain LTO info. */
688 if (lto_objects
.first
)
691 const char **lto_c_ptr
;
694 struct lto_object
*list
;
695 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
697 const char *prog
= "lto-wrapper";
698 int lto_ld_argv_size
= 0;
699 char **out_lto_ld_argv
;
700 int out_lto_ld_argv_size
;
704 fatal_error (input_location
, "environment variable "
705 "%<COLLECT_LTO_WRAPPER%> must be set");
709 /* There is at least one object file containing LTO info,
710 so we need to run the LTO back end and relink.
712 To do so we build updated ld arguments with first
713 LTO object replaced by all partitions and other LTO
716 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
717 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
719 *lto_c_ptr
++ = lto_wrapper
;
721 /* Add LTO objects to the wrapper command line. */
722 for (list
= lto_objects
.first
; list
; list
= list
->next
)
723 *lto_c_ptr
++ = list
->name
;
727 /* Run the LTO back end. */
728 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
736 stream
= pex_read_output (pex
, 0);
740 while ((c
= getc (stream
)) != EOF
)
742 obstack_1grow (&temporary_obstack
, c
);
747 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
748 lto_o_files
[num_files
] = NULL
;
749 start
= XOBFINISH (&temporary_obstack
, char *);
750 for (i
= 0; i
< num_files
; ++i
)
757 lto_o_files
[i
] = xstrdup (start
);
762 obstack_free (&temporary_obstack
, temporary_firstobj
);
767 /* Compute memory needed for new LD arguments. At most number of original arguments
768 plus number of partitions. */
769 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
771 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
772 out_lto_ld_argv_size
= 0;
774 /* After running the LTO back end, we will relink, substituting
775 the LTO output for the object files that we submitted to the
776 LTO. Here, we modify the linker command line for the relink. */
778 /* Copy all arguments until we find first LTO file. */
782 for (list
= lto_objects
.first
; list
; list
= list
->next
)
783 if (*p
== list
->name
) /* Note test for pointer equality! */
787 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
790 /* Now insert all LTO partitions. */
791 lto_o_ptr
= lto_o_files
;
793 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
795 /* ... and copy the rest. */
798 for (list
= lto_objects
.first
; list
; list
= list
->next
)
799 if (*p
== list
->name
) /* Note test for pointer equality! */
802 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
805 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
807 /* Run the linker again, this time replacing the object files
808 optimized by the LTO with the temporary file generated by the LTO. */
809 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
810 /* We assume that temp files were created, and therefore we need to take
811 that into account (maybe run dsymutil). */
812 post_ld_pass (/*temp_file*/true);
815 maybe_unlink_list (lto_o_files
);
819 /* Our caller is relying on us to do the link
820 even though there is no LTO back end work to be done. */
821 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
822 /* No LTO objects were found, so no new temp file. */
823 post_ld_pass (/*temp_file*/false);
826 post_ld_pass (false); /* No LTO objects were found, no temp file. */
832 main (int argc
, char **argv
)
842 } selected_linker
= USE_DEFAULT_LD
;
843 static const char *const ld_suffixes
[USE_LD_MAX
] =
851 static const char *const real_ld_suffix
= "real-ld";
852 static const char *const collect_ld_suffix
= "collect-ld";
853 static const char *const nm_suffix
= "nm";
854 static const char *const gnm_suffix
= "gnm";
856 static const char *const ldd_suffix
= LDD_SUFFIX
;
858 static const char *const strip_suffix
= "strip";
859 static const char *const gstrip_suffix
= "gstrip";
861 const char *full_ld_suffixes
[USE_LD_MAX
];
862 #ifdef CROSS_DIRECTORY_STRUCTURE
863 /* If we look for a program in the compiler directories, we just use
864 the short name, since these directories are already system-specific.
865 But it we look for a program in the system directories, we need to
866 qualify the program name with the target machine. */
868 const char *const full_nm_suffix
=
869 concat (target_machine
, "-", nm_suffix
, NULL
);
870 const char *const full_gnm_suffix
=
871 concat (target_machine
, "-", gnm_suffix
, NULL
);
873 const char *const full_ldd_suffix
=
874 concat (target_machine
, "-", ldd_suffix
, NULL
);
876 const char *const full_strip_suffix
=
877 concat (target_machine
, "-", strip_suffix
, NULL
);
878 const char *const full_gstrip_suffix
=
879 concat (target_machine
, "-", gstrip_suffix
, NULL
);
882 const char *const full_ldd_suffix
= ldd_suffix
;
884 const char *const full_nm_suffix
= nm_suffix
;
885 const char *const full_gnm_suffix
= gnm_suffix
;
886 const char *const full_strip_suffix
= strip_suffix
;
887 const char *const full_gstrip_suffix
= gstrip_suffix
;
888 #endif /* CROSS_DIRECTORY_STRUCTURE */
892 #ifdef COLLECT_EXPORT_LIST
895 const char *ld_file_name
;
901 bool use_plugin
= false;
902 bool use_collect_ld
= false;
904 /* The kinds of symbols we will have to consider when scanning the
905 outcome of a first pass link. This is ALL to start with, then might
906 be adjusted before getting to the first pass link per se, typically on
907 AIX where we perform an early scan of objects and libraries to fetch
908 the list of global ctors/dtors and make sure they are not garbage
910 scanfilter ld1_filter
= SCAN_ALL
;
916 #ifdef TARGET_AIX_VERSION
917 int object_nbr
= argc
;
922 #ifdef COLLECT_EXPORT_LIST
923 bool is_static
= false;
927 for (i
= 0; i
< USE_LD_MAX
; i
++)
929 #ifdef CROSS_DIRECTORY_STRUCTURE
930 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
935 p
= argv
[0] + strlen (argv
[0]);
936 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
940 xmalloc_set_program_name (progname
);
943 expandargv (&argc
, &argv
);
944 if (argv
!= old_argv
)
945 at_file_supplied
= 1;
947 process_args (&argc
, argv
);
949 num_c_args
= argc
+ 9;
951 #ifndef HAVE_LD_DEMANGLE
952 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
954 /* Suppress demangling by the real linker, which may be broken. */
955 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
958 #if defined (COLLECT2_HOST_INITIALIZATION)
959 /* Perform system dependent initialization, if necessary. */
960 COLLECT2_HOST_INITIALIZATION
;
964 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
965 receive the signal. A different setting is inheritable */
966 signal (SIGCHLD
, SIG_DFL
);
969 /* Unlock the stdio streams. */
970 unlock_std_streams ();
974 diagnostic_initialize (global_dc
, 0);
976 if (atexit (collect_atexit
) != 0)
977 fatal_error (input_location
, "atexit failed");
979 /* Do not invoke xcalloc before this point, since locale needs to be
980 set first, in case a diagnostic is issued. */
982 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
983 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
984 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
985 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
986 object_lst
= XCNEWVEC (char *, argc
);
987 object
= CONST_CAST2 (const char **, char **, object_lst
);
996 #ifndef DEFAULT_A_OUT_NAME
997 output_file
= "a.out";
999 output_file
= DEFAULT_A_OUT_NAME
;
1002 /* Parse command line / environment for flags we want early.
1003 This allows the debug flag to be set before functions like find_a_file()
1006 bool no_partition
= false;
1008 for (i
= 1; argv
[i
] != NULL
; i
++)
1010 if (! strcmp (argv
[i
], "-debug"))
1012 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1013 lto_mode
= LTO_MODE_NONE
;
1014 else if (! strcmp (argv
[i
], "-plugin"))
1017 if (selected_linker
== USE_DEFAULT_LD
)
1018 selected_linker
= USE_PLUGIN_LD
;
1020 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1021 selected_linker
= USE_BFD_LD
;
1022 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1023 selected_linker
= USE_GOLD_LD
;
1024 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
1025 selected_linker
= USE_LLD_LD
;
1026 else if (strncmp (argv
[i
], "-o", 2) == 0)
1028 /* Parse the output filename if it's given so that we can make
1029 meaningful temp filenames. */
1030 if (argv
[i
][2] == '\0')
1031 output_file
= argv
[i
+1];
1033 output_file
= &argv
[i
][2];
1036 #ifdef COLLECT_EXPORT_LIST
1037 /* These flags are position independent, although their order
1038 is important - subsequent flags override earlier ones. */
1039 else if (strcmp (argv
[i
], "-b64") == 0)
1041 /* -bexport:filename always needs the :filename */
1042 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1043 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1045 else if (strcmp (argv
[i
], "-brtl") == 0
1046 || strcmp (argv
[i
], "-bsvr4") == 0
1047 || strcmp (argv
[i
], "-G") == 0)
1049 else if (strcmp (argv
[i
], "-bnortl") == 0)
1051 else if (strcmp (argv
[i
], "-blazy") == 0)
1056 obstack_begin (&temporary_obstack
, 0);
1057 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1059 #ifndef HAVE_LD_DEMANGLE
1060 current_demangling_style
= auto_demangling
;
1063 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1064 The LTO options are passed here as are other options that might
1065 be unsuitable for ld (e.g. -save-temps). */
1066 p
= getenv ("COLLECT_GCC_OPTIONS");
1069 const char *q
= extract_string (&p
);
1070 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1072 if (strncmp (q
, "-flto-partition=none", 20) == 0)
1073 no_partition
= true;
1074 else if (strncmp (q
, "-fno-lto", 8) == 0)
1075 lto_mode
= LTO_MODE_NONE
;
1076 else if (strncmp (q
, "-save-temps", 11) == 0)
1077 /* FIXME: Honour =obj. */
1080 obstack_free (&temporary_obstack
, temporary_firstobj
);
1082 verbose
= verbose
|| debug
;
1083 save_temps
= save_temps
|| debug
;
1084 find_file_set_debug (debug
);
1086 lto_mode
= LTO_MODE_NONE
;
1087 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1088 lto_mode
= LTO_MODE_LTO
;
1091 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1092 -fno-exceptions -w -fno-whole-program */
1095 c_argv
= XCNEWVEC (char *, num_c_args
);
1096 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1099 fatal_error (input_location
, "no arguments");
1102 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1103 signal (SIGQUIT
, handler
);
1105 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1106 signal (SIGINT
, handler
);
1108 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1109 signal (SIGALRM
, handler
);
1112 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1113 signal (SIGHUP
, handler
);
1115 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1116 signal (SIGSEGV
, handler
);
1118 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1119 signal (SIGBUS
, handler
);
1122 /* Extract COMPILER_PATH and PATH into our prefix list. */
1123 prefix_from_env ("COMPILER_PATH", &cpath
);
1124 prefix_from_env ("PATH", &path
);
1126 /* Try to discover a valid linker/nm/strip to use. */
1128 /* Maybe we know the right file to use (if not cross). */
1130 #ifdef DEFAULT_LINKER
1131 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1132 selected_linker
== USE_LLD_LD
)
1135 # ifdef HOST_EXECUTABLE_SUFFIX
1136 int len
= (sizeof (DEFAULT_LINKER
)
1137 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1141 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1142 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1143 HOST_EXECUTABLE_SUFFIX. */
1144 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1146 default_linker
[len
] = '\0';
1147 linker_name
= concat (default_linker
,
1148 &ld_suffixes
[selected_linker
][2],
1149 HOST_EXECUTABLE_SUFFIX
, NULL
);
1152 if (linker_name
== NULL
)
1154 linker_name
= concat (DEFAULT_LINKER
,
1155 &ld_suffixes
[selected_linker
][2],
1157 if (access (linker_name
, X_OK
) == 0)
1158 ld_file_name
= linker_name
;
1160 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1161 ld_file_name
= DEFAULT_LINKER
;
1162 if (ld_file_name
== 0)
1164 #ifdef REAL_LD_FILE_NAME
1165 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1166 if (ld_file_name
== 0)
1168 /* Search the (target-specific) compiler dirs for ld'. */
1169 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1170 /* Likewise for `collect-ld'. */
1171 if (ld_file_name
== 0)
1173 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1174 use_collect_ld
= ld_file_name
!= 0;
1176 /* Search the compiler directories for `ld'. We have protection against
1177 recursive calls in find_a_file. */
1178 if (ld_file_name
== 0)
1179 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1180 /* Search the ordinary system bin directories
1181 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1182 if (ld_file_name
== 0)
1183 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1185 #ifdef REAL_NM_FILE_NAME
1186 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1187 if (nm_file_name
== 0)
1189 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1190 if (nm_file_name
== 0)
1191 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1192 if (nm_file_name
== 0)
1193 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1194 if (nm_file_name
== 0)
1195 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1198 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1199 if (ldd_file_name
== 0)
1200 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1203 #ifdef REAL_STRIP_FILE_NAME
1204 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1205 if (strip_file_name
== 0)
1207 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1208 if (strip_file_name
== 0)
1209 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1210 if (strip_file_name
== 0)
1211 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1212 if (strip_file_name
== 0)
1213 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1215 /* Determine the full path name of the C compiler to use. */
1216 c_file_name
= getenv ("COLLECT_GCC");
1217 if (c_file_name
== 0)
1219 #ifdef CROSS_DIRECTORY_STRUCTURE
1220 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1222 c_file_name
= "gcc";
1226 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1228 /* Here it should be safe to use the system search path since we should have
1229 already qualified the name of the compiler when it is needed. */
1231 p
= find_a_file (&path
, c_file_name
, X_OK
);
1236 *ld1
++ = *ld2
++ = ld_file_name
;
1238 /* Make temp file names. */
1241 c_file
= (char *) xmalloc (strlen (output_file
)
1242 + sizeof (".cdtor.c") + 1);
1243 strcpy (c_file
, output_file
);
1244 strcat (c_file
, ".cdtor.c");
1245 o_file
= (char *) xmalloc (strlen (output_file
)
1246 + sizeof (".cdtor.o") + 1);
1247 strcpy (o_file
, output_file
);
1248 strcat (o_file
, ".cdtor.o");
1252 c_file
= make_temp_file (".cdtor.c");
1253 o_file
= make_temp_file (".cdtor.o");
1255 #ifdef COLLECT_EXPORT_LIST
1256 export_file
= make_temp_file (".x");
1260 ldout
= make_temp_file (".ld");
1261 lderrout
= make_temp_file (".le");
1263 /* Build the command line to compile the ctor/dtor list. */
1264 *c_ptr
++ = c_file_name
;
1271 #ifdef COLLECT_EXPORT_LIST
1272 /* Generate a list of directories from LIBPATH. */
1273 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1274 /* Add to this list also two standard directories where
1275 AIX loader always searches for libraries. */
1276 add_prefix (&libpath_lib_dirs
, "/lib");
1277 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1280 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1282 AIX support needs to know if -shared has been specified before
1283 parsing commandline arguments. */
1285 p
= getenv ("COLLECT_GCC_OPTIONS");
1288 const char *q
= extract_string (&p
);
1289 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1290 *c_ptr
++ = xstrdup (q
);
1291 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1292 *c_ptr
++ = xstrdup (q
);
1293 if (strcmp (q
, "-shared") == 0)
1295 if (strcmp (q
, "-static") == 0)
1297 if (*q
== '-' && q
[1] == 'B')
1299 *c_ptr
++ = xstrdup (q
);
1302 q
= extract_string (&p
);
1303 *c_ptr
++ = xstrdup (q
);
1307 obstack_free (&temporary_obstack
, temporary_firstobj
);
1308 *c_ptr
++ = "-fno-profile-arcs";
1309 *c_ptr
++ = "-fno-test-coverage";
1310 *c_ptr
++ = "-fno-branch-probabilities";
1311 *c_ptr
++ = "-fno-exceptions";
1313 *c_ptr
++ = "-fno-whole-program";
1315 /* !!! When GCC calls collect2,
1316 it does not know whether it is calling collect2 or ld.
1317 So collect2 cannot meaningfully understand any options
1318 except those ld understands.
1319 If you propose to make GCC pass some other option,
1320 just imagine what will happen if ld is really ld!!! */
1322 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1323 /* After the first file, put in the c++ rt0. */
1325 #ifdef COLLECT_EXPORT_LIST
1326 is_static
= static_obj
;
1329 while ((arg
= *++argv
) != (char *) 0)
1331 *ld1
++ = *ld2
++ = arg
;
1338 if (!strcmp (arg
, "-debug"))
1340 /* Already parsed. */
1344 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1347 *ld1
++ = *ld2
++ = *argv
;
1352 if (strncmp (arg
, "-flto", 5) == 0)
1355 /* Do not pass LTO flag to the linker. */
1359 error ("LTO support has not been enabled in this "
1363 else if (!use_collect_ld
1364 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1366 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1370 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1372 /* Do not pass -fno-lto to the linker. */
1376 #ifdef TARGET_AIX_VERSION
1379 /* File containing a list of input files to process. */
1382 char buf
[MAXPATHLEN
+ 2];
1383 /* Number of additionnal object files. */
1385 /* Maximum of additionnal object files before vector
1388 const char *list_filename
= arg
+ 2;
1390 /* Accept -fFILENAME and -f FILENAME. */
1391 if (*list_filename
== '\0' && argv
[1])
1394 list_filename
= *argv
;
1395 *ld1
++ = *ld2
++ = *argv
;
1398 stream
= fopen (list_filename
, "r");
1400 fatal_error (input_location
, "cannot open %s: %m",
1403 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1405 /* Remove end of line. */
1406 int len
= strlen (buf
);
1407 if (len
>= 1 && buf
[len
- 1] =='\n')
1408 buf
[len
- 1] = '\0';
1410 /* Put on object vector.
1411 Note: we only expanse vector here, so we must keep
1412 extra space for remaining arguments. */
1413 if (add_nbr
>= add_max
)
1416 object
- CONST_CAST2 (const char **, char **,
1418 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1419 object_lst
= XRESIZEVEC (char *, object_lst
,
1420 object_nbr
+ add_max
);
1421 object
= CONST_CAST2 (const char **, char **,
1423 object_nbr
+= add_max
;
1425 *object
++ = xstrdup (buf
);
1433 #ifdef COLLECT_EXPORT_LIST
1435 if (!strcmp (arg
, "-bstatic"))
1439 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1448 /* place o_file BEFORE this argument! */
1454 #ifdef COLLECT_EXPORT_LIST
1456 /* Resolving full library name. */
1457 const char *s
= resolve_lib_name (arg
+2);
1459 /* Saving a full library name. */
1460 add_to_list (&libs
, s
);
1462 add_to_list (&static_libs
, s
);
1467 #ifdef COLLECT_EXPORT_LIST
1468 /* Saving directories where to search for libraries. */
1470 add_prefix (&cmdline_lib_dirs
, arg
+2);
1476 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1478 output_file
= &arg
[2];
1487 if (arg
[2] == '\0' && do_collecting
)
1489 /* We must strip after the nm run, otherwise C++ linking
1490 will not work. Thus we strip in the second ld run, or
1491 else with strip if there is no second ld run. */
1503 if (strcmp (arg
, "--no-demangle") == 0)
1505 #ifndef HAVE_LD_DEMANGLE
1511 else if (strncmp (arg
, "--demangle", 10) == 0)
1513 #ifndef HAVE_LD_DEMANGLE
1517 enum demangling_styles style
1518 = cplus_demangle_name_to_style (arg
+11);
1519 if (style
== unknown_demangling
)
1520 error ("unknown demangling style %qs", arg
+11);
1522 current_demangling_style
= style
;
1528 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1529 target_system_root
= arg
+ 10;
1530 else if (strcmp (arg
, "--version") == 0)
1532 else if (strcmp (arg
, "--help") == 0)
1537 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1538 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1539 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1540 || strcmp (p
, ".obj") == 0))
1549 /* place o_file BEFORE this argument! */
1555 if (p
[1] == 'o' || p
[1] == 'l')
1557 #ifdef COLLECT_EXPORT_LIST
1558 /* libraries can be specified directly, i.e. without -l flag. */
1561 /* Saving a full library name. */
1562 add_to_list (&libs
, arg
);
1564 add_to_list (&static_libs
, arg
);
1570 #ifdef COLLECT_EXPORT_LIST
1571 /* This is added only for debugging purposes. */
1574 fprintf (stderr
, "List of libraries:\n");
1575 dump_list (stderr
, "\t", libs
.first
);
1576 fprintf (stderr
, "List of statically linked libraries:\n");
1577 dump_list (stderr
, "\t", static_libs
.first
);
1580 /* The AIX linker will discard static constructors in object files if
1581 nothing else in the file is referenced, so look at them first. Unless
1582 we are building a shared object, ignore the eh frame tables, as we
1583 would otherwise reference them all, hence drag all the corresponding
1584 objects even if nothing else is referenced. */
1586 const char **export_object_lst
1587 = CONST_CAST2 (const char **, char **, object_lst
);
1589 struct id
*list
= libs
.first
;
1591 /* Compute the filter to use from the current one, do scan, then adjust
1592 the "current" filter to remove what we just included here. This will
1593 control whether we need a first pass link later on or not, and what
1594 will remain to be scanned there. */
1596 scanfilter this_filter
= ld1_filter
;
1599 this_filter
&= ~SCAN_DWEH
;
1602 /* Scan object files. */
1603 while (export_object_lst
< object
)
1604 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1606 /* Scan libraries. */
1607 for (; list
; list
= list
->next
)
1608 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1610 ld1_filter
= ld1_filter
& ~this_filter
;
1615 char *buf
= concat ("-bE:", export_file
, NULL
);
1620 exportf
= fopen (export_file
, "w");
1621 if (exportf
== (FILE *) 0)
1622 fatal_error (input_location
, "fopen %s: %m", export_file
);
1623 write_aix_file (exportf
, exports
.first
);
1624 if (fclose (exportf
))
1625 fatal_error (input_location
, "fclose %s: %m", export_file
);
1630 *c_ptr
= *ld1
= *object
= (char *) 0;
1633 notice ("collect2 version %s\n", version_string
);
1637 printf ("Usage: collect2 [options]\n");
1638 printf (" Wrap linker and generate constructor code if needed.\n");
1639 printf (" Options:\n");
1640 printf (" -debug Enable debug output\n");
1641 printf (" --help Display this information\n");
1642 printf (" -v, --version Display this program's version number\n");
1644 printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1645 printf ("Report bugs: %s\n", bug_report_url
);
1652 fprintf (stderr
, "ld_file_name = %s\n",
1653 (ld_file_name
? ld_file_name
: "not found"));
1654 fprintf (stderr
, "c_file_name = %s\n",
1655 (c_file_name
? c_file_name
: "not found"));
1656 fprintf (stderr
, "nm_file_name = %s\n",
1657 (nm_file_name
? nm_file_name
: "not found"));
1659 fprintf (stderr
, "ldd_file_name = %s\n",
1660 (ldd_file_name
? ldd_file_name
: "not found"));
1662 fprintf (stderr
, "strip_file_name = %s\n",
1663 (strip_file_name
? strip_file_name
: "not found"));
1664 fprintf (stderr
, "c_file = %s\n",
1665 (c_file
? c_file
: "not found"));
1666 fprintf (stderr
, "o_file = %s\n",
1667 (o_file
? o_file
: "not found"));
1669 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1671 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1673 ptr
= getenv ("COLLECT_GCC");
1675 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1677 ptr
= getenv ("COMPILER_PATH");
1679 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1681 ptr
= getenv (LIBRARY_PATH_ENV
);
1683 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1685 fprintf (stderr
, "\n");
1688 /* Load the program, searching all libraries and attempting to provide
1689 undefined symbols from repository information.
1691 If -r or they will be run via some other method, do not build the
1692 constructor or destructor list, just return now. */
1695 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1697 /* Perform the first pass link now, if we're about to exit or if we need
1698 to scan for things we haven't collected yet before pursuing further.
1700 On AIX, the latter typically includes nothing for shared objects or
1701 frame tables for an executable, out of what the required early scan on
1702 objects and libraries has performed above. In the !shared_obj case, we
1703 expect the relevant tables to be dragged together with their associated
1704 functions from precise cross reference insertions by the compiler. */
1706 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1707 do_tlink (ld1_argv
, object_lst
);
1711 #ifdef COLLECT_EXPORT_LIST
1712 /* Make sure we delete the export file we may have created. */
1713 if (export_file
!= 0 && export_file
[0])
1714 maybe_unlink (export_file
);
1716 if (lto_mode
!= LTO_MODE_NONE
)
1717 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1719 post_ld_pass (/*temp_file*/false);
1725 /* Unless we have done it all already, examine the namelist and search for
1726 static constructors and destructors to call. Write the constructor and
1727 destructor tables to a .s file and reload. */
1729 if (ld1_filter
!= SCAN_NOTHING
)
1730 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1732 #ifdef SCAN_LIBRARIES
1733 scan_libraries (output_file
);
1738 notice_translated (ngettext ("%d constructor found\n",
1739 "%d constructors found\n",
1740 constructors
.number
),
1741 constructors
.number
);
1742 notice_translated (ngettext ("%d destructor found\n",
1743 "%d destructors found\n",
1744 destructors
.number
),
1745 destructors
.number
);
1746 notice_translated (ngettext ("%d frame table found\n",
1747 "%d frame tables found\n",
1748 frame_tables
.number
),
1749 frame_tables
.number
);
1752 /* If the scan exposed nothing of special interest, there's no need to
1753 generate the glue code and relink so return now. */
1755 if (constructors
.number
== 0 && destructors
.number
== 0
1756 && frame_tables
.number
== 0
1757 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1758 /* If we will be running these functions ourselves, we want to emit
1759 stubs into the shared library so that we do not have to relink
1760 dependent programs when we add static objects. */
1765 /* Do tlink without additional code generation now if we didn't
1766 do it earlier for scanning purposes. */
1767 if (ld1_filter
== SCAN_NOTHING
)
1768 do_tlink (ld1_argv
, object_lst
);
1771 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1773 /* Strip now if it was requested on the command line. */
1776 char **real_strip_argv
= XCNEWVEC (char *, 3);
1777 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1780 strip_argv
[0] = strip_file_name
;
1781 strip_argv
[1] = output_file
;
1782 strip_argv
[2] = (char *) 0;
1783 fork_execute ("strip", real_strip_argv
, false);
1786 #ifdef COLLECT_EXPORT_LIST
1787 maybe_unlink (export_file
);
1789 post_ld_pass (/*temp_file*/false);
1791 maybe_unlink (c_file
);
1792 maybe_unlink (o_file
);
1796 /* Sort ctor and dtor lists by priority. */
1797 sort_ids (&constructors
);
1798 sort_ids (&destructors
);
1800 maybe_unlink (output_file
);
1801 outf
= fopen (c_file
, "w");
1802 if (outf
== (FILE *) 0)
1803 fatal_error (input_location
, "fopen %s: %m", c_file
);
1805 write_c_file (outf
, c_file
);
1808 fatal_error (input_location
, "fclose %s: %m", c_file
);
1810 /* Tell the linker that we have initializer and finalizer functions. */
1811 #ifdef LD_INIT_SWITCH
1812 #ifdef COLLECT_EXPORT_LIST
1813 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1815 *ld2
++ = LD_INIT_SWITCH
;
1817 *ld2
++ = LD_FINI_SWITCH
;
1822 #ifdef COLLECT_EXPORT_LIST
1825 /* If we did not add export flag to link arguments before, add it to
1826 second link phase now. No new exports should have been added. */
1827 if (! exports
.first
)
1828 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1830 #ifdef TARGET_AIX_VERSION
1831 add_to_list (&exports
, aix_shared_initname
);
1832 add_to_list (&exports
, aix_shared_fininame
);
1835 #ifndef LD_INIT_SWITCH
1836 add_to_list (&exports
, initname
);
1837 add_to_list (&exports
, fininame
);
1838 add_to_list (&exports
, "_GLOBAL__DI");
1839 add_to_list (&exports
, "_GLOBAL__DD");
1841 exportf
= fopen (export_file
, "w");
1842 if (exportf
== (FILE *) 0)
1843 fatal_error (input_location
, "fopen %s: %m", export_file
);
1844 write_aix_file (exportf
, exports
.first
);
1845 if (fclose (exportf
))
1846 fatal_error (input_location
, "fclose %s: %m", export_file
);
1850 /* End of arguments to second link phase. */
1855 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1856 output_file
, c_file
);
1857 write_c_file (stderr
, "stderr");
1858 fprintf (stderr
, "========== end of c_file\n\n");
1859 #ifdef COLLECT_EXPORT_LIST
1860 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1861 write_aix_file (stderr
, exports
.first
);
1862 fprintf (stderr
, "========== end of export_file\n\n");
1866 /* Assemble the constructor and destructor tables.
1867 Link the tables in with the rest of the program. */
1869 fork_execute ("gcc", c_argv
, at_file_supplied
);
1870 #ifdef COLLECT_EXPORT_LIST
1871 /* On AIX we must call tlink because of possible templates resolution. */
1872 do_tlink (ld2_argv
, object_lst
);
1875 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1877 /* Otherwise, simply call ld because tlink is already done. */
1879 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1882 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1883 post_ld_pass (/*temp_file*/false);
1886 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1887 constructors/destructors in shared libraries. */
1888 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1891 maybe_unlink (c_file
);
1892 maybe_unlink (o_file
);
1894 #ifdef COLLECT_EXPORT_LIST
1895 maybe_unlink (export_file
);
1902 /* Unlink FILE unless we are debugging or this is the output_file
1903 and we may not unlink it. */
1906 maybe_unlink (const char *file
)
1908 if (save_temps
&& file_exists (file
))
1911 notice ("[Leaving %s]\n", file
);
1915 if (file
== output_file
&& !may_unlink_output_file
)
1918 unlink_if_ordinary (file
);
1921 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1924 maybe_unlink_list (char **file_list
)
1926 char **tmp
= file_list
;
1929 maybe_unlink (*(tmp
++));
1933 static long sequence_number
= 0;
1935 /* Add a name to a linked list. */
1938 add_to_list (struct head
*head_ptr
, const char *name
)
1941 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1943 strcpy (newid
->name
, name
);
1945 if (head_ptr
->first
)
1946 head_ptr
->last
->next
= newid
;
1948 head_ptr
->first
= newid
;
1950 /* Check for duplicate symbols. */
1951 for (p
= head_ptr
->first
;
1952 strcmp (name
, p
->name
) != 0;
1957 head_ptr
->last
->next
= 0;
1962 newid
->sequence
= ++sequence_number
;
1963 head_ptr
->last
= newid
;
1967 /* Grab the init priority number from an init function name that
1968 looks like "_GLOBAL_.I.12345.foo". */
1971 extract_init_priority (const char *name
)
1975 #ifdef TARGET_AIX_VERSION
1976 /* Run dependent module initializers before any constructors in this
1978 switch (is_ctor_dtor (name
))
1988 while (name
[pos
] == '_')
1990 pos
+= 10; /* strlen ("GLOBAL__X_") */
1992 /* Extract init_p number from ctor/dtor name. */
1993 pri
= atoi (name
+ pos
);
1994 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1997 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1998 ctors will be run from right to left, dtors from left to right. */
2001 sort_ids (struct head
*head_ptr
)
2003 /* id holds the current element to insert. id_next holds the next
2004 element to insert. id_ptr iterates through the already sorted elements
2005 looking for the place to insert id. */
2006 struct id
*id
, *id_next
, **id_ptr
;
2008 id
= head_ptr
->first
;
2010 /* We don't have any sorted elements yet. */
2011 head_ptr
->first
= NULL
;
2013 for (; id
; id
= id_next
)
2016 id
->sequence
= extract_init_priority (id
->name
);
2018 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2020 /* If the sequence numbers are the same, we put the id from the
2021 file later on the command line later in the list. */
2022 || id
->sequence
> (*id_ptr
)->sequence
2023 /* Hack: do lexical compare, too.
2024 || (id->sequence == (*id_ptr)->sequence
2025 && strcmp (id->name, (*id_ptr)->name) > 0) */
2034 /* Now set the sequence numbers properly so write_c_file works. */
2035 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2036 id
->sequence
= ++sequence_number
;
2039 /* Write: `prefix', the names on list LIST, `suffix'. */
2042 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2046 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2051 #ifdef COLLECT_EXPORT_LIST
2052 /* This function is really used only on AIX, but may be useful. */
2054 is_in_list (const char *prefix
, struct id
*list
)
2058 if (!strcmp (prefix
, list
->name
)) return 1;
2063 #endif /* COLLECT_EXPORT_LIST */
2065 /* Added for debugging purpose. */
2066 #ifdef COLLECT_EXPORT_LIST
2068 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2072 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2080 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2084 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2091 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2095 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2096 prefix
, list
->sequence
, list
->name
);
2101 /* Write out the constructor and destructor tables statically (for a shared
2102 object), along with the functions to execute them. */
2105 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2109 int frames
= (frame_tables
.number
> 0);
2111 /* Figure out name of output_file, stripping off .so version. */
2112 q
= p
= lbasename (output_file
);
2124 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2126 q
+= strlen (SHLIB_SUFFIX
);
2133 /* q points to null at end of the string (or . of the .so version) */
2134 prefix
= XNEWVEC (char, q
- p
+ 1);
2135 strncpy (prefix
, p
, q
- p
);
2137 for (r
= prefix
; *r
; r
++)
2138 if (!ISALNUM ((unsigned char)*r
))
2141 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2142 output_file
, prefix
);
2144 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2145 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2146 #ifdef TARGET_AIX_VERSION
2147 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2148 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2153 /* Write the tables as C code. */
2155 /* This count variable is used to prevent multiple calls to the
2156 constructors/destructors.
2157 This guard against multiple calls is important on AIX as the initfini
2158 functions are deliberately invoked multiple times as part of the
2159 mechanisms GCC uses to order constructors across different dependent
2160 shared libraries (see config/rs6000/aix.h).
2162 fprintf (stream
, "static int count;\n");
2163 fprintf (stream
, "typedef void entry_pt();\n");
2164 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2168 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2170 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2171 write_list (stream
, "\t\t&", frame_tables
.first
);
2172 fprintf (stream
, "\t0\n};\n");
2174 /* This must match what's in frame.h. */
2175 fprintf (stream
, "struct object {\n");
2176 fprintf (stream
, " void *pc_begin;\n");
2177 fprintf (stream
, " void *pc_end;\n");
2178 fprintf (stream
, " void *fde_begin;\n");
2179 fprintf (stream
, " void *fde_array;\n");
2180 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2181 fprintf (stream
, " struct object *next;\n");
2182 fprintf (stream
, "};\n");
2184 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2185 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2186 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2187 #ifdef TARGET_AIX_VERSION
2188 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2191 fprintf (stream
, "static void reg_frame () {\n");
2192 fprintf (stream
, "\tstatic struct object ob;\n");
2193 #ifdef TARGET_AIX_VERSION
2194 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2195 This might not be the start of the segment, signed offsets assumed.
2197 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2199 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2201 fprintf (stream
, "\t}\n");
2203 fprintf (stream
, "static void dereg_frame () {\n");
2204 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2205 fprintf (stream
, "\t}\n");
2208 fprintf (stream
, "void %s() {\n", initname
);
2209 if (constructors
.number
> 0 || frames
)
2211 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2212 write_list (stream
, "\t\t", constructors
.first
);
2214 fprintf (stream
, "\treg_frame,\n");
2215 fprintf (stream
, "\t};\n");
2216 fprintf (stream
, "\tentry_pt **p;\n");
2217 fprintf (stream
, "\tif (count++ != 0) return;\n");
2218 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2219 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2222 fprintf (stream
, "\t++count;\n");
2223 fprintf (stream
, "}\n");
2224 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2225 fprintf (stream
, "void %s() {\n", fininame
);
2226 if (destructors
.number
> 0 || frames
)
2228 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2229 write_list (stream
, "\t\t", destructors
.first
);
2231 fprintf (stream
, "\tdereg_frame,\n");
2232 fprintf (stream
, "\t};\n");
2233 fprintf (stream
, "\tentry_pt **p;\n");
2234 fprintf (stream
, "\tif (--count != 0) return;\n");
2235 fprintf (stream
, "\tp = dtors;\n");
2236 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2237 destructors
.number
+ frames
);
2239 fprintf (stream
, "}\n");
2243 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2244 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2248 /* Write the constructor/destructor tables. */
2250 #ifndef LD_INIT_SWITCH
2252 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2254 /* Write the tables as C code. */
2256 int frames
= (frame_tables
.number
> 0);
2258 fprintf (stream
, "typedef void entry_pt();\n\n");
2260 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2264 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2266 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2267 write_list (stream
, "\t\t&", frame_tables
.first
);
2268 fprintf (stream
, "\t0\n};\n");
2270 /* This must match what's in frame.h. */
2271 fprintf (stream
, "struct object {\n");
2272 fprintf (stream
, " void *pc_begin;\n");
2273 fprintf (stream
, " void *pc_end;\n");
2274 fprintf (stream
, " void *fde_begin;\n");
2275 fprintf (stream
, " void *fde_array;\n");
2276 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2277 fprintf (stream
, " struct object *next;\n");
2278 fprintf (stream
, "};\n");
2280 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2281 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2283 fprintf (stream
, "static void reg_frame () {\n");
2284 fprintf (stream
, "\tstatic struct object ob;\n");
2285 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2286 fprintf (stream
, "\t}\n");
2288 fprintf (stream
, "static void dereg_frame () {\n");
2289 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2290 fprintf (stream
, "\t}\n");
2293 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2294 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2295 write_list (stream
, "\t", constructors
.first
);
2297 fprintf (stream
, "\treg_frame,\n");
2298 fprintf (stream
, "\t0\n};\n\n");
2300 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2302 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2303 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2304 write_list (stream
, "\t", destructors
.first
);
2306 fprintf (stream
, "\tdereg_frame,\n");
2307 fprintf (stream
, "\t0\n};\n\n");
2309 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2310 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2312 #endif /* ! LD_INIT_SWITCH */
2315 write_c_file (FILE *stream
, const char *name
)
2317 #ifndef LD_INIT_SWITCH
2319 write_c_file_glob (stream
, name
);
2322 write_c_file_stat (stream
, name
);
2325 #ifdef COLLECT_EXPORT_LIST
2327 write_aix_file (FILE *stream
, struct id
*list
)
2329 for (; list
; list
= list
->next
)
2331 fputs (list
->name
, stream
);
2332 putc ('\n', stream
);
2337 #ifdef OBJECT_FORMAT_NONE
2339 /* Check to make sure the file is an LTO object file. */
2342 has_lto_section (void *data
, const char *name ATTRIBUTE_UNUSED
,
2343 off_t offset ATTRIBUTE_UNUSED
,
2344 off_t length ATTRIBUTE_UNUSED
)
2346 int *found
= (int *) data
;
2348 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
2349 sizeof (LTO_SECTION_NAME_PREFIX
) - 1) != 0)
2351 if (strncmp (name
, OFFLOAD_SECTION_NAME_PREFIX
,
2352 sizeof (OFFLOAD_SECTION_NAME_PREFIX
) - 1) != 0)
2358 /* Stop iteration. */
2363 is_lto_object_file (const char *prog_name
)
2369 int infd
= open (prog_name
, O_RDONLY
| O_BINARY
);
2374 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
2380 errmsg
= simple_object_find_sections (inobj
, has_lto_section
,
2381 (void *) &found
, &err
);
2382 if (! errmsg
&& found
)
2386 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
2390 /* Generic version to scan the name list of the loaded program for
2391 the symbols g++ uses for static constructors and destructors. */
2394 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2397 void (*int_handler
) (int);
2399 void (*quit_handler
) (int);
2401 char *real_nm_argv
[4];
2402 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2404 struct pex_obj
*pex
;
2410 if (which_pass
== PASS_SECOND
)
2413 /* LTO objects must be in a known format. This check prevents
2414 us from accepting an archive containing LTO objects, which
2415 gcc cannot currently handle. */
2416 if (which_pass
== PASS_LTOINFO
)
2418 if(is_lto_object_file (prog_name
)) {
2419 add_lto_object (<o_objects
, prog_name
);
2424 /* If we do not have an `nm', complain. */
2425 if (nm_file_name
== 0)
2426 fatal_error (input_location
, "cannot find %<nm%>");
2428 nm_argv
[argc
++] = nm_file_name
;
2429 if (NM_FLAGS
[0] != '\0')
2430 nm_argv
[argc
++] = NM_FLAGS
;
2432 nm_argv
[argc
++] = prog_name
;
2433 nm_argv
[argc
++] = (char *) 0;
2435 /* Trace if needed. */
2438 const char **p_argv
;
2441 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2442 fprintf (stderr
, " %s", str
);
2444 fprintf (stderr
, "\n");
2450 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2452 fatal_error (input_location
, "%<pex_init%> failed: %m");
2454 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2461 fatal_error (input_location
, "%s: %m", _(errmsg
));
2464 fatal_error (input_location
, errmsg
);
2467 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2469 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2472 inf
= pex_read_output (pex
, 0);
2474 fatal_error (input_location
, "cannot open nm output: %m");
2477 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2479 /* Read each line of nm output. */
2480 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2486 fprintf (stderr
, "\t%s\n", buf
);
2488 /* If it contains a constructor or destructor name, add the name
2489 to the appropriate list unless this is a kind of symbol we're
2490 not supposed to even consider. */
2492 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2493 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2500 /* Find the end of the symbol name.
2501 Do not include `|', because Encore nm can tack that on the end. */
2502 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2509 switch (is_ctor_dtor (name
))
2512 if (! (filter
& SCAN_CTOR
))
2514 if (which_pass
!= PASS_LIB
)
2515 add_to_list (&constructors
, name
);
2519 if (! (filter
& SCAN_DTOR
))
2521 if (which_pass
!= PASS_LIB
)
2522 add_to_list (&destructors
, name
);
2526 if (! (filter
& SCAN_INIT
))
2528 if (which_pass
!= PASS_LIB
)
2529 fatal_error (input_location
, "init function found in object %s",
2531 #ifndef LD_INIT_SWITCH
2532 add_to_list (&constructors
, name
);
2537 if (! (filter
& SCAN_FINI
))
2539 if (which_pass
!= PASS_LIB
)
2540 fatal_error (input_location
, "fini function found in object %s",
2542 #ifndef LD_FINI_SWITCH
2543 add_to_list (&destructors
, name
);
2548 if (! (filter
& SCAN_DWEH
))
2550 if (which_pass
!= PASS_LIB
)
2551 add_to_list (&frame_tables
, name
);
2554 default: /* not a constructor or destructor */
2560 fprintf (stderr
, "\n");
2562 do_wait (nm_file_name
, pex
);
2564 signal (SIGINT
, int_handler
);
2566 signal (SIGQUIT
, quit_handler
);
2572 /* Use the List Dynamic Dependencies program to find shared libraries that
2573 the output file depends upon and their initialization/finalization
2574 routines, if any. */
2577 scan_libraries (const char *prog_name
)
2579 static struct head libraries
; /* list of shared libraries found */
2581 void (*int_handler
) (int);
2583 void (*quit_handler
) (int);
2585 char *real_ldd_argv
[4];
2586 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2588 struct pex_obj
*pex
;
2594 /* If we do not have an `ldd', complain. */
2595 if (ldd_file_name
== 0)
2597 error ("cannot find %<ldd%>");
2601 ldd_argv
[argc
++] = ldd_file_name
;
2602 ldd_argv
[argc
++] = prog_name
;
2603 ldd_argv
[argc
++] = (char *) 0;
2605 /* Trace if needed. */
2608 const char **p_argv
;
2611 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2612 fprintf (stderr
, " %s", str
);
2614 fprintf (stderr
, "\n");
2620 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2622 fatal_error (input_location
, "pex_init failed: %m");
2624 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2630 fatal_error (input_location
, "%s: %m", _(errmsg
));
2633 fatal_error (input_location
, errmsg
);
2636 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2638 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2641 inf
= pex_read_output (pex
, 0);
2643 fatal_error (input_location
, "cannot open ldd output: %m");
2646 notice ("\nldd output with constructors/destructors.\n");
2648 /* Read each line of ldd output. */
2649 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2652 char *name
, *end
, *p
= buf
;
2654 /* Extract names of libraries and add to list. */
2655 PARSE_LDD_OUTPUT (p
);
2660 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2661 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2663 /* Find the end of the symbol name. */
2665 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2670 if (access (name
, R_OK
) == 0)
2671 add_to_list (&libraries
, name
);
2673 fatal_error (input_location
, "unable to open dynamic dependency "
2677 fprintf (stderr
, "\t%s\n", buf
);
2680 fprintf (stderr
, "\n");
2682 do_wait (ldd_file_name
, pex
);
2684 signal (SIGINT
, int_handler
);
2686 signal (SIGQUIT
, quit_handler
);
2689 /* Now iterate through the library list adding their symbols to
2691 for (list
= libraries
.first
; list
; list
= list
->next
)
2692 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2695 #endif /* LDD_SUFFIX */
2697 #endif /* OBJECT_FORMAT_NONE */
2701 * COFF specific stuff.
2704 #ifdef OBJECT_FORMAT_COFF
2706 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2707 # define GCC_SYMENT SYMENT
2708 # if defined (C_WEAKEXT)
2709 # define GCC_OK_SYMBOL(X) \
2710 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2711 ((X).n_scnum > N_UNDEF) && \
2713 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2714 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2715 # define GCC_UNDEF_SYMBOL(X) \
2716 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2717 ((X).n_scnum == N_UNDEF))
2719 # define GCC_OK_SYMBOL(X) \
2720 (((X).n_sclass == C_EXT) && \
2721 ((X).n_scnum > N_UNDEF) && \
2723 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2724 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2725 # define GCC_UNDEF_SYMBOL(X) \
2726 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2728 # define GCC_SYMINC(X) ((X).n_numaux+1)
2729 # define GCC_SYMZERO(X) 0
2731 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2732 #if TARGET_AIX_VERSION >= 51
2733 # define GCC_CHECK_HDR(X) \
2734 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2735 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2736 && !(HEADER (X).f_flags & F_LOADONLY))
2738 # define GCC_CHECK_HDR(X) \
2739 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2740 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2741 && !(HEADER (X).f_flags & F_LOADONLY))
2744 #ifdef COLLECT_EXPORT_LIST
2745 /* Array of standard AIX libraries which should not
2746 be scanned for ctors/dtors. */
2747 static const char *const aix_std_libs
[] = {
2755 "/usr/lib/libc_r.a",
2756 "/usr/lib/libm_r.a",
2757 "/usr/lib/threads/libc.a",
2758 "/usr/ccs/lib/libc.a",
2759 "/usr/ccs/lib/libm.a",
2760 "/usr/ccs/lib/libc_r.a",
2761 "/usr/ccs/lib/libm_r.a",
2765 /* This function checks the filename and returns 1
2766 if this name matches the location of a standard AIX library. */
2767 static int ignore_library (const char *);
2769 ignore_library (const char *name
)
2771 const char *const *p
;
2774 if (target_system_root
[0] != '\0')
2776 length
= strlen (target_system_root
);
2777 if (strncmp (name
, target_system_root
, length
) != 0)
2781 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2782 if (strcmp (name
, *p
) == 0)
2786 #endif /* COLLECT_EXPORT_LIST */
2788 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2789 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2792 /* COFF version to scan the name list of the loaded program for
2793 the symbols g++ uses for static constructors and destructors. */
2796 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2799 LDFILE
*ldptr
= NULL
;
2800 int sym_index
, sym_count
;
2804 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
2805 && which_pass
!= PASS_LTOINFO
)
2808 #ifdef COLLECT_EXPORT_LIST
2809 /* We do not need scanning for some standard C libraries. */
2810 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2813 /* On AIX we have a loop, because there is not much difference
2814 between an object and an archive. This trick allows us to
2815 eliminate scan_libraries() function. */
2820 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2821 non-const char * filename parameter, even though it will not
2822 modify that string. So we must cast away const-ness here,
2823 using CONST_CAST to prevent complaints from -Wcast-qual. */
2824 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2826 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2827 fatal_error (input_location
, "%s: not a COFF file", prog_name
);
2829 if (GCC_CHECK_HDR (ldptr
))
2831 sym_count
= GCC_SYMBOLS (ldptr
);
2832 sym_index
= GCC_SYMZERO (ldptr
);
2834 #ifdef COLLECT_EXPORT_LIST
2835 /* Is current archive member a shared object? */
2836 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2839 while (sym_index
< sym_count
)
2843 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2845 sym_index
+= GCC_SYMINC (symbol
);
2847 if (GCC_OK_SYMBOL (symbol
))
2851 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2852 continue; /* Should never happen. */
2854 #ifdef XCOFF_DEBUGGING_INFO
2855 /* All AIX function names have a duplicate entry
2856 beginning with a dot. */
2861 if (which_pass
== PASS_LTOINFO
)
2865 if (strncmp (name
, "__gnu_lto_v1", 12) == 0)
2867 add_lto_object (<o_objects
, prog_name
);
2874 switch (is_ctor_dtor (name
))
2876 #if TARGET_AIX_VERSION
2877 /* Add AIX shared library initalisers/finalisers
2878 to the constructors/destructors list of the
2881 if (! (filter
& SCAN_CTOR
))
2883 if (is_shared
&& !aixlazy_flag
2884 #ifdef COLLECT_EXPORT_LIST
2886 && ! is_in_list (prog_name
, static_libs
.first
)
2889 add_to_list (&constructors
, name
);
2893 if (! (filter
& SCAN_DTOR
))
2895 if (is_shared
&& !aixlazy_flag
)
2896 add_to_list (&destructors
, name
);
2901 if (! (filter
& SCAN_CTOR
))
2904 add_to_list (&constructors
, name
);
2905 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2906 if (which_pass
== PASS_OBJ
)
2907 add_to_list (&exports
, name
);
2912 if (! (filter
& SCAN_DTOR
))
2915 add_to_list (&destructors
, name
);
2916 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2917 if (which_pass
== PASS_OBJ
)
2918 add_to_list (&exports
, name
);
2922 #ifdef COLLECT_EXPORT_LIST
2924 if (! (filter
& SCAN_INIT
))
2926 #ifndef LD_INIT_SWITCH
2928 add_to_list (&constructors
, name
);
2933 if (! (filter
& SCAN_FINI
))
2935 #ifndef LD_INIT_SWITCH
2937 add_to_list (&destructors
, name
);
2943 if (! (filter
& SCAN_DWEH
))
2946 add_to_list (&frame_tables
, name
);
2947 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2948 if (which_pass
== PASS_OBJ
)
2949 add_to_list (&exports
, name
);
2953 default: /* not a constructor or destructor */
2954 #ifdef COLLECT_EXPORT_LIST
2955 /* Explicitly export all global symbols when
2956 building a shared object on AIX, but do not
2957 re-export symbols from another shared object
2958 and do not export symbols if the user
2959 provides an explicit export list. */
2960 if (shared_obj
&& !is_shared
2961 && which_pass
== PASS_OBJ
&& !export_flag
)
2963 /* Do not auto-export __dso_handle or
2964 __gcc_unwind_dbase. They are required
2965 to be local to each module. */
2966 if (strcmp(name
, "__dso_handle") != 0
2967 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2969 add_to_list (&exports
, name
);
2977 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2978 symbol
.n_scnum
, symbol
.n_sclass
,
2979 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2984 #ifdef COLLECT_EXPORT_LIST
2987 /* If archive contains both 32-bit and 64-bit objects,
2988 we want to skip objects in other mode so mismatch normal. */
2990 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2991 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2997 fatal_error (input_location
, "%s: cannot open as COFF file",
3000 #ifdef COLLECT_EXPORT_LIST
3001 /* On AIX loop continues while there are more members in archive. */
3003 while (ldclose (ldptr
) == FAILURE
);
3005 /* Otherwise we simply close ldptr. */
3006 (void) ldclose (ldptr
);
3009 #endif /* OBJECT_FORMAT_COFF */
3011 #ifdef COLLECT_EXPORT_LIST
3012 /* Given a library name without "lib" prefix, this function
3013 returns a full library name including a path. */
3015 resolve_lib_name (const char *name
)
3019 /* Library extensions for AIX dynamic linking. */
3020 const char * const libexts
[2] = {"a", "so"};
3022 for (i
= 0; libpaths
[i
]; i
++)
3023 if (libpaths
[i
]->max_len
> l
)
3024 l
= libpaths
[i
]->max_len
;
3026 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
3028 for (i
= 0; libpaths
[i
]; i
++)
3030 struct prefix_list
*list
= libpaths
[i
]->plist
;
3031 for (; list
; list
= list
->next
)
3033 /* The following lines are needed because path_prefix list
3034 may contain directories both with trailing DIR_SEPARATOR and
3037 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
3039 for (j
= 0; j
< 2; j
++)
3041 sprintf (lib_buf
, "%s%slib%s.%s",
3042 list
->prefix
, p
, name
,
3043 libexts
[(j
+ aixrtl_flag
) % 2]);
3044 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3045 if (file_exists (lib_buf
))
3047 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3054 fprintf (stderr
, "not found\n");
3056 fatal_error (input_location
, "library lib%s not found", name
);
3059 #endif /* COLLECT_EXPORT_LIST */
3061 #ifdef COLLECT_RUN_DSYMUTIL
3062 static int flag_dsym
= false;
3063 static int flag_idsym
= false;
3066 process_args (int *argcp
, char **argv
) {
3069 for (i
=0; i
<argc
; ++i
)
3071 if (strcmp (argv
[i
], "-dsym") == 0)
3074 /* Remove the flag, as we handle all processing for it. */
3077 argv
[j
] = argv
[j
+1];
3082 else if (strcmp (argv
[i
], "-idsym") == 0)
3085 /* Remove the flag, as we handle all processing for it. */
3088 argv
[j
] = argv
[j
+1];
3097 do_dsymutil (const char *output_file
) {
3098 const char *dsymutil
= DSYMUTIL
+ 1;
3099 struct pex_obj
*pex
;
3100 char **real_argv
= XCNEWVEC (char *, 3);
3101 const char ** argv
= CONST_CAST2 (const char **, char **,
3105 argv
[1] = output_file
;
3106 argv
[2] = (char *) 0;
3108 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3109 PEX_LAST
| PEX_SEARCH
, false);
3110 do_wait (dsymutil
, pex
);
3114 post_ld_pass (bool temp_file
) {
3115 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3118 do_dsymutil (output_file
);
3122 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3123 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }