1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2020 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
29 #include "coretypes.h"
31 #include "filenames.h"
32 #include "file-find.h"
33 #include "simple-object.h"
34 #include "lto-section-names.h"
36 /* TARGET_64BIT may be defined to use driver specific functionality. */
38 #define TARGET_64BIT TARGET_64BIT_DEFAULT
40 #ifndef LIBRARY_PATH_ENV
41 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
47 #include "collect2-aix.h"
48 #include "collect-utils.h"
49 #include "diagnostic.h"
55 /* On certain systems, we have code that works by scanning the object file
56 directly. But this code uses system-specific header files and library
57 functions, so turn it off in a cross-compiler. Likewise, the names of
58 the utilities are not correct for a cross-compiler; we have to hope that
59 cross-versions are in the proper directories. */
61 #ifdef CROSS_DIRECTORY_STRUCTURE
62 #ifndef CROSS_AIX_SUPPORT
63 #undef OBJECT_FORMAT_COFF
66 #undef REAL_LD_FILE_NAME
67 #undef REAL_NM_FILE_NAME
68 #undef REAL_STRIP_FILE_NAME
71 /* If we cannot use a special method, use the ordinary one:
72 run nm to find what symbols are present.
73 In a cross-compiler, this means you need a cross nm,
74 but that is not quite as unpleasant as special headers. */
76 #if !defined (OBJECT_FORMAT_COFF)
77 #define OBJECT_FORMAT_NONE
80 #ifdef OBJECT_FORMAT_COFF
82 #ifndef CROSS_DIRECTORY_STRUCTURE
90 /* Many versions of ldfcn.h define these. */
99 /* Some systems have an ISCOFF macro, but others do not. In some cases
100 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
101 that either do not have an ISCOFF macro in /usr/include or for those
102 where it is wrong. */
105 #define MY_ISCOFF(X) ISCOFF (X)
108 #endif /* OBJECT_FORMAT_COFF */
110 #ifdef OBJECT_FORMAT_NONE
112 /* Default flags to pass to nm. */
114 #define NM_FLAGS "-n"
117 #endif /* OBJECT_FORMAT_NONE */
119 /* Some systems use __main in a way incompatible with its use in gcc, in these
120 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
121 give the same symbol without quotes for an alternative entry point. */
123 #define NAME__MAIN "__main"
126 /* This must match tree.h. */
127 #define DEFAULT_INIT_PRIORITY 65535
129 #ifndef COLLECT_SHARED_INIT_FUNC
130 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
133 #ifndef COLLECT_SHARED_FINI_FUNC
134 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
135 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
139 #define SCAN_LIBRARIES
143 #define SHLIB_SUFFIX ".so"
147 int do_collecting
= 1;
149 int do_collecting
= 0;
152 /* Cook up an always defined indication of whether we proceed the
153 "EXPORT_LIST" way. */
155 #ifdef COLLECT_EXPORT_LIST
156 #define DO_COLLECT_EXPORT_LIST 1
158 #define DO_COLLECT_EXPORT_LIST 0
161 /* Nonzero if we should suppress the automatic demangling of identifiers
162 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
165 /* Linked lists of constructor and destructor names. */
181 static int rflag
; /* true if -r */
182 static int strip_flag
; /* true if -s */
183 #ifdef COLLECT_EXPORT_LIST
184 static int export_flag
; /* true if -bE */
185 static int aix64_flag
; /* true if -b64 */
186 static int aixrtl_flag
; /* true if -brtl */
187 static int aixlazy_flag
; /* true if -blazy */
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
,
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
);
731 /* We assume that temp files were created, and therefore we need to take
732 that into account (maybe run dsymutil). */
733 post_ld_pass (/*temp_file*/true);
736 maybe_unlink_list (lto_o_files
);
740 /* Our caller is relying on us to do the link
741 even though there is no LTO back end work to be done. */
742 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
743 /* No LTO objects were found, so no new temp file. */
744 post_ld_pass (/*temp_file*/false);
747 post_ld_pass (false); /* No LTO objects were found, no temp file. */
749 /* Entry point for linker invoation. Called from main in collect2.c.
750 LD_ARGV is an array of arguments for the linker. */
753 do_link (char **ld_argv
)
756 const char *prog
= "ld";
757 pex
= collect_execute (prog
, ld_argv
, NULL
, NULL
,
758 PEX_LAST
| PEX_SEARCH
,
759 HAVE_GNU_LD
&& at_file_supplied
);
760 int ret
= collect_wait (prog
, pex
);
763 error ("ld returned %d exit status", ret
);
768 /* We have just successfully produced an output file, so assume that we
769 may unlink it if need be for now on. */
770 may_unlink_output_file
= true;
777 main (int argc
, char **argv
)
787 } selected_linker
= USE_DEFAULT_LD
;
788 static const char *const ld_suffixes
[USE_LD_MAX
] =
796 static const char *const real_ld_suffix
= "real-ld";
797 static const char *const collect_ld_suffix
= "collect-ld";
798 static const char *const nm_suffix
= "nm";
799 static const char *const gnm_suffix
= "gnm";
801 static const char *const ldd_suffix
= LDD_SUFFIX
;
803 static const char *const strip_suffix
= "strip";
804 static const char *const gstrip_suffix
= "gstrip";
806 const char *full_ld_suffixes
[USE_LD_MAX
];
807 #ifdef CROSS_DIRECTORY_STRUCTURE
808 /* If we look for a program in the compiler directories, we just use
809 the short name, since these directories are already system-specific.
810 But it we look for a program in the system directories, we need to
811 qualify the program name with the target machine. */
813 const char *const full_nm_suffix
=
814 concat (target_machine
, "-", nm_suffix
, NULL
);
815 const char *const full_gnm_suffix
=
816 concat (target_machine
, "-", gnm_suffix
, NULL
);
818 const char *const full_ldd_suffix
=
819 concat (target_machine
, "-", ldd_suffix
, NULL
);
821 const char *const full_strip_suffix
=
822 concat (target_machine
, "-", strip_suffix
, NULL
);
823 const char *const full_gstrip_suffix
=
824 concat (target_machine
, "-", gstrip_suffix
, NULL
);
827 const char *const full_ldd_suffix
= ldd_suffix
;
829 const char *const full_nm_suffix
= nm_suffix
;
830 const char *const full_gnm_suffix
= gnm_suffix
;
831 const char *const full_strip_suffix
= strip_suffix
;
832 const char *const full_gstrip_suffix
= gstrip_suffix
;
833 #endif /* CROSS_DIRECTORY_STRUCTURE */
837 #ifdef COLLECT_EXPORT_LIST
840 const char *ld_file_name
;
846 bool use_plugin
= false;
847 bool use_collect_ld
= false;
849 /* The kinds of symbols we will have to consider when scanning the
850 outcome of a first pass link. This is ALL to start with, then might
851 be adjusted before getting to the first pass link per se, typically on
852 AIX where we perform an early scan of objects and libraries to fetch
853 the list of global ctors/dtors and make sure they are not garbage
855 scanfilter ld1_filter
= SCAN_ALL
;
861 #ifdef TARGET_AIX_VERSION
862 int object_nbr
= argc
;
867 #ifdef COLLECT_EXPORT_LIST
868 bool is_static
= false;
872 for (i
= 0; i
< USE_LD_MAX
; i
++)
874 #ifdef CROSS_DIRECTORY_STRUCTURE
875 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
880 p
= argv
[0] + strlen (argv
[0]);
881 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
885 xmalloc_set_program_name (progname
);
888 expandargv (&argc
, &argv
);
889 if (argv
!= old_argv
)
890 at_file_supplied
= 1;
892 process_args (&argc
, argv
);
894 num_c_args
= argc
+ 9;
896 #ifndef HAVE_LD_DEMANGLE
897 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
899 /* Suppress demangling by the real linker, which may be broken. */
900 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
903 #if defined (COLLECT2_HOST_INITIALIZATION)
904 /* Perform system dependent initialization, if necessary. */
905 COLLECT2_HOST_INITIALIZATION
;
909 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
910 receive the signal. A different setting is inheritable */
911 signal (SIGCHLD
, SIG_DFL
);
914 /* Unlock the stdio streams. */
915 unlock_std_streams ();
919 diagnostic_initialize (global_dc
, 0);
921 if (atexit (collect_atexit
) != 0)
922 fatal_error (input_location
, "atexit failed");
924 /* Do not invoke xcalloc before this point, since locale needs to be
925 set first, in case a diagnostic is issued. */
927 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
928 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
929 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
930 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
931 object_lst
= XCNEWVEC (char *, argc
);
932 object
= CONST_CAST2 (const char **, char **, object_lst
);
941 #ifndef DEFAULT_A_OUT_NAME
942 output_file
= "a.out";
944 output_file
= DEFAULT_A_OUT_NAME
;
947 /* Parse command line / environment for flags we want early.
948 This allows the debug flag to be set before functions like find_a_file()
951 bool no_partition
= false;
953 for (i
= 1; argv
[i
] != NULL
; i
++)
955 if (! strcmp (argv
[i
], "-debug"))
957 else if (!strncmp (argv
[i
], "-fno-lto", 8))
958 lto_mode
= LTO_MODE_NONE
;
959 else if (! strcmp (argv
[i
], "-plugin"))
962 if (selected_linker
== USE_DEFAULT_LD
)
963 selected_linker
= USE_PLUGIN_LD
;
965 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
966 selected_linker
= USE_BFD_LD
;
967 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
968 selected_linker
= USE_GOLD_LD
;
969 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
970 selected_linker
= USE_LLD_LD
;
971 else if (strncmp (argv
[i
], "-o", 2) == 0)
973 /* Parse the output filename if it's given so that we can make
974 meaningful temp filenames. */
975 if (argv
[i
][2] == '\0')
976 output_file
= argv
[i
+1];
978 output_file
= &argv
[i
][2];
981 #ifdef COLLECT_EXPORT_LIST
982 /* These flags are position independent, although their order
983 is important - subsequent flags override earlier ones. */
984 else if (strcmp (argv
[i
], "-b64") == 0)
986 /* -bexport:filename always needs the :filename */
987 else if (strncmp (argv
[i
], "-bE:", 4) == 0
988 || strncmp (argv
[i
], "-bexport:", 9) == 0)
990 else if (strcmp (argv
[i
], "-brtl") == 0
991 || strcmp (argv
[i
], "-bsvr4") == 0
992 || strcmp (argv
[i
], "-G") == 0)
994 else if (strcmp (argv
[i
], "-bnortl") == 0)
996 else if (strcmp (argv
[i
], "-blazy") == 0)
1001 obstack_begin (&temporary_obstack
, 0);
1002 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1004 #ifndef HAVE_LD_DEMANGLE
1005 current_demangling_style
= auto_demangling
;
1008 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1009 The LTO options are passed here as are other options that might
1010 be unsuitable for ld (e.g. -save-temps). */
1011 p
= getenv ("COLLECT_GCC_OPTIONS");
1014 const char *q
= extract_string (&p
);
1015 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1017 if (strncmp (q
, "-flto-partition=none", 20) == 0)
1018 no_partition
= true;
1019 else if (strncmp (q
, "-fno-lto", 8) == 0)
1020 lto_mode
= LTO_MODE_NONE
;
1021 else if (strncmp (q
, "-save-temps", 11) == 0)
1022 /* FIXME: Honour =obj. */
1025 obstack_free (&temporary_obstack
, temporary_firstobj
);
1027 verbose
= verbose
|| debug
;
1028 save_temps
= save_temps
|| debug
;
1029 find_file_set_debug (debug
);
1031 lto_mode
= LTO_MODE_NONE
;
1032 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1033 lto_mode
= LTO_MODE_LTO
;
1036 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1037 -fno-exceptions -w -fno-whole-program */
1040 c_argv
= XCNEWVEC (char *, num_c_args
);
1041 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1044 fatal_error (input_location
, "no arguments");
1047 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1048 signal (SIGQUIT
, handler
);
1050 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1051 signal (SIGINT
, handler
);
1053 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1054 signal (SIGALRM
, handler
);
1057 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1058 signal (SIGHUP
, handler
);
1060 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1061 signal (SIGSEGV
, handler
);
1063 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1064 signal (SIGBUS
, handler
);
1067 /* Extract COMPILER_PATH and PATH into our prefix list. */
1068 prefix_from_env ("COMPILER_PATH", &cpath
);
1069 prefix_from_env ("PATH", &path
);
1071 /* Try to discover a valid linker/nm/strip to use. */
1073 /* Maybe we know the right file to use (if not cross). */
1075 #ifdef DEFAULT_LINKER
1076 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1077 selected_linker
== USE_LLD_LD
)
1080 # ifdef HOST_EXECUTABLE_SUFFIX
1081 int len
= (sizeof (DEFAULT_LINKER
)
1082 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1086 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1087 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1088 HOST_EXECUTABLE_SUFFIX. */
1089 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1091 default_linker
[len
] = '\0';
1092 linker_name
= concat (default_linker
,
1093 &ld_suffixes
[selected_linker
][2],
1094 HOST_EXECUTABLE_SUFFIX
, NULL
);
1097 if (linker_name
== NULL
)
1099 linker_name
= concat (DEFAULT_LINKER
,
1100 &ld_suffixes
[selected_linker
][2],
1102 if (access (linker_name
, X_OK
) == 0)
1103 ld_file_name
= linker_name
;
1105 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1106 ld_file_name
= DEFAULT_LINKER
;
1107 if (ld_file_name
== 0)
1109 #ifdef REAL_LD_FILE_NAME
1110 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1111 if (ld_file_name
== 0)
1113 /* Search the (target-specific) compiler dirs for ld'. */
1114 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1115 /* Likewise for `collect-ld'. */
1116 if (ld_file_name
== 0)
1118 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1119 use_collect_ld
= ld_file_name
!= 0;
1121 /* Search the compiler directories for `ld'. We have protection against
1122 recursive calls in find_a_file. */
1123 if (ld_file_name
== 0)
1124 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1125 /* Search the ordinary system bin directories
1126 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1127 if (ld_file_name
== 0)
1128 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1130 #ifdef REAL_NM_FILE_NAME
1131 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1132 if (nm_file_name
== 0)
1134 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1135 if (nm_file_name
== 0)
1136 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1137 if (nm_file_name
== 0)
1138 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1139 if (nm_file_name
== 0)
1140 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1143 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1144 if (ldd_file_name
== 0)
1145 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1148 #ifdef REAL_STRIP_FILE_NAME
1149 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1150 if (strip_file_name
== 0)
1152 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1153 if (strip_file_name
== 0)
1154 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1155 if (strip_file_name
== 0)
1156 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1157 if (strip_file_name
== 0)
1158 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1160 /* Determine the full path name of the C compiler to use. */
1161 c_file_name
= getenv ("COLLECT_GCC");
1162 if (c_file_name
== 0)
1164 #ifdef CROSS_DIRECTORY_STRUCTURE
1165 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1167 c_file_name
= "gcc";
1171 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1173 /* Here it should be safe to use the system search path since we should have
1174 already qualified the name of the compiler when it is needed. */
1176 p
= find_a_file (&path
, c_file_name
, X_OK
);
1181 *ld1
++ = *ld2
++ = ld_file_name
;
1183 /* Make temp file names. */
1186 c_file
= concat (output_file
, ".cdtor.c", NULL
);
1187 o_file
= concat (output_file
, ".cdtor.o", NULL
);
1188 #ifdef COLLECT_EXPORT_LIST
1189 export_file
= concat (output_file
, ".x", NULL
);
1194 c_file
= make_temp_file (".cdtor.c");
1195 o_file
= make_temp_file (".cdtor.o");
1196 #ifdef COLLECT_EXPORT_LIST
1197 export_file
= make_temp_file (".x");
1200 /* Build the command line to compile the ctor/dtor list. */
1201 *c_ptr
++ = c_file_name
;
1208 #ifdef COLLECT_EXPORT_LIST
1209 /* Generate a list of directories from LIBPATH. */
1210 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1211 /* Add to this list also two standard directories where
1212 AIX loader always searches for libraries. */
1213 add_prefix (&libpath_lib_dirs
, "/lib");
1214 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1217 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1219 AIX support needs to know if -shared has been specified before
1220 parsing commandline arguments. */
1222 p
= getenv ("COLLECT_GCC_OPTIONS");
1225 const char *q
= extract_string (&p
);
1226 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1227 *c_ptr
++ = xstrdup (q
);
1228 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1229 *c_ptr
++ = xstrdup (q
);
1230 if (strcmp (q
, "-shared") == 0)
1232 if (strcmp (q
, "-static") == 0)
1234 if (*q
== '-' && q
[1] == 'B')
1236 *c_ptr
++ = xstrdup (q
);
1239 q
= extract_string (&p
);
1240 *c_ptr
++ = xstrdup (q
);
1243 #ifdef COLLECT_EXPORT_LIST
1244 /* Detect any invocation with -fvisibility. */
1245 if (strncmp (q
, "-fvisibility", 12) == 0)
1246 visibility_flag
= 1;
1249 obstack_free (&temporary_obstack
, temporary_firstobj
);
1250 *c_ptr
++ = "-fno-profile-arcs";
1251 *c_ptr
++ = "-fno-test-coverage";
1252 *c_ptr
++ = "-fno-branch-probabilities";
1253 *c_ptr
++ = "-fno-exceptions";
1255 *c_ptr
++ = "-fno-whole-program";
1257 /* !!! When GCC calls collect2,
1258 it does not know whether it is calling collect2 or ld.
1259 So collect2 cannot meaningfully understand any options
1260 except those ld understands.
1261 If you propose to make GCC pass some other option,
1262 just imagine what will happen if ld is really ld!!! */
1264 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1265 /* After the first file, put in the c++ rt0. */
1267 #ifdef COLLECT_EXPORT_LIST
1268 is_static
= static_obj
;
1271 while ((arg
= *++argv
) != (char *) 0)
1273 *ld1
++ = *ld2
++ = arg
;
1280 if (!strcmp (arg
, "-debug"))
1282 /* Already parsed. */
1286 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1289 *ld1
++ = *ld2
++ = *argv
;
1294 if (strncmp (arg
, "-flto", 5) == 0)
1297 /* Do not pass LTO flag to the linker. */
1301 error ("LTO support has not been enabled in this "
1305 else if (!use_collect_ld
1306 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1308 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1312 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1314 /* Do not pass -fno-lto to the linker. */
1318 #ifdef TARGET_AIX_VERSION
1321 /* File containing a list of input files to process. */
1324 char buf
[MAXPATHLEN
+ 2];
1325 /* Number of additionnal object files. */
1327 /* Maximum of additionnal object files before vector
1330 const char *list_filename
= arg
+ 2;
1332 /* Accept -fFILENAME and -f FILENAME. */
1333 if (*list_filename
== '\0' && argv
[1])
1336 list_filename
= *argv
;
1337 *ld1
++ = *ld2
++ = *argv
;
1340 stream
= fopen (list_filename
, "r");
1342 fatal_error (input_location
, "cannot open %s: %m",
1345 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1347 /* Remove end of line. */
1348 int len
= strlen (buf
);
1349 if (len
>= 1 && buf
[len
- 1] =='\n')
1350 buf
[len
- 1] = '\0';
1352 /* Put on object vector.
1353 Note: we only expanse vector here, so we must keep
1354 extra space for remaining arguments. */
1355 if (add_nbr
>= add_max
)
1358 object
- CONST_CAST2 (const char **, char **,
1360 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1361 object_lst
= XRESIZEVEC (char *, object_lst
,
1362 object_nbr
+ add_max
);
1363 object
= CONST_CAST2 (const char **, char **,
1365 object_nbr
+= add_max
;
1367 *object
++ = xstrdup (buf
);
1375 #ifdef COLLECT_EXPORT_LIST
1377 if (!strcmp (arg
, "-bstatic"))
1381 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1390 /* place o_file BEFORE this argument! */
1396 #ifdef COLLECT_EXPORT_LIST
1398 /* Resolving full library name. */
1399 const char *s
= resolve_lib_name (arg
+2);
1401 /* Saving a full library name. */
1402 add_to_list (&libs
, s
);
1404 add_to_list (&static_libs
, s
);
1409 #ifdef COLLECT_EXPORT_LIST
1410 /* Saving directories where to search for libraries. */
1412 add_prefix (&cmdline_lib_dirs
, arg
+2);
1418 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1420 output_file
= &arg
[2];
1429 if (arg
[2] == '\0' && do_collecting
)
1431 /* We must strip after the nm run, otherwise C++ linking
1432 will not work. Thus we strip in the second ld run, or
1433 else with strip if there is no second ld run. */
1445 if (strcmp (arg
, "--no-demangle") == 0)
1447 #ifndef HAVE_LD_DEMANGLE
1453 else if (strncmp (arg
, "--demangle", 10) == 0)
1455 #ifndef HAVE_LD_DEMANGLE
1459 enum demangling_styles style
1460 = cplus_demangle_name_to_style (arg
+11);
1461 if (style
== unknown_demangling
)
1462 error ("unknown demangling style %qs", arg
+11);
1464 current_demangling_style
= style
;
1470 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1471 target_system_root
= arg
+ 10;
1472 else if (strcmp (arg
, "--version") == 0)
1474 else if (strcmp (arg
, "--help") == 0)
1479 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1480 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1481 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1482 || strcmp (p
, ".obj") == 0))
1491 /* place o_file BEFORE this argument! */
1497 if (p
[1] == 'o' || p
[1] == 'l')
1499 #ifdef COLLECT_EXPORT_LIST
1500 /* libraries can be specified directly, i.e. without -l flag. */
1503 /* Saving a full library name. */
1504 add_to_list (&libs
, arg
);
1506 add_to_list (&static_libs
, arg
);
1512 #ifdef COLLECT_EXPORT_LIST
1513 /* This is added only for debugging purposes. */
1516 fprintf (stderr
, "List of libraries:\n");
1517 dump_list (stderr
, "\t", libs
.first
);
1518 fprintf (stderr
, "List of statically linked libraries:\n");
1519 dump_list (stderr
, "\t", static_libs
.first
);
1522 /* The AIX linker will discard static constructors in object files if
1523 nothing else in the file is referenced, so look at them first. Unless
1524 we are building a shared object, ignore the eh frame tables, as we
1525 would otherwise reference them all, hence drag all the corresponding
1526 objects even if nothing else is referenced. */
1528 const char **export_object_lst
1529 = CONST_CAST2 (const char **, char **, object_lst
);
1531 struct id
*list
= libs
.first
;
1533 /* Compute the filter to use from the current one, do scan, then adjust
1534 the "current" filter to remove what we just included here. This will
1535 control whether we need a first pass link later on or not, and what
1536 will remain to be scanned there. */
1538 scanfilter this_filter
= ld1_filter
;
1541 this_filter
&= ~SCAN_DWEH
;
1544 /* Scan object files. */
1545 while (export_object_lst
< object
)
1546 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1548 /* Scan libraries. */
1549 for (; list
; list
= list
->next
)
1550 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1552 ld1_filter
= ld1_filter
& ~this_filter
;
1557 char *buf
= concat ("-bE:", export_file
, NULL
);
1562 exportf
= fopen (export_file
, "w");
1563 if (exportf
== (FILE *) 0)
1564 fatal_error (input_location
, "fopen %s: %m", export_file
);
1565 write_aix_file (exportf
, exports
.first
);
1566 if (fclose (exportf
))
1567 fatal_error (input_location
, "fclose %s: %m", export_file
);
1572 *c_ptr
= *ld1
= *object
= (char *) 0;
1575 notice ("collect2 version %s\n", version_string
);
1579 printf ("Usage: collect2 [options]\n");
1580 printf (" Wrap linker and generate constructor code if needed.\n");
1581 printf (" Options:\n");
1582 printf (" -debug Enable debug output\n");
1583 printf (" --help Display this information\n");
1584 printf (" -v, --version Display this program's version number\n");
1586 printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1587 printf ("Report bugs: %s\n", bug_report_url
);
1594 fprintf (stderr
, "ld_file_name = %s\n",
1595 (ld_file_name
? ld_file_name
: "not found"));
1596 fprintf (stderr
, "c_file_name = %s\n",
1597 (c_file_name
? c_file_name
: "not found"));
1598 fprintf (stderr
, "nm_file_name = %s\n",
1599 (nm_file_name
? nm_file_name
: "not found"));
1601 fprintf (stderr
, "ldd_file_name = %s\n",
1602 (ldd_file_name
? ldd_file_name
: "not found"));
1604 fprintf (stderr
, "strip_file_name = %s\n",
1605 (strip_file_name
? strip_file_name
: "not found"));
1606 fprintf (stderr
, "c_file = %s\n",
1607 (c_file
? c_file
: "not found"));
1608 fprintf (stderr
, "o_file = %s\n",
1609 (o_file
? o_file
: "not found"));
1611 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1613 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1615 ptr
= getenv ("COLLECT_GCC");
1617 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1619 ptr
= getenv ("COMPILER_PATH");
1621 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1623 ptr
= getenv (LIBRARY_PATH_ENV
);
1625 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1627 fprintf (stderr
, "\n");
1630 /* Load the program, searching all libraries and attempting to provide
1631 undefined symbols from repository information.
1633 If -r or they will be run via some other method, do not build the
1634 constructor or destructor list, just return now. */
1637 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1639 /* Perform the first pass link now, if we're about to exit or if we need
1640 to scan for things we haven't collected yet before pursuing further.
1642 On AIX, the latter typically includes nothing for shared objects or
1643 frame tables for an executable, out of what the required early scan on
1644 objects and libraries has performed above. In the !shared_obj case, we
1645 expect the relevant tables to be dragged together with their associated
1646 functions from precise cross reference insertions by the compiler. */
1648 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1653 #ifdef COLLECT_EXPORT_LIST
1654 /* Make sure we delete the export file we may have created. */
1655 if (export_file
!= 0 && export_file
[0])
1656 maybe_unlink (export_file
);
1658 if (lto_mode
!= LTO_MODE_NONE
)
1659 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1661 post_ld_pass (/*temp_file*/false);
1667 /* Unless we have done it all already, examine the namelist and search for
1668 static constructors and destructors to call. Write the constructor and
1669 destructor tables to a .s file and reload. */
1671 if (ld1_filter
!= SCAN_NOTHING
)
1672 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1674 #ifdef SCAN_LIBRARIES
1675 scan_libraries (output_file
);
1680 notice_translated (ngettext ("%d constructor found\n",
1681 "%d constructors found\n",
1682 constructors
.number
),
1683 constructors
.number
);
1684 notice_translated (ngettext ("%d destructor found\n",
1685 "%d destructors found\n",
1686 destructors
.number
),
1687 destructors
.number
);
1688 notice_translated (ngettext ("%d frame table found\n",
1689 "%d frame tables found\n",
1690 frame_tables
.number
),
1691 frame_tables
.number
);
1694 /* If the scan exposed nothing of special interest, there's no need to
1695 generate the glue code and relink so return now. */
1697 if (constructors
.number
== 0 && destructors
.number
== 0
1698 && frame_tables
.number
== 0
1699 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1700 /* If we will be running these functions ourselves, we want to emit
1701 stubs into the shared library so that we do not have to relink
1702 dependent programs when we add static objects. */
1707 /* Do link without additional code generation now if we didn't
1708 do it earlier for scanning purposes. */
1709 if (ld1_filter
== SCAN_NOTHING
)
1713 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1715 /* Strip now if it was requested on the command line. */
1718 char **real_strip_argv
= XCNEWVEC (char *, 3);
1719 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1722 strip_argv
[0] = strip_file_name
;
1723 strip_argv
[1] = output_file
;
1724 strip_argv
[2] = (char *) 0;
1725 fork_execute ("strip", real_strip_argv
, false);
1728 #ifdef COLLECT_EXPORT_LIST
1729 maybe_unlink (export_file
);
1731 post_ld_pass (/*temp_file*/false);
1735 /* Sort ctor and dtor lists by priority. */
1736 sort_ids (&constructors
);
1737 sort_ids (&destructors
);
1739 maybe_unlink (output_file
);
1740 outf
= fopen (c_file
, "w");
1741 if (outf
== (FILE *) 0)
1742 fatal_error (input_location
, "fopen %s: %m", c_file
);
1744 write_c_file (outf
, c_file
);
1747 fatal_error (input_location
, "fclose %s: %m", c_file
);
1749 /* Tell the linker that we have initializer and finalizer functions. */
1750 #ifdef LD_INIT_SWITCH
1751 #ifdef COLLECT_EXPORT_LIST
1752 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1754 *ld2
++ = LD_INIT_SWITCH
;
1756 *ld2
++ = LD_FINI_SWITCH
;
1761 #ifdef COLLECT_EXPORT_LIST
1764 /* If we did not add export flag to link arguments before, add it to
1765 second link phase now. No new exports should have been added. */
1766 if (! exports
.first
)
1767 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1769 #ifdef TARGET_AIX_VERSION
1770 add_to_list (&exports
, aix_shared_initname
);
1771 add_to_list (&exports
, aix_shared_fininame
);
1774 #ifndef LD_INIT_SWITCH
1775 add_to_list (&exports
, initname
);
1776 add_to_list (&exports
, fininame
);
1777 add_to_list (&exports
, "_GLOBAL__DI");
1778 add_to_list (&exports
, "_GLOBAL__DD");
1780 exportf
= fopen (export_file
, "w");
1781 if (exportf
== (FILE *) 0)
1782 fatal_error (input_location
, "fopen %s: %m", export_file
);
1783 write_aix_file (exportf
, exports
.first
);
1784 if (fclose (exportf
))
1785 fatal_error (input_location
, "fclose %s: %m", export_file
);
1789 /* End of arguments to second link phase. */
1794 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1795 output_file
, c_file
);
1796 write_c_file (stderr
, "stderr");
1797 fprintf (stderr
, "========== end of c_file\n\n");
1798 #ifdef COLLECT_EXPORT_LIST
1799 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1800 write_aix_file (stderr
, exports
.first
);
1801 fprintf (stderr
, "========== end of export_file\n\n");
1805 /* Assemble the constructor and destructor tables.
1806 Link the tables in with the rest of the program. */
1808 fork_execute ("gcc", c_argv
, at_file_supplied
);
1809 #ifdef COLLECT_EXPORT_LIST
1810 /* On AIX we must call link because of possible templates resolution. */
1814 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1816 /* Otherwise, simply call ld because link is already done. */
1818 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1821 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1822 post_ld_pass (/*temp_file*/false);
1825 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1826 constructors/destructors in shared libraries. */
1827 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1834 /* Unlink FILE unless we are debugging or this is the output_file
1835 and we may not unlink it. */
1838 maybe_unlink (const char *file
)
1840 if (save_temps
&& file_exists (file
))
1843 notice ("[Leaving %s]\n", file
);
1847 if (file
== output_file
&& !may_unlink_output_file
)
1850 unlink_if_ordinary (file
);
1853 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1856 maybe_unlink_list (char **file_list
)
1858 char **tmp
= file_list
;
1861 maybe_unlink (*(tmp
++));
1865 static long sequence_number
= 0;
1867 /* Add a name to a linked list. */
1870 add_to_list (struct head
*head_ptr
, const char *name
)
1873 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1875 strcpy (newid
->name
, name
);
1877 if (head_ptr
->first
)
1878 head_ptr
->last
->next
= newid
;
1880 head_ptr
->first
= newid
;
1882 /* Check for duplicate symbols. */
1883 for (p
= head_ptr
->first
;
1884 strcmp (name
, p
->name
) != 0;
1889 head_ptr
->last
->next
= 0;
1894 newid
->sequence
= ++sequence_number
;
1895 head_ptr
->last
= newid
;
1899 /* Grab the init priority number from an init function name that
1900 looks like "_GLOBAL_.I.12345.foo". */
1903 extract_init_priority (const char *name
)
1907 #ifdef TARGET_AIX_VERSION
1908 /* Run dependent module initializers before any constructors in this
1910 switch (is_ctor_dtor (name
))
1920 while (name
[pos
] == '_')
1922 pos
+= 10; /* strlen ("GLOBAL__X_") */
1924 /* Extract init_p number from ctor/dtor name. */
1925 pri
= atoi (name
+ pos
);
1926 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1929 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1930 ctors will be run from right to left, dtors from left to right. */
1933 sort_ids (struct head
*head_ptr
)
1935 /* id holds the current element to insert. id_next holds the next
1936 element to insert. id_ptr iterates through the already sorted elements
1937 looking for the place to insert id. */
1938 struct id
*id
, *id_next
, **id_ptr
;
1940 id
= head_ptr
->first
;
1942 /* We don't have any sorted elements yet. */
1943 head_ptr
->first
= NULL
;
1945 for (; id
; id
= id_next
)
1948 id
->sequence
= extract_init_priority (id
->name
);
1950 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
1952 /* If the sequence numbers are the same, we put the id from the
1953 file later on the command line later in the list. */
1954 || id
->sequence
> (*id_ptr
)->sequence
1955 /* Hack: do lexical compare, too.
1956 || (id->sequence == (*id_ptr)->sequence
1957 && strcmp (id->name, (*id_ptr)->name) > 0) */
1966 /* Now set the sequence numbers properly so write_c_file works. */
1967 for (id
= head_ptr
->first
; id
; id
= id
->next
)
1968 id
->sequence
= ++sequence_number
;
1971 /* Write: `prefix', the names on list LIST, `suffix'. */
1974 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
1978 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
1983 #ifdef COLLECT_EXPORT_LIST
1984 /* This function is really used only on AIX, but may be useful. */
1986 is_in_list (const char *prefix
, struct id
*list
)
1990 if (!strcmp (prefix
, list
->name
)) return 1;
1995 #endif /* COLLECT_EXPORT_LIST */
1997 /* Added for debugging purpose. */
1998 #ifdef COLLECT_EXPORT_LIST
2000 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2004 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2012 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2016 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2023 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2027 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2028 prefix
, list
->sequence
, list
->name
);
2033 /* Write out the constructor and destructor tables statically (for a shared
2034 object), along with the functions to execute them. */
2037 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2041 int frames
= (frame_tables
.number
> 0);
2043 /* Figure out name of output_file, stripping off .so version. */
2044 q
= p
= lbasename (output_file
);
2056 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2058 q
+= strlen (SHLIB_SUFFIX
);
2065 /* q points to null at end of the string (or . of the .so version) */
2066 prefix
= XNEWVEC (char, q
- p
+ 1);
2067 strncpy (prefix
, p
, q
- p
);
2069 for (r
= prefix
; *r
; r
++)
2070 if (!ISALNUM ((unsigned char)*r
))
2073 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2074 output_file
, prefix
);
2076 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2077 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2078 #ifdef TARGET_AIX_VERSION
2079 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2080 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2085 /* Write the tables as C code. */
2087 /* This count variable is used to prevent multiple calls to the
2088 constructors/destructors.
2089 This guard against multiple calls is important on AIX as the initfini
2090 functions are deliberately invoked multiple times as part of the
2091 mechanisms GCC uses to order constructors across different dependent
2092 shared libraries (see config/rs6000/aix.h).
2094 fprintf (stream
, "static int count;\n");
2095 fprintf (stream
, "typedef void entry_pt();\n");
2096 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2100 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2102 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2103 write_list (stream
, "\t\t&", frame_tables
.first
);
2104 fprintf (stream
, "\t0\n};\n");
2106 /* This must match what's in frame.h. */
2107 fprintf (stream
, "struct object {\n");
2108 fprintf (stream
, " void *pc_begin;\n");
2109 fprintf (stream
, " void *pc_end;\n");
2110 fprintf (stream
, " void *fde_begin;\n");
2111 fprintf (stream
, " void *fde_array;\n");
2112 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2113 fprintf (stream
, " struct object *next;\n");
2114 fprintf (stream
, "};\n");
2116 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2117 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2118 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2119 #ifdef TARGET_AIX_VERSION
2120 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2123 fprintf (stream
, "static void reg_frame () {\n");
2124 fprintf (stream
, "\tstatic struct object ob;\n");
2125 #ifdef TARGET_AIX_VERSION
2126 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2127 This might not be the start of the segment, signed offsets assumed.
2129 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2131 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2133 fprintf (stream
, "\t}\n");
2135 fprintf (stream
, "static void dereg_frame () {\n");
2136 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2137 fprintf (stream
, "\t}\n");
2140 #ifdef COLLECT_EXPORT_LIST
2141 /* Set visibility of initializers to default. */
2142 if (visibility_flag
)
2143 fprintf (stream
, "#pragma GCC visibility push(default)\n");
2145 fprintf (stream
, "void %s() {\n", initname
);
2146 if (constructors
.number
> 0 || frames
)
2148 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2149 write_list (stream
, "\t\t", constructors
.first
);
2151 fprintf (stream
, "\treg_frame,\n");
2152 fprintf (stream
, "\t};\n");
2153 fprintf (stream
, "\tentry_pt **p;\n");
2154 fprintf (stream
, "\tif (count++ != 0) return;\n");
2155 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2156 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2159 fprintf (stream
, "\t++count;\n");
2160 fprintf (stream
, "}\n");
2161 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2162 fprintf (stream
, "void %s() {\n", fininame
);
2163 if (destructors
.number
> 0 || frames
)
2165 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2166 write_list (stream
, "\t\t", destructors
.first
);
2168 fprintf (stream
, "\tdereg_frame,\n");
2169 fprintf (stream
, "\t};\n");
2170 fprintf (stream
, "\tentry_pt **p;\n");
2171 fprintf (stream
, "\tif (--count != 0) return;\n");
2172 fprintf (stream
, "\tp = dtors;\n");
2173 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2174 destructors
.number
+ frames
);
2176 fprintf (stream
, "}\n");
2177 #ifdef COLLECT_EXPORT_LIST
2178 if (visibility_flag
)
2179 fprintf (stream
, "#pragma GCC visibility pop\n");
2184 #ifdef COLLECT_EXPORT_LIST
2185 /* Set visibility of initializers to default. */
2186 if (visibility_flag
)
2187 fprintf (stream
, "#pragma GCC visibility push(default)\n");
2189 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2190 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2191 #ifdef COLLECT_EXPORT_LIST
2192 if (visibility_flag
)
2193 fprintf (stream
, "#pragma GCC visibility pop\n");
2198 /* Write the constructor/destructor tables. */
2200 #ifndef LD_INIT_SWITCH
2202 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2204 /* Write the tables as C code. */
2206 int frames
= (frame_tables
.number
> 0);
2208 fprintf (stream
, "typedef void entry_pt();\n\n");
2210 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2214 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2216 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2217 write_list (stream
, "\t\t&", frame_tables
.first
);
2218 fprintf (stream
, "\t0\n};\n");
2220 /* This must match what's in frame.h. */
2221 fprintf (stream
, "struct object {\n");
2222 fprintf (stream
, " void *pc_begin;\n");
2223 fprintf (stream
, " void *pc_end;\n");
2224 fprintf (stream
, " void *fde_begin;\n");
2225 fprintf (stream
, " void *fde_array;\n");
2226 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2227 fprintf (stream
, " struct object *next;\n");
2228 fprintf (stream
, "};\n");
2230 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2231 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2233 fprintf (stream
, "static void reg_frame () {\n");
2234 fprintf (stream
, "\tstatic struct object ob;\n");
2235 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2236 fprintf (stream
, "\t}\n");
2238 fprintf (stream
, "static void dereg_frame () {\n");
2239 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2240 fprintf (stream
, "\t}\n");
2243 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2244 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2245 write_list (stream
, "\t", constructors
.first
);
2247 fprintf (stream
, "\treg_frame,\n");
2248 fprintf (stream
, "\t0\n};\n\n");
2250 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2252 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2253 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2254 write_list (stream
, "\t", destructors
.first
);
2256 fprintf (stream
, "\tdereg_frame,\n");
2257 fprintf (stream
, "\t0\n};\n\n");
2259 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2260 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2262 #endif /* ! LD_INIT_SWITCH */
2265 write_c_file (FILE *stream
, const char *name
)
2267 #ifndef LD_INIT_SWITCH
2269 write_c_file_glob (stream
, name
);
2272 write_c_file_stat (stream
, name
);
2275 #ifdef COLLECT_EXPORT_LIST
2277 write_aix_file (FILE *stream
, struct id
*list
)
2279 for (; list
; list
= list
->next
)
2281 fputs (list
->name
, stream
);
2282 putc ('\n', stream
);
2287 #ifdef OBJECT_FORMAT_NONE
2289 /* Check to make sure the file is an LTO object file. */
2292 has_lto_section (void *data
, const char *name ATTRIBUTE_UNUSED
,
2293 off_t offset ATTRIBUTE_UNUSED
,
2294 off_t length ATTRIBUTE_UNUSED
)
2296 int *found
= (int *) data
;
2298 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
2299 sizeof (LTO_SECTION_NAME_PREFIX
) - 1) != 0)
2301 if (strncmp (name
, OFFLOAD_SECTION_NAME_PREFIX
,
2302 sizeof (OFFLOAD_SECTION_NAME_PREFIX
) - 1) != 0)
2308 /* Stop iteration. */
2313 is_lto_object_file (const char *prog_name
)
2319 int infd
= open (prog_name
, O_RDONLY
| O_BINARY
);
2324 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
2330 errmsg
= simple_object_find_sections (inobj
, has_lto_section
,
2331 (void *) &found
, &err
);
2332 if (! errmsg
&& found
)
2336 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
2340 /* Generic version to scan the name list of the loaded program for
2341 the symbols g++ uses for static constructors and destructors. */
2344 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2347 void (*int_handler
) (int);
2349 void (*quit_handler
) (int);
2351 char *real_nm_argv
[4];
2352 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2354 struct pex_obj
*pex
;
2360 if (which_pass
== PASS_SECOND
)
2363 /* LTO objects must be in a known format. This check prevents
2364 us from accepting an archive containing LTO objects, which
2365 gcc cannot currently handle. */
2366 if (which_pass
== PASS_LTOINFO
)
2368 if(is_lto_object_file (prog_name
)) {
2369 add_lto_object (<o_objects
, prog_name
);
2374 /* If we do not have an `nm', complain. */
2375 if (nm_file_name
== 0)
2376 fatal_error (input_location
, "cannot find %<nm%>");
2378 nm_argv
[argc
++] = nm_file_name
;
2379 if (NM_FLAGS
[0] != '\0')
2380 nm_argv
[argc
++] = NM_FLAGS
;
2382 nm_argv
[argc
++] = prog_name
;
2383 nm_argv
[argc
++] = (char *) 0;
2385 /* Trace if needed. */
2388 const char **p_argv
;
2391 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2392 fprintf (stderr
, " %s", str
);
2394 fprintf (stderr
, "\n");
2400 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2402 fatal_error (input_location
, "%<pex_init%> failed: %m");
2404 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2411 fatal_error (input_location
, "%s: %m", _(errmsg
));
2414 fatal_error (input_location
, errmsg
);
2417 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2419 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2422 inf
= pex_read_output (pex
, 0);
2424 fatal_error (input_location
, "cannot open nm output: %m");
2427 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2429 /* Read each line of nm output. */
2430 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2436 fprintf (stderr
, "\t%s\n", buf
);
2438 /* If it contains a constructor or destructor name, add the name
2439 to the appropriate list unless this is a kind of symbol we're
2440 not supposed to even consider. */
2442 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2443 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2450 /* Find the end of the symbol name.
2451 Do not include `|', because Encore nm can tack that on the end. */
2452 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2459 switch (is_ctor_dtor (name
))
2462 if (! (filter
& SCAN_CTOR
))
2464 if (which_pass
!= PASS_LIB
)
2465 add_to_list (&constructors
, name
);
2469 if (! (filter
& SCAN_DTOR
))
2471 if (which_pass
!= PASS_LIB
)
2472 add_to_list (&destructors
, name
);
2476 if (! (filter
& SCAN_INIT
))
2478 if (which_pass
!= PASS_LIB
)
2479 fatal_error (input_location
, "init function found in object %s",
2481 #ifndef LD_INIT_SWITCH
2482 add_to_list (&constructors
, name
);
2487 if (! (filter
& SCAN_FINI
))
2489 if (which_pass
!= PASS_LIB
)
2490 fatal_error (input_location
, "fini function found in object %s",
2492 #ifndef LD_FINI_SWITCH
2493 add_to_list (&destructors
, name
);
2498 if (! (filter
& SCAN_DWEH
))
2500 if (which_pass
!= PASS_LIB
)
2501 add_to_list (&frame_tables
, name
);
2504 default: /* not a constructor or destructor */
2510 fprintf (stderr
, "\n");
2512 do_wait (nm_file_name
, pex
);
2514 signal (SIGINT
, int_handler
);
2516 signal (SIGQUIT
, quit_handler
);
2522 /* Use the List Dynamic Dependencies program to find shared libraries that
2523 the output file depends upon and their initialization/finalization
2524 routines, if any. */
2527 scan_libraries (const char *prog_name
)
2529 static struct head libraries
; /* list of shared libraries found */
2531 void (*int_handler
) (int);
2533 void (*quit_handler
) (int);
2535 char *real_ldd_argv
[4];
2536 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2538 struct pex_obj
*pex
;
2544 /* If we do not have an `ldd', complain. */
2545 if (ldd_file_name
== 0)
2547 error ("cannot find %<ldd%>");
2551 ldd_argv
[argc
++] = ldd_file_name
;
2552 ldd_argv
[argc
++] = prog_name
;
2553 ldd_argv
[argc
++] = (char *) 0;
2555 /* Trace if needed. */
2558 const char **p_argv
;
2561 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2562 fprintf (stderr
, " %s", str
);
2564 fprintf (stderr
, "\n");
2570 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2572 fatal_error (input_location
, "pex_init failed: %m");
2574 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2580 fatal_error (input_location
, "%s: %m", _(errmsg
));
2583 fatal_error (input_location
, errmsg
);
2586 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2588 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2591 inf
= pex_read_output (pex
, 0);
2593 fatal_error (input_location
, "cannot open ldd output: %m");
2596 notice ("\nldd output with constructors/destructors.\n");
2598 /* Read each line of ldd output. */
2599 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2602 char *name
, *end
, *p
= buf
;
2604 /* Extract names of libraries and add to list. */
2605 PARSE_LDD_OUTPUT (p
);
2610 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2611 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2613 /* Find the end of the symbol name. */
2615 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2620 if (access (name
, R_OK
) == 0)
2621 add_to_list (&libraries
, name
);
2623 fatal_error (input_location
, "unable to open dynamic dependency "
2627 fprintf (stderr
, "\t%s\n", buf
);
2630 fprintf (stderr
, "\n");
2632 do_wait (ldd_file_name
, pex
);
2634 signal (SIGINT
, int_handler
);
2636 signal (SIGQUIT
, quit_handler
);
2639 /* Now iterate through the library list adding their symbols to
2641 for (list
= libraries
.first
; list
; list
= list
->next
)
2642 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2645 #endif /* LDD_SUFFIX */
2647 #endif /* OBJECT_FORMAT_NONE */
2651 * COFF specific stuff.
2654 #ifdef OBJECT_FORMAT_COFF
2656 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2657 # define GCC_SYMENT SYMENT
2658 # if defined (C_WEAKEXT)
2659 # define GCC_OK_SYMBOL(X) \
2660 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2661 ((X).n_scnum > N_UNDEF) && \
2663 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2664 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2665 # define GCC_UNDEF_SYMBOL(X) \
2666 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2667 ((X).n_scnum == N_UNDEF))
2669 # define GCC_OK_SYMBOL(X) \
2670 (((X).n_sclass == C_EXT) && \
2671 ((X).n_scnum > N_UNDEF) && \
2673 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2674 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2675 # define GCC_UNDEF_SYMBOL(X) \
2676 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2678 # define GCC_SYMINC(X) ((X).n_numaux+1)
2679 # define GCC_SYMZERO(X) 0
2681 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2682 #if TARGET_AIX_VERSION >= 51
2683 # define GCC_CHECK_HDR(X) \
2684 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2685 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2686 && !(HEADER (X).f_flags & F_LOADONLY))
2688 # define GCC_CHECK_HDR(X) \
2689 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2690 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2691 && !(HEADER (X).f_flags & F_LOADONLY))
2694 #ifdef COLLECT_EXPORT_LIST
2695 /* Array of standard AIX libraries which should not
2696 be scanned for ctors/dtors. */
2697 static const char *const aix_std_libs
[] = {
2705 "/usr/lib/libc_r.a",
2706 "/usr/lib/libm_r.a",
2707 "/usr/lib/threads/libc.a",
2708 "/usr/ccs/lib/libc.a",
2709 "/usr/ccs/lib/libm.a",
2710 "/usr/ccs/lib/libc_r.a",
2711 "/usr/ccs/lib/libm_r.a",
2715 /* This function checks the filename and returns 1
2716 if this name matches the location of a standard AIX library. */
2717 static int ignore_library (const char *);
2719 ignore_library (const char *name
)
2721 const char *const *p
;
2724 if (target_system_root
[0] != '\0')
2726 length
= strlen (target_system_root
);
2727 if (strncmp (name
, target_system_root
, length
) != 0)
2731 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2732 if (strcmp (name
, *p
) == 0)
2736 #endif /* COLLECT_EXPORT_LIST */
2738 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2739 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2742 /* COFF version to scan the name list of the loaded program for
2743 the symbols g++ uses for static constructors and destructors. */
2746 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2749 LDFILE
*ldptr
= NULL
;
2750 int sym_index
, sym_count
;
2753 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2756 #ifdef COLLECT_EXPORT_LIST
2757 /* We do not need scanning for some standard C libraries. */
2758 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2761 /* On AIX we have a loop, because there is not much difference
2762 between an object and an archive. This trick allows us to
2763 eliminate scan_libraries() function. */
2767 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2768 non-const char * filename parameter, even though it will not
2769 modify that string. So we must cast away const-ness here,
2770 using CONST_CAST to prevent complaints from -Wcast-qual. */
2771 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2773 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2774 fatal_error (input_location
, "%s: not a COFF file", prog_name
);
2776 if (GCC_CHECK_HDR (ldptr
))
2778 sym_count
= GCC_SYMBOLS (ldptr
);
2779 sym_index
= GCC_SYMZERO (ldptr
);
2781 #ifdef COLLECT_EXPORT_LIST
2782 /* Is current archive member a shared object? */
2783 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2786 while (sym_index
< sym_count
)
2790 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2792 sym_index
+= GCC_SYMINC (symbol
);
2794 if (GCC_OK_SYMBOL (symbol
))
2798 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2799 continue; /* Should never happen. */
2801 #ifdef XCOFF_DEBUGGING_INFO
2802 /* All AIX function names have a duplicate entry
2803 beginning with a dot. */
2808 switch (is_ctor_dtor (name
))
2810 #if TARGET_AIX_VERSION
2811 /* Add AIX shared library initalisers/finalisers
2812 to the constructors/destructors list of the
2815 if (! (filter
& SCAN_CTOR
))
2817 if (is_shared
&& !aixlazy_flag
2818 #ifdef COLLECT_EXPORT_LIST
2820 && ! is_in_list (prog_name
, static_libs
.first
)
2823 add_to_list (&constructors
, name
);
2827 if (! (filter
& SCAN_DTOR
))
2829 if (is_shared
&& !aixlazy_flag
)
2830 add_to_list (&destructors
, name
);
2835 if (! (filter
& SCAN_CTOR
))
2838 add_to_list (&constructors
, name
);
2839 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2840 if (which_pass
== PASS_OBJ
)
2841 add_to_list (&exports
, name
);
2846 if (! (filter
& SCAN_DTOR
))
2849 add_to_list (&destructors
, name
);
2850 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2851 if (which_pass
== PASS_OBJ
)
2852 add_to_list (&exports
, name
);
2856 #ifdef COLLECT_EXPORT_LIST
2858 if (! (filter
& SCAN_INIT
))
2860 #ifndef LD_INIT_SWITCH
2862 add_to_list (&constructors
, name
);
2867 if (! (filter
& SCAN_FINI
))
2869 #ifndef LD_INIT_SWITCH
2871 add_to_list (&destructors
, name
);
2877 if (! (filter
& SCAN_DWEH
))
2880 add_to_list (&frame_tables
, name
);
2881 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2882 if (which_pass
== PASS_OBJ
)
2883 add_to_list (&exports
, name
);
2887 default: /* not a constructor or destructor */
2888 #ifdef COLLECT_EXPORT_LIST
2889 /* Explicitly export all global symbols when
2890 building a shared object on AIX, but do not
2891 re-export symbols from another shared object
2892 and do not export symbols if the user
2893 provides an explicit export list. */
2894 if (shared_obj
&& !is_shared
2895 && which_pass
== PASS_OBJ
&& !export_flag
)
2897 /* Do not auto-export __dso_handle or
2898 __gcc_unwind_dbase. They are required
2899 to be local to each module. */
2900 if (strcmp(name
, "__dso_handle") != 0
2901 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2903 add_to_list (&exports
, name
);
2911 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2912 symbol
.n_scnum
, symbol
.n_sclass
,
2913 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2918 #ifdef COLLECT_EXPORT_LIST
2921 /* If archive contains both 32-bit and 64-bit objects,
2922 we want to skip objects in other mode so mismatch normal. */
2924 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2925 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2931 fatal_error (input_location
, "%s: cannot open as COFF file",
2934 #ifdef COLLECT_EXPORT_LIST
2935 /* On AIX loop continues while there are more members in archive. */
2937 while (ldclose (ldptr
) == FAILURE
);
2939 /* Otherwise we simply close ldptr. */
2940 (void) ldclose (ldptr
);
2943 #endif /* OBJECT_FORMAT_COFF */
2945 #ifdef COLLECT_EXPORT_LIST
2946 /* Given a library name without "lib" prefix, this function
2947 returns a full library name including a path. */
2949 resolve_lib_name (const char *name
)
2953 /* Library extensions for AIX dynamic linking. */
2954 const char * const libexts
[2] = {"a", "so"};
2956 for (i
= 0; libpaths
[i
]; i
++)
2957 if (libpaths
[i
]->max_len
> l
)
2958 l
= libpaths
[i
]->max_len
;
2960 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
2962 for (i
= 0; libpaths
[i
]; i
++)
2964 struct prefix_list
*list
= libpaths
[i
]->plist
;
2965 for (; list
; list
= list
->next
)
2967 /* The following lines are needed because path_prefix list
2968 may contain directories both with trailing DIR_SEPARATOR and
2971 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
2973 for (j
= 0; j
< 2; j
++)
2975 sprintf (lib_buf
, "%s%slib%s.%s",
2976 list
->prefix
, p
, name
,
2977 libexts
[(j
+ aixrtl_flag
) % 2]);
2978 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
2979 if (file_exists (lib_buf
))
2981 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
2988 fprintf (stderr
, "not found\n");
2990 fatal_error (input_location
, "library lib%s not found", name
);
2993 #endif /* COLLECT_EXPORT_LIST */
2995 #ifdef COLLECT_RUN_DSYMUTIL
2996 static int flag_dsym
= false;
2997 static int flag_idsym
= false;
3000 process_args (int *argcp
, char **argv
) {
3003 for (i
=0; i
<argc
; ++i
)
3005 if (strcmp (argv
[i
], "-dsym") == 0)
3008 /* Remove the flag, as we handle all processing for it. */
3011 argv
[j
] = argv
[j
+1];
3016 else if (strcmp (argv
[i
], "-idsym") == 0)
3019 /* Remove the flag, as we handle all processing for it. */
3022 argv
[j
] = argv
[j
+1];
3031 do_dsymutil (const char *output_file
) {
3032 const char *dsymutil
= DSYMUTIL
+ 1;
3033 struct pex_obj
*pex
;
3034 char **real_argv
= XCNEWVEC (char *, 3);
3035 const char ** argv
= CONST_CAST2 (const char **, char **,
3039 argv
[1] = output_file
;
3040 argv
[2] = (char *) 0;
3042 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3043 PEX_LAST
| PEX_SEARCH
, false);
3044 do_wait (dsymutil
, pex
);
3048 post_ld_pass (bool temp_file
) {
3049 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3052 do_dsymutil (output_file
);
3056 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3057 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }