1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2020 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 const char *c_file
; /* <xxx>.c for constructor/destructor list. */
209 static const 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 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 bool at_file_supplied
; /* Whether to use @file arguments */
239 struct obstack temporary_obstack
;
240 char * temporary_firstobj
;
242 /* A string that must be prepended to a target OS path in order to find
243 it on the host system. */
244 #ifdef TARGET_SYSTEM_ROOT
245 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
247 static const char *target_system_root
= "";
250 /* Whether we may unlink the output file, which should be set as soon as we
251 know we have successfully produced it. This is typically useful to prevent
252 blindly attempting to unlink a read-only output that the target linker
253 would leave untouched. */
254 bool may_unlink_output_file
= false;
256 #ifdef COLLECT_EXPORT_LIST
257 /* Lists to keep libraries to be scanned for global constructors/destructors. */
258 static struct head libs
; /* list of libraries */
259 static struct head static_libs
; /* list of statically linked 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 const char tool_name
[] = "collect2";
301 static symkind
is_ctor_dtor (const char *);
303 static void handler (int);
304 static void maybe_unlink_list (char **);
305 static void add_to_list (struct head
*, const char *);
306 static int extract_init_priority (const char *);
307 static void sort_ids (struct head
*);
308 static void write_list (FILE *, const char *, struct id
*);
309 #ifdef COLLECT_EXPORT_LIST
310 static void dump_list (FILE *, const char *, struct id
*);
313 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
315 static void write_list_with_asm (FILE *, const char *, struct id
*);
316 static void write_c_file (FILE *, const char *);
317 static void write_c_file_stat (FILE *, const char *);
318 #ifndef LD_INIT_SWITCH
319 static void write_c_file_glob (FILE *, const char *);
321 #ifdef SCAN_LIBRARIES
322 static void scan_libraries (const char *);
324 #ifdef COLLECT_EXPORT_LIST
325 static int is_in_list (const char *, struct id
*);
326 static void write_aix_file (FILE *, struct id
*);
327 static char *resolve_lib_name (const char *);
329 static char *extract_string (const char **);
330 static void post_ld_pass (bool);
331 static void process_args (int *argcp
, char **argv
);
333 /* Enumerations describing which pass this is for scanning the
337 PASS_FIRST
, /* without constructors */
338 PASS_OBJ
, /* individual objects */
339 PASS_LIB
, /* looking for shared libraries */
340 PASS_SECOND
, /* with constructors linked in */
341 PASS_LTOINFO
/* looking for objects with LTO info */
344 /* ... and which kinds of symbols are to be considered. */
346 enum scanfilter_masks
{
349 SCAN_CTOR
= 1 << SYM_CTOR
,
350 SCAN_DTOR
= 1 << SYM_DTOR
,
351 SCAN_INIT
= 1 << SYM_INIT
,
352 SCAN_FINI
= 1 << SYM_FINI
,
353 SCAN_DWEH
= 1 << SYM_DWEH
,
354 SCAN_AIXI
= 1 << SYM_AIXI
,
355 SCAN_AIXD
= 1 << SYM_AIXD
,
359 /* This type is used for parameters and variables which hold
360 combinations of the flags in enum scanfilter_masks. */
361 typedef int scanfilter
;
363 /* Scan the name list of the loaded program for the symbols g++ uses for
364 static constructors and destructors.
366 The SCANPASS argument tells which collect processing pass this is for and
367 the SCANFILTER argument tells which kinds of symbols to consider in this
368 pass. Symbols of a special kind not in the filter mask are considered as
371 The constructor table begins at __CTOR_LIST__ and contains a count of the
372 number of pointers (or -1 if the constructors are built in a separate
373 section by the linker), followed by the pointers to the constructor
374 functions, terminated with a null pointer. The destructor table has the
375 same format, and begins at __DTOR_LIST__. */
377 static void scan_prog_file (const char *, scanpass
, scanfilter
);
380 /* Delete tempfiles and exit function. */
383 tool_cleanup (bool from_signal
)
385 /* maybe_unlink may call notice, which is not signal safe. */
389 if (c_file
!= 0 && c_file
[0])
390 maybe_unlink (c_file
);
392 if (o_file
!= 0 && o_file
[0])
393 maybe_unlink (o_file
);
395 #ifdef COLLECT_EXPORT_LIST
396 if (export_file
!= 0 && export_file
[0])
397 maybe_unlink (export_file
);
401 maybe_unlink_list (lto_o_files
);
405 collect_atexit (void)
407 tool_cleanup (false);
415 signal (signo
, SIG_DFL
);
418 /* Notify user of a non-error, without translating the format string. */
420 notice_translated (const char *cmsgid
, ...)
424 va_start (ap
, cmsgid
);
425 vfprintf (stderr
, cmsgid
, ap
);
430 file_exists (const char *name
)
432 return access (name
, R_OK
) == 0;
435 /* Parse a reasonable subset of shell quoting syntax. */
438 extract_string (const char **pp
)
451 obstack_1grow (&temporary_obstack
, c
);
452 else if (! inside
&& c
== ' ')
454 else if (! inside
&& c
== '\\')
459 obstack_1grow (&temporary_obstack
, c
);
462 obstack_1grow (&temporary_obstack
, '\0');
464 return XOBFINISH (&temporary_obstack
, char *);
467 /* Return the kind of symbol denoted by name S. */
470 is_ctor_dtor (const char *s
)
472 struct names
{ const char *const name
; const int len
; symkind ret
;
473 const int two_underscores
; };
475 const struct names
*p
;
477 const char *orig_s
= s
;
479 static const struct names special
[] = {
480 #ifndef NO_DOLLAR_IN_LABEL
481 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
482 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
484 #ifndef NO_DOT_IN_LABEL
485 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
486 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
487 #endif /* NO_DOT_IN_LABEL */
488 #endif /* NO_DOLLAR_IN_LABEL */
489 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
490 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
491 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
492 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
493 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
494 #ifdef TARGET_AIX_VERSION
495 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
496 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
498 { NULL
, 0, SYM_REGULAR
, 0 }
501 while ((ch
= *s
) == '_')
507 for (p
= &special
[0]; p
->len
> 0; p
++)
510 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
511 && strncmp (s
, p
->name
, p
->len
) == 0)
519 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
520 and one from the PATH variable. */
522 static struct path_prefix cpath
, path
;
524 #ifdef CROSS_DIRECTORY_STRUCTURE
525 /* This is the name of the target machine. We use it to form the name
526 of the files to execute. */
528 static const char *const target_machine
= TARGET_MACHINE
;
531 /* Search for NAME using prefix list PPREFIX. We only look for executable
534 Return 0 if not found, otherwise return its name, allocated with malloc. */
536 #ifdef OBJECT_FORMAT_NONE
538 /* Add an entry for the object file NAME to object file list LIST.
539 New entries are added at the end of the list. The original pointer
540 value of NAME is preserved, i.e., no string copy is performed. */
543 add_lto_object (struct lto_object_list
*list
, const char *name
)
545 struct lto_object
*n
= XNEW (struct lto_object
);
550 list
->last
->next
= n
;
556 #endif /* OBJECT_FORMAT_NONE */
559 /* Perform a link-time recompilation and relink if any of the object
560 files contain LTO info. The linker command line LTO_LD_ARGV
561 represents the linker command that would produce a final executable
562 without the use of LTO. OBJECT_LST is a vector of object file names
563 appearing in LTO_LD_ARGV that are to be considered for link-time
564 recompilation, where OBJECT is a pointer to the last valid element.
565 (This awkward convention avoids an impedance mismatch with the
566 usage of similarly-named variables in main().) The elements of
567 OBJECT_LST must be identical, i.e., pointer equal, to the
568 corresponding arguments in LTO_LD_ARGV.
570 Upon entry, at least one linker run has been performed without the
571 use of any LTO info that might be present. Any recompilations
572 necessary for template instantiations have been performed, and
573 initializer/finalizer tables have been created if needed and
574 included in the linker command line LTO_LD_ARGV. If any of the
575 object files contain LTO info, we run the LTO back end on all such
576 files, and perform the final link with the LTO back end output
577 substituted for the LTO-optimized files. In some cases, a final
578 link with all link-time generated code has already been performed,
579 so there is no need to relink if no LTO info is found. In other
580 cases, our caller has not produced the final executable, and is
581 relying on us to perform the required link whether LTO info is
582 present or not. In that case, the FORCE argument should be true.
583 Note that the linker command line argument LTO_LD_ARGV passed into
584 this function may be modified in place. */
587 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
588 const char **object
, bool force
)
590 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
592 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
594 while (object_file
< object
)
596 /* If file contains LTO info, add it to the list of LTO objects. */
597 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
599 /* Increment the argument count by the number of object file arguments
600 we will add. An upper bound suffices, so just count all of the
601 object files regardless of whether they contain LTO info. */
605 if (lto_objects
.first
)
608 const char **lto_c_ptr
;
611 struct lto_object
*list
;
612 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
614 const char *prog
= "lto-wrapper";
615 int lto_ld_argv_size
= 0;
616 char **out_lto_ld_argv
;
617 int out_lto_ld_argv_size
;
621 fatal_error (input_location
, "environment variable "
622 "%<COLLECT_LTO_WRAPPER%> must be set");
626 /* There is at least one object file containing LTO info,
627 so we need to run the LTO back end and relink.
629 To do so we build updated ld arguments with first
630 LTO object replaced by all partitions and other LTO
633 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
634 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
636 *lto_c_ptr
++ = lto_wrapper
;
638 /* Add LTO objects to the wrapper command line. */
639 for (list
= lto_objects
.first
; list
; list
= list
->next
)
640 *lto_c_ptr
++ = list
->name
;
644 /* Run the LTO back end. */
645 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
653 stream
= pex_read_output (pex
, 0);
657 while ((c
= getc (stream
)) != EOF
)
659 obstack_1grow (&temporary_obstack
, c
);
664 /* signal handler may access uninitialized memory
665 and delete whatever it points to, if lto_o_files
666 is not allocated with calloc. */
667 lto_o_files
= XCNEWVEC (char *, num_files
+ 1);
668 lto_o_files
[num_files
] = NULL
;
669 start
= XOBFINISH (&temporary_obstack
, char *);
670 for (i
= 0; i
< num_files
; ++i
)
677 lto_o_files
[i
] = xstrdup (start
);
682 obstack_free (&temporary_obstack
, temporary_firstobj
);
687 /* Compute memory needed for new LD arguments. At most number of original arguments
688 plus number of partitions. */
689 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
691 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
692 out_lto_ld_argv_size
= 0;
694 /* After running the LTO back end, we will relink, substituting
695 the LTO output for the object files that we submitted to the
696 LTO. Here, we modify the linker command line for the relink. */
698 /* Copy all arguments until we find first LTO file. */
702 for (list
= lto_objects
.first
; list
; list
= list
->next
)
703 if (*p
== list
->name
) /* Note test for pointer equality! */
707 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
710 /* Now insert all LTO partitions. */
711 lto_o_ptr
= lto_o_files
;
713 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
715 /* ... and copy the rest. */
718 for (list
= lto_objects
.first
; list
; list
= list
->next
)
719 if (*p
== list
->name
) /* Note test for pointer equality! */
722 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
725 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
727 /* Run the linker again, this time replacing the object files
728 optimized by the LTO with the temporary file generated by the LTO. */
729 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
730 /* We assume that temp files were created, and therefore we need to take
731 that into account (maybe run dsymutil). */
732 post_ld_pass (/*temp_file*/true);
735 maybe_unlink_list (lto_o_files
);
739 /* Our caller is relying on us to do the link
740 even though there is no LTO back end work to be done. */
741 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
742 /* No LTO objects were found, so no new temp file. */
743 post_ld_pass (/*temp_file*/false);
746 post_ld_pass (false); /* No LTO objects were found, no temp file. */
748 /* Entry point for linker invoation. Called from main in collect2.c.
749 LD_ARGV is an array of arguments for the linker. */
752 do_link (char **ld_argv
)
755 const char *prog
= "ld";
756 pex
= collect_execute (prog
, ld_argv
, NULL
, NULL
,
757 PEX_LAST
| PEX_SEARCH
,
758 HAVE_GNU_LD
&& at_file_supplied
);
759 int ret
= collect_wait (prog
, pex
);
762 error ("ld returned %d exit status", ret
);
767 /* We have just successfully produced an output file, so assume that we
768 may unlink it if need be for now on. */
769 may_unlink_output_file
= true;
776 main (int argc
, char **argv
)
786 } selected_linker
= USE_DEFAULT_LD
;
787 static const char *const ld_suffixes
[USE_LD_MAX
] =
795 static const char *const real_ld_suffix
= "real-ld";
796 static const char *const collect_ld_suffix
= "collect-ld";
797 static const char *const nm_suffix
= "nm";
798 static const char *const gnm_suffix
= "gnm";
800 static const char *const ldd_suffix
= LDD_SUFFIX
;
802 static const char *const strip_suffix
= "strip";
803 static const char *const gstrip_suffix
= "gstrip";
805 const char *full_ld_suffixes
[USE_LD_MAX
];
806 #ifdef CROSS_DIRECTORY_STRUCTURE
807 /* If we look for a program in the compiler directories, we just use
808 the short name, since these directories are already system-specific.
809 But it we look for a program in the system directories, we need to
810 qualify the program name with the target machine. */
812 const char *const full_nm_suffix
=
813 concat (target_machine
, "-", nm_suffix
, NULL
);
814 const char *const full_gnm_suffix
=
815 concat (target_machine
, "-", gnm_suffix
, NULL
);
817 const char *const full_ldd_suffix
=
818 concat (target_machine
, "-", ldd_suffix
, NULL
);
820 const char *const full_strip_suffix
=
821 concat (target_machine
, "-", strip_suffix
, NULL
);
822 const char *const full_gstrip_suffix
=
823 concat (target_machine
, "-", gstrip_suffix
, NULL
);
826 const char *const full_ldd_suffix
= ldd_suffix
;
828 const char *const full_nm_suffix
= nm_suffix
;
829 const char *const full_gnm_suffix
= gnm_suffix
;
830 const char *const full_strip_suffix
= strip_suffix
;
831 const char *const full_gstrip_suffix
= gstrip_suffix
;
832 #endif /* CROSS_DIRECTORY_STRUCTURE */
836 #ifdef COLLECT_EXPORT_LIST
839 const char *ld_file_name
;
845 bool use_plugin
= false;
846 bool use_collect_ld
= false;
848 /* The kinds of symbols we will have to consider when scanning the
849 outcome of a first pass link. This is ALL to start with, then might
850 be adjusted before getting to the first pass link per se, typically on
851 AIX where we perform an early scan of objects and libraries to fetch
852 the list of global ctors/dtors and make sure they are not garbage
854 scanfilter ld1_filter
= SCAN_ALL
;
860 #ifdef TARGET_AIX_VERSION
861 int object_nbr
= argc
;
866 #ifdef COLLECT_EXPORT_LIST
867 bool is_static
= false;
871 for (i
= 0; i
< USE_LD_MAX
; i
++)
873 #ifdef CROSS_DIRECTORY_STRUCTURE
874 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
879 p
= argv
[0] + strlen (argv
[0]);
880 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
884 xmalloc_set_program_name (progname
);
887 expandargv (&argc
, &argv
);
888 if (argv
!= old_argv
)
889 at_file_supplied
= 1;
891 process_args (&argc
, argv
);
893 num_c_args
= argc
+ 9;
895 #ifndef HAVE_LD_DEMANGLE
896 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
898 /* Suppress demangling by the real linker, which may be broken. */
899 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
902 #if defined (COLLECT2_HOST_INITIALIZATION)
903 /* Perform system dependent initialization, if necessary. */
904 COLLECT2_HOST_INITIALIZATION
;
908 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
909 receive the signal. A different setting is inheritable */
910 signal (SIGCHLD
, SIG_DFL
);
913 /* Unlock the stdio streams. */
914 unlock_std_streams ();
918 diagnostic_initialize (global_dc
, 0);
920 if (atexit (collect_atexit
) != 0)
921 fatal_error (input_location
, "atexit failed");
923 /* Do not invoke xcalloc before this point, since locale needs to be
924 set first, in case a diagnostic is issued. */
926 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
927 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
928 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
929 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
930 object_lst
= XCNEWVEC (char *, argc
);
931 object
= CONST_CAST2 (const char **, char **, object_lst
);
940 #ifndef DEFAULT_A_OUT_NAME
941 output_file
= "a.out";
943 output_file
= DEFAULT_A_OUT_NAME
;
946 /* Parse command line / environment for flags we want early.
947 This allows the debug flag to be set before functions like find_a_file()
950 bool no_partition
= false;
952 for (i
= 1; argv
[i
] != NULL
; i
++)
954 if (! strcmp (argv
[i
], "-debug"))
956 else if (!strncmp (argv
[i
], "-fno-lto", 8))
957 lto_mode
= LTO_MODE_NONE
;
958 else if (! strcmp (argv
[i
], "-plugin"))
961 if (selected_linker
== USE_DEFAULT_LD
)
962 selected_linker
= USE_PLUGIN_LD
;
964 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
965 selected_linker
= USE_BFD_LD
;
966 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
967 selected_linker
= USE_GOLD_LD
;
968 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
969 selected_linker
= USE_LLD_LD
;
970 else if (strncmp (argv
[i
], "-o", 2) == 0)
972 /* Parse the output filename if it's given so that we can make
973 meaningful temp filenames. */
974 if (argv
[i
][2] == '\0')
975 output_file
= argv
[i
+1];
977 output_file
= &argv
[i
][2];
980 #ifdef COLLECT_EXPORT_LIST
981 /* These flags are position independent, although their order
982 is important - subsequent flags override earlier ones. */
983 else if (strcmp (argv
[i
], "-b64") == 0)
985 /* -bexport:filename always needs the :filename */
986 else if (strncmp (argv
[i
], "-bE:", 4) == 0
987 || strncmp (argv
[i
], "-bexport:", 9) == 0)
989 else if (strcmp (argv
[i
], "-brtl") == 0
990 || strcmp (argv
[i
], "-bsvr4") == 0
991 || strcmp (argv
[i
], "-G") == 0)
993 else if (strcmp (argv
[i
], "-bnortl") == 0)
995 else if (strcmp (argv
[i
], "-blazy") == 0)
1000 obstack_begin (&temporary_obstack
, 0);
1001 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1003 #ifndef HAVE_LD_DEMANGLE
1004 current_demangling_style
= auto_demangling
;
1007 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1008 The LTO options are passed here as are other options that might
1009 be unsuitable for ld (e.g. -save-temps). */
1010 p
= getenv ("COLLECT_GCC_OPTIONS");
1013 const char *q
= extract_string (&p
);
1014 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1016 if (strncmp (q
, "-flto-partition=none", 20) == 0)
1017 no_partition
= true;
1018 else if (strncmp (q
, "-fno-lto", 8) == 0)
1019 lto_mode
= LTO_MODE_NONE
;
1020 else if (strncmp (q
, "-save-temps", 11) == 0)
1021 /* FIXME: Honour =obj. */
1024 obstack_free (&temporary_obstack
, temporary_firstobj
);
1026 verbose
= verbose
|| debug
;
1027 save_temps
= save_temps
|| debug
;
1028 find_file_set_debug (debug
);
1030 lto_mode
= LTO_MODE_NONE
;
1031 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1032 lto_mode
= LTO_MODE_LTO
;
1035 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1036 -fno-exceptions -w -fno-whole-program */
1039 c_argv
= XCNEWVEC (char *, num_c_args
);
1040 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1043 fatal_error (input_location
, "no arguments");
1046 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1047 signal (SIGQUIT
, handler
);
1049 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1050 signal (SIGINT
, handler
);
1052 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1053 signal (SIGALRM
, handler
);
1056 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1057 signal (SIGHUP
, handler
);
1059 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1060 signal (SIGSEGV
, handler
);
1062 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1063 signal (SIGBUS
, handler
);
1066 /* Extract COMPILER_PATH and PATH into our prefix list. */
1067 prefix_from_env ("COMPILER_PATH", &cpath
);
1068 prefix_from_env ("PATH", &path
);
1070 /* Try to discover a valid linker/nm/strip to use. */
1072 /* Maybe we know the right file to use (if not cross). */
1074 #ifdef DEFAULT_LINKER
1075 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1076 selected_linker
== USE_LLD_LD
)
1079 # ifdef HOST_EXECUTABLE_SUFFIX
1080 int len
= (sizeof (DEFAULT_LINKER
)
1081 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1085 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1086 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1087 HOST_EXECUTABLE_SUFFIX. */
1088 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1090 default_linker
[len
] = '\0';
1091 linker_name
= concat (default_linker
,
1092 &ld_suffixes
[selected_linker
][2],
1093 HOST_EXECUTABLE_SUFFIX
, NULL
);
1096 if (linker_name
== NULL
)
1098 linker_name
= concat (DEFAULT_LINKER
,
1099 &ld_suffixes
[selected_linker
][2],
1101 if (access (linker_name
, X_OK
) == 0)
1102 ld_file_name
= linker_name
;
1104 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1105 ld_file_name
= DEFAULT_LINKER
;
1106 if (ld_file_name
== 0)
1108 #ifdef REAL_LD_FILE_NAME
1109 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1110 if (ld_file_name
== 0)
1112 /* Search the (target-specific) compiler dirs for ld'. */
1113 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1114 /* Likewise for `collect-ld'. */
1115 if (ld_file_name
== 0)
1117 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1118 use_collect_ld
= ld_file_name
!= 0;
1120 /* Search the compiler directories for `ld'. We have protection against
1121 recursive calls in find_a_file. */
1122 if (ld_file_name
== 0)
1123 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1124 /* Search the ordinary system bin directories
1125 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1126 if (ld_file_name
== 0)
1127 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1129 #ifdef REAL_NM_FILE_NAME
1130 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1131 if (nm_file_name
== 0)
1133 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1134 if (nm_file_name
== 0)
1135 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1136 if (nm_file_name
== 0)
1137 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1138 if (nm_file_name
== 0)
1139 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1142 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1143 if (ldd_file_name
== 0)
1144 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1147 #ifdef REAL_STRIP_FILE_NAME
1148 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1149 if (strip_file_name
== 0)
1151 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1152 if (strip_file_name
== 0)
1153 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1154 if (strip_file_name
== 0)
1155 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1156 if (strip_file_name
== 0)
1157 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1159 /* Determine the full path name of the C compiler to use. */
1160 c_file_name
= getenv ("COLLECT_GCC");
1161 if (c_file_name
== 0)
1163 #ifdef CROSS_DIRECTORY_STRUCTURE
1164 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1166 c_file_name
= "gcc";
1170 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1172 /* Here it should be safe to use the system search path since we should have
1173 already qualified the name of the compiler when it is needed. */
1175 p
= find_a_file (&path
, c_file_name
, X_OK
);
1180 *ld1
++ = *ld2
++ = ld_file_name
;
1182 /* Make temp file names. */
1185 c_file
= concat (output_file
, ".cdtor.c", NULL
);
1186 o_file
= concat (output_file
, ".cdtor.o", NULL
);
1187 #ifdef COLLECT_EXPORT_LIST
1188 export_file
= concat (output_file
, ".x", NULL
);
1193 c_file
= make_temp_file (".cdtor.c");
1194 o_file
= make_temp_file (".cdtor.o");
1195 #ifdef COLLECT_EXPORT_LIST
1196 export_file
= make_temp_file (".x");
1199 /* Build the command line to compile the ctor/dtor list. */
1200 *c_ptr
++ = c_file_name
;
1207 #ifdef COLLECT_EXPORT_LIST
1208 /* Generate a list of directories from LIBPATH. */
1209 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1210 /* Add to this list also two standard directories where
1211 AIX loader always searches for libraries. */
1212 add_prefix (&libpath_lib_dirs
, "/lib");
1213 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1216 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1218 AIX support needs to know if -shared has been specified before
1219 parsing commandline arguments. */
1221 p
= getenv ("COLLECT_GCC_OPTIONS");
1224 const char *q
= extract_string (&p
);
1225 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1226 *c_ptr
++ = xstrdup (q
);
1227 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1228 *c_ptr
++ = xstrdup (q
);
1229 if (strcmp (q
, "-shared") == 0)
1231 if (strcmp (q
, "-static") == 0)
1233 if (*q
== '-' && q
[1] == 'B')
1235 *c_ptr
++ = xstrdup (q
);
1238 q
= extract_string (&p
);
1239 *c_ptr
++ = xstrdup (q
);
1243 obstack_free (&temporary_obstack
, temporary_firstobj
);
1244 *c_ptr
++ = "-fno-profile-arcs";
1245 *c_ptr
++ = "-fno-test-coverage";
1246 *c_ptr
++ = "-fno-branch-probabilities";
1247 *c_ptr
++ = "-fno-exceptions";
1249 *c_ptr
++ = "-fno-whole-program";
1251 /* !!! When GCC calls collect2,
1252 it does not know whether it is calling collect2 or ld.
1253 So collect2 cannot meaningfully understand any options
1254 except those ld understands.
1255 If you propose to make GCC pass some other option,
1256 just imagine what will happen if ld is really ld!!! */
1258 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1259 /* After the first file, put in the c++ rt0. */
1261 #ifdef COLLECT_EXPORT_LIST
1262 is_static
= static_obj
;
1265 while ((arg
= *++argv
) != (char *) 0)
1267 *ld1
++ = *ld2
++ = arg
;
1274 if (!strcmp (arg
, "-debug"))
1276 /* Already parsed. */
1280 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1283 *ld1
++ = *ld2
++ = *argv
;
1288 if (strncmp (arg
, "-flto", 5) == 0)
1291 /* Do not pass LTO flag to the linker. */
1295 error ("LTO support has not been enabled in this "
1299 else if (!use_collect_ld
1300 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1302 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1306 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1308 /* Do not pass -fno-lto to the linker. */
1312 #ifdef TARGET_AIX_VERSION
1315 /* File containing a list of input files to process. */
1318 char buf
[MAXPATHLEN
+ 2];
1319 /* Number of additionnal object files. */
1321 /* Maximum of additionnal object files before vector
1324 const char *list_filename
= arg
+ 2;
1326 /* Accept -fFILENAME and -f FILENAME. */
1327 if (*list_filename
== '\0' && argv
[1])
1330 list_filename
= *argv
;
1331 *ld1
++ = *ld2
++ = *argv
;
1334 stream
= fopen (list_filename
, "r");
1336 fatal_error (input_location
, "cannot open %s: %m",
1339 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1341 /* Remove end of line. */
1342 int len
= strlen (buf
);
1343 if (len
>= 1 && buf
[len
- 1] =='\n')
1344 buf
[len
- 1] = '\0';
1346 /* Put on object vector.
1347 Note: we only expanse vector here, so we must keep
1348 extra space for remaining arguments. */
1349 if (add_nbr
>= add_max
)
1352 object
- CONST_CAST2 (const char **, char **,
1354 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1355 object_lst
= XRESIZEVEC (char *, object_lst
,
1356 object_nbr
+ add_max
);
1357 object
= CONST_CAST2 (const char **, char **,
1359 object_nbr
+= add_max
;
1361 *object
++ = xstrdup (buf
);
1369 #ifdef COLLECT_EXPORT_LIST
1371 if (!strcmp (arg
, "-bstatic"))
1375 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1384 /* place o_file BEFORE this argument! */
1390 #ifdef COLLECT_EXPORT_LIST
1392 /* Resolving full library name. */
1393 const char *s
= resolve_lib_name (arg
+2);
1395 /* Saving a full library name. */
1396 add_to_list (&libs
, s
);
1398 add_to_list (&static_libs
, s
);
1403 #ifdef COLLECT_EXPORT_LIST
1404 /* Saving directories where to search for libraries. */
1406 add_prefix (&cmdline_lib_dirs
, arg
+2);
1412 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1414 output_file
= &arg
[2];
1423 if (arg
[2] == '\0' && do_collecting
)
1425 /* We must strip after the nm run, otherwise C++ linking
1426 will not work. Thus we strip in the second ld run, or
1427 else with strip if there is no second ld run. */
1439 if (strcmp (arg
, "--no-demangle") == 0)
1441 #ifndef HAVE_LD_DEMANGLE
1447 else if (strncmp (arg
, "--demangle", 10) == 0)
1449 #ifndef HAVE_LD_DEMANGLE
1453 enum demangling_styles style
1454 = cplus_demangle_name_to_style (arg
+11);
1455 if (style
== unknown_demangling
)
1456 error ("unknown demangling style %qs", arg
+11);
1458 current_demangling_style
= style
;
1464 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1465 target_system_root
= arg
+ 10;
1466 else if (strcmp (arg
, "--version") == 0)
1468 else if (strcmp (arg
, "--help") == 0)
1473 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1474 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1475 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1476 || strcmp (p
, ".obj") == 0))
1485 /* place o_file BEFORE this argument! */
1491 if (p
[1] == 'o' || p
[1] == 'l')
1493 #ifdef COLLECT_EXPORT_LIST
1494 /* libraries can be specified directly, i.e. without -l flag. */
1497 /* Saving a full library name. */
1498 add_to_list (&libs
, arg
);
1500 add_to_list (&static_libs
, arg
);
1506 #ifdef COLLECT_EXPORT_LIST
1507 /* This is added only for debugging purposes. */
1510 fprintf (stderr
, "List of libraries:\n");
1511 dump_list (stderr
, "\t", libs
.first
);
1512 fprintf (stderr
, "List of statically linked libraries:\n");
1513 dump_list (stderr
, "\t", static_libs
.first
);
1516 /* The AIX linker will discard static constructors in object files if
1517 nothing else in the file is referenced, so look at them first. Unless
1518 we are building a shared object, ignore the eh frame tables, as we
1519 would otherwise reference them all, hence drag all the corresponding
1520 objects even if nothing else is referenced. */
1522 const char **export_object_lst
1523 = CONST_CAST2 (const char **, char **, object_lst
);
1525 struct id
*list
= libs
.first
;
1527 /* Compute the filter to use from the current one, do scan, then adjust
1528 the "current" filter to remove what we just included here. This will
1529 control whether we need a first pass link later on or not, and what
1530 will remain to be scanned there. */
1532 scanfilter this_filter
= ld1_filter
;
1535 this_filter
&= ~SCAN_DWEH
;
1538 /* Scan object files. */
1539 while (export_object_lst
< object
)
1540 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1542 /* Scan libraries. */
1543 for (; list
; list
= list
->next
)
1544 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1546 ld1_filter
= ld1_filter
& ~this_filter
;
1551 char *buf
= concat ("-bE:", export_file
, NULL
);
1556 exportf
= fopen (export_file
, "w");
1557 if (exportf
== (FILE *) 0)
1558 fatal_error (input_location
, "fopen %s: %m", export_file
);
1559 write_aix_file (exportf
, exports
.first
);
1560 if (fclose (exportf
))
1561 fatal_error (input_location
, "fclose %s: %m", export_file
);
1566 *c_ptr
= *ld1
= *object
= (char *) 0;
1569 notice ("collect2 version %s\n", version_string
);
1573 printf ("Usage: collect2 [options]\n");
1574 printf (" Wrap linker and generate constructor code if needed.\n");
1575 printf (" Options:\n");
1576 printf (" -debug Enable debug output\n");
1577 printf (" --help Display this information\n");
1578 printf (" -v, --version Display this program's version number\n");
1580 printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1581 printf ("Report bugs: %s\n", bug_report_url
);
1588 fprintf (stderr
, "ld_file_name = %s\n",
1589 (ld_file_name
? ld_file_name
: "not found"));
1590 fprintf (stderr
, "c_file_name = %s\n",
1591 (c_file_name
? c_file_name
: "not found"));
1592 fprintf (stderr
, "nm_file_name = %s\n",
1593 (nm_file_name
? nm_file_name
: "not found"));
1595 fprintf (stderr
, "ldd_file_name = %s\n",
1596 (ldd_file_name
? ldd_file_name
: "not found"));
1598 fprintf (stderr
, "strip_file_name = %s\n",
1599 (strip_file_name
? strip_file_name
: "not found"));
1600 fprintf (stderr
, "c_file = %s\n",
1601 (c_file
? c_file
: "not found"));
1602 fprintf (stderr
, "o_file = %s\n",
1603 (o_file
? o_file
: "not found"));
1605 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1607 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1609 ptr
= getenv ("COLLECT_GCC");
1611 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1613 ptr
= getenv ("COMPILER_PATH");
1615 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1617 ptr
= getenv (LIBRARY_PATH_ENV
);
1619 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1621 fprintf (stderr
, "\n");
1624 /* Load the program, searching all libraries and attempting to provide
1625 undefined symbols from repository information.
1627 If -r or they will be run via some other method, do not build the
1628 constructor or destructor list, just return now. */
1631 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1633 /* Perform the first pass link now, if we're about to exit or if we need
1634 to scan for things we haven't collected yet before pursuing further.
1636 On AIX, the latter typically includes nothing for shared objects or
1637 frame tables for an executable, out of what the required early scan on
1638 objects and libraries has performed above. In the !shared_obj case, we
1639 expect the relevant tables to be dragged together with their associated
1640 functions from precise cross reference insertions by the compiler. */
1642 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1647 #ifdef COLLECT_EXPORT_LIST
1648 /* Make sure we delete the export file we may have created. */
1649 if (export_file
!= 0 && export_file
[0])
1650 maybe_unlink (export_file
);
1652 if (lto_mode
!= LTO_MODE_NONE
)
1653 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1655 post_ld_pass (/*temp_file*/false);
1661 /* Unless we have done it all already, examine the namelist and search for
1662 static constructors and destructors to call. Write the constructor and
1663 destructor tables to a .s file and reload. */
1665 if (ld1_filter
!= SCAN_NOTHING
)
1666 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1668 #ifdef SCAN_LIBRARIES
1669 scan_libraries (output_file
);
1674 notice_translated (ngettext ("%d constructor found\n",
1675 "%d constructors found\n",
1676 constructors
.number
),
1677 constructors
.number
);
1678 notice_translated (ngettext ("%d destructor found\n",
1679 "%d destructors found\n",
1680 destructors
.number
),
1681 destructors
.number
);
1682 notice_translated (ngettext ("%d frame table found\n",
1683 "%d frame tables found\n",
1684 frame_tables
.number
),
1685 frame_tables
.number
);
1688 /* If the scan exposed nothing of special interest, there's no need to
1689 generate the glue code and relink so return now. */
1691 if (constructors
.number
== 0 && destructors
.number
== 0
1692 && frame_tables
.number
== 0
1693 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1694 /* If we will be running these functions ourselves, we want to emit
1695 stubs into the shared library so that we do not have to relink
1696 dependent programs when we add static objects. */
1701 /* Do link without additional code generation now if we didn't
1702 do it earlier for scanning purposes. */
1703 if (ld1_filter
== SCAN_NOTHING
)
1707 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1709 /* Strip now if it was requested on the command line. */
1712 char **real_strip_argv
= XCNEWVEC (char *, 3);
1713 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1716 strip_argv
[0] = strip_file_name
;
1717 strip_argv
[1] = output_file
;
1718 strip_argv
[2] = (char *) 0;
1719 fork_execute ("strip", real_strip_argv
, false);
1722 #ifdef COLLECT_EXPORT_LIST
1723 maybe_unlink (export_file
);
1725 post_ld_pass (/*temp_file*/false);
1729 /* Sort ctor and dtor lists by priority. */
1730 sort_ids (&constructors
);
1731 sort_ids (&destructors
);
1733 maybe_unlink (output_file
);
1734 outf
= fopen (c_file
, "w");
1735 if (outf
== (FILE *) 0)
1736 fatal_error (input_location
, "fopen %s: %m", c_file
);
1738 write_c_file (outf
, c_file
);
1741 fatal_error (input_location
, "fclose %s: %m", c_file
);
1743 /* Tell the linker that we have initializer and finalizer functions. */
1744 #ifdef LD_INIT_SWITCH
1745 #ifdef COLLECT_EXPORT_LIST
1746 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1748 *ld2
++ = LD_INIT_SWITCH
;
1750 *ld2
++ = LD_FINI_SWITCH
;
1755 #ifdef COLLECT_EXPORT_LIST
1758 /* If we did not add export flag to link arguments before, add it to
1759 second link phase now. No new exports should have been added. */
1760 if (! exports
.first
)
1761 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1763 #ifdef TARGET_AIX_VERSION
1764 add_to_list (&exports
, aix_shared_initname
);
1765 add_to_list (&exports
, aix_shared_fininame
);
1768 #ifndef LD_INIT_SWITCH
1769 add_to_list (&exports
, initname
);
1770 add_to_list (&exports
, fininame
);
1771 add_to_list (&exports
, "_GLOBAL__DI");
1772 add_to_list (&exports
, "_GLOBAL__DD");
1774 exportf
= fopen (export_file
, "w");
1775 if (exportf
== (FILE *) 0)
1776 fatal_error (input_location
, "fopen %s: %m", export_file
);
1777 write_aix_file (exportf
, exports
.first
);
1778 if (fclose (exportf
))
1779 fatal_error (input_location
, "fclose %s: %m", export_file
);
1783 /* End of arguments to second link phase. */
1788 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1789 output_file
, c_file
);
1790 write_c_file (stderr
, "stderr");
1791 fprintf (stderr
, "========== end of c_file\n\n");
1792 #ifdef COLLECT_EXPORT_LIST
1793 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1794 write_aix_file (stderr
, exports
.first
);
1795 fprintf (stderr
, "========== end of export_file\n\n");
1799 /* Assemble the constructor and destructor tables.
1800 Link the tables in with the rest of the program. */
1802 fork_execute ("gcc", c_argv
, at_file_supplied
);
1803 #ifdef COLLECT_EXPORT_LIST
1804 /* On AIX we must call link because of possible templates resolution. */
1808 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1810 /* Otherwise, simply call ld because link is already done. */
1812 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1815 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1816 post_ld_pass (/*temp_file*/false);
1819 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1820 constructors/destructors in shared libraries. */
1821 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1828 /* Unlink FILE unless we are debugging or this is the output_file
1829 and we may not unlink it. */
1832 maybe_unlink (const char *file
)
1834 if (save_temps
&& file_exists (file
))
1837 notice ("[Leaving %s]\n", file
);
1841 if (file
== output_file
&& !may_unlink_output_file
)
1844 unlink_if_ordinary (file
);
1847 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1850 maybe_unlink_list (char **file_list
)
1852 char **tmp
= file_list
;
1855 maybe_unlink (*(tmp
++));
1859 static long sequence_number
= 0;
1861 /* Add a name to a linked list. */
1864 add_to_list (struct head
*head_ptr
, const char *name
)
1867 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1869 strcpy (newid
->name
, name
);
1871 if (head_ptr
->first
)
1872 head_ptr
->last
->next
= newid
;
1874 head_ptr
->first
= newid
;
1876 /* Check for duplicate symbols. */
1877 for (p
= head_ptr
->first
;
1878 strcmp (name
, p
->name
) != 0;
1883 head_ptr
->last
->next
= 0;
1888 newid
->sequence
= ++sequence_number
;
1889 head_ptr
->last
= newid
;
1893 /* Grab the init priority number from an init function name that
1894 looks like "_GLOBAL_.I.12345.foo". */
1897 extract_init_priority (const char *name
)
1901 #ifdef TARGET_AIX_VERSION
1902 /* Run dependent module initializers before any constructors in this
1904 switch (is_ctor_dtor (name
))
1914 while (name
[pos
] == '_')
1916 pos
+= 10; /* strlen ("GLOBAL__X_") */
1918 /* Extract init_p number from ctor/dtor name. */
1919 pri
= atoi (name
+ pos
);
1920 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1923 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1924 ctors will be run from right to left, dtors from left to right. */
1927 sort_ids (struct head
*head_ptr
)
1929 /* id holds the current element to insert. id_next holds the next
1930 element to insert. id_ptr iterates through the already sorted elements
1931 looking for the place to insert id. */
1932 struct id
*id
, *id_next
, **id_ptr
;
1934 id
= head_ptr
->first
;
1936 /* We don't have any sorted elements yet. */
1937 head_ptr
->first
= NULL
;
1939 for (; id
; id
= id_next
)
1942 id
->sequence
= extract_init_priority (id
->name
);
1944 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
1946 /* If the sequence numbers are the same, we put the id from the
1947 file later on the command line later in the list. */
1948 || id
->sequence
> (*id_ptr
)->sequence
1949 /* Hack: do lexical compare, too.
1950 || (id->sequence == (*id_ptr)->sequence
1951 && strcmp (id->name, (*id_ptr)->name) > 0) */
1960 /* Now set the sequence numbers properly so write_c_file works. */
1961 for (id
= head_ptr
->first
; id
; id
= id
->next
)
1962 id
->sequence
= ++sequence_number
;
1965 /* Write: `prefix', the names on list LIST, `suffix'. */
1968 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
1972 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
1977 #ifdef COLLECT_EXPORT_LIST
1978 /* This function is really used only on AIX, but may be useful. */
1980 is_in_list (const char *prefix
, struct id
*list
)
1984 if (!strcmp (prefix
, list
->name
)) return 1;
1989 #endif /* COLLECT_EXPORT_LIST */
1991 /* Added for debugging purpose. */
1992 #ifdef COLLECT_EXPORT_LIST
1994 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
1998 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2006 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2010 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2017 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2021 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2022 prefix
, list
->sequence
, list
->name
);
2027 /* Write out the constructor and destructor tables statically (for a shared
2028 object), along with the functions to execute them. */
2031 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2035 int frames
= (frame_tables
.number
> 0);
2037 /* Figure out name of output_file, stripping off .so version. */
2038 q
= p
= lbasename (output_file
);
2050 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2052 q
+= strlen (SHLIB_SUFFIX
);
2059 /* q points to null at end of the string (or . of the .so version) */
2060 prefix
= XNEWVEC (char, q
- p
+ 1);
2061 strncpy (prefix
, p
, q
- p
);
2063 for (r
= prefix
; *r
; r
++)
2064 if (!ISALNUM ((unsigned char)*r
))
2067 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2068 output_file
, prefix
);
2070 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2071 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2072 #ifdef TARGET_AIX_VERSION
2073 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2074 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2079 /* Write the tables as C code. */
2081 /* This count variable is used to prevent multiple calls to the
2082 constructors/destructors.
2083 This guard against multiple calls is important on AIX as the initfini
2084 functions are deliberately invoked multiple times as part of the
2085 mechanisms GCC uses to order constructors across different dependent
2086 shared libraries (see config/rs6000/aix.h).
2088 fprintf (stream
, "static int count;\n");
2089 fprintf (stream
, "typedef void entry_pt();\n");
2090 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2094 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2096 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2097 write_list (stream
, "\t\t&", frame_tables
.first
);
2098 fprintf (stream
, "\t0\n};\n");
2100 /* This must match what's in frame.h. */
2101 fprintf (stream
, "struct object {\n");
2102 fprintf (stream
, " void *pc_begin;\n");
2103 fprintf (stream
, " void *pc_end;\n");
2104 fprintf (stream
, " void *fde_begin;\n");
2105 fprintf (stream
, " void *fde_array;\n");
2106 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2107 fprintf (stream
, " struct object *next;\n");
2108 fprintf (stream
, "};\n");
2110 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2111 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2112 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2113 #ifdef TARGET_AIX_VERSION
2114 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2117 fprintf (stream
, "static void reg_frame () {\n");
2118 fprintf (stream
, "\tstatic struct object ob;\n");
2119 #ifdef TARGET_AIX_VERSION
2120 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2121 This might not be the start of the segment, signed offsets assumed.
2123 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2125 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2127 fprintf (stream
, "\t}\n");
2129 fprintf (stream
, "static void dereg_frame () {\n");
2130 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2131 fprintf (stream
, "\t}\n");
2134 fprintf (stream
, "void %s() {\n", initname
);
2135 if (constructors
.number
> 0 || frames
)
2137 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2138 write_list (stream
, "\t\t", constructors
.first
);
2140 fprintf (stream
, "\treg_frame,\n");
2141 fprintf (stream
, "\t};\n");
2142 fprintf (stream
, "\tentry_pt **p;\n");
2143 fprintf (stream
, "\tif (count++ != 0) return;\n");
2144 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2145 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2148 fprintf (stream
, "\t++count;\n");
2149 fprintf (stream
, "}\n");
2150 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2151 fprintf (stream
, "void %s() {\n", fininame
);
2152 if (destructors
.number
> 0 || frames
)
2154 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2155 write_list (stream
, "\t\t", destructors
.first
);
2157 fprintf (stream
, "\tdereg_frame,\n");
2158 fprintf (stream
, "\t};\n");
2159 fprintf (stream
, "\tentry_pt **p;\n");
2160 fprintf (stream
, "\tif (--count != 0) return;\n");
2161 fprintf (stream
, "\tp = dtors;\n");
2162 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2163 destructors
.number
+ frames
);
2165 fprintf (stream
, "}\n");
2169 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2170 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2174 /* Write the constructor/destructor tables. */
2176 #ifndef LD_INIT_SWITCH
2178 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2180 /* Write the tables as C code. */
2182 int frames
= (frame_tables
.number
> 0);
2184 fprintf (stream
, "typedef void entry_pt();\n\n");
2186 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2190 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2192 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2193 write_list (stream
, "\t\t&", frame_tables
.first
);
2194 fprintf (stream
, "\t0\n};\n");
2196 /* This must match what's in frame.h. */
2197 fprintf (stream
, "struct object {\n");
2198 fprintf (stream
, " void *pc_begin;\n");
2199 fprintf (stream
, " void *pc_end;\n");
2200 fprintf (stream
, " void *fde_begin;\n");
2201 fprintf (stream
, " void *fde_array;\n");
2202 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2203 fprintf (stream
, " struct object *next;\n");
2204 fprintf (stream
, "};\n");
2206 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2207 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2209 fprintf (stream
, "static void reg_frame () {\n");
2210 fprintf (stream
, "\tstatic struct object ob;\n");
2211 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2212 fprintf (stream
, "\t}\n");
2214 fprintf (stream
, "static void dereg_frame () {\n");
2215 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2216 fprintf (stream
, "\t}\n");
2219 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2220 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2221 write_list (stream
, "\t", constructors
.first
);
2223 fprintf (stream
, "\treg_frame,\n");
2224 fprintf (stream
, "\t0\n};\n\n");
2226 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2228 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2229 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2230 write_list (stream
, "\t", destructors
.first
);
2232 fprintf (stream
, "\tdereg_frame,\n");
2233 fprintf (stream
, "\t0\n};\n\n");
2235 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2236 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2238 #endif /* ! LD_INIT_SWITCH */
2241 write_c_file (FILE *stream
, const char *name
)
2243 #ifndef LD_INIT_SWITCH
2245 write_c_file_glob (stream
, name
);
2248 write_c_file_stat (stream
, name
);
2251 #ifdef COLLECT_EXPORT_LIST
2253 write_aix_file (FILE *stream
, struct id
*list
)
2255 for (; list
; list
= list
->next
)
2257 fputs (list
->name
, stream
);
2258 putc ('\n', stream
);
2263 #ifdef OBJECT_FORMAT_NONE
2265 /* Check to make sure the file is an LTO object file. */
2268 has_lto_section (void *data
, const char *name ATTRIBUTE_UNUSED
,
2269 off_t offset ATTRIBUTE_UNUSED
,
2270 off_t length ATTRIBUTE_UNUSED
)
2272 int *found
= (int *) data
;
2274 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
2275 sizeof (LTO_SECTION_NAME_PREFIX
) - 1) != 0)
2277 if (strncmp (name
, OFFLOAD_SECTION_NAME_PREFIX
,
2278 sizeof (OFFLOAD_SECTION_NAME_PREFIX
) - 1) != 0)
2284 /* Stop iteration. */
2289 is_lto_object_file (const char *prog_name
)
2295 int infd
= open (prog_name
, O_RDONLY
| O_BINARY
);
2300 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
2306 errmsg
= simple_object_find_sections (inobj
, has_lto_section
,
2307 (void *) &found
, &err
);
2308 if (! errmsg
&& found
)
2312 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
2316 /* Generic version to scan the name list of the loaded program for
2317 the symbols g++ uses for static constructors and destructors. */
2320 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2323 void (*int_handler
) (int);
2325 void (*quit_handler
) (int);
2327 char *real_nm_argv
[4];
2328 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2330 struct pex_obj
*pex
;
2336 if (which_pass
== PASS_SECOND
)
2339 /* LTO objects must be in a known format. This check prevents
2340 us from accepting an archive containing LTO objects, which
2341 gcc cannot currently handle. */
2342 if (which_pass
== PASS_LTOINFO
)
2344 if(is_lto_object_file (prog_name
)) {
2345 add_lto_object (<o_objects
, prog_name
);
2350 /* If we do not have an `nm', complain. */
2351 if (nm_file_name
== 0)
2352 fatal_error (input_location
, "cannot find %<nm%>");
2354 nm_argv
[argc
++] = nm_file_name
;
2355 if (NM_FLAGS
[0] != '\0')
2356 nm_argv
[argc
++] = NM_FLAGS
;
2358 nm_argv
[argc
++] = prog_name
;
2359 nm_argv
[argc
++] = (char *) 0;
2361 /* Trace if needed. */
2364 const char **p_argv
;
2367 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2368 fprintf (stderr
, " %s", str
);
2370 fprintf (stderr
, "\n");
2376 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2378 fatal_error (input_location
, "%<pex_init%> failed: %m");
2380 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2387 fatal_error (input_location
, "%s: %m", _(errmsg
));
2390 fatal_error (input_location
, errmsg
);
2393 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2395 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2398 inf
= pex_read_output (pex
, 0);
2400 fatal_error (input_location
, "cannot open nm output: %m");
2403 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2405 /* Read each line of nm output. */
2406 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2412 fprintf (stderr
, "\t%s\n", buf
);
2414 /* If it contains a constructor or destructor name, add the name
2415 to the appropriate list unless this is a kind of symbol we're
2416 not supposed to even consider. */
2418 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2419 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2426 /* Find the end of the symbol name.
2427 Do not include `|', because Encore nm can tack that on the end. */
2428 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2435 switch (is_ctor_dtor (name
))
2438 if (! (filter
& SCAN_CTOR
))
2440 if (which_pass
!= PASS_LIB
)
2441 add_to_list (&constructors
, name
);
2445 if (! (filter
& SCAN_DTOR
))
2447 if (which_pass
!= PASS_LIB
)
2448 add_to_list (&destructors
, name
);
2452 if (! (filter
& SCAN_INIT
))
2454 if (which_pass
!= PASS_LIB
)
2455 fatal_error (input_location
, "init function found in object %s",
2457 #ifndef LD_INIT_SWITCH
2458 add_to_list (&constructors
, name
);
2463 if (! (filter
& SCAN_FINI
))
2465 if (which_pass
!= PASS_LIB
)
2466 fatal_error (input_location
, "fini function found in object %s",
2468 #ifndef LD_FINI_SWITCH
2469 add_to_list (&destructors
, name
);
2474 if (! (filter
& SCAN_DWEH
))
2476 if (which_pass
!= PASS_LIB
)
2477 add_to_list (&frame_tables
, name
);
2480 default: /* not a constructor or destructor */
2486 fprintf (stderr
, "\n");
2488 do_wait (nm_file_name
, pex
);
2490 signal (SIGINT
, int_handler
);
2492 signal (SIGQUIT
, quit_handler
);
2498 /* Use the List Dynamic Dependencies program to find shared libraries that
2499 the output file depends upon and their initialization/finalization
2500 routines, if any. */
2503 scan_libraries (const char *prog_name
)
2505 static struct head libraries
; /* list of shared libraries found */
2507 void (*int_handler
) (int);
2509 void (*quit_handler
) (int);
2511 char *real_ldd_argv
[4];
2512 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2514 struct pex_obj
*pex
;
2520 /* If we do not have an `ldd', complain. */
2521 if (ldd_file_name
== 0)
2523 error ("cannot find %<ldd%>");
2527 ldd_argv
[argc
++] = ldd_file_name
;
2528 ldd_argv
[argc
++] = prog_name
;
2529 ldd_argv
[argc
++] = (char *) 0;
2531 /* Trace if needed. */
2534 const char **p_argv
;
2537 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2538 fprintf (stderr
, " %s", str
);
2540 fprintf (stderr
, "\n");
2546 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2548 fatal_error (input_location
, "pex_init failed: %m");
2550 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2556 fatal_error (input_location
, "%s: %m", _(errmsg
));
2559 fatal_error (input_location
, errmsg
);
2562 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2564 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2567 inf
= pex_read_output (pex
, 0);
2569 fatal_error (input_location
, "cannot open ldd output: %m");
2572 notice ("\nldd output with constructors/destructors.\n");
2574 /* Read each line of ldd output. */
2575 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2578 char *name
, *end
, *p
= buf
;
2580 /* Extract names of libraries and add to list. */
2581 PARSE_LDD_OUTPUT (p
);
2586 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2587 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2589 /* Find the end of the symbol name. */
2591 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2596 if (access (name
, R_OK
) == 0)
2597 add_to_list (&libraries
, name
);
2599 fatal_error (input_location
, "unable to open dynamic dependency "
2603 fprintf (stderr
, "\t%s\n", buf
);
2606 fprintf (stderr
, "\n");
2608 do_wait (ldd_file_name
, pex
);
2610 signal (SIGINT
, int_handler
);
2612 signal (SIGQUIT
, quit_handler
);
2615 /* Now iterate through the library list adding their symbols to
2617 for (list
= libraries
.first
; list
; list
= list
->next
)
2618 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2621 #endif /* LDD_SUFFIX */
2623 #endif /* OBJECT_FORMAT_NONE */
2627 * COFF specific stuff.
2630 #ifdef OBJECT_FORMAT_COFF
2632 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2633 # define GCC_SYMENT SYMENT
2634 # if defined (C_WEAKEXT)
2635 # define GCC_OK_SYMBOL(X) \
2636 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2637 ((X).n_scnum > N_UNDEF) && \
2639 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2640 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2641 # define GCC_UNDEF_SYMBOL(X) \
2642 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2643 ((X).n_scnum == N_UNDEF))
2645 # define GCC_OK_SYMBOL(X) \
2646 (((X).n_sclass == C_EXT) && \
2647 ((X).n_scnum > N_UNDEF) && \
2649 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2650 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2651 # define GCC_UNDEF_SYMBOL(X) \
2652 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2654 # define GCC_SYMINC(X) ((X).n_numaux+1)
2655 # define GCC_SYMZERO(X) 0
2657 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2658 #if TARGET_AIX_VERSION >= 51
2659 # define GCC_CHECK_HDR(X) \
2660 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2661 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2662 && !(HEADER (X).f_flags & F_LOADONLY))
2664 # define GCC_CHECK_HDR(X) \
2665 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2666 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2667 && !(HEADER (X).f_flags & F_LOADONLY))
2670 #ifdef COLLECT_EXPORT_LIST
2671 /* Array of standard AIX libraries which should not
2672 be scanned for ctors/dtors. */
2673 static const char *const aix_std_libs
[] = {
2681 "/usr/lib/libc_r.a",
2682 "/usr/lib/libm_r.a",
2683 "/usr/lib/threads/libc.a",
2684 "/usr/ccs/lib/libc.a",
2685 "/usr/ccs/lib/libm.a",
2686 "/usr/ccs/lib/libc_r.a",
2687 "/usr/ccs/lib/libm_r.a",
2691 /* This function checks the filename and returns 1
2692 if this name matches the location of a standard AIX library. */
2693 static int ignore_library (const char *);
2695 ignore_library (const char *name
)
2697 const char *const *p
;
2700 if (target_system_root
[0] != '\0')
2702 length
= strlen (target_system_root
);
2703 if (strncmp (name
, target_system_root
, length
) != 0)
2707 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2708 if (strcmp (name
, *p
) == 0)
2712 #endif /* COLLECT_EXPORT_LIST */
2714 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2715 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2718 /* COFF version to scan the name list of the loaded program for
2719 the symbols g++ uses for static constructors and destructors. */
2722 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2725 LDFILE
*ldptr
= NULL
;
2726 int sym_index
, sym_count
;
2729 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2732 #ifdef COLLECT_EXPORT_LIST
2733 /* We do not need scanning for some standard C libraries. */
2734 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2737 /* On AIX we have a loop, because there is not much difference
2738 between an object and an archive. This trick allows us to
2739 eliminate scan_libraries() function. */
2743 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2744 non-const char * filename parameter, even though it will not
2745 modify that string. So we must cast away const-ness here,
2746 using CONST_CAST to prevent complaints from -Wcast-qual. */
2747 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2749 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2750 fatal_error (input_location
, "%s: not a COFF file", prog_name
);
2752 if (GCC_CHECK_HDR (ldptr
))
2754 sym_count
= GCC_SYMBOLS (ldptr
);
2755 sym_index
= GCC_SYMZERO (ldptr
);
2757 #ifdef COLLECT_EXPORT_LIST
2758 /* Is current archive member a shared object? */
2759 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2762 while (sym_index
< sym_count
)
2766 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2768 sym_index
+= GCC_SYMINC (symbol
);
2770 if (GCC_OK_SYMBOL (symbol
))
2774 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2775 continue; /* Should never happen. */
2777 #ifdef XCOFF_DEBUGGING_INFO
2778 /* All AIX function names have a duplicate entry
2779 beginning with a dot. */
2784 switch (is_ctor_dtor (name
))
2786 #if TARGET_AIX_VERSION
2787 /* Add AIX shared library initalisers/finalisers
2788 to the constructors/destructors list of the
2791 if (! (filter
& SCAN_CTOR
))
2793 if (is_shared
&& !aixlazy_flag
2794 #ifdef COLLECT_EXPORT_LIST
2796 && ! is_in_list (prog_name
, static_libs
.first
)
2799 add_to_list (&constructors
, name
);
2803 if (! (filter
& SCAN_DTOR
))
2805 if (is_shared
&& !aixlazy_flag
)
2806 add_to_list (&destructors
, name
);
2811 if (! (filter
& SCAN_CTOR
))
2814 add_to_list (&constructors
, name
);
2815 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2816 if (which_pass
== PASS_OBJ
)
2817 add_to_list (&exports
, name
);
2822 if (! (filter
& SCAN_DTOR
))
2825 add_to_list (&destructors
, name
);
2826 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2827 if (which_pass
== PASS_OBJ
)
2828 add_to_list (&exports
, name
);
2832 #ifdef COLLECT_EXPORT_LIST
2834 if (! (filter
& SCAN_INIT
))
2836 #ifndef LD_INIT_SWITCH
2838 add_to_list (&constructors
, name
);
2843 if (! (filter
& SCAN_FINI
))
2845 #ifndef LD_INIT_SWITCH
2847 add_to_list (&destructors
, name
);
2853 if (! (filter
& SCAN_DWEH
))
2856 add_to_list (&frame_tables
, name
);
2857 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2858 if (which_pass
== PASS_OBJ
)
2859 add_to_list (&exports
, name
);
2863 default: /* not a constructor or destructor */
2864 #ifdef COLLECT_EXPORT_LIST
2865 /* Explicitly export all global symbols when
2866 building a shared object on AIX, but do not
2867 re-export symbols from another shared object
2868 and do not export symbols if the user
2869 provides an explicit export list. */
2870 if (shared_obj
&& !is_shared
2871 && which_pass
== PASS_OBJ
&& !export_flag
)
2873 /* Do not auto-export __dso_handle or
2874 __gcc_unwind_dbase. They are required
2875 to be local to each module. */
2876 if (strcmp(name
, "__dso_handle") != 0
2877 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2879 add_to_list (&exports
, name
);
2887 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2888 symbol
.n_scnum
, symbol
.n_sclass
,
2889 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2894 #ifdef COLLECT_EXPORT_LIST
2897 /* If archive contains both 32-bit and 64-bit objects,
2898 we want to skip objects in other mode so mismatch normal. */
2900 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2901 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2907 fatal_error (input_location
, "%s: cannot open as COFF file",
2910 #ifdef COLLECT_EXPORT_LIST
2911 /* On AIX loop continues while there are more members in archive. */
2913 while (ldclose (ldptr
) == FAILURE
);
2915 /* Otherwise we simply close ldptr. */
2916 (void) ldclose (ldptr
);
2919 #endif /* OBJECT_FORMAT_COFF */
2921 #ifdef COLLECT_EXPORT_LIST
2922 /* Given a library name without "lib" prefix, this function
2923 returns a full library name including a path. */
2925 resolve_lib_name (const char *name
)
2929 /* Library extensions for AIX dynamic linking. */
2930 const char * const libexts
[2] = {"a", "so"};
2932 for (i
= 0; libpaths
[i
]; i
++)
2933 if (libpaths
[i
]->max_len
> l
)
2934 l
= libpaths
[i
]->max_len
;
2936 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
2938 for (i
= 0; libpaths
[i
]; i
++)
2940 struct prefix_list
*list
= libpaths
[i
]->plist
;
2941 for (; list
; list
= list
->next
)
2943 /* The following lines are needed because path_prefix list
2944 may contain directories both with trailing DIR_SEPARATOR and
2947 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
2949 for (j
= 0; j
< 2; j
++)
2951 sprintf (lib_buf
, "%s%slib%s.%s",
2952 list
->prefix
, p
, name
,
2953 libexts
[(j
+ aixrtl_flag
) % 2]);
2954 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
2955 if (file_exists (lib_buf
))
2957 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
2964 fprintf (stderr
, "not found\n");
2966 fatal_error (input_location
, "library lib%s not found", name
);
2969 #endif /* COLLECT_EXPORT_LIST */
2971 #ifdef COLLECT_RUN_DSYMUTIL
2972 static int flag_dsym
= false;
2973 static int flag_idsym
= false;
2976 process_args (int *argcp
, char **argv
) {
2979 for (i
=0; i
<argc
; ++i
)
2981 if (strcmp (argv
[i
], "-dsym") == 0)
2984 /* Remove the flag, as we handle all processing for it. */
2987 argv
[j
] = argv
[j
+1];
2992 else if (strcmp (argv
[i
], "-idsym") == 0)
2995 /* Remove the flag, as we handle all processing for it. */
2998 argv
[j
] = argv
[j
+1];
3007 do_dsymutil (const char *output_file
) {
3008 const char *dsymutil
= DSYMUTIL
+ 1;
3009 struct pex_obj
*pex
;
3010 char **real_argv
= XCNEWVEC (char *, 3);
3011 const char ** argv
= CONST_CAST2 (const char **, char **,
3015 argv
[1] = output_file
;
3016 argv
[2] = (char *) 0;
3018 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3019 PEX_LAST
| PEX_SEARCH
, false);
3020 do_wait (dsymutil
, pex
);
3024 post_ld_pass (bool temp_file
) {
3025 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3028 do_dsymutil (output_file
);
3032 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3033 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }