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 "collect-utils.h"
47 #include "diagnostic.h"
53 /* On certain systems, we have code that works by scanning the object file
54 directly. But this code uses system-specific header files and library
55 functions, so turn it off in a cross-compiler. Likewise, the names of
56 the utilities are not correct for a cross-compiler; we have to hope that
57 cross-versions are in the proper directories. */
59 #ifdef CROSS_DIRECTORY_STRUCTURE
60 #ifndef CROSS_AIX_SUPPORT
61 #undef OBJECT_FORMAT_COFF
64 #undef REAL_LD_FILE_NAME
65 #undef REAL_NM_FILE_NAME
66 #undef REAL_STRIP_FILE_NAME
69 /* If we cannot use a special method, use the ordinary one:
70 run nm to find what symbols are present.
71 In a cross-compiler, this means you need a cross nm,
72 but that is not quite as unpleasant as special headers. */
74 #if !defined (OBJECT_FORMAT_COFF)
75 #define OBJECT_FORMAT_NONE
78 #ifdef OBJECT_FORMAT_COFF
80 #ifndef CROSS_DIRECTORY_STRUCTURE
88 /* Many versions of ldfcn.h define these. */
97 /* Some systems have an ISCOFF macro, but others do not. In some cases
98 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
99 that either do not have an ISCOFF macro in /usr/include or for those
100 where it is wrong. */
103 #define MY_ISCOFF(X) ISCOFF (X)
106 #endif /* OBJECT_FORMAT_COFF */
108 #ifdef OBJECT_FORMAT_NONE
110 /* Default flags to pass to nm. */
112 #define NM_FLAGS "-n"
115 #endif /* OBJECT_FORMAT_NONE */
117 /* Some systems use __main in a way incompatible with its use in gcc, in these
118 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
119 give the same symbol without quotes for an alternative entry point. */
121 #define NAME__MAIN "__main"
124 /* This must match tree.h. */
125 #define DEFAULT_INIT_PRIORITY 65535
127 #ifndef COLLECT_SHARED_INIT_FUNC
128 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
129 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
131 #ifndef COLLECT_SHARED_FINI_FUNC
132 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
133 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
137 #define SCAN_LIBRARIES
141 #define SHLIB_SUFFIX ".so"
145 int do_collecting
= 1;
147 int do_collecting
= 0;
150 /* Cook up an always defined indication of whether we proceed the
151 "EXPORT_LIST" way. */
153 #ifdef COLLECT_EXPORT_LIST
154 #define DO_COLLECT_EXPORT_LIST 1
156 #define DO_COLLECT_EXPORT_LIST 0
159 /* Nonzero if we should suppress the automatic demangling of identifiers
160 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
163 /* Linked lists of constructor and destructor names. */
179 static int rflag
; /* true if -r */
180 static int strip_flag
; /* true if -s */
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag
; /* true if -bE */
183 static int aix64_flag
; /* true if -b64 */
184 static int aixrtl_flag
; /* true if -brtl */
185 static int aixlazy_flag
; /* true if -blazy */
189 LTO_MODE_NONE
, /* Not doing LTO. */
190 LTO_MODE_LTO
, /* Normal LTO. */
191 LTO_MODE_WHOPR
/* WHOPR. */
194 /* Current LTO mode. */
196 static enum lto_mode_d lto_mode
= LTO_MODE_WHOPR
;
198 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
201 bool helpflag
; /* true if --help */
203 static int shared_obj
; /* true if -shared */
205 static const char *c_file
; /* <xxx>.c for constructor/destructor list. */
206 static const char *o_file
; /* <xxx>.o for constructor/destructor list. */
207 #ifdef COLLECT_EXPORT_LIST
208 static const char *export_file
; /* <xxx>.x for AIX export list. */
210 static char **lto_o_files
; /* Output files for LTO. */
211 const char *ldout
; /* File for ld stdout. */
212 const char *lderrout
; /* File for ld stderr. */
213 static const char *output_file
; /* Output file for ld. */
214 static const char *nm_file_name
; /* pathname of nm */
216 static const char *ldd_file_name
; /* pathname of ldd (or equivalent) */
218 static const char *strip_file_name
; /* pathname of strip */
219 const char *c_file_name
; /* pathname of gcc */
220 static char *initname
, *fininame
; /* names of init and fini funcs */
223 #ifdef TARGET_AIX_VERSION
224 static char *aix_shared_initname
;
225 static char *aix_shared_fininame
; /* init/fini names as per the scheme
226 described in config/rs6000/aix.h */
229 static struct head constructors
; /* list of constructors found */
230 static struct head destructors
; /* list of destructors found */
231 #ifdef COLLECT_EXPORT_LIST
232 static struct head exports
; /* list of exported symbols */
234 static struct head frame_tables
; /* list of frame unwind info tables */
236 bool at_file_supplied
; /* Whether to use @file arguments */
238 struct obstack temporary_obstack
;
239 char * temporary_firstobj
;
241 /* A string that must be prepended to a target OS path in order to find
242 it on the host system. */
243 #ifdef TARGET_SYSTEM_ROOT
244 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
246 static const char *target_system_root
= "";
249 /* Whether we may unlink the output file, which should be set as soon as we
250 know we have successfully produced it. This is typically useful to prevent
251 blindly attempting to unlink a read-only output that the target linker
252 would leave untouched. */
253 bool may_unlink_output_file
= false;
255 #ifdef COLLECT_EXPORT_LIST
256 /* Lists to keep libraries to be scanned for global constructors/destructors. */
257 static struct head libs
; /* list of libraries */
258 static struct path_prefix cmdline_lib_dirs
; /* directories specified with -L */
259 static struct path_prefix libpath_lib_dirs
; /* directories in LIBPATH */
260 static struct path_prefix
*libpaths
[3] = {&cmdline_lib_dirs
,
261 &libpath_lib_dirs
, NULL
};
264 /* List of names of object files containing LTO information.
265 These are a subset of the object file names appearing on the
266 command line, and must be identical, in the sense of pointer
267 equality, with the names passed to maybe_run_lto_and_relink(). */
271 const char *name
; /* Name of object file. */
272 struct lto_object
*next
; /* Next in linked list. */
275 struct lto_object_list
277 struct lto_object
*first
; /* First list element. */
278 struct lto_object
*last
; /* Last list element. */
281 static struct lto_object_list lto_objects
;
283 /* Special kinds of symbols that a name may denote. */
286 SYM_REGULAR
= 0, /* nothing special */
288 SYM_CTOR
= 1, /* constructor */
289 SYM_DTOR
= 2, /* destructor */
290 SYM_INIT
= 3, /* shared object routine that calls all the ctors */
291 SYM_FINI
= 4, /* shared object routine that calls all the dtors */
292 SYM_DWEH
= 5, /* DWARF exception handling table */
297 const char tool_name
[] = "collect2";
299 static symkind
is_ctor_dtor (const char *);
301 static void handler (int);
302 static void maybe_unlink_list (char **);
303 static void add_to_list (struct head
*, const char *);
304 static int extract_init_priority (const char *);
305 static void sort_ids (struct head
*);
306 static void write_list (FILE *, const char *, struct id
*);
307 #ifdef COLLECT_EXPORT_LIST
308 static void dump_list (FILE *, const char *, struct id
*);
311 static void dump_prefix_list (FILE *, const char *, struct prefix_list
*);
313 static void write_list_with_asm (FILE *, const char *, struct id
*);
314 static void write_c_file (FILE *, const char *);
315 static void write_c_file_stat (FILE *, const char *);
316 #ifndef LD_INIT_SWITCH
317 static void write_c_file_glob (FILE *, const char *);
319 #ifdef SCAN_LIBRARIES
320 static void scan_libraries (const char *);
322 #ifdef COLLECT_EXPORT_LIST
324 static int is_in_list (const char *, struct id
*);
326 static void write_aix_file (FILE *, struct id
*);
327 static char *resolve_lib_name (const char *);
329 static char *extract_string (const char **);
330 static void post_ld_pass (bool);
331 static void process_args (int *argcp
, char **argv
);
333 /* Enumerations describing which pass this is for scanning the
337 PASS_FIRST
, /* without constructors */
338 PASS_OBJ
, /* individual objects */
339 PASS_LIB
, /* looking for shared libraries */
340 PASS_SECOND
, /* with constructors linked in */
341 PASS_LTOINFO
/* looking for objects with LTO info */
344 /* ... and which kinds of symbols are to be considered. */
346 enum scanfilter_masks
{
349 SCAN_CTOR
= 1 << SYM_CTOR
,
350 SCAN_DTOR
= 1 << SYM_DTOR
,
351 SCAN_INIT
= 1 << SYM_INIT
,
352 SCAN_FINI
= 1 << SYM_FINI
,
353 SCAN_DWEH
= 1 << SYM_DWEH
,
354 SCAN_AIXI
= 1 << SYM_AIXI
,
355 SCAN_AIXD
= 1 << SYM_AIXD
,
359 /* This type is used for parameters and variables which hold
360 combinations of the flags in enum scanfilter_masks. */
361 typedef int scanfilter
;
363 /* Scan the name list of the loaded program for the symbols g++ uses for
364 static constructors and destructors.
366 The SCANPASS argument tells which collect processing pass this is for and
367 the SCANFILTER argument tells which kinds of symbols to consider in this
368 pass. Symbols of a special kind not in the filter mask are considered as
371 The constructor table begins at __CTOR_LIST__ and contains a count of the
372 number of pointers (or -1 if the constructors are built in a separate
373 section by the linker), followed by the pointers to the constructor
374 functions, terminated with a null pointer. The destructor table has the
375 same format, and begins at __DTOR_LIST__. */
377 static void scan_prog_file (const char *, scanpass
, scanfilter
);
380 /* Delete tempfiles and exit function. */
383 tool_cleanup (bool from_signal
)
385 if (c_file
!= 0 && c_file
[0])
386 maybe_unlink (c_file
);
388 if (o_file
!= 0 && o_file
[0])
389 maybe_unlink (o_file
);
391 #ifdef COLLECT_EXPORT_LIST
392 if (export_file
!= 0 && export_file
[0])
393 maybe_unlink (export_file
);
397 maybe_unlink_list (lto_o_files
);
399 if (ldout
!= 0 && ldout
[0])
402 dump_ld_file (ldout
, stdout
);
403 maybe_unlink (ldout
);
406 if (lderrout
!= 0 && lderrout
[0])
409 dump_ld_file (lderrout
, stderr
);
410 maybe_unlink (lderrout
);
415 collect_atexit (void)
417 utils_cleanup (false);
425 signal (signo
, SIG_DFL
);
429 /* Notify user of a non-error, without translating the format string. */
431 notice_translated (const char *cmsgid
, ...)
435 va_start (ap
, cmsgid
);
436 vfprintf (stderr
, cmsgid
, ap
);
441 file_exists (const char *name
)
443 return access (name
, R_OK
) == 0;
446 /* Parse a reasonable subset of shell quoting syntax. */
449 extract_string (const char **pp
)
462 obstack_1grow (&temporary_obstack
, c
);
463 else if (! inside
&& c
== ' ')
465 else if (! inside
&& c
== '\\')
470 obstack_1grow (&temporary_obstack
, c
);
473 obstack_1grow (&temporary_obstack
, '\0');
475 return XOBFINISH (&temporary_obstack
, char *);
479 dump_ld_file (const char *name
, FILE *to
)
481 FILE *stream
= fopen (name
, "r");
488 while (c
= getc (stream
),
489 c
!= EOF
&& (ISIDNUM (c
) || c
== '$' || c
== '.'))
490 obstack_1grow (&temporary_obstack
, c
);
491 if (obstack_object_size (&temporary_obstack
) > 0)
493 const char *word
, *p
;
495 obstack_1grow (&temporary_obstack
, '\0');
496 word
= XOBFINISH (&temporary_obstack
, const char *);
499 ++word
, putc ('.', to
);
501 if (!strncmp (p
, USER_LABEL_PREFIX
, strlen (USER_LABEL_PREFIX
)))
502 p
+= strlen (USER_LABEL_PREFIX
);
504 #ifdef HAVE_LD_DEMANGLE
510 result
= cplus_demangle (p
, DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
);
518 diff
= strlen (word
) - strlen (result
);
519 while (diff
> 0 && c
== ' ')
520 --diff
, putc (' ', to
);
521 if (diff
< 0 && c
== ' ')
523 while (diff
< 0 && c
== ' ')
524 ++diff
, c
= getc (stream
);
527 /* Make sure we output at least one space, or
528 the demangled symbol name will run into
529 whatever text follows. */
540 obstack_free (&temporary_obstack
, temporary_firstobj
);
549 /* Return the kind of symbol denoted by name S. */
552 is_ctor_dtor (const char *s
)
554 struct names
{ const char *const name
; const int len
; symkind ret
;
555 const int two_underscores
; };
557 const struct names
*p
;
559 const char *orig_s
= s
;
561 static const struct names special
[] = {
562 #ifndef NO_DOLLAR_IN_LABEL
563 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR
, 0 },
564 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR
, 0 },
566 #ifndef NO_DOT_IN_LABEL
567 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR
, 0 },
568 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR
, 0 },
569 #endif /* NO_DOT_IN_LABEL */
570 #endif /* NO_DOLLAR_IN_LABEL */
571 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR
, 0 },
572 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR
, 0 },
573 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH
, 0 },
574 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT
, 0 },
575 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI
, 0 },
576 #ifdef TARGET_AIX_VERSION
577 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI
, 0 },
578 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD
, 0 },
580 { NULL
, 0, SYM_REGULAR
, 0 }
583 while ((ch
= *s
) == '_')
589 for (p
= &special
[0]; p
->len
> 0; p
++)
592 && (!p
->two_underscores
|| ((s
- orig_s
) >= 2))
593 && strncmp (s
, p
->name
, p
->len
) == 0)
601 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
602 and one from the PATH variable. */
604 static struct path_prefix cpath
, path
;
606 #ifdef CROSS_DIRECTORY_STRUCTURE
607 /* This is the name of the target machine. We use it to form the name
608 of the files to execute. */
610 static const char *const target_machine
= TARGET_MACHINE
;
613 /* Search for NAME using prefix list PPREFIX. We only look for executable
616 Return 0 if not found, otherwise return its name, allocated with malloc. */
618 #ifdef OBJECT_FORMAT_NONE
620 /* Add an entry for the object file NAME to object file list LIST.
621 New entries are added at the end of the list. The original pointer
622 value of NAME is preserved, i.e., no string copy is performed. */
625 add_lto_object (struct lto_object_list
*list
, const char *name
)
627 struct lto_object
*n
= XNEW (struct lto_object
);
632 list
->last
->next
= n
;
638 #endif /* OBJECT_FORMAT_NONE */
641 /* Perform a link-time recompilation and relink if any of the object
642 files contain LTO info. The linker command line LTO_LD_ARGV
643 represents the linker command that would produce a final executable
644 without the use of LTO. OBJECT_LST is a vector of object file names
645 appearing in LTO_LD_ARGV that are to be considered for link-time
646 recompilation, where OBJECT is a pointer to the last valid element.
647 (This awkward convention avoids an impedance mismatch with the
648 usage of similarly-named variables in main().) The elements of
649 OBJECT_LST must be identical, i.e., pointer equal, to the
650 corresponding arguments in LTO_LD_ARGV.
652 Upon entry, at least one linker run has been performed without the
653 use of any LTO info that might be present. Any recompilations
654 necessary for template instantiations have been performed, and
655 initializer/finalizer tables have been created if needed and
656 included in the linker command line LTO_LD_ARGV. If any of the
657 object files contain LTO info, we run the LTO back end on all such
658 files, and perform the final link with the LTO back end output
659 substituted for the LTO-optimized files. In some cases, a final
660 link with all link-time generated code has already been performed,
661 so there is no need to relink if no LTO info is found. In other
662 cases, our caller has not produced the final executable, and is
663 relying on us to perform the required link whether LTO info is
664 present or not. In that case, the FORCE argument should be true.
665 Note that the linker command line argument LTO_LD_ARGV passed into
666 this function may be modified in place. */
669 maybe_run_lto_and_relink (char **lto_ld_argv
, char **object_lst
,
670 const char **object
, bool force
)
672 const char **object_file
= CONST_CAST2 (const char **, char **, object_lst
);
674 int num_lto_c_args
= 1; /* Allow space for the terminating NULL. */
676 while (object_file
< object
)
678 /* If file contains LTO info, add it to the list of LTO objects. */
679 scan_prog_file (*object_file
++, PASS_LTOINFO
, SCAN_ALL
);
681 /* Increment the argument count by the number of object file arguments
682 we will add. An upper bound suffices, so just count all of the
683 object files regardless of whether they contain LTO info. */
687 if (lto_objects
.first
)
690 const char **lto_c_ptr
;
693 struct lto_object
*list
;
694 char *lto_wrapper
= getenv ("COLLECT_LTO_WRAPPER");
696 const char *prog
= "lto-wrapper";
697 int lto_ld_argv_size
= 0;
698 char **out_lto_ld_argv
;
699 int out_lto_ld_argv_size
;
703 fatal_error ("COLLECT_LTO_WRAPPER must be set");
707 /* There is at least one object file containing LTO info,
708 so we need to run the LTO back end and relink.
710 To do so we build updated ld arguments with first
711 LTO object replaced by all partitions and other LTO
714 lto_c_argv
= (char **) xcalloc (sizeof (char *), num_lto_c_args
);
715 lto_c_ptr
= CONST_CAST2 (const char **, char **, lto_c_argv
);
717 *lto_c_ptr
++ = lto_wrapper
;
719 /* Add LTO objects to the wrapper command line. */
720 for (list
= lto_objects
.first
; list
; list
= list
->next
)
721 *lto_c_ptr
++ = list
->name
;
725 /* Run the LTO back end. */
726 pex
= collect_execute (prog
, lto_c_argv
, NULL
, NULL
, PEX_SEARCH
,
734 stream
= pex_read_output (pex
, 0);
738 while ((c
= getc (stream
)) != EOF
)
740 obstack_1grow (&temporary_obstack
, c
);
745 lto_o_files
= XNEWVEC (char *, num_files
+ 1);
746 lto_o_files
[num_files
] = NULL
;
747 start
= XOBFINISH (&temporary_obstack
, char *);
748 for (i
= 0; i
< num_files
; ++i
)
755 lto_o_files
[i
] = xstrdup (start
);
760 obstack_free (&temporary_obstack
, temporary_firstobj
);
765 /* Compute memory needed for new LD arguments. At most number of original arguemtns
766 plus number of partitions. */
767 for (lto_ld_argv_size
= 0; lto_ld_argv
[lto_ld_argv_size
]; lto_ld_argv_size
++)
769 out_lto_ld_argv
= XCNEWVEC (char *, num_files
+ lto_ld_argv_size
+ 1);
770 out_lto_ld_argv_size
= 0;
772 /* After running the LTO back end, we will relink, substituting
773 the LTO output for the object files that we submitted to the
774 LTO. Here, we modify the linker command line for the relink. */
776 /* Copy all arguments until we find first LTO file. */
780 for (list
= lto_objects
.first
; list
; list
= list
->next
)
781 if (*p
== list
->name
) /* Note test for pointer equality! */
785 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
++;
788 /* Now insert all LTO partitions. */
789 lto_o_ptr
= lto_o_files
;
791 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *lto_o_ptr
++;
793 /* ... and copy the rest. */
796 for (list
= lto_objects
.first
; list
; list
= list
->next
)
797 if (*p
== list
->name
) /* Note test for pointer equality! */
800 out_lto_ld_argv
[out_lto_ld_argv_size
++] = *p
;
803 out_lto_ld_argv
[out_lto_ld_argv_size
++] = 0;
805 /* Run the linker again, this time replacing the object files
806 optimized by the LTO with the temporary file generated by the LTO. */
807 fork_execute ("ld", out_lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
811 maybe_unlink_list (lto_o_files
);
815 /* Our caller is relying on us to do the link
816 even though there is no LTO back end work to be done. */
817 fork_execute ("ld", lto_ld_argv
, HAVE_GNU_LD
&& at_file_supplied
);
818 post_ld_pass (false);
825 main (int argc
, char **argv
)
834 } selected_linker
= USE_DEFAULT_LD
;
835 static const char *const ld_suffixes
[USE_LD_MAX
] =
842 static const char *const real_ld_suffix
= "real-ld";
843 static const char *const collect_ld_suffix
= "collect-ld";
844 static const char *const nm_suffix
= "nm";
845 static const char *const gnm_suffix
= "gnm";
847 static const char *const ldd_suffix
= LDD_SUFFIX
;
849 static const char *const strip_suffix
= "strip";
850 static const char *const gstrip_suffix
= "gstrip";
852 const char *full_ld_suffixes
[USE_LD_MAX
];
853 #ifdef CROSS_DIRECTORY_STRUCTURE
854 /* If we look for a program in the compiler directories, we just use
855 the short name, since these directories are already system-specific.
856 But it we look for a program in the system directories, we need to
857 qualify the program name with the target machine. */
859 const char *const full_nm_suffix
=
860 concat (target_machine
, "-", nm_suffix
, NULL
);
861 const char *const full_gnm_suffix
=
862 concat (target_machine
, "-", gnm_suffix
, NULL
);
864 const char *const full_ldd_suffix
=
865 concat (target_machine
, "-", ldd_suffix
, NULL
);
867 const char *const full_strip_suffix
=
868 concat (target_machine
, "-", strip_suffix
, NULL
);
869 const char *const full_gstrip_suffix
=
870 concat (target_machine
, "-", gstrip_suffix
, NULL
);
873 const char *const full_ldd_suffix
= ldd_suffix
;
875 const char *const full_nm_suffix
= nm_suffix
;
876 const char *const full_gnm_suffix
= gnm_suffix
;
877 const char *const full_strip_suffix
= strip_suffix
;
878 const char *const full_gstrip_suffix
= gstrip_suffix
;
879 #endif /* CROSS_DIRECTORY_STRUCTURE */
883 #ifdef COLLECT_EXPORT_LIST
886 const char *ld_file_name
;
892 bool use_plugin
= false;
893 bool use_collect_ld
= false;
895 /* The kinds of symbols we will have to consider when scanning the
896 outcome of a first pass link. This is ALL to start with, then might
897 be adjusted before getting to the first pass link per se, typically on
898 AIX where we perform an early scan of objects and libraries to fetch
899 the list of global ctors/dtors and make sure they are not garbage
901 scanfilter ld1_filter
= SCAN_ALL
;
907 #ifdef TARGET_AIX_VERSION
908 int object_nbr
= argc
;
915 for (i
= 0; i
< USE_LD_MAX
; i
++)
917 #ifdef CROSS_DIRECTORY_STRUCTURE
918 = concat (target_machine
, "-", ld_suffixes
[i
], NULL
);
923 p
= argv
[0] + strlen (argv
[0]);
924 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
928 xmalloc_set_program_name (progname
);
931 expandargv (&argc
, &argv
);
932 if (argv
!= old_argv
)
933 at_file_supplied
= 1;
935 process_args (&argc
, argv
);
937 num_c_args
= argc
+ 9;
939 #ifndef HAVE_LD_DEMANGLE
940 no_demangle
= !! getenv ("COLLECT_NO_DEMANGLE");
942 /* Suppress demangling by the real linker, which may be broken. */
943 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
946 #if defined (COLLECT2_HOST_INITIALIZATION)
947 /* Perform system dependent initialization, if necessary. */
948 COLLECT2_HOST_INITIALIZATION
;
952 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
953 receive the signal. A different setting is inheritable */
954 signal (SIGCHLD
, SIG_DFL
);
957 if (atexit (collect_atexit
) != 0)
958 fatal_error ("atexit failed");
960 /* Unlock the stdio streams. */
961 unlock_std_streams ();
965 diagnostic_initialize (global_dc
, 0);
967 /* Do not invoke xcalloc before this point, since locale needs to be
968 set first, in case a diagnostic is issued. */
970 ld1_argv
= XCNEWVEC (char *, argc
+ 4);
971 ld1
= CONST_CAST2 (const char **, char **, ld1_argv
);
972 ld2_argv
= XCNEWVEC (char *, argc
+ 11);
973 ld2
= CONST_CAST2 (const char **, char **, ld2_argv
);
974 object_lst
= XCNEWVEC (char *, argc
);
975 object
= CONST_CAST2 (const char **, char **, object_lst
);
981 /* Parse command line early for instances of -debug. This allows
982 the debug flag to be set before functions like find_a_file()
983 are called. We also look for the -flto or -flto-partition=none flag to know
984 what LTO mode we are in. */
986 bool no_partition
= false;
988 for (i
= 1; argv
[i
] != NULL
; i
++)
990 if (! strcmp (argv
[i
], "-debug"))
992 else if (! strcmp (argv
[i
], "-flto-partition=none"))
994 else if (!strncmp (argv
[i
], "-fno-lto", 8))
995 lto_mode
= LTO_MODE_NONE
;
996 else if (! strcmp (argv
[i
], "-plugin"))
999 if (selected_linker
== USE_DEFAULT_LD
)
1000 selected_linker
= USE_PLUGIN_LD
;
1002 else if (strcmp (argv
[i
], "-fuse-ld=bfd") == 0)
1003 selected_linker
= USE_BFD_LD
;
1004 else if (strcmp (argv
[i
], "-fuse-ld=gold") == 0)
1005 selected_linker
= USE_GOLD_LD
;
1007 #ifdef COLLECT_EXPORT_LIST
1008 /* These flags are position independent, although their order
1009 is important - subsequent flags override earlier ones. */
1010 else if (strcmp (argv
[i
], "-b64") == 0)
1012 /* -bexport:filename always needs the :filename */
1013 else if (strncmp (argv
[i
], "-bE:", 4) == 0
1014 || strncmp (argv
[i
], "-bexport:", 9) == 0)
1016 else if (strcmp (argv
[i
], "-brtl") == 0
1017 || strcmp (argv
[i
], "-bsvr4") == 0
1018 || strcmp (argv
[i
], "-G") == 0)
1020 else if (strcmp (argv
[i
], "-bnortl") == 0)
1022 else if (strcmp (argv
[i
], "-blazy") == 0)
1027 find_file_set_debug (debug
);
1029 lto_mode
= LTO_MODE_NONE
;
1030 if (no_partition
&& lto_mode
== LTO_MODE_WHOPR
)
1031 lto_mode
= LTO_MODE_LTO
;
1034 #ifndef DEFAULT_A_OUT_NAME
1035 output_file
= "a.out";
1037 output_file
= DEFAULT_A_OUT_NAME
;
1040 obstack_begin (&temporary_obstack
, 0);
1041 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
1043 #ifndef HAVE_LD_DEMANGLE
1044 current_demangling_style
= auto_demangling
;
1046 p
= getenv ("COLLECT_GCC_OPTIONS");
1049 const char *q
= extract_string (&p
);
1050 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1053 obstack_free (&temporary_obstack
, temporary_firstobj
);
1055 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1056 -fno-exceptions -w -fno-whole-program */
1059 c_argv
= XCNEWVEC (char *, num_c_args
);
1060 c_ptr
= CONST_CAST2 (const char **, char **, c_argv
);
1063 fatal_error ("no arguments");
1066 if (signal (SIGQUIT
, SIG_IGN
) != SIG_IGN
)
1067 signal (SIGQUIT
, handler
);
1069 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1070 signal (SIGINT
, handler
);
1072 if (signal (SIGALRM
, SIG_IGN
) != SIG_IGN
)
1073 signal (SIGALRM
, handler
);
1076 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1077 signal (SIGHUP
, handler
);
1079 if (signal (SIGSEGV
, SIG_IGN
) != SIG_IGN
)
1080 signal (SIGSEGV
, handler
);
1082 if (signal (SIGBUS
, SIG_IGN
) != SIG_IGN
)
1083 signal (SIGBUS
, handler
);
1086 /* Extract COMPILER_PATH and PATH into our prefix list. */
1087 prefix_from_env ("COMPILER_PATH", &cpath
);
1088 prefix_from_env ("PATH", &path
);
1090 /* Try to discover a valid linker/nm/strip to use. */
1092 /* Maybe we know the right file to use (if not cross). */
1094 #ifdef DEFAULT_LINKER
1095 if (selected_linker
== USE_BFD_LD
|| selected_linker
== USE_GOLD_LD
)
1098 # ifdef HOST_EXECUTABLE_SUFFIX
1099 int len
= (sizeof (DEFAULT_LINKER
)
1100 - sizeof (HOST_EXECUTABLE_SUFFIX
));
1104 char *default_linker
= xstrdup (DEFAULT_LINKER
);
1105 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1106 HOST_EXECUTABLE_SUFFIX. */
1107 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
1109 default_linker
[len
] = '\0';
1110 linker_name
= concat (default_linker
,
1111 &ld_suffixes
[selected_linker
][2],
1112 HOST_EXECUTABLE_SUFFIX
, NULL
);
1115 if (linker_name
== NULL
)
1117 linker_name
= concat (DEFAULT_LINKER
,
1118 &ld_suffixes
[selected_linker
][2],
1120 if (access (linker_name
, X_OK
) == 0)
1121 ld_file_name
= linker_name
;
1123 if (ld_file_name
== 0 && access (DEFAULT_LINKER
, X_OK
) == 0)
1124 ld_file_name
= DEFAULT_LINKER
;
1125 if (ld_file_name
== 0)
1127 #ifdef REAL_LD_FILE_NAME
1128 ld_file_name
= find_a_file (&path
, REAL_LD_FILE_NAME
, X_OK
);
1129 if (ld_file_name
== 0)
1131 /* Search the (target-specific) compiler dirs for ld'. */
1132 ld_file_name
= find_a_file (&cpath
, real_ld_suffix
, X_OK
);
1133 /* Likewise for `collect-ld'. */
1134 if (ld_file_name
== 0)
1136 ld_file_name
= find_a_file (&cpath
, collect_ld_suffix
, X_OK
);
1137 use_collect_ld
= ld_file_name
!= 0;
1139 /* Search the compiler directories for `ld'. We have protection against
1140 recursive calls in find_a_file. */
1141 if (ld_file_name
== 0)
1142 ld_file_name
= find_a_file (&cpath
, ld_suffixes
[selected_linker
], X_OK
);
1143 /* Search the ordinary system bin directories
1144 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1145 if (ld_file_name
== 0)
1146 ld_file_name
= find_a_file (&path
, full_ld_suffixes
[selected_linker
], X_OK
);
1148 #ifdef REAL_NM_FILE_NAME
1149 nm_file_name
= find_a_file (&path
, REAL_NM_FILE_NAME
, X_OK
);
1150 if (nm_file_name
== 0)
1152 nm_file_name
= find_a_file (&cpath
, gnm_suffix
, X_OK
);
1153 if (nm_file_name
== 0)
1154 nm_file_name
= find_a_file (&path
, full_gnm_suffix
, X_OK
);
1155 if (nm_file_name
== 0)
1156 nm_file_name
= find_a_file (&cpath
, nm_suffix
, X_OK
);
1157 if (nm_file_name
== 0)
1158 nm_file_name
= find_a_file (&path
, full_nm_suffix
, X_OK
);
1161 ldd_file_name
= find_a_file (&cpath
, ldd_suffix
, X_OK
);
1162 if (ldd_file_name
== 0)
1163 ldd_file_name
= find_a_file (&path
, full_ldd_suffix
, X_OK
);
1166 #ifdef REAL_STRIP_FILE_NAME
1167 strip_file_name
= find_a_file (&path
, REAL_STRIP_FILE_NAME
, X_OK
);
1168 if (strip_file_name
== 0)
1170 strip_file_name
= find_a_file (&cpath
, gstrip_suffix
, X_OK
);
1171 if (strip_file_name
== 0)
1172 strip_file_name
= find_a_file (&path
, full_gstrip_suffix
, X_OK
);
1173 if (strip_file_name
== 0)
1174 strip_file_name
= find_a_file (&cpath
, strip_suffix
, X_OK
);
1175 if (strip_file_name
== 0)
1176 strip_file_name
= find_a_file (&path
, full_strip_suffix
, X_OK
);
1178 /* Determine the full path name of the C compiler to use. */
1179 c_file_name
= getenv ("COLLECT_GCC");
1180 if (c_file_name
== 0)
1182 #ifdef CROSS_DIRECTORY_STRUCTURE
1183 c_file_name
= concat (target_machine
, "-gcc", NULL
);
1185 c_file_name
= "gcc";
1189 p
= find_a_file (&cpath
, c_file_name
, X_OK
);
1191 /* Here it should be safe to use the system search path since we should have
1192 already qualified the name of the compiler when it is needed. */
1194 p
= find_a_file (&path
, c_file_name
, X_OK
);
1199 *ld1
++ = *ld2
++ = ld_file_name
;
1201 /* Make temp file names. */
1202 c_file
= make_temp_file (".c");
1203 o_file
= make_temp_file (".o");
1204 #ifdef COLLECT_EXPORT_LIST
1205 export_file
= make_temp_file (".x");
1209 ldout
= make_temp_file (".ld");
1210 lderrout
= make_temp_file (".le");
1212 *c_ptr
++ = c_file_name
;
1219 #ifdef COLLECT_EXPORT_LIST
1220 /* Generate a list of directories from LIBPATH. */
1221 prefix_from_env ("LIBPATH", &libpath_lib_dirs
);
1222 /* Add to this list also two standard directories where
1223 AIX loader always searches for libraries. */
1224 add_prefix (&libpath_lib_dirs
, "/lib");
1225 add_prefix (&libpath_lib_dirs
, "/usr/lib");
1228 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1230 AIX support needs to know if -shared has been specified before
1231 parsing commandline arguments. */
1233 p
= getenv ("COLLECT_GCC_OPTIONS");
1236 const char *q
= extract_string (&p
);
1237 if (*q
== '-' && (q
[1] == 'm' || q
[1] == 'f'))
1238 *c_ptr
++ = xstrdup (q
);
1239 if (strcmp (q
, "-EL") == 0 || strcmp (q
, "-EB") == 0)
1240 *c_ptr
++ = xstrdup (q
);
1241 if (strcmp (q
, "-shared") == 0)
1243 if (*q
== '-' && q
[1] == 'B')
1245 *c_ptr
++ = xstrdup (q
);
1248 q
= extract_string (&p
);
1249 *c_ptr
++ = xstrdup (q
);
1253 obstack_free (&temporary_obstack
, temporary_firstobj
);
1254 *c_ptr
++ = "-fno-profile-arcs";
1255 *c_ptr
++ = "-fno-test-coverage";
1256 *c_ptr
++ = "-fno-branch-probabilities";
1257 *c_ptr
++ = "-fno-exceptions";
1259 *c_ptr
++ = "-fno-whole-program";
1261 /* !!! When GCC calls collect2,
1262 it does not know whether it is calling collect2 or ld.
1263 So collect2 cannot meaningfully understand any options
1264 except those ld understands.
1265 If you propose to make GCC pass some other option,
1266 just imagine what will happen if ld is really ld!!! */
1268 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1269 /* After the first file, put in the c++ rt0. */
1272 while ((arg
= *++argv
) != (char *) 0)
1274 *ld1
++ = *ld2
++ = arg
;
1281 if (!strcmp (arg
, "-debug"))
1283 /* Already parsed. */
1287 if (!strcmp (arg
, "-dynamic-linker") && argv
[1])
1290 *ld1
++ = *ld2
++ = *argv
;
1295 if (strncmp (arg
, "-flto", 5) == 0)
1298 /* Do not pass LTO flag to the linker. */
1302 error ("LTO support has not been enabled in this "
1306 else if (!use_collect_ld
1307 && strncmp (arg
, "-fuse-ld=", 9) == 0)
1309 /* Do not pass -fuse-ld={bfd|gold} to the linker. */
1313 #ifdef TARGET_AIX_VERSION
1316 /* File containing a list of input files to process. */
1319 char buf
[MAXPATHLEN
+ 2];
1320 /* Number of additionnal object files. */
1322 /* Maximum of additionnal object files before vector
1325 const char *list_filename
= arg
+ 2;
1327 /* Accept -fFILENAME and -f FILENAME. */
1328 if (*list_filename
== '\0' && argv
[1])
1331 list_filename
= *argv
;
1332 *ld1
++ = *ld2
++ = *argv
;
1335 stream
= fopen (list_filename
, "r");
1337 fatal_error ("can't open %s: %m", list_filename
);
1339 while (fgets (buf
, sizeof buf
, stream
) != NULL
)
1341 /* Remove end of line. */
1342 int len
= strlen (buf
);
1343 if (len
>= 1 && buf
[len
- 1] =='\n')
1344 buf
[len
- 1] = '\0';
1346 /* Put on object vector.
1347 Note: we only expanse vector here, so we must keep
1348 extra space for remaining arguments. */
1349 if (add_nbr
>= add_max
)
1352 object
- CONST_CAST2 (const char **, char **,
1354 add_max
= (add_max
== 0) ? 16 : add_max
* 2;
1355 object_lst
= XRESIZEVEC (char *, object_lst
,
1356 object_nbr
+ add_max
);
1357 object
= CONST_CAST2 (const char **, char **,
1359 object_nbr
+= add_max
;
1361 *object
++ = xstrdup (buf
);
1372 /* place o_file BEFORE this argument! */
1378 #ifdef COLLECT_EXPORT_LIST
1380 /* Resolving full library name. */
1381 const char *s
= resolve_lib_name (arg
+2);
1383 /* Saving a full library name. */
1384 add_to_list (&libs
, s
);
1389 #ifdef COLLECT_EXPORT_LIST
1390 /* Saving directories where to search for libraries. */
1392 add_prefix (&cmdline_lib_dirs
, arg
+2);
1398 output_file
= *ld1
++ = *ld2
++ = *++argv
;
1400 output_file
= &arg
[2];
1409 if (arg
[2] == '\0' && do_collecting
)
1411 /* We must strip after the nm run, otherwise C++ linking
1412 will not work. Thus we strip in the second ld run, or
1413 else with strip if there is no second ld run. */
1425 if (strcmp (arg
, "--no-demangle") == 0)
1427 #ifndef HAVE_LD_DEMANGLE
1433 else if (strncmp (arg
, "--demangle", 10) == 0)
1435 #ifndef HAVE_LD_DEMANGLE
1439 enum demangling_styles style
1440 = cplus_demangle_name_to_style (arg
+11);
1441 if (style
== unknown_demangling
)
1442 error ("unknown demangling style '%s'", arg
+11);
1444 current_demangling_style
= style
;
1450 else if (strncmp (arg
, "--sysroot=", 10) == 0)
1451 target_system_root
= arg
+ 10;
1452 else if (strcmp (arg
, "--version") == 0)
1454 else if (strcmp (arg
, "--help") == 0)
1459 else if ((p
= strrchr (arg
, '.')) != (char *) 0
1460 && (strcmp (p
, ".o") == 0 || strcmp (p
, ".a") == 0
1461 || strcmp (p
, ".so") == 0 || strcmp (p
, ".lo") == 0
1462 || strcmp (p
, ".obj") == 0))
1471 /* place o_file BEFORE this argument! */
1477 if (p
[1] == 'o' || p
[1] == 'l')
1479 #ifdef COLLECT_EXPORT_LIST
1480 /* libraries can be specified directly, i.e. without -l flag. */
1483 /* Saving a full library name. */
1484 add_to_list (&libs
, arg
);
1490 #ifdef COLLECT_EXPORT_LIST
1491 /* This is added only for debugging purposes. */
1494 fprintf (stderr
, "List of libraries:\n");
1495 dump_list (stderr
, "\t", libs
.first
);
1498 /* The AIX linker will discard static constructors in object files if
1499 nothing else in the file is referenced, so look at them first. Unless
1500 we are building a shared object, ignore the eh frame tables, as we
1501 would otherwise reference them all, hence drag all the corresponding
1502 objects even if nothing else is referenced. */
1504 const char **export_object_lst
1505 = CONST_CAST2 (const char **, char **, object_lst
);
1507 struct id
*list
= libs
.first
;
1509 /* Compute the filter to use from the current one, do scan, then adjust
1510 the "current" filter to remove what we just included here. This will
1511 control whether we need a first pass link later on or not, and what
1512 will remain to be scanned there. */
1514 scanfilter this_filter
= ld1_filter
;
1517 this_filter
&= ~SCAN_DWEH
;
1520 while (export_object_lst
< object
)
1521 scan_prog_file (*export_object_lst
++, PASS_OBJ
, this_filter
);
1523 for (; list
; list
= list
->next
)
1524 scan_prog_file (list
->name
, PASS_FIRST
, this_filter
);
1526 ld1_filter
= ld1_filter
& ~this_filter
;
1531 char *buf
= concat ("-bE:", export_file
, NULL
);
1536 exportf
= fopen (export_file
, "w");
1537 if (exportf
== (FILE *) 0)
1538 fatal_error ("fopen %s: %m", export_file
);
1539 write_aix_file (exportf
, exports
.first
);
1540 if (fclose (exportf
))
1541 fatal_error ("fclose %s: %m", export_file
);
1546 *c_ptr
= *ld1
= *object
= (char *) 0;
1549 notice ("collect2 version %s\n", version_string
);
1553 printf ("Usage: collect2 [options]\n");
1554 printf (" Wrap linker and generate constructor code if needed.\n");
1555 printf (" Options:\n");
1556 printf (" -debug Enable debug output\n");
1557 printf (" --help Display this information\n");
1558 printf (" -v, --version Display this program's version number\n");
1560 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1561 printf ("Report bugs: %s\n", bug_report_url
);
1568 fprintf (stderr
, "ld_file_name = %s\n",
1569 (ld_file_name
? ld_file_name
: "not found"));
1570 fprintf (stderr
, "c_file_name = %s\n",
1571 (c_file_name
? c_file_name
: "not found"));
1572 fprintf (stderr
, "nm_file_name = %s\n",
1573 (nm_file_name
? nm_file_name
: "not found"));
1575 fprintf (stderr
, "ldd_file_name = %s\n",
1576 (ldd_file_name
? ldd_file_name
: "not found"));
1578 fprintf (stderr
, "strip_file_name = %s\n",
1579 (strip_file_name
? strip_file_name
: "not found"));
1580 fprintf (stderr
, "c_file = %s\n",
1581 (c_file
? c_file
: "not found"));
1582 fprintf (stderr
, "o_file = %s\n",
1583 (o_file
? o_file
: "not found"));
1585 ptr
= getenv ("COLLECT_GCC_OPTIONS");
1587 fprintf (stderr
, "COLLECT_GCC_OPTIONS = %s\n", ptr
);
1589 ptr
= getenv ("COLLECT_GCC");
1591 fprintf (stderr
, "COLLECT_GCC = %s\n", ptr
);
1593 ptr
= getenv ("COMPILER_PATH");
1595 fprintf (stderr
, "COMPILER_PATH = %s\n", ptr
);
1597 ptr
= getenv (LIBRARY_PATH_ENV
);
1599 fprintf (stderr
, "%-20s= %s\n", LIBRARY_PATH_ENV
, ptr
);
1601 fprintf (stderr
, "\n");
1604 /* Load the program, searching all libraries and attempting to provide
1605 undefined symbols from repository information.
1607 If -r or they will be run via some other method, do not build the
1608 constructor or destructor list, just return now. */
1611 = rflag
|| (! DO_COLLECT_EXPORT_LIST
&& ! do_collecting
);
1613 /* Perform the first pass link now, if we're about to exit or if we need
1614 to scan for things we haven't collected yet before pursuing further.
1616 On AIX, the latter typically includes nothing for shared objects or
1617 frame tables for an executable, out of what the required early scan on
1618 objects and libraries has performed above. In the !shared_obj case, we
1619 expect the relevant tables to be dragged together with their associated
1620 functions from precise cross reference insertions by the compiler. */
1622 if (early_exit
|| ld1_filter
!= SCAN_NOTHING
)
1623 do_tlink (ld1_argv
, object_lst
);
1627 #ifdef COLLECT_EXPORT_LIST
1628 /* Make sure we delete the export file we may have created. */
1629 if (export_file
!= 0 && export_file
[0])
1630 maybe_unlink (export_file
);
1632 if (lto_mode
!= LTO_MODE_NONE
)
1633 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1635 post_ld_pass (false);
1637 maybe_unlink (c_file
);
1638 maybe_unlink (o_file
);
1643 /* Unless we have done it all already, examine the namelist and search for
1644 static constructors and destructors to call. Write the constructor and
1645 destructor tables to a .s file and reload. */
1647 if (ld1_filter
!= SCAN_NOTHING
)
1648 scan_prog_file (output_file
, PASS_FIRST
, ld1_filter
);
1650 #ifdef SCAN_LIBRARIES
1651 scan_libraries (output_file
);
1656 notice_translated (ngettext ("%d constructor found\n",
1657 "%d constructors found\n",
1658 constructors
.number
),
1659 constructors
.number
);
1660 notice_translated (ngettext ("%d destructor found\n",
1661 "%d destructors found\n",
1662 destructors
.number
),
1663 destructors
.number
);
1664 notice_translated (ngettext ("%d frame table found\n",
1665 "%d frame tables found\n",
1666 frame_tables
.number
),
1667 frame_tables
.number
);
1670 /* If the scan exposed nothing of special interest, there's no need to
1671 generate the glue code and relink so return now. */
1673 if (constructors
.number
== 0 && destructors
.number
== 0
1674 && frame_tables
.number
== 0
1675 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1676 /* If we will be running these functions ourselves, we want to emit
1677 stubs into the shared library so that we do not have to relink
1678 dependent programs when we add static objects. */
1683 /* Do tlink without additional code generation now if we didn't
1684 do it earlier for scanning purposes. */
1685 if (ld1_filter
== SCAN_NOTHING
)
1686 do_tlink (ld1_argv
, object_lst
);
1689 maybe_run_lto_and_relink (ld1_argv
, object_lst
, object
, false);
1691 /* Strip now if it was requested on the command line. */
1694 char **real_strip_argv
= XCNEWVEC (char *, 3);
1695 const char ** strip_argv
= CONST_CAST2 (const char **, char **,
1698 strip_argv
[0] = strip_file_name
;
1699 strip_argv
[1] = output_file
;
1700 strip_argv
[2] = (char *) 0;
1701 fork_execute ("strip", real_strip_argv
, false);
1704 #ifdef COLLECT_EXPORT_LIST
1705 maybe_unlink (export_file
);
1707 post_ld_pass (false);
1709 maybe_unlink (c_file
);
1710 maybe_unlink (o_file
);
1714 /* Sort ctor and dtor lists by priority. */
1715 sort_ids (&constructors
);
1716 sort_ids (&destructors
);
1718 maybe_unlink (output_file
);
1719 outf
= fopen (c_file
, "w");
1720 if (outf
== (FILE *) 0)
1721 fatal_error ("fopen %s: %m", c_file
);
1723 write_c_file (outf
, c_file
);
1726 fatal_error ("fclose %s: %m", c_file
);
1728 /* Tell the linker that we have initializer and finalizer functions. */
1729 #ifdef LD_INIT_SWITCH
1730 #ifdef COLLECT_EXPORT_LIST
1731 *ld2
++ = concat (LD_INIT_SWITCH
, ":", initname
, ":", fininame
, NULL
);
1733 *ld2
++ = LD_INIT_SWITCH
;
1735 *ld2
++ = LD_FINI_SWITCH
;
1740 #ifdef COLLECT_EXPORT_LIST
1743 /* If we did not add export flag to link arguments before, add it to
1744 second link phase now. No new exports should have been added. */
1745 if (! exports
.first
)
1746 *ld2
++ = concat ("-bE:", export_file
, NULL
);
1748 #ifdef TARGET_AIX_VERSION
1749 add_to_list (&exports
, aix_shared_initname
);
1750 add_to_list (&exports
, aix_shared_fininame
);
1753 #ifndef LD_INIT_SWITCH
1754 add_to_list (&exports
, initname
);
1755 add_to_list (&exports
, fininame
);
1756 add_to_list (&exports
, "_GLOBAL__DI");
1757 add_to_list (&exports
, "_GLOBAL__DD");
1759 exportf
= fopen (export_file
, "w");
1760 if (exportf
== (FILE *) 0)
1761 fatal_error ("fopen %s: %m", export_file
);
1762 write_aix_file (exportf
, exports
.first
);
1763 if (fclose (exportf
))
1764 fatal_error ("fclose %s: %m", export_file
);
1768 /* End of arguments to second link phase. */
1773 fprintf (stderr
, "\n========== output_file = %s, c_file = %s\n",
1774 output_file
, c_file
);
1775 write_c_file (stderr
, "stderr");
1776 fprintf (stderr
, "========== end of c_file\n\n");
1777 #ifdef COLLECT_EXPORT_LIST
1778 fprintf (stderr
, "\n========== export_file = %s\n", export_file
);
1779 write_aix_file (stderr
, exports
.first
);
1780 fprintf (stderr
, "========== end of export_file\n\n");
1784 /* Assemble the constructor and destructor tables.
1785 Link the tables in with the rest of the program. */
1787 fork_execute ("gcc", c_argv
, at_file_supplied
);
1788 #ifdef COLLECT_EXPORT_LIST
1789 /* On AIX we must call tlink because of possible templates resolution. */
1790 do_tlink (ld2_argv
, object_lst
);
1793 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, false);
1795 /* Otherwise, simply call ld because tlink is already done. */
1797 maybe_run_lto_and_relink (ld2_argv
, object_lst
, object
, true);
1800 fork_execute ("ld", ld2_argv
, HAVE_GNU_LD
&& at_file_supplied
);
1801 post_ld_pass (false);
1804 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1805 constructors/destructors in shared libraries. */
1806 scan_prog_file (output_file
, PASS_SECOND
, SCAN_ALL
);
1809 maybe_unlink (c_file
);
1810 maybe_unlink (o_file
);
1812 #ifdef COLLECT_EXPORT_LIST
1813 maybe_unlink (export_file
);
1820 /* Unlink FILE unless we are debugging or this is the output_file
1821 and we may not unlink it. */
1824 maybe_unlink (const char *file
)
1828 notice ("[Leaving %s]\n", file
);
1832 if (file
== output_file
&& !may_unlink_output_file
)
1835 unlink_if_ordinary (file
);
1838 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1841 maybe_unlink_list (char **file_list
)
1843 char **tmp
= file_list
;
1846 maybe_unlink (*(tmp
++));
1850 static long sequence_number
= 0;
1852 /* Add a name to a linked list. */
1855 add_to_list (struct head
*head_ptr
, const char *name
)
1858 = (struct id
*) xcalloc (sizeof (struct id
) + strlen (name
), 1);
1860 strcpy (newid
->name
, name
);
1862 if (head_ptr
->first
)
1863 head_ptr
->last
->next
= newid
;
1865 head_ptr
->first
= newid
;
1867 /* Check for duplicate symbols. */
1868 for (p
= head_ptr
->first
;
1869 strcmp (name
, p
->name
) != 0;
1874 head_ptr
->last
->next
= 0;
1879 newid
->sequence
= ++sequence_number
;
1880 head_ptr
->last
= newid
;
1884 /* Grab the init priority number from an init function name that
1885 looks like "_GLOBAL_.I.12345.foo". */
1888 extract_init_priority (const char *name
)
1892 #ifdef TARGET_AIX_VERSION
1893 /* Run dependent module initializers before any constructors in this
1895 switch (is_ctor_dtor (name
))
1905 while (name
[pos
] == '_')
1907 pos
+= 10; /* strlen ("GLOBAL__X_") */
1909 /* Extract init_p number from ctor/dtor name. */
1910 pri
= atoi (name
+ pos
);
1911 return pri
? pri
: DEFAULT_INIT_PRIORITY
;
1914 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1915 ctors will be run from right to left, dtors from left to right. */
1918 sort_ids (struct head
*head_ptr
)
1920 /* id holds the current element to insert. id_next holds the next
1921 element to insert. id_ptr iterates through the already sorted elements
1922 looking for the place to insert id. */
1923 struct id
*id
, *id_next
, **id_ptr
;
1925 id
= head_ptr
->first
;
1927 /* We don't have any sorted elements yet. */
1928 head_ptr
->first
= NULL
;
1930 for (; id
; id
= id_next
)
1933 id
->sequence
= extract_init_priority (id
->name
);
1935 for (id_ptr
= &(head_ptr
->first
); ; id_ptr
= &((*id_ptr
)->next
))
1937 /* If the sequence numbers are the same, we put the id from the
1938 file later on the command line later in the list. */
1939 || id
->sequence
> (*id_ptr
)->sequence
1940 /* Hack: do lexical compare, too.
1941 || (id->sequence == (*id_ptr)->sequence
1942 && strcmp (id->name, (*id_ptr)->name) > 0) */
1951 /* Now set the sequence numbers properly so write_c_file works. */
1952 for (id
= head_ptr
->first
; id
; id
= id
->next
)
1953 id
->sequence
= ++sequence_number
;
1956 /* Write: `prefix', the names on list LIST, `suffix'. */
1959 write_list (FILE *stream
, const char *prefix
, struct id
*list
)
1963 fprintf (stream
, "%sx%d,\n", prefix
, list
->sequence
);
1968 #ifdef COLLECT_EXPORT_LIST
1969 /* This function is really used only on AIX, but may be useful. */
1972 is_in_list (const char *prefix
, struct id
*list
)
1976 if (!strcmp (prefix
, list
->name
)) return 1;
1982 #endif /* COLLECT_EXPORT_LIST */
1984 /* Added for debugging purpose. */
1985 #ifdef COLLECT_EXPORT_LIST
1987 dump_list (FILE *stream
, const char *prefix
, struct id
*list
)
1991 fprintf (stream
, "%s%s,\n", prefix
, list
->name
);
1999 dump_prefix_list (FILE *stream
, const char *prefix
, struct prefix_list
*list
)
2003 fprintf (stream
, "%s%s,\n", prefix
, list
->prefix
);
2010 write_list_with_asm (FILE *stream
, const char *prefix
, struct id
*list
)
2014 fprintf (stream
, "%sx%d __asm__ (\"%s\");\n",
2015 prefix
, list
->sequence
, list
->name
);
2020 /* Write out the constructor and destructor tables statically (for a shared
2021 object), along with the functions to execute them. */
2024 write_c_file_stat (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2028 int frames
= (frame_tables
.number
> 0);
2030 /* Figure out name of output_file, stripping off .so version. */
2031 q
= p
= lbasename (output_file
);
2043 if (filename_ncmp (q
, SHLIB_SUFFIX
, strlen (SHLIB_SUFFIX
)) == 0)
2045 q
+= strlen (SHLIB_SUFFIX
);
2052 /* q points to null at end of the string (or . of the .so version) */
2053 prefix
= XNEWVEC (char, q
- p
+ 1);
2054 strncpy (prefix
, p
, q
- p
);
2056 for (r
= prefix
; *r
; r
++)
2057 if (!ISALNUM ((unsigned char)*r
))
2060 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2061 output_file
, prefix
);
2063 initname
= concat ("_GLOBAL__FI_", prefix
, NULL
);
2064 fininame
= concat ("_GLOBAL__FD_", prefix
, NULL
);
2065 #ifdef TARGET_AIX_VERSION
2066 aix_shared_initname
= concat ("_GLOBAL__AIXI_", prefix
, NULL
);
2067 aix_shared_fininame
= concat ("_GLOBAL__AIXD_", prefix
, NULL
);
2072 /* Write the tables as C code. */
2074 /* This count variable is used to prevent multiple calls to the
2075 constructors/destructors.
2076 This guard against multiple calls is important on AIX as the initfini
2077 functions are deliberately invoked multiple times as part of the
2078 mechanisms GCC uses to order constructors across different dependent
2079 shared libraries (see config/rs6000/aix.h).
2081 fprintf (stream
, "static int count;\n");
2082 fprintf (stream
, "typedef void entry_pt();\n");
2083 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2087 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2089 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2090 write_list (stream
, "\t\t&", frame_tables
.first
);
2091 fprintf (stream
, "\t0\n};\n");
2093 /* This must match what's in frame.h. */
2094 fprintf (stream
, "struct object {\n");
2095 fprintf (stream
, " void *pc_begin;\n");
2096 fprintf (stream
, " void *pc_end;\n");
2097 fprintf (stream
, " void *fde_begin;\n");
2098 fprintf (stream
, " void *fde_array;\n");
2099 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2100 fprintf (stream
, " struct object *next;\n");
2101 fprintf (stream
, "};\n");
2103 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2104 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2106 fprintf (stream
, "static void reg_frame () {\n");
2107 fprintf (stream
, "\tstatic struct object ob;\n");
2108 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2109 fprintf (stream
, "\t}\n");
2111 fprintf (stream
, "static void dereg_frame () {\n");
2112 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2113 fprintf (stream
, "\t}\n");
2116 fprintf (stream
, "void %s() {\n", initname
);
2117 if (constructors
.number
> 0 || frames
)
2119 fprintf (stream
, "\tstatic entry_pt *ctors[] = {\n");
2120 write_list (stream
, "\t\t", constructors
.first
);
2122 fprintf (stream
, "\treg_frame,\n");
2123 fprintf (stream
, "\t};\n");
2124 fprintf (stream
, "\tentry_pt **p;\n");
2125 fprintf (stream
, "\tif (count++ != 0) return;\n");
2126 fprintf (stream
, "\tp = ctors + %d;\n", constructors
.number
+ frames
);
2127 fprintf (stream
, "\twhile (p > ctors) (*--p)();\n");
2130 fprintf (stream
, "\t++count;\n");
2131 fprintf (stream
, "}\n");
2132 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2133 fprintf (stream
, "void %s() {\n", fininame
);
2134 if (destructors
.number
> 0 || frames
)
2136 fprintf (stream
, "\tstatic entry_pt *dtors[] = {\n");
2137 write_list (stream
, "\t\t", destructors
.first
);
2139 fprintf (stream
, "\tdereg_frame,\n");
2140 fprintf (stream
, "\t};\n");
2141 fprintf (stream
, "\tentry_pt **p;\n");
2142 fprintf (stream
, "\tif (--count != 0) return;\n");
2143 fprintf (stream
, "\tp = dtors;\n");
2144 fprintf (stream
, "\twhile (p < dtors + %d) (*p++)();\n",
2145 destructors
.number
+ frames
);
2147 fprintf (stream
, "}\n");
2151 COLLECT_SHARED_INIT_FUNC (stream
, initname
);
2152 COLLECT_SHARED_FINI_FUNC (stream
, fininame
);
2156 /* Write the constructor/destructor tables. */
2158 #ifndef LD_INIT_SWITCH
2160 write_c_file_glob (FILE *stream
, const char *name ATTRIBUTE_UNUSED
)
2162 /* Write the tables as C code. */
2164 int frames
= (frame_tables
.number
> 0);
2166 fprintf (stream
, "typedef void entry_pt();\n\n");
2168 write_list_with_asm (stream
, "extern entry_pt ", constructors
.first
);
2172 write_list_with_asm (stream
, "extern void *", frame_tables
.first
);
2174 fprintf (stream
, "\tstatic void *frame_table[] = {\n");
2175 write_list (stream
, "\t\t&", frame_tables
.first
);
2176 fprintf (stream
, "\t0\n};\n");
2178 /* This must match what's in frame.h. */
2179 fprintf (stream
, "struct object {\n");
2180 fprintf (stream
, " void *pc_begin;\n");
2181 fprintf (stream
, " void *pc_end;\n");
2182 fprintf (stream
, " void *fde_begin;\n");
2183 fprintf (stream
, " void *fde_array;\n");
2184 fprintf (stream
, " __SIZE_TYPE__ count;\n");
2185 fprintf (stream
, " struct object *next;\n");
2186 fprintf (stream
, "};\n");
2188 fprintf (stream
, "extern void __register_frame_info_table (void *, struct object *);\n");
2189 fprintf (stream
, "extern void *__deregister_frame_info (void *);\n");
2191 fprintf (stream
, "static void reg_frame () {\n");
2192 fprintf (stream
, "\tstatic struct object ob;\n");
2193 fprintf (stream
, "\t__register_frame_info_table (frame_table, &ob);\n");
2194 fprintf (stream
, "\t}\n");
2196 fprintf (stream
, "static void dereg_frame () {\n");
2197 fprintf (stream
, "\t__deregister_frame_info (frame_table);\n");
2198 fprintf (stream
, "\t}\n");
2201 fprintf (stream
, "\nentry_pt * __CTOR_LIST__[] = {\n");
2202 fprintf (stream
, "\t(entry_pt *) %d,\n", constructors
.number
+ frames
);
2203 write_list (stream
, "\t", constructors
.first
);
2205 fprintf (stream
, "\treg_frame,\n");
2206 fprintf (stream
, "\t0\n};\n\n");
2208 write_list_with_asm (stream
, "extern entry_pt ", destructors
.first
);
2210 fprintf (stream
, "\nentry_pt * __DTOR_LIST__[] = {\n");
2211 fprintf (stream
, "\t(entry_pt *) %d,\n", destructors
.number
+ frames
);
2212 write_list (stream
, "\t", destructors
.first
);
2214 fprintf (stream
, "\tdereg_frame,\n");
2215 fprintf (stream
, "\t0\n};\n\n");
2217 fprintf (stream
, "extern entry_pt %s;\n", NAME__MAIN
);
2218 fprintf (stream
, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN
);
2220 #endif /* ! LD_INIT_SWITCH */
2223 write_c_file (FILE *stream
, const char *name
)
2225 #ifndef LD_INIT_SWITCH
2227 write_c_file_glob (stream
, name
);
2230 write_c_file_stat (stream
, name
);
2233 #ifdef COLLECT_EXPORT_LIST
2235 write_aix_file (FILE *stream
, struct id
*list
)
2237 for (; list
; list
= list
->next
)
2239 fputs (list
->name
, stream
);
2240 putc ('\n', stream
);
2245 #ifdef OBJECT_FORMAT_NONE
2247 /* Check to make sure the file is an LTO object file. */
2250 maybe_lto_object_file (const char *prog_name
)
2253 unsigned char buf
[4];
2256 static unsigned char elfmagic
[4] = { 0x7f, 'E', 'L', 'F' };
2257 static unsigned char coffmagic
[2] = { 0x4c, 0x01 };
2258 static unsigned char coffmagic_x64
[2] = { 0x64, 0x86 };
2259 static unsigned char machomagic
[4][4] = {
2260 { 0xcf, 0xfa, 0xed, 0xfe },
2261 { 0xce, 0xfa, 0xed, 0xfe },
2262 { 0xfe, 0xed, 0xfa, 0xcf },
2263 { 0xfe, 0xed, 0xfa, 0xce }
2266 f
= fopen (prog_name
, "rb");
2269 if (fread (buf
, sizeof (buf
), 1, f
) != 1)
2273 if (memcmp (buf
, elfmagic
, sizeof (elfmagic
)) == 0
2274 || memcmp (buf
, coffmagic
, sizeof (coffmagic
)) == 0
2275 || memcmp (buf
, coffmagic_x64
, sizeof (coffmagic_x64
)) == 0)
2277 for (i
= 0; i
< 4; i
++)
2278 if (memcmp (buf
, machomagic
[i
], sizeof (machomagic
[i
])) == 0)
2284 /* Generic version to scan the name list of the loaded program for
2285 the symbols g++ uses for static constructors and destructors. */
2288 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2291 void (*int_handler
) (int);
2293 void (*quit_handler
) (int);
2295 char *real_nm_argv
[4];
2296 const char **nm_argv
= CONST_CAST2 (const char **, char**, real_nm_argv
);
2298 struct pex_obj
*pex
;
2305 if (which_pass
== PASS_SECOND
)
2308 /* LTO objects must be in a known format. This check prevents
2309 us from accepting an archive containing LTO objects, which
2310 gcc cannot currently handle. */
2311 if (which_pass
== PASS_LTOINFO
&& !maybe_lto_object_file (prog_name
))
2314 /* If we do not have an `nm', complain. */
2315 if (nm_file_name
== 0)
2316 fatal_error ("cannot find 'nm'");
2318 nm_argv
[argc
++] = nm_file_name
;
2319 if (NM_FLAGS
[0] != '\0')
2320 nm_argv
[argc
++] = NM_FLAGS
;
2322 nm_argv
[argc
++] = prog_name
;
2323 nm_argv
[argc
++] = (char *) 0;
2325 /* Trace if needed. */
2328 const char **p_argv
;
2331 for (p_argv
= &nm_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2332 fprintf (stderr
, " %s", str
);
2334 fprintf (stderr
, "\n");
2340 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2342 fatal_error ("pex_init failed: %m");
2344 errmsg
= pex_run (pex
, 0, nm_file_name
, real_nm_argv
, NULL
, HOST_BIT_BUCKET
,
2351 fatal_error ("%s: %m", _(errmsg
));
2354 fatal_error (errmsg
);
2357 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2359 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2362 inf
= pex_read_output (pex
, 0);
2364 fatal_error ("can't open nm output: %m");
2368 if (which_pass
== PASS_LTOINFO
)
2369 fprintf (stderr
, "\nnm output with LTO info marker symbol.\n");
2371 fprintf (stderr
, "\nnm output with constructors/destructors.\n");
2374 /* Read each line of nm output. */
2375 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2381 fprintf (stderr
, "\t%s\n", buf
);
2383 if (which_pass
== PASS_LTOINFO
)
2388 /* Look for the LTO info marker symbol, and add filename to
2389 the LTO objects list if found. */
2390 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n'; p
++)
2391 if (ch
== ' ' && p
[1] == '_' && p
[2] == '_'
2392 && (strncmp (p
+ (p
[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2393 && ISSPACE (p
[p
[3] == '_' ? 14 : 13]))
2395 add_lto_object (<o_objects
, prog_name
);
2397 /* We need to read all the input, so we can't just
2398 return here. But we can avoid useless work. */
2407 /* If it contains a constructor or destructor name, add the name
2408 to the appropriate list unless this is a kind of symbol we're
2409 not supposed to even consider. */
2411 for (p
= buf
; (ch
= *p
) != '\0' && ch
!= '\n' && ch
!= '_'; p
++)
2412 if (ch
== ' ' && p
[1] == 'U' && p
[2] == ' ')
2419 /* Find the end of the symbol name.
2420 Do not include `|', because Encore nm can tack that on the end. */
2421 for (end
= p
; (ch2
= *end
) != '\0' && !ISSPACE (ch2
) && ch2
!= '|';
2428 switch (is_ctor_dtor (name
))
2431 if (! (filter
& SCAN_CTOR
))
2433 if (which_pass
!= PASS_LIB
)
2434 add_to_list (&constructors
, name
);
2438 if (! (filter
& SCAN_DTOR
))
2440 if (which_pass
!= PASS_LIB
)
2441 add_to_list (&destructors
, name
);
2445 if (! (filter
& SCAN_INIT
))
2447 if (which_pass
!= PASS_LIB
)
2448 fatal_error ("init function found in object %s", prog_name
);
2449 #ifndef LD_INIT_SWITCH
2450 add_to_list (&constructors
, name
);
2455 if (! (filter
& SCAN_FINI
))
2457 if (which_pass
!= PASS_LIB
)
2458 fatal_error ("fini function found in object %s", prog_name
);
2459 #ifndef LD_FINI_SWITCH
2460 add_to_list (&destructors
, name
);
2465 if (! (filter
& SCAN_DWEH
))
2467 if (which_pass
!= PASS_LIB
)
2468 add_to_list (&frame_tables
, name
);
2471 default: /* not a constructor or destructor */
2477 fprintf (stderr
, "\n");
2479 do_wait (nm_file_name
, pex
);
2481 signal (SIGINT
, int_handler
);
2483 signal (SIGQUIT
, quit_handler
);
2489 /* Use the List Dynamic Dependencies program to find shared libraries that
2490 the output file depends upon and their initialization/finalization
2491 routines, if any. */
2494 scan_libraries (const char *prog_name
)
2496 static struct head libraries
; /* list of shared libraries found */
2498 void (*int_handler
) (int);
2500 void (*quit_handler
) (int);
2502 char *real_ldd_argv
[4];
2503 const char **ldd_argv
= CONST_CAST2 (const char **, char **, real_ldd_argv
);
2505 struct pex_obj
*pex
;
2511 /* If we do not have an `ldd', complain. */
2512 if (ldd_file_name
== 0)
2514 error ("cannot find 'ldd'");
2518 ldd_argv
[argc
++] = ldd_file_name
;
2519 ldd_argv
[argc
++] = prog_name
;
2520 ldd_argv
[argc
++] = (char *) 0;
2522 /* Trace if needed. */
2525 const char **p_argv
;
2528 for (p_argv
= &ldd_argv
[0]; (str
= *p_argv
) != (char *) 0; p_argv
++)
2529 fprintf (stderr
, " %s", str
);
2531 fprintf (stderr
, "\n");
2537 pex
= pex_init (PEX_USE_PIPES
, "collect2", NULL
);
2539 fatal_error ("pex_init failed: %m");
2541 errmsg
= pex_run (pex
, 0, ldd_file_name
, real_ldd_argv
, NULL
, NULL
, &err
);
2547 fatal_error ("%s: %m", _(errmsg
));
2550 fatal_error (errmsg
);
2553 int_handler
= (void (*) (int)) signal (SIGINT
, SIG_IGN
);
2555 quit_handler
= (void (*) (int)) signal (SIGQUIT
, SIG_IGN
);
2558 inf
= pex_read_output (pex
, 0);
2560 fatal_error ("can't open ldd output: %m");
2563 notice ("\nldd output with constructors/destructors.\n");
2565 /* Read each line of ldd output. */
2566 while (fgets (buf
, sizeof buf
, inf
) != (char *) 0)
2569 char *name
, *end
, *p
= buf
;
2571 /* Extract names of libraries and add to list. */
2572 PARSE_LDD_OUTPUT (p
);
2577 if (strncmp (name
, "not found", sizeof ("not found") - 1) == 0)
2578 fatal_error ("dynamic dependency %s not found", buf
);
2580 /* Find the end of the symbol name. */
2582 (ch2
= *end
) != '\0' && ch2
!= '\n' && !ISSPACE (ch2
) && ch2
!= '|';
2587 if (access (name
, R_OK
) == 0)
2588 add_to_list (&libraries
, name
);
2590 fatal_error ("unable to open dynamic dependency '%s'", buf
);
2593 fprintf (stderr
, "\t%s\n", buf
);
2596 fprintf (stderr
, "\n");
2598 do_wait (ldd_file_name
, pex
);
2600 signal (SIGINT
, int_handler
);
2602 signal (SIGQUIT
, quit_handler
);
2605 /* Now iterate through the library list adding their symbols to
2607 for (list
= libraries
.first
; list
; list
= list
->next
)
2608 scan_prog_file (list
->name
, PASS_LIB
, SCAN_ALL
);
2611 #endif /* LDD_SUFFIX */
2613 #endif /* OBJECT_FORMAT_NONE */
2617 * COFF specific stuff.
2620 #ifdef OBJECT_FORMAT_COFF
2622 #if defined (EXTENDED_COFF)
2624 # define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax)
2625 # define GCC_SYMENT SYMR
2626 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2627 # define GCC_SYMINC(X) (1)
2628 # define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
2629 # define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
2633 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2634 # define GCC_SYMENT SYMENT
2635 # if defined (C_WEAKEXT)
2636 # define GCC_OK_SYMBOL(X) \
2637 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2638 ((X).n_scnum > N_UNDEF) && \
2640 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2641 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2642 # define GCC_UNDEF_SYMBOL(X) \
2643 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2644 ((X).n_scnum == N_UNDEF))
2646 # define GCC_OK_SYMBOL(X) \
2647 (((X).n_sclass == C_EXT) && \
2648 ((X).n_scnum > N_UNDEF) && \
2650 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2651 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2652 # define GCC_UNDEF_SYMBOL(X) \
2653 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2655 # define GCC_SYMINC(X) ((X).n_numaux+1)
2656 # define GCC_SYMZERO(X) 0
2658 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2659 #if TARGET_AIX_VERSION >= 51
2660 # define GCC_CHECK_HDR(X) \
2661 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2662 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2663 && !(HEADER (X).f_flags & F_LOADONLY))
2665 # define GCC_CHECK_HDR(X) \
2666 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2667 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2668 && !(HEADER (X).f_flags & F_LOADONLY))
2673 #ifdef COLLECT_EXPORT_LIST
2674 /* Array of standard AIX libraries which should not
2675 be scanned for ctors/dtors. */
2676 static const char *const aix_std_libs
[] = {
2684 "/usr/lib/libc_r.a",
2685 "/usr/lib/libm_r.a",
2686 "/usr/lib/threads/libc.a",
2687 "/usr/ccs/lib/libc.a",
2688 "/usr/ccs/lib/libm.a",
2689 "/usr/ccs/lib/libc_r.a",
2690 "/usr/ccs/lib/libm_r.a",
2694 /* This function checks the filename and returns 1
2695 if this name matches the location of a standard AIX library. */
2696 static int ignore_library (const char *);
2698 ignore_library (const char *name
)
2700 const char *const *p
;
2703 if (target_system_root
[0] != '\0')
2705 length
= strlen (target_system_root
);
2706 if (strncmp (name
, target_system_root
, length
) != 0)
2710 for (p
= &aix_std_libs
[0]; *p
!= NULL
; ++p
)
2711 if (strcmp (name
, *p
) == 0)
2715 #endif /* COLLECT_EXPORT_LIST */
2717 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2718 extern char *ldgetname (LDFILE
*, GCC_SYMENT
*);
2721 /* COFF version to scan the name list of the loaded program for
2722 the symbols g++ uses for static constructors and destructors. */
2725 scan_prog_file (const char *prog_name
, scanpass which_pass
,
2728 LDFILE
*ldptr
= NULL
;
2729 int sym_index
, sym_count
;
2732 if (which_pass
!= PASS_FIRST
&& which_pass
!= PASS_OBJ
)
2735 #ifdef COLLECT_EXPORT_LIST
2736 /* We do not need scanning for some standard C libraries. */
2737 if (which_pass
== PASS_FIRST
&& ignore_library (prog_name
))
2740 /* On AIX we have a loop, because there is not much difference
2741 between an object and an archive. This trick allows us to
2742 eliminate scan_libraries() function. */
2746 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2747 non-const char * filename parameter, even though it will not
2748 modify that string. So we must cast away const-ness here,
2749 using CONST_CAST to prevent complaints from -Wcast-qual. */
2750 if ((ldptr
= ldopen (CONST_CAST (char *, prog_name
), ldptr
)) != NULL
)
2752 if (! MY_ISCOFF (HEADER (ldptr
).f_magic
))
2753 fatal_error ("%s: not a COFF file", prog_name
);
2755 if (GCC_CHECK_HDR (ldptr
))
2757 sym_count
= GCC_SYMBOLS (ldptr
);
2758 sym_index
= GCC_SYMZERO (ldptr
);
2760 #ifdef COLLECT_EXPORT_LIST
2761 /* Is current archive member a shared object? */
2762 is_shared
= HEADER (ldptr
).f_flags
& F_SHROBJ
;
2765 while (sym_index
< sym_count
)
2769 if (ldtbread (ldptr
, sym_index
, &symbol
) <= 0)
2771 sym_index
+= GCC_SYMINC (symbol
);
2773 if (GCC_OK_SYMBOL (symbol
))
2777 if ((name
= ldgetname (ldptr
, &symbol
)) == NULL
)
2778 continue; /* Should never happen. */
2780 #ifdef XCOFF_DEBUGGING_INFO
2781 /* All AIX function names have a duplicate entry
2782 beginning with a dot. */
2787 switch (is_ctor_dtor (name
))
2789 #if TARGET_AIX_VERSION
2790 /* Add AIX shared library initalisers/finalisers
2791 to the constructors/destructors list of the
2794 if (! (filter
& SCAN_CTOR
))
2796 if (is_shared
&& !aixlazy_flag
)
2797 add_to_list (&constructors
, name
);
2801 if (! (filter
& SCAN_DTOR
))
2803 if (is_shared
&& !aixlazy_flag
)
2804 add_to_list (&destructors
, name
);
2809 if (! (filter
& SCAN_CTOR
))
2812 add_to_list (&constructors
, name
);
2813 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2814 if (which_pass
== PASS_OBJ
)
2815 add_to_list (&exports
, name
);
2820 if (! (filter
& SCAN_DTOR
))
2823 add_to_list (&destructors
, name
);
2824 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2825 if (which_pass
== PASS_OBJ
)
2826 add_to_list (&exports
, name
);
2830 #ifdef COLLECT_EXPORT_LIST
2832 if (! (filter
& SCAN_INIT
))
2834 #ifndef LD_INIT_SWITCH
2836 add_to_list (&constructors
, name
);
2841 if (! (filter
& SCAN_FINI
))
2843 #ifndef LD_INIT_SWITCH
2845 add_to_list (&destructors
, name
);
2851 if (! (filter
& SCAN_DWEH
))
2854 add_to_list (&frame_tables
, name
);
2855 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2856 if (which_pass
== PASS_OBJ
)
2857 add_to_list (&exports
, name
);
2861 default: /* not a constructor or destructor */
2862 #ifdef COLLECT_EXPORT_LIST
2863 /* Explicitly export all global symbols when
2864 building a shared object on AIX, but do not
2865 re-export symbols from another shared object
2866 and do not export symbols if the user
2867 provides an explicit export list. */
2868 if (shared_obj
&& !is_shared
2869 && which_pass
== PASS_OBJ
&& !export_flag
)
2870 add_to_list (&exports
, name
);
2876 #if !defined(EXTENDED_COFF)
2877 fprintf (stderr
, "\tsec=%d class=%d type=%s%o %s\n",
2878 symbol
.n_scnum
, symbol
.n_sclass
,
2879 (symbol
.n_type
? "0" : ""), symbol
.n_type
,
2883 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2884 symbol
.iss
, (long) symbol
.value
, symbol
.index
, name
);
2889 #ifdef COLLECT_EXPORT_LIST
2892 /* If archive contains both 32-bit and 64-bit objects,
2893 we want to skip objects in other mode so mismatch normal. */
2895 fprintf (stderr
, "%s : magic=%o aix64=%d mismatch\n",
2896 prog_name
, HEADER (ldptr
).f_magic
, aix64_flag
);
2902 fatal_error ("%s: cannot open as COFF file", prog_name
);
2904 #ifdef COLLECT_EXPORT_LIST
2905 /* On AIX loop continues while there are more members in archive. */
2907 while (ldclose (ldptr
) == FAILURE
);
2909 /* Otherwise we simply close ldptr. */
2910 (void) ldclose (ldptr
);
2913 #endif /* OBJECT_FORMAT_COFF */
2915 #ifdef COLLECT_EXPORT_LIST
2916 /* Given a library name without "lib" prefix, this function
2917 returns a full library name including a path. */
2919 resolve_lib_name (const char *name
)
2923 /* Library extensions for AIX dynamic linking. */
2924 const char * const libexts
[2] = {"a", "so"};
2926 for (i
= 0; libpaths
[i
]; i
++)
2927 if (libpaths
[i
]->max_len
> l
)
2928 l
= libpaths
[i
]->max_len
;
2930 lib_buf
= XNEWVEC (char, l
+ strlen (name
) + 10);
2932 for (i
= 0; libpaths
[i
]; i
++)
2934 struct prefix_list
*list
= libpaths
[i
]->plist
;
2935 for (; list
; list
= list
->next
)
2937 /* The following lines are needed because path_prefix list
2938 may contain directories both with trailing DIR_SEPARATOR and
2941 if (!IS_DIR_SEPARATOR (list
->prefix
[strlen (list
->prefix
)-1]))
2943 for (j
= 0; j
< 2; j
++)
2945 sprintf (lib_buf
, "%s%slib%s.%s",
2946 list
->prefix
, p
, name
,
2947 libexts
[(j
+ aixrtl_flag
) % 2]);
2948 if (debug
) fprintf (stderr
, "searching for: %s\n", lib_buf
);
2949 if (file_exists (lib_buf
))
2951 if (debug
) fprintf (stderr
, "found: %s\n", lib_buf
);
2958 fprintf (stderr
, "not found\n");
2960 fatal_error ("library lib%s not found", name
);
2963 #endif /* COLLECT_EXPORT_LIST */
2965 #ifdef COLLECT_RUN_DSYMUTIL
2966 static int flag_dsym
= false;
2967 static int flag_idsym
= false;
2970 process_args (int *argcp
, char **argv
) {
2973 for (i
=0; i
<argc
; ++i
)
2975 if (strcmp (argv
[i
], "-dsym") == 0)
2978 /* Remove the flag, as we handle all processing for it. */
2981 argv
[j
] = argv
[j
+1];
2986 else if (strcmp (argv
[i
], "-idsym") == 0)
2989 /* Remove the flag, as we handle all processing for it. */
2992 argv
[j
] = argv
[j
+1];
3001 do_dsymutil (const char *output_file
) {
3002 const char *dsymutil
= DSYMUTIL
+ 1;
3003 struct pex_obj
*pex
;
3004 char **real_argv
= XCNEWVEC (char *, 3);
3005 const char ** argv
= CONST_CAST2 (const char **, char **,
3009 argv
[1] = output_file
;
3010 argv
[2] = (char *) 0;
3012 pex
= collect_execute (dsymutil
, real_argv
, NULL
, NULL
,
3013 PEX_LAST
| PEX_SEARCH
, false);
3014 do_wait (dsymutil
, pex
);
3018 post_ld_pass (bool temp_file
) {
3019 if (!(temp_file
&& flag_idsym
) && !flag_dsym
)
3022 do_dsymutil (output_file
);
3026 process_args (int *argcp ATTRIBUTE_UNUSED
, char **argv ATTRIBUTE_UNUSED
) { }
3027 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED
) { }