1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2019 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
29 #include "coretypes.h"
31 #include "filenames.h"
32 #include "file-find.h"
33 #include "simple-object.h"
34 #include "lto-section-names.h"
36 /* TARGET_64BIT may be defined to use driver specific functionality. */
38 #define TARGET_64BIT TARGET_64BIT_DEFAULT
40 #ifndef LIBRARY_PATH_ENV
41 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
47 #include "collect2-aix.h"
48 #include "collect-utils.h"
49 #include "diagnostic.h"
55 /* On certain systems, we have code that works by scanning the object file
56 directly. But this code uses system-specific header files and library
57 functions, so turn it off in a cross-compiler. Likewise, the names of
58 the utilities are not correct for a cross-compiler; we have to hope that
59 cross-versions are in the proper directories. */
61 #ifdef CROSS_DIRECTORY_STRUCTURE
62 #ifndef CROSS_AIX_SUPPORT
63 #undef OBJECT_FORMAT_COFF
66 #undef REAL_LD_FILE_NAME
67 #undef REAL_NM_FILE_NAME
68 #undef REAL_STRIP_FILE_NAME
71 /* If we cannot use a special method, use the ordinary one:
72 run nm to find what symbols are present.
73 In a cross-compiler, this means you need a cross nm,
74 but that is not quite as unpleasant as special headers. */
76 #if !defined (OBJECT_FORMAT_COFF)
77 #define OBJECT_FORMAT_NONE
80 #ifdef OBJECT_FORMAT_COFF
82 #ifndef CROSS_DIRECTORY_STRUCTURE
90 /* Many versions of ldfcn.h define these. */
99 /* Some systems have an ISCOFF macro, but others do not. In some cases
100 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
101 that either do not have an ISCOFF macro in /usr/include or for those
102 where it is wrong. */
105 #define MY_ISCOFF(X) ISCOFF (X)
108 #endif /* OBJECT_FORMAT_COFF */
110 #ifdef OBJECT_FORMAT_NONE
112 /* Default flags to pass to nm. */
114 #define NM_FLAGS "-n"
117 #endif /* OBJECT_FORMAT_NONE */
119 /* Some systems use __main in a way incompatible with its use in gcc, in these
120 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
121 give the same symbol without quotes for an alternative entry point. */
123 #define NAME__MAIN "__main"
126 /* This must match tree.h. */
127 #define DEFAULT_INIT_PRIORITY 65535
129 #ifndef COLLECT_SHARED_INIT_FUNC
130 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
131 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
133 #ifndef COLLECT_SHARED_FINI_FUNC
134 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
135 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
139 #define SCAN_LIBRARIES
143 #define SHLIB_SUFFIX ".so"
147 int do_collecting
= 1;
149 int do_collecting
= 0;
152 /* Cook up an always defined indication of whether we proceed the
153 "EXPORT_LIST" way. */
155 #ifdef COLLECT_EXPORT_LIST
156 #define DO_COLLECT_EXPORT_LIST 1
158 #define DO_COLLECT_EXPORT_LIST 0
161 /* Nonzero if we should suppress the automatic demangling of identifiers
162 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
165 /* Linked lists of constructor and destructor names. */
181 static int rflag
; /* true if -r */
182 static int strip_flag
; /* true if -s */
183 #ifdef COLLECT_EXPORT_LIST
184 static int export_flag
; /* true if -bE */
185 static int aix64_flag
; /* true if -b64 */
186 static int aixrtl_flag
; /* true if -brtl */
187 static int aixlazy_flag
; /* true if -blazy */
191 LTO_MODE_NONE
, /* Not doing LTO. */
192 LTO_MODE_LTO
, /* Normal LTO. */
193 LTO_MODE_WHOPR
/* WHOPR. */
196 /* Current LTO mode. */
198 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
200 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
203 bool helpflag
; /* true if --help */
205 static int shared_obj
; /* true if -shared */
206 static int static_obj
; /* true if -static */
208 static char *c_file
; /* <xxx>.c for constructor/destructor list. */
209 static char *o_file
; /* <xxx>.o for constructor/destructor list. */
210 #ifdef COLLECT_EXPORT_LIST
211 static const char *export_file
; /* <xxx>.x for AIX export list. */
213 static char **lto_o_files
; /* Output files for LTO. */
214 const char *ldout
; /* File for ld stdout. */
215 const char *lderrout
; /* File for ld stderr. */
216 static const char *output_file
; /* Output file for ld. */
217 static const char *nm_file_name
; /* pathname of nm */
219 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
221 static const char *strip_file_name
; /* pathname of strip */
222 const char *c_file_name
; /* pathname of gcc */
223 static char *initname
, *fininame
; /* names of init and fini funcs */
226 #ifdef TARGET_AIX_VERSION
227 static char *aix_shared_initname
;
228 static char *aix_shared_fininame
; /* init/fini names as per the scheme
229 described in config/rs6000/aix.h */
232 static struct head constructors
; /* list of constructors found */
233 static struct head destructors
; /* list of destructors found */
234 #ifdef COLLECT_EXPORT_LIST
235 static struct head exports
; /* list of exported symbols */
237 static struct head frame_tables
; /* list of frame unwind info tables */
239 bool at_file_supplied
; /* Whether to use @file arguments */
241 struct obstack temporary_obstack
;
242 char * temporary_firstobj
;
244 /* A string that must be prepended to a target OS path in order to find
245 it on the host system. */
246 #ifdef TARGET_SYSTEM_ROOT
247 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
249 static const char *target_system_root
= "";
252 /* Whether we may unlink the output file, which should be set as soon as we
253 know we have successfully produced it. This is typically useful to prevent
254 blindly attempting to unlink a read-only output that the target linker
255 would leave untouched. */
256 bool may_unlink_output_file
= false;
258 #ifdef COLLECT_EXPORT_LIST
259 /* Lists to keep libraries to be scanned for global constructors/destructors. */
260 static struct head libs
; /* list of libraries */
261 static struct head static_libs
; /* list of statically linked libraries */
262 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
263 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
264 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
265 &libpath_lib_dirs
, NULL
};
268 /* List of names of object files containing LTO information.
269 These are a subset of the object file names appearing on the
270 command line, and must be identical, in the sense of pointer
271 equality, with the names passed to maybe_run_lto_and_relink(). */
275 const char *name
; /* Name of object file. */
276 struct lto_object
*next
; /* Next in linked list. */
279 struct lto_object_list
281 struct lto_object
*first
; /* First list element. */
282 struct lto_object
*last
; /* Last list element. */
285 static struct lto_object_list lto_objects
;
287 /* Special kinds of symbols that a name may denote. */
290 SYM_REGULAR
= 0, /* nothing special */
292 SYM_CTOR
= 1, /* constructor */
293 SYM_DTOR
= 2, /* destructor */
294 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
295 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
296 SYM_DWEH
= 5, /* DWARF exception handling table */
301 const char tool_name
[] = "collect2";
303 static symkind
is_ctor_dtor (const char *);
305 static void handler (int);
306 static void maybe_unlink_list (char **);
307 static void add_to_list (struct head
*, const char *);
308 static int extract_init_priority (const char *);
309 static void sort_ids (struct head
*);
310 static void write_list (FILE *, const char *, struct id
*);
311 #ifdef COLLECT_EXPORT_LIST
312 static void dump_list (FILE *, const char *, struct id
*);
315 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
317 static void write_list_with_asm (FILE *, const char *, struct id
*);
318 static void write_c_file (FILE *, const char *);
319 static void write_c_file_stat (FILE *, const char *);
320 #ifndef LD_INIT_SWITCH
321 static void write_c_file_glob (FILE *, const char *);
323 #ifdef SCAN_LIBRARIES
324 static void scan_libraries (const char *);
326 #ifdef COLLECT_EXPORT_LIST
327 static int is_in_list (const char *, struct id
*);
328 static void write_aix_file (FILE *, struct id
*);
329 static char *resolve_lib_name (const char *);
331 static char *extract_string (const char **);
332 static void post_ld_pass (bool);
333 static void process_args (int *argcp
, char **argv
);
335 /* Enumerations describing which pass this is for scanning the
339 PASS_FIRST
, /* without constructors */
340 PASS_OBJ
, /* individual objects */
341 PASS_LIB
, /* looking for shared libraries */
342 PASS_SECOND
, /* with constructors linked in */
343 PASS_LTOINFO
/* looking for objects with LTO info */
346 /* ... and which kinds of symbols are to be considered. */
348 enum scanfilter_masks
{
351 SCAN_CTOR
= 1 << SYM_CTOR
,
352 SCAN_DTOR
= 1 << SYM_DTOR
,
353 SCAN_INIT
= 1 << SYM_INIT
,
354 SCAN_FINI
= 1 << SYM_FINI
,
355 SCAN_DWEH
= 1 << SYM_DWEH
,
356 SCAN_AIXI
= 1 << SYM_AIXI
,
357 SCAN_AIXD
= 1 << SYM_AIXD
,
361 /* This type is used for parameters and variables which hold
362 combinations of the flags in enum scanfilter_masks. */
363 typedef int scanfilter
;
365 /* Scan the name list of the loaded program for the symbols g++ uses for
366 static constructors and destructors.
368 The SCANPASS argument tells which collect processing pass this is for and
369 the SCANFILTER argument tells which kinds of symbols to consider in this
370 pass. Symbols of a special kind not in the filter mask are considered as
373 The constructor table begins at __CTOR_LIST__ and contains a count of the
374 number of pointers (or -1 if the constructors are built in a separate
375 section by the linker), followed by the pointers to the constructor
376 functions, terminated with a null pointer. The destructor table has the
377 same format, and begins at __DTOR_LIST__. */
379 static void scan_prog_file (const char *, scanpass
, scanfilter
);
382 /* Delete tempfiles and exit function. */
385 tool_cleanup (bool from_signal
)
387 if (c_file
!= 0 && c_file
[0])
388 maybe_unlink (c_file
);
390 if (o_file
!= 0 && o_file
[0])
391 maybe_unlink (o_file
);
393 #ifdef COLLECT_EXPORT_LIST
394 if (export_file
!= 0 && export_file
[0])
395 maybe_unlink (export_file
);
399 maybe_unlink_list (lto_o_files
);
401 if (ldout
!= 0 && ldout
[0])
404 dump_ld_file (ldout
, stdout
);
405 maybe_unlink (ldout
);
408 if (lderrout
!= 0 && lderrout
[0])
411 dump_ld_file (lderrout
, stderr
);
412 maybe_unlink (lderrout
);
417 collect_atexit (void)
419 tool_cleanup (false);
427 signal (signo
, SIG_DFL
);
430 /* Notify user of a non-error, without translating the format string. */
432 notice_translated (const char *cmsgid
, ...)
436 va_start (ap
, cmsgid
);
437 vfprintf (stderr
, cmsgid
, ap
);
442 file_exists (const char *name
)
444 return access (name
, R_OK
) == 0;
447 /* Parse a reasonable subset of shell quoting syntax. */
450 extract_string (const char **pp
)
463 obstack_1grow (&temporary_obstack
, c
);
464 else if (! inside
&& c
== ' ')
466 else if (! inside
&& c
== '\\')
471 obstack_1grow (&temporary_obstack
, c
);
474 obstack_1grow (&temporary_obstack
, '\0');
476 return XOBFINISH (&temporary_obstack
, char *);
480 dump_ld_file (const char *name
, FILE *to
)
482 FILE *stream
= fopen (name
, "r");
489 while (c
= getc (stream
),
490 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
491 obstack_1grow (&temporary_obstack
, c
);
492 if (obstack_object_size (&temporary_obstack
) > 0)
494 const char *word
, *p
;
496 obstack_1grow (&temporary_obstack
, '\0');
497 word
= XOBFINISH (&temporary_obstack
, const char *);
500 ++word
, putc ('.', to
);
502 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
503 p
+= strlen (USER_LABEL_PREFIX
);
505 #ifdef HAVE_LD_DEMANGLE
511 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
519 diff
= strlen (word
) - strlen (result
);
520 while (diff
> 0 && c
== ' ')
521 --diff
, putc (' ', to
);
522 if (diff
< 0 && c
== ' ')
524 while (diff
< 0 && c
== ' ')
525 ++diff
, c
= getc (stream
);
528 /* Make sure we output at least one space, or
529 the demangled symbol name will run into
530 whatever text follows. */
541 obstack_free (&temporary_obstack
, temporary_firstobj
);
550 /* Return the kind of symbol denoted by name S. */
553 is_ctor_dtor (const char *s
)
555 struct names
{ const char *const name
; const int len
; symkind ret
;
556 const int two_underscores
; };
558 const struct names
*p
;
560 const char *orig_s
= s
;
562 static const struct names special
[] = {
563 #ifndef NO_DOLLAR_IN_LABEL
564 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
565 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
567 #ifndef NO_DOT_IN_LABEL
568 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
569 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
570 #endif /* NO_DOT_IN_LABEL */
571 #endif /* NO_DOLLAR_IN_LABEL */
572 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
573 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
574 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
575 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
576 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
577 #ifdef TARGET_AIX_VERSION
578 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
579 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
581 { NULL
, 0, SYM_REGULAR
, 0 }
584 while ((ch
= *s
) == '_')
590 for (p
= &special
[0]; p
->len
> 0; p
++)
593 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
594 && strncmp (s
, p
->name
, p
->len
) == 0)
602 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
603 and one from the PATH variable. */
605 static struct path_prefix cpath
, path
;
607 #ifdef CROSS_DIRECTORY_STRUCTURE
608 /* This is the name of the target machine. We use it to form the name
609 of the files to execute. */
611 static const char *const target_machine
= TARGET_MACHINE
;
614 /* Search for NAME using prefix list PPREFIX. We only look for executable
617 Return 0 if not found, otherwise return its name, allocated with malloc. */
619 #ifdef OBJECT_FORMAT_NONE
621 /* Add an entry for the object file NAME to object file list LIST.
622 New entries are added at the end of the list. The original pointer
623 value of NAME is preserved, i.e., no string copy is performed. */
626 add_lto_object (struct lto_object_list
*list
, const char *name
)
628 struct lto_object
*n
= XNEW (struct lto_object
);
633 list
->last
->next
= n
;
639 #endif /* OBJECT_FORMAT_NONE */
642 /* Perform a link-time recompilation and relink if any of the object
643 files contain LTO info. The linker command line LTO_LD_ARGV
644 represents the linker command that would produce a final executable
645 without the use of LTO. OBJECT_LST is a vector of object file names
646 appearing in LTO_LD_ARGV that are to be considered for link-time
647 recompilation, where OBJECT is a pointer to the last valid element.
648 (This awkward convention avoids an impedance mismatch with the
649 usage of similarly-named variables in main().) The elements of
650 OBJECT_LST must be identical, i.e., pointer equal, to the
651 corresponding arguments in LTO_LD_ARGV.
653 Upon entry, at least one linker run has been performed without the
654 use of any LTO info that might be present. Any recompilations
655 necessary for template instantiations have been performed, and
656 initializer/finalizer tables have been created if needed and
657 included in the linker command line LTO_LD_ARGV. If any of the
658 object files contain LTO info, we run the LTO back end on all such
659 files, and perform the final link with the LTO back end output
660 substituted for the LTO-optimized files. In some cases, a final
661 link with all link-time generated code has already been performed,
662 so there is no need to relink if no LTO info is found. In other
663 cases, our caller has not produced the final executable, and is
664 relying on us to perform the required link whether LTO info is
665 present or not. In that case, the FORCE argument should be true.
666 Note that the linker command line argument LTO_LD_ARGV passed into
667 this function may be modified in place. */
670 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
671 const char **object
, bool force
)
673 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
675 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
677 while (object_file
< object
)
679 /* If file contains LTO info, add it to the list of LTO objects. */
680 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
682 /* Increment the argument count by the number of object file arguments
683 we will add. An upper bound suffices, so just count all of the
684 object files regardless of whether they contain LTO info. */
688 if (lto_objects
.first
)
691 const char **lto_c_ptr
;
694 struct lto_object
*list
;
695 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
697 const char *prog
= "lto-wrapper";
698 int lto_ld_argv_size
= 0;
699 char **out_lto_ld_argv
;
700 int out_lto_ld_argv_size
;
704 fatal_error (input_location
, "environment variable "
705 "%<COLLECT_LTO_WRAPPER%> must be set");
709 /* There is at least one object file containing LTO info,
710 so we need to run the LTO back end and relink.
712 To do so we build updated ld arguments with first
713 LTO object replaced by all partitions and other LTO
716 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
717 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
719 *lto_c_ptr
++ = lto_wrapper
;
721 /* Add LTO objects to the wrapper command line. */
722 for (list
= lto_objects
.first
; list
; list
= list
->next
)
723 *lto_c_ptr
++ = list
->name
;
727 /* Run the LTO back end. */
728 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
736 stream
= pex_read_output (pex
, 0);
740 while ((c
= getc (stream
)) != EOF
)
742 obstack_1grow (&temporary_obstack
, c
);
747 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
748 lto_o_files
[num_files
] = NULL
;
749 start
= XOBFINISH (&temporary_obstack
, char *);
750 for (i
= 0; i
< num_files
; ++i
)
757 lto_o_files
[i
] = xstrdup (start
);
762 obstack_free (&temporary_obstack
, temporary_firstobj
);
767 /* Compute memory needed for new LD arguments. At most number of original arguments
768 plus number of partitions. */
769 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
771 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
772 out_lto_ld_argv_size
= 0;
774 /* After running the LTO back end, we will relink, substituting
775 the LTO output for the object files that we submitted to the
776 LTO. Here, we modify the linker command line for the relink. */
778 /* Copy all arguments until we find first LTO file. */
782 for (list
= lto_objects
.first
; list
; list
= list
->next
)
783 if (*p
== list
->name
) /* Note test for pointer equality! */
787 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
790 /* Now insert all LTO partitions. */
791 lto_o_ptr
= lto_o_files
;
793 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
795 /* ... and copy the rest. */
798 for (list
= lto_objects
.first
; list
; list
= list
->next
)
799 if (*p
== list
->name
) /* Note test for pointer equality! */
802 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
805 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
807 /* Run the linker again, this time replacing the object files
808 optimized by the LTO with the temporary file generated by the LTO. */
809 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
810 /* We assume that temp files were created, and therefore we need to take
811 that into account (maybe run dsymutil). */
812 post_ld_pass (/*temp_file*/true);
815 maybe_unlink_list (lto_o_files
);
819 /* Our caller is relying on us to do the link
820 even though there is no LTO back end work to be done. */
821 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
822 /* No LTO objects were found, so no new temp file. */
823 post_ld_pass (/*temp_file*/false);
826 post_ld_pass (false); /* No LTO objects were found, no temp file. */
828 /* Entry point for linker invoation. Called from main in collect2.c.
829 LD_ARGV is an array of arguments for the linker. */
832 do_link (char **ld_argv
)
835 const char *prog
= "ld";
836 pex
= collect_execute (prog
, ld_argv
, NULL
, NULL
,
837 PEX_LAST
| PEX_SEARCH
,
838 HAVE_GNU_LD
&& at_file_supplied
);
839 int ret
= collect_wait (prog
, pex
);
842 error ("ld returned %d exit status", ret
);
847 /* We have just successfully produced an output file, so assume that we
848 may unlink it if need be for now on. */
849 may_unlink_output_file
= true;
856 main (int argc
, char **argv
)
866 } selected_linker
= USE_DEFAULT_LD
;
867 static const char *const ld_suffixes
[USE_LD_MAX
] =
875 static const char *const real_ld_suffix
= "real-ld";
876 static const char *const collect_ld_suffix
= "collect-ld";
877 static const char *const nm_suffix
= "nm";
878 static const char *const gnm_suffix
= "gnm";
880 static const char *const ldd_suffix
= LDD_SUFFIX
;
882 static const char *const strip_suffix
= "strip";
883 static const char *const gstrip_suffix
= "gstrip";
885 const char *full_ld_suffixes
[USE_LD_MAX
];
886 #ifdef CROSS_DIRECTORY_STRUCTURE
887 /* If we look for a program in the compiler directories, we just use
888 the short name, since these directories are already system-specific.
889 But it we look for a program in the system directories, we need to
890 qualify the program name with the target machine. */
892 const char *const full_nm_suffix
=
893 concat (target_machine
, "-", nm_suffix
, NULL
);
894 const char *const full_gnm_suffix
=
895 concat (target_machine
, "-", gnm_suffix
, NULL
);
897 const char *const full_ldd_suffix
=
898 concat (target_machine
, "-", ldd_suffix
, NULL
);
900 const char *const full_strip_suffix
=
901 concat (target_machine
, "-", strip_suffix
, NULL
);
902 const char *const full_gstrip_suffix
=
903 concat (target_machine
, "-", gstrip_suffix
, NULL
);
906 const char *const full_ldd_suffix
= ldd_suffix
;
908 const char *const full_nm_suffix
= nm_suffix
;
909 const char *const full_gnm_suffix
= gnm_suffix
;
910 const char *const full_strip_suffix
= strip_suffix
;
911 const char *const full_gstrip_suffix
= gstrip_suffix
;
912 #endif /* CROSS_DIRECTORY_STRUCTURE */
916 #ifdef COLLECT_EXPORT_LIST
919 const char *ld_file_name
;
925 bool use_plugin
= false;
926 bool use_collect_ld
= false;
928 /* The kinds of symbols we will have to consider when scanning the
929 outcome of a first pass link. This is ALL to start with, then might
930 be adjusted before getting to the first pass link per se, typically on
931 AIX where we perform an early scan of objects and libraries to fetch
932 the list of global ctors/dtors and make sure they are not garbage
934 scanfilter ld1_filter
= SCAN_ALL
;
940 #ifdef TARGET_AIX_VERSION
941 int object_nbr
= argc
;
946 #ifdef COLLECT_EXPORT_LIST
947 bool is_static
= false;
951 for (i
= 0; i
< USE_LD_MAX
; i
++)
953 #ifdef CROSS_DIRECTORY_STRUCTURE
954 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
959 p
= argv
[0] + strlen (argv
[0]);
960 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
964 xmalloc_set_program_name (progname
);
967 expandargv (&argc
, &argv
);
968 if (argv
!= old_argv
)
969 at_file_supplied
= 1;
971 process_args (&argc
, argv
);
973 num_c_args
= argc
+ 9;
975 #ifndef HAVE_LD_DEMANGLE
976 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
978 /* Suppress demangling by the real linker, which may be broken. */
979 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
982 #if defined (COLLECT2_HOST_INITIALIZATION)
983 /* Perform system dependent initialization, if necessary. */
984 COLLECT2_HOST_INITIALIZATION
;
988 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
989 receive the signal. A different setting is inheritable */
990 signal (SIGCHLD
, SIG_DFL
);
993 /* Unlock the stdio streams. */
994 unlock_std_streams ();
998 diagnostic_initialize (global_dc
, 0);
1000 if (atexit (collect_atexit
) != 0)
1001 fatal_error (input_location
, "atexit failed");
1003 /* Do not invoke xcalloc before this point, since locale needs to be
1004 set first, in case a diagnostic is issued. */
1006 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
1007 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
1008 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
1009 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
1010 object_lst
= XCNEWVEC (char *, argc
);
1011 object
= CONST_CAST2 (const char **, char **, object_lst
);
1020 #ifndef DEFAULT_A_OUT_NAME
1021 output_file
= "a.out";
1023 output_file
= DEFAULT_A_OUT_NAME
;
1026 /* Parse command line / environment for flags we want early.
1027 This allows the debug flag to be set before functions like find_a_file()
1030 bool no_partition
= false;
1032 for (i
= 1; argv
[i
] != NULL
; i
++)
1034 if (! strcmp (argv
[i
], "-debug"))
1036 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1037 lto_mode
= LTO_MODE_NONE
;
1038 else if (! strcmp (argv
[i
], "-plugin"))
1041 if (selected_linker
== USE_DEFAULT_LD
)
1042 selected_linker
= USE_PLUGIN_LD
;
1044 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1045 selected_linker
= USE_BFD_LD
;
1046 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1047 selected_linker
= USE_GOLD_LD
;
1048 else if (strcmp (argv
[i
], "-fuse-ld=lld") == 0)
1049 selected_linker
= USE_LLD_LD
;
1050 else if (strncmp (argv
[i
], "-o", 2) == 0)
1052 /* Parse the output filename if it's given so that we can make
1053 meaningful temp filenames. */
1054 if (argv
[i
][2] == '\0')
1055 output_file
= argv
[i
+1];
1057 output_file
= &argv
[i
][2];
1060 #ifdef COLLECT_EXPORT_LIST
1061 /* These flags are position independent, although their order
1062 is important - subsequent flags override earlier ones. */
1063 else if (strcmp (argv
[i
], "-b64") == 0)
1065 /* -bexport:filename always needs the :filename */
1066 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1067 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1069 else if (strcmp (argv
[i
], "-brtl") == 0
1070 || strcmp (argv
[i
], "-bsvr4") == 0
1071 || strcmp (argv
[i
], "-G") == 0)
1073 else if (strcmp (argv
[i
], "-bnortl") == 0)
1075 else if (strcmp (argv
[i
], "-blazy") == 0)
1080 obstack_begin (&temporary_obstack
, 0);
1081 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1083 #ifndef HAVE_LD_DEMANGLE
1084 current_demangling_style
= auto_demangling
;
1087 /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1088 The LTO options are passed here as are other options that might
1089 be unsuitable for ld (e.g. -save-temps). */
1090 p
= getenv ("COLLECT_GCC_OPTIONS");
1093 const char *q
= extract_string (&p
);
1094 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1096 if (strncmp (q
, "-flto-partition=none", 20) == 0)
1097 no_partition
= true;
1098 else if (strncmp (q
, "-fno-lto", 8) == 0)
1099 lto_mode
= LTO_MODE_NONE
;
1100 else if (strncmp (q
, "-save-temps", 11) == 0)
1101 /* FIXME: Honour =obj. */
1104 obstack_free (&temporary_obstack
, temporary_firstobj
);
1106 verbose
= verbose
|| debug
;
1107 save_temps
= save_temps
|| debug
;
1108 find_file_set_debug (debug
);
1110 lto_mode
= LTO_MODE_NONE
;
1111 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1112 lto_mode
= LTO_MODE_LTO
;
1115 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1116 -fno-exceptions -w -fno-whole-program */
1119 c_argv
= XCNEWVEC (char *, num_c_args
);
1120 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1123 fatal_error (input_location
, "no arguments");
1126 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1127 signal (SIGQUIT
, handler
);
1129 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1130 signal (SIGINT
, handler
);
1132 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1133 signal (SIGALRM
, handler
);
1136 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1137 signal (SIGHUP
, handler
);
1139 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1140 signal (SIGSEGV
, handler
);
1142 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1143 signal (SIGBUS
, handler
);
1146 /* Extract COMPILER_PATH and PATH into our prefix list. */
1147 prefix_from_env ("COMPILER_PATH", &cpath
);
1148 prefix_from_env ("PATH", &path
);
1150 /* Try to discover a valid linker/nm/strip to use. */
1152 /* Maybe we know the right file to use (if not cross). */
1154 #ifdef DEFAULT_LINKER
1155 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
||
1156 selected_linker
== USE_LLD_LD
)
1159 # ifdef HOST_EXECUTABLE_SUFFIX
1160 int len
= (sizeof (DEFAULT_LINKER
)
1161 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1165 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1166 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1167 HOST_EXECUTABLE_SUFFIX. */
1168 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1170 default_linker
[len
] = '\0';
1171 linker_name
= concat (default_linker
,
1172 &ld_suffixes
[selected_linker
][2],
1173 HOST_EXECUTABLE_SUFFIX
, NULL
);
1176 if (linker_name
== NULL
)
1178 linker_name
= concat (DEFAULT_LINKER
,
1179 &ld_suffixes
[selected_linker
][2],
1181 if (access (linker_name
, X_OK
) == 0)
1182 ld_file_name
= linker_name
;
1184 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1185 ld_file_name
= DEFAULT_LINKER
;
1186 if (ld_file_name
== 0)
1188 #ifdef REAL_LD_FILE_NAME
1189 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1190 if (ld_file_name
== 0)
1192 /* Search the (target-specific) compiler dirs for ld'. */
1193 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1194 /* Likewise for `collect-ld'. */
1195 if (ld_file_name
== 0)
1197 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1198 use_collect_ld
= ld_file_name
!= 0;
1200 /* Search the compiler directories for `ld'. We have protection against
1201 recursive calls in find_a_file. */
1202 if (ld_file_name
== 0)
1203 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1204 /* Search the ordinary system bin directories
1205 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1206 if (ld_file_name
== 0)
1207 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1209 #ifdef REAL_NM_FILE_NAME
1210 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1211 if (nm_file_name
== 0)
1213 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1214 if (nm_file_name
== 0)
1215 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1216 if (nm_file_name
== 0)
1217 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1218 if (nm_file_name
== 0)
1219 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1222 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1223 if (ldd_file_name
== 0)
1224 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1227 #ifdef REAL_STRIP_FILE_NAME
1228 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1229 if (strip_file_name
== 0)
1231 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1232 if (strip_file_name
== 0)
1233 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1234 if (strip_file_name
== 0)
1235 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1236 if (strip_file_name
== 0)
1237 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1239 /* Determine the full path name of the C compiler to use. */
1240 c_file_name
= getenv ("COLLECT_GCC");
1241 if (c_file_name
== 0)
1243 #ifdef CROSS_DIRECTORY_STRUCTURE
1244 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1246 c_file_name
= "gcc";
1250 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1252 /* Here it should be safe to use the system search path since we should have
1253 already qualified the name of the compiler when it is needed. */
1255 p
= find_a_file (&path
, c_file_name
, X_OK
);
1260 *ld1
++ = *ld2
++ = ld_file_name
;
1262 /* Make temp file names. */
1265 c_file
= (char *) xmalloc (strlen (output_file
)
1266 + sizeof (".cdtor.c") + 1);
1267 strcpy (c_file
, output_file
);
1268 strcat (c_file
, ".cdtor.c");
1269 o_file
= (char *) xmalloc (strlen (output_file
)
1270 + sizeof (".cdtor.o") + 1);
1271 strcpy (o_file
, output_file
);
1272 strcat (o_file
, ".cdtor.o");
1276 c_file
= make_temp_file (".cdtor.c");
1277 o_file
= make_temp_file (".cdtor.o");
1279 #ifdef COLLECT_EXPORT_LIST
1280 export_file
= make_temp_file (".x");
1284 ldout
= make_temp_file (".ld");
1285 lderrout
= make_temp_file (".le");
1287 /* Build the command line to compile the ctor/dtor list. */
1288 *c_ptr
++ = c_file_name
;
1295 #ifdef COLLECT_EXPORT_LIST
1296 /* Generate a list of directories from LIBPATH. */
1297 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1298 /* Add to this list also two standard directories where
1299 AIX loader always searches for libraries. */
1300 add_prefix (&libpath_lib_dirs
, "/lib");
1301 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1304 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1306 AIX support needs to know if -shared has been specified before
1307 parsing commandline arguments. */
1309 p
= getenv ("COLLECT_GCC_OPTIONS");
1312 const char *q
= extract_string (&p
);
1313 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1314 *c_ptr
++ = xstrdup (q
);
1315 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1316 *c_ptr
++ = xstrdup (q
);
1317 if (strcmp (q
, "-shared") == 0)
1319 if (strcmp (q
, "-static") == 0)
1321 if (*q
== '-' && q
[1] == 'B')
1323 *c_ptr
++ = xstrdup (q
);
1326 q
= extract_string (&p
);
1327 *c_ptr
++ = xstrdup (q
);
1331 obstack_free (&temporary_obstack
, temporary_firstobj
);
1332 *c_ptr
++ = "-fno-profile-arcs";
1333 *c_ptr
++ = "-fno-test-coverage";
1334 *c_ptr
++ = "-fno-branch-probabilities";
1335 *c_ptr
++ = "-fno-exceptions";
1337 *c_ptr
++ = "-fno-whole-program";
1339 /* !!! When GCC calls collect2,
1340 it does not know whether it is calling collect2 or ld.
1341 So collect2 cannot meaningfully understand any options
1342 except those ld understands.
1343 If you propose to make GCC pass some other option,
1344 just imagine what will happen if ld is really ld!!! */
1346 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1347 /* After the first file, put in the c++ rt0. */
1349 #ifdef COLLECT_EXPORT_LIST
1350 is_static
= static_obj
;
1353 while ((arg
= *++argv
) != (char *) 0)
1355 *ld1
++ = *ld2
++ = arg
;
1362 if (!strcmp (arg
, "-debug"))
1364 /* Already parsed. */
1368 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1371 *ld1
++ = *ld2
++ = *argv
;
1376 if (strncmp (arg
, "-flto", 5) == 0)
1379 /* Do not pass LTO flag to the linker. */
1383 error ("LTO support has not been enabled in this "
1387 else if (!use_collect_ld
1388 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1390 /* Do not pass -fuse-ld={bfd|gold|lld} to the linker. */
1394 else if (strncmp (arg
, "-fno-lto", 8) == 0)
1396 /* Do not pass -fno-lto to the linker. */
1400 #ifdef TARGET_AIX_VERSION
1403 /* File containing a list of input files to process. */
1406 char buf
[MAXPATHLEN
+ 2];
1407 /* Number of additionnal object files. */
1409 /* Maximum of additionnal object files before vector
1412 const char *list_filename
= arg
+ 2;
1414 /* Accept -fFILENAME and -f FILENAME. */
1415 if (*list_filename
== '\0' && argv
[1])
1418 list_filename
= *argv
;
1419 *ld1
++ = *ld2
++ = *argv
;
1422 stream
= fopen (list_filename
, "r");
1424 fatal_error (input_location
, "cannot open %s: %m",
1427 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1429 /* Remove end of line. */
1430 int len
= strlen (buf
);
1431 if (len
>= 1 && buf
[len
- 1] =='\n')
1432 buf
[len
- 1] = '\0';
1434 /* Put on object vector.
1435 Note: we only expanse vector here, so we must keep
1436 extra space for remaining arguments. */
1437 if (add_nbr
>= add_max
)
1440 object
- CONST_CAST2 (const char **, char **,
1442 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1443 object_lst
= XRESIZEVEC (char *, object_lst
,
1444 object_nbr
+ add_max
);
1445 object
= CONST_CAST2 (const char **, char **,
1447 object_nbr
+= add_max
;
1449 *object
++ = xstrdup (buf
);
1457 #ifdef COLLECT_EXPORT_LIST
1459 if (!strcmp (arg
, "-bstatic"))
1463 else if (!strcmp (arg
, "-bdynamic") || !strcmp (arg
, "-bshared"))
1472 /* place o_file BEFORE this argument! */
1478 #ifdef COLLECT_EXPORT_LIST
1480 /* Resolving full library name. */
1481 const char *s
= resolve_lib_name (arg
+2);
1483 /* Saving a full library name. */
1484 add_to_list (&libs
, s
);
1486 add_to_list (&static_libs
, s
);
1491 #ifdef COLLECT_EXPORT_LIST
1492 /* Saving directories where to search for libraries. */
1494 add_prefix (&cmdline_lib_dirs
, arg
+2);
1500 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1502 output_file
= &arg
[2];
1511 if (arg
[2] == '\0' && do_collecting
)
1513 /* We must strip after the nm run, otherwise C++ linking
1514 will not work. Thus we strip in the second ld run, or
1515 else with strip if there is no second ld run. */
1527 if (strcmp (arg
, "--no-demangle") == 0)
1529 #ifndef HAVE_LD_DEMANGLE
1535 else if (strncmp (arg
, "--demangle", 10) == 0)
1537 #ifndef HAVE_LD_DEMANGLE
1541 enum demangling_styles style
1542 = cplus_demangle_name_to_style (arg
+11);
1543 if (style
== unknown_demangling
)
1544 error ("unknown demangling style %qs", arg
+11);
1546 current_demangling_style
= style
;
1552 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1553 target_system_root
= arg
+ 10;
1554 else if (strcmp (arg
, "--version") == 0)
1556 else if (strcmp (arg
, "--help") == 0)
1561 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1562 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1563 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1564 || strcmp (p
, ".obj") == 0))
1573 /* place o_file BEFORE this argument! */
1579 if (p
[1] == 'o' || p
[1] == 'l')
1581 #ifdef COLLECT_EXPORT_LIST
1582 /* libraries can be specified directly, i.e. without -l flag. */
1585 /* Saving a full library name. */
1586 add_to_list (&libs
, arg
);
1588 add_to_list (&static_libs
, arg
);
1594 #ifdef COLLECT_EXPORT_LIST
1595 /* This is added only for debugging purposes. */
1598 fprintf (stderr
, "List of libraries:\n");
1599 dump_list (stderr
, "\t", libs
.first
);
1600 fprintf (stderr
, "List of statically linked libraries:\n");
1601 dump_list (stderr
, "\t", static_libs
.first
);
1604 /* The AIX linker will discard static constructors in object files if
1605 nothing else in the file is referenced, so look at them first. Unless
1606 we are building a shared object, ignore the eh frame tables, as we
1607 would otherwise reference them all, hence drag all the corresponding
1608 objects even if nothing else is referenced. */
1610 const char **export_object_lst
1611 = CONST_CAST2 (const char **, char **, object_lst
);
1613 struct id
*list
= libs
.first
;
1615 /* Compute the filter to use from the current one, do scan, then adjust
1616 the "current" filter to remove what we just included here. This will
1617 control whether we need a first pass link later on or not, and what
1618 will remain to be scanned there. */
1620 scanfilter this_filter
= ld1_filter
;
1623 this_filter
&= ~SCAN_DWEH
;
1626 /* Scan object files. */
1627 while (export_object_lst
< object
)
1628 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1630 /* Scan libraries. */
1631 for (; list
; list
= list
->next
)
1632 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1634 ld1_filter
= ld1_filter
& ~this_filter
;
1639 char *buf
= concat ("-bE:", export_file
, NULL
);
1644 exportf
= fopen (export_file
, "w");
1645 if (exportf
== (FILE *) 0)
1646 fatal_error (input_location
, "fopen %s: %m", export_file
);
1647 write_aix_file (exportf
, exports
.first
);
1648 if (fclose (exportf
))
1649 fatal_error (input_location
, "fclose %s: %m", export_file
);
1654 *c_ptr
= *ld1
= *object
= (char *) 0;
1657 notice ("collect2 version %s\n", version_string
);
1661 printf ("Usage: collect2 [options]\n");
1662 printf (" Wrap linker and generate constructor code if needed.\n");
1663 printf (" Options:\n");
1664 printf (" -debug Enable debug output\n");
1665 printf (" --help Display this information\n");
1666 printf (" -v, --version Display this program's version number\n");
1668 printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1669 printf ("Report bugs: %s\n", bug_report_url
);
1676 fprintf (stderr
, "ld_file_name = %s\n",
1677 (ld_file_name
? ld_file_name
: "not found"));
1678 fprintf (stderr
, "c_file_name = %s\n",
1679 (c_file_name
? c_file_name
: "not found"));
1680 fprintf (stderr
, "nm_file_name = %s\n",
1681 (nm_file_name
? nm_file_name
: "not found"));
1683 fprintf (stderr
, "ldd_file_name = %s\n",
1684 (ldd_file_name
? ldd_file_name
: "not found"));
1686 fprintf (stderr
, "strip_file_name = %s\n",
1687 (strip_file_name
? strip_file_name
: "not found"));
1688 fprintf (stderr
, "c_file = %s\n",
1689 (c_file
? c_file
: "not found"));
1690 fprintf (stderr
, "o_file = %s\n",
1691 (o_file
? o_file
: "not found"));
1693 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1695 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1697 ptr
= getenv ("COLLECT_GCC");
1699 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1701 ptr
= getenv ("COMPILER_PATH");
1703 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1705 ptr
= getenv (LIBRARY_PATH_ENV
);
1707 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1709 fprintf (stderr
, "\n");
1712 /* Load the program, searching all libraries and attempting to provide
1713 undefined symbols from repository information.
1715 If -r or they will be run via some other method, do not build the
1716 constructor or destructor list, just return now. */
1719 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1721 /* Perform the first pass link now, if we're about to exit or if we need
1722 to scan for things we haven't collected yet before pursuing further.
1724 On AIX, the latter typically includes nothing for shared objects or
1725 frame tables for an executable, out of what the required early scan on
1726 objects and libraries has performed above. In the !shared_obj case, we
1727 expect the relevant tables to be dragged together with their associated
1728 functions from precise cross reference insertions by the compiler. */
1730 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1735 #ifdef COLLECT_EXPORT_LIST
1736 /* Make sure we delete the export file we may have created. */
1737 if (export_file
!= 0 && export_file
[0])
1738 maybe_unlink (export_file
);
1740 if (lto_mode
!= LTO_MODE_NONE
)
1741 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1743 post_ld_pass (/*temp_file*/false);
1749 /* Unless we have done it all already, examine the namelist and search for
1750 static constructors and destructors to call. Write the constructor and
1751 destructor tables to a .s file and reload. */
1753 if (ld1_filter
!= SCAN_NOTHING
)
1754 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1756 #ifdef SCAN_LIBRARIES
1757 scan_libraries (output_file
);
1762 notice_translated (ngettext ("%d constructor found\n",
1763 "%d constructors found\n",
1764 constructors
.number
),
1765 constructors
.number
);
1766 notice_translated (ngettext ("%d destructor found\n",
1767 "%d destructors found\n",
1768 destructors
.number
),
1769 destructors
.number
);
1770 notice_translated (ngettext ("%d frame table found\n",
1771 "%d frame tables found\n",
1772 frame_tables
.number
),
1773 frame_tables
.number
);
1776 /* If the scan exposed nothing of special interest, there's no need to
1777 generate the glue code and relink so return now. */
1779 if (constructors
.number
== 0 && destructors
.number
== 0
1780 && frame_tables
.number
== 0
1781 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1782 /* If we will be running these functions ourselves, we want to emit
1783 stubs into the shared library so that we do not have to relink
1784 dependent programs when we add static objects. */
1789 /* Do link without additional code generation now if we didn't
1790 do it earlier for scanning purposes. */
1791 if (ld1_filter
== SCAN_NOTHING
)
1795 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1797 /* Strip now if it was requested on the command line. */
1800 char **real_strip_argv
= XCNEWVEC (char *, 3);
1801 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1804 strip_argv
[0] = strip_file_name
;
1805 strip_argv
[1] = output_file
;
1806 strip_argv
[2] = (char *) 0;
1807 fork_execute ("strip", real_strip_argv
, false);
1810 #ifdef COLLECT_EXPORT_LIST
1811 maybe_unlink (export_file
);
1813 post_ld_pass (/*temp_file*/false);
1815 maybe_unlink (c_file
);
1816 maybe_unlink (o_file
);
1820 /* Sort ctor and dtor lists by priority. */
1821 sort_ids (&constructors
);
1822 sort_ids (&destructors
);
1824 maybe_unlink (output_file
);
1825 outf
= fopen (c_file
, "w");
1826 if (outf
== (FILE *) 0)
1827 fatal_error (input_location
, "fopen %s: %m", c_file
);
1829 write_c_file (outf
, c_file
);
1832 fatal_error (input_location
, "fclose %s: %m", c_file
);
1834 /* Tell the linker that we have initializer and finalizer functions. */
1835 #ifdef LD_INIT_SWITCH
1836 #ifdef COLLECT_EXPORT_LIST
1837 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1839 *ld2
++ = LD_INIT_SWITCH
;
1841 *ld2
++ = LD_FINI_SWITCH
;
1846 #ifdef COLLECT_EXPORT_LIST
1849 /* If we did not add export flag to link arguments before, add it to
1850 second link phase now. No new exports should have been added. */
1851 if (! exports
.first
)
1852 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1854 #ifdef TARGET_AIX_VERSION
1855 add_to_list (&exports
, aix_shared_initname
);
1856 add_to_list (&exports
, aix_shared_fininame
);
1859 #ifndef LD_INIT_SWITCH
1860 add_to_list (&exports
, initname
);
1861 add_to_list (&exports
, fininame
);
1862 add_to_list (&exports
, "_GLOBAL__DI");
1863 add_to_list (&exports
, "_GLOBAL__DD");
1865 exportf
= fopen (export_file
, "w");
1866 if (exportf
== (FILE *) 0)
1867 fatal_error (input_location
, "fopen %s: %m", export_file
);
1868 write_aix_file (exportf
, exports
.first
);
1869 if (fclose (exportf
))
1870 fatal_error (input_location
, "fclose %s: %m", export_file
);
1874 /* End of arguments to second link phase. */
1879 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1880 output_file
, c_file
);
1881 write_c_file (stderr
, "stderr");
1882 fprintf (stderr
, "========== end of c_file\n\n");
1883 #ifdef COLLECT_EXPORT_LIST
1884 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1885 write_aix_file (stderr
, exports
.first
);
1886 fprintf (stderr
, "========== end of export_file\n\n");
1890 /* Assemble the constructor and destructor tables.
1891 Link the tables in with the rest of the program. */
1893 fork_execute ("gcc", c_argv
, at_file_supplied
);
1894 #ifdef COLLECT_EXPORT_LIST
1895 /* On AIX we must call link because of possible templates resolution. */
1899 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1901 /* Otherwise, simply call ld because link is already done. */
1903 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1906 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1907 post_ld_pass (/*temp_file*/false);
1910 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1911 constructors/destructors in shared libraries. */
1912 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1915 maybe_unlink (c_file
);
1916 maybe_unlink (o_file
);
1918 #ifdef COLLECT_EXPORT_LIST
1919 maybe_unlink (export_file
);
1926 /* Unlink FILE unless we are debugging or this is the output_file
1927 and we may not unlink it. */
1930 maybe_unlink (const char *file
)
1932 if (save_temps
&& file_exists (file
))
1935 notice ("[Leaving %s]\n", file
);
1939 if (file
== output_file
&& !may_unlink_output_file
)
1942 unlink_if_ordinary (file
);
1945 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1948 maybe_unlink_list (char **file_list
)
1950 char **tmp
= file_list
;
1953 maybe_unlink (*(tmp
++));
1957 static long sequence_number
= 0;
1959 /* Add a name to a linked list. */
1962 add_to_list (struct head
*head_ptr
, const char *name
)
1965 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1967 strcpy (newid
->name
, name
);
1969 if (head_ptr
->first
)
1970 head_ptr
->last
->next
= newid
;
1972 head_ptr
->first
= newid
;
1974 /* Check for duplicate symbols. */
1975 for (p
= head_ptr
->first
;
1976 strcmp (name
, p
->name
) != 0;
1981 head_ptr
->last
->next
= 0;
1986 newid
->sequence
= ++sequence_number
;
1987 head_ptr
->last
= newid
;
1991 /* Grab the init priority number from an init function name that
1992 looks like "_GLOBAL_.I.12345.foo". */
1995 extract_init_priority (const char *name
)
1999 #ifdef TARGET_AIX_VERSION
2000 /* Run dependent module initializers before any constructors in this
2002 switch (is_ctor_dtor (name
))
2012 while (name
[pos
] == '_')
2014 pos
+= 10; /* strlen ("GLOBAL__X_") */
2016 /* Extract init_p number from ctor/dtor name. */
2017 pri
= atoi (name
+ pos
);
2018 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2021 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2022 ctors will be run from right to left, dtors from left to right. */
2025 sort_ids (struct head
*head_ptr
)
2027 /* id holds the current element to insert. id_next holds the next
2028 element to insert. id_ptr iterates through the already sorted elements
2029 looking for the place to insert id. */
2030 struct id
*id
, *id_next
, **id_ptr
;
2032 id
= head_ptr
->first
;
2034 /* We don't have any sorted elements yet. */
2035 head_ptr
->first
= NULL
;
2037 for (; id
; id
= id_next
)
2040 id
->sequence
= extract_init_priority (id
->name
);
2042 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2044 /* If the sequence numbers are the same, we put the id from the
2045 file later on the command line later in the list. */
2046 || id
->sequence
> (*id_ptr
)->sequence
2047 /* Hack: do lexical compare, too.
2048 || (id->sequence == (*id_ptr)->sequence
2049 && strcmp (id->name, (*id_ptr)->name) > 0) */
2058 /* Now set the sequence numbers properly so write_c_file works. */
2059 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2060 id
->sequence
= ++sequence_number
;
2063 /* Write: `prefix', the names on list LIST, `suffix'. */
2066 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2070 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2075 #ifdef COLLECT_EXPORT_LIST
2076 /* This function is really used only on AIX, but may be useful. */
2078 is_in_list (const char *prefix
, struct id
*list
)
2082 if (!strcmp (prefix
, list
->name
)) return 1;
2087 #endif /* COLLECT_EXPORT_LIST */
2089 /* Added for debugging purpose. */
2090 #ifdef COLLECT_EXPORT_LIST
2092 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2096 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2104 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2108 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2115 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2119 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2120 prefix
, list
->sequence
, list
->name
);
2125 /* Write out the constructor and destructor tables statically (for a shared
2126 object), along with the functions to execute them. */
2129 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2133 int frames
= (frame_tables
.number
> 0);
2135 /* Figure out name of output_file, stripping off .so version. */
2136 q
= p
= lbasename (output_file
);
2148 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2150 q
+= strlen (SHLIB_SUFFIX
);
2157 /* q points to null at end of the string (or . of the .so version) */
2158 prefix
= XNEWVEC (char, q
- p
+ 1);
2159 strncpy (prefix
, p
, q
- p
);
2161 for (r
= prefix
; *r
; r
++)
2162 if (!ISALNUM ((unsigned char)*r
))
2165 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2166 output_file
, prefix
);
2168 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2169 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2170 #ifdef TARGET_AIX_VERSION
2171 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2172 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2177 /* Write the tables as C code. */
2179 /* This count variable is used to prevent multiple calls to the
2180 constructors/destructors.
2181 This guard against multiple calls is important on AIX as the initfini
2182 functions are deliberately invoked multiple times as part of the
2183 mechanisms GCC uses to order constructors across different dependent
2184 shared libraries (see config/rs6000/aix.h).
2186 fprintf (stream
, "static int count;\n");
2187 fprintf (stream
, "typedef void entry_pt();\n");
2188 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2192 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2194 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2195 write_list (stream
, "\t\t&", frame_tables
.first
);
2196 fprintf (stream
, "\t0\n};\n");
2198 /* This must match what's in frame.h. */
2199 fprintf (stream
, "struct object {\n");
2200 fprintf (stream
, " void *pc_begin;\n");
2201 fprintf (stream
, " void *pc_end;\n");
2202 fprintf (stream
, " void *fde_begin;\n");
2203 fprintf (stream
, " void *fde_array;\n");
2204 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2205 fprintf (stream
, " struct object *next;\n");
2206 fprintf (stream
, "};\n");
2208 fprintf (stream
, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2209 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2210 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2211 #ifdef TARGET_AIX_VERSION
2212 fprintf (stream
, "extern void *__gcc_unwind_dbase;\n");
2215 fprintf (stream
, "static void reg_frame () {\n");
2216 fprintf (stream
, "\tstatic struct object ob;\n");
2217 #ifdef TARGET_AIX_VERSION
2218 /* Use __gcc_unwind_dbase as the base address for data on AIX.
2219 This might not be the start of the segment, signed offsets assumed.
2221 fprintf (stream
, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2223 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2225 fprintf (stream
, "\t}\n");
2227 fprintf (stream
, "static void dereg_frame () {\n");
2228 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2229 fprintf (stream
, "\t}\n");
2232 fprintf (stream
, "void %s() {\n", initname
);
2233 if (constructors
.number
> 0 || frames
)
2235 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2236 write_list (stream
, "\t\t", constructors
.first
);
2238 fprintf (stream
, "\treg_frame,\n");
2239 fprintf (stream
, "\t};\n");
2240 fprintf (stream
, "\tentry_pt **p;\n");
2241 fprintf (stream
, "\tif (count++ != 0) return;\n");
2242 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2243 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2246 fprintf (stream
, "\t++count;\n");
2247 fprintf (stream
, "}\n");
2248 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2249 fprintf (stream
, "void %s() {\n", fininame
);
2250 if (destructors
.number
> 0 || frames
)
2252 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2253 write_list (stream
, "\t\t", destructors
.first
);
2255 fprintf (stream
, "\tdereg_frame,\n");
2256 fprintf (stream
, "\t};\n");
2257 fprintf (stream
, "\tentry_pt **p;\n");
2258 fprintf (stream
, "\tif (--count != 0) return;\n");
2259 fprintf (stream
, "\tp = dtors;\n");
2260 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2261 destructors
.number
+ frames
);
2263 fprintf (stream
, "}\n");
2267 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2268 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2272 /* Write the constructor/destructor tables. */
2274 #ifndef LD_INIT_SWITCH
2276 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2278 /* Write the tables as C code. */
2280 int frames
= (frame_tables
.number
> 0);
2282 fprintf (stream
, "typedef void entry_pt();\n\n");
2284 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2288 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2290 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2291 write_list (stream
, "\t\t&", frame_tables
.first
);
2292 fprintf (stream
, "\t0\n};\n");
2294 /* This must match what's in frame.h. */
2295 fprintf (stream
, "struct object {\n");
2296 fprintf (stream
, " void *pc_begin;\n");
2297 fprintf (stream
, " void *pc_end;\n");
2298 fprintf (stream
, " void *fde_begin;\n");
2299 fprintf (stream
, " void *fde_array;\n");
2300 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2301 fprintf (stream
, " struct object *next;\n");
2302 fprintf (stream
, "};\n");
2304 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2305 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2307 fprintf (stream
, "static void reg_frame () {\n");
2308 fprintf (stream
, "\tstatic struct object ob;\n");
2309 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2310 fprintf (stream
, "\t}\n");
2312 fprintf (stream
, "static void dereg_frame () {\n");
2313 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2314 fprintf (stream
, "\t}\n");
2317 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2318 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2319 write_list (stream
, "\t", constructors
.first
);
2321 fprintf (stream
, "\treg_frame,\n");
2322 fprintf (stream
, "\t0\n};\n\n");
2324 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2326 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2327 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2328 write_list (stream
, "\t", destructors
.first
);
2330 fprintf (stream
, "\tdereg_frame,\n");
2331 fprintf (stream
, "\t0\n};\n\n");
2333 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2334 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2336 #endif /* ! LD_INIT_SWITCH */
2339 write_c_file (FILE *stream
, const char *name
)
2341 #ifndef LD_INIT_SWITCH
2343 write_c_file_glob (stream
, name
);
2346 write_c_file_stat (stream
, name
);
2349 #ifdef COLLECT_EXPORT_LIST
2351 write_aix_file (FILE *stream
, struct id
*list
)
2353 for (; list
; list
= list
->next
)
2355 fputs (list
->name
, stream
);
2356 putc ('\n', stream
);
2361 #ifdef OBJECT_FORMAT_NONE
2363 /* Check to make sure the file is an LTO object file. */
2366 has_lto_section (void *data
, const char *name ATTRIBUTE_UNUSED
,
2367 off_t offset ATTRIBUTE_UNUSED
,
2368 off_t length ATTRIBUTE_UNUSED
)
2370 int *found
= (int *) data
;
2372 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
2373 sizeof (LTO_SECTION_NAME_PREFIX
) - 1) != 0)
2375 if (strncmp (name
, OFFLOAD_SECTION_NAME_PREFIX
,
2376 sizeof (OFFLOAD_SECTION_NAME_PREFIX
) - 1) != 0)
2382 /* Stop iteration. */
2387 is_lto_object_file (const char *prog_name
)
2393 int infd
= open (prog_name
, O_RDONLY
| O_BINARY
);
2398 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
2404 errmsg
= simple_object_find_sections (inobj
, has_lto_section
,
2405 (void *) &found
, &err
);
2406 if (! errmsg
&& found
)
2410 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
2414 /* Generic version to scan the name list of the loaded program for
2415 the symbols g++ uses for static constructors and destructors. */
2418 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2421 void (*int_handler
) (int);
2423 void (*quit_handler
) (int);
2425 char *real_nm_argv
[4];
2426 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2428 struct pex_obj
*pex
;
2434 if (which_pass
== PASS_SECOND
)
2437 /* LTO objects must be in a known format. This check prevents
2438 us from accepting an archive containing LTO objects, which
2439 gcc cannot currently handle. */
2440 if (which_pass
== PASS_LTOINFO
)
2442 if(is_lto_object_file (prog_name
)) {
2443 add_lto_object (<o_objects
, prog_name
);
2448 /* If we do not have an `nm', complain. */
2449 if (nm_file_name
== 0)
2450 fatal_error (input_location
, "cannot find %<nm%>");
2452 nm_argv
[argc
++] = nm_file_name
;
2453 if (NM_FLAGS
[0] != '\0')
2454 nm_argv
[argc
++] = NM_FLAGS
;
2456 nm_argv
[argc
++] = prog_name
;
2457 nm_argv
[argc
++] = (char *) 0;
2459 /* Trace if needed. */
2462 const char **p_argv
;
2465 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2466 fprintf (stderr
, " %s", str
);
2468 fprintf (stderr
, "\n");
2474 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2476 fatal_error (input_location
, "%<pex_init%> failed: %m");
2478 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2485 fatal_error (input_location
, "%s: %m", _(errmsg
));
2488 fatal_error (input_location
, errmsg
);
2491 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2493 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2496 inf
= pex_read_output (pex
, 0);
2498 fatal_error (input_location
, "cannot open nm output: %m");
2501 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2503 /* Read each line of nm output. */
2504 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2510 fprintf (stderr
, "\t%s\n", buf
);
2512 /* If it contains a constructor or destructor name, add the name
2513 to the appropriate list unless this is a kind of symbol we're
2514 not supposed to even consider. */
2516 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2517 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2524 /* Find the end of the symbol name.
2525 Do not include `|', because Encore nm can tack that on the end. */
2526 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2533 switch (is_ctor_dtor (name
))
2536 if (! (filter
& SCAN_CTOR
))
2538 if (which_pass
!= PASS_LIB
)
2539 add_to_list (&constructors
, name
);
2543 if (! (filter
& SCAN_DTOR
))
2545 if (which_pass
!= PASS_LIB
)
2546 add_to_list (&destructors
, name
);
2550 if (! (filter
& SCAN_INIT
))
2552 if (which_pass
!= PASS_LIB
)
2553 fatal_error (input_location
, "init function found in object %s",
2555 #ifndef LD_INIT_SWITCH
2556 add_to_list (&constructors
, name
);
2561 if (! (filter
& SCAN_FINI
))
2563 if (which_pass
!= PASS_LIB
)
2564 fatal_error (input_location
, "fini function found in object %s",
2566 #ifndef LD_FINI_SWITCH
2567 add_to_list (&destructors
, name
);
2572 if (! (filter
& SCAN_DWEH
))
2574 if (which_pass
!= PASS_LIB
)
2575 add_to_list (&frame_tables
, name
);
2578 default: /* not a constructor or destructor */
2584 fprintf (stderr
, "\n");
2586 do_wait (nm_file_name
, pex
);
2588 signal (SIGINT
, int_handler
);
2590 signal (SIGQUIT
, quit_handler
);
2596 /* Use the List Dynamic Dependencies program to find shared libraries that
2597 the output file depends upon and their initialization/finalization
2598 routines, if any. */
2601 scan_libraries (const char *prog_name
)
2603 static struct head libraries
; /* list of shared libraries found */
2605 void (*int_handler
) (int);
2607 void (*quit_handler
) (int);
2609 char *real_ldd_argv
[4];
2610 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2612 struct pex_obj
*pex
;
2618 /* If we do not have an `ldd', complain. */
2619 if (ldd_file_name
== 0)
2621 error ("cannot find %<ldd%>");
2625 ldd_argv
[argc
++] = ldd_file_name
;
2626 ldd_argv
[argc
++] = prog_name
;
2627 ldd_argv
[argc
++] = (char *) 0;
2629 /* Trace if needed. */
2632 const char **p_argv
;
2635 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2636 fprintf (stderr
, " %s", str
);
2638 fprintf (stderr
, "\n");
2644 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2646 fatal_error (input_location
, "pex_init failed: %m");
2648 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2654 fatal_error (input_location
, "%s: %m", _(errmsg
));
2657 fatal_error (input_location
, errmsg
);
2660 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2662 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2665 inf
= pex_read_output (pex
, 0);
2667 fatal_error (input_location
, "cannot open ldd output: %m");
2670 notice ("\nldd output with constructors/destructors.\n");
2672 /* Read each line of ldd output. */
2673 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2676 char *name
, *end
, *p
= buf
;
2678 /* Extract names of libraries and add to list. */
2679 PARSE_LDD_OUTPUT (p
);
2684 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2685 fatal_error (input_location
, "dynamic dependency %s not found", buf
);
2687 /* Find the end of the symbol name. */
2689 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2694 if (access (name
, R_OK
) == 0)
2695 add_to_list (&libraries
, name
);
2697 fatal_error (input_location
, "unable to open dynamic dependency "
2701 fprintf (stderr
, "\t%s\n", buf
);
2704 fprintf (stderr
, "\n");
2706 do_wait (ldd_file_name
, pex
);
2708 signal (SIGINT
, int_handler
);
2710 signal (SIGQUIT
, quit_handler
);
2713 /* Now iterate through the library list adding their symbols to
2715 for (list
= libraries
.first
; list
; list
= list
->next
)
2716 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2719 #endif /* LDD_SUFFIX */
2721 #endif /* OBJECT_FORMAT_NONE */
2725 * COFF specific stuff.
2728 #ifdef OBJECT_FORMAT_COFF
2730 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2731 # define GCC_SYMENT SYMENT
2732 # if defined (C_WEAKEXT)
2733 # define GCC_OK_SYMBOL(X) \
2734 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2735 ((X).n_scnum > N_UNDEF) && \
2737 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2738 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2739 # define GCC_UNDEF_SYMBOL(X) \
2740 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2741 ((X).n_scnum == N_UNDEF))
2743 # define GCC_OK_SYMBOL(X) \
2744 (((X).n_sclass == C_EXT) && \
2745 ((X).n_scnum > N_UNDEF) && \
2747 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2748 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2749 # define GCC_UNDEF_SYMBOL(X) \
2750 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2752 # define GCC_SYMINC(X) ((X).n_numaux+1)
2753 # define GCC_SYMZERO(X) 0
2755 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2756 #if TARGET_AIX_VERSION >= 51
2757 # define GCC_CHECK_HDR(X) \
2758 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2759 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2760 && !(HEADER (X).f_flags & F_LOADONLY))
2762 # define GCC_CHECK_HDR(X) \
2763 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2764 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2765 && !(HEADER (X).f_flags & F_LOADONLY))
2768 #ifdef COLLECT_EXPORT_LIST
2769 /* Array of standard AIX libraries which should not
2770 be scanned for ctors/dtors. */
2771 static const char *const aix_std_libs
[] = {
2779 "/usr/lib/libc_r.a",
2780 "/usr/lib/libm_r.a",
2781 "/usr/lib/threads/libc.a",
2782 "/usr/ccs/lib/libc.a",
2783 "/usr/ccs/lib/libm.a",
2784 "/usr/ccs/lib/libc_r.a",
2785 "/usr/ccs/lib/libm_r.a",
2789 /* This function checks the filename and returns 1
2790 if this name matches the location of a standard AIX library. */
2791 static int ignore_library (const char *);
2793 ignore_library (const char *name
)
2795 const char *const *p
;
2798 if (target_system_root
[0] != '\0')
2800 length
= strlen (target_system_root
);
2801 if (strncmp (name
, target_system_root
, length
) != 0)
2805 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2806 if (strcmp (name
, *p
) == 0)
2810 #endif /* COLLECT_EXPORT_LIST */
2812 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2813 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2816 /* COFF version to scan the name list of the loaded program for
2817 the symbols g++ uses for static constructors and destructors. */
2820 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2823 LDFILE
*ldptr
= NULL
;
2824 int sym_index
, sym_count
;
2827 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2830 #ifdef COLLECT_EXPORT_LIST
2831 /* We do not need scanning for some standard C libraries. */
2832 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2835 /* On AIX we have a loop, because there is not much difference
2836 between an object and an archive. This trick allows us to
2837 eliminate scan_libraries() function. */
2841 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2842 non-const char * filename parameter, even though it will not
2843 modify that string. So we must cast away const-ness here,
2844 using CONST_CAST to prevent complaints from -Wcast-qual. */
2845 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2847 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2848 fatal_error (input_location
, "%s: not a COFF file", prog_name
);
2850 if (GCC_CHECK_HDR (ldptr
))
2852 sym_count
= GCC_SYMBOLS (ldptr
);
2853 sym_index
= GCC_SYMZERO (ldptr
);
2855 #ifdef COLLECT_EXPORT_LIST
2856 /* Is current archive member a shared object? */
2857 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2860 while (sym_index
< sym_count
)
2864 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2866 sym_index
+= GCC_SYMINC (symbol
);
2868 if (GCC_OK_SYMBOL (symbol
))
2872 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2873 continue; /* Should never happen. */
2875 #ifdef XCOFF_DEBUGGING_INFO
2876 /* All AIX function names have a duplicate entry
2877 beginning with a dot. */
2882 switch (is_ctor_dtor (name
))
2884 #if TARGET_AIX_VERSION
2885 /* Add AIX shared library initalisers/finalisers
2886 to the constructors/destructors list of the
2889 if (! (filter
& SCAN_CTOR
))
2891 if (is_shared
&& !aixlazy_flag
2892 #ifdef COLLECT_EXPORT_LIST
2894 && ! is_in_list (prog_name
, static_libs
.first
)
2897 add_to_list (&constructors
, name
);
2901 if (! (filter
& SCAN_DTOR
))
2903 if (is_shared
&& !aixlazy_flag
)
2904 add_to_list (&destructors
, name
);
2909 if (! (filter
& SCAN_CTOR
))
2912 add_to_list (&constructors
, name
);
2913 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2914 if (which_pass
== PASS_OBJ
)
2915 add_to_list (&exports
, name
);
2920 if (! (filter
& SCAN_DTOR
))
2923 add_to_list (&destructors
, name
);
2924 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2925 if (which_pass
== PASS_OBJ
)
2926 add_to_list (&exports
, name
);
2930 #ifdef COLLECT_EXPORT_LIST
2932 if (! (filter
& SCAN_INIT
))
2934 #ifndef LD_INIT_SWITCH
2936 add_to_list (&constructors
, name
);
2941 if (! (filter
& SCAN_FINI
))
2943 #ifndef LD_INIT_SWITCH
2945 add_to_list (&destructors
, name
);
2951 if (! (filter
& SCAN_DWEH
))
2954 add_to_list (&frame_tables
, name
);
2955 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2956 if (which_pass
== PASS_OBJ
)
2957 add_to_list (&exports
, name
);
2961 default: /* not a constructor or destructor */
2962 #ifdef COLLECT_EXPORT_LIST
2963 /* Explicitly export all global symbols when
2964 building a shared object on AIX, but do not
2965 re-export symbols from another shared object
2966 and do not export symbols if the user
2967 provides an explicit export list. */
2968 if (shared_obj
&& !is_shared
2969 && which_pass
== PASS_OBJ
&& !export_flag
)
2971 /* Do not auto-export __dso_handle or
2972 __gcc_unwind_dbase. They are required
2973 to be local to each module. */
2974 if (strcmp(name
, "__dso_handle") != 0
2975 && strcmp(name
, "__gcc_unwind_dbase") != 0)
2977 add_to_list (&exports
, name
);
2985 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2986 symbol
.n_scnum
, symbol
.n_sclass
,
2987 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2992 #ifdef COLLECT_EXPORT_LIST
2995 /* If archive contains both 32-bit and 64-bit objects,
2996 we want to skip objects in other mode so mismatch normal. */
2998 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2999 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3005 fatal_error (input_location
, "%s: cannot open as COFF file",
3008 #ifdef COLLECT_EXPORT_LIST
3009 /* On AIX loop continues while there are more members in archive. */
3011 while (ldclose (ldptr
) == FAILURE
);
3013 /* Otherwise we simply close ldptr. */
3014 (void) ldclose (ldptr
);
3017 #endif /* OBJECT_FORMAT_COFF */
3019 #ifdef COLLECT_EXPORT_LIST
3020 /* Given a library name without "lib" prefix, this function
3021 returns a full library name including a path. */
3023 resolve_lib_name (const char *name
)
3027 /* Library extensions for AIX dynamic linking. */
3028 const char * const libexts
[2] = {"a", "so"};
3030 for (i
= 0; libpaths
[i
]; i
++)
3031 if (libpaths
[i
]->max_len
> l
)
3032 l
= libpaths
[i
]->max_len
;
3034 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
3036 for (i
= 0; libpaths
[i
]; i
++)
3038 struct prefix_list
*list
= libpaths
[i
]->plist
;
3039 for (; list
; list
= list
->next
)
3041 /* The following lines are needed because path_prefix list
3042 may contain directories both with trailing DIR_SEPARATOR and
3045 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
3047 for (j
= 0; j
< 2; j
++)
3049 sprintf (lib_buf
, "%s%slib%s.%s",
3050 list
->prefix
, p
, name
,
3051 libexts
[(j
+ aixrtl_flag
) % 2]);
3052 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3053 if (file_exists (lib_buf
))
3055 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3062 fprintf (stderr
, "not found\n");
3064 fatal_error (input_location
, "library lib%s not found", name
);
3067 #endif /* COLLECT_EXPORT_LIST */
3069 #ifdef COLLECT_RUN_DSYMUTIL
3070 static int flag_dsym
= false;
3071 static int flag_idsym
= false;
3074 process_args (int *argcp
, char **argv
) {
3077 for (i
=0; i
<argc
; ++i
)
3079 if (strcmp (argv
[i
], "-dsym") == 0)
3082 /* Remove the flag, as we handle all processing for it. */
3085 argv
[j
] = argv
[j
+1];
3090 else if (strcmp (argv
[i
], "-idsym") == 0)
3093 /* Remove the flag, as we handle all processing for it. */
3096 argv
[j
] = argv
[j
+1];
3105 do_dsymutil (const char *output_file
) {
3106 const char *dsymutil
= DSYMUTIL
+ 1;
3107 struct pex_obj
*pex
;
3108 char **real_argv
= XCNEWVEC (char *, 3);
3109 const char ** argv
= CONST_CAST2 (const char **, char **,
3113 argv
[1] = output_file
;
3114 argv
[2] = (char *) 0;
3116 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3117 PEX_LAST
| PEX_SEARCH
, false);
3118 do_wait (dsymutil
, pex
);
3122 post_ld_pass (bool temp_file
) {
3123 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3126 do_dsymutil (output_file
);
3130 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3131 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }