1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
29 #include "coretypes.h"
31 #include "filenames.h"
32 #include "file-find.h"
34 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
45 #include "collect2-aix.h"
46 #include "collect-utils.h"
47 #include "diagnostic.h"
53 /* On certain systems, we have code that works by scanning the object file
54 directly. But this code uses system-specific header files and library
55 functions, so turn it off in a cross-compiler. Likewise, the names of
56 the utilities are not correct for a cross-compiler; we have to hope that
57 cross-versions are in the proper directories. */
59 #ifdef CROSS_DIRECTORY_STRUCTURE
60 #ifndef CROSS_AIX_SUPPORT
61 #undef OBJECT_FORMAT_COFF
64 #undef REAL_LD_FILE_NAME
65 #undef REAL_NM_FILE_NAME
66 #undef REAL_STRIP_FILE_NAME
69 /* If we cannot use a special method, use the ordinary one:
70 run nm to find what symbols are present.
71 In a cross-compiler, this means you need a cross nm,
72 but that is not quite as unpleasant as special headers. */
74 #if !defined (OBJECT_FORMAT_COFF)
75 #define OBJECT_FORMAT_NONE
78 #ifdef OBJECT_FORMAT_COFF
80 #ifndef CROSS_DIRECTORY_STRUCTURE
88 /* Many versions of ldfcn.h define these. */
97 /* Some systems have an ISCOFF macro, but others do not. In some cases
98 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
99 that either do not have an ISCOFF macro in /usr/include or for those
100 where it is wrong. */
103 #define MY_ISCOFF(X) ISCOFF (X)
106 #endif /* OBJECT_FORMAT_COFF */
108 #ifdef OBJECT_FORMAT_NONE
110 /* Default flags to pass to nm. */
112 #define NM_FLAGS "-n"
115 #endif /* OBJECT_FORMAT_NONE */
117 /* Some systems use __main in a way incompatible with its use in gcc, in these
118 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
119 give the same symbol without quotes for an alternative entry point. */
121 #define NAME__MAIN "__main"
124 /* This must match tree.h. */
125 #define DEFAULT_INIT_PRIORITY 65535
127 #ifndef COLLECT_SHARED_INIT_FUNC
128 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
129 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
131 #ifndef COLLECT_SHARED_FINI_FUNC
132 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
133 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
137 #define SCAN_LIBRARIES
141 #define SHLIB_SUFFIX ".so"
145 int do_collecting
= 1;
147 int do_collecting
= 0;
150 /* Cook up an always defined indication of whether we proceed the
151 "EXPORT_LIST" way. */
153 #ifdef COLLECT_EXPORT_LIST
154 #define DO_COLLECT_EXPORT_LIST 1
156 #define DO_COLLECT_EXPORT_LIST 0
159 /* Nonzero if we should suppress the automatic demangling of identifiers
160 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
163 /* Linked lists of constructor and destructor names. */
179 static int rflag
; /* true if -r */
180 static int strip_flag
; /* true if -s */
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag
; /* true if -bE */
183 static int aix64_flag
; /* true if -b64 */
184 static int aixrtl_flag
; /* true if -brtl */
185 static int aixlazy_flag
; /* true if -blazy */
189 LTO_MODE_NONE
, /* Not doing LTO. */
190 LTO_MODE_LTO
, /* Normal LTO. */
191 LTO_MODE_WHOPR
/* WHOPR. */
194 /* Current LTO mode. */
196 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
198 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
201 bool helpflag
; /* true if --help */
203 static int shared_obj
; /* true if -shared */
204 static int static_obj
; /* true if -static */
206 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
207 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
208 #ifdef COLLECT_EXPORT_LIST
209 static const char *export_file
; /* <xxx>.x for AIX export list. */
211 static char **lto_o_files
; /* Output files for LTO. */
212 const char *ldout
; /* File for ld stdout. */
213 const char *lderrout
; /* File for ld stderr. */
214 static const char *output_file
; /* Output file for ld. */
215 static const char *nm_file_name
; /* pathname of nm */
217 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
219 static const char *strip_file_name
; /* pathname of strip */
220 const char *c_file_name
; /* pathname of gcc */
221 static char *initname
, *fininame
; /* names of init and fini funcs */
224 #ifdef TARGET_AIX_VERSION
225 static char *aix_shared_initname
;
226 static char *aix_shared_fininame
; /* init/fini names as per the scheme
227 described in config/rs6000/aix.h */
230 static struct head constructors
; /* list of constructors found */
231 static struct head destructors
; /* list of destructors found */
232 #ifdef COLLECT_EXPORT_LIST
233 static struct head exports
; /* list of exported symbols */
235 static struct head frame_tables
; /* list of frame unwind info tables */
237 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 if (c_file
!= 0 && c_file
[0])
386 maybe_unlink (c_file
);
388 if (o_file
!= 0 && o_file
[0])
389 maybe_unlink (o_file
);
391 #ifdef COLLECT_EXPORT_LIST
392 if (export_file
!= 0 && export_file
[0])
393 maybe_unlink (export_file
);
397 maybe_unlink_list (lto_o_files
);
399 if (ldout
!= 0 && ldout
[0])
402 dump_ld_file (ldout
, stdout
);
403 maybe_unlink (ldout
);
406 if (lderrout
!= 0 && lderrout
[0])
409 dump_ld_file (lderrout
, stderr
);
410 maybe_unlink (lderrout
);
415 collect_atexit (void)
417 tool_cleanup (false);
425 signal (signo
, SIG_DFL
);
428 /* Notify user of a non-error, without translating the format string. */
430 notice_translated (const char *cmsgid
, ...)
434 va_start (ap
, cmsgid
);
435 vfprintf (stderr
, cmsgid
, ap
);
440 file_exists (const char *name
)
442 return access (name
, R_OK
) == 0;
445 /* Parse a reasonable subset of shell quoting syntax. */
448 extract_string (const char **pp
)
461 obstack_1grow (&temporary_obstack
, c
);
462 else if (! inside
&& c
== ' ')
464 else if (! inside
&& c
== '\\')
469 obstack_1grow (&temporary_obstack
, c
);
472 obstack_1grow (&temporary_obstack
, '\0');
474 return XOBFINISH (&temporary_obstack
, char *);
478 dump_ld_file (const char *name
, FILE *to
)
480 FILE *stream
= fopen (name
, "r");
487 while (c
= getc (stream
),
488 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
489 obstack_1grow (&temporary_obstack
, c
);
490 if (obstack_object_size (&temporary_obstack
) > 0)
492 const char *word
, *p
;
494 obstack_1grow (&temporary_obstack
, '\0');
495 word
= XOBFINISH (&temporary_obstack
, const char *);
498 ++word
, putc ('.', to
);
500 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
501 p
+= strlen (USER_LABEL_PREFIX
);
503 #ifdef HAVE_LD_DEMANGLE
509 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
517 diff
= strlen (word
) - strlen (result
);
518 while (diff
> 0 && c
== ' ')
519 --diff
, putc (' ', to
);
520 if (diff
< 0 && c
== ' ')
522 while (diff
< 0 && c
== ' ')
523 ++diff
, c
= getc (stream
);
526 /* Make sure we output at least one space, or
527 the demangled symbol name will run into
528 whatever text follows. */
539 obstack_free (&temporary_obstack
, temporary_firstobj
);
548 /* Return the kind of symbol denoted by name S. */
551 is_ctor_dtor (const char *s
)
553 struct names
{ const char *const name
; const int len
; symkind ret
;
554 const int two_underscores
; };
556 const struct names
*p
;
558 const char *orig_s
= s
;
560 static const struct names special
[] = {
561 #ifndef NO_DOLLAR_IN_LABEL
562 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
563 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
565 #ifndef NO_DOT_IN_LABEL
566 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
567 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
568 #endif /* NO_DOT_IN_LABEL */
569 #endif /* NO_DOLLAR_IN_LABEL */
570 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
571 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
572 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
573 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
574 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
575 #ifdef TARGET_AIX_VERSION
576 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
577 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
579 { NULL
, 0, SYM_REGULAR
, 0 }
582 while ((ch
= *s
) == '_')
588 for (p
= &special
[0]; p
->len
> 0; p
++)
591 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
592 && strncmp (s
, p
->name
, p
->len
) == 0)
600 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
601 and one from the PATH variable. */
603 static struct path_prefix cpath
, path
;
605 #ifdef CROSS_DIRECTORY_STRUCTURE
606 /* This is the name of the target machine. We use it to form the name
607 of the files to execute. */
609 static const char *const target_machine
= TARGET_MACHINE
;
612 /* Search for NAME using prefix list PPREFIX. We only look for executable
615 Return 0 if not found, otherwise return its name, allocated with malloc. */
617 #if defined (OBJECT_FORMAT_NONE) || defined (OBJECT_FORMAT_COFF)
619 /* Add an entry for the object file NAME to object file list LIST.
620 New entries are added at the end of the list. The original pointer
621 value of NAME is preserved, i.e., no string copy is performed. */
624 add_lto_object (struct lto_object_list
*list
, const char *name
)
626 struct lto_object
*n
= XNEW (struct lto_object
);
631 list
->last
->next
= n
;
640 /* Perform a link-time recompilation and relink if any of the object
641 files contain LTO info. The linker command line LTO_LD_ARGV
642 represents the linker command that would produce a final executable
643 without the use of LTO. OBJECT_LST is a vector of object file names
644 appearing in LTO_LD_ARGV that are to be considered for link-time
645 recompilation, where OBJECT is a pointer to the last valid element.
646 (This awkward convention avoids an impedance mismatch with the
647 usage of similarly-named variables in main().) The elements of
648 OBJECT_LST must be identical, i.e., pointer equal, to the
649 corresponding arguments in LTO_LD_ARGV.
651 Upon entry, at least one linker run has been performed without the
652 use of any LTO info that might be present. Any recompilations
653 necessary for template instantiations have been performed, and
654 initializer/finalizer tables have been created if needed and
655 included in the linker command line LTO_LD_ARGV. If any of the
656 object files contain LTO info, we run the LTO back end on all such
657 files, and perform the final link with the LTO back end output
658 substituted for the LTO-optimized files. In some cases, a final
659 link with all link-time generated code has already been performed,
660 so there is no need to relink if no LTO info is found. In other
661 cases, our caller has not produced the final executable, and is
662 relying on us to perform the required link whether LTO info is
663 present or not. In that case, the FORCE argument should be true.
664 Note that the linker command line argument LTO_LD_ARGV passed into
665 this function may be modified in place. */
668 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
669 const char **object
, bool force
)
671 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
673 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
675 while (object_file
< object
)
677 /* If file contains LTO info, add it to the list of LTO objects. */
678 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
680 /* Increment the argument count by the number of object file arguments
681 we will add. An upper bound suffices, so just count all of the
682 object files regardless of whether they contain LTO info. */
686 if (lto_objects
.first
)
689 const char **lto_c_ptr
;
692 struct lto_object
*list
;
693 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
695 const char *prog
= "lto-wrapper";
696 int lto_ld_argv_size
= 0;
697 char **out_lto_ld_argv
;
698 int out_lto_ld_argv_size
;
702 fatal_error (input_location
, "COLLECT_LTO_WRAPPER must be set");
706 /* There is at least one object file containing LTO info,
707 so we need to run the LTO back end and relink.
709 To do so we build updated ld arguments with first
710 LTO object replaced by all partitions and other LTO
713 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
714 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
716 *lto_c_ptr
++ = lto_wrapper
;
718 /* Add LTO objects to the wrapper command line. */
719 for (list
= lto_objects
.first
; list
; list
= list
->next
)
720 *lto_c_ptr
++ = list
->name
;
724 /* Run the LTO back end. */
725 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
733 stream
= pex_read_output (pex
, 0);
737 while ((c
= getc (stream
)) != EOF
)
739 obstack_1grow (&temporary_obstack
, c
);
744 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
745 lto_o_files
[num_files
] = NULL
;
746 start
= XOBFINISH (&temporary_obstack
, char *);
747 for (i
= 0; i
< num_files
; ++i
)
754 lto_o_files
[i
] = xstrdup (start
);
759 obstack_free (&temporary_obstack
, temporary_firstobj
);
764 /* Compute memory needed for new LD arguments. At most number of original arguments
765 plus number of partitions. */
766 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
768 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
769 out_lto_ld_argv_size
= 0;
771 /* After running the LTO back end, we will relink, substituting
772 the LTO output for the object files that we submitted to the
773 LTO. Here, we modify the linker command line for the relink. */
775 /* Copy all arguments until we find first LTO file. */
779 for (list
= lto_objects
.first
; list
; list
= list
->next
)
780 if (*p
== list
->name
) /* Note test for pointer equality! */
784 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
787 /* Now insert all LTO partitions. */
788 lto_o_ptr
= lto_o_files
;
790 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
792 /* ... and copy the rest. */
795 for (list
= lto_objects
.first
; list
; list
= list
->next
)
796 if (*p
== list
->name
) /* Note test for pointer equality! */
799 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
802 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
804 /* Run the linker again, this time replacing the object files
805 optimized by the LTO with the temporary file generated by the LTO. */
806 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
810 maybe_unlink_list (lto_o_files
);
814 /* Our caller is relying on us to do the link
815 even though there is no LTO back end work to be done. */
816 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
817 post_ld_pass (false);
826 main (int argc
, char **argv
)
836 } selected_linker
= USE_DEFAULT_LD
;
837 static const char *const ld_suffixes
[USE_LD_MAX
] =
845 static const char *const real_ld_suffix
= "real-ld";
846 static const char *const collect_ld_suffix
= "collect-ld";
847 static const char *const nm_suffix
= "nm";
848 static const char *const gnm_suffix
= "gnm";
850 static const char *const ldd_suffix
= LDD_SUFFIX
;
852 static const char *const strip_suffix
= "strip";
853 static const char *const gstrip_suffix
= "gstrip";
855 const char *full_ld_suffixes
[USE_LD_MAX
];
856 #ifdef CROSS_DIRECTORY_STRUCTURE
857 /* If we look for a program in the compiler directories, we just use
858 the short name, since these directories are already system-specific.
859 But it we look for a program in the system directories, we need to
860 qualify the program name with the target machine. */
862 const char *const full_nm_suffix
=
863 concat (target_machine
, "-", nm_suffix
, NULL
);
864 const char *const full_gnm_suffix
=
865 concat (target_machine
, "-", gnm_suffix
, NULL
);
867 const char *const full_ldd_suffix
=
868 concat (target_machine
, "-", ldd_suffix
, NULL
);
870 const char *const full_strip_suffix
=
871 concat (target_machine
, "-", strip_suffix
, NULL
);
872 const char *const full_gstrip_suffix
=
873 concat (target_machine
, "-", gstrip_suffix
, NULL
);
876 const char *const full_ldd_suffix
= ldd_suffix
;
878 const char *const full_nm_suffix
= nm_suffix
;
879 const char *const full_gnm_suffix
= gnm_suffix
;
880 const char *const full_strip_suffix
= strip_suffix
;
881 const char *const full_gstrip_suffix
= gstrip_suffix
;
882 #endif /* CROSS_DIRECTORY_STRUCTURE */
886 #ifdef COLLECT_EXPORT_LIST
889 const char *ld_file_name
;
895 bool use_plugin
= false;
896 bool use_collect_ld
= false;
898 /* The kinds of symbols we will have to consider when scanning the
899 outcome of a first pass link. This is ALL to start with, then might
900 be adjusted before getting to the first pass link per se, typically on
901 AIX where we perform an early scan of objects and libraries to fetch
902 the list of global ctors/dtors and make sure they are not garbage
904 scanfilter ld1_filter
= SCAN_ALL
;
910 #ifdef TARGET_AIX_VERSION
911 int object_nbr
= argc
;
916 #ifdef COLLECT_EXPORT_LIST
917 bool is_static
= false;
921 for (i
= 0; i
< USE_LD_MAX
; i
++)
923 #ifdef CROSS_DIRECTORY_STRUCTURE
924 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
929 p
= argv
[0] + strlen (argv
[0]);
930 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
934 xmalloc_set_program_name (progname
);
937 expandargv (&argc
, &argv
);
938 if (argv
!= old_argv
)
939 at_file_supplied
= 1;
941 process_args (&argc
, argv
);
943 num_c_args
= argc
+ 9;
945 #ifndef HAVE_LD_DEMANGLE
946 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
948 /* Suppress demangling by the real linker, which may be broken. */
949 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
952 #if defined (COLLECT2_HOST_INITIALIZATION)
953 /* Perform system dependent initialization, if necessary. */
954 COLLECT2_HOST_INITIALIZATION
;
958 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
959 receive the signal. A different setting is inheritable */
960 signal (SIGCHLD
, SIG_DFL
);
963 /* Unlock the stdio streams. */
964 unlock_std_streams ();
968 diagnostic_initialize (global_dc
, 0);
970 if (atexit (collect_atexit
) != 0)
971 fatal_error (input_location
, "atexit failed");
973 /* Do not invoke xcalloc before this point, since locale needs to be
974 set first, in case a diagnostic is issued. */
976 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
977 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
978 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
979 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
980 object_lst
= XCNEWVEC (char *, argc
);
981 object
= CONST_CAST2 (const char **, char **, object_lst
);
989 /* Parse command line / environment for flags we want early.
990 This allows the debug flag to be set before functions like find_a_file()
993 bool no_partition
= false;
995 for (i
= 1; argv
[i
] != NULL
; i
++)
997 if (! strcmp (argv
[i
], "-debug"))
999 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1000 lto_mode
= LTO_MODE_NONE
;
1001 else if (! strcmp (argv
[i
], "-plugin"))
1004 if (selected_linker
== USE_DEFAULT_LD
)
1005 selected_linker
= USE_PLUGIN_LD
;
1007 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1008 selected_linker
= USE_BFD_LD
;
1009 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1010 selected_linker
= USE_GOLD_LD
;
1011 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
1012 selected_linker
= USE_LLD_LD
;
1014 #ifdef COLLECT_EXPORT_LIST
1015 /* These flags are position independent, although their order
1016 is important - subsequent flags override earlier ones. */
1017 else if (strcmp (argv
[i
], "-b64") == 0)
1019 /* -bexport:filename always needs the :filename */
1020 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1021 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1023 else if (strcmp (argv
[i
], "-brtl") == 0
1024 || strcmp (argv
[i
], "-bsvr4") == 0
1025 || strcmp (argv
[i
], "-G") == 0)
1027 else if (strcmp (argv
[i
], "-bnortl") == 0)
1029 else if (strcmp (argv
[i
], "-blazy") == 0)
1034 #ifndef DEFAULT_A_OUT_NAME
1035 output_file
= "a.out";
1037 output_file
= DEFAULT_A_OUT_NAME
;
1040 obstack_begin (&temporary_obstack
, 0);
1041 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1043 #ifndef HAVE_LD_DEMANGLE
1044 current_demangling_style
= auto_demangling
;
1047 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1048 The LTO options are passed here as are other options that might
1049 be unsuitable for ld (e.g. -save-temps). */
1050 p
= getenv ("COLLECT_GCC_OPTIONS");
1053 const char *q
= extract_string (&p
);
1054 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1056 if (strncmp (q
, "-flto-partition=none", 20) == 0)
1057 no_partition
= true;
1058 else if (strncmp (q
, "-fno-lto", 8) == 0)
1059 lto_mode
= LTO_MODE_NONE
;
1061 obstack_free (&temporary_obstack
, temporary_firstobj
);
1063 verbose
= verbose
|| debug
;
1064 save_temps
= save_temps
|| debug
;
1065 find_file_set_debug (debug
);
1067 lto_mode
= LTO_MODE_NONE
;
1068 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1069 lto_mode
= LTO_MODE_LTO
;
1072 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1073 -fno-exceptions -w -fno-whole-program */
1076 c_argv
= XCNEWVEC (char *, num_c_args
);
1077 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1080 fatal_error (input_location
, "no arguments");
1083 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1084 signal (SIGQUIT
, handler
);
1086 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1087 signal (SIGINT
, handler
);
1089 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1090 signal (SIGALRM
, handler
);
1093 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1094 signal (SIGHUP
, handler
);
1096 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1097 signal (SIGSEGV
, handler
);
1099 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1100 signal (SIGBUS
, handler
);
1103 /* Extract COMPILER_PATH and PATH into our prefix list. */
1104 prefix_from_env ("COMPILER_PATH", &cpath
);
1105 prefix_from_env ("PATH", &path
);
1107 /* Try to discover a valid linker/nm/strip to use. */
1109 /* Maybe we know the right file to use (if not cross). */
1111 #ifdef DEFAULT_LINKER
1112 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1113 selected_linker
== USE_LLD_LD
)
1116 # ifdef HOST_EXECUTABLE_SUFFIX
1117 int len
= (sizeof (DEFAULT_LINKER
)
1118 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1122 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1123 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1124 HOST_EXECUTABLE_SUFFIX. */
1125 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1127 default_linker
[len
] = '\0';
1128 linker_name
= concat (default_linker
,
1129 &ld_suffixes
[selected_linker
][2],
1130 HOST_EXECUTABLE_SUFFIX
, NULL
);
1133 if (linker_name
== NULL
)
1135 linker_name
= concat (DEFAULT_LINKER
,
1136 &ld_suffixes
[selected_linker
][2],
1138 if (access (linker_name
, X_OK
) == 0)
1139 ld_file_name
= linker_name
;
1141 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1142 ld_file_name
= DEFAULT_LINKER
;
1143 if (ld_file_name
== 0)
1145 #ifdef REAL_LD_FILE_NAME
1146 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1147 if (ld_file_name
== 0)
1149 /* Search the (target-specific) compiler dirs for ld'. */
1150 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1151 /* Likewise for `collect-ld'. */
1152 if (ld_file_name
== 0)
1154 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1155 use_collect_ld
= ld_file_name
!= 0;
1157 /* Search the compiler directories for `ld'. We have protection against
1158 recursive calls in find_a_file. */
1159 if (ld_file_name
== 0)
1160 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1161 /* Search the ordinary system bin directories
1162 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1163 if (ld_file_name
== 0)
1164 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1166 #ifdef REAL_NM_FILE_NAME
1167 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1168 if (nm_file_name
== 0)
1170 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1171 if (nm_file_name
== 0)
1172 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1173 if (nm_file_name
== 0)
1174 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1175 if (nm_file_name
== 0)
1176 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1179 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1180 if (ldd_file_name
== 0)
1181 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1184 #ifdef REAL_STRIP_FILE_NAME
1185 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1186 if (strip_file_name
== 0)
1188 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1189 if (strip_file_name
== 0)
1190 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1191 if (strip_file_name
== 0)
1192 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1193 if (strip_file_name
== 0)
1194 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1196 /* Determine the full path name of the C compiler to use. */
1197 c_file_name
= getenv ("COLLECT_GCC");
1198 if (c_file_name
== 0)
1200 #ifdef CROSS_DIRECTORY_STRUCTURE
1201 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1203 c_file_name
= "gcc";
1207 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1209 /* Here it should be safe to use the system search path since we should have
1210 already qualified the name of the compiler when it is needed. */
1212 p
= find_a_file (&path
, c_file_name
, X_OK
);
1217 *ld1
++ = *ld2
++ = ld_file_name
;
1219 /* Make temp file names. */
1220 c_file
= make_temp_file (".c");
1221 o_file
= make_temp_file (".o");
1222 #ifdef COLLECT_EXPORT_LIST
1223 export_file
= make_temp_file (".x");
1227 ldout
= make_temp_file (".ld");
1228 lderrout
= make_temp_file (".le");
1230 *c_ptr
++ = c_file_name
;
1237 #ifdef COLLECT_EXPORT_LIST
1238 /* Generate a list of directories from LIBPATH. */
1239 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1240 /* Add to this list also two standard directories where
1241 AIX loader always searches for libraries. */
1242 add_prefix (&libpath_lib_dirs
, "/lib");
1243 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1246 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1248 AIX support needs to know if -shared has been specified before
1249 parsing commandline arguments. */
1251 p
= getenv ("COLLECT_GCC_OPTIONS");
1254 const char *q
= extract_string (&p
);
1255 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1256 *c_ptr
++ = xstrdup (q
);
1257 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1258 *c_ptr
++ = xstrdup (q
);
1259 if (strcmp (q
, "-shared") == 0)
1261 if (strcmp (q
, "-static") == 0)
1263 if (*q
== '-' && q
[1] == 'B')
1265 *c_ptr
++ = xstrdup (q
);
1268 q
= extract_string (&p
);
1269 *c_ptr
++ = xstrdup (q
);
1273 obstack_free (&temporary_obstack
, temporary_firstobj
);
1274 *c_ptr
++ = "-fno-profile-arcs";
1275 *c_ptr
++ = "-fno-test-coverage";
1276 *c_ptr
++ = "-fno-branch-probabilities";
1277 *c_ptr
++ = "-fno-exceptions";
1279 *c_ptr
++ = "-fno-whole-program";
1281 /* !!! When GCC calls collect2,
1282 it does not know whether it is calling collect2 or ld.
1283 So collect2 cannot meaningfully understand any options
1284 except those ld understands.
1285 If you propose to make GCC pass some other option,
1286 just imagine what will happen if ld is really ld!!! */
1288 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1289 /* After the first file, put in the c++ rt0. */
1291 #ifdef COLLECT_EXPORT_LIST
1292 is_static
= static_obj
;
1295 while ((arg
= *++argv
) != (char *) 0)
1297 *ld1
++ = *ld2
++ = arg
;
1304 if (!strcmp (arg
, "-debug"))
1306 /* Already parsed. */
1310 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1313 *ld1
++ = *ld2
++ = *argv
;
1318 if (strncmp (arg
, "-flto", 5) == 0)
1321 /* Do not pass LTO flag to the linker. */
1325 error ("LTO support has not been enabled in this "
1329 else if (!use_collect_ld
1330 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1332 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1336 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1338 /* Do not pass -fno-lto to the linker. */
1342 #ifdef TARGET_AIX_VERSION
1345 /* File containing a list of input files to process. */
1348 char buf
[MAXPATHLEN
+ 2];
1349 /* Number of additionnal object files. */
1351 /* Maximum of additionnal object files before vector
1354 const char *list_filename
= arg
+ 2;
1356 /* Accept -fFILENAME and -f FILENAME. */
1357 if (*list_filename
== '\0' && argv
[1])
1360 list_filename
= *argv
;
1361 *ld1
++ = *ld2
++ = *argv
;
1364 stream
= fopen (list_filename
, "r");
1366 fatal_error (input_location
, "can't open %s: %m",
1369 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1371 /* Remove end of line. */
1372 int len
= strlen (buf
);
1373 if (len
>= 1 && buf
[len
- 1] =='\n')
1374 buf
[len
- 1] = '\0';
1376 /* Put on object vector.
1377 Note: we only expanse vector here, so we must keep
1378 extra space for remaining arguments. */
1379 if (add_nbr
>= add_max
)
1382 object
- CONST_CAST2 (const char **, char **,
1384 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1385 object_lst
= XRESIZEVEC (char *, object_lst
,
1386 object_nbr
+ add_max
);
1387 object
= CONST_CAST2 (const char **, char **,
1389 object_nbr
+= add_max
;
1391 *object
++ = xstrdup (buf
);
1399 #ifdef COLLECT_EXPORT_LIST
1401 if (!strcmp (arg
, "-bstatic"))
1405 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1414 /* place o_file BEFORE this argument! */
1420 #ifdef COLLECT_EXPORT_LIST
1422 /* Resolving full library name. */
1423 const char *s
= resolve_lib_name (arg
+2);
1425 /* Saving a full library name. */
1426 add_to_list (&libs
, s
);
1428 add_to_list (&static_libs
, s
);
1433 #ifdef COLLECT_EXPORT_LIST
1434 /* Saving directories where to search for libraries. */
1436 add_prefix (&cmdline_lib_dirs
, arg
+2);
1442 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1444 output_file
= &arg
[2];
1453 if (arg
[2] == '\0' && do_collecting
)
1455 /* We must strip after the nm run, otherwise C++ linking
1456 will not work. Thus we strip in the second ld run, or
1457 else with strip if there is no second ld run. */
1469 if (strcmp (arg
, "--no-demangle") == 0)
1471 #ifndef HAVE_LD_DEMANGLE
1477 else if (strncmp (arg
, "--demangle", 10) == 0)
1479 #ifndef HAVE_LD_DEMANGLE
1483 enum demangling_styles style
1484 = cplus_demangle_name_to_style (arg
+11);
1485 if (style
== unknown_demangling
)
1486 error ("unknown demangling style '%s'", arg
+11);
1488 current_demangling_style
= style
;
1494 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1495 target_system_root
= arg
+ 10;
1496 else if (strcmp (arg
, "--version") == 0)
1498 else if (strcmp (arg
, "--help") == 0)
1503 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1504 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1505 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1506 || strcmp (p
, ".obj") == 0))
1515 /* place o_file BEFORE this argument! */
1521 if (p
[1] == 'o' || p
[1] == 'l')
1523 #ifdef COLLECT_EXPORT_LIST
1524 /* libraries can be specified directly, i.e. without -l flag. */
1527 /* Saving a full library name. */
1528 add_to_list (&libs
, arg
);
1530 add_to_list (&static_libs
, arg
);
1536 #ifdef COLLECT_EXPORT_LIST
1537 /* This is added only for debugging purposes. */
1540 fprintf (stderr
, "List of libraries:\n");
1541 dump_list (stderr
, "\t", libs
.first
);
1542 fprintf (stderr
, "List of statically linked libraries:\n");
1543 dump_list (stderr
, "\t", static_libs
.first
);
1546 /* The AIX linker will discard static constructors in object files if
1547 nothing else in the file is referenced, so look at them first. Unless
1548 we are building a shared object, ignore the eh frame tables, as we
1549 would otherwise reference them all, hence drag all the corresponding
1550 objects even if nothing else is referenced. */
1552 const char **export_object_lst
1553 = CONST_CAST2 (const char **, char **, object_lst
);
1555 struct id
*list
= libs
.first
;
1557 /* Compute the filter to use from the current one, do scan, then adjust
1558 the "current" filter to remove what we just included here. This will
1559 control whether we need a first pass link later on or not, and what
1560 will remain to be scanned there. */
1562 scanfilter this_filter
= ld1_filter
;
1565 this_filter
&= ~SCAN_DWEH
;
1568 /* Scan object files. */
1569 while (export_object_lst
< object
)
1570 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1572 /* Scan libraries. */
1573 for (; list
; list
= list
->next
)
1574 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1576 ld1_filter
= ld1_filter
& ~this_filter
;
1581 char *buf
= concat ("-bE:", export_file
, NULL
);
1586 exportf
= fopen (export_file
, "w");
1587 if (exportf
== (FILE *) 0)
1588 fatal_error (input_location
, "fopen %s: %m", export_file
);
1589 write_aix_file (exportf
, exports
.first
);
1590 if (fclose (exportf
))
1591 fatal_error (input_location
, "fclose %s: %m", export_file
);
1596 *c_ptr
= *ld1
= *object
= (char *) 0;
1599 notice ("collect2 version %s\n", version_string
);
1603 printf ("Usage: collect2 [options]\n");
1604 printf (" Wrap linker and generate constructor code if needed.\n");
1605 printf (" Options:\n");
1606 printf (" -debug Enable debug output\n");
1607 printf (" --help Display this information\n");
1608 printf (" -v, --version Display this program's version number\n");
1610 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1611 printf ("Report bugs: %s\n", bug_report_url
);
1618 fprintf (stderr
, "ld_file_name = %s\n",
1619 (ld_file_name
? ld_file_name
: "not found"));
1620 fprintf (stderr
, "c_file_name = %s\n",
1621 (c_file_name
? c_file_name
: "not found"));
1622 fprintf (stderr
, "nm_file_name = %s\n",
1623 (nm_file_name
? nm_file_name
: "not found"));
1625 fprintf (stderr
, "ldd_file_name = %s\n",
1626 (ldd_file_name
? ldd_file_name
: "not found"));
1628 fprintf (stderr
, "strip_file_name = %s\n",
1629 (strip_file_name
? strip_file_name
: "not found"));
1630 fprintf (stderr
, "c_file = %s\n",
1631 (c_file
? c_file
: "not found"));
1632 fprintf (stderr
, "o_file = %s\n",
1633 (o_file
? o_file
: "not found"));
1635 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1637 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1639 ptr
= getenv ("COLLECT_GCC");
1641 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1643 ptr
= getenv ("COMPILER_PATH");
1645 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1647 ptr
= getenv (LIBRARY_PATH_ENV
);
1649 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1651 fprintf (stderr
, "\n");
1654 /* Load the program, searching all libraries and attempting to provide
1655 undefined symbols from repository information.
1657 If -r or they will be run via some other method, do not build the
1658 constructor or destructor list, just return now. */
1661 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1663 /* Perform the first pass link now, if we're about to exit or if we need
1664 to scan for things we haven't collected yet before pursuing further.
1666 On AIX, the latter typically includes nothing for shared objects or
1667 frame tables for an executable, out of what the required early scan on
1668 objects and libraries has performed above. In the !shared_obj case, we
1669 expect the relevant tables to be dragged together with their associated
1670 functions from precise cross reference insertions by the compiler. */
1672 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1673 do_tlink (ld1_argv
, object_lst
);
1677 #ifdef COLLECT_EXPORT_LIST
1678 /* Make sure we delete the export file we may have created. */
1679 if (export_file
!= 0 && export_file
[0])
1680 maybe_unlink (export_file
);
1682 if (lto_mode
!= LTO_MODE_NONE
)
1683 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1685 post_ld_pass (false);
1687 maybe_unlink (c_file
);
1688 maybe_unlink (o_file
);
1693 /* Unless we have done it all already, examine the namelist and search for
1694 static constructors and destructors to call. Write the constructor and
1695 destructor tables to a .s file and reload. */
1697 if (ld1_filter
!= SCAN_NOTHING
)
1698 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1700 #ifdef SCAN_LIBRARIES
1701 scan_libraries (output_file
);
1706 notice_translated (ngettext ("%d constructor found\n",
1707 "%d constructors found\n",
1708 constructors
.number
),
1709 constructors
.number
);
1710 notice_translated (ngettext ("%d destructor found\n",
1711 "%d destructors found\n",
1712 destructors
.number
),
1713 destructors
.number
);
1714 notice_translated (ngettext ("%d frame table found\n",
1715 "%d frame tables found\n",
1716 frame_tables
.number
),
1717 frame_tables
.number
);
1720 /* If the scan exposed nothing of special interest, there's no need to
1721 generate the glue code and relink so return now. */
1723 if (constructors
.number
== 0 && destructors
.number
== 0
1724 && frame_tables
.number
== 0
1725 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1726 /* If we will be running these functions ourselves, we want to emit
1727 stubs into the shared library so that we do not have to relink
1728 dependent programs when we add static objects. */
1733 /* Do tlink without additional code generation now if we didn't
1734 do it earlier for scanning purposes. */
1735 if (ld1_filter
== SCAN_NOTHING
)
1736 do_tlink (ld1_argv
, object_lst
);
1739 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1741 /* Strip now if it was requested on the command line. */
1744 char **real_strip_argv
= XCNEWVEC (char *, 3);
1745 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1748 strip_argv
[0] = strip_file_name
;
1749 strip_argv
[1] = output_file
;
1750 strip_argv
[2] = (char *) 0;
1751 fork_execute ("strip", real_strip_argv
, false);
1754 #ifdef COLLECT_EXPORT_LIST
1755 maybe_unlink (export_file
);
1757 post_ld_pass (false);
1759 maybe_unlink (c_file
);
1760 maybe_unlink (o_file
);
1764 /* Sort ctor and dtor lists by priority. */
1765 sort_ids (&constructors
);
1766 sort_ids (&destructors
);
1768 maybe_unlink (output_file
);
1769 outf
= fopen (c_file
, "w");
1770 if (outf
== (FILE *) 0)
1771 fatal_error (input_location
, "fopen %s: %m", c_file
);
1773 write_c_file (outf
, c_file
);
1776 fatal_error (input_location
, "fclose %s: %m", c_file
);
1778 /* Tell the linker that we have initializer and finalizer functions. */
1779 #ifdef LD_INIT_SWITCH
1780 #ifdef COLLECT_EXPORT_LIST
1781 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1783 *ld2
++ = LD_INIT_SWITCH
;
1785 *ld2
++ = LD_FINI_SWITCH
;
1790 #ifdef COLLECT_EXPORT_LIST
1793 /* If we did not add export flag to link arguments before, add it to
1794 second link phase now. No new exports should have been added. */
1795 if (! exports
.first
)
1796 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1798 #ifdef TARGET_AIX_VERSION
1799 add_to_list (&exports
, aix_shared_initname
);
1800 add_to_list (&exports
, aix_shared_fininame
);
1803 #ifndef LD_INIT_SWITCH
1804 add_to_list (&exports
, initname
);
1805 add_to_list (&exports
, fininame
);
1806 add_to_list (&exports
, "_GLOBAL__DI");
1807 add_to_list (&exports
, "_GLOBAL__DD");
1809 exportf
= fopen (export_file
, "w");
1810 if (exportf
== (FILE *) 0)
1811 fatal_error (input_location
, "fopen %s: %m", export_file
);
1812 write_aix_file (exportf
, exports
.first
);
1813 if (fclose (exportf
))
1814 fatal_error (input_location
, "fclose %s: %m", export_file
);
1818 /* End of arguments to second link phase. */
1823 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1824 output_file
, c_file
);
1825 write_c_file (stderr
, "stderr");
1826 fprintf (stderr
, "========== end of c_file\n\n");
1827 #ifdef COLLECT_EXPORT_LIST
1828 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1829 write_aix_file (stderr
, exports
.first
);
1830 fprintf (stderr
, "========== end of export_file\n\n");
1834 /* Assemble the constructor and destructor tables.
1835 Link the tables in with the rest of the program. */
1837 fork_execute ("gcc", c_argv
, at_file_supplied
);
1838 #ifdef COLLECT_EXPORT_LIST
1839 /* On AIX we must call tlink because of possible templates resolution. */
1840 do_tlink (ld2_argv
, object_lst
);
1843 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1845 /* Otherwise, simply call ld because tlink is already done. */
1847 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1850 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1851 post_ld_pass (false);
1854 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1855 constructors/destructors in shared libraries. */
1856 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1859 maybe_unlink (c_file
);
1860 maybe_unlink (o_file
);
1862 #ifdef COLLECT_EXPORT_LIST
1863 maybe_unlink (export_file
);
1870 /* Unlink FILE unless we are debugging or this is the output_file
1871 and we may not unlink it. */
1874 maybe_unlink (const char *file
)
1878 notice ("[Leaving %s]\n", file
);
1882 if (file
== output_file
&& !may_unlink_output_file
)
1885 unlink_if_ordinary (file
);
1888 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1891 maybe_unlink_list (char **file_list
)
1893 char **tmp
= file_list
;
1896 maybe_unlink (*(tmp
++));
1900 static long sequence_number
= 0;
1902 /* Add a name to a linked list. */
1905 add_to_list (struct head
*head_ptr
, const char *name
)
1908 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1910 strcpy (newid
->name
, name
);
1912 if (head_ptr
->first
)
1913 head_ptr
->last
->next
= newid
;
1915 head_ptr
->first
= newid
;
1917 /* Check for duplicate symbols. */
1918 for (p
= head_ptr
->first
;
1919 strcmp (name
, p
->name
) != 0;
1924 head_ptr
->last
->next
= 0;
1929 newid
->sequence
= ++sequence_number
;
1930 head_ptr
->last
= newid
;
1934 /* Grab the init priority number from an init function name that
1935 looks like "_GLOBAL_.I.12345.foo". */
1938 extract_init_priority (const char *name
)
1942 #ifdef TARGET_AIX_VERSION
1943 /* Run dependent module initializers before any constructors in this
1945 switch (is_ctor_dtor (name
))
1955 while (name
[pos
] == '_')
1957 pos
+= 10; /* strlen ("GLOBAL__X_") */
1959 /* Extract init_p number from ctor/dtor name. */
1960 pri
= atoi (name
+ pos
);
1961 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1964 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1965 ctors will be run from right to left, dtors from left to right. */
1968 sort_ids (struct head
*head_ptr
)
1970 /* id holds the current element to insert. id_next holds the next
1971 element to insert. id_ptr iterates through the already sorted elements
1972 looking for the place to insert id. */
1973 struct id
*id
, *id_next
, **id_ptr
;
1975 id
= head_ptr
->first
;
1977 /* We don't have any sorted elements yet. */
1978 head_ptr
->first
= NULL
;
1980 for (; id
; id
= id_next
)
1983 id
->sequence
= extract_init_priority (id
->name
);
1985 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
1987 /* If the sequence numbers are the same, we put the id from the
1988 file later on the command line later in the list. */
1989 || id
->sequence
> (*id_ptr
)->sequence
1990 /* Hack: do lexical compare, too.
1991 || (id->sequence == (*id_ptr)->sequence
1992 && strcmp (id->name, (*id_ptr)->name) > 0) */
2001 /* Now set the sequence numbers properly so write_c_file works. */
2002 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2003 id
->sequence
= ++sequence_number
;
2006 /* Write: `prefix', the names on list LIST, `suffix'. */
2009 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2013 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2018 #ifdef COLLECT_EXPORT_LIST
2019 /* This function is really used only on AIX, but may be useful. */
2021 is_in_list (const char *prefix
, struct id
*list
)
2025 if (!strcmp (prefix
, list
->name
)) return 1;
2030 #endif /* COLLECT_EXPORT_LIST */
2032 /* Added for debugging purpose. */
2033 #ifdef COLLECT_EXPORT_LIST
2035 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2039 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2047 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2051 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2058 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2062 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2063 prefix
, list
->sequence
, list
->name
);
2068 /* Write out the constructor and destructor tables statically (for a shared
2069 object), along with the functions to execute them. */
2072 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2076 int frames
= (frame_tables
.number
> 0);
2078 /* Figure out name of output_file, stripping off .so version. */
2079 q
= p
= lbasename (output_file
);
2091 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2093 q
+= strlen (SHLIB_SUFFIX
);
2100 /* q points to null at end of the string (or . of the .so version) */
2101 prefix
= XNEWVEC (char, q
- p
+ 1);
2102 strncpy (prefix
, p
, q
- p
);
2104 for (r
= prefix
; *r
; r
++)
2105 if (!ISALNUM ((unsigned char)*r
))
2108 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2109 output_file
, prefix
);
2111 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2112 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2113 #ifdef TARGET_AIX_VERSION
2114 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2115 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2120 /* Write the tables as C code. */
2122 /* This count variable is used to prevent multiple calls to the
2123 constructors/destructors.
2124 This guard against multiple calls is important on AIX as the initfini
2125 functions are deliberately invoked multiple times as part of the
2126 mechanisms GCC uses to order constructors across different dependent
2127 shared libraries (see config/rs6000/aix.h).
2129 fprintf (stream
, "static int count;\n");
2130 fprintf (stream
, "typedef void entry_pt();\n");
2131 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2135 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2137 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2138 write_list (stream
, "\t\t&", frame_tables
.first
);
2139 fprintf (stream
, "\t0\n};\n");
2141 /* This must match what's in frame.h. */
2142 fprintf (stream
, "struct object {\n");
2143 fprintf (stream
, " void *pc_begin;\n");
2144 fprintf (stream
, " void *pc_end;\n");
2145 fprintf (stream
, " void *fde_begin;\n");
2146 fprintf (stream
, " void *fde_array;\n");
2147 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2148 fprintf (stream
, " struct object *next;\n");
2149 fprintf (stream
, "};\n");
2151 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2152 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2153 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2154 #ifdef TARGET_AIX_VERSION
2155 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2158 fprintf (stream
, "static void reg_frame () {\n");
2159 fprintf (stream
, "\tstatic struct object ob;\n");
2160 #ifdef TARGET_AIX_VERSION
2161 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2162 This might not be the start of the segment, signed offsets assumed.
2164 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2166 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2168 fprintf (stream
, "\t}\n");
2170 fprintf (stream
, "static void dereg_frame () {\n");
2171 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2172 fprintf (stream
, "\t}\n");
2175 fprintf (stream
, "void %s() {\n", initname
);
2176 if (constructors
.number
> 0 || frames
)
2178 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2179 write_list (stream
, "\t\t", constructors
.first
);
2181 fprintf (stream
, "\treg_frame,\n");
2182 fprintf (stream
, "\t};\n");
2183 fprintf (stream
, "\tentry_pt **p;\n");
2184 fprintf (stream
, "\tif (count++ != 0) return;\n");
2185 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2186 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2189 fprintf (stream
, "\t++count;\n");
2190 fprintf (stream
, "}\n");
2191 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2192 fprintf (stream
, "void %s() {\n", fininame
);
2193 if (destructors
.number
> 0 || frames
)
2195 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2196 write_list (stream
, "\t\t", destructors
.first
);
2198 fprintf (stream
, "\tdereg_frame,\n");
2199 fprintf (stream
, "\t};\n");
2200 fprintf (stream
, "\tentry_pt **p;\n");
2201 fprintf (stream
, "\tif (--count != 0) return;\n");
2202 fprintf (stream
, "\tp = dtors;\n");
2203 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2204 destructors
.number
+ frames
);
2206 fprintf (stream
, "}\n");
2210 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2211 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2215 /* Write the constructor/destructor tables. */
2217 #ifndef LD_INIT_SWITCH
2219 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2221 /* Write the tables as C code. */
2223 int frames
= (frame_tables
.number
> 0);
2225 fprintf (stream
, "typedef void entry_pt();\n\n");
2227 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2231 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2233 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2234 write_list (stream
, "\t\t&", frame_tables
.first
);
2235 fprintf (stream
, "\t0\n};\n");
2237 /* This must match what's in frame.h. */
2238 fprintf (stream
, "struct object {\n");
2239 fprintf (stream
, " void *pc_begin;\n");
2240 fprintf (stream
, " void *pc_end;\n");
2241 fprintf (stream
, " void *fde_begin;\n");
2242 fprintf (stream
, " void *fde_array;\n");
2243 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2244 fprintf (stream
, " struct object *next;\n");
2245 fprintf (stream
, "};\n");
2247 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2248 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2250 fprintf (stream
, "static void reg_frame () {\n");
2251 fprintf (stream
, "\tstatic struct object ob;\n");
2252 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2253 fprintf (stream
, "\t}\n");
2255 fprintf (stream
, "static void dereg_frame () {\n");
2256 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2257 fprintf (stream
, "\t}\n");
2260 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2261 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2262 write_list (stream
, "\t", constructors
.first
);
2264 fprintf (stream
, "\treg_frame,\n");
2265 fprintf (stream
, "\t0\n};\n\n");
2267 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2269 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2270 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2271 write_list (stream
, "\t", destructors
.first
);
2273 fprintf (stream
, "\tdereg_frame,\n");
2274 fprintf (stream
, "\t0\n};\n\n");
2276 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2277 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2279 #endif /* ! LD_INIT_SWITCH */
2282 write_c_file (FILE *stream
, const char *name
)
2284 #ifndef LD_INIT_SWITCH
2286 write_c_file_glob (stream
, name
);
2289 write_c_file_stat (stream
, name
);
2292 #ifdef COLLECT_EXPORT_LIST
2294 write_aix_file (FILE *stream
, struct id
*list
)
2296 for (; list
; list
= list
->next
)
2298 fputs (list
->name
, stream
);
2299 putc ('\n', stream
);
2304 #ifdef OBJECT_FORMAT_NONE
2306 /* Check to make sure the file is an LTO object file. */
2309 maybe_lto_object_file (const char *prog_name
)
2312 unsigned char buf
[4];
2315 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2316 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2317 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2318 static unsigned char machomagic
[4][4] = {
2319 { 0xcf, 0xfa, 0xed, 0xfe },
2320 { 0xce, 0xfa, 0xed, 0xfe },
2321 { 0xfe, 0xed, 0xfa, 0xcf },
2322 { 0xfe, 0xed, 0xfa, 0xce }
2325 f
= fopen (prog_name
, "rb");
2328 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2332 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2333 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2334 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2336 for (i
= 0; i
< 4; i
++)
2337 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2343 /* Generic version to scan the name list of the loaded program for
2344 the symbols g++ uses for static constructors and destructors. */
2347 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2350 void (*int_handler
) (int);
2352 void (*quit_handler
) (int);
2354 char *real_nm_argv
[4];
2355 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2357 struct pex_obj
*pex
;
2364 if (which_pass
== PASS_SECOND
)
2367 /* LTO objects must be in a known format. This check prevents
2368 us from accepting an archive containing LTO objects, which
2369 gcc cannot currently handle. */
2370 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2373 /* If we do not have an `nm', complain. */
2374 if (nm_file_name
== 0)
2375 fatal_error (input_location
, "cannot find 'nm'");
2377 nm_argv
[argc
++] = nm_file_name
;
2378 if (NM_FLAGS
[0] != '\0')
2379 nm_argv
[argc
++] = NM_FLAGS
;
2381 nm_argv
[argc
++] = prog_name
;
2382 nm_argv
[argc
++] = (char *) 0;
2384 /* Trace if needed. */
2387 const char **p_argv
;
2390 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2391 fprintf (stderr
, " %s", str
);
2393 fprintf (stderr
, "\n");
2399 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2401 fatal_error (input_location
, "pex_init failed: %m");
2403 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2410 fatal_error (input_location
, "%s: %m", _(errmsg
));
2413 fatal_error (input_location
, errmsg
);
2416 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2418 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2421 inf
= pex_read_output (pex
, 0);
2423 fatal_error (input_location
, "can't open nm output: %m");
2427 if (which_pass
== PASS_LTOINFO
)
2428 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2430 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2433 /* Read each line of nm output. */
2434 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2440 fprintf (stderr
, "\t%s\n", buf
);
2442 if (which_pass
== PASS_LTOINFO
)
2447 /* Look for the LTO info marker symbol, and add filename to
2448 the LTO objects list if found. */
2449 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2450 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2451 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2452 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2454 add_lto_object (<o_objects
, prog_name
);
2456 /* We need to read all the input, so we can't just
2457 return here. But we can avoid useless work. */
2466 /* If it contains a constructor or destructor name, add the name
2467 to the appropriate list unless this is a kind of symbol we're
2468 not supposed to even consider. */
2470 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2471 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2478 /* Find the end of the symbol name.
2479 Do not include `|', because Encore nm can tack that on the end. */
2480 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2487 switch (is_ctor_dtor (name
))
2490 if (! (filter
& SCAN_CTOR
))
2492 if (which_pass
!= PASS_LIB
)
2493 add_to_list (&constructors
, name
);
2497 if (! (filter
& SCAN_DTOR
))
2499 if (which_pass
!= PASS_LIB
)
2500 add_to_list (&destructors
, name
);
2504 if (! (filter
& SCAN_INIT
))
2506 if (which_pass
!= PASS_LIB
)
2507 fatal_error (input_location
, "init function found in object %s",
2509 #ifndef LD_INIT_SWITCH
2510 add_to_list (&constructors
, name
);
2515 if (! (filter
& SCAN_FINI
))
2517 if (which_pass
!= PASS_LIB
)
2518 fatal_error (input_location
, "fini function found in object %s",
2520 #ifndef LD_FINI_SWITCH
2521 add_to_list (&destructors
, name
);
2526 if (! (filter
& SCAN_DWEH
))
2528 if (which_pass
!= PASS_LIB
)
2529 add_to_list (&frame_tables
, name
);
2532 default: /* not a constructor or destructor */
2538 fprintf (stderr
, "\n");
2540 do_wait (nm_file_name
, pex
);
2542 signal (SIGINT
, int_handler
);
2544 signal (SIGQUIT
, quit_handler
);
2550 /* Use the List Dynamic Dependencies program to find shared libraries that
2551 the output file depends upon and their initialization/finalization
2552 routines, if any. */
2555 scan_libraries (const char *prog_name
)
2557 static struct head libraries
; /* list of shared libraries found */
2559 void (*int_handler
) (int);
2561 void (*quit_handler
) (int);
2563 char *real_ldd_argv
[4];
2564 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2566 struct pex_obj
*pex
;
2572 /* If we do not have an `ldd', complain. */
2573 if (ldd_file_name
== 0)
2575 error ("cannot find 'ldd'");
2579 ldd_argv
[argc
++] = ldd_file_name
;
2580 ldd_argv
[argc
++] = prog_name
;
2581 ldd_argv
[argc
++] = (char *) 0;
2583 /* Trace if needed. */
2586 const char **p_argv
;
2589 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2590 fprintf (stderr
, " %s", str
);
2592 fprintf (stderr
, "\n");
2598 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2600 fatal_error (input_location
, "pex_init failed: %m");
2602 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2608 fatal_error (input_location
, "%s: %m", _(errmsg
));
2611 fatal_error (input_location
, errmsg
);
2614 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2616 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2619 inf
= pex_read_output (pex
, 0);
2621 fatal_error (input_location
, "can't open ldd output: %m");
2624 notice ("\nldd output with constructors/destructors.\n");
2626 /* Read each line of ldd output. */
2627 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2630 char *name
, *end
, *p
= buf
;
2632 /* Extract names of libraries and add to list. */
2633 PARSE_LDD_OUTPUT (p
);
2638 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2639 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2641 /* Find the end of the symbol name. */
2643 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2648 if (access (name
, R_OK
) == 0)
2649 add_to_list (&libraries
, name
);
2651 fatal_error (input_location
, "unable to open dynamic dependency '%s'",
2655 fprintf (stderr
, "\t%s\n", buf
);
2658 fprintf (stderr
, "\n");
2660 do_wait (ldd_file_name
, pex
);
2662 signal (SIGINT
, int_handler
);
2664 signal (SIGQUIT
, quit_handler
);
2667 /* Now iterate through the library list adding their symbols to
2669 for (list
= libraries
.first
; list
; list
= list
->next
)
2670 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2673 #endif /* LDD_SUFFIX */
2675 #endif /* OBJECT_FORMAT_NONE */
2679 * COFF specific stuff.
2682 #ifdef OBJECT_FORMAT_COFF
2684 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2685 # define GCC_SYMENT SYMENT
2686 # if defined (C_WEAKEXT)
2687 # define GCC_OK_SYMBOL(X) \
2688 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2689 ((X).n_scnum > N_UNDEF) && \
2691 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2692 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2693 # define GCC_UNDEF_SYMBOL(X) \
2694 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2695 ((X).n_scnum == N_UNDEF))
2697 # define GCC_OK_SYMBOL(X) \
2698 (((X).n_sclass == C_EXT) && \
2699 ((X).n_scnum > N_UNDEF) && \
2701 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2702 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2703 # define GCC_UNDEF_SYMBOL(X) \
2704 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2706 # define GCC_SYMINC(X) ((X).n_numaux+1)
2707 # define GCC_SYMZERO(X) 0
2709 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2710 #if TARGET_AIX_VERSION >= 51
2711 # define GCC_CHECK_HDR(X) \
2712 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2713 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2714 && !(HEADER (X).f_flags & F_LOADONLY))
2716 # define GCC_CHECK_HDR(X) \
2717 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2718 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2719 && !(HEADER (X).f_flags & F_LOADONLY))
2722 #ifdef COLLECT_EXPORT_LIST
2723 /* Array of standard AIX libraries which should not
2724 be scanned for ctors/dtors. */
2725 static const char *const aix_std_libs
[] = {
2733 "/usr/lib/libc_r.a",
2734 "/usr/lib/libm_r.a",
2735 "/usr/lib/threads/libc.a",
2736 "/usr/ccs/lib/libc.a",
2737 "/usr/ccs/lib/libm.a",
2738 "/usr/ccs/lib/libc_r.a",
2739 "/usr/ccs/lib/libm_r.a",
2743 /* This function checks the filename and returns 1
2744 if this name matches the location of a standard AIX library. */
2745 static int ignore_library (const char *);
2747 ignore_library (const char *name
)
2749 const char *const *p
;
2752 if (target_system_root
[0] != '\0')
2754 length
= strlen (target_system_root
);
2755 if (strncmp (name
, target_system_root
, length
) != 0)
2759 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2760 if (strcmp (name
, *p
) == 0)
2764 #endif /* COLLECT_EXPORT_LIST */
2766 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2767 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2770 /* COFF version to scan the name list of the loaded program for
2771 the symbols g++ uses for static constructors and destructors. */
2774 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2777 LDFILE
*ldptr
= NULL
;
2778 int sym_index
, sym_count
;
2782 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
2783 && which_pass
!= PASS_LTOINFO
)
2786 #ifdef COLLECT_EXPORT_LIST
2787 /* We do not need scanning for some standard C libraries. */
2788 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2791 /* On AIX we have a loop, because there is not much difference
2792 between an object and an archive. This trick allows us to
2793 eliminate scan_libraries() function. */
2798 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2799 non-const char * filename parameter, even though it will not
2800 modify that string. So we must cast away const-ness here,
2801 using CONST_CAST to prevent complaints from -Wcast-qual. */
2802 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2804 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2805 fatal_error (input_location
, "%s: not a COFF file", prog_name
);
2807 if (GCC_CHECK_HDR (ldptr
))
2809 sym_count
= GCC_SYMBOLS (ldptr
);
2810 sym_index
= GCC_SYMZERO (ldptr
);
2812 #ifdef COLLECT_EXPORT_LIST
2813 /* Is current archive member a shared object? */
2814 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2817 while (sym_index
< sym_count
)
2821 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2823 sym_index
+= GCC_SYMINC (symbol
);
2825 if (GCC_OK_SYMBOL (symbol
))
2829 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2830 continue; /* Should never happen. */
2832 #ifdef XCOFF_DEBUGGING_INFO
2833 /* All AIX function names have a duplicate entry
2834 beginning with a dot. */
2839 if (which_pass
== PASS_LTOINFO
)
2843 if (strncmp (name
, "__gnu_lto_v1", 12) == 0)
2845 add_lto_object (<o_objects
, prog_name
);
2852 switch (is_ctor_dtor (name
))
2854 #if TARGET_AIX_VERSION
2855 /* Add AIX shared library initalisers/finalisers
2856 to the constructors/destructors list of the
2859 if (! (filter
& SCAN_CTOR
))
2861 if (is_shared
&& !aixlazy_flag
2862 #ifdef COLLECT_EXPORT_LIST
2864 && ! is_in_list (prog_name
, static_libs
.first
)
2867 add_to_list (&constructors
, name
);
2871 if (! (filter
& SCAN_DTOR
))
2873 if (is_shared
&& !aixlazy_flag
)
2874 add_to_list (&destructors
, name
);
2879 if (! (filter
& SCAN_CTOR
))
2882 add_to_list (&constructors
, name
);
2883 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2884 if (which_pass
== PASS_OBJ
)
2885 add_to_list (&exports
, name
);
2890 if (! (filter
& SCAN_DTOR
))
2893 add_to_list (&destructors
, name
);
2894 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2895 if (which_pass
== PASS_OBJ
)
2896 add_to_list (&exports
, name
);
2900 #ifdef COLLECT_EXPORT_LIST
2902 if (! (filter
& SCAN_INIT
))
2904 #ifndef LD_INIT_SWITCH
2906 add_to_list (&constructors
, name
);
2911 if (! (filter
& SCAN_FINI
))
2913 #ifndef LD_INIT_SWITCH
2915 add_to_list (&destructors
, name
);
2921 if (! (filter
& SCAN_DWEH
))
2924 add_to_list (&frame_tables
, name
);
2925 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2926 if (which_pass
== PASS_OBJ
)
2927 add_to_list (&exports
, name
);
2931 default: /* not a constructor or destructor */
2932 #ifdef COLLECT_EXPORT_LIST
2933 /* Explicitly export all global symbols when
2934 building a shared object on AIX, but do not
2935 re-export symbols from another shared object
2936 and do not export symbols if the user
2937 provides an explicit export list. */
2938 if (shared_obj
&& !is_shared
2939 && which_pass
== PASS_OBJ
&& !export_flag
)
2941 /* Do not auto-export __dso_handle or
2942 __gcc_unwind_dbase. They are required
2943 to be local to each module. */
2944 if (strcmp(name
, "__dso_handle") != 0
2945 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2947 add_to_list (&exports
, name
);
2955 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2956 symbol
.n_scnum
, symbol
.n_sclass
,
2957 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2962 #ifdef COLLECT_EXPORT_LIST
2965 /* If archive contains both 32-bit and 64-bit objects,
2966 we want to skip objects in other mode so mismatch normal. */
2968 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2969 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2975 fatal_error (input_location
, "%s: cannot open as COFF file",
2978 #ifdef COLLECT_EXPORT_LIST
2979 /* On AIX loop continues while there are more members in archive. */
2981 while (ldclose (ldptr
) == FAILURE
);
2983 /* Otherwise we simply close ldptr. */
2984 (void) ldclose (ldptr
);
2987 #endif /* OBJECT_FORMAT_COFF */
2989 #ifdef COLLECT_EXPORT_LIST
2990 /* Given a library name without "lib" prefix, this function
2991 returns a full library name including a path. */
2993 resolve_lib_name (const char *name
)
2997 /* Library extensions for AIX dynamic linking. */
2998 const char * const libexts
[2] = {"a", "so"};
3000 for (i
= 0; libpaths
[i
]; i
++)
3001 if (libpaths
[i
]->max_len
> l
)
3002 l
= libpaths
[i
]->max_len
;
3004 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
3006 for (i
= 0; libpaths
[i
]; i
++)
3008 struct prefix_list
*list
= libpaths
[i
]->plist
;
3009 for (; list
; list
= list
->next
)
3011 /* The following lines are needed because path_prefix list
3012 may contain directories both with trailing DIR_SEPARATOR and
3015 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
3017 for (j
= 0; j
< 2; j
++)
3019 sprintf (lib_buf
, "%s%slib%s.%s",
3020 list
->prefix
, p
, name
,
3021 libexts
[(j
+ aixrtl_flag
) % 2]);
3022 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3023 if (file_exists (lib_buf
))
3025 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3032 fprintf (stderr
, "not found\n");
3034 fatal_error (input_location
, "library lib%s not found", name
);
3037 #endif /* COLLECT_EXPORT_LIST */
3039 #ifdef COLLECT_RUN_DSYMUTIL
3040 static int flag_dsym
= false;
3041 static int flag_idsym
= false;
3044 process_args (int *argcp
, char **argv
) {
3047 for (i
=0; i
<argc
; ++i
)
3049 if (strcmp (argv
[i
], "-dsym") == 0)
3052 /* Remove the flag, as we handle all processing for it. */
3055 argv
[j
] = argv
[j
+1];
3060 else if (strcmp (argv
[i
], "-idsym") == 0)
3063 /* Remove the flag, as we handle all processing for it. */
3066 argv
[j
] = argv
[j
+1];
3075 do_dsymutil (const char *output_file
) {
3076 const char *dsymutil
= DSYMUTIL
+ 1;
3077 struct pex_obj
*pex
;
3078 char **real_argv
= XCNEWVEC (char *, 3);
3079 const char ** argv
= CONST_CAST2 (const char **, char **,
3083 argv
[1] = output_file
;
3084 argv
[2] = (char *) 0;
3086 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3087 PEX_LAST
| PEX_SEARCH
, false);
3088 do_wait (dsymutil
, pex
);
3092 post_ld_pass (bool temp_file
) {
3093 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3096 do_dsymutil (output_file
);
3100 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3101 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }