1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 Contributed by Chris Smith (csmith@convex.com).
6 Heavily modified by Michael Meissner (meissner@cygnus.com),
7 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 2, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING. If not, write to the Free
23 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 /* Build tables of static constructors and destructors and run ld. */
31 #include "coretypes.h"
34 #if ! defined( SIGCHLD ) && defined( SIGCLD )
35 # define SIGCHLD SIGCLD
38 #ifdef vfork /* Autoconf may define this to fork for us. */
39 # define VFORK_STRING "fork"
41 # define VFORK_STRING "vfork"
47 #define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
48 lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
51 #ifndef LIBRARY_PATH_ENV
52 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
63 /* On certain systems, we have code that works by scanning the object file
64 directly. But this code uses system-specific header files and library
65 functions, so turn it off in a cross-compiler. Likewise, the names of
66 the utilities are not correct for a cross-compiler; we have to hope that
67 cross-versions are in the proper directories. */
70 #undef OBJECT_FORMAT_COFF
72 #undef REAL_LD_FILE_NAME
73 #undef REAL_NM_FILE_NAME
74 #undef REAL_STRIP_FILE_NAME
77 /* If we cannot use a special method, use the ordinary one:
78 run nm to find what symbols are present.
79 In a cross-compiler, this means you need a cross nm,
80 but that is not quite as unpleasant as special headers. */
82 #if !defined (OBJECT_FORMAT_COFF)
83 #define OBJECT_FORMAT_NONE
86 #ifdef OBJECT_FORMAT_COFF
95 /* Many versions of ldfcn.h define these. */
103 /* Some systems have an ISCOFF macro, but others do not. In some cases
104 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
105 that either do not have an ISCOFF macro in /usr/include or for those
106 where it is wrong. */
109 #define MY_ISCOFF(X) ISCOFF (X)
112 #endif /* OBJECT_FORMAT_COFF */
114 #ifdef OBJECT_FORMAT_NONE
116 /* Default flags to pass to nm. */
118 #define NM_FLAGS "-n"
121 #endif /* OBJECT_FORMAT_NONE */
123 /* Some systems use __main in a way incompatible with its use in gcc, in these
124 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
125 give the same symbol without quotes for an alternative entry point. */
127 #define NAME__MAIN "__main"
130 /* This must match tree.h. */
131 #define DEFAULT_INIT_PRIORITY 65535
133 #ifndef COLLECT_SHARED_INIT_FUNC
134 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
135 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
137 #ifndef COLLECT_SHARED_FINI_FUNC
138 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
139 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
143 #define SCAN_LIBRARIES
147 int do_collecting = 1;
149 int do_collecting = 0;
152 #ifndef COLLECT_PARSE_FLAG
153 #define COLLECT_PARSE_FLAG(FLAG)
156 /* Nonzero if we should suppress the automatic demangling of identifiers
157 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
160 /* Linked lists of constructor and destructor names. */
176 /* Enumeration giving which pass this is for scanning the program file. */
179 PASS_FIRST, /* without constructors */
180 PASS_OBJ, /* individual objects */
181 PASS_LIB, /* looking for shared libraries */
182 PASS_SECOND /* with constructors linked in */
185 int vflag; /* true if -v */
186 static int rflag; /* true if -r */
187 static int strip_flag; /* true if -s */
188 #ifdef COLLECT_EXPORT_LIST
189 static int export_flag; /* true if -bE */
190 static int aix64_flag; /* true if -b64 */
193 int debug; /* true if -debug */
195 static int shared_obj; /* true if -shared */
197 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
198 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
199 #ifdef COLLECT_EXPORT_LIST
200 static const char *export_file; /* <xxx>.x for AIX export list. */
202 const char *ldout; /* File for ld errors. */
203 static const char *output_file; /* Output file for ld. */
204 static const char *nm_file_name; /* pathname of nm */
206 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
208 static const char *strip_file_name; /* pathname of strip */
209 const char *c_file_name; /* pathname of gcc */
210 static char *initname, *fininame; /* names of init and fini funcs */
212 static struct head constructors; /* list of constructors found */
213 static struct head destructors; /* list of destructors found */
214 #ifdef COLLECT_EXPORT_LIST
215 static struct head exports; /* list of exported symbols */
217 static struct head frame_tables; /* list of frame unwind info tables */
219 struct obstack temporary_obstack;
220 char * temporary_firstobj;
222 /* Holds the return value of pexecute and fork. */
225 /* Structure to hold all the directories in which to search for files to
230 const char *prefix; /* String to prepend to the path. */
231 struct prefix_list *next; /* Next in linked list. */
236 struct prefix_list *plist; /* List of prefixes to try */
237 int max_len; /* Max length of a prefix in PLIST */
238 const char *name; /* Name of this list (used in config stuff) */
241 #ifdef COLLECT_EXPORT_LIST
242 /* Lists to keep libraries to be scanned for global constructors/destructors. */
243 static struct head libs; /* list of libraries */
244 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
245 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
246 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
247 &libpath_lib_dirs, NULL};
248 static const char *const libexts[3] = {"a", "so", NULL}; /* possible library extensions */
251 static void handler (int);
252 static int is_ctor_dtor (const char *);
253 static char *find_a_file (struct path_prefix *, const char *);
254 static void add_prefix (struct path_prefix *, const char *);
255 static void prefix_from_env (const char *, struct path_prefix *);
256 static void prefix_from_string (const char *, struct path_prefix *);
257 static void do_wait (const char *);
258 static void fork_execute (const char *, char **);
259 static void maybe_unlink (const char *);
260 static void add_to_list (struct head *, const char *);
261 static int extract_init_priority (const char *);
262 static void sort_ids (struct head *);
263 static void write_list (FILE *, const char *, struct id *);
264 #ifdef COLLECT_EXPORT_LIST
265 static void dump_list (FILE *, const char *, struct id *);
268 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
270 static void write_list_with_asm (FILE *, const char *, struct id *);
271 static void write_c_file (FILE *, const char *);
272 static void write_c_file_stat (FILE *, const char *);
273 #ifndef LD_INIT_SWITCH
274 static void write_c_file_glob (FILE *, const char *);
276 static void scan_prog_file (const char *, enum pass);
277 #ifdef SCAN_LIBRARIES
278 static void scan_libraries (const char *);
280 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
281 static int is_in_args (const char *, const char **, const char **);
283 #ifdef COLLECT_EXPORT_LIST
285 static int is_in_list (const char *, struct id *);
287 static void write_aix_file (FILE *, struct id *);
288 static char *resolve_lib_name (const char *);
290 static char *extract_string (const char **);
294 dup2 (int oldfd, int newfd)
303 while ((fd = dup (oldfd)) != newfd && fd >= 0) /* good enough for low fd's */
306 close (fdtmp[--fdx]);
310 #endif /* ! HAVE_DUP2 */
312 /* Delete tempfiles and exit function. */
315 collect_exit (int status)
317 if (c_file != 0 && c_file[0])
318 maybe_unlink (c_file);
320 if (o_file != 0 && o_file[0])
321 maybe_unlink (o_file);
323 #ifdef COLLECT_EXPORT_LIST
324 if (export_file != 0 && export_file[0])
325 maybe_unlink (export_file);
328 if (ldout != 0 && ldout[0])
331 maybe_unlink (ldout);
334 if (status != 0 && output_file != 0 && output_file[0])
335 maybe_unlink (output_file);
341 /* Notify user of a non-error. */
343 notice (const char *msgid, ...)
347 va_start (ap, msgid);
348 vfprintf (stderr, _(msgid), ap);
352 /* Die when sys call fails. */
355 fatal_perror (const char * msgid, ...)
360 va_start (ap, msgid);
361 fprintf (stderr, "collect2: ");
362 vfprintf (stderr, _(msgid), ap);
363 fprintf (stderr, ": %s\n", xstrerror (e));
366 collect_exit (FATAL_EXIT_CODE);
372 fatal (const char * msgid, ...)
376 va_start (ap, msgid);
377 fprintf (stderr, "collect2: ");
378 vfprintf (stderr, _(msgid), ap);
379 fprintf (stderr, "\n");
382 collect_exit (FATAL_EXIT_CODE);
385 /* Write error message. */
388 error (const char * msgid, ...)
392 va_start (ap, msgid);
393 fprintf (stderr, "collect2: ");
394 vfprintf (stderr, _(msgid), ap);
395 fprintf (stderr, "\n");
399 /* In case obstack is linked in, and abort is defined to fancy_abort,
400 provide a default entry. */
405 fatal ("internal error");
411 if (c_file != 0 && c_file[0])
412 maybe_unlink (c_file);
414 if (o_file != 0 && o_file[0])
415 maybe_unlink (o_file);
417 if (ldout != 0 && ldout[0])
418 maybe_unlink (ldout);
420 #ifdef COLLECT_EXPORT_LIST
421 if (export_file != 0 && export_file[0])
422 maybe_unlink (export_file);
425 signal (signo, SIG_DFL);
426 kill (getpid (), signo);
431 file_exists (const char *name)
433 return access (name, R_OK) == 0;
436 /* Parse a reasonable subset of shell quoting syntax. */
439 extract_string (const char **pp)
452 obstack_1grow (&temporary_obstack, c);
453 else if (! inside && c == ' ')
455 else if (! inside && c == '\\')
460 obstack_1grow (&temporary_obstack, c);
463 obstack_1grow (&temporary_obstack, '\0');
465 return obstack_finish (&temporary_obstack);
469 dump_file (const char *name)
471 FILE *stream = fopen (name, "r");
478 while (c = getc (stream),
479 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
480 obstack_1grow (&temporary_obstack, c);
481 if (obstack_object_size (&temporary_obstack) > 0)
483 const char *word, *p;
485 obstack_1grow (&temporary_obstack, '\0');
486 word = obstack_finish (&temporary_obstack);
489 ++word, putc ('.', stderr);
491 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
492 p += strlen (USER_LABEL_PREFIX);
494 #ifdef HAVE_LD_DEMANGLE
500 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
506 fputs (result, stderr);
508 diff = strlen (word) - strlen (result);
509 while (diff > 0 && c == ' ')
510 --diff, putc (' ', stderr);
511 while (diff < 0 && c == ' ')
512 ++diff, c = getc (stream);
517 fputs (word, stderr);
520 obstack_free (&temporary_obstack, temporary_firstobj);
529 /* Decide whether the given symbol is: a constructor (1), a destructor
530 (2), a routine in a shared object that calls all the constructors
531 (3) or destructors (4), a DWARF exception-handling table (5), or
532 nothing special (0). */
535 is_ctor_dtor (const char *s)
537 struct names { const char *const name; const int len; const int ret;
538 const int two_underscores; };
540 const struct names *p;
542 const char *orig_s = s;
544 static const struct names special[] = {
545 #ifndef NO_DOLLAR_IN_LABEL
546 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, 1, 0 },
547 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, 2, 0 },
549 #ifndef NO_DOT_IN_LABEL
550 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, 1, 0 },
551 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, 2, 0 },
552 #endif /* NO_DOT_IN_LABEL */
553 #endif /* NO_DOLLAR_IN_LABEL */
554 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
555 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
556 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, 5, 0 },
557 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
558 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
562 while ((ch = *s) == '_')
568 for (p = &special[0]; p->len > 0; p++)
571 && (!p->two_underscores || ((s - orig_s) >= 2))
572 && strncmp(s, p->name, p->len) == 0)
580 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
581 and one from the PATH variable. */
583 static struct path_prefix cpath, path;
586 /* This is the name of the target machine. We use it to form the name
587 of the files to execute. */
589 static const char *const target_machine = TARGET_MACHINE;
592 /* Search for NAME using prefix list PPREFIX. We only look for executable
595 Return 0 if not found, otherwise return its name, allocated with malloc. */
598 find_a_file (struct path_prefix *pprefix, const char *name)
601 struct prefix_list *pl;
602 int len = pprefix->max_len + strlen (name) + 1;
605 fprintf (stderr, "Looking for '%s'\n", name);
607 #ifdef HOST_EXECUTABLE_SUFFIX
608 len += strlen (HOST_EXECUTABLE_SUFFIX);
611 temp = xmalloc (len);
613 /* Determine the filename to execute (special case for absolute paths). */
616 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
617 || (*name && name[1] == ':')
621 if (access (name, X_OK) == 0)
626 fprintf (stderr, " - found: absolute path\n");
631 #ifdef HOST_EXECUTABLE_SUFFIX
632 /* Some systems have a suffix for executable files.
633 So try appending that. */
635 strcat (temp, HOST_EXECUTABLE_SUFFIX);
637 if (access (temp, X_OK) == 0)
642 fprintf (stderr, " - failed to locate using absolute path\n");
645 for (pl = pprefix->plist; pl; pl = pl->next)
649 strcpy (temp, pl->prefix);
652 if (stat (temp, &st) >= 0
653 && ! S_ISDIR (st.st_mode)
654 && access (temp, X_OK) == 0)
657 #ifdef HOST_EXECUTABLE_SUFFIX
658 /* Some systems have a suffix for executable files.
659 So try appending that. */
660 strcat (temp, HOST_EXECUTABLE_SUFFIX);
662 if (stat (temp, &st) >= 0
663 && ! S_ISDIR (st.st_mode)
664 && access (temp, X_OK) == 0)
669 if (debug && pprefix->plist == NULL)
670 fprintf (stderr, " - failed: no entries in prefix list\n");
676 /* Add an entry for PREFIX to prefix list PPREFIX. */
679 add_prefix (struct path_prefix *pprefix, const char *prefix)
681 struct prefix_list *pl, **prev;
686 for (pl = pprefix->plist; pl->next; pl = pl->next)
691 prev = &pprefix->plist;
693 /* Keep track of the longest prefix. */
695 len = strlen (prefix);
696 if (len > pprefix->max_len)
697 pprefix->max_len = len;
699 pl = xmalloc (sizeof (struct prefix_list));
700 pl->prefix = xstrdup (prefix);
705 pl->next = (struct prefix_list *) 0;
709 /* Take the value of the environment variable ENV, break it into a path, and
710 add of the entries to PPREFIX. */
713 prefix_from_env (const char *env, struct path_prefix *pprefix)
716 GET_ENVIRONMENT (p, env);
719 prefix_from_string (p, pprefix);
723 prefix_from_string (const char *p, struct path_prefix *pprefix)
725 const char *startp, *endp;
726 char *nstore = xmalloc (strlen (p) + 3);
729 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
734 if (*endp == PATH_SEPARATOR || *endp == 0)
736 strncpy (nstore, startp, endp-startp);
739 strcpy (nstore, "./");
741 else if (! IS_DIR_SEPARATOR (endp[-1]))
743 nstore[endp-startp] = DIR_SEPARATOR;
744 nstore[endp-startp+1] = 0;
747 nstore[endp-startp] = 0;
750 fprintf (stderr, " - add prefix: %s\n", nstore);
752 add_prefix (pprefix, nstore);
755 endp = startp = endp + 1;
765 main (int argc, char **argv)
767 static const char *const ld_suffix = "ld";
768 static const char *const real_ld_suffix = "real-ld";
769 static const char *const collect_ld_suffix = "collect-ld";
770 static const char *const nm_suffix = "nm";
771 static const char *const gnm_suffix = "gnm";
773 static const char *const ldd_suffix = LDD_SUFFIX;
775 static const char *const strip_suffix = "strip";
776 static const char *const gstrip_suffix = "gstrip";
779 /* If we look for a program in the compiler directories, we just use
780 the short name, since these directories are already system-specific.
781 But it we look for a program in the system directories, we need to
782 qualify the program name with the target machine. */
784 const char *const full_ld_suffix =
785 concat(target_machine, "-", ld_suffix, NULL);
786 const char *const full_nm_suffix =
787 concat (target_machine, "-", nm_suffix, NULL);
788 const char *const full_gnm_suffix =
789 concat (target_machine, "-", gnm_suffix, NULL);
791 const char *const full_ldd_suffix =
792 concat (target_machine, "-", ldd_suffix, NULL);
794 const char *const full_strip_suffix =
795 concat (target_machine, "-", strip_suffix, NULL);
796 const char *const full_gstrip_suffix =
797 concat (target_machine, "-", gstrip_suffix, NULL);
799 const char *const full_ld_suffix = ld_suffix;
800 const char *const full_nm_suffix = nm_suffix;
801 const char *const full_gnm_suffix = gnm_suffix;
803 const char *const full_ldd_suffix = ldd_suffix;
805 const char *const full_strip_suffix = strip_suffix;
806 const char *const full_gstrip_suffix = gstrip_suffix;
807 #endif /* CROSS_COMPILE */
811 #ifdef COLLECT_EXPORT_LIST
814 const char *ld_file_name;
825 int num_c_args = argc+9;
827 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
829 /* Suppress demangling by the real linker, which may be broken. */
830 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
832 #if defined (COLLECT2_HOST_INITIALIZATION)
833 /* Perform system dependent initialization, if necessary. */
834 COLLECT2_HOST_INITIALIZATION;
838 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
839 receive the signal. A different setting is inheritable */
840 signal (SIGCHLD, SIG_DFL);
845 /* Do not invoke xcalloc before this point, since locale needs to be
846 set first, in case a diagnostic is issued. */
848 ld1 = (const char **)(ld1_argv = xcalloc(sizeof (char *), argc+4));
849 ld2 = (const char **)(ld2_argv = xcalloc(sizeof (char *), argc+11));
850 object = (const char **)(object_lst = xcalloc(sizeof (char *), argc));
856 /* Parse command line early for instances of -debug. This allows
857 the debug flag to be set before functions like find_a_file()
862 for (i = 1; argv[i] != NULL; i ++)
864 if (! strcmp (argv[i], "-debug"))
866 COLLECT_PARSE_FLAG (argv[i]);
871 #ifndef DEFAULT_A_OUT_NAME
872 output_file = "a.out";
874 output_file = DEFAULT_A_OUT_NAME;
877 obstack_begin (&temporary_obstack, 0);
878 temporary_firstobj = obstack_alloc (&temporary_obstack, 0);
880 #ifndef HAVE_LD_DEMANGLE
881 current_demangling_style = auto_demangling;
883 p = getenv ("COLLECT_GCC_OPTIONS");
886 const char *q = extract_string (&p);
887 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
890 obstack_free (&temporary_obstack, temporary_firstobj);
892 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
893 -fno-exceptions -w */
896 c_ptr = (const char **) (c_argv = xcalloc (sizeof (char *), num_c_args));
899 fatal ("no arguments");
902 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
903 signal (SIGQUIT, handler);
905 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
906 signal (SIGINT, handler);
908 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
909 signal (SIGALRM, handler);
912 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
913 signal (SIGHUP, handler);
915 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
916 signal (SIGSEGV, handler);
918 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
919 signal (SIGBUS, handler);
922 /* Extract COMPILER_PATH and PATH into our prefix list. */
923 prefix_from_env ("COMPILER_PATH", &cpath);
924 prefix_from_env ("PATH", &path);
926 /* Try to discover a valid linker/nm/strip to use. */
928 /* Maybe we know the right file to use (if not cross). */
930 #ifdef DEFAULT_LINKER
931 if (access (DEFAULT_LINKER, X_OK) == 0)
932 ld_file_name = DEFAULT_LINKER;
933 if (ld_file_name == 0)
935 #ifdef REAL_LD_FILE_NAME
936 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
937 if (ld_file_name == 0)
939 /* Search the (target-specific) compiler dirs for ld'. */
940 ld_file_name = find_a_file (&cpath, real_ld_suffix);
941 /* Likewise for `collect-ld'. */
942 if (ld_file_name == 0)
943 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
944 /* Search the compiler directories for `ld'. We have protection against
945 recursive calls in find_a_file. */
946 if (ld_file_name == 0)
947 ld_file_name = find_a_file (&cpath, ld_suffix);
948 /* Search the ordinary system bin directories
949 for `ld' (if native linking) or `TARGET-ld' (if cross). */
950 if (ld_file_name == 0)
951 ld_file_name = find_a_file (&path, full_ld_suffix);
953 #ifdef REAL_NM_FILE_NAME
954 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
955 if (nm_file_name == 0)
957 nm_file_name = find_a_file (&cpath, gnm_suffix);
958 if (nm_file_name == 0)
959 nm_file_name = find_a_file (&path, full_gnm_suffix);
960 if (nm_file_name == 0)
961 nm_file_name = find_a_file (&cpath, nm_suffix);
962 if (nm_file_name == 0)
963 nm_file_name = find_a_file (&path, full_nm_suffix);
966 ldd_file_name = find_a_file (&cpath, ldd_suffix);
967 if (ldd_file_name == 0)
968 ldd_file_name = find_a_file (&path, full_ldd_suffix);
971 #ifdef REAL_STRIP_FILE_NAME
972 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
973 if (strip_file_name == 0)
975 strip_file_name = find_a_file (&cpath, gstrip_suffix);
976 if (strip_file_name == 0)
977 strip_file_name = find_a_file (&path, full_gstrip_suffix);
978 if (strip_file_name == 0)
979 strip_file_name = find_a_file (&cpath, strip_suffix);
980 if (strip_file_name == 0)
981 strip_file_name = find_a_file (&path, full_strip_suffix);
983 /* Determine the full path name of the C compiler to use. */
984 c_file_name = getenv ("COLLECT_GCC");
985 if (c_file_name == 0)
988 c_file_name = concat (target_machine, "-gcc", NULL);
994 p = find_a_file (&cpath, c_file_name);
996 /* Here it should be safe to use the system search path since we should have
997 already qualified the name of the compiler when it is needed. */
999 p = find_a_file (&path, c_file_name);
1004 *ld1++ = *ld2++ = ld_file_name;
1006 /* Make temp file names. */
1007 c_file = make_temp_file (".c");
1008 o_file = make_temp_file (".o");
1009 #ifdef COLLECT_EXPORT_LIST
1010 export_file = make_temp_file (".x");
1012 ldout = make_temp_file (".ld");
1013 *c_ptr++ = c_file_name;
1020 #ifdef COLLECT_EXPORT_LIST
1021 /* Generate a list of directories from LIBPATH. */
1022 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1023 /* Add to this list also two standard directories where
1024 AIX loader always searches for libraries. */
1025 add_prefix (&libpath_lib_dirs, "/lib");
1026 add_prefix (&libpath_lib_dirs, "/usr/lib");
1029 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1031 AIX support needs to know if -shared has been specified before
1032 parsing commandline arguments. */
1034 p = getenv ("COLLECT_GCC_OPTIONS");
1037 const char *q = extract_string (&p);
1038 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1039 *c_ptr++ = xstrdup (q);
1040 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1041 *c_ptr++ = xstrdup (q);
1042 if (strcmp (q, "-shared") == 0)
1044 if (*q == '-' && q[1] == 'B')
1046 *c_ptr++ = xstrdup (q);
1049 q = extract_string (&p);
1050 *c_ptr++ = xstrdup (q);
1054 obstack_free (&temporary_obstack, temporary_firstobj);
1055 *c_ptr++ = "-fno-profile-arcs";
1056 *c_ptr++ = "-fno-test-coverage";
1057 *c_ptr++ = "-fno-branch-probabilities";
1058 *c_ptr++ = "-fno-exceptions";
1061 /* !!! When GCC calls collect2,
1062 it does not know whether it is calling collect2 or ld.
1063 So collect2 cannot meaningfully understand any options
1064 except those ld understands.
1065 If you propose to make GCC pass some other option,
1066 just imagine what will happen if ld is really ld!!! */
1068 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1069 /* After the first file, put in the c++ rt0. */
1072 #ifdef HAVE_LD_DEMANGLE
1074 *ld1++ = *ld2++ = "--demangle";
1076 while ((arg = *++argv) != (char *) 0)
1078 *ld1++ = *ld2++ = arg;
1084 #ifdef COLLECT_EXPORT_LIST
1085 /* We want to disable automatic exports on AIX when user
1086 explicitly puts an export list in command line */
1088 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1090 else if (arg[2] == '6' && arg[3] == '4')
1096 if (!strcmp (arg, "-debug"))
1098 /* Already parsed. */
1107 /* place o_file BEFORE this argument! */
1113 #ifdef COLLECT_EXPORT_LIST
1115 /* Resolving full library name. */
1116 const char *s = resolve_lib_name (arg+2);
1118 /* Saving a full library name. */
1119 add_to_list (&libs, s);
1124 #ifdef COLLECT_EXPORT_LIST
1125 /* Saving directories where to search for libraries. */
1127 add_prefix (&cmdline_lib_dirs, arg+2);
1130 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1132 if (is_in_args (arg, (const char **) ld1_argv, ld1-1))
1135 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1140 output_file = *ld1++ = *ld2++ = *++argv;
1142 #ifdef SWITCHES_NEED_SPACES
1143 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1147 output_file = &arg[2];
1156 if (arg[2] == '\0' && do_collecting)
1158 /* We must strip after the nm run, otherwise C++ linking
1159 will not work. Thus we strip in the second ld run, or
1160 else with strip if there is no second ld run. */
1172 else if ((p = strrchr (arg, '.')) != (char *) 0
1173 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1174 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1175 || strcmp (p, ".obj") == 0))
1184 /* place o_file BEFORE this argument! */
1190 if (p[1] == 'o' || p[1] == 'l')
1192 #ifdef COLLECT_EXPORT_LIST
1193 /* libraries can be specified directly, i.e. without -l flag. */
1196 /* Saving a full library name. */
1197 add_to_list (&libs, arg);
1203 #ifdef COLLECT_EXPORT_LIST
1204 /* This is added only for debugging purposes. */
1207 fprintf (stderr, "List of libraries:\n");
1208 dump_list (stderr, "\t", libs.first);
1211 /* The AIX linker will discard static constructors in object files if
1212 nothing else in the file is referenced, so look at them first. */
1214 const char **export_object_lst = (const char **)object_lst;
1216 while (export_object_lst < object)
1217 scan_prog_file (*export_object_lst++, PASS_OBJ);
1220 struct id *list = libs.first;
1222 for (; list; list = list->next)
1223 scan_prog_file (list->name, PASS_FIRST);
1228 char *buf = concat ("-bE:", export_file, NULL);
1233 exportf = fopen (export_file, "w");
1234 if (exportf == (FILE *) 0)
1235 fatal_perror ("fopen %s", export_file);
1236 write_aix_file (exportf, exports.first);
1237 if (fclose (exportf))
1238 fatal_perror ("fclose %s", export_file);
1243 *c_ptr = *ld1 = *object = (char *) 0;
1247 notice ("collect2 version %s", version_string);
1248 #ifdef TARGET_VERSION
1251 fprintf (stderr, "\n");
1257 fprintf (stderr, "ld_file_name = %s\n",
1258 (ld_file_name ? ld_file_name : "not found"));
1259 fprintf (stderr, "c_file_name = %s\n",
1260 (c_file_name ? c_file_name : "not found"));
1261 fprintf (stderr, "nm_file_name = %s\n",
1262 (nm_file_name ? nm_file_name : "not found"));
1264 fprintf (stderr, "ldd_file_name = %s\n",
1265 (ldd_file_name ? ldd_file_name : "not found"));
1267 fprintf (stderr, "strip_file_name = %s\n",
1268 (strip_file_name ? strip_file_name : "not found"));
1269 fprintf (stderr, "c_file = %s\n",
1270 (c_file ? c_file : "not found"));
1271 fprintf (stderr, "o_file = %s\n",
1272 (o_file ? o_file : "not found"));
1274 ptr = getenv ("COLLECT_GCC_OPTIONS");
1276 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1278 ptr = getenv ("COLLECT_GCC");
1280 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1282 ptr = getenv ("COMPILER_PATH");
1284 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1286 ptr = getenv (LIBRARY_PATH_ENV);
1288 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1290 fprintf (stderr, "\n");
1293 /* Load the program, searching all libraries and attempting to provide
1294 undefined symbols from repository information. */
1296 /* On AIX we do this later. */
1297 #ifndef COLLECT_EXPORT_LIST
1298 do_tlink (ld1_argv, object_lst);
1301 /* If -r or they will be run via some other method, do not build the
1302 constructor or destructor list, just return now. */
1304 #ifndef COLLECT_EXPORT_LIST
1309 #ifdef COLLECT_EXPORT_LIST
1310 /* Do the link we avoided above if we are exiting. */
1311 do_tlink (ld1_argv, object_lst);
1313 /* But make sure we delete the export file we may have created. */
1314 if (export_file != 0 && export_file[0])
1315 maybe_unlink (export_file);
1317 maybe_unlink (c_file);
1318 maybe_unlink (o_file);
1322 /* Examine the namelist with nm and search it for static constructors
1323 and destructors to call.
1324 Write the constructor and destructor tables to a .s file and reload. */
1326 /* On AIX we already scanned for global constructors/destructors. */
1327 #ifndef COLLECT_EXPORT_LIST
1328 scan_prog_file (output_file, PASS_FIRST);
1331 #ifdef SCAN_LIBRARIES
1332 scan_libraries (output_file);
1337 notice ("%d constructor(s) found\n", constructors.number);
1338 notice ("%d destructor(s) found\n", destructors.number);
1339 notice ("%d frame table(s) found\n", frame_tables.number);
1342 if (constructors.number == 0 && destructors.number == 0
1343 && frame_tables.number == 0
1344 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1345 /* If we will be running these functions ourselves, we want to emit
1346 stubs into the shared library so that we do not have to relink
1347 dependent programs when we add static objects. */
1352 #ifdef COLLECT_EXPORT_LIST
1353 /* Do tlink without additional code generation. */
1354 do_tlink (ld1_argv, object_lst);
1356 /* Strip now if it was requested on the command line. */
1359 char **real_strip_argv = xcalloc (sizeof (char *), 3);
1360 const char ** strip_argv = (const char **) real_strip_argv;
1362 strip_argv[0] = strip_file_name;
1363 strip_argv[1] = output_file;
1364 strip_argv[2] = (char *) 0;
1365 fork_execute ("strip", real_strip_argv);
1368 #ifdef COLLECT_EXPORT_LIST
1369 maybe_unlink (export_file);
1371 maybe_unlink (c_file);
1372 maybe_unlink (o_file);
1376 /* Sort ctor and dtor lists by priority. */
1377 sort_ids (&constructors);
1378 sort_ids (&destructors);
1380 maybe_unlink(output_file);
1381 outf = fopen (c_file, "w");
1382 if (outf == (FILE *) 0)
1383 fatal_perror ("fopen %s", c_file);
1385 write_c_file (outf, c_file);
1388 fatal_perror ("fclose %s", c_file);
1390 /* Tell the linker that we have initializer and finalizer functions. */
1391 #ifdef LD_INIT_SWITCH
1392 #ifdef COLLECT_EXPORT_LIST
1393 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1395 *ld2++ = LD_INIT_SWITCH;
1397 *ld2++ = LD_FINI_SWITCH;
1402 #ifdef COLLECT_EXPORT_LIST
1405 /* If we did not add export flag to link arguments before, add it to
1406 second link phase now. No new exports should have been added. */
1407 if (! exports.first)
1408 *ld2++ = concat ("-bE:", export_file, NULL);
1410 #ifndef LD_INIT_SWITCH
1411 add_to_list (&exports, initname);
1412 add_to_list (&exports, fininame);
1413 add_to_list (&exports, "_GLOBAL__DI");
1414 add_to_list (&exports, "_GLOBAL__DD");
1416 exportf = fopen (export_file, "w");
1417 if (exportf == (FILE *) 0)
1418 fatal_perror ("fopen %s", export_file);
1419 write_aix_file (exportf, exports.first);
1420 if (fclose (exportf))
1421 fatal_perror ("fclose %s", export_file);
1425 /* End of arguments to second link phase. */
1430 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1431 output_file, c_file);
1432 write_c_file (stderr, "stderr");
1433 fprintf (stderr, "========== end of c_file\n\n");
1434 #ifdef COLLECT_EXPORT_LIST
1435 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1436 write_aix_file (stderr, exports.first);
1437 fprintf (stderr, "========== end of export_file\n\n");
1441 /* Assemble the constructor and destructor tables.
1442 Link the tables in with the rest of the program. */
1444 fork_execute ("gcc", c_argv);
1445 #ifdef COLLECT_EXPORT_LIST
1446 /* On AIX we must call tlink because of possible templates resolution. */
1447 do_tlink (ld2_argv, object_lst);
1449 /* Otherwise, simply call ld because tlink is already done. */
1450 fork_execute ("ld", ld2_argv);
1452 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1453 constructors/destructors in shared libraries. */
1454 scan_prog_file (output_file, PASS_SECOND);
1457 maybe_unlink (c_file);
1458 maybe_unlink (o_file);
1460 #ifdef COLLECT_EXPORT_LIST
1461 maybe_unlink (export_file);
1468 /* Wait for a process to finish, and exit if a nonzero status is found. */
1471 collect_wait (const char *prog)
1475 pwait (pid, &status, 0);
1478 if (WIFSIGNALED (status))
1480 int sig = WTERMSIG (status);
1481 error ("%s terminated with signal %d [%s]%s",
1482 prog, sig, strsignal(sig),
1483 WCOREDUMP(status) ? ", core dumped" : "");
1484 collect_exit (FATAL_EXIT_CODE);
1487 if (WIFEXITED (status))
1488 return WEXITSTATUS (status);
1494 do_wait (const char *prog)
1496 int ret = collect_wait (prog);
1499 error ("%s returned %d exit status", prog, ret);
1505 /* Execute a program, and wait for the reply. */
1508 collect_execute (const char *prog, char **argv, const char *redir)
1512 int redir_handle = -1;
1513 int stdout_save = -1;
1514 int stderr_save = -1;
1522 fprintf (stderr, "%s", argv[0]);
1524 notice ("[cannot find %s]", prog);
1526 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1527 fprintf (stderr, " %s", str);
1529 fprintf (stderr, "\n");
1535 /* If we cannot find a program we need, complain error. Do this here
1536 since we might not end up needing something that we could not find. */
1539 fatal ("cannot find `%s'", prog);
1543 /* Open response file. */
1544 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT);
1546 /* Duplicate the stdout and stderr file handles
1547 so they can be restored later. */
1548 stdout_save = dup (STDOUT_FILENO);
1549 if (stdout_save == -1)
1550 fatal_perror ("redirecting stdout: %s", redir);
1551 stderr_save = dup (STDERR_FILENO);
1552 if (stderr_save == -1)
1553 fatal_perror ("redirecting stdout: %s", redir);
1555 /* Redirect stdout & stderr to our response file. */
1556 dup2 (redir_handle, STDOUT_FILENO);
1557 dup2 (redir_handle, STDERR_FILENO);
1560 pid = pexecute (argv[0], argv, argv[0], NULL, &errmsg_fmt, &errmsg_arg,
1561 (PEXECUTE_FIRST | PEXECUTE_LAST | PEXECUTE_SEARCH));
1565 /* Restore stdout and stderr to their previous settings. */
1566 dup2 (stdout_save, STDOUT_FILENO);
1567 dup2 (stderr_save, STDERR_FILENO);
1569 /* Close response file. */
1570 close (redir_handle);
1574 fatal_perror (errmsg_fmt, errmsg_arg);
1578 fork_execute (const char *prog, char **argv)
1580 collect_execute (prog, argv, NULL);
1584 /* Unlink a file unless we are debugging. */
1587 maybe_unlink (const char *file)
1592 notice ("[Leaving %s]\n", file);
1596 static long sequence_number = 0;
1598 /* Add a name to a linked list. */
1601 add_to_list (struct head *head_ptr, const char *name)
1603 struct id *newid = xcalloc (sizeof (struct id) + strlen (name), 1);
1605 strcpy (newid->name, name);
1607 if (head_ptr->first)
1608 head_ptr->last->next = newid;
1610 head_ptr->first = newid;
1612 /* Check for duplicate symbols. */
1613 for (p = head_ptr->first;
1614 strcmp (name, p->name) != 0;
1619 head_ptr->last->next = 0;
1624 newid->sequence = ++sequence_number;
1625 head_ptr->last = newid;
1629 /* Grab the init priority number from an init function name that
1630 looks like "_GLOBAL_.I.12345.foo". */
1633 extract_init_priority (const char *name)
1637 while (name[pos] == '_')
1639 pos += 10; /* strlen ("GLOBAL__X_") */
1641 /* Extract init_p number from ctor/dtor name. */
1642 pri = atoi (name + pos);
1643 return pri ? pri : DEFAULT_INIT_PRIORITY;
1646 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1647 ctors will be run from right to left, dtors from left to right. */
1650 sort_ids (struct head *head_ptr)
1652 /* id holds the current element to insert. id_next holds the next
1653 element to insert. id_ptr iterates through the already sorted elements
1654 looking for the place to insert id. */
1655 struct id *id, *id_next, **id_ptr;
1657 id = head_ptr->first;
1659 /* We don't have any sorted elements yet. */
1660 head_ptr->first = NULL;
1662 for (; id; id = id_next)
1665 id->sequence = extract_init_priority (id->name);
1667 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
1669 /* If the sequence numbers are the same, we put the id from the
1670 file later on the command line later in the list. */
1671 || id->sequence > (*id_ptr)->sequence
1672 /* Hack: do lexical compare, too.
1673 || (id->sequence == (*id_ptr)->sequence
1674 && strcmp (id->name, (*id_ptr)->name) > 0) */
1683 /* Now set the sequence numbers properly so write_c_file works. */
1684 for (id = head_ptr->first; id; id = id->next)
1685 id->sequence = ++sequence_number;
1688 /* Write: `prefix', the names on list LIST, `suffix'. */
1691 write_list (FILE *stream, const char *prefix, struct id *list)
1695 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1700 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1701 /* Given a STRING, return nonzero if it occurs in the list in range
1702 [ARGS_BEGIN,ARGS_END). */
1705 is_in_args (const char *string, const char **args_begin,
1706 const char **args_end)
1708 const char **args_pointer;
1709 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
1710 if (strcmp (string, *args_pointer) == 0)
1714 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1716 #ifdef COLLECT_EXPORT_LIST
1717 /* This function is really used only on AIX, but may be useful. */
1720 is_in_list (const char *prefix, struct id *list)
1724 if (!strcmp (prefix, list->name)) return 1;
1730 #endif /* COLLECT_EXPORT_LIST */
1732 /* Added for debugging purpose. */
1733 #ifdef COLLECT_EXPORT_LIST
1735 dump_list (FILE *stream, const char *prefix, struct id *list)
1739 fprintf (stream, "%s%s,\n", prefix, list->name);
1747 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
1751 fprintf (stream, "%s%s,\n", prefix, list->prefix);
1758 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
1762 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1763 prefix, list->sequence, list->name);
1768 /* Write out the constructor and destructor tables statically (for a shared
1769 object), along with the functions to execute them. */
1772 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
1776 int frames = (frame_tables.number > 0);
1778 /* Figure out name of output_file, stripping off .so version. */
1779 p = strrchr (output_file, '/');
1795 if (strncmp (q, ".so", 3) == 0)
1804 /* q points to null at end of the string (or . of the .so version) */
1805 prefix = xmalloc (q - p + 1);
1806 strncpy (prefix, p, q - p);
1808 for (r = prefix; *r; r++)
1809 if (!ISALNUM ((unsigned char)*r))
1812 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
1813 output_file, prefix);
1815 initname = concat ("_GLOBAL__FI_", prefix, NULL);
1816 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
1820 /* Write the tables as C code. */
1822 fprintf (stream, "static int count;\n");
1823 fprintf (stream, "typedef void entry_pt();\n");
1824 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1828 write_list_with_asm (stream, "extern void *", frame_tables.first);
1830 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1831 write_list (stream, "\t\t&", frame_tables.first);
1832 fprintf (stream, "\t0\n};\n");
1834 /* This must match what's in frame.h. */
1835 fprintf (stream, "struct object {\n");
1836 fprintf (stream, " void *pc_begin;\n");
1837 fprintf (stream, " void *pc_end;\n");
1838 fprintf (stream, " void *fde_begin;\n");
1839 fprintf (stream, " void *fde_array;\n");
1840 fprintf (stream, " __SIZE_TYPE__ count;\n");
1841 fprintf (stream, " struct object *next;\n");
1842 fprintf (stream, "};\n");
1844 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1845 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1847 fprintf (stream, "static void reg_frame () {\n");
1848 fprintf (stream, "\tstatic struct object ob;\n");
1849 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1850 fprintf (stream, "\t}\n");
1852 fprintf (stream, "static void dereg_frame () {\n");
1853 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1854 fprintf (stream, "\t}\n");
1857 fprintf (stream, "void %s() {\n", initname);
1858 if (constructors.number > 0 || frames)
1860 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1861 write_list (stream, "\t\t", constructors.first);
1863 fprintf (stream, "\treg_frame,\n");
1864 fprintf (stream, "\t};\n");
1865 fprintf (stream, "\tentry_pt **p;\n");
1866 fprintf (stream, "\tif (count++ != 0) return;\n");
1867 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1868 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1871 fprintf (stream, "\t++count;\n");
1872 fprintf (stream, "}\n");
1873 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1874 fprintf (stream, "void %s() {\n", fininame);
1875 if (destructors.number > 0 || frames)
1877 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1878 write_list (stream, "\t\t", destructors.first);
1880 fprintf (stream, "\tdereg_frame,\n");
1881 fprintf (stream, "\t};\n");
1882 fprintf (stream, "\tentry_pt **p;\n");
1883 fprintf (stream, "\tif (--count != 0) return;\n");
1884 fprintf (stream, "\tp = dtors;\n");
1885 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1886 destructors.number + frames);
1888 fprintf (stream, "}\n");
1892 COLLECT_SHARED_INIT_FUNC(stream, initname);
1893 COLLECT_SHARED_FINI_FUNC(stream, fininame);
1897 /* Write the constructor/destructor tables. */
1899 #ifndef LD_INIT_SWITCH
1901 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
1903 /* Write the tables as C code. */
1905 int frames = (frame_tables.number > 0);
1907 fprintf (stream, "typedef void entry_pt();\n\n");
1909 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1913 write_list_with_asm (stream, "extern void *", frame_tables.first);
1915 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1916 write_list (stream, "\t\t&", frame_tables.first);
1917 fprintf (stream, "\t0\n};\n");
1919 /* This must match what's in frame.h. */
1920 fprintf (stream, "struct object {\n");
1921 fprintf (stream, " void *pc_begin;\n");
1922 fprintf (stream, " void *pc_end;\n");
1923 fprintf (stream, " void *fde_begin;\n");
1924 fprintf (stream, " void *fde_array;\n");
1925 fprintf (stream, " __SIZE_TYPE__ count;\n");
1926 fprintf (stream, " struct object *next;\n");
1927 fprintf (stream, "};\n");
1929 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1930 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1932 fprintf (stream, "static void reg_frame () {\n");
1933 fprintf (stream, "\tstatic struct object ob;\n");
1934 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1935 fprintf (stream, "\t}\n");
1937 fprintf (stream, "static void dereg_frame () {\n");
1938 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1939 fprintf (stream, "\t}\n");
1942 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
1943 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
1944 write_list (stream, "\t", constructors.first);
1946 fprintf (stream, "\treg_frame,\n");
1947 fprintf (stream, "\t0\n};\n\n");
1949 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1951 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
1952 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
1953 write_list (stream, "\t", destructors.first);
1955 fprintf (stream, "\tdereg_frame,\n");
1956 fprintf (stream, "\t0\n};\n\n");
1958 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
1959 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
1961 #endif /* ! LD_INIT_SWITCH */
1964 write_c_file (FILE *stream, const char *name)
1966 fprintf (stream, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
1967 #ifndef LD_INIT_SWITCH
1969 write_c_file_glob (stream, name);
1972 write_c_file_stat (stream, name);
1973 fprintf (stream, "#ifdef __cplusplus\n}\n#endif\n");
1976 #ifdef COLLECT_EXPORT_LIST
1978 write_aix_file (FILE *stream, struct id *list)
1980 for (; list; list = list->next)
1982 fputs (list->name, stream);
1983 putc ('\n', stream);
1988 #ifdef OBJECT_FORMAT_NONE
1990 /* Generic version to scan the name list of the loaded program for
1991 the symbols g++ uses for static constructors and destructors.
1993 The constructor table begins at __CTOR_LIST__ and contains a count
1994 of the number of pointers (or -1 if the constructors are built in a
1995 separate section by the linker), followed by the pointers to the
1996 constructor functions, terminated with a null pointer. The
1997 destructor table has the same format, and begins at __DTOR_LIST__. */
2000 scan_prog_file (const char *prog_name, enum pass which_pass)
2002 void (*int_handler) (int);
2003 void (*quit_handler) (int);
2004 char *real_nm_argv[4];
2005 const char **nm_argv = (const char **) real_nm_argv;
2011 if (which_pass == PASS_SECOND)
2014 /* If we do not have an `nm', complain. */
2015 if (nm_file_name == 0)
2016 fatal ("cannot find `nm'");
2018 nm_argv[argc++] = nm_file_name;
2019 if (NM_FLAGS[0] != '\0')
2020 nm_argv[argc++] = NM_FLAGS;
2022 nm_argv[argc++] = prog_name;
2023 nm_argv[argc++] = (char *) 0;
2025 if (pipe (pipe_fd) < 0)
2026 fatal_perror ("pipe");
2028 inf = fdopen (pipe_fd[0], "r");
2029 if (inf == (FILE *) 0)
2030 fatal_perror ("fdopen");
2032 /* Trace if needed. */
2035 const char **p_argv;
2038 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2039 fprintf (stderr, " %s", str);
2041 fprintf (stderr, "\n");
2047 /* Spawn child nm on pipe. */
2050 fatal_perror (VFORK_STRING);
2052 if (pid == 0) /* child context */
2055 if (dup2 (pipe_fd[1], 1) < 0)
2056 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2058 if (close (pipe_fd[0]) < 0)
2059 fatal_perror ("close %d", pipe_fd[0]);
2061 if (close (pipe_fd[1]) < 0)
2062 fatal_perror ("close %d", pipe_fd[1]);
2064 execv (nm_file_name, real_nm_argv);
2065 fatal_perror ("execv %s", nm_file_name);
2068 /* Parent context from here on. */
2069 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2071 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2074 if (close (pipe_fd[1]) < 0)
2075 fatal_perror ("close %d", pipe_fd[1]);
2078 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2080 /* Read each line of nm output. */
2081 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2086 /* If it contains a constructor or destructor name, add the name
2087 to the appropriate list. */
2089 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2090 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2097 /* Find the end of the symbol name.
2098 Do not include `|', because Encore nm can tack that on the end. */
2099 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2105 switch (is_ctor_dtor (name))
2108 if (which_pass != PASS_LIB)
2109 add_to_list (&constructors, name);
2113 if (which_pass != PASS_LIB)
2114 add_to_list (&destructors, name);
2118 if (which_pass != PASS_LIB)
2119 fatal ("init function found in object %s", prog_name);
2120 #ifndef LD_INIT_SWITCH
2121 add_to_list (&constructors, name);
2126 if (which_pass != PASS_LIB)
2127 fatal ("fini function found in object %s", prog_name);
2128 #ifndef LD_FINI_SWITCH
2129 add_to_list (&destructors, name);
2134 if (which_pass != PASS_LIB)
2135 add_to_list (&frame_tables, name);
2138 default: /* not a constructor or destructor */
2143 fprintf (stderr, "\t%s\n", buf);
2147 fprintf (stderr, "\n");
2149 if (fclose (inf) != 0)
2150 fatal_perror ("fclose");
2152 do_wait (nm_file_name);
2154 signal (SIGINT, int_handler);
2156 signal (SIGQUIT, quit_handler);
2162 /* Use the List Dynamic Dependencies program to find shared libraries that
2163 the output file depends upon and their initialization/finalization
2164 routines, if any. */
2167 scan_libraries (const char *prog_name)
2169 static struct head libraries; /* list of shared libraries found */
2171 void (*int_handler) (int);
2172 void (*quit_handler) (int);
2173 char *real_ldd_argv[4];
2174 const char **ldd_argv = (const char **) real_ldd_argv;
2180 /* If we do not have an `ldd', complain. */
2181 if (ldd_file_name == 0)
2183 error ("cannot find `ldd'");
2187 ldd_argv[argc++] = ldd_file_name;
2188 ldd_argv[argc++] = prog_name;
2189 ldd_argv[argc++] = (char *) 0;
2191 if (pipe (pipe_fd) < 0)
2192 fatal_perror ("pipe");
2194 inf = fdopen (pipe_fd[0], "r");
2195 if (inf == (FILE *) 0)
2196 fatal_perror ("fdopen");
2198 /* Trace if needed. */
2201 const char **p_argv;
2204 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2205 fprintf (stderr, " %s", str);
2207 fprintf (stderr, "\n");
2213 /* Spawn child ldd on pipe. */
2216 fatal_perror (VFORK_STRING);
2218 if (pid == 0) /* child context */
2221 if (dup2 (pipe_fd[1], 1) < 0)
2222 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2224 if (close (pipe_fd[0]) < 0)
2225 fatal_perror ("close %d", pipe_fd[0]);
2227 if (close (pipe_fd[1]) < 0)
2228 fatal_perror ("close %d", pipe_fd[1]);
2230 execv (ldd_file_name, real_ldd_argv);
2231 fatal_perror ("execv %s", ldd_file_name);
2234 /* Parent context from here on. */
2235 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2237 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2240 if (close (pipe_fd[1]) < 0)
2241 fatal_perror ("close %d", pipe_fd[1]);
2244 notice ("\nldd output with constructors/destructors.\n");
2246 /* Read each line of ldd output. */
2247 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2250 char *name, *end, *p = buf;
2252 /* Extract names of libraries and add to list. */
2253 PARSE_LDD_OUTPUT (p);
2258 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2259 fatal ("dynamic dependency %s not found", buf);
2261 /* Find the end of the symbol name. */
2263 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2268 if (access (name, R_OK) == 0)
2269 add_to_list (&libraries, name);
2271 fatal ("unable to open dynamic dependency '%s'", buf);
2274 fprintf (stderr, "\t%s\n", buf);
2277 fprintf (stderr, "\n");
2279 if (fclose (inf) != 0)
2280 fatal_perror ("fclose");
2282 do_wait (ldd_file_name);
2284 signal (SIGINT, int_handler);
2286 signal (SIGQUIT, quit_handler);
2289 /* Now iterate through the library list adding their symbols to
2291 for (list = libraries.first; list; list = list->next)
2292 scan_prog_file (list->name, PASS_LIB);
2295 #endif /* LDD_SUFFIX */
2297 #endif /* OBJECT_FORMAT_NONE */
2301 * COFF specific stuff.
2304 #ifdef OBJECT_FORMAT_COFF
2306 #if defined (EXTENDED_COFF)
2308 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2309 # define GCC_SYMENT SYMR
2310 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2311 # define GCC_SYMINC(X) (1)
2312 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2313 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2317 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2318 # define GCC_SYMENT SYMENT
2319 # if defined (C_WEAKEXT)
2320 # define GCC_OK_SYMBOL(X) \
2321 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2322 ((X).n_scnum > N_UNDEF) && \
2324 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2325 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2326 # define GCC_UNDEF_SYMBOL(X) \
2327 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2328 ((X).n_scnum == N_UNDEF))
2330 # define GCC_OK_SYMBOL(X) \
2331 (((X).n_sclass == C_EXT) && \
2332 ((X).n_scnum > N_UNDEF) && \
2334 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2335 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2336 # define GCC_UNDEF_SYMBOL(X) \
2337 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2339 # define GCC_SYMINC(X) ((X).n_numaux+1)
2340 # define GCC_SYMZERO(X) 0
2342 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2344 # define GCC_CHECK_HDR(X) \
2345 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2346 || (HEADER (X).f_magic == 0767 && aix64_flag))
2348 # define GCC_CHECK_HDR(X) \
2349 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2350 || (HEADER (X).f_magic == 0757 && aix64_flag))
2355 #ifdef COLLECT_EXPORT_LIST
2356 /* Array of standard AIX libraries which should not
2357 be scanned for ctors/dtors. */
2358 static const char *const aix_std_libs[] = {
2366 "/usr/lib/libc_r.a",
2367 "/usr/lib/libm_r.a",
2368 "/usr/lib/threads/libc.a",
2369 "/usr/ccs/lib/libc.a",
2370 "/usr/ccs/lib/libm.a",
2371 "/usr/ccs/lib/libc_r.a",
2372 "/usr/ccs/lib/libm_r.a",
2376 /* This function checks the filename and returns 1
2377 if this name matches the location of a standard AIX library. */
2378 static int ignore_library (const char *);
2380 ignore_library (const char *name)
2382 const char *const *p = &aix_std_libs[0];
2383 while (*p++ != NULL)
2384 if (! strcmp (name, *p)) return 1;
2387 #endif /* COLLECT_EXPORT_LIST */
2389 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2390 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2393 /* COFF version to scan the name list of the loaded program for
2394 the symbols g++ uses for static constructors and destructors.
2396 The constructor table begins at __CTOR_LIST__ and contains a count
2397 of the number of pointers (or -1 if the constructors are built in a
2398 separate section by the linker), followed by the pointers to the
2399 constructor functions, terminated with a null pointer. The
2400 destructor table has the same format, and begins at __DTOR_LIST__. */
2403 scan_prog_file (const char *prog_name, enum pass which_pass)
2405 LDFILE *ldptr = NULL;
2406 int sym_index, sym_count;
2409 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2412 #ifdef COLLECT_EXPORT_LIST
2413 /* We do not need scanning for some standard C libraries. */
2414 if (which_pass == PASS_FIRST && ignore_library (prog_name))
2417 /* On AIX we have a loop, because there is not much difference
2418 between an object and an archive. This trick allows us to
2419 eliminate scan_libraries() function. */
2423 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2424 non-const char * filename parameter, even though it will not
2425 modify that string. So we must cast away const-ness here,
2426 which will cause -Wcast-qual to burp. */
2427 if ((ldptr = ldopen ((char *)prog_name, ldptr)) != NULL)
2429 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2430 fatal ("%s: not a COFF file", prog_name);
2432 if (GCC_CHECK_HDR (ldptr))
2434 sym_count = GCC_SYMBOLS (ldptr);
2435 sym_index = GCC_SYMZERO (ldptr);
2437 #ifdef COLLECT_EXPORT_LIST
2438 /* Is current archive member a shared object? */
2439 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2442 while (sym_index < sym_count)
2446 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2448 sym_index += GCC_SYMINC (symbol);
2450 if (GCC_OK_SYMBOL (symbol))
2454 if ((name = ldgetname (ldptr, &symbol)) == NULL)
2455 continue; /* Should never happen. */
2457 #ifdef XCOFF_DEBUGGING_INFO
2458 /* All AIX function names have a duplicate entry
2459 beginning with a dot. */
2464 switch (is_ctor_dtor (name))
2468 add_to_list (&constructors, name);
2469 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2470 if (which_pass == PASS_OBJ)
2471 add_to_list (&exports, name);
2477 add_to_list (&destructors, name);
2478 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2479 if (which_pass == PASS_OBJ)
2480 add_to_list (&exports, name);
2484 #ifdef COLLECT_EXPORT_LIST
2486 #ifndef LD_INIT_SWITCH
2488 add_to_list (&constructors, name);
2493 #ifndef LD_INIT_SWITCH
2495 add_to_list (&destructors, name);
2502 add_to_list (&frame_tables, name);
2503 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2504 if (which_pass == PASS_OBJ)
2505 add_to_list (&exports, name);
2509 default: /* not a constructor or destructor */
2510 #ifdef COLLECT_EXPORT_LIST
2511 /* Explicitly export all global symbols when
2512 building a shared object on AIX, but do not
2513 re-export symbols from another shared object
2514 and do not export symbols if the user
2515 provides an explicit export list. */
2516 if (shared_obj && !is_shared
2517 && which_pass == PASS_OBJ && !export_flag)
2518 add_to_list (&exports, name);
2524 #if !defined(EXTENDED_COFF)
2525 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2526 symbol.n_scnum, symbol.n_sclass,
2527 (symbol.n_type ? "0" : ""), symbol.n_type,
2531 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2532 symbol.iss, (long) symbol.value, symbol.index, name);
2537 #ifdef COLLECT_EXPORT_LIST
2540 /* If archive contains both 32-bit and 64-bit objects,
2541 we want to skip objects in other mode so mismatch normal. */
2543 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
2544 prog_name, HEADER (ldptr).f_magic, aix64_flag);
2550 fatal ("%s: cannot open as COFF file", prog_name);
2552 #ifdef COLLECT_EXPORT_LIST
2553 /* On AIX loop continues while there are more members in archive. */
2555 while (ldclose (ldptr) == FAILURE);
2557 /* Otherwise we simply close ldptr. */
2558 (void) ldclose(ldptr);
2561 #endif /* OBJECT_FORMAT_COFF */
2563 #ifdef COLLECT_EXPORT_LIST
2564 /* Given a library name without "lib" prefix, this function
2565 returns a full library name including a path. */
2567 resolve_lib_name (const char *name)
2572 for (i = 0; libpaths[i]; i++)
2573 if (libpaths[i]->max_len > l)
2574 l = libpaths[i]->max_len;
2576 lib_buf = xmalloc (l + strlen(name) + 10);
2578 for (i = 0; libpaths[i]; i++)
2580 struct prefix_list *list = libpaths[i]->plist;
2581 for (; list; list = list->next)
2583 /* The following lines are needed because path_prefix list
2584 may contain directories both with trailing '/' and
2587 if (list->prefix[strlen(list->prefix)-1] != '/')
2589 for (j = 0; libexts[j]; j++)
2591 sprintf (lib_buf, "%s%slib%s.%s",
2592 list->prefix, p, name, libexts[j]);
2593 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2594 if (file_exists (lib_buf))
2596 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2603 fprintf (stderr, "not found\n");
2605 fatal ("library lib%s not found", name);
2608 #endif /* COLLECT_EXPORT_LIST */