1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2021 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 */
188 static int visibility_flag
; /* true if -fvisibility */
192 LTO_MODE_NONE
, /* Not doing LTO. */
193 LTO_MODE_LTO
, /* Normal LTO. */
194 LTO_MODE_WHOPR
/* WHOPR. */
197 /* Current LTO mode. */
199 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
201 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
204 bool helpflag
; /* true if --help */
206 static int shared_obj
; /* true if -shared */
207 static int static_obj
; /* true if -static */
209 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
210 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
211 #ifdef COLLECT_EXPORT_LIST
212 static const char *export_file
; /* <xxx>.x for AIX export list. */
214 static char **lto_o_files
; /* Output files for LTO. */
215 static const char *output_file
; /* Output file for ld. */
216 static const char *nm_file_name
; /* pathname of nm */
218 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
220 static const char *strip_file_name
; /* pathname of strip */
221 const char *c_file_name
; /* pathname of gcc */
222 static char *initname
, *fininame
; /* names of init and fini funcs */
225 #ifdef TARGET_AIX_VERSION
226 static char *aix_shared_initname
;
227 static char *aix_shared_fininame
; /* init/fini names as per the scheme
228 described in config/rs6000/aix.h */
231 static struct head constructors
; /* list of constructors found */
232 static struct head destructors
; /* list of destructors found */
233 #ifdef COLLECT_EXPORT_LIST
234 static struct head exports
; /* list of exported symbols */
236 static struct head frame_tables
; /* list of frame unwind info tables */
238 bool at_file_supplied
; /* Whether to use @file arguments */
240 struct obstack temporary_obstack
;
241 char * temporary_firstobj
;
243 /* A string that must be prepended to a target OS path in order to find
244 it on the host system. */
245 #ifdef TARGET_SYSTEM_ROOT
246 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
248 static const char *target_system_root
= "";
251 /* Whether we may unlink the output file, which should be set as soon as we
252 know we have successfully produced it. This is typically useful to prevent
253 blindly attempting to unlink a read-only output that the target linker
254 would leave untouched. */
255 bool may_unlink_output_file
= false;
257 #ifdef COLLECT_EXPORT_LIST
258 /* Lists to keep libraries to be scanned for global constructors/destructors. */
259 static struct head libs
; /* list of libraries */
260 static struct head static_libs
; /* list of statically linked libraries */
261 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
262 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
263 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
264 &libpath_lib_dirs
, NULL
};
267 /* List of names of object files containing LTO information.
268 These are a subset of the object file names appearing on the
269 command line, and must be identical, in the sense of pointer
270 equality, with the names passed to maybe_run_lto_and_relink(). */
274 const char *name
; /* Name of object file. */
275 struct lto_object
*next
; /* Next in linked list. */
278 struct lto_object_list
280 struct lto_object
*first
; /* First list element. */
281 struct lto_object
*last
; /* Last list element. */
284 static struct lto_object_list lto_objects
;
286 /* Special kinds of symbols that a name may denote. */
289 SYM_REGULAR
= 0, /* nothing special */
291 SYM_CTOR
= 1, /* constructor */
292 SYM_DTOR
= 2, /* destructor */
293 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
294 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
295 SYM_DWEH
= 5, /* DWARF exception handling table */
300 const char tool_name
[] = "collect2";
302 static symkind
is_ctor_dtor (const char *);
304 static void handler (int);
305 static void maybe_unlink_list (char **);
306 static void add_to_list (struct head
*, const char *);
307 static int extract_init_priority (const char *);
308 static void sort_ids (struct head
*);
309 static void write_list (FILE *, const char *, struct id
*);
310 #ifdef COLLECT_EXPORT_LIST
311 static void dump_list (FILE *, const char *, struct id
*);
314 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
316 static void write_list_with_asm (FILE *, const char *, struct id
*);
317 static void write_c_file (FILE *, const char *);
318 static void write_c_file_stat (FILE *, const char *);
319 #ifndef LD_INIT_SWITCH
320 static void write_c_file_glob (FILE *, const char *);
322 #ifdef SCAN_LIBRARIES
323 static void scan_libraries (const char *);
325 #ifdef COLLECT_EXPORT_LIST
326 static int is_in_list (const char *, struct id
*);
327 static void write_aix_file (FILE *, struct id
*);
328 static char *resolve_lib_name (const char *);
330 static char *extract_string (const char **);
331 static void post_ld_pass (bool);
332 static void process_args (int *argcp
, char **argv
);
334 /* Enumerations describing which pass this is for scanning the
338 PASS_FIRST
, /* without constructors */
339 PASS_OBJ
, /* individual objects */
340 PASS_LIB
, /* looking for shared libraries */
341 PASS_SECOND
, /* with constructors linked in */
342 PASS_LTOINFO
/* looking for objects with LTO info */
345 /* ... and which kinds of symbols are to be considered. */
347 enum scanfilter_masks
{
350 SCAN_CTOR
= 1 << SYM_CTOR
,
351 SCAN_DTOR
= 1 << SYM_DTOR
,
352 SCAN_INIT
= 1 << SYM_INIT
,
353 SCAN_FINI
= 1 << SYM_FINI
,
354 SCAN_DWEH
= 1 << SYM_DWEH
,
355 SCAN_AIXI
= 1 << SYM_AIXI
,
356 SCAN_AIXD
= 1 << SYM_AIXD
,
360 /* This type is used for parameters and variables which hold
361 combinations of the flags in enum scanfilter_masks. */
362 typedef int scanfilter
;
364 /* Scan the name list of the loaded program for the symbols g++ uses for
365 static constructors and destructors.
367 The SCANPASS argument tells which collect processing pass this is for and
368 the SCANFILTER argument tells which kinds of symbols to consider in this
369 pass. Symbols of a special kind not in the filter mask are considered as
372 The constructor table begins at __CTOR_LIST__ and contains a count of the
373 number of pointers (or -1 if the constructors are built in a separate
374 section by the linker), followed by the pointers to the constructor
375 functions, terminated with a null pointer. The destructor table has the
376 same format, and begins at __DTOR_LIST__. */
378 static void scan_prog_file (const char *, scanpass
, scanfilter
);
381 /* Delete tempfiles and exit function. */
384 tool_cleanup (bool from_signal
)
386 /* maybe_unlink may call notice, which is not signal safe. */
390 if (c_file
!= 0 && c_file
[0])
391 maybe_unlink (c_file
);
393 if (o_file
!= 0 && o_file
[0])
394 maybe_unlink (o_file
);
396 #ifdef COLLECT_EXPORT_LIST
397 if (export_file
!= 0 && export_file
[0])
398 maybe_unlink (export_file
);
402 maybe_unlink_list (lto_o_files
);
406 collect_atexit (void)
408 tool_cleanup (false);
416 signal (signo
, SIG_DFL
);
419 /* Notify user of a non-error, without translating the format string. */
421 notice_translated (const char *cmsgid
, ...)
425 va_start (ap
, cmsgid
);
426 vfprintf (stderr
, cmsgid
, ap
);
431 file_exists (const char *name
)
433 return access (name
, R_OK
) == 0;
436 /* Parse a reasonable subset of shell quoting syntax. */
439 extract_string (const char **pp
)
452 obstack_1grow (&temporary_obstack
, c
);
453 else if (! inside
&& c
== ' ')
455 else if (! inside
&& c
== '\\')
460 obstack_1grow (&temporary_obstack
, c
);
463 obstack_1grow (&temporary_obstack
, '\0');
465 return XOBFINISH (&temporary_obstack
, char *);
468 /* Return the kind of symbol denoted by name S. */
471 is_ctor_dtor (const char *s
)
473 struct names
{ const char *const name
; const int len
; symkind ret
;
474 const int two_underscores
; };
476 const struct names
*p
;
478 const char *orig_s
= s
;
480 static const struct names special
[] = {
481 #ifndef NO_DOLLAR_IN_LABEL
482 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
483 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
485 #ifndef NO_DOT_IN_LABEL
486 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
487 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
488 #endif /* NO_DOT_IN_LABEL */
489 #endif /* NO_DOLLAR_IN_LABEL */
490 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
491 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
492 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
493 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
494 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
495 #ifdef TARGET_AIX_VERSION
496 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
497 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
499 { NULL
, 0, SYM_REGULAR
, 0 }
502 while ((ch
= *s
) == '_')
508 for (p
= &special
[0]; p
->len
> 0; p
++)
511 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
512 && strncmp (s
, p
->name
, p
->len
) == 0)
520 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
521 and one from the PATH variable. */
523 static struct path_prefix cpath
, path
;
525 #ifdef CROSS_DIRECTORY_STRUCTURE
526 /* This is the name of the target machine. We use it to form the name
527 of the files to execute. */
529 static const char *const target_machine
= TARGET_MACHINE
;
532 /* Search for NAME using prefix list PPREFIX. We only look for executable
535 Return 0 if not found, otherwise return its name, allocated with malloc. */
537 #ifdef OBJECT_FORMAT_NONE
539 /* Add an entry for the object file NAME to object file list LIST.
540 New entries are added at the end of the list. The original pointer
541 value of NAME is preserved, i.e., no string copy is performed. */
544 add_lto_object (struct lto_object_list
*list
, const char *name
)
546 struct lto_object
*n
= XNEW (struct lto_object
);
551 list
->last
->next
= n
;
557 #endif /* OBJECT_FORMAT_NONE */
560 /* Perform a link-time recompilation and relink if any of the object
561 files contain LTO info. The linker command line LTO_LD_ARGV
562 represents the linker command that would produce a final executable
563 without the use of LTO. OBJECT_LST is a vector of object file names
564 appearing in LTO_LD_ARGV that are to be considered for link-time
565 recompilation, where OBJECT is a pointer to the last valid element.
566 (This awkward convention avoids an impedance mismatch with the
567 usage of similarly-named variables in main().) The elements of
568 OBJECT_LST must be identical, i.e., pointer equal, to the
569 corresponding arguments in LTO_LD_ARGV.
571 Upon entry, at least one linker run has been performed without the
572 use of any LTO info that might be present. Any recompilations
573 necessary for template instantiations have been performed, and
574 initializer/finalizer tables have been created if needed and
575 included in the linker command line LTO_LD_ARGV. If any of the
576 object files contain LTO info, we run the LTO back end on all such
577 files, and perform the final link with the LTO back end output
578 substituted for the LTO-optimized files. In some cases, a final
579 link with all link-time generated code has already been performed,
580 so there is no need to relink if no LTO info is found. In other
581 cases, our caller has not produced the final executable, and is
582 relying on us to perform the required link whether LTO info is
583 present or not. In that case, the FORCE argument should be true.
584 Note that the linker command line argument LTO_LD_ARGV passed into
585 this function may be modified in place. */
588 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
589 const char **object
, bool force
)
591 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
593 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
595 while (object_file
< object
)
597 /* If file contains LTO info, add it to the list of LTO objects. */
598 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
600 /* Increment the argument count by the number of object file arguments
601 we will add. An upper bound suffices, so just count all of the
602 object files regardless of whether they contain LTO info. */
606 if (lto_objects
.first
)
609 const char **lto_c_ptr
;
612 struct lto_object
*list
;
613 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
615 const char *prog
= "lto-wrapper";
616 int lto_ld_argv_size
= 0;
617 char **out_lto_ld_argv
;
618 int out_lto_ld_argv_size
;
622 fatal_error (input_location
, "environment variable "
623 "%<COLLECT_LTO_WRAPPER%> must be set");
627 /* There is at least one object file containing LTO info,
628 so we need to run the LTO back end and relink.
630 To do so we build updated ld arguments with first
631 LTO object replaced by all partitions and other LTO
634 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
635 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
637 *lto_c_ptr
++ = lto_wrapper
;
639 /* Add LTO objects to the wrapper command line. */
640 for (list
= lto_objects
.first
; list
; list
= list
->next
)
641 *lto_c_ptr
++ = list
->name
;
645 /* Run the LTO back end. */
646 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
647 at_file_supplied
, "lto_args");
654 stream
= pex_read_output (pex
, 0);
658 while ((c
= getc (stream
)) != EOF
)
660 obstack_1grow (&temporary_obstack
, c
);
665 /* signal handler may access uninitialized memory
666 and delete whatever it points to, if lto_o_files
667 is not allocated with calloc. */
668 lto_o_files
= XCNEWVEC (char *, num_files
+ 1);
669 lto_o_files
[num_files
] = NULL
;
670 start
= XOBFINISH (&temporary_obstack
, char *);
671 for (i
= 0; i
< num_files
; ++i
)
678 lto_o_files
[i
] = xstrdup (start
);
683 obstack_free (&temporary_obstack
, temporary_firstobj
);
688 /* Compute memory needed for new LD arguments. At most number of original arguments
689 plus number of partitions. */
690 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
692 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
693 out_lto_ld_argv_size
= 0;
695 /* After running the LTO back end, we will relink, substituting
696 the LTO output for the object files that we submitted to the
697 LTO. Here, we modify the linker command line for the relink. */
699 /* Copy all arguments until we find first LTO file. */
703 for (list
= lto_objects
.first
; list
; list
= list
->next
)
704 if (*p
== list
->name
) /* Note test for pointer equality! */
708 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
711 /* Now insert all LTO partitions. */
712 lto_o_ptr
= lto_o_files
;
714 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
716 /* ... and copy the rest. */
719 for (list
= lto_objects
.first
; list
; list
= list
->next
)
720 if (*p
== list
->name
) /* Note test for pointer equality! */
723 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
726 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
728 /* Run the linker again, this time replacing the object files
729 optimized by the LTO with the temporary file generated by the LTO. */
730 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
,
732 /* We assume that temp files were created, and therefore we need to take
733 that into account (maybe run dsymutil). */
734 post_ld_pass (/*temp_file*/true);
737 maybe_unlink_list (lto_o_files
);
741 /* Our caller is relying on us to do the link
742 even though there is no LTO back end work to be done. */
743 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
,
745 /* No LTO objects were found, so no new temp file. */
746 post_ld_pass (/*temp_file*/false);
749 post_ld_pass (false); /* No LTO objects were found, no temp file. */
751 /* Entry point for linker invoation. Called from main in collect2.c.
752 LD_ARGV is an array of arguments for the linker. */
755 do_link (char **ld_argv
, const char *atsuffix
)
758 const char *prog
= "ld";
759 pex
= collect_execute (prog
, ld_argv
, NULL
, NULL
,
760 PEX_LAST
| PEX_SEARCH
,
761 HAVE_GNU_LD
&& at_file_supplied
, atsuffix
);
762 int ret
= collect_wait (prog
, pex
);
765 error ("ld returned %d exit status", ret
);
770 /* We have just successfully produced an output file, so assume that we
771 may unlink it if need be for now on. */
772 may_unlink_output_file
= true;
779 main (int argc
, char **argv
)
789 } selected_linker
= USE_DEFAULT_LD
;
790 static const char *const ld_suffixes
[USE_LD_MAX
] =
798 static const char *const real_ld_suffix
= "real-ld";
799 static const char *const collect_ld_suffix
= "collect-ld";
800 static const char *const nm_suffix
= "nm";
801 static const char *const gnm_suffix
= "gnm";
803 static const char *const ldd_suffix
= LDD_SUFFIX
;
805 static const char *const strip_suffix
= "strip";
806 static const char *const gstrip_suffix
= "gstrip";
808 const char *full_ld_suffixes
[USE_LD_MAX
];
809 #ifdef CROSS_DIRECTORY_STRUCTURE
810 /* If we look for a program in the compiler directories, we just use
811 the short name, since these directories are already system-specific.
812 But it we look for a program in the system directories, we need to
813 qualify the program name with the target machine. */
815 const char *const full_nm_suffix
=
816 concat (target_machine
, "-", nm_suffix
, NULL
);
817 const char *const full_gnm_suffix
=
818 concat (target_machine
, "-", gnm_suffix
, NULL
);
820 const char *const full_ldd_suffix
=
821 concat (target_machine
, "-", ldd_suffix
, NULL
);
823 const char *const full_strip_suffix
=
824 concat (target_machine
, "-", strip_suffix
, NULL
);
825 const char *const full_gstrip_suffix
=
826 concat (target_machine
, "-", gstrip_suffix
, NULL
);
829 const char *const full_ldd_suffix
= ldd_suffix
;
831 const char *const full_nm_suffix
= nm_suffix
;
832 const char *const full_gnm_suffix
= gnm_suffix
;
833 const char *const full_strip_suffix
= strip_suffix
;
834 const char *const full_gstrip_suffix
= gstrip_suffix
;
835 #endif /* CROSS_DIRECTORY_STRUCTURE */
839 #ifdef COLLECT_EXPORT_LIST
842 const char *ld_file_name
;
848 bool use_plugin
= false;
849 bool use_collect_ld
= false;
851 /* The kinds of symbols we will have to consider when scanning the
852 outcome of a first pass link. This is ALL to start with, then might
853 be adjusted before getting to the first pass link per se, typically on
854 AIX where we perform an early scan of objects and libraries to fetch
855 the list of global ctors/dtors and make sure they are not garbage
857 scanfilter ld1_filter
= SCAN_ALL
;
863 #ifdef TARGET_AIX_VERSION
864 int object_nbr
= argc
;
869 #ifdef COLLECT_EXPORT_LIST
870 bool is_static
= false;
874 for (i
= 0; i
< USE_LD_MAX
; i
++)
876 #ifdef CROSS_DIRECTORY_STRUCTURE
877 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
882 p
= argv
[0] + strlen (argv
[0]);
883 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
887 xmalloc_set_program_name (progname
);
890 expandargv (&argc
, &argv
);
891 if (argv
!= old_argv
)
892 at_file_supplied
= 1;
894 process_args (&argc
, argv
);
896 num_c_args
= argc
+ 9;
898 #ifndef HAVE_LD_DEMANGLE
899 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
901 /* Suppress demangling by the real linker, which may be broken. */
902 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
905 #if defined (COLLECT2_HOST_INITIALIZATION)
906 /* Perform system dependent initialization, if necessary. */
907 COLLECT2_HOST_INITIALIZATION
;
911 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
912 receive the signal. A different setting is inheritable */
913 signal (SIGCHLD
, SIG_DFL
);
916 /* Unlock the stdio streams. */
917 unlock_std_streams ();
921 diagnostic_initialize (global_dc
, 0);
923 if (atexit (collect_atexit
) != 0)
924 fatal_error (input_location
, "atexit failed");
926 /* Do not invoke xcalloc before this point, since locale needs to be
927 set first, in case a diagnostic is issued. */
929 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
930 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
931 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
932 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
933 object_lst
= XCNEWVEC (char *, argc
);
934 object
= CONST_CAST2 (const char **, char **, object_lst
);
943 #ifndef DEFAULT_A_OUT_NAME
944 output_file
= "a.out";
946 output_file
= DEFAULT_A_OUT_NAME
;
949 /* Parse command line / environment for flags we want early.
950 This allows the debug flag to be set before functions like find_a_file()
953 bool no_partition
= false;
955 for (i
= 1; argv
[i
] != NULL
; i
++)
957 if (! strcmp (argv
[i
], "-debug"))
959 else if (startswith (argv
[i
], "-fno-lto"))
960 lto_mode
= LTO_MODE_NONE
;
961 else if (! strcmp (argv
[i
], "-plugin"))
964 if (selected_linker
== USE_DEFAULT_LD
)
965 selected_linker
= USE_PLUGIN_LD
;
967 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
968 selected_linker
= USE_BFD_LD
;
969 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
970 selected_linker
= USE_GOLD_LD
;
971 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
972 selected_linker
= USE_LLD_LD
;
973 else if (startswith (argv
[i
], "-o"))
975 /* Parse the output filename if it's given so that we can make
976 meaningful temp filenames. */
977 if (argv
[i
][2] != '\0')
978 output_file
= &argv
[i
][2];
979 else if (argv
[i
+1] != NULL
)
980 output_file
= argv
[++i
];
983 #ifdef COLLECT_EXPORT_LIST
984 /* These flags are position independent, although their order
985 is important - subsequent flags override earlier ones. */
986 else if (strcmp (argv
[i
], "-b64") == 0)
988 /* -bexport:filename always needs the :filename */
989 else if (startswith (argv
[i
], "-bE:")
990 || startswith (argv
[i
], "-bexport:"))
992 else if (strcmp (argv
[i
], "-brtl") == 0
993 || strcmp (argv
[i
], "-bsvr4") == 0
994 || strcmp (argv
[i
], "-G") == 0)
996 else if (strcmp (argv
[i
], "-bnortl") == 0)
998 else if (strcmp (argv
[i
], "-blazy") == 0)
1003 obstack_begin (&temporary_obstack
, 0);
1004 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1006 #ifndef HAVE_LD_DEMANGLE
1007 current_demangling_style
= auto_demangling
;
1010 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1011 The LTO options are passed here as are other options that might
1012 be unsuitable for ld (e.g. -save-temps). */
1013 p
= getenv ("COLLECT_GCC_OPTIONS");
1016 const char *q
= extract_string (&p
);
1017 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1019 if (startswith (q
, "-flto-partition=none"))
1020 no_partition
= true;
1021 else if (startswith (q
, "-fno-lto"))
1022 lto_mode
= LTO_MODE_NONE
;
1023 else if (startswith (q
, "-save-temps"))
1024 /* FIXME: Honour =obj. */
1026 else if (strcmp (q
, "-dumpdir") == 0)
1027 dumppfx
= xstrdup (extract_string (&p
));
1028 else if (strcmp (q
, "-o") == 0
1029 || strcmp (q
, "-B") == 0
1030 || strcmp (q
, "-isystem") == 0)
1031 (void) extract_string (&p
);
1033 obstack_free (&temporary_obstack
, temporary_firstobj
);
1035 verbose
= verbose
|| debug
;
1036 save_temps
= save_temps
|| debug
;
1037 find_file_set_debug (debug
);
1039 lto_mode
= LTO_MODE_NONE
;
1040 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1041 lto_mode
= LTO_MODE_LTO
;
1044 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1045 -fno-exceptions -w -fno-whole-program */
1048 c_argv
= XCNEWVEC (char *, num_c_args
);
1049 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1052 fatal_error (input_location
, "no arguments");
1055 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1056 signal (SIGQUIT
, handler
);
1058 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1059 signal (SIGINT
, handler
);
1061 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1062 signal (SIGALRM
, handler
);
1065 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1066 signal (SIGHUP
, handler
);
1068 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1069 signal (SIGSEGV
, handler
);
1071 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1072 signal (SIGBUS
, handler
);
1075 /* Extract COMPILER_PATH and PATH into our prefix list. */
1076 prefix_from_env ("COMPILER_PATH", &cpath
);
1077 prefix_from_env ("PATH", &path
);
1079 /* Try to discover a valid linker/nm/strip to use. */
1081 /* Maybe we know the right file to use (if not cross). */
1083 #ifdef DEFAULT_LINKER
1084 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1085 selected_linker
== USE_LLD_LD
)
1088 # ifdef HOST_EXECUTABLE_SUFFIX
1089 int len
= (sizeof (DEFAULT_LINKER
)
1090 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1094 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1095 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1096 HOST_EXECUTABLE_SUFFIX. */
1097 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1099 default_linker
[len
] = '\0';
1100 linker_name
= concat (default_linker
,
1101 &ld_suffixes
[selected_linker
][2],
1102 HOST_EXECUTABLE_SUFFIX
, NULL
);
1105 if (linker_name
== NULL
)
1107 linker_name
= concat (DEFAULT_LINKER
,
1108 &ld_suffixes
[selected_linker
][2],
1110 if (access (linker_name
, X_OK
) == 0)
1111 ld_file_name
= linker_name
;
1113 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1114 ld_file_name
= DEFAULT_LINKER
;
1115 if (ld_file_name
== 0)
1117 #ifdef REAL_LD_FILE_NAME
1118 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1119 if (ld_file_name
== 0)
1121 /* Search the (target-specific) compiler dirs for ld'. */
1122 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1123 /* Likewise for `collect-ld'. */
1124 if (ld_file_name
== 0)
1126 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1127 use_collect_ld
= ld_file_name
!= 0;
1129 /* Search the compiler directories for `ld'. We have protection against
1130 recursive calls in find_a_file. */
1131 if (ld_file_name
== 0)
1132 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1133 /* Search the ordinary system bin directories
1134 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1135 if (ld_file_name
== 0)
1136 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1138 #ifdef REAL_NM_FILE_NAME
1139 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1140 if (nm_file_name
== 0)
1142 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1143 if (nm_file_name
== 0)
1144 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1145 if (nm_file_name
== 0)
1146 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1147 if (nm_file_name
== 0)
1148 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1151 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1152 if (ldd_file_name
== 0)
1153 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1156 #ifdef REAL_STRIP_FILE_NAME
1157 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1158 if (strip_file_name
== 0)
1160 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1161 if (strip_file_name
== 0)
1162 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1163 if (strip_file_name
== 0)
1164 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1165 if (strip_file_name
== 0)
1166 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1168 /* Determine the full path name of the C compiler to use. */
1169 c_file_name
= getenv ("COLLECT_GCC");
1170 if (c_file_name
== 0)
1172 #ifdef CROSS_DIRECTORY_STRUCTURE
1173 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1175 c_file_name
= "gcc";
1179 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1181 /* Here it should be safe to use the system search path since we should have
1182 already qualified the name of the compiler when it is needed. */
1184 p
= find_a_file (&path
, c_file_name
, X_OK
);
1189 *ld1
++ = *ld2
++ = ld_file_name
;
1191 /* Make temp file names. */
1194 c_file
= concat (output_file
, ".cdtor.c", NULL
);
1195 o_file
= concat (output_file
, ".cdtor.o", NULL
);
1196 #ifdef COLLECT_EXPORT_LIST
1197 export_file
= concat (output_file
, ".x", NULL
);
1202 c_file
= make_temp_file (".cdtor.c");
1203 o_file
= make_temp_file (".cdtor.o");
1204 #ifdef COLLECT_EXPORT_LIST
1205 export_file
= make_temp_file (".x");
1208 /* Build the command line to compile the ctor/dtor list. */
1209 *c_ptr
++ = c_file_name
;
1216 #ifdef COLLECT_EXPORT_LIST
1217 /* Generate a list of directories from LIBPATH. */
1218 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1219 /* Add to this list also two standard directories where
1220 AIX loader always searches for libraries. */
1221 add_prefix (&libpath_lib_dirs
, "/lib");
1222 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1225 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1227 AIX support needs to know if -shared has been specified before
1228 parsing commandline arguments. */
1230 p
= getenv ("COLLECT_GCC_OPTIONS");
1233 const char *q
= extract_string (&p
);
1234 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1235 *c_ptr
++ = xstrdup (q
);
1236 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1237 *c_ptr
++ = xstrdup (q
);
1238 if (strcmp (q
, "-shared") == 0)
1240 if (strcmp (q
, "-static") == 0)
1242 if (*q
== '-' && q
[1] == 'B')
1244 *c_ptr
++ = xstrdup (q
);
1247 q
= extract_string (&p
);
1248 *c_ptr
++ = xstrdup (q
);
1251 else if (strcmp (q
, "-o") == 0
1252 || strcmp (q
, "-dumpdir") == 0
1253 || strcmp (q
, "-isystem") == 0)
1254 (void) extract_string (&p
);
1255 #ifdef COLLECT_EXPORT_LIST
1256 /* Detect any invocation with -fvisibility. */
1257 if (startswith (q
, "-fvisibility"))
1258 visibility_flag
= 1;
1261 obstack_free (&temporary_obstack
, temporary_firstobj
);
1262 *c_ptr
++ = "-fno-profile-arcs";
1263 *c_ptr
++ = "-fno-test-coverage";
1264 *c_ptr
++ = "-fno-branch-probabilities";
1265 *c_ptr
++ = "-fno-exceptions";
1267 *c_ptr
++ = "-fno-whole-program";
1269 /* !!! When GCC calls collect2,
1270 it does not know whether it is calling collect2 or ld.
1271 So collect2 cannot meaningfully understand any options
1272 except those ld understands.
1273 If you propose to make GCC pass some other option,
1274 just imagine what will happen if ld is really ld!!! */
1276 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1277 /* After the first file, put in the c++ rt0. */
1279 #ifdef COLLECT_EXPORT_LIST
1280 is_static
= static_obj
;
1283 while ((arg
= *++argv
) != (char *) 0)
1285 *ld1
++ = *ld2
++ = arg
;
1292 if (!strcmp (arg
, "-debug"))
1294 /* Already parsed. */
1298 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1301 *ld1
++ = *ld2
++ = *argv
;
1306 if (startswith (arg
, "-flto"))
1309 /* Do not pass LTO flag to the linker. */
1313 error ("LTO support has not been enabled in this "
1317 else if (!use_collect_ld
1318 && startswith (arg
, "-fuse-ld="))
1320 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1324 else if (startswith (arg
, "-fno-lto"))
1326 /* Do not pass -fno-lto to the linker. */
1330 #ifdef TARGET_AIX_VERSION
1333 /* File containing a list of input files to process. */
1336 char buf
[MAXPATHLEN
+ 2];
1337 /* Number of additionnal object files. */
1339 /* Maximum of additionnal object files before vector
1342 const char *list_filename
= arg
+ 2;
1344 /* Accept -fFILENAME and -f FILENAME. */
1345 if (*list_filename
== '\0' && argv
[1])
1348 list_filename
= *argv
;
1349 *ld1
++ = *ld2
++ = *argv
;
1352 stream
= fopen (list_filename
, "r");
1354 fatal_error (input_location
, "cannot open %s: %m",
1357 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1359 /* Remove end of line. */
1360 int len
= strlen (buf
);
1361 if (len
>= 1 && buf
[len
- 1] =='\n')
1362 buf
[len
- 1] = '\0';
1364 /* Put on object vector.
1365 Note: we only expanse vector here, so we must keep
1366 extra space for remaining arguments. */
1367 if (add_nbr
>= add_max
)
1370 object
- CONST_CAST2 (const char **, char **,
1372 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1373 object_lst
= XRESIZEVEC (char *, object_lst
,
1374 object_nbr
+ add_max
);
1375 object
= CONST_CAST2 (const char **, char **,
1377 object_nbr
+= add_max
;
1379 *object
++ = xstrdup (buf
);
1387 #ifdef COLLECT_EXPORT_LIST
1389 if (!strcmp (arg
, "-bstatic"))
1393 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1402 /* place o_file BEFORE this argument! */
1408 #ifdef COLLECT_EXPORT_LIST
1410 /* Resolving full library name. */
1411 const char *s
= resolve_lib_name (arg
+2);
1413 /* Saving a full library name. */
1414 add_to_list (&libs
, s
);
1416 add_to_list (&static_libs
, s
);
1421 #ifdef COLLECT_EXPORT_LIST
1422 /* Saving directories where to search for libraries. */
1424 add_prefix (&cmdline_lib_dirs
, arg
+2);
1430 output_file
= &arg
[2];
1432 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1441 if (arg
[2] == '\0' && do_collecting
)
1443 /* We must strip after the nm run, otherwise C++ linking
1444 will not work. Thus we strip in the second ld run, or
1445 else with strip if there is no second ld run. */
1457 if (strcmp (arg
, "--no-demangle") == 0)
1459 #ifndef HAVE_LD_DEMANGLE
1465 else if (startswith (arg
, "--demangle"))
1467 #ifndef HAVE_LD_DEMANGLE
1471 enum demangling_styles style
1472 = cplus_demangle_name_to_style (arg
+11);
1473 if (style
== unknown_demangling
)
1474 error ("unknown demangling style %qs", arg
+11);
1476 current_demangling_style
= style
;
1482 else if (startswith (arg
, "--sysroot="))
1483 target_system_root
= arg
+ 10;
1484 else if (strcmp (arg
, "--version") == 0)
1486 else if (strcmp (arg
, "--help") == 0)
1491 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1492 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1493 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1494 || strcmp (p
, ".obj") == 0))
1503 /* place o_file BEFORE this argument! */
1509 if (p
[1] == 'o' || p
[1] == 'l')
1511 #ifdef COLLECT_EXPORT_LIST
1512 /* libraries can be specified directly, i.e. without -l flag. */
1515 /* Saving a full library name. */
1516 add_to_list (&libs
, arg
);
1518 add_to_list (&static_libs
, arg
);
1524 #ifdef COLLECT_EXPORT_LIST
1525 /* This is added only for debugging purposes. */
1528 fprintf (stderr
, "List of libraries:\n");
1529 dump_list (stderr
, "\t", libs
.first
);
1530 fprintf (stderr
, "List of statically linked libraries:\n");
1531 dump_list (stderr
, "\t", static_libs
.first
);
1534 /* The AIX linker will discard static constructors in object files if
1535 nothing else in the file is referenced, so look at them first. Unless
1536 we are building a shared object, ignore the eh frame tables, as we
1537 would otherwise reference them all, hence drag all the corresponding
1538 objects even if nothing else is referenced. */
1540 const char **export_object_lst
1541 = CONST_CAST2 (const char **, char **, object_lst
);
1543 struct id
*list
= libs
.first
;
1545 /* Compute the filter to use from the current one, do scan, then adjust
1546 the "current" filter to remove what we just included here. This will
1547 control whether we need a first pass link later on or not, and what
1548 will remain to be scanned there. */
1550 scanfilter this_filter
= ld1_filter
;
1553 this_filter
&= ~SCAN_DWEH
;
1556 /* Scan object files. */
1557 while (export_object_lst
< object
)
1558 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1560 /* Scan libraries. */
1561 for (; list
; list
= list
->next
)
1562 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1564 ld1_filter
= ld1_filter
& ~this_filter
;
1569 char *buf
= concat ("-bE:", export_file
, NULL
);
1574 exportf
= fopen (export_file
, "w");
1575 if (exportf
== (FILE *) 0)
1576 fatal_error (input_location
, "fopen %s: %m", export_file
);
1577 write_aix_file (exportf
, exports
.first
);
1578 if (fclose (exportf
))
1579 fatal_error (input_location
, "fclose %s: %m", export_file
);
1584 *c_ptr
= *ld1
= *object
= (char *) 0;
1587 notice ("collect2 version %s\n", version_string
);
1591 printf ("Usage: collect2 [options]\n");
1592 printf (" Wrap linker and generate constructor code if needed.\n");
1593 printf (" Options:\n");
1594 printf (" -debug Enable debug output\n");
1595 printf (" --help Display this information\n");
1596 printf (" -v, --version Display this program's version number\n");
1598 printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1599 printf ("Report bugs: %s\n", bug_report_url
);
1606 fprintf (stderr
, "ld_file_name = %s\n",
1607 (ld_file_name
? ld_file_name
: "not found"));
1608 fprintf (stderr
, "c_file_name = %s\n",
1609 (c_file_name
? c_file_name
: "not found"));
1610 fprintf (stderr
, "nm_file_name = %s\n",
1611 (nm_file_name
? nm_file_name
: "not found"));
1613 fprintf (stderr
, "ldd_file_name = %s\n",
1614 (ldd_file_name
? ldd_file_name
: "not found"));
1616 fprintf (stderr
, "strip_file_name = %s\n",
1617 (strip_file_name
? strip_file_name
: "not found"));
1618 fprintf (stderr
, "c_file = %s\n",
1619 (c_file
? c_file
: "not found"));
1620 fprintf (stderr
, "o_file = %s\n",
1621 (o_file
? o_file
: "not found"));
1623 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1625 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1627 ptr
= getenv ("COLLECT_GCC");
1629 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1631 ptr
= getenv ("COMPILER_PATH");
1633 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1635 ptr
= getenv (LIBRARY_PATH_ENV
);
1637 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1639 fprintf (stderr
, "\n");
1642 /* Load the program, searching all libraries and attempting to provide
1643 undefined symbols from repository information.
1645 If -r or they will be run via some other method, do not build the
1646 constructor or destructor list, just return now. */
1649 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1651 /* Perform the first pass link now, if we're about to exit or if we need
1652 to scan for things we haven't collected yet before pursuing further.
1654 On AIX, the latter typically includes nothing for shared objects or
1655 frame tables for an executable, out of what the required early scan on
1656 objects and libraries has performed above. In the !shared_obj case, we
1657 expect the relevant tables to be dragged together with their associated
1658 functions from precise cross reference insertions by the compiler. */
1660 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1661 do_link (ld1_argv
, "ld1_args");
1665 #ifdef COLLECT_EXPORT_LIST
1666 /* Make sure we delete the export file we may have created. */
1667 if (export_file
!= 0 && export_file
[0])
1668 maybe_unlink (export_file
);
1670 if (lto_mode
!= LTO_MODE_NONE
)
1671 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1673 post_ld_pass (/*temp_file*/false);
1679 /* Unless we have done it all already, examine the namelist and search for
1680 static constructors and destructors to call. Write the constructor and
1681 destructor tables to a .s file and reload. */
1683 if (ld1_filter
!= SCAN_NOTHING
)
1684 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1686 #ifdef SCAN_LIBRARIES
1687 scan_libraries (output_file
);
1692 notice_translated (ngettext ("%d constructor found\n",
1693 "%d constructors found\n",
1694 constructors
.number
),
1695 constructors
.number
);
1696 notice_translated (ngettext ("%d destructor found\n",
1697 "%d destructors found\n",
1698 destructors
.number
),
1699 destructors
.number
);
1700 notice_translated (ngettext ("%d frame table found\n",
1701 "%d frame tables found\n",
1702 frame_tables
.number
),
1703 frame_tables
.number
);
1706 /* If the scan exposed nothing of special interest, there's no need to
1707 generate the glue code and relink so return now. */
1709 if (constructors
.number
== 0 && destructors
.number
== 0
1710 && frame_tables
.number
== 0
1711 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1712 /* If we will be running these functions ourselves, we want to emit
1713 stubs into the shared library so that we do not have to relink
1714 dependent programs when we add static objects. */
1719 /* Do link without additional code generation now if we didn't
1720 do it earlier for scanning purposes. */
1721 if (ld1_filter
== SCAN_NOTHING
)
1722 do_link (ld1_argv
, "ld1_args");
1725 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1727 /* Strip now if it was requested on the command line. */
1730 char **real_strip_argv
= XCNEWVEC (char *, 3);
1731 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1734 strip_argv
[0] = strip_file_name
;
1735 strip_argv
[1] = output_file
;
1736 strip_argv
[2] = (char *) 0;
1737 fork_execute ("strip", real_strip_argv
, false, NULL
);
1740 #ifdef COLLECT_EXPORT_LIST
1741 maybe_unlink (export_file
);
1743 post_ld_pass (/*temp_file*/false);
1747 /* Sort ctor and dtor lists by priority. */
1748 sort_ids (&constructors
);
1749 sort_ids (&destructors
);
1751 maybe_unlink (output_file
);
1752 outf
= fopen (c_file
, "w");
1753 if (outf
== (FILE *) 0)
1754 fatal_error (input_location
, "fopen %s: %m", c_file
);
1756 write_c_file (outf
, c_file
);
1759 fatal_error (input_location
, "fclose %s: %m", c_file
);
1761 /* Tell the linker that we have initializer and finalizer functions. */
1762 #ifdef LD_INIT_SWITCH
1763 #ifdef COLLECT_EXPORT_LIST
1764 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1766 *ld2
++ = LD_INIT_SWITCH
;
1768 *ld2
++ = LD_FINI_SWITCH
;
1773 #ifdef COLLECT_EXPORT_LIST
1776 /* If we did not add export flag to link arguments before, add it to
1777 second link phase now. No new exports should have been added. */
1778 if (! exports
.first
)
1779 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1781 #ifdef TARGET_AIX_VERSION
1782 add_to_list (&exports
, aix_shared_initname
);
1783 add_to_list (&exports
, aix_shared_fininame
);
1786 #ifndef LD_INIT_SWITCH
1787 add_to_list (&exports
, initname
);
1788 add_to_list (&exports
, fininame
);
1789 add_to_list (&exports
, "_GLOBAL__DI");
1790 add_to_list (&exports
, "_GLOBAL__DD");
1792 exportf
= fopen (export_file
, "w");
1793 if (exportf
== (FILE *) 0)
1794 fatal_error (input_location
, "fopen %s: %m", export_file
);
1795 write_aix_file (exportf
, exports
.first
);
1796 if (fclose (exportf
))
1797 fatal_error (input_location
, "fclose %s: %m", export_file
);
1801 /* End of arguments to second link phase. */
1806 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1807 output_file
, c_file
);
1808 write_c_file (stderr
, "stderr");
1809 fprintf (stderr
, "========== end of c_file\n\n");
1810 #ifdef COLLECT_EXPORT_LIST
1811 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1812 write_aix_file (stderr
, exports
.first
);
1813 fprintf (stderr
, "========== end of export_file\n\n");
1817 /* Assemble the constructor and destructor tables.
1818 Link the tables in with the rest of the program. */
1820 fork_execute ("gcc", c_argv
, at_file_supplied
, "gcc_args");
1821 #ifdef COLLECT_EXPORT_LIST
1822 /* On AIX we must call link because of possible templates resolution. */
1823 do_link (ld2_argv
, "ld2_args");
1826 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1828 /* Otherwise, simply call ld because link is already done. */
1830 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1833 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
, "ld_args");
1834 post_ld_pass (/*temp_file*/false);
1837 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1838 constructors/destructors in shared libraries. */
1839 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1846 /* Unlink FILE unless we are debugging or this is the output_file
1847 and we may not unlink it. */
1850 maybe_unlink (const char *file
)
1852 if (save_temps
&& file_exists (file
))
1855 notice ("[Leaving %s]\n", file
);
1859 if (file
== output_file
&& !may_unlink_output_file
)
1862 unlink_if_ordinary (file
);
1865 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1868 maybe_unlink_list (char **file_list
)
1870 char **tmp
= file_list
;
1873 maybe_unlink (*(tmp
++));
1877 static long sequence_number
= 0;
1879 /* Add a name to a linked list. */
1882 add_to_list (struct head
*head_ptr
, const char *name
)
1885 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1887 strcpy (newid
->name
, name
);
1889 if (head_ptr
->first
)
1890 head_ptr
->last
->next
= newid
;
1892 head_ptr
->first
= newid
;
1894 /* Check for duplicate symbols. */
1895 for (p
= head_ptr
->first
;
1896 strcmp (name
, p
->name
) != 0;
1901 head_ptr
->last
->next
= 0;
1906 newid
->sequence
= ++sequence_number
;
1907 head_ptr
->last
= newid
;
1911 /* Grab the init priority number from an init function name that
1912 looks like "_GLOBAL_.I.12345.foo". */
1915 extract_init_priority (const char *name
)
1919 #ifdef TARGET_AIX_VERSION
1920 /* Run dependent module initializers before any constructors in this
1922 switch (is_ctor_dtor (name
))
1932 while (name
[pos
] == '_')
1934 pos
+= 10; /* strlen ("GLOBAL__X_") */
1936 /* Extract init_p number from ctor/dtor name. */
1937 pri
= atoi (name
+ pos
);
1938 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1941 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1942 ctors will be run from right to left, dtors from left to right. */
1945 sort_ids (struct head
*head_ptr
)
1947 /* id holds the current element to insert. id_next holds the next
1948 element to insert. id_ptr iterates through the already sorted elements
1949 looking for the place to insert id. */
1950 struct id
*id
, *id_next
, **id_ptr
;
1952 id
= head_ptr
->first
;
1954 /* We don't have any sorted elements yet. */
1955 head_ptr
->first
= NULL
;
1957 for (; id
; id
= id_next
)
1960 id
->sequence
= extract_init_priority (id
->name
);
1962 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
1964 /* If the sequence numbers are the same, we put the id from the
1965 file later on the command line later in the list. */
1966 || id
->sequence
> (*id_ptr
)->sequence
1967 /* Hack: do lexical compare, too.
1968 || (id->sequence == (*id_ptr)->sequence
1969 && strcmp (id->name, (*id_ptr)->name) > 0) */
1978 /* Now set the sequence numbers properly so write_c_file works. */
1979 for (id
= head_ptr
->first
; id
; id
= id
->next
)
1980 id
->sequence
= ++sequence_number
;
1983 /* Write: `prefix', the names on list LIST, `suffix'. */
1986 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
1990 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
1995 #ifdef COLLECT_EXPORT_LIST
1996 /* This function is really used only on AIX, but may be useful. */
1998 is_in_list (const char *prefix
, struct id
*list
)
2002 if (!strcmp (prefix
, list
->name
)) return 1;
2007 #endif /* COLLECT_EXPORT_LIST */
2009 /* Added for debugging purpose. */
2010 #ifdef COLLECT_EXPORT_LIST
2012 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2016 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2024 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2028 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2035 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2039 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2040 prefix
, list
->sequence
, list
->name
);
2045 /* Write out the constructor and destructor tables statically (for a shared
2046 object), along with the functions to execute them. */
2049 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2053 int frames
= (frame_tables
.number
> 0);
2055 /* Figure out name of output_file, stripping off .so version. */
2056 q
= p
= lbasename (output_file
);
2068 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2070 q
+= strlen (SHLIB_SUFFIX
);
2077 /* q points to null at end of the string (or . of the .so version) */
2078 prefix
= XNEWVEC (char, q
- p
+ 1);
2079 strncpy (prefix
, p
, q
- p
);
2081 for (r
= prefix
; *r
; r
++)
2082 if (!ISALNUM ((unsigned char)*r
))
2085 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2086 output_file
, prefix
);
2088 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2089 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2090 #ifdef TARGET_AIX_VERSION
2091 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2092 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2097 /* Write the tables as C code. */
2099 /* This count variable is used to prevent multiple calls to the
2100 constructors/destructors.
2101 This guard against multiple calls is important on AIX as the initfini
2102 functions are deliberately invoked multiple times as part of the
2103 mechanisms GCC uses to order constructors across different dependent
2104 shared libraries (see config/rs6000/aix.h).
2106 fprintf (stream
, "static int count;\n");
2107 fprintf (stream
, "typedef void entry_pt();\n");
2108 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2112 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2114 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2115 write_list (stream
, "\t\t&", frame_tables
.first
);
2116 fprintf (stream
, "\t0\n};\n");
2118 /* This must match what's in frame.h. */
2119 fprintf (stream
, "struct object {\n");
2120 fprintf (stream
, " void *pc_begin;\n");
2121 fprintf (stream
, " void *pc_end;\n");
2122 fprintf (stream
, " void *fde_begin;\n");
2123 fprintf (stream
, " void *fde_array;\n");
2124 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2125 fprintf (stream
, " struct object *next;\n");
2126 fprintf (stream
, "};\n");
2128 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2129 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2130 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2131 #ifdef TARGET_AIX_VERSION
2132 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2135 fprintf (stream
, "static void reg_frame () {\n");
2136 fprintf (stream
, "\tstatic struct object ob;\n");
2137 #ifdef TARGET_AIX_VERSION
2138 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2139 This might not be the start of the segment, signed offsets assumed.
2141 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2143 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2145 fprintf (stream
, "\t}\n");
2147 fprintf (stream
, "static void dereg_frame () {\n");
2148 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2149 fprintf (stream
, "\t}\n");
2152 #ifdef COLLECT_EXPORT_LIST
2153 /* Set visibility of initializers to default. */
2154 if (visibility_flag
)
2155 fprintf (stream
, "#pragma GCC visibility push(default)\n");
2157 fprintf (stream
, "void %s() {\n", initname
);
2158 if (constructors
.number
> 0 || frames
)
2160 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2161 write_list (stream
, "\t\t", constructors
.first
);
2163 fprintf (stream
, "\treg_frame,\n");
2164 fprintf (stream
, "\t};\n");
2165 fprintf (stream
, "\tentry_pt **p;\n");
2166 fprintf (stream
, "\tif (count++ != 0) return;\n");
2167 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2168 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2171 fprintf (stream
, "\t++count;\n");
2172 fprintf (stream
, "}\n");
2173 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2174 fprintf (stream
, "void %s() {\n", fininame
);
2175 if (destructors
.number
> 0 || frames
)
2177 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2178 write_list (stream
, "\t\t", destructors
.first
);
2180 fprintf (stream
, "\tdereg_frame,\n");
2181 fprintf (stream
, "\t};\n");
2182 fprintf (stream
, "\tentry_pt **p;\n");
2183 fprintf (stream
, "\tif (--count != 0) return;\n");
2184 fprintf (stream
, "\tp = dtors;\n");
2185 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2186 destructors
.number
+ frames
);
2188 fprintf (stream
, "}\n");
2189 #ifdef COLLECT_EXPORT_LIST
2190 if (visibility_flag
)
2191 fprintf (stream
, "#pragma GCC visibility pop\n");
2196 #ifdef COLLECT_EXPORT_LIST
2197 /* Set visibility of initializers to default. */
2198 if (visibility_flag
)
2199 fprintf (stream
, "#pragma GCC visibility push(default)\n");
2201 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2202 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2203 #ifdef COLLECT_EXPORT_LIST
2204 if (visibility_flag
)
2205 fprintf (stream
, "#pragma GCC visibility pop\n");
2210 /* Write the constructor/destructor tables. */
2212 #ifndef LD_INIT_SWITCH
2214 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2216 /* Write the tables as C code. */
2218 int frames
= (frame_tables
.number
> 0);
2220 fprintf (stream
, "typedef void entry_pt();\n\n");
2222 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2226 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2228 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2229 write_list (stream
, "\t\t&", frame_tables
.first
);
2230 fprintf (stream
, "\t0\n};\n");
2232 /* This must match what's in frame.h. */
2233 fprintf (stream
, "struct object {\n");
2234 fprintf (stream
, " void *pc_begin;\n");
2235 fprintf (stream
, " void *pc_end;\n");
2236 fprintf (stream
, " void *fde_begin;\n");
2237 fprintf (stream
, " void *fde_array;\n");
2238 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2239 fprintf (stream
, " struct object *next;\n");
2240 fprintf (stream
, "};\n");
2242 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2243 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2245 fprintf (stream
, "static void reg_frame () {\n");
2246 fprintf (stream
, "\tstatic struct object ob;\n");
2247 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2248 fprintf (stream
, "\t}\n");
2250 fprintf (stream
, "static void dereg_frame () {\n");
2251 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2252 fprintf (stream
, "\t}\n");
2255 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2256 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2257 write_list (stream
, "\t", constructors
.first
);
2259 fprintf (stream
, "\treg_frame,\n");
2260 fprintf (stream
, "\t0\n};\n\n");
2262 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2264 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2265 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2266 write_list (stream
, "\t", destructors
.first
);
2268 fprintf (stream
, "\tdereg_frame,\n");
2269 fprintf (stream
, "\t0\n};\n\n");
2271 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2272 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2274 #endif /* ! LD_INIT_SWITCH */
2277 write_c_file (FILE *stream
, const char *name
)
2279 #ifndef LD_INIT_SWITCH
2281 write_c_file_glob (stream
, name
);
2284 write_c_file_stat (stream
, name
);
2287 #ifdef COLLECT_EXPORT_LIST
2289 write_aix_file (FILE *stream
, struct id
*list
)
2291 for (; list
; list
= list
->next
)
2293 fputs (list
->name
, stream
);
2294 putc ('\n', stream
);
2299 #ifdef OBJECT_FORMAT_NONE
2301 /* Check to make sure the file is an LTO object file. */
2304 has_lto_section (void *data
, const char *name ATTRIBUTE_UNUSED
,
2305 off_t offset ATTRIBUTE_UNUSED
,
2306 off_t length ATTRIBUTE_UNUSED
)
2308 int *found
= (int *) data
;
2310 if (!startswith (name
, LTO_SECTION_NAME_PREFIX
)
2311 && !startswith (name
, OFFLOAD_SECTION_NAME_PREFIX
))
2316 /* Stop iteration. */
2321 is_lto_object_file (const char *prog_name
)
2327 int infd
= open (prog_name
, O_RDONLY
| O_BINARY
);
2332 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
2338 errmsg
= simple_object_find_sections (inobj
, has_lto_section
,
2339 (void *) &found
, &err
);
2340 if (! errmsg
&& found
)
2344 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
2348 /* Generic version to scan the name list of the loaded program for
2349 the symbols g++ uses for static constructors and destructors. */
2352 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2355 void (*int_handler
) (int);
2357 void (*quit_handler
) (int);
2359 char *real_nm_argv
[4];
2360 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2362 struct pex_obj
*pex
;
2368 if (which_pass
== PASS_SECOND
)
2371 /* LTO objects must be in a known format. This check prevents
2372 us from accepting an archive containing LTO objects, which
2373 gcc cannot currently handle. */
2374 if (which_pass
== PASS_LTOINFO
)
2376 if(is_lto_object_file (prog_name
)) {
2377 add_lto_object (<o_objects
, prog_name
);
2382 /* If we do not have an `nm', complain. */
2383 if (nm_file_name
== 0)
2384 fatal_error (input_location
, "cannot find %<nm%>");
2386 nm_argv
[argc
++] = nm_file_name
;
2387 if (NM_FLAGS
[0] != '\0')
2388 nm_argv
[argc
++] = NM_FLAGS
;
2390 nm_argv
[argc
++] = prog_name
;
2391 nm_argv
[argc
++] = (char *) 0;
2393 /* Trace if needed. */
2396 const char **p_argv
;
2399 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2400 fprintf (stderr
, " %s", str
);
2402 fprintf (stderr
, "\n");
2408 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2410 fatal_error (input_location
, "%<pex_init%> failed: %m");
2412 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2419 fatal_error (input_location
, "%s: %m", _(errmsg
));
2422 fatal_error (input_location
, errmsg
);
2425 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2427 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2430 inf
= pex_read_output (pex
, 0);
2432 fatal_error (input_location
, "cannot open nm output: %m");
2435 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2437 /* Read each line of nm output. */
2438 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2444 fprintf (stderr
, "\t%s\n", buf
);
2446 /* If it contains a constructor or destructor name, add the name
2447 to the appropriate list unless this is a kind of symbol we're
2448 not supposed to even consider. */
2450 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2451 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2458 /* Find the end of the symbol name.
2459 Do not include `|', because Encore nm can tack that on the end. */
2460 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2467 switch (is_ctor_dtor (name
))
2470 if (! (filter
& SCAN_CTOR
))
2472 if (which_pass
!= PASS_LIB
)
2473 add_to_list (&constructors
, name
);
2477 if (! (filter
& SCAN_DTOR
))
2479 if (which_pass
!= PASS_LIB
)
2480 add_to_list (&destructors
, name
);
2484 if (! (filter
& SCAN_INIT
))
2486 if (which_pass
!= PASS_LIB
)
2487 fatal_error (input_location
, "init function found in object %s",
2489 #ifndef LD_INIT_SWITCH
2490 add_to_list (&constructors
, name
);
2495 if (! (filter
& SCAN_FINI
))
2497 if (which_pass
!= PASS_LIB
)
2498 fatal_error (input_location
, "fini function found in object %s",
2500 #ifndef LD_FINI_SWITCH
2501 add_to_list (&destructors
, name
);
2506 if (! (filter
& SCAN_DWEH
))
2508 if (which_pass
!= PASS_LIB
)
2509 add_to_list (&frame_tables
, name
);
2512 default: /* not a constructor or destructor */
2518 fprintf (stderr
, "\n");
2520 do_wait (nm_file_name
, pex
);
2522 signal (SIGINT
, int_handler
);
2524 signal (SIGQUIT
, quit_handler
);
2530 /* Use the List Dynamic Dependencies program to find shared libraries that
2531 the output file depends upon and their initialization/finalization
2532 routines, if any. */
2535 scan_libraries (const char *prog_name
)
2537 static struct head libraries
; /* list of shared libraries found */
2539 void (*int_handler
) (int);
2541 void (*quit_handler
) (int);
2543 char *real_ldd_argv
[4];
2544 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2546 struct pex_obj
*pex
;
2552 /* If we do not have an `ldd', complain. */
2553 if (ldd_file_name
== 0)
2555 error ("cannot find %<ldd%>");
2559 ldd_argv
[argc
++] = ldd_file_name
;
2560 ldd_argv
[argc
++] = prog_name
;
2561 ldd_argv
[argc
++] = (char *) 0;
2563 /* Trace if needed. */
2566 const char **p_argv
;
2569 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2570 fprintf (stderr
, " %s", str
);
2572 fprintf (stderr
, "\n");
2578 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2580 fatal_error (input_location
, "pex_init failed: %m");
2582 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2588 fatal_error (input_location
, "%s: %m", _(errmsg
));
2591 fatal_error (input_location
, errmsg
);
2594 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2596 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2599 inf
= pex_read_output (pex
, 0);
2601 fatal_error (input_location
, "cannot open ldd output: %m");
2604 notice ("\nldd output with constructors/destructors.\n");
2606 /* Read each line of ldd output. */
2607 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2610 char *name
, *end
, *p
= buf
;
2612 /* Extract names of libraries and add to list. */
2613 PARSE_LDD_OUTPUT (p
);
2618 if (startswith (name
, "not found"))
2619 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2621 /* Find the end of the symbol name. */
2623 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2628 if (access (name
, R_OK
) == 0)
2629 add_to_list (&libraries
, name
);
2631 fatal_error (input_location
, "unable to open dynamic dependency "
2635 fprintf (stderr
, "\t%s\n", buf
);
2638 fprintf (stderr
, "\n");
2640 do_wait (ldd_file_name
, pex
);
2642 signal (SIGINT
, int_handler
);
2644 signal (SIGQUIT
, quit_handler
);
2647 /* Now iterate through the library list adding their symbols to
2649 for (list
= libraries
.first
; list
; list
= list
->next
)
2650 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2653 #endif /* LDD_SUFFIX */
2655 #endif /* OBJECT_FORMAT_NONE */
2659 * COFF specific stuff.
2662 #ifdef OBJECT_FORMAT_COFF
2664 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2665 # define GCC_SYMENT SYMENT
2666 # if defined (C_WEAKEXT)
2667 # define GCC_OK_SYMBOL(X) \
2668 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2669 ((X).n_scnum > N_UNDEF) && \
2671 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2672 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2673 # define GCC_UNDEF_SYMBOL(X) \
2674 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2675 ((X).n_scnum == N_UNDEF))
2677 # define GCC_OK_SYMBOL(X) \
2678 (((X).n_sclass == C_EXT) && \
2679 ((X).n_scnum > N_UNDEF) && \
2681 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2682 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2683 # define GCC_UNDEF_SYMBOL(X) \
2684 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2686 # define GCC_SYMINC(X) ((X).n_numaux+1)
2687 # define GCC_SYMZERO(X) 0
2689 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2690 #if TARGET_AIX_VERSION >= 51
2691 # define GCC_CHECK_HDR(X) \
2692 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2693 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2694 && !(HEADER (X).f_flags & F_LOADONLY))
2696 # define GCC_CHECK_HDR(X) \
2697 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2698 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2699 && !(HEADER (X).f_flags & F_LOADONLY))
2702 #ifdef COLLECT_EXPORT_LIST
2703 /* Array of standard AIX libraries which should not
2704 be scanned for ctors/dtors. */
2705 static const char *const aix_std_libs
[] = {
2713 "/usr/lib/libc_r.a",
2714 "/usr/lib/libm_r.a",
2715 "/usr/lib/threads/libc.a",
2716 "/usr/ccs/lib/libc.a",
2717 "/usr/ccs/lib/libm.a",
2718 "/usr/ccs/lib/libc_r.a",
2719 "/usr/ccs/lib/libm_r.a",
2723 /* This function checks the filename and returns 1
2724 if this name matches the location of a standard AIX library. */
2725 static int ignore_library (const char *);
2727 ignore_library (const char *name
)
2729 const char *const *p
;
2732 if (target_system_root
[0] != '\0')
2734 length
= strlen (target_system_root
);
2735 if (strncmp (name
, target_system_root
, length
) != 0)
2739 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2740 if (strcmp (name
, *p
) == 0)
2744 #endif /* COLLECT_EXPORT_LIST */
2746 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2747 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2750 /* COFF version to scan the name list of the loaded program for
2751 the symbols g++ uses for static constructors and destructors. */
2754 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2757 LDFILE
*ldptr
= NULL
;
2758 int sym_index
, sym_count
;
2761 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2764 #ifdef COLLECT_EXPORT_LIST
2765 /* We do not need scanning for some standard C libraries. */
2766 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2769 /* On AIX we have a loop, because there is not much difference
2770 between an object and an archive. This trick allows us to
2771 eliminate scan_libraries() function. */
2775 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2776 non-const char * filename parameter, even though it will not
2777 modify that string. So we must cast away const-ness here,
2778 using CONST_CAST to prevent complaints from -Wcast-qual. */
2779 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2781 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2783 warning (0, "%s: not a COFF file", prog_name
);
2787 if (GCC_CHECK_HDR (ldptr
))
2789 sym_count
= GCC_SYMBOLS (ldptr
);
2790 sym_index
= GCC_SYMZERO (ldptr
);
2792 #ifdef COLLECT_EXPORT_LIST
2793 /* Is current archive member a shared object? */
2794 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2797 while (sym_index
< sym_count
)
2801 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2803 sym_index
+= GCC_SYMINC (symbol
);
2805 if (GCC_OK_SYMBOL (symbol
))
2809 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2810 continue; /* Should never happen. */
2812 #ifdef XCOFF_DEBUGGING_INFO
2813 /* All AIX function names have a duplicate entry
2814 beginning with a dot. */
2819 switch (is_ctor_dtor (name
))
2821 #if TARGET_AIX_VERSION
2822 /* Add AIX shared library initalisers/finalisers
2823 to the constructors/destructors list of the
2826 if (! (filter
& SCAN_CTOR
))
2828 if (is_shared
&& !aixlazy_flag
2829 #ifdef COLLECT_EXPORT_LIST
2831 && ! is_in_list (prog_name
, static_libs
.first
)
2834 add_to_list (&constructors
, name
);
2838 if (! (filter
& SCAN_DTOR
))
2840 if (is_shared
&& !aixlazy_flag
)
2841 add_to_list (&destructors
, name
);
2846 if (! (filter
& SCAN_CTOR
))
2849 add_to_list (&constructors
, name
);
2850 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2851 if (which_pass
== PASS_OBJ
)
2852 add_to_list (&exports
, name
);
2857 if (! (filter
& SCAN_DTOR
))
2860 add_to_list (&destructors
, name
);
2861 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2862 if (which_pass
== PASS_OBJ
)
2863 add_to_list (&exports
, name
);
2867 #ifdef COLLECT_EXPORT_LIST
2869 if (! (filter
& SCAN_INIT
))
2871 #ifndef LD_INIT_SWITCH
2873 add_to_list (&constructors
, name
);
2878 if (! (filter
& SCAN_FINI
))
2880 #ifndef LD_INIT_SWITCH
2882 add_to_list (&destructors
, name
);
2888 if (! (filter
& SCAN_DWEH
))
2891 add_to_list (&frame_tables
, name
);
2892 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2893 if (which_pass
== PASS_OBJ
)
2894 add_to_list (&exports
, name
);
2898 default: /* not a constructor or destructor */
2899 #ifdef COLLECT_EXPORT_LIST
2900 /* Explicitly export all global symbols when
2901 building a shared object on AIX, but do not
2902 re-export symbols from another shared object
2903 and do not export symbols if the user
2904 provides an explicit export list. */
2905 if (shared_obj
&& !is_shared
2906 && which_pass
== PASS_OBJ
&& !export_flag
)
2908 /* Do not auto-export __dso_handle or
2909 __gcc_unwind_dbase. They are required
2910 to be local to each module. */
2911 if (strcmp(name
, "__dso_handle") != 0
2912 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2914 add_to_list (&exports
, name
);
2922 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2923 symbol
.n_scnum
, symbol
.n_sclass
,
2924 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2929 #ifdef COLLECT_EXPORT_LIST
2932 /* If archive contains both 32-bit and 64-bit objects,
2933 we want to skip objects in other mode so mismatch normal. */
2935 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2936 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2942 fatal_error (input_location
, "%s: cannot open as COFF file",
2945 #ifdef COLLECT_EXPORT_LIST
2946 /* On AIX loop continues while there are more members in archive. */
2948 while (ldclose (ldptr
) == FAILURE
);
2950 /* Otherwise we simply close ldptr. */
2951 (void) ldclose (ldptr
);
2954 #endif /* OBJECT_FORMAT_COFF */
2956 #ifdef COLLECT_EXPORT_LIST
2957 /* Given a library name without "lib" prefix, this function
2958 returns a full library name including a path. */
2960 resolve_lib_name (const char *name
)
2964 /* Library extensions for AIX dynamic linking. */
2965 const char * const libexts
[2] = {"a", "so"};
2967 for (i
= 0; libpaths
[i
]; i
++)
2968 if (libpaths
[i
]->max_len
> l
)
2969 l
= libpaths
[i
]->max_len
;
2971 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
2973 for (i
= 0; libpaths
[i
]; i
++)
2975 struct prefix_list
*list
= libpaths
[i
]->plist
;
2976 for (; list
; list
= list
->next
)
2978 /* The following lines are needed because path_prefix list
2979 may contain directories both with trailing DIR_SEPARATOR and
2982 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
2984 for (j
= 0; j
< 2; j
++)
2986 sprintf (lib_buf
, "%s%slib%s.%s",
2987 list
->prefix
, p
, name
,
2988 libexts
[(j
+ aixrtl_flag
) % 2]);
2989 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
2990 if (file_exists (lib_buf
))
2992 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
2999 fprintf (stderr
, "not found\n");
3001 fatal_error (input_location
, "library lib%s not found", name
);
3004 #endif /* COLLECT_EXPORT_LIST */
3006 #ifdef COLLECT_RUN_DSYMUTIL
3007 static int flag_dsym
= false;
3008 static int flag_idsym
= false;
3011 process_args (int *argcp
, char **argv
) {
3014 for (i
=0; i
<argc
; ++i
)
3016 if (strcmp (argv
[i
], "-dsym") == 0)
3019 /* Remove the flag, as we handle all processing for it. */
3022 argv
[j
] = argv
[j
+1];
3027 else if (strcmp (argv
[i
], "-idsym") == 0)
3030 /* Remove the flag, as we handle all processing for it. */
3033 argv
[j
] = argv
[j
+1];
3042 do_dsymutil (const char *output_file
) {
3043 const char *dsymutil
= DSYMUTIL
+ 1;
3044 struct pex_obj
*pex
;
3045 char **real_argv
= XCNEWVEC (char *, 3);
3046 const char ** argv
= CONST_CAST2 (const char **, char **,
3050 argv
[1] = output_file
;
3051 argv
[2] = (char *) 0;
3053 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3054 PEX_LAST
| PEX_SEARCH
, false, NULL
);
3055 do_wait (dsymutil
, pex
);
3059 post_ld_pass (bool temp_file
) {
3060 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3063 do_dsymutil (output_file
);
3067 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3068 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }