1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
29 #include "coretypes.h"
31 #include "filenames.h"
32 #include "file-find.h"
34 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
45 #include "collect2-aix.h"
46 #include "diagnostic.h"
52 /* On certain systems, we have code that works by scanning the object file
53 directly. But this code uses system-specific header files and library
54 functions, so turn it off in a cross-compiler. Likewise, the names of
55 the utilities are not correct for a cross-compiler; we have to hope that
56 cross-versions are in the proper directories. */
58 #ifdef CROSS_DIRECTORY_STRUCTURE
59 #ifndef CROSS_AIX_SUPPORT
60 #undef OBJECT_FORMAT_COFF
63 #undef REAL_LD_FILE_NAME
64 #undef REAL_NM_FILE_NAME
65 #undef REAL_STRIP_FILE_NAME
68 /* If we cannot use a special method, use the ordinary one:
69 run nm to find what symbols are present.
70 In a cross-compiler, this means you need a cross nm,
71 but that is not quite as unpleasant as special headers. */
73 #if !defined (OBJECT_FORMAT_COFF)
74 #define OBJECT_FORMAT_NONE
77 #ifdef OBJECT_FORMAT_COFF
79 #ifndef CROSS_DIRECTORY_STRUCTURE
87 /* Many versions of ldfcn.h define these. */
96 /* Some systems have an ISCOFF macro, but others do not. In some cases
97 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
98 that either do not have an ISCOFF macro in /usr/include or for those
102 #define MY_ISCOFF(X) ISCOFF (X)
105 #endif /* OBJECT_FORMAT_COFF */
107 #ifdef OBJECT_FORMAT_NONE
109 /* Default flags to pass to nm. */
111 #define NM_FLAGS "-n"
114 #endif /* OBJECT_FORMAT_NONE */
116 /* Some systems use __main in a way incompatible with its use in gcc, in these
117 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
118 give the same symbol without quotes for an alternative entry point. */
120 #define NAME__MAIN "__main"
123 /* This must match tree.h. */
124 #define DEFAULT_INIT_PRIORITY 65535
126 #ifndef COLLECT_SHARED_INIT_FUNC
127 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
128 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
130 #ifndef COLLECT_SHARED_FINI_FUNC
131 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
132 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
136 #define SCAN_LIBRARIES
140 #define SHLIB_SUFFIX ".so"
144 int do_collecting
= 1;
146 int do_collecting
= 0;
149 /* Cook up an always defined indication of whether we proceed the
150 "EXPORT_LIST" way. */
152 #ifdef COLLECT_EXPORT_LIST
153 #define DO_COLLECT_EXPORT_LIST 1
155 #define DO_COLLECT_EXPORT_LIST 0
158 /* Nonzero if we should suppress the automatic demangling of identifiers
159 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
162 /* Linked lists of constructor and destructor names. */
178 bool verbose
; /* true if -v or --version */
179 static int rflag
; /* true if -r */
180 static int strip_flag
; /* true if -s */
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag
; /* true if -bE */
183 static int aix64_flag
; /* true if -b64 */
184 static int aixrtl_flag
; /* true if -brtl */
185 static int aixlazy_flag
; /* true if -blazy */
189 LTO_MODE_NONE
, /* Not doing LTO. */
190 LTO_MODE_LTO
, /* Normal LTO. */
191 LTO_MODE_WHOPR
/* WHOPR. */
194 /* Current LTO mode. */
196 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
198 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
201 bool debug
; /* true if -debug */
202 bool helpflag
; /* true if --help */
204 static int shared_obj
; /* true if -shared */
206 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
207 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
208 #ifdef COLLECT_EXPORT_LIST
209 static const char *export_file
; /* <xxx>.x for AIX export list. */
211 static char **lto_o_files
; /* Output files for LTO. */
212 const char *ldout
; /* File for ld stdout. */
213 const char *lderrout
; /* File for ld stderr. */
214 static const char *output_file
; /* Output file for ld. */
215 static const char *nm_file_name
; /* pathname of nm */
217 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
219 static const char *strip_file_name
; /* pathname of strip */
220 const char *c_file_name
; /* pathname of gcc */
221 static char *initname
, *fininame
; /* names of init and fini funcs */
224 #ifdef TARGET_AIX_VERSION
225 static char *aix_shared_initname
;
226 static char *aix_shared_fininame
; /* init/fini names as per the scheme
227 described in config/rs6000/aix.h */
230 static struct head constructors
; /* list of constructors found */
231 static struct head destructors
; /* list of destructors found */
232 #ifdef COLLECT_EXPORT_LIST
233 static struct head exports
; /* list of exported symbols */
235 static struct head frame_tables
; /* list of frame unwind info tables */
237 static bool at_file_supplied
; /* Whether to use @file arguments */
238 static char *response_file
; /* Name of any current response file */
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 path_prefix cmdline_lib_dirs
; /* directories specified with -L */
261 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
262 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
263 &libpath_lib_dirs
, NULL
};
266 /* List of names of object files containing LTO information.
267 These are a subset of the object file names appearing on the
268 command line, and must be identical, in the sense of pointer
269 equality, with the names passed to maybe_run_lto_and_relink(). */
273 const char *name
; /* Name of object file. */
274 struct lto_object
*next
; /* Next in linked list. */
277 struct lto_object_list
279 struct lto_object
*first
; /* First list element. */
280 struct lto_object
*last
; /* Last list element. */
283 static struct lto_object_list lto_objects
;
285 /* Special kinds of symbols that a name may denote. */
288 SYM_REGULAR
= 0, /* nothing special */
290 SYM_CTOR
= 1, /* constructor */
291 SYM_DTOR
= 2, /* destructor */
292 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
293 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
294 SYM_DWEH
= 5, /* DWARF exception handling table */
299 static symkind
is_ctor_dtor (const char *);
301 static void handler (int);
302 static void do_wait (const char *, struct pex_obj
*);
303 static void fork_execute (const char *, char **);
304 static void maybe_unlink (const char *);
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
327 static int is_in_list (const char *, struct id
*);
329 static void write_aix_file (FILE *, struct id
*);
330 static char *resolve_lib_name (const char *);
332 static char *extract_string (const char **);
333 static void post_ld_pass (bool);
334 static void process_args (int *argcp
, char **argv
);
336 /* Enumerations describing which pass this is for scanning the
340 PASS_FIRST
, /* without constructors */
341 PASS_OBJ
, /* individual objects */
342 PASS_LIB
, /* looking for shared libraries */
343 PASS_SECOND
, /* with constructors linked in */
344 PASS_LTOINFO
/* looking for objects with LTO info */
347 /* ... and which kinds of symbols are to be considered. */
349 enum scanfilter_masks
{
352 SCAN_CTOR
= 1 << SYM_CTOR
,
353 SCAN_DTOR
= 1 << SYM_DTOR
,
354 SCAN_INIT
= 1 << SYM_INIT
,
355 SCAN_FINI
= 1 << SYM_FINI
,
356 SCAN_DWEH
= 1 << SYM_DWEH
,
357 SCAN_AIXI
= 1 << SYM_AIXI
,
358 SCAN_AIXD
= 1 << SYM_AIXD
,
362 /* This type is used for parameters and variables which hold
363 combinations of the flags in enum scanfilter_masks. */
364 typedef int scanfilter
;
366 /* Scan the name list of the loaded program for the symbols g++ uses for
367 static constructors and destructors.
369 The SCANPASS argument tells which collect processing pass this is for and
370 the SCANFILTER argument tells which kinds of symbols to consider in this
371 pass. Symbols of a special kind not in the filter mask are considered as
374 The constructor table begins at __CTOR_LIST__ and contains a count of the
375 number of pointers (or -1 if the constructors are built in a separate
376 section by the linker), followed by the pointers to the constructor
377 functions, terminated with a null pointer. The destructor table has the
378 same format, and begins at __DTOR_LIST__. */
380 static void scan_prog_file (const char *, scanpass
, scanfilter
);
383 /* Delete tempfiles and exit function. */
386 tool_cleanup (bool from_signal
)
388 if (c_file
!= 0 && c_file
[0])
389 maybe_unlink (c_file
);
391 if (o_file
!= 0 && o_file
[0])
392 maybe_unlink (o_file
);
394 #ifdef COLLECT_EXPORT_LIST
395 if (export_file
!= 0 && export_file
[0])
396 maybe_unlink (export_file
);
400 maybe_unlink_list (lto_o_files
);
402 if (ldout
!= 0 && ldout
[0])
405 dump_ld_file (ldout
, stdout
);
406 maybe_unlink (ldout
);
409 if (lderrout
!= 0 && lderrout
[0])
412 dump_ld_file (lderrout
, stderr
);
413 maybe_unlink (lderrout
);
418 collect_atexit (void)
420 tool_cleanup (false);
428 signal (signo
, SIG_DFL
);
432 /* Notify user of a non-error. */
434 notice (const char *cmsgid
, ...)
438 va_start (ap
, cmsgid
);
439 vfprintf (stderr
, _(cmsgid
), ap
);
443 /* Notify user of a non-error, without translating the format string. */
445 notice_translated (const char *cmsgid
, ...)
449 va_start (ap
, cmsgid
);
450 vfprintf (stderr
, cmsgid
, ap
);
455 file_exists (const char *name
)
457 return access (name
, R_OK
) == 0;
460 /* Parse a reasonable subset of shell quoting syntax. */
463 extract_string (const char **pp
)
476 obstack_1grow (&temporary_obstack
, c
);
477 else if (! inside
&& c
== ' ')
479 else if (! inside
&& c
== '\\')
484 obstack_1grow (&temporary_obstack
, c
);
487 obstack_1grow (&temporary_obstack
, '\0');
489 return XOBFINISH (&temporary_obstack
, char *);
493 dump_ld_file (const char *name
, FILE *to
)
495 FILE *stream
= fopen (name
, "r");
502 while (c
= getc (stream
),
503 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
504 obstack_1grow (&temporary_obstack
, c
);
505 if (obstack_object_size (&temporary_obstack
) > 0)
507 const char *word
, *p
;
509 obstack_1grow (&temporary_obstack
, '\0');
510 word
= XOBFINISH (&temporary_obstack
, const char *);
513 ++word
, putc ('.', to
);
515 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
516 p
+= strlen (USER_LABEL_PREFIX
);
518 #ifdef HAVE_LD_DEMANGLE
524 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
532 diff
= strlen (word
) - strlen (result
);
533 while (diff
> 0 && c
== ' ')
534 --diff
, putc (' ', to
);
535 if (diff
< 0 && c
== ' ')
537 while (diff
< 0 && c
== ' ')
538 ++diff
, c
= getc (stream
);
541 /* Make sure we output at least one space, or
542 the demangled symbol name will run into
543 whatever text follows. */
554 obstack_free (&temporary_obstack
, temporary_firstobj
);
563 /* Return the kind of symbol denoted by name S. */
566 is_ctor_dtor (const char *s
)
568 struct names
{ const char *const name
; const int len
; symkind ret
;
569 const int two_underscores
; };
571 const struct names
*p
;
573 const char *orig_s
= s
;
575 static const struct names special
[] = {
576 #ifndef NO_DOLLAR_IN_LABEL
577 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
578 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
580 #ifndef NO_DOT_IN_LABEL
581 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
582 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
583 #endif /* NO_DOT_IN_LABEL */
584 #endif /* NO_DOLLAR_IN_LABEL */
585 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
586 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
587 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
588 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
589 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
590 #ifdef TARGET_AIX_VERSION
591 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
592 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
594 { NULL
, 0, SYM_REGULAR
, 0 }
597 while ((ch
= *s
) == '_')
603 for (p
= &special
[0]; p
->len
> 0; p
++)
606 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
607 && strncmp (s
, p
->name
, p
->len
) == 0)
615 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
616 and one from the PATH variable. */
618 static struct path_prefix cpath
, path
;
620 #ifdef CROSS_DIRECTORY_STRUCTURE
621 /* This is the name of the target machine. We use it to form the name
622 of the files to execute. */
624 static const char *const target_machine
= TARGET_MACHINE
;
627 /* Search for NAME using prefix list PPREFIX. We only look for executable
630 Return 0 if not found, otherwise return its name, allocated with malloc. */
632 #ifdef OBJECT_FORMAT_NONE
634 /* Add an entry for the object file NAME to object file list LIST.
635 New entries are added at the end of the list. The original pointer
636 value of NAME is preserved, i.e., no string copy is performed. */
639 add_lto_object (struct lto_object_list
*list
, const char *name
)
641 struct lto_object
*n
= XNEW (struct lto_object
);
646 list
->last
->next
= n
;
652 #endif /* OBJECT_FORMAT_NONE */
655 /* Perform a link-time recompilation and relink if any of the object
656 files contain LTO info. The linker command line LTO_LD_ARGV
657 represents the linker command that would produce a final executable
658 without the use of LTO. OBJECT_LST is a vector of object file names
659 appearing in LTO_LD_ARGV that are to be considered for link-time
660 recompilation, where OBJECT is a pointer to the last valid element.
661 (This awkward convention avoids an impedance mismatch with the
662 usage of similarly-named variables in main().) The elements of
663 OBJECT_LST must be identical, i.e., pointer equal, to the
664 corresponding arguments in LTO_LD_ARGV.
666 Upon entry, at least one linker run has been performed without the
667 use of any LTO info that might be present. Any recompilations
668 necessary for template instantiations have been performed, and
669 initializer/finalizer tables have been created if needed and
670 included in the linker command line LTO_LD_ARGV. If any of the
671 object files contain LTO info, we run the LTO back end on all such
672 files, and perform the final link with the LTO back end output
673 substituted for the LTO-optimized files. In some cases, a final
674 link with all link-time generated code has already been performed,
675 so there is no need to relink if no LTO info is found. In other
676 cases, our caller has not produced the final executable, and is
677 relying on us to perform the required link whether LTO info is
678 present or not. In that case, the FORCE argument should be true.
679 Note that the linker command line argument LTO_LD_ARGV passed into
680 this function may be modified in place. */
683 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
684 const char **object
, bool force
)
686 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
688 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
690 while (object_file
< object
)
692 /* If file contains LTO info, add it to the list of LTO objects. */
693 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
695 /* Increment the argument count by the number of object file arguments
696 we will add. An upper bound suffices, so just count all of the
697 object files regardless of whether they contain LTO info. */
701 if (lto_objects
.first
)
704 const char **lto_c_ptr
;
707 struct lto_object
*list
;
708 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
710 const char *prog
= "lto-wrapper";
711 int lto_ld_argv_size
= 0;
712 char **out_lto_ld_argv
;
713 int out_lto_ld_argv_size
;
717 fatal_error ("COLLECT_LTO_WRAPPER must be set");
721 /* There is at least one object file containing LTO info,
722 so we need to run the LTO back end and relink.
724 To do so we build updated ld arguments with first
725 LTO object replaced by all partitions and other LTO
728 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
729 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
731 *lto_c_ptr
++ = lto_wrapper
;
733 /* Add LTO objects to the wrapper command line. */
734 for (list
= lto_objects
.first
; list
; list
= list
->next
)
735 *lto_c_ptr
++ = list
->name
;
739 /* Run the LTO back end. */
740 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
);
747 stream
= pex_read_output (pex
, 0);
751 while ((c
= getc (stream
)) != EOF
)
753 obstack_1grow (&temporary_obstack
, c
);
758 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
759 lto_o_files
[num_files
] = NULL
;
760 start
= XOBFINISH (&temporary_obstack
, char *);
761 for (i
= 0; i
< num_files
; ++i
)
768 lto_o_files
[i
] = xstrdup (start
);
773 obstack_free (&temporary_obstack
, temporary_firstobj
);
778 /* Compute memory needed for new LD arguments. At most number of original arguemtns
779 plus number of partitions. */
780 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
782 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
783 out_lto_ld_argv_size
= 0;
785 /* After running the LTO back end, we will relink, substituting
786 the LTO output for the object files that we submitted to the
787 LTO. Here, we modify the linker command line for the relink. */
789 /* Copy all arguments until we find first LTO file. */
793 for (list
= lto_objects
.first
; list
; list
= list
->next
)
794 if (*p
== list
->name
) /* Note test for pointer equality! */
798 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
801 /* Now insert all LTO partitions. */
802 lto_o_ptr
= lto_o_files
;
804 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
806 /* ... and copy the rest. */
809 for (list
= lto_objects
.first
; list
; list
= list
->next
)
810 if (*p
== list
->name
) /* Note test for pointer equality! */
813 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
816 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
818 /* Run the linker again, this time replacing the object files
819 optimized by the LTO with the temporary file generated by the LTO. */
820 fork_execute ("ld", out_lto_ld_argv
);
824 maybe_unlink_list (lto_o_files
);
828 /* Our caller is relying on us to do the link
829 even though there is no LTO back end work to be done. */
830 fork_execute ("ld", lto_ld_argv
);
831 post_ld_pass (false);
840 main (int argc
, char **argv
)
849 } selected_linker
= USE_DEFAULT_LD
;
850 static const char *const ld_suffixes
[USE_LD_MAX
] =
857 static const char *const real_ld_suffix
= "real-ld";
858 static const char *const collect_ld_suffix
= "collect-ld";
859 static const char *const nm_suffix
= "nm";
860 static const char *const gnm_suffix
= "gnm";
862 static const char *const ldd_suffix
= LDD_SUFFIX
;
864 static const char *const strip_suffix
= "strip";
865 static const char *const gstrip_suffix
= "gstrip";
867 const char *full_ld_suffixes
[USE_LD_MAX
];
868 #ifdef CROSS_DIRECTORY_STRUCTURE
869 /* If we look for a program in the compiler directories, we just use
870 the short name, since these directories are already system-specific.
871 But it we look for a program in the system directories, we need to
872 qualify the program name with the target machine. */
874 const char *const full_nm_suffix
=
875 concat (target_machine
, "-", nm_suffix
, NULL
);
876 const char *const full_gnm_suffix
=
877 concat (target_machine
, "-", gnm_suffix
, NULL
);
879 const char *const full_ldd_suffix
=
880 concat (target_machine
, "-", ldd_suffix
, NULL
);
882 const char *const full_strip_suffix
=
883 concat (target_machine
, "-", strip_suffix
, NULL
);
884 const char *const full_gstrip_suffix
=
885 concat (target_machine
, "-", gstrip_suffix
, NULL
);
888 const char *const full_ldd_suffix
= ldd_suffix
;
890 const char *const full_nm_suffix
= nm_suffix
;
891 const char *const full_gnm_suffix
= gnm_suffix
;
892 const char *const full_strip_suffix
= strip_suffix
;
893 const char *const full_gstrip_suffix
= gstrip_suffix
;
894 #endif /* CROSS_DIRECTORY_STRUCTURE */
898 #ifdef COLLECT_EXPORT_LIST
901 const char *ld_file_name
;
907 bool use_plugin
= false;
908 bool use_collect_ld
= false;
910 /* The kinds of symbols we will have to consider when scanning the
911 outcome of a first pass link. This is ALL to start with, then might
912 be adjusted before getting to the first pass link per se, typically on
913 AIX where we perform an early scan of objects and libraries to fetch
914 the list of global ctors/dtors and make sure they are not garbage
916 scanfilter ld1_filter
= SCAN_ALL
;
922 #ifdef TARGET_AIX_VERSION
923 int object_nbr
= argc
;
930 for (i
= 0; i
< USE_LD_MAX
; i
++)
932 #ifdef CROSS_DIRECTORY_STRUCTURE
933 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
938 p
= argv
[0] + strlen (argv
[0]);
939 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
943 xmalloc_set_program_name (progname
);
946 expandargv (&argc
, &argv
);
947 if (argv
!= old_argv
)
948 at_file_supplied
= 1;
950 process_args (&argc
, argv
);
952 num_c_args
= argc
+ 9;
954 #ifndef HAVE_LD_DEMANGLE
955 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
957 /* Suppress demangling by the real linker, which may be broken. */
958 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
961 #if defined (COLLECT2_HOST_INITIALIZATION)
962 /* Perform system dependent initialization, if necessary. */
963 COLLECT2_HOST_INITIALIZATION
;
967 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
968 receive the signal. A different setting is inheritable */
969 signal (SIGCHLD
, SIG_DFL
);
972 if (atexit (collect_atexit
) != 0)
973 fatal_error ("atexit failed");
975 /* Unlock the stdio streams. */
976 unlock_std_streams ();
980 diagnostic_initialize (global_dc
, 0);
982 /* Do not invoke xcalloc before this point, since locale needs to be
983 set first, in case a diagnostic is issued. */
985 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
986 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
987 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
988 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
989 object_lst
= XCNEWVEC (char *, argc
);
990 object
= CONST_CAST2 (const char **, char **, object_lst
);
996 /* Parse command line early for instances of -debug. This allows
997 the debug flag to be set before functions like find_a_file()
998 are called. We also look for the -flto or -flto-partition=none flag to know
999 what LTO mode we are in. */
1001 bool no_partition
= false;
1003 for (i
= 1; argv
[i
] != NULL
; i
++)
1005 if (! strcmp (argv
[i
], "-debug"))
1007 else if (! strcmp (argv
[i
], "-flto-partition=none"))
1008 no_partition
= true;
1009 else if (!strncmp (argv
[i
], "-fno-lto", 8))
1010 lto_mode
= LTO_MODE_NONE
;
1011 else if (! strcmp (argv
[i
], "-plugin"))
1014 if (selected_linker
== USE_DEFAULT_LD
)
1015 selected_linker
= USE_PLUGIN_LD
;
1017 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1018 selected_linker
= USE_BFD_LD
;
1019 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1020 selected_linker
= USE_GOLD_LD
;
1022 #ifdef COLLECT_EXPORT_LIST
1023 /* These flags are position independent, although their order
1024 is important - subsequent flags override earlier ones. */
1025 else if (strcmp (argv
[i
], "-b64") == 0)
1027 /* -bexport:filename always needs the :filename */
1028 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1029 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1031 else if (strcmp (argv
[i
], "-brtl") == 0
1032 || strcmp (argv
[i
], "-bsvr4") == 0
1033 || strcmp (argv
[i
], "-G") == 0)
1035 else if (strcmp (argv
[i
], "-bnortl") == 0)
1037 else if (strcmp (argv
[i
], "-blazy") == 0)
1042 find_file_set_debug (debug
);
1044 lto_mode
= LTO_MODE_NONE
;
1045 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1046 lto_mode
= LTO_MODE_LTO
;
1049 #ifndef DEFAULT_A_OUT_NAME
1050 output_file
= "a.out";
1052 output_file
= DEFAULT_A_OUT_NAME
;
1055 obstack_begin (&temporary_obstack
, 0);
1056 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1058 #ifndef HAVE_LD_DEMANGLE
1059 current_demangling_style
= auto_demangling
;
1061 p
= getenv ("COLLECT_GCC_OPTIONS");
1064 const char *q
= extract_string (&p
);
1065 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1068 obstack_free (&temporary_obstack
, temporary_firstobj
);
1070 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1071 -fno-exceptions -w -fno-whole-program */
1074 c_argv
= XCNEWVEC (char *, num_c_args
);
1075 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1078 fatal_error ("no arguments");
1081 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1082 signal (SIGQUIT
, handler
);
1084 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1085 signal (SIGINT
, handler
);
1087 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1088 signal (SIGALRM
, handler
);
1091 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1092 signal (SIGHUP
, handler
);
1094 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1095 signal (SIGSEGV
, handler
);
1097 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1098 signal (SIGBUS
, handler
);
1101 /* Extract COMPILER_PATH and PATH into our prefix list. */
1102 prefix_from_env ("COMPILER_PATH", &cpath
);
1103 prefix_from_env ("PATH", &path
);
1105 /* Try to discover a valid linker/nm/strip to use. */
1107 /* Maybe we know the right file to use (if not cross). */
1109 #ifdef DEFAULT_LINKER
1110 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
)
1113 # ifdef HOST_EXECUTABLE_SUFFIX
1114 int len
= (sizeof (DEFAULT_LINKER
)
1115 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1119 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1120 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1121 HOST_EXECUTABLE_SUFFIX. */
1122 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1124 default_linker
[len
] = '\0';
1125 linker_name
= concat (default_linker
,
1126 &ld_suffixes
[selected_linker
][2],
1127 HOST_EXECUTABLE_SUFFIX
, NULL
);
1130 if (linker_name
== NULL
)
1132 linker_name
= concat (DEFAULT_LINKER
,
1133 &ld_suffixes
[selected_linker
][2],
1135 if (access (linker_name
, X_OK
) == 0)
1136 ld_file_name
= linker_name
;
1138 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1139 ld_file_name
= DEFAULT_LINKER
;
1140 if (ld_file_name
== 0)
1142 #ifdef REAL_LD_FILE_NAME
1143 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1144 if (ld_file_name
== 0)
1146 /* Search the (target-specific) compiler dirs for ld'. */
1147 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1148 /* Likewise for `collect-ld'. */
1149 if (ld_file_name
== 0)
1151 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1152 use_collect_ld
= ld_file_name
!= 0;
1154 /* Search the compiler directories for `ld'. We have protection against
1155 recursive calls in find_a_file. */
1156 if (ld_file_name
== 0)
1157 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1158 /* Search the ordinary system bin directories
1159 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1160 if (ld_file_name
== 0)
1161 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1163 #ifdef REAL_NM_FILE_NAME
1164 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1165 if (nm_file_name
== 0)
1167 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1168 if (nm_file_name
== 0)
1169 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1170 if (nm_file_name
== 0)
1171 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1172 if (nm_file_name
== 0)
1173 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1176 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1177 if (ldd_file_name
== 0)
1178 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1181 #ifdef REAL_STRIP_FILE_NAME
1182 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1183 if (strip_file_name
== 0)
1185 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1186 if (strip_file_name
== 0)
1187 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1188 if (strip_file_name
== 0)
1189 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1190 if (strip_file_name
== 0)
1191 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1193 /* Determine the full path name of the C compiler to use. */
1194 c_file_name
= getenv ("COLLECT_GCC");
1195 if (c_file_name
== 0)
1197 #ifdef CROSS_DIRECTORY_STRUCTURE
1198 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1200 c_file_name
= "gcc";
1204 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1206 /* Here it should be safe to use the system search path since we should have
1207 already qualified the name of the compiler when it is needed. */
1209 p
= find_a_file (&path
, c_file_name
, X_OK
);
1214 *ld1
++ = *ld2
++ = ld_file_name
;
1216 /* Make temp file names. */
1217 c_file
= make_temp_file (".c");
1218 o_file
= make_temp_file (".o");
1219 #ifdef COLLECT_EXPORT_LIST
1220 export_file
= make_temp_file (".x");
1224 ldout
= make_temp_file (".ld");
1225 lderrout
= make_temp_file (".le");
1227 *c_ptr
++ = c_file_name
;
1234 #ifdef COLLECT_EXPORT_LIST
1235 /* Generate a list of directories from LIBPATH. */
1236 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1237 /* Add to this list also two standard directories where
1238 AIX loader always searches for libraries. */
1239 add_prefix (&libpath_lib_dirs
, "/lib");
1240 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1243 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1245 AIX support needs to know if -shared has been specified before
1246 parsing commandline arguments. */
1248 p
= getenv ("COLLECT_GCC_OPTIONS");
1251 const char *q
= extract_string (&p
);
1252 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1253 *c_ptr
++ = xstrdup (q
);
1254 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1255 *c_ptr
++ = xstrdup (q
);
1256 if (strcmp (q
, "-shared") == 0)
1258 if (*q
== '-' && q
[1] == 'B')
1260 *c_ptr
++ = xstrdup (q
);
1263 q
= extract_string (&p
);
1264 *c_ptr
++ = xstrdup (q
);
1268 obstack_free (&temporary_obstack
, temporary_firstobj
);
1269 *c_ptr
++ = "-fno-profile-arcs";
1270 *c_ptr
++ = "-fno-test-coverage";
1271 *c_ptr
++ = "-fno-branch-probabilities";
1272 *c_ptr
++ = "-fno-exceptions";
1274 *c_ptr
++ = "-fno-whole-program";
1276 /* !!! When GCC calls collect2,
1277 it does not know whether it is calling collect2 or ld.
1278 So collect2 cannot meaningfully understand any options
1279 except those ld understands.
1280 If you propose to make GCC pass some other option,
1281 just imagine what will happen if ld is really ld!!! */
1283 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1284 /* After the first file, put in the c++ rt0. */
1287 while ((arg
= *++argv
) != (char *) 0)
1289 *ld1
++ = *ld2
++ = arg
;
1296 if (!strcmp (arg
, "-debug"))
1298 /* Already parsed. */
1302 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1305 *ld1
++ = *ld2
++ = *argv
;
1310 if (strncmp (arg
, "-flto", 5) == 0)
1313 /* Do not pass LTO flag to the linker. */
1317 error ("LTO support has not been enabled in this "
1321 else if (!use_collect_ld
1322 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1324 /* Do not pass -fuse-ld={bfd|gold} to the linker. */
1328 #ifdef TARGET_AIX_VERSION
1331 /* File containing a list of input files to process. */
1334 char buf
[MAXPATHLEN
+ 2];
1335 /* Number of additionnal object files. */
1337 /* Maximum of additionnal object files before vector
1340 const char *list_filename
= arg
+ 2;
1342 /* Accept -fFILENAME and -f FILENAME. */
1343 if (*list_filename
== '\0' && argv
[1])
1346 list_filename
= *argv
;
1347 *ld1
++ = *ld2
++ = *argv
;
1350 stream
= fopen (list_filename
, "r");
1352 fatal_error ("can't open %s: %m", list_filename
);
1354 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1356 /* Remove end of line. */
1357 int len
= strlen (buf
);
1358 if (len
>= 1 && buf
[len
- 1] =='\n')
1359 buf
[len
- 1] = '\0';
1361 /* Put on object vector.
1362 Note: we only expanse vector here, so we must keep
1363 extra space for remaining arguments. */
1364 if (add_nbr
>= add_max
)
1367 object
- CONST_CAST2 (const char **, char **,
1369 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1370 object_lst
= XRESIZEVEC (char *, object_lst
,
1371 object_nbr
+ add_max
);
1372 object
= CONST_CAST2 (const char **, char **,
1374 object_nbr
+= add_max
;
1376 *object
++ = xstrdup (buf
);
1387 /* place o_file BEFORE this argument! */
1393 #ifdef COLLECT_EXPORT_LIST
1395 /* Resolving full library name. */
1396 const char *s
= resolve_lib_name (arg
+2);
1398 /* Saving a full library name. */
1399 add_to_list (&libs
, s
);
1404 #ifdef COLLECT_EXPORT_LIST
1405 /* Saving directories where to search for libraries. */
1407 add_prefix (&cmdline_lib_dirs
, arg
+2);
1413 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1415 output_file
= &arg
[2];
1424 if (arg
[2] == '\0' && do_collecting
)
1426 /* We must strip after the nm run, otherwise C++ linking
1427 will not work. Thus we strip in the second ld run, or
1428 else with strip if there is no second ld run. */
1440 if (strcmp (arg
, "--no-demangle") == 0)
1442 #ifndef HAVE_LD_DEMANGLE
1448 else if (strncmp (arg
, "--demangle", 10) == 0)
1450 #ifndef HAVE_LD_DEMANGLE
1454 enum demangling_styles style
1455 = cplus_demangle_name_to_style (arg
+11);
1456 if (style
== unknown_demangling
)
1457 error ("unknown demangling style '%s'", arg
+11);
1459 current_demangling_style
= style
;
1465 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1466 target_system_root
= arg
+ 10;
1467 else if (strcmp (arg
, "--version") == 0)
1469 else if (strcmp (arg
, "--help") == 0)
1474 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1475 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1476 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1477 || strcmp (p
, ".obj") == 0))
1486 /* place o_file BEFORE this argument! */
1492 if (p
[1] == 'o' || p
[1] == 'l')
1494 #ifdef COLLECT_EXPORT_LIST
1495 /* libraries can be specified directly, i.e. without -l flag. */
1498 /* Saving a full library name. */
1499 add_to_list (&libs
, arg
);
1505 #ifdef COLLECT_EXPORT_LIST
1506 /* This is added only for debugging purposes. */
1509 fprintf (stderr
, "List of libraries:\n");
1510 dump_list (stderr
, "\t", libs
.first
);
1513 /* The AIX linker will discard static constructors in object files if
1514 nothing else in the file is referenced, so look at them first. Unless
1515 we are building a shared object, ignore the eh frame tables, as we
1516 would otherwise reference them all, hence drag all the corresponding
1517 objects even if nothing else is referenced. */
1519 const char **export_object_lst
1520 = CONST_CAST2 (const char **, char **, object_lst
);
1522 struct id
*list
= libs
.first
;
1524 /* Compute the filter to use from the current one, do scan, then adjust
1525 the "current" filter to remove what we just included here. This will
1526 control whether we need a first pass link later on or not, and what
1527 will remain to be scanned there. */
1529 scanfilter this_filter
= ld1_filter
;
1532 this_filter
&= ~SCAN_DWEH
;
1535 while (export_object_lst
< object
)
1536 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1538 for (; list
; list
= list
->next
)
1539 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1541 ld1_filter
= ld1_filter
& ~this_filter
;
1546 char *buf
= concat ("-bE:", export_file
, NULL
);
1551 exportf
= fopen (export_file
, "w");
1552 if (exportf
== (FILE *) 0)
1553 fatal_error ("fopen %s: %m", export_file
);
1554 write_aix_file (exportf
, exports
.first
);
1555 if (fclose (exportf
))
1556 fatal_error ("fclose %s: %m", export_file
);
1561 *c_ptr
= *ld1
= *object
= (char *) 0;
1564 notice ("collect2 version %s\n", version_string
);
1568 printf ("Usage: collect2 [options]\n");
1569 printf (" Wrap linker and generate constructor code if needed.\n");
1570 printf (" Options:\n");
1571 printf (" -debug Enable debug output\n");
1572 printf (" --help Display this information\n");
1573 printf (" -v, --version Display this program's version number\n");
1575 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1576 printf ("Report bugs: %s\n", bug_report_url
);
1583 fprintf (stderr
, "ld_file_name = %s\n",
1584 (ld_file_name
? ld_file_name
: "not found"));
1585 fprintf (stderr
, "c_file_name = %s\n",
1586 (c_file_name
? c_file_name
: "not found"));
1587 fprintf (stderr
, "nm_file_name = %s\n",
1588 (nm_file_name
? nm_file_name
: "not found"));
1590 fprintf (stderr
, "ldd_file_name = %s\n",
1591 (ldd_file_name
? ldd_file_name
: "not found"));
1593 fprintf (stderr
, "strip_file_name = %s\n",
1594 (strip_file_name
? strip_file_name
: "not found"));
1595 fprintf (stderr
, "c_file = %s\n",
1596 (c_file
? c_file
: "not found"));
1597 fprintf (stderr
, "o_file = %s\n",
1598 (o_file
? o_file
: "not found"));
1600 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1602 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1604 ptr
= getenv ("COLLECT_GCC");
1606 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1608 ptr
= getenv ("COMPILER_PATH");
1610 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1612 ptr
= getenv (LIBRARY_PATH_ENV
);
1614 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1616 fprintf (stderr
, "\n");
1619 /* Load the program, searching all libraries and attempting to provide
1620 undefined symbols from repository information.
1622 If -r or they will be run via some other method, do not build the
1623 constructor or destructor list, just return now. */
1626 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1628 /* Perform the first pass link now, if we're about to exit or if we need
1629 to scan for things we haven't collected yet before pursuing further.
1631 On AIX, the latter typically includes nothing for shared objects or
1632 frame tables for an executable, out of what the required early scan on
1633 objects and libraries has performed above. In the !shared_obj case, we
1634 expect the relevant tables to be dragged together with their associated
1635 functions from precise cross reference insertions by the compiler. */
1637 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1638 do_tlink (ld1_argv
, object_lst
);
1642 #ifdef COLLECT_EXPORT_LIST
1643 /* Make sure we delete the export file we may have created. */
1644 if (export_file
!= 0 && export_file
[0])
1645 maybe_unlink (export_file
);
1647 if (lto_mode
!= LTO_MODE_NONE
)
1648 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1650 post_ld_pass (false);
1652 maybe_unlink (c_file
);
1653 maybe_unlink (o_file
);
1658 /* Unless we have done it all already, examine the namelist and search for
1659 static constructors and destructors to call. Write the constructor and
1660 destructor tables to a .s file and reload. */
1662 if (ld1_filter
!= SCAN_NOTHING
)
1663 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1665 #ifdef SCAN_LIBRARIES
1666 scan_libraries (output_file
);
1671 notice_translated (ngettext ("%d constructor found\n",
1672 "%d constructors found\n",
1673 constructors
.number
),
1674 constructors
.number
);
1675 notice_translated (ngettext ("%d destructor found\n",
1676 "%d destructors found\n",
1677 destructors
.number
),
1678 destructors
.number
);
1679 notice_translated (ngettext ("%d frame table found\n",
1680 "%d frame tables found\n",
1681 frame_tables
.number
),
1682 frame_tables
.number
);
1685 /* If the scan exposed nothing of special interest, there's no need to
1686 generate the glue code and relink so return now. */
1688 if (constructors
.number
== 0 && destructors
.number
== 0
1689 && frame_tables
.number
== 0
1690 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1691 /* If we will be running these functions ourselves, we want to emit
1692 stubs into the shared library so that we do not have to relink
1693 dependent programs when we add static objects. */
1698 /* Do tlink without additional code generation now if we didn't
1699 do it earlier for scanning purposes. */
1700 if (ld1_filter
== SCAN_NOTHING
)
1701 do_tlink (ld1_argv
, object_lst
);
1704 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1706 /* Strip now if it was requested on the command line. */
1709 char **real_strip_argv
= XCNEWVEC (char *, 3);
1710 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1713 strip_argv
[0] = strip_file_name
;
1714 strip_argv
[1] = output_file
;
1715 strip_argv
[2] = (char *) 0;
1716 fork_execute ("strip", real_strip_argv
);
1719 #ifdef COLLECT_EXPORT_LIST
1720 maybe_unlink (export_file
);
1722 post_ld_pass (false);
1724 maybe_unlink (c_file
);
1725 maybe_unlink (o_file
);
1729 /* Sort ctor and dtor lists by priority. */
1730 sort_ids (&constructors
);
1731 sort_ids (&destructors
);
1733 maybe_unlink (output_file
);
1734 outf
= fopen (c_file
, "w");
1735 if (outf
== (FILE *) 0)
1736 fatal_error ("fopen %s: %m", c_file
);
1738 write_c_file (outf
, c_file
);
1741 fatal_error ("fclose %s: %m", c_file
);
1743 /* Tell the linker that we have initializer and finalizer functions. */
1744 #ifdef LD_INIT_SWITCH
1745 #ifdef COLLECT_EXPORT_LIST
1746 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1748 *ld2
++ = LD_INIT_SWITCH
;
1750 *ld2
++ = LD_FINI_SWITCH
;
1755 #ifdef COLLECT_EXPORT_LIST
1758 /* If we did not add export flag to link arguments before, add it to
1759 second link phase now. No new exports should have been added. */
1760 if (! exports
.first
)
1761 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1763 #ifdef TARGET_AIX_VERSION
1764 add_to_list (&exports
, aix_shared_initname
);
1765 add_to_list (&exports
, aix_shared_fininame
);
1768 #ifndef LD_INIT_SWITCH
1769 add_to_list (&exports
, initname
);
1770 add_to_list (&exports
, fininame
);
1771 add_to_list (&exports
, "_GLOBAL__DI");
1772 add_to_list (&exports
, "_GLOBAL__DD");
1774 exportf
= fopen (export_file
, "w");
1775 if (exportf
== (FILE *) 0)
1776 fatal_error ("fopen %s: %m", export_file
);
1777 write_aix_file (exportf
, exports
.first
);
1778 if (fclose (exportf
))
1779 fatal_error ("fclose %s: %m", export_file
);
1783 /* End of arguments to second link phase. */
1788 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1789 output_file
, c_file
);
1790 write_c_file (stderr
, "stderr");
1791 fprintf (stderr
, "========== end of c_file\n\n");
1792 #ifdef COLLECT_EXPORT_LIST
1793 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1794 write_aix_file (stderr
, exports
.first
);
1795 fprintf (stderr
, "========== end of export_file\n\n");
1799 /* Assemble the constructor and destructor tables.
1800 Link the tables in with the rest of the program. */
1802 fork_execute ("gcc", c_argv
);
1803 #ifdef COLLECT_EXPORT_LIST
1804 /* On AIX we must call tlink because of possible templates resolution. */
1805 do_tlink (ld2_argv
, object_lst
);
1808 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1810 /* Otherwise, simply call ld because tlink is already done. */
1812 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1815 fork_execute ("ld", ld2_argv
);
1816 post_ld_pass (false);
1819 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1820 constructors/destructors in shared libraries. */
1821 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1824 maybe_unlink (c_file
);
1825 maybe_unlink (o_file
);
1827 #ifdef COLLECT_EXPORT_LIST
1828 maybe_unlink (export_file
);
1835 /* Wait for a process to finish, and exit if a nonzero status is found. */
1838 collect_wait (const char *prog
, struct pex_obj
*pex
)
1842 if (!pex_get_status (pex
, 1, &status
))
1843 fatal_error ("can't get program status: %m");
1848 if (WIFSIGNALED (status
))
1850 int sig
= WTERMSIG (status
);
1851 error ("%s terminated with signal %d [%s]%s",
1852 prog
, sig
, strsignal (sig
),
1853 WCOREDUMP (status
) ? ", core dumped" : "");
1854 exit (FATAL_EXIT_CODE
);
1857 if (WIFEXITED (status
))
1858 return WEXITSTATUS (status
);
1864 do_wait (const char *prog
, struct pex_obj
*pex
)
1866 int ret
= collect_wait (prog
, pex
);
1869 error ("%s returned %d exit status", prog
, ret
);
1875 unlink (response_file
);
1876 response_file
= NULL
;
1881 /* Execute a program, and wait for the reply. */
1884 collect_execute (const char *prog
, char **argv
, const char *outname
,
1885 const char *errname
, int flags
)
1887 struct pex_obj
*pex
;
1890 char *response_arg
= NULL
;
1891 char *response_argv
[3] ATTRIBUTE_UNUSED
;
1893 if (HAVE_GNU_LD
&& at_file_supplied
&& argv
[0] != NULL
)
1895 /* If using @file arguments, create a temporary file and put the
1896 contents of argv into it. Then change argv to an array corresponding
1897 to a single argument @FILE, where FILE is the temporary filename. */
1899 char **current_argv
= argv
+ 1;
1900 char *argv0
= argv
[0];
1904 /* Note: we assume argv contains at least one element; this is
1907 response_file
= make_temp_file ("");
1909 f
= fopen (response_file
, "w");
1912 fatal_error ("could not open response file %s", response_file
);
1914 status
= writeargv (current_argv
, f
);
1917 fatal_error ("could not write to response file %s", response_file
);
1919 status
= fclose (f
);
1922 fatal_error ("could not close response file %s", response_file
);
1924 response_arg
= concat ("@", response_file
, NULL
);
1925 response_argv
[0] = argv0
;
1926 response_argv
[1] = response_arg
;
1927 response_argv
[2] = NULL
;
1929 argv
= response_argv
;
1932 if (verbose
|| debug
)
1938 fprintf (stderr
, "%s", argv
[0]);
1940 notice ("[cannot find %s]", prog
);
1942 for (p_argv
= &argv
[1]; (str
= *p_argv
) != (char *) 0; p_argv
++)
1943 fprintf (stderr
, " %s", str
);
1945 fprintf (stderr
, "\n");
1951 /* If we cannot find a program we need, complain error. Do this here
1952 since we might not end up needing something that we could not find. */
1955 fatal_error ("cannot find '%s'", prog
);
1957 pex
= pex_init (0, "collect2", NULL
);
1959 fatal_error ("pex_init failed: %m");
1961 errmsg
= pex_run (pex
, flags
, argv
[0], argv
, outname
,
1968 fatal_error ("%s: %m", _(errmsg
));
1971 fatal_error (errmsg
);
1974 free (response_arg
);
1980 fork_execute (const char *prog
, char **argv
)
1982 struct pex_obj
*pex
;
1984 pex
= collect_execute (prog
, argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
1985 do_wait (prog
, pex
);
1988 /* Unlink FILE unless we are debugging or this is the output_file
1989 and we may not unlink it. */
1992 maybe_unlink (const char *file
)
1996 notice ("[Leaving %s]\n", file
);
2000 if (file
== output_file
&& !may_unlink_output_file
)
2003 unlink_if_ordinary (file
);
2006 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2009 maybe_unlink_list (char **file_list
)
2011 char **tmp
= file_list
;
2014 maybe_unlink (*(tmp
++));
2018 static long sequence_number
= 0;
2020 /* Add a name to a linked list. */
2023 add_to_list (struct head
*head_ptr
, const char *name
)
2026 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
2028 strcpy (newid
->name
, name
);
2030 if (head_ptr
->first
)
2031 head_ptr
->last
->next
= newid
;
2033 head_ptr
->first
= newid
;
2035 /* Check for duplicate symbols. */
2036 for (p
= head_ptr
->first
;
2037 strcmp (name
, p
->name
) != 0;
2042 head_ptr
->last
->next
= 0;
2047 newid
->sequence
= ++sequence_number
;
2048 head_ptr
->last
= newid
;
2052 /* Grab the init priority number from an init function name that
2053 looks like "_GLOBAL_.I.12345.foo". */
2056 extract_init_priority (const char *name
)
2060 #ifdef TARGET_AIX_VERSION
2061 /* Run dependent module initializers before any constructors in this
2063 switch (is_ctor_dtor (name
))
2073 while (name
[pos
] == '_')
2075 pos
+= 10; /* strlen ("GLOBAL__X_") */
2077 /* Extract init_p number from ctor/dtor name. */
2078 pri
= atoi (name
+ pos
);
2079 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
2082 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2083 ctors will be run from right to left, dtors from left to right. */
2086 sort_ids (struct head
*head_ptr
)
2088 /* id holds the current element to insert. id_next holds the next
2089 element to insert. id_ptr iterates through the already sorted elements
2090 looking for the place to insert id. */
2091 struct id
*id
, *id_next
, **id_ptr
;
2093 id
= head_ptr
->first
;
2095 /* We don't have any sorted elements yet. */
2096 head_ptr
->first
= NULL
;
2098 for (; id
; id
= id_next
)
2101 id
->sequence
= extract_init_priority (id
->name
);
2103 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
2105 /* If the sequence numbers are the same, we put the id from the
2106 file later on the command line later in the list. */
2107 || id
->sequence
> (*id_ptr
)->sequence
2108 /* Hack: do lexical compare, too.
2109 || (id->sequence == (*id_ptr)->sequence
2110 && strcmp (id->name, (*id_ptr)->name) > 0) */
2119 /* Now set the sequence numbers properly so write_c_file works. */
2120 for (id
= head_ptr
->first
; id
; id
= id
->next
)
2121 id
->sequence
= ++sequence_number
;
2124 /* Write: `prefix', the names on list LIST, `suffix'. */
2127 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
2131 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
2136 #ifdef COLLECT_EXPORT_LIST
2137 /* This function is really used only on AIX, but may be useful. */
2140 is_in_list (const char *prefix
, struct id
*list
)
2144 if (!strcmp (prefix
, list
->name
)) return 1;
2150 #endif /* COLLECT_EXPORT_LIST */
2152 /* Added for debugging purpose. */
2153 #ifdef COLLECT_EXPORT_LIST
2155 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
2159 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
2167 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2171 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2178 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2182 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2183 prefix
, list
->sequence
, list
->name
);
2188 /* Write out the constructor and destructor tables statically (for a shared
2189 object), along with the functions to execute them. */
2192 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2196 int frames
= (frame_tables
.number
> 0);
2198 /* Figure out name of output_file, stripping off .so version. */
2199 q
= p
= lbasename (output_file
);
2211 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2213 q
+= strlen (SHLIB_SUFFIX
);
2220 /* q points to null at end of the string (or . of the .so version) */
2221 prefix
= XNEWVEC (char, q
- p
+ 1);
2222 strncpy (prefix
, p
, q
- p
);
2224 for (r
= prefix
; *r
; r
++)
2225 if (!ISALNUM ((unsigned char)*r
))
2228 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2229 output_file
, prefix
);
2231 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2232 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2233 #ifdef TARGET_AIX_VERSION
2234 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2235 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2240 /* Write the tables as C code. */
2242 /* This count variable is used to prevent multiple calls to the
2243 constructors/destructors.
2244 This guard against multiple calls is important on AIX as the initfini
2245 functions are deliberately invoked multiple times as part of the
2246 mechanisms GCC uses to order constructors across different dependent
2247 shared libraries (see config/rs6000/aix.h).
2249 fprintf (stream
, "static int count;\n");
2250 fprintf (stream
, "typedef void entry_pt();\n");
2251 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2255 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2257 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2258 write_list (stream
, "\t\t&", frame_tables
.first
);
2259 fprintf (stream
, "\t0\n};\n");
2261 /* This must match what's in frame.h. */
2262 fprintf (stream
, "struct object {\n");
2263 fprintf (stream
, " void *pc_begin;\n");
2264 fprintf (stream
, " void *pc_end;\n");
2265 fprintf (stream
, " void *fde_begin;\n");
2266 fprintf (stream
, " void *fde_array;\n");
2267 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2268 fprintf (stream
, " struct object *next;\n");
2269 fprintf (stream
, "};\n");
2271 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2272 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2274 fprintf (stream
, "static void reg_frame () {\n");
2275 fprintf (stream
, "\tstatic struct object ob;\n");
2276 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2277 fprintf (stream
, "\t}\n");
2279 fprintf (stream
, "static void dereg_frame () {\n");
2280 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2281 fprintf (stream
, "\t}\n");
2284 fprintf (stream
, "void %s() {\n", initname
);
2285 if (constructors
.number
> 0 || frames
)
2287 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2288 write_list (stream
, "\t\t", constructors
.first
);
2290 fprintf (stream
, "\treg_frame,\n");
2291 fprintf (stream
, "\t};\n");
2292 fprintf (stream
, "\tentry_pt **p;\n");
2293 fprintf (stream
, "\tif (count++ != 0) return;\n");
2294 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2295 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2298 fprintf (stream
, "\t++count;\n");
2299 fprintf (stream
, "}\n");
2300 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2301 fprintf (stream
, "void %s() {\n", fininame
);
2302 if (destructors
.number
> 0 || frames
)
2304 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2305 write_list (stream
, "\t\t", destructors
.first
);
2307 fprintf (stream
, "\tdereg_frame,\n");
2308 fprintf (stream
, "\t};\n");
2309 fprintf (stream
, "\tentry_pt **p;\n");
2310 fprintf (stream
, "\tif (--count != 0) return;\n");
2311 fprintf (stream
, "\tp = dtors;\n");
2312 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2313 destructors
.number
+ frames
);
2315 fprintf (stream
, "}\n");
2319 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2320 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2324 /* Write the constructor/destructor tables. */
2326 #ifndef LD_INIT_SWITCH
2328 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2330 /* Write the tables as C code. */
2332 int frames
= (frame_tables
.number
> 0);
2334 fprintf (stream
, "typedef void entry_pt();\n\n");
2336 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2340 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2342 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2343 write_list (stream
, "\t\t&", frame_tables
.first
);
2344 fprintf (stream
, "\t0\n};\n");
2346 /* This must match what's in frame.h. */
2347 fprintf (stream
, "struct object {\n");
2348 fprintf (stream
, " void *pc_begin;\n");
2349 fprintf (stream
, " void *pc_end;\n");
2350 fprintf (stream
, " void *fde_begin;\n");
2351 fprintf (stream
, " void *fde_array;\n");
2352 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2353 fprintf (stream
, " struct object *next;\n");
2354 fprintf (stream
, "};\n");
2356 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2357 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2359 fprintf (stream
, "static void reg_frame () {\n");
2360 fprintf (stream
, "\tstatic struct object ob;\n");
2361 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2362 fprintf (stream
, "\t}\n");
2364 fprintf (stream
, "static void dereg_frame () {\n");
2365 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2366 fprintf (stream
, "\t}\n");
2369 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2370 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2371 write_list (stream
, "\t", constructors
.first
);
2373 fprintf (stream
, "\treg_frame,\n");
2374 fprintf (stream
, "\t0\n};\n\n");
2376 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2378 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2379 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2380 write_list (stream
, "\t", destructors
.first
);
2382 fprintf (stream
, "\tdereg_frame,\n");
2383 fprintf (stream
, "\t0\n};\n\n");
2385 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2386 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2388 #endif /* ! LD_INIT_SWITCH */
2391 write_c_file (FILE *stream
, const char *name
)
2393 #ifndef LD_INIT_SWITCH
2395 write_c_file_glob (stream
, name
);
2398 write_c_file_stat (stream
, name
);
2401 #ifdef COLLECT_EXPORT_LIST
2403 write_aix_file (FILE *stream
, struct id
*list
)
2405 for (; list
; list
= list
->next
)
2407 fputs (list
->name
, stream
);
2408 putc ('\n', stream
);
2413 #ifdef OBJECT_FORMAT_NONE
2415 /* Check to make sure the file is an LTO object file. */
2418 maybe_lto_object_file (const char *prog_name
)
2421 unsigned char buf
[4];
2424 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2425 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2426 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2427 static unsigned char machomagic
[4][4] = {
2428 { 0xcf, 0xfa, 0xed, 0xfe },
2429 { 0xce, 0xfa, 0xed, 0xfe },
2430 { 0xfe, 0xed, 0xfa, 0xcf },
2431 { 0xfe, 0xed, 0xfa, 0xce }
2434 f
= fopen (prog_name
, "rb");
2437 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2441 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2442 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2443 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2445 for (i
= 0; i
< 4; i
++)
2446 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2452 /* Generic version to scan the name list of the loaded program for
2453 the symbols g++ uses for static constructors and destructors. */
2456 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2459 void (*int_handler
) (int);
2461 void (*quit_handler
) (int);
2463 char *real_nm_argv
[4];
2464 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2466 struct pex_obj
*pex
;
2473 if (which_pass
== PASS_SECOND
)
2476 /* LTO objects must be in a known format. This check prevents
2477 us from accepting an archive containing LTO objects, which
2478 gcc cannot currently handle. */
2479 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2482 /* If we do not have an `nm', complain. */
2483 if (nm_file_name
== 0)
2484 fatal_error ("cannot find 'nm'");
2486 nm_argv
[argc
++] = nm_file_name
;
2487 if (NM_FLAGS
[0] != '\0')
2488 nm_argv
[argc
++] = NM_FLAGS
;
2490 nm_argv
[argc
++] = prog_name
;
2491 nm_argv
[argc
++] = (char *) 0;
2493 /* Trace if needed. */
2496 const char **p_argv
;
2499 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2500 fprintf (stderr
, " %s", str
);
2502 fprintf (stderr
, "\n");
2508 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2510 fatal_error ("pex_init failed: %m");
2512 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2519 fatal_error ("%s: %m", _(errmsg
));
2522 fatal_error (errmsg
);
2525 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2527 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2530 inf
= pex_read_output (pex
, 0);
2532 fatal_error ("can't open nm output: %m");
2536 if (which_pass
== PASS_LTOINFO
)
2537 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2539 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2542 /* Read each line of nm output. */
2543 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2549 fprintf (stderr
, "\t%s\n", buf
);
2551 if (which_pass
== PASS_LTOINFO
)
2556 /* Look for the LTO info marker symbol, and add filename to
2557 the LTO objects list if found. */
2558 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2559 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2560 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2561 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2563 add_lto_object (<o_objects
, prog_name
);
2565 /* We need to read all the input, so we can't just
2566 return here. But we can avoid useless work. */
2575 /* If it contains a constructor or destructor name, add the name
2576 to the appropriate list unless this is a kind of symbol we're
2577 not supposed to even consider. */
2579 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2580 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2587 /* Find the end of the symbol name.
2588 Do not include `|', because Encore nm can tack that on the end. */
2589 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2596 switch (is_ctor_dtor (name
))
2599 if (! (filter
& SCAN_CTOR
))
2601 if (which_pass
!= PASS_LIB
)
2602 add_to_list (&constructors
, name
);
2606 if (! (filter
& SCAN_DTOR
))
2608 if (which_pass
!= PASS_LIB
)
2609 add_to_list (&destructors
, name
);
2613 if (! (filter
& SCAN_INIT
))
2615 if (which_pass
!= PASS_LIB
)
2616 fatal_error ("init function found in object %s", prog_name
);
2617 #ifndef LD_INIT_SWITCH
2618 add_to_list (&constructors
, name
);
2623 if (! (filter
& SCAN_FINI
))
2625 if (which_pass
!= PASS_LIB
)
2626 fatal_error ("fini function found in object %s", prog_name
);
2627 #ifndef LD_FINI_SWITCH
2628 add_to_list (&destructors
, name
);
2633 if (! (filter
& SCAN_DWEH
))
2635 if (which_pass
!= PASS_LIB
)
2636 add_to_list (&frame_tables
, name
);
2639 default: /* not a constructor or destructor */
2645 fprintf (stderr
, "\n");
2647 do_wait (nm_file_name
, pex
);
2649 signal (SIGINT
, int_handler
);
2651 signal (SIGQUIT
, quit_handler
);
2657 /* Use the List Dynamic Dependencies program to find shared libraries that
2658 the output file depends upon and their initialization/finalization
2659 routines, if any. */
2662 scan_libraries (const char *prog_name
)
2664 static struct head libraries
; /* list of shared libraries found */
2666 void (*int_handler
) (int);
2668 void (*quit_handler
) (int);
2670 char *real_ldd_argv
[4];
2671 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2673 struct pex_obj
*pex
;
2679 /* If we do not have an `ldd', complain. */
2680 if (ldd_file_name
== 0)
2682 error ("cannot find 'ldd'");
2686 ldd_argv
[argc
++] = ldd_file_name
;
2687 ldd_argv
[argc
++] = prog_name
;
2688 ldd_argv
[argc
++] = (char *) 0;
2690 /* Trace if needed. */
2693 const char **p_argv
;
2696 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2697 fprintf (stderr
, " %s", str
);
2699 fprintf (stderr
, "\n");
2705 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2707 fatal_error ("pex_init failed: %m");
2709 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2715 fatal_error ("%s: %m", _(errmsg
));
2718 fatal_error (errmsg
);
2721 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2723 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2726 inf
= pex_read_output (pex
, 0);
2728 fatal_error ("can't open ldd output: %m");
2731 notice ("\nldd output with constructors/destructors.\n");
2733 /* Read each line of ldd output. */
2734 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2737 char *name
, *end
, *p
= buf
;
2739 /* Extract names of libraries and add to list. */
2740 PARSE_LDD_OUTPUT (p
);
2745 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2746 fatal_error ("dynamic dependency %s not found", buf
);
2748 /* Find the end of the symbol name. */
2750 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2755 if (access (name
, R_OK
) == 0)
2756 add_to_list (&libraries
, name
);
2758 fatal_error ("unable to open dynamic dependency '%s'", buf
);
2761 fprintf (stderr
, "\t%s\n", buf
);
2764 fprintf (stderr
, "\n");
2766 do_wait (ldd_file_name
, pex
);
2768 signal (SIGINT
, int_handler
);
2770 signal (SIGQUIT
, quit_handler
);
2773 /* Now iterate through the library list adding their symbols to
2775 for (list
= libraries
.first
; list
; list
= list
->next
)
2776 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2779 #endif /* LDD_SUFFIX */
2781 #endif /* OBJECT_FORMAT_NONE */
2785 * COFF specific stuff.
2788 #ifdef OBJECT_FORMAT_COFF
2790 #if defined (EXTENDED_COFF)
2792 # define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax)
2793 # define GCC_SYMENT SYMR
2794 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2795 # define GCC_SYMINC(X) (1)
2796 # define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
2797 # define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
2801 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2802 # define GCC_SYMENT SYMENT
2803 # if defined (C_WEAKEXT)
2804 # define GCC_OK_SYMBOL(X) \
2805 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2806 ((X).n_scnum > N_UNDEF) && \
2808 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2809 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2810 # define GCC_UNDEF_SYMBOL(X) \
2811 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2812 ((X).n_scnum == N_UNDEF))
2814 # define GCC_OK_SYMBOL(X) \
2815 (((X).n_sclass == C_EXT) && \
2816 ((X).n_scnum > N_UNDEF) && \
2818 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2819 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2820 # define GCC_UNDEF_SYMBOL(X) \
2821 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2823 # define GCC_SYMINC(X) ((X).n_numaux+1)
2824 # define GCC_SYMZERO(X) 0
2826 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2827 #if TARGET_AIX_VERSION >= 51
2828 # define GCC_CHECK_HDR(X) \
2829 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2830 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2831 && !(HEADER (X).f_flags & F_LOADONLY))
2833 # define GCC_CHECK_HDR(X) \
2834 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2835 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2836 && !(HEADER (X).f_flags & F_LOADONLY))
2841 #ifdef COLLECT_EXPORT_LIST
2842 /* Array of standard AIX libraries which should not
2843 be scanned for ctors/dtors. */
2844 static const char *const aix_std_libs
[] = {
2852 "/usr/lib/libc_r.a",
2853 "/usr/lib/libm_r.a",
2854 "/usr/lib/threads/libc.a",
2855 "/usr/ccs/lib/libc.a",
2856 "/usr/ccs/lib/libm.a",
2857 "/usr/ccs/lib/libc_r.a",
2858 "/usr/ccs/lib/libm_r.a",
2862 /* This function checks the filename and returns 1
2863 if this name matches the location of a standard AIX library. */
2864 static int ignore_library (const char *);
2866 ignore_library (const char *name
)
2868 const char *const *p
;
2871 if (target_system_root
[0] != '\0')
2873 length
= strlen (target_system_root
);
2874 if (strncmp (name
, target_system_root
, length
) != 0)
2878 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2879 if (strcmp (name
, *p
) == 0)
2883 #endif /* COLLECT_EXPORT_LIST */
2885 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2886 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2889 /* COFF version to scan the name list of the loaded program for
2890 the symbols g++ uses for static constructors and destructors. */
2893 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2896 LDFILE
*ldptr
= NULL
;
2897 int sym_index
, sym_count
;
2900 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2903 #ifdef COLLECT_EXPORT_LIST
2904 /* We do not need scanning for some standard C libraries. */
2905 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2908 /* On AIX we have a loop, because there is not much difference
2909 between an object and an archive. This trick allows us to
2910 eliminate scan_libraries() function. */
2914 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2915 non-const char * filename parameter, even though it will not
2916 modify that string. So we must cast away const-ness here,
2917 using CONST_CAST to prevent complaints from -Wcast-qual. */
2918 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2920 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2921 fatal_error ("%s: not a COFF file", prog_name
);
2923 if (GCC_CHECK_HDR (ldptr
))
2925 sym_count
= GCC_SYMBOLS (ldptr
);
2926 sym_index
= GCC_SYMZERO (ldptr
);
2928 #ifdef COLLECT_EXPORT_LIST
2929 /* Is current archive member a shared object? */
2930 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2933 while (sym_index
< sym_count
)
2937 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2939 sym_index
+= GCC_SYMINC (symbol
);
2941 if (GCC_OK_SYMBOL (symbol
))
2945 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2946 continue; /* Should never happen. */
2948 #ifdef XCOFF_DEBUGGING_INFO
2949 /* All AIX function names have a duplicate entry
2950 beginning with a dot. */
2955 switch (is_ctor_dtor (name
))
2957 #if TARGET_AIX_VERSION
2958 /* Add AIX shared library initalisers/finalisers
2959 to the constructors/destructors list of the
2962 if (! (filter
& SCAN_CTOR
))
2964 if (is_shared
&& !aixlazy_flag
)
2965 add_to_list (&constructors
, name
);
2969 if (! (filter
& SCAN_DTOR
))
2971 if (is_shared
&& !aixlazy_flag
)
2972 add_to_list (&destructors
, name
);
2977 if (! (filter
& SCAN_CTOR
))
2980 add_to_list (&constructors
, name
);
2981 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2982 if (which_pass
== PASS_OBJ
)
2983 add_to_list (&exports
, name
);
2988 if (! (filter
& SCAN_DTOR
))
2991 add_to_list (&destructors
, name
);
2992 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2993 if (which_pass
== PASS_OBJ
)
2994 add_to_list (&exports
, name
);
2998 #ifdef COLLECT_EXPORT_LIST
3000 if (! (filter
& SCAN_INIT
))
3002 #ifndef LD_INIT_SWITCH
3004 add_to_list (&constructors
, name
);
3009 if (! (filter
& SCAN_FINI
))
3011 #ifndef LD_INIT_SWITCH
3013 add_to_list (&destructors
, name
);
3019 if (! (filter
& SCAN_DWEH
))
3022 add_to_list (&frame_tables
, name
);
3023 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3024 if (which_pass
== PASS_OBJ
)
3025 add_to_list (&exports
, name
);
3029 default: /* not a constructor or destructor */
3030 #ifdef COLLECT_EXPORT_LIST
3031 /* Explicitly export all global symbols when
3032 building a shared object on AIX, but do not
3033 re-export symbols from another shared object
3034 and do not export symbols if the user
3035 provides an explicit export list. */
3036 if (shared_obj
&& !is_shared
3037 && which_pass
== PASS_OBJ
&& !export_flag
)
3038 add_to_list (&exports
, name
);
3044 #if !defined(EXTENDED_COFF)
3045 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
3046 symbol
.n_scnum
, symbol
.n_sclass
,
3047 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
3051 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3052 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
3057 #ifdef COLLECT_EXPORT_LIST
3060 /* If archive contains both 32-bit and 64-bit objects,
3061 we want to skip objects in other mode so mismatch normal. */
3063 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
3064 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
3070 fatal_error ("%s: cannot open as COFF file", prog_name
);
3072 #ifdef COLLECT_EXPORT_LIST
3073 /* On AIX loop continues while there are more members in archive. */
3075 while (ldclose (ldptr
) == FAILURE
);
3077 /* Otherwise we simply close ldptr. */
3078 (void) ldclose (ldptr
);
3081 #endif /* OBJECT_FORMAT_COFF */
3083 #ifdef COLLECT_EXPORT_LIST
3084 /* Given a library name without "lib" prefix, this function
3085 returns a full library name including a path. */
3087 resolve_lib_name (const char *name
)
3091 /* Library extensions for AIX dynamic linking. */
3092 const char * const libexts
[2] = {"a", "so"};
3094 for (i
= 0; libpaths
[i
]; i
++)
3095 if (libpaths
[i
]->max_len
> l
)
3096 l
= libpaths
[i
]->max_len
;
3098 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
3100 for (i
= 0; libpaths
[i
]; i
++)
3102 struct prefix_list
*list
= libpaths
[i
]->plist
;
3103 for (; list
; list
= list
->next
)
3105 /* The following lines are needed because path_prefix list
3106 may contain directories both with trailing DIR_SEPARATOR and
3109 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
3111 for (j
= 0; j
< 2; j
++)
3113 sprintf (lib_buf
, "%s%slib%s.%s",
3114 list
->prefix
, p
, name
,
3115 libexts
[(j
+ aixrtl_flag
) % 2]);
3116 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
3117 if (file_exists (lib_buf
))
3119 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
3126 fprintf (stderr
, "not found\n");
3128 fatal_error ("library lib%s not found", name
);
3131 #endif /* COLLECT_EXPORT_LIST */
3133 #ifdef COLLECT_RUN_DSYMUTIL
3134 static int flag_dsym
= false;
3135 static int flag_idsym
= false;
3138 process_args (int *argcp
, char **argv
) {
3141 for (i
=0; i
<argc
; ++i
)
3143 if (strcmp (argv
[i
], "-dsym") == 0)
3146 /* Remove the flag, as we handle all processing for it. */
3149 argv
[j
] = argv
[j
+1];
3154 else if (strcmp (argv
[i
], "-idsym") == 0)
3157 /* Remove the flag, as we handle all processing for it. */
3160 argv
[j
] = argv
[j
+1];
3169 do_dsymutil (const char *output_file
) {
3170 const char *dsymutil
= DSYMUTIL
+ 1;
3171 struct pex_obj
*pex
;
3172 char **real_argv
= XCNEWVEC (char *, 3);
3173 const char ** argv
= CONST_CAST2 (const char **, char **,
3177 argv
[1] = output_file
;
3178 argv
[2] = (char *) 0;
3180 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
, PEX_LAST
| PEX_SEARCH
);
3181 do_wait (dsymutil
, pex
);
3185 post_ld_pass (bool temp_file
) {
3186 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3189 do_dsymutil (output_file
);
3193 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3194 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }