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 SUNOS4_SHARED_LIBRARIES
71 #undef OBJECT_FORMAT_COFF
73 #undef REAL_LD_FILE_NAME
74 #undef REAL_NM_FILE_NAME
75 #undef REAL_STRIP_FILE_NAME
78 /* If we cannot use a special method, use the ordinary one:
79 run nm to find what symbols are present.
80 In a cross-compiler, this means you need a cross nm,
81 but that is not quite as unpleasant as special headers. */
83 #if !defined (OBJECT_FORMAT_COFF)
84 #define OBJECT_FORMAT_NONE
87 #ifdef OBJECT_FORMAT_COFF
96 /* Many versions of ldfcn.h define these. */
104 /* Some systems have an ISCOFF macro, but others do not. In some cases
105 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
106 that either do not have an ISCOFF macro in /usr/include or for those
107 where it is wrong. */
110 #define MY_ISCOFF(X) ISCOFF (X)
113 #endif /* OBJECT_FORMAT_COFF */
115 #ifdef OBJECT_FORMAT_NONE
117 /* Default flags to pass to nm. */
119 #define NM_FLAGS "-n"
122 #endif /* OBJECT_FORMAT_NONE */
124 /* Some systems use __main in a way incompatible with its use in gcc, in these
125 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
126 give the same symbol without quotes for an alternative entry point. */
128 #define NAME__MAIN "__main"
131 /* This must match tree.h. */
132 #define DEFAULT_INIT_PRIORITY 65535
134 #ifndef COLLECT_SHARED_INIT_FUNC
135 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
136 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
138 #ifndef COLLECT_SHARED_FINI_FUNC
139 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
140 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
143 #if defined (LDD_SUFFIX) || SUNOS4_SHARED_LIBRARIES
144 #define SCAN_LIBRARIES
148 int do_collecting = 1;
150 int do_collecting = 0;
153 #ifndef COLLECT_PARSE_FLAG
154 #define COLLECT_PARSE_FLAG(FLAG)
157 /* Nonzero if we should suppress the automatic demangling of identifiers
158 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
161 /* Linked lists of constructor and destructor names. */
177 /* Enumeration giving which pass this is for scanning the program file. */
180 PASS_FIRST, /* without constructors */
181 PASS_OBJ, /* individual objects */
182 PASS_LIB, /* looking for shared libraries */
183 PASS_SECOND /* with constructors linked in */
186 int vflag; /* true if -v */
187 static int rflag; /* true if -r */
188 static int strip_flag; /* true if -s */
189 #ifdef COLLECT_EXPORT_LIST
190 static int export_flag; /* true if -bE */
191 static int aix64_flag; /* true if -b64 */
194 int debug; /* true if -debug */
196 static int shared_obj; /* true if -shared */
198 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
199 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
200 #ifdef COLLECT_EXPORT_LIST
201 static const char *export_file; /* <xxx>.x for AIX export list. */
203 const char *ldout; /* File for ld errors. */
204 static const char *output_file; /* Output file for ld. */
205 static const char *nm_file_name; /* pathname of nm */
207 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
209 static const char *strip_file_name; /* pathname of strip */
210 const char *c_file_name; /* pathname of gcc */
211 static char *initname, *fininame; /* names of init and fini funcs */
213 static struct head constructors; /* list of constructors found */
214 static struct head destructors; /* list of destructors found */
215 #ifdef COLLECT_EXPORT_LIST
216 static struct head exports; /* list of exported symbols */
218 static struct head frame_tables; /* list of frame unwind info tables */
220 struct obstack temporary_obstack;
221 char * temporary_firstobj;
223 /* Holds the return value of pexecute and fork. */
226 /* Structure to hold all the directories in which to search for files to
231 const char *prefix; /* String to prepend to the path. */
232 struct prefix_list *next; /* Next in linked list. */
237 struct prefix_list *plist; /* List of prefixes to try */
238 int max_len; /* Max length of a prefix in PLIST */
239 const char *name; /* Name of this list (used in config stuff) */
242 #ifdef COLLECT_EXPORT_LIST
243 /* Lists to keep libraries to be scanned for global constructors/destructors. */
244 static struct head libs; /* list of libraries */
245 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
246 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
247 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
248 &libpath_lib_dirs, NULL};
249 static const char *const libexts[3] = {"a", "so", NULL}; /* possible library extensions */
252 static void handler (int);
253 static int is_ctor_dtor (const char *);
254 static char *find_a_file (struct path_prefix *, const char *);
255 static void add_prefix (struct path_prefix *, const char *);
256 static void prefix_from_env (const char *, struct path_prefix *);
257 static void prefix_from_string (const char *, struct path_prefix *);
258 static void do_wait (const char *);
259 static void fork_execute (const char *, char **);
260 static void maybe_unlink (const char *);
261 static void add_to_list (struct head *, const char *);
262 static int extract_init_priority (const char *);
263 static void sort_ids (struct head *);
264 static void write_list (FILE *, const char *, struct id *);
265 #ifdef COLLECT_EXPORT_LIST
266 static void dump_list (FILE *, const char *, struct id *);
269 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
271 static void write_list_with_asm (FILE *, const char *, struct id *);
272 static void write_c_file (FILE *, const char *);
273 static void write_c_file_stat (FILE *, const char *);
274 #ifndef LD_INIT_SWITCH
275 static void write_c_file_glob (FILE *, const char *);
277 static void scan_prog_file (const char *, enum pass);
278 #ifdef SCAN_LIBRARIES
279 static void scan_libraries (const char *);
281 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
282 static int is_in_args (const char *, const char **, const char **);
284 #ifdef COLLECT_EXPORT_LIST
286 static int is_in_list (const char *, struct id *);
288 static void write_aix_file (FILE *, struct id *);
289 static char *resolve_lib_name (const char *);
291 static char *extract_string (const char **);
295 dup2 (int oldfd, int newfd)
304 while ((fd = dup (oldfd)) != newfd && fd >= 0) /* good enough for low fd's */
307 close (fdtmp[--fdx]);
311 #endif /* ! HAVE_DUP2 */
313 /* Delete tempfiles and exit function. */
316 collect_exit (int status)
318 if (c_file != 0 && c_file[0])
319 maybe_unlink (c_file);
321 if (o_file != 0 && o_file[0])
322 maybe_unlink (o_file);
324 #ifdef COLLECT_EXPORT_LIST
325 if (export_file != 0 && export_file[0])
326 maybe_unlink (export_file);
329 if (ldout != 0 && ldout[0])
332 maybe_unlink (ldout);
335 if (status != 0 && output_file != 0 && output_file[0])
336 maybe_unlink (output_file);
342 /* Notify user of a non-error. */
344 notice (const char *msgid, ...)
348 va_start (ap, msgid);
349 vfprintf (stderr, _(msgid), ap);
353 /* Die when sys call fails. */
356 fatal_perror (const char * msgid, ...)
361 va_start (ap, msgid);
362 fprintf (stderr, "collect2: ");
363 vfprintf (stderr, _(msgid), ap);
364 fprintf (stderr, ": %s\n", xstrerror (e));
367 collect_exit (FATAL_EXIT_CODE);
373 fatal (const char * msgid, ...)
377 va_start (ap, msgid);
378 fprintf (stderr, "collect2: ");
379 vfprintf (stderr, _(msgid), ap);
380 fprintf (stderr, "\n");
383 collect_exit (FATAL_EXIT_CODE);
386 /* Write error message. */
389 error (const char * msgid, ...)
393 va_start (ap, msgid);
394 fprintf (stderr, "collect2: ");
395 vfprintf (stderr, _(msgid), ap);
396 fprintf (stderr, "\n");
400 /* In case obstack is linked in, and abort is defined to fancy_abort,
401 provide a default entry. */
406 fatal ("internal error");
412 if (c_file != 0 && c_file[0])
413 maybe_unlink (c_file);
415 if (o_file != 0 && o_file[0])
416 maybe_unlink (o_file);
418 if (ldout != 0 && ldout[0])
419 maybe_unlink (ldout);
421 #ifdef COLLECT_EXPORT_LIST
422 if (export_file != 0 && export_file[0])
423 maybe_unlink (export_file);
426 signal (signo, SIG_DFL);
427 kill (getpid (), signo);
432 file_exists (const char *name)
434 return access (name, R_OK) == 0;
437 /* Parse a reasonable subset of shell quoting syntax. */
440 extract_string (const char **pp)
453 obstack_1grow (&temporary_obstack, c);
454 else if (! inside && c == ' ')
456 else if (! inside && c == '\\')
461 obstack_1grow (&temporary_obstack, c);
464 obstack_1grow (&temporary_obstack, '\0');
466 return obstack_finish (&temporary_obstack);
470 dump_file (const char *name)
472 FILE *stream = fopen (name, "r");
479 while (c = getc (stream),
480 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
481 obstack_1grow (&temporary_obstack, c);
482 if (obstack_object_size (&temporary_obstack) > 0)
484 const char *word, *p;
486 obstack_1grow (&temporary_obstack, '\0');
487 word = obstack_finish (&temporary_obstack);
490 ++word, putc ('.', stderr);
492 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
493 p += strlen (USER_LABEL_PREFIX);
498 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
503 fputs (result, stderr);
505 diff = strlen (word) - strlen (result);
506 while (diff > 0 && c == ' ')
507 --diff, putc (' ', stderr);
508 while (diff < 0 && c == ' ')
509 ++diff, c = getc (stream);
514 fputs (word, stderr);
517 obstack_free (&temporary_obstack, temporary_firstobj);
526 /* Decide whether the given symbol is: a constructor (1), a destructor
527 (2), a routine in a shared object that calls all the constructors
528 (3) or destructors (4), a DWARF exception-handling table (5), or
529 nothing special (0). */
532 is_ctor_dtor (const char *s)
534 struct names { const char *const name; const int len; const int ret;
535 const int two_underscores; };
537 const struct names *p;
539 const char *orig_s = s;
541 static const struct names special[] = {
542 #ifndef NO_DOLLAR_IN_LABEL
543 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, 1, 0 },
544 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, 2, 0 },
546 #ifndef NO_DOT_IN_LABEL
547 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, 1, 0 },
548 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, 2, 0 },
549 #endif /* NO_DOT_IN_LABEL */
550 #endif /* NO_DOLLAR_IN_LABEL */
551 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
552 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
553 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, 5, 0 },
554 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
555 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
559 while ((ch = *s) == '_')
565 for (p = &special[0]; p->len > 0; p++)
568 && (!p->two_underscores || ((s - orig_s) >= 2))
569 && strncmp(s, p->name, p->len) == 0)
577 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
578 and one from the PATH variable. */
580 static struct path_prefix cpath, path;
583 /* This is the name of the target machine. We use it to form the name
584 of the files to execute. */
586 static const char *const target_machine = TARGET_MACHINE;
589 /* Search for NAME using prefix list PPREFIX. We only look for executable
592 Return 0 if not found, otherwise return its name, allocated with malloc. */
595 find_a_file (struct path_prefix *pprefix, const char *name)
598 struct prefix_list *pl;
599 int len = pprefix->max_len + strlen (name) + 1;
602 fprintf (stderr, "Looking for '%s'\n", name);
604 #ifdef HOST_EXECUTABLE_SUFFIX
605 len += strlen (HOST_EXECUTABLE_SUFFIX);
608 temp = xmalloc (len);
610 /* Determine the filename to execute (special case for absolute paths). */
613 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
614 || (*name && name[1] == ':')
618 if (access (name, X_OK) == 0)
623 fprintf (stderr, " - found: absolute path\n");
628 #ifdef HOST_EXECUTABLE_SUFFIX
629 /* Some systems have a suffix for executable files.
630 So try appending that. */
632 strcat (temp, HOST_EXECUTABLE_SUFFIX);
634 if (access (temp, X_OK) == 0)
639 fprintf (stderr, " - failed to locate using absolute path\n");
642 for (pl = pprefix->plist; pl; pl = pl->next)
646 strcpy (temp, pl->prefix);
649 if (stat (temp, &st) >= 0
650 && ! S_ISDIR (st.st_mode)
651 && access (temp, X_OK) == 0)
654 #ifdef HOST_EXECUTABLE_SUFFIX
655 /* Some systems have a suffix for executable files.
656 So try appending that. */
657 strcat (temp, HOST_EXECUTABLE_SUFFIX);
659 if (stat (temp, &st) >= 0
660 && ! S_ISDIR (st.st_mode)
661 && access (temp, X_OK) == 0)
666 if (debug && pprefix->plist == NULL)
667 fprintf (stderr, " - failed: no entries in prefix list\n");
673 /* Add an entry for PREFIX to prefix list PPREFIX. */
676 add_prefix (struct path_prefix *pprefix, const char *prefix)
678 struct prefix_list *pl, **prev;
683 for (pl = pprefix->plist; pl->next; pl = pl->next)
688 prev = &pprefix->plist;
690 /* Keep track of the longest prefix. */
692 len = strlen (prefix);
693 if (len > pprefix->max_len)
694 pprefix->max_len = len;
696 pl = xmalloc (sizeof (struct prefix_list));
697 pl->prefix = xstrdup (prefix);
702 pl->next = (struct prefix_list *) 0;
706 /* Take the value of the environment variable ENV, break it into a path, and
707 add of the entries to PPREFIX. */
710 prefix_from_env (const char *env, struct path_prefix *pprefix)
713 GET_ENVIRONMENT (p, env);
716 prefix_from_string (p, pprefix);
720 prefix_from_string (const char *p, struct path_prefix *pprefix)
722 const char *startp, *endp;
723 char *nstore = xmalloc (strlen (p) + 3);
726 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
731 if (*endp == PATH_SEPARATOR || *endp == 0)
733 strncpy (nstore, startp, endp-startp);
736 strcpy (nstore, "./");
738 else if (! IS_DIR_SEPARATOR (endp[-1]))
740 nstore[endp-startp] = DIR_SEPARATOR;
741 nstore[endp-startp+1] = 0;
744 nstore[endp-startp] = 0;
747 fprintf (stderr, " - add prefix: %s\n", nstore);
749 add_prefix (pprefix, nstore);
752 endp = startp = endp + 1;
762 main (int argc, char **argv)
764 static const char *const ld_suffix = "ld";
765 static const char *const real_ld_suffix = "real-ld";
766 static const char *const collect_ld_suffix = "collect-ld";
767 static const char *const nm_suffix = "nm";
768 static const char *const gnm_suffix = "gnm";
770 static const char *const ldd_suffix = LDD_SUFFIX;
772 static const char *const strip_suffix = "strip";
773 static const char *const gstrip_suffix = "gstrip";
776 /* If we look for a program in the compiler directories, we just use
777 the short name, since these directories are already system-specific.
778 But it we look for a program in the system directories, we need to
779 qualify the program name with the target machine. */
781 const char *const full_ld_suffix =
782 concat(target_machine, "-", ld_suffix, NULL);
783 const char *const full_nm_suffix =
784 concat (target_machine, "-", nm_suffix, NULL);
785 const char *const full_gnm_suffix =
786 concat (target_machine, "-", gnm_suffix, NULL);
788 const char *const full_ldd_suffix =
789 concat (target_machine, "-", ldd_suffix, NULL);
791 const char *const full_strip_suffix =
792 concat (target_machine, "-", strip_suffix, NULL);
793 const char *const full_gstrip_suffix =
794 concat (target_machine, "-", gstrip_suffix, NULL);
796 const char *const full_ld_suffix = ld_suffix;
797 const char *const full_nm_suffix = nm_suffix;
798 const char *const full_gnm_suffix = gnm_suffix;
800 const char *const full_ldd_suffix = ldd_suffix;
802 const char *const full_strip_suffix = strip_suffix;
803 const char *const full_gstrip_suffix = gstrip_suffix;
804 #endif /* CROSS_COMPILE */
808 #ifdef COLLECT_EXPORT_LIST
811 const char *ld_file_name;
822 int num_c_args = argc+9;
824 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
826 /* Suppress demangling by the real linker, which may be broken. */
827 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
829 #if defined (COLLECT2_HOST_INITIALIZATION)
830 /* Perform system dependent initialization, if necessary. */
831 COLLECT2_HOST_INITIALIZATION;
835 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
836 receive the signal. A different setting is inheritable */
837 signal (SIGCHLD, SIG_DFL);
842 /* Do not invoke xcalloc before this point, since locale needs to be
843 set first, in case a diagnostic is issued. */
845 ld1 = (const char **)(ld1_argv = xcalloc(sizeof (char *), argc+3));
846 ld2 = (const char **)(ld2_argv = xcalloc(sizeof (char *), argc+10));
847 object = (const char **)(object_lst = xcalloc(sizeof (char *), argc));
853 /* Parse command line early for instances of -debug. This allows
854 the debug flag to be set before functions like find_a_file()
859 for (i = 1; argv[i] != NULL; i ++)
861 if (! strcmp (argv[i], "-debug"))
863 COLLECT_PARSE_FLAG (argv[i]);
868 #ifndef DEFAULT_A_OUT_NAME
869 output_file = "a.out";
871 output_file = DEFAULT_A_OUT_NAME;
874 obstack_begin (&temporary_obstack, 0);
875 temporary_firstobj = obstack_alloc (&temporary_obstack, 0);
877 current_demangling_style = auto_demangling;
878 p = getenv ("COLLECT_GCC_OPTIONS");
881 const char *q = extract_string (&p);
882 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
885 obstack_free (&temporary_obstack, temporary_firstobj);
887 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
888 -fno-exceptions -w */
891 c_ptr = (const char **) (c_argv = xcalloc (sizeof (char *), num_c_args));
894 fatal ("no arguments");
897 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
898 signal (SIGQUIT, handler);
900 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
901 signal (SIGINT, handler);
903 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
904 signal (SIGALRM, handler);
907 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
908 signal (SIGHUP, handler);
910 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
911 signal (SIGSEGV, handler);
913 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
914 signal (SIGBUS, handler);
917 /* Extract COMPILER_PATH and PATH into our prefix list. */
918 prefix_from_env ("COMPILER_PATH", &cpath);
919 prefix_from_env ("PATH", &path);
921 /* Try to discover a valid linker/nm/strip to use. */
923 /* Maybe we know the right file to use (if not cross). */
925 #ifdef DEFAULT_LINKER
926 if (access (DEFAULT_LINKER, X_OK) == 0)
927 ld_file_name = DEFAULT_LINKER;
928 if (ld_file_name == 0)
930 #ifdef REAL_LD_FILE_NAME
931 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
932 if (ld_file_name == 0)
934 /* Search the (target-specific) compiler dirs for ld'. */
935 ld_file_name = find_a_file (&cpath, real_ld_suffix);
936 /* Likewise for `collect-ld'. */
937 if (ld_file_name == 0)
938 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
939 /* Search the compiler directories for `ld'. We have protection against
940 recursive calls in find_a_file. */
941 if (ld_file_name == 0)
942 ld_file_name = find_a_file (&cpath, ld_suffix);
943 /* Search the ordinary system bin directories
944 for `ld' (if native linking) or `TARGET-ld' (if cross). */
945 if (ld_file_name == 0)
946 ld_file_name = find_a_file (&path, full_ld_suffix);
948 #ifdef REAL_NM_FILE_NAME
949 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
950 if (nm_file_name == 0)
952 nm_file_name = find_a_file (&cpath, gnm_suffix);
953 if (nm_file_name == 0)
954 nm_file_name = find_a_file (&path, full_gnm_suffix);
955 if (nm_file_name == 0)
956 nm_file_name = find_a_file (&cpath, nm_suffix);
957 if (nm_file_name == 0)
958 nm_file_name = find_a_file (&path, full_nm_suffix);
961 ldd_file_name = find_a_file (&cpath, ldd_suffix);
962 if (ldd_file_name == 0)
963 ldd_file_name = find_a_file (&path, full_ldd_suffix);
966 #ifdef REAL_STRIP_FILE_NAME
967 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
968 if (strip_file_name == 0)
970 strip_file_name = find_a_file (&cpath, gstrip_suffix);
971 if (strip_file_name == 0)
972 strip_file_name = find_a_file (&path, full_gstrip_suffix);
973 if (strip_file_name == 0)
974 strip_file_name = find_a_file (&cpath, strip_suffix);
975 if (strip_file_name == 0)
976 strip_file_name = find_a_file (&path, full_strip_suffix);
978 /* Determine the full path name of the C compiler to use. */
979 c_file_name = getenv ("COLLECT_GCC");
980 if (c_file_name == 0)
983 c_file_name = concat (target_machine, "-gcc", NULL);
989 p = find_a_file (&cpath, c_file_name);
991 /* Here it should be safe to use the system search path since we should have
992 already qualified the name of the compiler when it is needed. */
994 p = find_a_file (&path, c_file_name);
999 *ld1++ = *ld2++ = ld_file_name;
1001 /* Make temp file names. */
1002 c_file = make_temp_file (".c");
1003 o_file = make_temp_file (".o");
1004 #ifdef COLLECT_EXPORT_LIST
1005 export_file = make_temp_file (".x");
1007 ldout = make_temp_file (".ld");
1008 *c_ptr++ = c_file_name;
1015 #ifdef COLLECT_EXPORT_LIST
1016 /* Generate a list of directories from LIBPATH. */
1017 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1018 /* Add to this list also two standard directories where
1019 AIX loader always searches for libraries. */
1020 add_prefix (&libpath_lib_dirs, "/lib");
1021 add_prefix (&libpath_lib_dirs, "/usr/lib");
1024 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1026 AIX support needs to know if -shared has been specified before
1027 parsing commandline arguments. */
1029 p = getenv ("COLLECT_GCC_OPTIONS");
1032 const char *q = extract_string (&p);
1033 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1034 *c_ptr++ = xstrdup (q);
1035 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1036 *c_ptr++ = xstrdup (q);
1037 if (strcmp (q, "-shared") == 0)
1039 if (*q == '-' && q[1] == 'B')
1041 *c_ptr++ = xstrdup (q);
1044 q = extract_string (&p);
1045 *c_ptr++ = xstrdup (q);
1049 obstack_free (&temporary_obstack, temporary_firstobj);
1050 *c_ptr++ = "-fno-profile-arcs";
1051 *c_ptr++ = "-fno-test-coverage";
1052 *c_ptr++ = "-fno-branch-probabilities";
1053 *c_ptr++ = "-fno-exceptions";
1056 /* !!! When GCC calls collect2,
1057 it does not know whether it is calling collect2 or ld.
1058 So collect2 cannot meaningfully understand any options
1059 except those ld understands.
1060 If you propose to make GCC pass some other option,
1061 just imagine what will happen if ld is really ld!!! */
1063 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1064 /* After the first file, put in the c++ rt0. */
1067 while ((arg = *++argv) != (char *) 0)
1069 *ld1++ = *ld2++ = arg;
1075 #ifdef COLLECT_EXPORT_LIST
1076 /* We want to disable automatic exports on AIX when user
1077 explicitly puts an export list in command line */
1079 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1081 else if (arg[2] == '6' && arg[3] == '4')
1087 if (!strcmp (arg, "-debug"))
1089 /* Already parsed. */
1098 /* place o_file BEFORE this argument! */
1104 #ifdef COLLECT_EXPORT_LIST
1106 /* Resolving full library name. */
1107 const char *s = resolve_lib_name (arg+2);
1109 /* Saving a full library name. */
1110 add_to_list (&libs, s);
1115 #ifdef COLLECT_EXPORT_LIST
1116 /* Saving directories where to search for libraries. */
1118 add_prefix (&cmdline_lib_dirs, arg+2);
1121 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1123 if (is_in_args (arg, (const char **) ld1_argv, ld1-1))
1126 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1131 output_file = *ld1++ = *ld2++ = *++argv;
1133 #ifdef SWITCHES_NEED_SPACES
1134 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1138 output_file = &arg[2];
1147 if (arg[2] == '\0' && do_collecting)
1149 /* We must strip after the nm run, otherwise C++ linking
1150 will not work. Thus we strip in the second ld run, or
1151 else with strip if there is no second ld run. */
1163 else if ((p = strrchr (arg, '.')) != (char *) 0
1164 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1165 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1166 || strcmp (p, ".obj") == 0))
1175 /* place o_file BEFORE this argument! */
1181 if (p[1] == 'o' || p[1] == 'l')
1183 #ifdef COLLECT_EXPORT_LIST
1184 /* libraries can be specified directly, i.e. without -l flag. */
1187 /* Saving a full library name. */
1188 add_to_list (&libs, arg);
1194 #ifdef COLLECT_EXPORT_LIST
1195 /* This is added only for debugging purposes. */
1198 fprintf (stderr, "List of libraries:\n");
1199 dump_list (stderr, "\t", libs.first);
1202 /* The AIX linker will discard static constructors in object files if
1203 nothing else in the file is referenced, so look at them first. */
1205 const char **export_object_lst = (const char **)object_lst;
1207 while (export_object_lst < object)
1208 scan_prog_file (*export_object_lst++, PASS_OBJ);
1211 struct id *list = libs.first;
1213 for (; list; list = list->next)
1214 scan_prog_file (list->name, PASS_FIRST);
1219 char *buf = concat ("-bE:", export_file, NULL);
1224 exportf = fopen (export_file, "w");
1225 if (exportf == (FILE *) 0)
1226 fatal_perror ("fopen %s", export_file);
1227 write_aix_file (exportf, exports.first);
1228 if (fclose (exportf))
1229 fatal_perror ("fclose %s", export_file);
1234 *c_ptr = *ld1 = *object = (char *) 0;
1238 notice ("collect2 version %s", version_string);
1239 #ifdef TARGET_VERSION
1242 fprintf (stderr, "\n");
1248 fprintf (stderr, "ld_file_name = %s\n",
1249 (ld_file_name ? ld_file_name : "not found"));
1250 fprintf (stderr, "c_file_name = %s\n",
1251 (c_file_name ? c_file_name : "not found"));
1252 fprintf (stderr, "nm_file_name = %s\n",
1253 (nm_file_name ? nm_file_name : "not found"));
1255 fprintf (stderr, "ldd_file_name = %s\n",
1256 (ldd_file_name ? ldd_file_name : "not found"));
1258 fprintf (stderr, "strip_file_name = %s\n",
1259 (strip_file_name ? strip_file_name : "not found"));
1260 fprintf (stderr, "c_file = %s\n",
1261 (c_file ? c_file : "not found"));
1262 fprintf (stderr, "o_file = %s\n",
1263 (o_file ? o_file : "not found"));
1265 ptr = getenv ("COLLECT_GCC_OPTIONS");
1267 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1269 ptr = getenv ("COLLECT_GCC");
1271 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1273 ptr = getenv ("COMPILER_PATH");
1275 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1277 ptr = getenv (LIBRARY_PATH_ENV);
1279 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1281 fprintf (stderr, "\n");
1284 /* Load the program, searching all libraries and attempting to provide
1285 undefined symbols from repository information. */
1287 /* On AIX we do this later. */
1288 #ifndef COLLECT_EXPORT_LIST
1289 do_tlink (ld1_argv, object_lst);
1292 /* If -r or they will be run via some other method, do not build the
1293 constructor or destructor list, just return now. */
1295 #ifndef COLLECT_EXPORT_LIST
1300 #ifdef COLLECT_EXPORT_LIST
1301 /* Do the link we avoided above if we are exiting. */
1302 do_tlink (ld1_argv, object_lst);
1304 /* But make sure we delete the export file we may have created. */
1305 if (export_file != 0 && export_file[0])
1306 maybe_unlink (export_file);
1308 maybe_unlink (c_file);
1309 maybe_unlink (o_file);
1313 /* Examine the namelist with nm and search it for static constructors
1314 and destructors to call.
1315 Write the constructor and destructor tables to a .s file and reload. */
1317 /* On AIX we already scanned for global constructors/destructors. */
1318 #ifndef COLLECT_EXPORT_LIST
1319 scan_prog_file (output_file, PASS_FIRST);
1322 #ifdef SCAN_LIBRARIES
1323 scan_libraries (output_file);
1328 notice ("%d constructor(s) found\n", constructors.number);
1329 notice ("%d destructor(s) found\n", destructors.number);
1330 notice ("%d frame table(s) found\n", frame_tables.number);
1333 if (constructors.number == 0 && destructors.number == 0
1334 && frame_tables.number == 0
1335 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1336 /* If we will be running these functions ourselves, we want to emit
1337 stubs into the shared library so that we do not have to relink
1338 dependent programs when we add static objects. */
1343 #ifdef COLLECT_EXPORT_LIST
1344 /* Do tlink without additional code generation. */
1345 do_tlink (ld1_argv, object_lst);
1347 /* Strip now if it was requested on the command line. */
1350 char **real_strip_argv = xcalloc (sizeof (char *), 3);
1351 const char ** strip_argv = (const char **) real_strip_argv;
1353 strip_argv[0] = strip_file_name;
1354 strip_argv[1] = output_file;
1355 strip_argv[2] = (char *) 0;
1356 fork_execute ("strip", real_strip_argv);
1359 #ifdef COLLECT_EXPORT_LIST
1360 maybe_unlink (export_file);
1362 maybe_unlink (c_file);
1363 maybe_unlink (o_file);
1367 /* Sort ctor and dtor lists by priority. */
1368 sort_ids (&constructors);
1369 sort_ids (&destructors);
1371 maybe_unlink(output_file);
1372 outf = fopen (c_file, "w");
1373 if (outf == (FILE *) 0)
1374 fatal_perror ("fopen %s", c_file);
1376 write_c_file (outf, c_file);
1379 fatal_perror ("fclose %s", c_file);
1381 /* Tell the linker that we have initializer and finalizer functions. */
1382 #ifdef LD_INIT_SWITCH
1383 #ifdef COLLECT_EXPORT_LIST
1384 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1386 *ld2++ = LD_INIT_SWITCH;
1388 *ld2++ = LD_FINI_SWITCH;
1393 #ifdef COLLECT_EXPORT_LIST
1396 /* If we did not add export flag to link arguments before, add it to
1397 second link phase now. No new exports should have been added. */
1398 if (! exports.first)
1399 *ld2++ = concat ("-bE:", export_file, NULL);
1401 #ifndef LD_INIT_SWITCH
1402 add_to_list (&exports, initname);
1403 add_to_list (&exports, fininame);
1404 add_to_list (&exports, "_GLOBAL__DI");
1405 add_to_list (&exports, "_GLOBAL__DD");
1407 exportf = fopen (export_file, "w");
1408 if (exportf == (FILE *) 0)
1409 fatal_perror ("fopen %s", export_file);
1410 write_aix_file (exportf, exports.first);
1411 if (fclose (exportf))
1412 fatal_perror ("fclose %s", export_file);
1416 /* End of arguments to second link phase. */
1421 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1422 output_file, c_file);
1423 write_c_file (stderr, "stderr");
1424 fprintf (stderr, "========== end of c_file\n\n");
1425 #ifdef COLLECT_EXPORT_LIST
1426 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1427 write_aix_file (stderr, exports.first);
1428 fprintf (stderr, "========== end of export_file\n\n");
1432 /* Assemble the constructor and destructor tables.
1433 Link the tables in with the rest of the program. */
1435 fork_execute ("gcc", c_argv);
1436 #ifdef COLLECT_EXPORT_LIST
1437 /* On AIX we must call tlink because of possible templates resolution. */
1438 do_tlink (ld2_argv, object_lst);
1440 /* Otherwise, simply call ld because tlink is already done. */
1441 fork_execute ("ld", ld2_argv);
1443 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1444 constructors/destructors in shared libraries. */
1445 scan_prog_file (output_file, PASS_SECOND);
1448 maybe_unlink (c_file);
1449 maybe_unlink (o_file);
1451 #ifdef COLLECT_EXPORT_LIST
1452 maybe_unlink (export_file);
1459 /* Wait for a process to finish, and exit if a nonzero status is found. */
1462 collect_wait (const char *prog)
1466 pwait (pid, &status, 0);
1469 if (WIFSIGNALED (status))
1471 int sig = WTERMSIG (status);
1472 error ("%s terminated with signal %d [%s]%s",
1473 prog, sig, strsignal(sig),
1474 WCOREDUMP(status) ? ", core dumped" : "");
1475 collect_exit (FATAL_EXIT_CODE);
1478 if (WIFEXITED (status))
1479 return WEXITSTATUS (status);
1485 do_wait (const char *prog)
1487 int ret = collect_wait (prog);
1490 error ("%s returned %d exit status", prog, ret);
1496 /* Execute a program, and wait for the reply. */
1499 collect_execute (const char *prog, char **argv, const char *redir)
1503 int redir_handle = -1;
1504 int stdout_save = -1;
1505 int stderr_save = -1;
1513 fprintf (stderr, "%s", argv[0]);
1515 notice ("[cannot find %s]", prog);
1517 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1518 fprintf (stderr, " %s", str);
1520 fprintf (stderr, "\n");
1526 /* If we cannot find a program we need, complain error. Do this here
1527 since we might not end up needing something that we could not find. */
1530 fatal ("cannot find `%s'", prog);
1534 /* Open response file. */
1535 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT);
1537 /* Duplicate the stdout and stderr file handles
1538 so they can be restored later. */
1539 stdout_save = dup (STDOUT_FILENO);
1540 if (stdout_save == -1)
1541 fatal_perror ("redirecting stdout: %s", redir);
1542 stderr_save = dup (STDERR_FILENO);
1543 if (stderr_save == -1)
1544 fatal_perror ("redirecting stdout: %s", redir);
1546 /* Redirect stdout & stderr to our response file. */
1547 dup2 (redir_handle, STDOUT_FILENO);
1548 dup2 (redir_handle, STDERR_FILENO);
1551 pid = pexecute (argv[0], argv, argv[0], NULL, &errmsg_fmt, &errmsg_arg,
1552 (PEXECUTE_FIRST | PEXECUTE_LAST | PEXECUTE_SEARCH));
1556 /* Restore stdout and stderr to their previous settings. */
1557 dup2 (stdout_save, STDOUT_FILENO);
1558 dup2 (stderr_save, STDERR_FILENO);
1560 /* Close response file. */
1561 close (redir_handle);
1565 fatal_perror (errmsg_fmt, errmsg_arg);
1569 fork_execute (const char *prog, char **argv)
1571 collect_execute (prog, argv, NULL);
1575 /* Unlink a file unless we are debugging. */
1578 maybe_unlink (const char *file)
1583 notice ("[Leaving %s]\n", file);
1587 static long sequence_number = 0;
1589 /* Add a name to a linked list. */
1592 add_to_list (struct head *head_ptr, const char *name)
1594 struct id *newid = xcalloc (sizeof (struct id) + strlen (name), 1);
1596 strcpy (newid->name, name);
1598 if (head_ptr->first)
1599 head_ptr->last->next = newid;
1601 head_ptr->first = newid;
1603 /* Check for duplicate symbols. */
1604 for (p = head_ptr->first;
1605 strcmp (name, p->name) != 0;
1610 head_ptr->last->next = 0;
1615 newid->sequence = ++sequence_number;
1616 head_ptr->last = newid;
1620 /* Grab the init priority number from an init function name that
1621 looks like "_GLOBAL_.I.12345.foo". */
1624 extract_init_priority (const char *name)
1628 while (name[pos] == '_')
1630 pos += 10; /* strlen ("GLOBAL__X_") */
1632 /* Extract init_p number from ctor/dtor name. */
1633 pri = atoi (name + pos);
1634 return pri ? pri : DEFAULT_INIT_PRIORITY;
1637 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1638 ctors will be run from right to left, dtors from left to right. */
1641 sort_ids (struct head *head_ptr)
1643 /* id holds the current element to insert. id_next holds the next
1644 element to insert. id_ptr iterates through the already sorted elements
1645 looking for the place to insert id. */
1646 struct id *id, *id_next, **id_ptr;
1648 id = head_ptr->first;
1650 /* We don't have any sorted elements yet. */
1651 head_ptr->first = NULL;
1653 for (; id; id = id_next)
1656 id->sequence = extract_init_priority (id->name);
1658 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
1660 /* If the sequence numbers are the same, we put the id from the
1661 file later on the command line later in the list. */
1662 || id->sequence > (*id_ptr)->sequence
1663 /* Hack: do lexical compare, too.
1664 || (id->sequence == (*id_ptr)->sequence
1665 && strcmp (id->name, (*id_ptr)->name) > 0) */
1674 /* Now set the sequence numbers properly so write_c_file works. */
1675 for (id = head_ptr->first; id; id = id->next)
1676 id->sequence = ++sequence_number;
1679 /* Write: `prefix', the names on list LIST, `suffix'. */
1682 write_list (FILE *stream, const char *prefix, struct id *list)
1686 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1691 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1692 /* Given a STRING, return nonzero if it occurs in the list in range
1693 [ARGS_BEGIN,ARGS_END). */
1696 is_in_args (const char *string, const char **args_begin,
1697 const char **args_end)
1699 const char **args_pointer;
1700 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
1701 if (strcmp (string, *args_pointer) == 0)
1705 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1707 #ifdef COLLECT_EXPORT_LIST
1708 /* This function is really used only on AIX, but may be useful. */
1711 is_in_list (const char *prefix, struct id *list)
1715 if (!strcmp (prefix, list->name)) return 1;
1721 #endif /* COLLECT_EXPORT_LIST */
1723 /* Added for debugging purpose. */
1724 #ifdef COLLECT_EXPORT_LIST
1726 dump_list (FILE *stream, const char *prefix, struct id *list)
1730 fprintf (stream, "%s%s,\n", prefix, list->name);
1738 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
1742 fprintf (stream, "%s%s,\n", prefix, list->prefix);
1749 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
1753 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1754 prefix, list->sequence, list->name);
1759 /* Write out the constructor and destructor tables statically (for a shared
1760 object), along with the functions to execute them. */
1763 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
1767 int frames = (frame_tables.number > 0);
1769 /* Figure out name of output_file, stripping off .so version. */
1770 p = strrchr (output_file, '/');
1786 if (strncmp (q, ".so", 3) == 0)
1795 /* q points to null at end of the string (or . of the .so version) */
1796 prefix = xmalloc (q - p + 1);
1797 strncpy (prefix, p, q - p);
1799 for (r = prefix; *r; r++)
1800 if (!ISALNUM ((unsigned char)*r))
1803 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
1804 output_file, prefix);
1806 initname = concat ("_GLOBAL__FI_", prefix, NULL);
1807 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
1811 /* Write the tables as C code. */
1813 fprintf (stream, "static int count;\n");
1814 fprintf (stream, "typedef void entry_pt();\n");
1815 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1819 write_list_with_asm (stream, "extern void *", frame_tables.first);
1821 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1822 write_list (stream, "\t\t&", frame_tables.first);
1823 fprintf (stream, "\t0\n};\n");
1825 /* This must match what's in frame.h. */
1826 fprintf (stream, "struct object {\n");
1827 fprintf (stream, " void *pc_begin;\n");
1828 fprintf (stream, " void *pc_end;\n");
1829 fprintf (stream, " void *fde_begin;\n");
1830 fprintf (stream, " void *fde_array;\n");
1831 fprintf (stream, " __SIZE_TYPE__ count;\n");
1832 fprintf (stream, " struct object *next;\n");
1833 fprintf (stream, "};\n");
1835 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1836 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1838 fprintf (stream, "static void reg_frame () {\n");
1839 fprintf (stream, "\tstatic struct object ob;\n");
1840 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1841 fprintf (stream, "\t}\n");
1843 fprintf (stream, "static void dereg_frame () {\n");
1844 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1845 fprintf (stream, "\t}\n");
1848 fprintf (stream, "void %s() {\n", initname);
1849 if (constructors.number > 0 || frames)
1851 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1852 write_list (stream, "\t\t", constructors.first);
1854 fprintf (stream, "\treg_frame,\n");
1855 fprintf (stream, "\t};\n");
1856 fprintf (stream, "\tentry_pt **p;\n");
1857 fprintf (stream, "\tif (count++ != 0) return;\n");
1858 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1859 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1862 fprintf (stream, "\t++count;\n");
1863 fprintf (stream, "}\n");
1864 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1865 fprintf (stream, "void %s() {\n", fininame);
1866 if (destructors.number > 0 || frames)
1868 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1869 write_list (stream, "\t\t", destructors.first);
1871 fprintf (stream, "\tdereg_frame,\n");
1872 fprintf (stream, "\t};\n");
1873 fprintf (stream, "\tentry_pt **p;\n");
1874 fprintf (stream, "\tif (--count != 0) return;\n");
1875 fprintf (stream, "\tp = dtors;\n");
1876 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1877 destructors.number + frames);
1879 fprintf (stream, "}\n");
1883 COLLECT_SHARED_INIT_FUNC(stream, initname);
1884 COLLECT_SHARED_FINI_FUNC(stream, fininame);
1888 /* Write the constructor/destructor tables. */
1890 #ifndef LD_INIT_SWITCH
1892 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
1894 /* Write the tables as C code. */
1896 int frames = (frame_tables.number > 0);
1898 fprintf (stream, "typedef void entry_pt();\n\n");
1900 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1904 write_list_with_asm (stream, "extern void *", frame_tables.first);
1906 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1907 write_list (stream, "\t\t&", frame_tables.first);
1908 fprintf (stream, "\t0\n};\n");
1910 /* This must match what's in frame.h. */
1911 fprintf (stream, "struct object {\n");
1912 fprintf (stream, " void *pc_begin;\n");
1913 fprintf (stream, " void *pc_end;\n");
1914 fprintf (stream, " void *fde_begin;\n");
1915 fprintf (stream, " void *fde_array;\n");
1916 fprintf (stream, " __SIZE_TYPE__ count;\n");
1917 fprintf (stream, " struct object *next;\n");
1918 fprintf (stream, "};\n");
1920 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1921 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1923 fprintf (stream, "static void reg_frame () {\n");
1924 fprintf (stream, "\tstatic struct object ob;\n");
1925 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1926 fprintf (stream, "\t}\n");
1928 fprintf (stream, "static void dereg_frame () {\n");
1929 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1930 fprintf (stream, "\t}\n");
1933 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
1934 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
1935 write_list (stream, "\t", constructors.first);
1937 fprintf (stream, "\treg_frame,\n");
1938 fprintf (stream, "\t0\n};\n\n");
1940 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1942 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
1943 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
1944 write_list (stream, "\t", destructors.first);
1946 fprintf (stream, "\tdereg_frame,\n");
1947 fprintf (stream, "\t0\n};\n\n");
1949 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
1950 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
1952 #endif /* ! LD_INIT_SWITCH */
1955 write_c_file (FILE *stream, const char *name)
1957 fprintf (stream, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
1958 #ifndef LD_INIT_SWITCH
1960 write_c_file_glob (stream, name);
1963 write_c_file_stat (stream, name);
1964 fprintf (stream, "#ifdef __cplusplus\n}\n#endif\n");
1967 #ifdef COLLECT_EXPORT_LIST
1969 write_aix_file (FILE *stream, struct id *list)
1971 for (; list; list = list->next)
1973 fputs (list->name, stream);
1974 putc ('\n', stream);
1979 #ifdef OBJECT_FORMAT_NONE
1981 /* Generic version to scan the name list of the loaded program for
1982 the symbols g++ uses for static constructors and destructors.
1984 The constructor table begins at __CTOR_LIST__ and contains a count
1985 of the number of pointers (or -1 if the constructors are built in a
1986 separate section by the linker), followed by the pointers to the
1987 constructor functions, terminated with a null pointer. The
1988 destructor table has the same format, and begins at __DTOR_LIST__. */
1991 scan_prog_file (const char *prog_name, enum pass which_pass)
1993 void (*int_handler) (int);
1994 void (*quit_handler) (int);
1995 char *real_nm_argv[4];
1996 const char **nm_argv = (const char **) real_nm_argv;
2002 if (which_pass == PASS_SECOND)
2005 /* If we do not have an `nm', complain. */
2006 if (nm_file_name == 0)
2007 fatal ("cannot find `nm'");
2009 nm_argv[argc++] = nm_file_name;
2010 if (NM_FLAGS[0] != '\0')
2011 nm_argv[argc++] = NM_FLAGS;
2013 nm_argv[argc++] = prog_name;
2014 nm_argv[argc++] = (char *) 0;
2016 if (pipe (pipe_fd) < 0)
2017 fatal_perror ("pipe");
2019 inf = fdopen (pipe_fd[0], "r");
2020 if (inf == (FILE *) 0)
2021 fatal_perror ("fdopen");
2023 /* Trace if needed. */
2026 const char **p_argv;
2029 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2030 fprintf (stderr, " %s", str);
2032 fprintf (stderr, "\n");
2038 /* Spawn child nm on pipe. */
2041 fatal_perror (VFORK_STRING);
2043 if (pid == 0) /* child context */
2046 if (dup2 (pipe_fd[1], 1) < 0)
2047 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2049 if (close (pipe_fd[0]) < 0)
2050 fatal_perror ("close %d", pipe_fd[0]);
2052 if (close (pipe_fd[1]) < 0)
2053 fatal_perror ("close %d", pipe_fd[1]);
2055 execv (nm_file_name, real_nm_argv);
2056 fatal_perror ("execv %s", nm_file_name);
2059 /* Parent context from here on. */
2060 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2062 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2065 if (close (pipe_fd[1]) < 0)
2066 fatal_perror ("close %d", pipe_fd[1]);
2069 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2071 /* Read each line of nm output. */
2072 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2077 /* If it contains a constructor or destructor name, add the name
2078 to the appropriate list. */
2080 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2081 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2088 /* Find the end of the symbol name.
2089 Do not include `|', because Encore nm can tack that on the end. */
2090 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2096 switch (is_ctor_dtor (name))
2099 if (which_pass != PASS_LIB)
2100 add_to_list (&constructors, name);
2104 if (which_pass != PASS_LIB)
2105 add_to_list (&destructors, name);
2109 if (which_pass != PASS_LIB)
2110 fatal ("init function found in object %s", prog_name);
2111 #ifndef LD_INIT_SWITCH
2112 add_to_list (&constructors, name);
2117 if (which_pass != PASS_LIB)
2118 fatal ("fini function found in object %s", prog_name);
2119 #ifndef LD_FINI_SWITCH
2120 add_to_list (&destructors, name);
2125 if (which_pass != PASS_LIB)
2126 add_to_list (&frame_tables, name);
2129 default: /* not a constructor or destructor */
2134 fprintf (stderr, "\t%s\n", buf);
2138 fprintf (stderr, "\n");
2140 if (fclose (inf) != 0)
2141 fatal_perror ("fclose");
2143 do_wait (nm_file_name);
2145 signal (SIGINT, int_handler);
2147 signal (SIGQUIT, quit_handler);
2151 #if SUNOS4_SHARED_LIBRARIES
2153 /* Routines to scan the SunOS 4 _DYNAMIC structure to find shared libraries
2154 that the output file depends upon and their initialization/finalization
2155 routines, if any. */
2160 #include <sys/mman.h>
2161 #include <sys/param.h>
2163 #include <sys/dir.h>
2165 /* pointers to the object file */
2166 unsigned object; /* address of memory mapped file */
2167 unsigned objsize; /* size of memory mapped to file */
2168 char * code; /* pointer to code segment */
2169 char * data; /* pointer to data segment */
2170 struct nlist *symtab; /* pointer to symbol table */
2171 struct link_dynamic *ld;
2172 struct link_dynamic_2 *ld_2;
2173 struct head libraries;
2175 /* Map the file indicated by NAME into memory and store its address. */
2178 mapfile (const char *name)
2182 if ((fp = open (name, O_RDONLY)) == -1)
2183 fatal ("unable to open file '%s'", name);
2184 if (fstat (fp, &s) == -1)
2185 fatal ("unable to stat file '%s'", name);
2187 objsize = s.st_size;
2188 object = (unsigned) mmap (0, objsize, PROT_READ|PROT_WRITE, MAP_PRIVATE,
2190 if (object == (unsigned)-1)
2191 fatal ("unable to mmap file '%s'", name);
2196 /* Helpers for locatelib. */
2198 static const char *libname;
2201 libselect (struct direct *d)
2203 return (strncmp (libname, d->d_name, strlen (libname)) == 0);
2206 /* If one file has an additional numeric extension past LIBNAME, then put
2207 that one first in the sort. If both files have additional numeric
2208 extensions, then put the one with the higher number first in the sort.
2210 We must verify that the extension is numeric, because Sun saves the
2211 original versions of patched libraries with a .FCS extension. Files with
2212 invalid extensions must go last in the sort, so that they will not be used. */
2215 libcompare (struct direct **d1, struct direct **d2)
2217 int i1, i2 = strlen (libname);
2218 char *e1 = (*d1)->d_name + i2;
2219 char *e2 = (*d2)->d_name + i2;
2221 while (*e1 && *e2 && *e1 == '.' && *e2 == '.'
2222 && e1[1] && ISDIGIT (e1[1]) && e2[1] && ISDIGIT (e2[1]))
2226 i1 = strtol (e1, &e1, 10);
2227 i2 = strtol (e2, &e2, 10);
2234 /* It has a valid numeric extension, prefer this one. */
2235 if (*e1 == '.' && e1[1] && ISDIGIT (e1[1]))
2237 /* It has an invalid numeric extension, must prefer the other one. */
2243 /* It has a valid numeric extension, prefer this one. */
2244 if (*e2 == '.' && e2[1] && ISDIGIT (e2[1]))
2246 /* It has an invalid numeric extension, must prefer the other one. */
2254 /* Given the name NAME of a dynamic dependency, find its pathname and add
2255 it to the list of libraries. */
2258 locatelib (const char *name)
2260 static const char **l;
2262 char buf[MAXPATHLEN];
2270 /* counting elements in array, need 1 extra for null */
2272 ld_rules = (char *) (ld_2->ld_rules + code);
2276 for (; *ld_rules != 0; ld_rules++)
2277 if (*ld_rules == ':')
2279 ld_rules = (char *) (ld_2->ld_rules + code);
2280 ldr = xstrdup (ld_rules);
2282 p = getenv ("LD_LIBRARY_PATH");
2287 for (q = p ; *q != 0; q++)
2292 l = xmalloc ((cnt + 3) * sizeof (char *));
2297 for (; *ldr != 0; ldr++)
2307 for (; *q != 0; q++)
2314 /* built in directories are /lib, /usr/lib, and /usr/local/lib */
2317 *pp++ = "/usr/local/lib";
2321 for (pp = l; *pp != 0 ; pp++)
2323 struct direct **namelist;
2325 if ((entries = scandir (*pp, &namelist, libselect, libcompare)) > 0)
2327 sprintf (buf, "%s/%s", *pp, namelist[entries - 1]->d_name);
2328 add_to_list (&libraries, buf);
2330 fprintf (stderr, "%s\n", buf);
2337 notice ("not found\n");
2339 fatal ("dynamic dependency %s not found", name);
2343 /* Scan the _DYNAMIC structure of the output file to find shared libraries
2344 that it depends upon and any constructors or destructors they contain. */
2347 scan_libraries (const char *prog_name)
2349 struct exec *header;
2351 struct link_object *lo;
2352 char buff[MAXPATHLEN];
2355 mapfile (prog_name);
2356 header = (struct exec *)object;
2357 if (N_BADMAG (*header))
2358 fatal ("bad magic number in file '%s'", prog_name);
2359 if (header->a_dynamic == 0)
2362 code = (char *) (N_TXTOFF (*header) + (long) header);
2363 data = (char *) (N_DATOFF (*header) + (long) header);
2364 symtab = (struct nlist *) (N_SYMOFF (*header) + (long) header);
2366 if (header->a_magic == ZMAGIC && header->a_entry == 0x20)
2369 ld = (struct link_dynamic *) (symtab->n_value + code);
2375 ld = (struct link_dynamic *) data;
2380 notice ("dynamic dependencies.\n");
2382 ld_2 = (struct link_dynamic_2 *) ((long) ld->ld_un.ld_2 + (long)base);
2383 for (lo = (struct link_object *) ld_2->ld_need; lo;
2384 lo = (struct link_object *) lo->lo_next)
2387 lo = (struct link_object *) ((long) lo + code);
2388 name = (char *) (code + lo->lo_name);
2392 fprintf (stderr, "\t-l%s.%d => ", name, lo->lo_major);
2393 sprintf (buff, "lib%s.so.%d.%d", name, lo->lo_major, lo->lo_minor);
2399 fprintf (stderr, "\t%s\n", name);
2400 add_to_list (&libraries, name);
2405 fprintf (stderr, "\n");
2407 /* Now iterate through the library list adding their symbols to
2409 for (list = libraries.first; list; list = list->next)
2410 scan_prog_file (list->name, PASS_LIB);
2413 #else /* SUNOS4_SHARED_LIBRARIES */
2416 /* Use the List Dynamic Dependencies program to find shared libraries that
2417 the output file depends upon and their initialization/finalization
2418 routines, if any. */
2421 scan_libraries (const char *prog_name)
2423 static struct head libraries; /* list of shared libraries found */
2425 void (*int_handler) (int);
2426 void (*quit_handler) (int);
2427 char *real_ldd_argv[4];
2428 const char **ldd_argv = (const char **) real_ldd_argv;
2434 /* If we do not have an `ldd', complain. */
2435 if (ldd_file_name == 0)
2437 error ("cannot find `ldd'");
2441 ldd_argv[argc++] = ldd_file_name;
2442 ldd_argv[argc++] = prog_name;
2443 ldd_argv[argc++] = (char *) 0;
2445 if (pipe (pipe_fd) < 0)
2446 fatal_perror ("pipe");
2448 inf = fdopen (pipe_fd[0], "r");
2449 if (inf == (FILE *) 0)
2450 fatal_perror ("fdopen");
2452 /* Trace if needed. */
2455 const char **p_argv;
2458 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2459 fprintf (stderr, " %s", str);
2461 fprintf (stderr, "\n");
2467 /* Spawn child ldd on pipe. */
2470 fatal_perror (VFORK_STRING);
2472 if (pid == 0) /* child context */
2475 if (dup2 (pipe_fd[1], 1) < 0)
2476 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2478 if (close (pipe_fd[0]) < 0)
2479 fatal_perror ("close %d", pipe_fd[0]);
2481 if (close (pipe_fd[1]) < 0)
2482 fatal_perror ("close %d", pipe_fd[1]);
2484 execv (ldd_file_name, real_ldd_argv);
2485 fatal_perror ("execv %s", ldd_file_name);
2488 /* Parent context from here on. */
2489 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2491 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2494 if (close (pipe_fd[1]) < 0)
2495 fatal_perror ("close %d", pipe_fd[1]);
2498 notice ("\nldd output with constructors/destructors.\n");
2500 /* Read each line of ldd output. */
2501 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2504 char *name, *end, *p = buf;
2506 /* Extract names of libraries and add to list. */
2507 PARSE_LDD_OUTPUT (p);
2512 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2513 fatal ("dynamic dependency %s not found", buf);
2515 /* Find the end of the symbol name. */
2517 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2522 if (access (name, R_OK) == 0)
2523 add_to_list (&libraries, name);
2525 fatal ("unable to open dynamic dependency '%s'", buf);
2528 fprintf (stderr, "\t%s\n", buf);
2531 fprintf (stderr, "\n");
2533 if (fclose (inf) != 0)
2534 fatal_perror ("fclose");
2536 do_wait (ldd_file_name);
2538 signal (SIGINT, int_handler);
2540 signal (SIGQUIT, quit_handler);
2543 /* Now iterate through the library list adding their symbols to
2545 for (list = libraries.first; list; list = list->next)
2546 scan_prog_file (list->name, PASS_LIB);
2549 #endif /* LDD_SUFFIX */
2550 #endif /* SUNOS4_SHARED_LIBRARIES */
2552 #endif /* OBJECT_FORMAT_NONE */
2556 * COFF specific stuff.
2559 #ifdef OBJECT_FORMAT_COFF
2561 #if defined (EXTENDED_COFF)
2563 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2564 # define GCC_SYMENT SYMR
2565 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2566 # define GCC_SYMINC(X) (1)
2567 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2568 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2572 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2573 # define GCC_SYMENT SYMENT
2574 # if defined (C_WEAKEXT)
2575 # define GCC_OK_SYMBOL(X) \
2576 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2577 ((X).n_scnum > N_UNDEF) && \
2579 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2580 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2581 # define GCC_UNDEF_SYMBOL(X) \
2582 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2583 ((X).n_scnum == N_UNDEF))
2585 # define GCC_OK_SYMBOL(X) \
2586 (((X).n_sclass == C_EXT) && \
2587 ((X).n_scnum > N_UNDEF) && \
2589 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2590 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2591 # define GCC_UNDEF_SYMBOL(X) \
2592 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2594 # define GCC_SYMINC(X) ((X).n_numaux+1)
2595 # define GCC_SYMZERO(X) 0
2597 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2599 # define GCC_CHECK_HDR(X) \
2600 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2601 || (HEADER (X).f_magic == 0767 && aix64_flag))
2603 # define GCC_CHECK_HDR(X) \
2604 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2605 || (HEADER (X).f_magic == 0757 && aix64_flag))
2610 #ifdef COLLECT_EXPORT_LIST
2611 /* Array of standard AIX libraries which should not
2612 be scanned for ctors/dtors. */
2613 static const char *const aix_std_libs[] = {
2621 "/usr/lib/libc_r.a",
2622 "/usr/lib/libm_r.a",
2623 "/usr/lib/threads/libc.a",
2624 "/usr/ccs/lib/libc.a",
2625 "/usr/ccs/lib/libm.a",
2626 "/usr/ccs/lib/libc_r.a",
2627 "/usr/ccs/lib/libm_r.a",
2631 /* This function checks the filename and returns 1
2632 if this name matches the location of a standard AIX library. */
2633 static int ignore_library (const char *);
2635 ignore_library (const char *name)
2637 const char *const *p = &aix_std_libs[0];
2638 while (*p++ != NULL)
2639 if (! strcmp (name, *p)) return 1;
2642 #endif /* COLLECT_EXPORT_LIST */
2644 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2645 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2648 /* COFF version to scan the name list of the loaded program for
2649 the symbols g++ uses for static constructors and destructors.
2651 The constructor table begins at __CTOR_LIST__ and contains a count
2652 of the number of pointers (or -1 if the constructors are built in a
2653 separate section by the linker), followed by the pointers to the
2654 constructor functions, terminated with a null pointer. The
2655 destructor table has the same format, and begins at __DTOR_LIST__. */
2658 scan_prog_file (const char *prog_name, enum pass which_pass)
2660 LDFILE *ldptr = NULL;
2661 int sym_index, sym_count;
2664 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2667 #ifdef COLLECT_EXPORT_LIST
2668 /* We do not need scanning for some standard C libraries. */
2669 if (which_pass == PASS_FIRST && ignore_library (prog_name))
2672 /* On AIX we have a loop, because there is not much difference
2673 between an object and an archive. This trick allows us to
2674 eliminate scan_libraries() function. */
2678 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2679 non-const char * filename parameter, even though it will not
2680 modify that string. So we must cast away const-ness here,
2681 which will cause -Wcast-qual to burp. */
2682 if ((ldptr = ldopen ((char *)prog_name, ldptr)) != NULL)
2684 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2685 fatal ("%s: not a COFF file", prog_name);
2687 if (GCC_CHECK_HDR (ldptr))
2689 sym_count = GCC_SYMBOLS (ldptr);
2690 sym_index = GCC_SYMZERO (ldptr);
2692 #ifdef COLLECT_EXPORT_LIST
2693 /* Is current archive member a shared object? */
2694 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2697 while (sym_index < sym_count)
2701 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2703 sym_index += GCC_SYMINC (symbol);
2705 if (GCC_OK_SYMBOL (symbol))
2709 if ((name = ldgetname (ldptr, &symbol)) == NULL)
2710 continue; /* Should never happen. */
2712 #ifdef XCOFF_DEBUGGING_INFO
2713 /* All AIX function names have a duplicate entry
2714 beginning with a dot. */
2719 switch (is_ctor_dtor (name))
2723 add_to_list (&constructors, name);
2724 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2725 if (which_pass == PASS_OBJ)
2726 add_to_list (&exports, name);
2732 add_to_list (&destructors, name);
2733 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2734 if (which_pass == PASS_OBJ)
2735 add_to_list (&exports, name);
2739 #ifdef COLLECT_EXPORT_LIST
2741 #ifndef LD_INIT_SWITCH
2743 add_to_list (&constructors, name);
2748 #ifndef LD_INIT_SWITCH
2750 add_to_list (&destructors, name);
2757 add_to_list (&frame_tables, name);
2758 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2759 if (which_pass == PASS_OBJ)
2760 add_to_list (&exports, name);
2764 default: /* not a constructor or destructor */
2765 #ifdef COLLECT_EXPORT_LIST
2766 /* Explicitly export all global symbols when
2767 building a shared object on AIX, but do not
2768 re-export symbols from another shared object
2769 and do not export symbols if the user
2770 provides an explicit export list. */
2771 if (shared_obj && !is_shared
2772 && which_pass == PASS_OBJ && !export_flag)
2773 add_to_list (&exports, name);
2779 #if !defined(EXTENDED_COFF)
2780 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2781 symbol.n_scnum, symbol.n_sclass,
2782 (symbol.n_type ? "0" : ""), symbol.n_type,
2786 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2787 symbol.iss, (long) symbol.value, symbol.index, name);
2792 #ifdef COLLECT_EXPORT_LIST
2795 /* If archive contains both 32-bit and 64-bit objects,
2796 we want to skip objects in other mode so mismatch normal. */
2798 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
2799 prog_name, HEADER (ldptr).f_magic, aix64_flag);
2805 fatal ("%s: cannot open as COFF file", prog_name);
2807 #ifdef COLLECT_EXPORT_LIST
2808 /* On AIX loop continues while there are more members in archive. */
2810 while (ldclose (ldptr) == FAILURE);
2812 /* Otherwise we simply close ldptr. */
2813 (void) ldclose(ldptr);
2816 #endif /* OBJECT_FORMAT_COFF */
2818 #ifdef COLLECT_EXPORT_LIST
2819 /* Given a library name without "lib" prefix, this function
2820 returns a full library name including a path. */
2822 resolve_lib_name (const char *name)
2827 for (i = 0; libpaths[i]; i++)
2828 if (libpaths[i]->max_len > l)
2829 l = libpaths[i]->max_len;
2831 lib_buf = xmalloc (l + strlen(name) + 10);
2833 for (i = 0; libpaths[i]; i++)
2835 struct prefix_list *list = libpaths[i]->plist;
2836 for (; list; list = list->next)
2838 /* The following lines are needed because path_prefix list
2839 may contain directories both with trailing '/' and
2842 if (list->prefix[strlen(list->prefix)-1] != '/')
2844 for (j = 0; libexts[j]; j++)
2846 sprintf (lib_buf, "%s%slib%s.%s",
2847 list->prefix, p, name, libexts[j]);
2848 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2849 if (file_exists (lib_buf))
2851 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2858 fprintf (stderr, "not found\n");
2860 fatal ("library lib%s not found", name);
2863 #endif /* COLLECT_EXPORT_LIST */