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 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. */
32 #if ! defined( SIGCHLD ) && defined( SIGCLD )
33 # define SIGCHLD SIGCLD
36 #ifdef vfork /* Autoconf may define this to fork for us. */
37 # define VFORK_STRING "fork"
39 # define VFORK_STRING "vfork"
45 #define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
46 lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
49 #ifndef LIBRARY_PATH_ENV
50 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
61 /* Obstack allocation and deallocation routines. */
62 #define obstack_chunk_alloc xmalloc
63 #define obstack_chunk_free free
65 /* On certain systems, we have code that works by scanning the object file
66 directly. But this code uses system-specific header files and library
67 functions, so turn it off in a cross-compiler. Likewise, the names of
68 the utilities are not correct for a cross-compiler; we have to hope that
69 cross-versions are in the proper directories. */
72 #undef SUNOS4_SHARED_LIBRARIES
73 #undef OBJECT_FORMAT_COFF
74 #undef OBJECT_FORMAT_ROSE
76 #undef REAL_LD_FILE_NAME
77 #undef REAL_NM_FILE_NAME
78 #undef REAL_STRIP_FILE_NAME
81 /* If we cannot use a special method, use the ordinary one:
82 run nm to find what symbols are present.
83 In a cross-compiler, this means you need a cross nm,
84 but that is not quite as unpleasant as special headers. */
86 #if !defined (OBJECT_FORMAT_COFF) && !defined (OBJECT_FORMAT_ROSE)
87 #define OBJECT_FORMAT_NONE
90 #ifdef OBJECT_FORMAT_COFF
99 /* Many versions of ldfcn.h define these. */
107 /* Some systems have an ISCOFF macro, but others do not. In some cases
108 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
109 that either do not have an ISCOFF macro in /usr/include or for those
110 where it is wrong. */
113 #define MY_ISCOFF(X) ISCOFF (X)
116 #endif /* OBJECT_FORMAT_COFF */
118 #ifdef OBJECT_FORMAT_ROSE
125 #include <sys/mman.h>
129 #include <mach_o_format.h>
130 #include <mach_o_header.h>
131 #include <mach_o_vals.h>
132 #include <mach_o_types.h>
134 #endif /* OBJECT_FORMAT_ROSE */
136 #ifdef OBJECT_FORMAT_NONE
138 /* Default flags to pass to nm. */
140 #define NM_FLAGS "-n"
143 #endif /* OBJECT_FORMAT_NONE */
145 /* Some systems use __main in a way incompatible with its use in gcc, in these
146 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
147 give the same symbol without quotes for an alternative entry point. You
148 must define both, or neither. */
150 #define NAME__MAIN "__main"
151 #define SYMBOL__MAIN __main
154 /* This must match tree.h. */
155 #define DEFAULT_INIT_PRIORITY 65535
157 #if defined (LDD_SUFFIX) || SUNOS4_SHARED_LIBRARIES
158 #define SCAN_LIBRARIES
162 int do_collecting = 1;
164 int do_collecting = 0;
167 /* Nonzero if we should suppress the automatic demangling of identifiers
168 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
171 /* Linked lists of constructor and destructor names. */
187 /* Enumeration giving which pass this is for scanning the program file. */
190 PASS_FIRST, /* without constructors */
191 PASS_OBJ, /* individual objects */
192 PASS_LIB, /* looking for shared libraries */
193 PASS_SECOND /* with constructors linked in */
196 int vflag; /* true if -v */
197 static int rflag; /* true if -r */
198 static int strip_flag; /* true if -s */
199 #ifdef COLLECT_EXPORT_LIST
200 static int export_flag; /* true if -bE */
201 static int aix64_flag; /* true if -b64 */
204 int debug; /* true if -debug */
206 static int shared_obj; /* true if -shared */
208 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
209 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
210 #ifdef COLLECT_EXPORT_LIST
211 static const char *export_file; /* <xxx>.x for AIX export list. */
213 const char *ldout; /* File for ld errors. */
214 static const char *output_file; /* Output file for ld. */
215 static const char *nm_file_name; /* pathname of nm */
217 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
219 static const char *strip_file_name; /* pathname of strip */
220 const char *c_file_name; /* pathname of gcc */
221 static char *initname, *fininame; /* names of init and fini funcs */
223 static struct head constructors; /* list of constructors found */
224 static struct head destructors; /* list of destructors found */
225 #ifdef COLLECT_EXPORT_LIST
226 static struct head exports; /* list of exported symbols */
228 static struct head frame_tables; /* list of frame unwind info tables */
230 struct obstack temporary_obstack;
231 struct obstack permanent_obstack;
232 char * temporary_firstobj;
234 /* Holds the return value of pexecute. */
237 /* Defined in the automatically-generated underscore.c. */
238 extern int prepends_underscore;
240 #ifndef GET_ENV_PATH_LIST
241 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
244 /* Structure to hold all the directories in which to search for files to
249 const char *prefix; /* String to prepend to the path. */
250 struct prefix_list *next; /* Next in linked list. */
255 struct prefix_list *plist; /* List of prefixes to try */
256 int max_len; /* Max length of a prefix in PLIST */
257 const char *name; /* Name of this list (used in config stuff) */
260 #ifdef COLLECT_EXPORT_LIST
261 /* Lists to keep libraries to be scanned for global constructors/destructors. */
262 static struct head libs; /* list of libraries */
263 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
264 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
265 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
266 &libpath_lib_dirs, NULL};
267 static const char *const libexts[3] = {"a", "so", NULL}; /* possible library extentions */
270 static void handler PARAMS ((int));
271 static int is_ctor_dtor PARAMS ((const char *));
272 static char *find_a_file PARAMS ((struct path_prefix *, const char *));
273 static void add_prefix PARAMS ((struct path_prefix *, const char *));
274 static void prefix_from_env PARAMS ((const char *, struct path_prefix *));
275 static void prefix_from_string PARAMS ((const char *, struct path_prefix *));
276 static void do_wait PARAMS ((const char *));
277 static void fork_execute PARAMS ((const char *, char **));
278 static void maybe_unlink PARAMS ((const char *));
279 static void add_to_list PARAMS ((struct head *, const char *));
280 static int extract_init_priority PARAMS ((const char *));
281 static void sort_ids PARAMS ((struct head *));
282 static void write_list PARAMS ((FILE *, const char *, struct id *));
283 #ifdef COLLECT_EXPORT_LIST
284 static void dump_list PARAMS ((FILE *, const char *, struct id *));
287 static void dump_prefix_list PARAMS ((FILE *, const char *, struct prefix_list *));
289 static void write_list_with_asm PARAMS ((FILE *, const char *, struct id *));
290 static void write_c_file PARAMS ((FILE *, const char *));
291 static void write_c_file_stat PARAMS ((FILE *, const char *));
292 #ifndef LD_INIT_SWITCH
293 static void write_c_file_glob PARAMS ((FILE *, const char *));
295 static void scan_prog_file PARAMS ((const char *, enum pass));
296 #ifdef SCAN_LIBRARIES
297 static void scan_libraries PARAMS ((const char *));
299 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
300 static int is_in_args PARAMS ((const char *, const char **, const char **));
302 #ifdef COLLECT_EXPORT_LIST
303 static int is_in_list PARAMS ((const char *, struct id *));
304 static void write_aix_file PARAMS ((FILE *, struct id *));
305 static char *resolve_lib_name PARAMS ((const char *));
306 static int ignore_library PARAMS ((const char *));
308 static char *extract_string PARAMS ((const char **));
323 while ((fd = dup (oldfd)) != newfd && fd >= 0) /* good enough for low fd's */
326 close (fdtmp[--fdx]);
332 /* Delete tempfiles and exit function. */
335 collect_exit (status)
338 if (c_file != 0 && c_file[0])
339 maybe_unlink (c_file);
341 if (o_file != 0 && o_file[0])
342 maybe_unlink (o_file);
344 #ifdef COLLECT_EXPORT_LIST
345 if (export_file != 0 && export_file[0])
346 maybe_unlink (export_file);
349 if (ldout != 0 && ldout[0])
352 maybe_unlink (ldout);
355 if (status != 0 && output_file != 0 && output_file[0])
356 maybe_unlink (output_file);
362 /* Notify user of a non-error. */
364 notice VPARAMS ((const char *msgid, ...))
367 VA_FIXEDARG (ap, const char *, msgid);
369 vfprintf (stderr, _(msgid), ap);
373 /* Die when sys call fails. */
376 fatal_perror VPARAMS ((const char * msgid, ...))
381 VA_FIXEDARG (ap, const char *, msgid);
383 fprintf (stderr, "collect2: ");
384 vfprintf (stderr, _(msgid), ap);
385 fprintf (stderr, ": %s\n", xstrerror (e));
388 collect_exit (FATAL_EXIT_CODE);
394 fatal VPARAMS ((const char * msgid, ...))
397 VA_FIXEDARG (ap, const char *, msgid);
399 fprintf (stderr, "collect2: ");
400 vfprintf (stderr, _(msgid), ap);
401 fprintf (stderr, "\n");
404 collect_exit (FATAL_EXIT_CODE);
407 /* Write error message. */
410 error VPARAMS ((const char * msgid, ...))
413 VA_FIXEDARG (ap, const char *, msgid);
415 fprintf (stderr, "collect2: ");
416 vfprintf (stderr, _(msgid), ap);
417 fprintf (stderr, "\n");
421 /* In case obstack is linked in, and abort is defined to fancy_abort,
422 provide a default entry. */
427 fatal ("internal error");
434 if (c_file != 0 && c_file[0])
435 maybe_unlink (c_file);
437 if (o_file != 0 && o_file[0])
438 maybe_unlink (o_file);
440 if (ldout != 0 && ldout[0])
441 maybe_unlink (ldout);
443 #ifdef COLLECT_EXPORT_LIST
444 if (export_file != 0 && export_file[0])
445 maybe_unlink (export_file);
448 signal (signo, SIG_DFL);
449 kill (getpid (), signo);
457 return access (name, R_OK) == 0;
460 /* Parse a reasonable subset of shell quoting syntax. */
477 obstack_1grow (&temporary_obstack, c);
478 else if (! inside && c == ' ')
480 else if (! inside && c == '\\')
485 obstack_1grow (&temporary_obstack, c);
488 obstack_1grow (&temporary_obstack, '\0');
490 return obstack_finish (&temporary_obstack);
497 FILE *stream = fopen (name, "r");
504 while (c = getc (stream),
505 c != EOF && (ISALNUM (c) || c == '_' || c == '$' || c == '.'))
506 obstack_1grow (&temporary_obstack, c);
507 if (obstack_object_size (&temporary_obstack) > 0)
509 const char *word, *p;
511 obstack_1grow (&temporary_obstack, '\0');
512 word = obstack_finish (&temporary_obstack);
515 ++word, putc ('.', stderr);
517 if (*p == '_' && prepends_underscore)
523 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI);
528 fputs (result, stderr);
530 diff = strlen (word) - strlen (result);
531 while (diff > 0 && c == ' ')
532 --diff, putc (' ', stderr);
533 while (diff < 0 && c == ' ')
534 ++diff, c = getc (stream);
539 fputs (word, stderr);
542 obstack_free (&temporary_obstack, temporary_firstobj);
551 /* Decide whether the given symbol is: a constructor (1), a destructor
552 (2), a routine in a shared object that calls all the constructors
553 (3) or destructors (4), a DWARF exception-handling table (5), or
554 nothing special (0). */
560 struct names { const char *const name; int len; int ret; int two_underscores; };
562 register struct names *p;
564 register const char *orig_s = s;
566 static struct names special[] = {
567 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
568 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
569 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, 5, 0 },
570 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
571 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
572 #ifdef CFRONT_LOSSAGE /* Do not collect cfront initialization functions.
573 cfront has its own linker procedure to collect them;
574 if collect2 gets them too, they get collected twice
575 when the cfront procedure is run and the compiler used
576 for linking happens to be GCC. */
577 { "sti__", sizeof ("sti__")-1, 1, 1 },
578 { "std__", sizeof ("std__")-1, 2, 1 },
579 #endif /* CFRONT_LOSSAGE */
583 while ((ch = *s) == '_')
589 for (p = &special[0]; p->len > 0; p++)
592 && (!p->two_underscores || ((s - orig_s) >= 2))
593 && strncmp(s, p->name, p->len) == 0)
601 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
602 and one from the PATH variable. */
604 static struct path_prefix cpath, path;
607 /* This is the name of the target machine. We use it to form the name
608 of the files to execute. */
610 static const char *const target_machine = TARGET_MACHINE;
613 /* Search for NAME using prefix list PPREFIX. We only look for executable
616 Return 0 if not found, otherwise return its name, allocated with malloc. */
619 find_a_file (pprefix, name)
620 struct path_prefix *pprefix;
624 struct prefix_list *pl;
625 int len = pprefix->max_len + strlen (name) + 1;
628 fprintf (stderr, "Looking for '%s'\n", name);
630 #ifdef HOST_EXECUTABLE_SUFFIX
631 len += strlen (HOST_EXECUTABLE_SUFFIX);
634 temp = xmalloc (len);
636 /* Determine the filename to execute (special case for absolute paths). */
639 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
640 || (*name && name[1] == ':')
644 if (access (name, X_OK) == 0)
649 fprintf (stderr, " - found: absolute path\n");
654 #ifdef HOST_EXECUTABLE_SUFFIX
655 /* Some systems have a suffix for executable files.
656 So try appending that. */
658 strcat (temp, HOST_EXECUTABLE_SUFFIX);
660 if (access (temp, X_OK) == 0)
665 fprintf (stderr, " - failed to locate using absolute path\n");
668 for (pl = pprefix->plist; pl; pl = pl->next)
672 strcpy (temp, pl->prefix);
675 if (stat (temp, &st) >= 0
676 && ! S_ISDIR (st.st_mode)
677 && access (temp, X_OK) == 0)
680 #ifdef HOST_EXECUTABLE_SUFFIX
681 /* Some systems have a suffix for executable files.
682 So try appending that. */
683 strcat (temp, HOST_EXECUTABLE_SUFFIX);
685 if (stat (temp, &st) >= 0
686 && ! S_ISDIR (st.st_mode)
687 && access (temp, X_OK) == 0)
692 if (debug && pprefix->plist == NULL)
693 fprintf (stderr, " - failed: no entries in prefix list\n");
699 /* Add an entry for PREFIX to prefix list PPREFIX. */
702 add_prefix (pprefix, prefix)
703 struct path_prefix *pprefix;
706 struct prefix_list *pl, **prev;
711 for (pl = pprefix->plist; pl->next; pl = pl->next)
716 prev = &pprefix->plist;
718 /* Keep track of the longest prefix */
720 len = strlen (prefix);
721 if (len > pprefix->max_len)
722 pprefix->max_len = len;
724 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
725 pl->prefix = xstrdup (prefix);
730 pl->next = (struct prefix_list *) 0;
734 /* Take the value of the environment variable ENV, break it into a path, and
735 add of the entries to PPREFIX. */
738 prefix_from_env (env, pprefix)
740 struct path_prefix *pprefix;
743 GET_ENV_PATH_LIST (p, env);
746 prefix_from_string (p, pprefix);
750 prefix_from_string (p, pprefix)
752 struct path_prefix *pprefix;
754 const char *startp, *endp;
755 char *nstore = (char *) xmalloc (strlen (p) + 3);
758 fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
763 if (*endp == PATH_SEPARATOR || *endp == 0)
765 strncpy (nstore, startp, endp-startp);
768 strcpy (nstore, "./");
770 else if (! IS_DIR_SEPARATOR (endp[-1]))
772 nstore[endp-startp] = DIR_SEPARATOR;
773 nstore[endp-startp+1] = 0;
776 nstore[endp-startp] = 0;
779 fprintf (stderr, " - add prefix: %s\n", nstore);
781 add_prefix (pprefix, nstore);
784 endp = startp = endp + 1;
793 int main PARAMS ((int, char *[]));
799 const char *const ld_suffix = "ld";
800 const char *full_ld_suffix = ld_suffix;
801 const char *const real_ld_suffix = "real-ld";
802 const char *const collect_ld_suffix = "collect-ld";
803 const char *const nm_suffix = "nm";
804 const char *full_nm_suffix = nm_suffix;
805 const char *const gnm_suffix = "gnm";
806 const char *full_gnm_suffix = gnm_suffix;
808 const char *const ldd_suffix = LDD_SUFFIX;
809 const char *full_ldd_suffix = ldd_suffix;
811 const char *const strip_suffix = "strip";
812 const char *full_strip_suffix = strip_suffix;
813 const char *const gstrip_suffix = "gstrip";
814 const char *full_gstrip_suffix = gstrip_suffix;
817 #ifdef COLLECT_EXPORT_LIST
820 const char *ld_file_name;
831 int num_c_args = argc+9;
833 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
835 /* Suppress demangling by the real linker, which may be broken. */
836 putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
838 #if defined (COLLECT2_HOST_INITIALIZATION)
839 /* Perform system dependent initialization, if neccessary. */
840 COLLECT2_HOST_INITIALIZATION;
844 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
845 receive the signal. A different setting is inheritable */
846 signal (SIGCHLD, SIG_DFL);
849 /* LC_CTYPE determines the character set used by the terminal so it has be set
850 to output messages correctly. */
852 #ifdef HAVE_LC_MESSAGES
853 setlocale (LC_CTYPE, "");
854 setlocale (LC_MESSAGES, "");
856 setlocale (LC_ALL, "");
859 (void) bindtextdomain (PACKAGE, localedir);
860 (void) textdomain (PACKAGE);
862 /* Do not invoke xcalloc before this point, since locale needs to be
863 set first, in case a diagnostic is issued. */
865 ld1 = (const char **)(ld1_argv = (char **) xcalloc(sizeof (char *), argc+3));
866 ld2 = (const char **)(ld2_argv = (char **) xcalloc(sizeof (char *), argc+10));
867 object = (const char **)(object_lst = (char **) xcalloc(sizeof (char *), argc));
873 /* Parse command line early for instances of -debug. This allows
874 the debug flag to be set before functions like find_a_file()
879 for (i = 1; argv[i] != NULL; i ++)
880 if (! strcmp (argv[i], "-debug"))
885 #ifndef DEFAULT_A_OUT_NAME
886 output_file = "a.out";
888 output_file = DEFAULT_A_OUT_NAME;
891 obstack_begin (&temporary_obstack, 0);
892 obstack_begin (&permanent_obstack, 0);
893 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
895 current_demangling_style = auto_demangling;
896 p = getenv ("COLLECT_GCC_OPTIONS");
899 const char *q = extract_string (&p);
900 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
903 obstack_free (&temporary_obstack, temporary_firstobj);
905 /* -fno-exceptions -w */
908 c_ptr = (const char **)
909 (c_argv = (char **) xcalloc (sizeof (char *), num_c_args));
912 fatal ("no arguments");
915 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
916 signal (SIGQUIT, handler);
918 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
919 signal (SIGINT, handler);
921 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
922 signal (SIGALRM, handler);
925 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
926 signal (SIGHUP, handler);
928 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
929 signal (SIGSEGV, handler);
931 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
932 signal (SIGBUS, handler);
935 /* Extract COMPILER_PATH and PATH into our prefix list. */
936 prefix_from_env ("COMPILER_PATH", &cpath);
937 prefix_from_env ("PATH", &path);
940 /* If we look for a program in the compiler directories, we just use
941 the short name, since these directories are already system-specific.
942 But it we look for a program in the system directories, we need to
943 qualify the program name with the target machine. */
945 full_ld_suffix = concat(target_machine, "-", ld_suffix, NULL);
948 full_gld_suffix = concat (target_machine, "-", gld_suffix, NULL);
951 full_nm_suffix = concat (target_machine, "-", nm_suffix, NULL);
953 full_gnm_suffix = concat (target_machine, "-", gnm_suffix, NULL);
956 full_ldd_suffix = concat (target_machine, "-", ldd_suffix, NULL);
959 full_strip_suffix = concat (target_machine, "-", strip_suffix, NULL);
961 full_gstrip_suffix = concat (target_machine, "-", gstrip_suffix, NULL);
962 #endif /* CROSS_COMPILE */
964 /* Try to discover a valid linker/nm/strip to use. */
966 /* Maybe we know the right file to use (if not cross). */
968 #ifdef DEFAULT_LINKER
969 if (access (DEFAULT_LINKER, X_OK) == 0)
970 ld_file_name = DEFAULT_LINKER;
971 if (ld_file_name == 0)
973 #ifdef REAL_LD_FILE_NAME
974 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
975 if (ld_file_name == 0)
977 /* Search the (target-specific) compiler dirs for ld'. */
978 ld_file_name = find_a_file (&cpath, real_ld_suffix);
979 /* Likewise for `collect-ld'. */
980 if (ld_file_name == 0)
981 ld_file_name = find_a_file (&cpath, collect_ld_suffix);
982 /* Search the compiler directories for `ld'. We have protection against
983 recursive calls in find_a_file. */
984 if (ld_file_name == 0)
985 ld_file_name = find_a_file (&cpath, ld_suffix);
986 /* Search the ordinary system bin directories
987 for `ld' (if native linking) or `TARGET-ld' (if cross). */
988 if (ld_file_name == 0)
989 ld_file_name = find_a_file (&path, full_ld_suffix);
991 #ifdef REAL_NM_FILE_NAME
992 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
993 if (nm_file_name == 0)
995 nm_file_name = find_a_file (&cpath, gnm_suffix);
996 if (nm_file_name == 0)
997 nm_file_name = find_a_file (&path, full_gnm_suffix);
998 if (nm_file_name == 0)
999 nm_file_name = find_a_file (&cpath, nm_suffix);
1000 if (nm_file_name == 0)
1001 nm_file_name = find_a_file (&path, full_nm_suffix);
1004 ldd_file_name = find_a_file (&cpath, ldd_suffix);
1005 if (ldd_file_name == 0)
1006 ldd_file_name = find_a_file (&path, full_ldd_suffix);
1009 #ifdef REAL_STRIP_FILE_NAME
1010 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1011 if (strip_file_name == 0)
1013 strip_file_name = find_a_file (&cpath, gstrip_suffix);
1014 if (strip_file_name == 0)
1015 strip_file_name = find_a_file (&path, full_gstrip_suffix);
1016 if (strip_file_name == 0)
1017 strip_file_name = find_a_file (&cpath, strip_suffix);
1018 if (strip_file_name == 0)
1019 strip_file_name = find_a_file (&path, full_strip_suffix);
1021 /* Determine the full path name of the C compiler to use. */
1022 c_file_name = getenv ("COLLECT_GCC");
1023 if (c_file_name == 0)
1025 #ifdef CROSS_COMPILE
1026 c_file_name = concat (target_machine, "-gcc", NULL);
1028 c_file_name = "gcc";
1032 p = find_a_file (&cpath, c_file_name);
1034 /* Here it should be safe to use the system search path since we should have
1035 already qualified the name of the compiler when it is needed. */
1037 p = find_a_file (&path, c_file_name);
1042 *ld1++ = *ld2++ = ld_file_name;
1044 /* Make temp file names. */
1045 c_file = make_temp_file (".c");
1046 o_file = make_temp_file (".o");
1047 #ifdef COLLECT_EXPORT_LIST
1048 export_file = make_temp_file (".x");
1050 ldout = make_temp_file (".ld");
1051 *c_ptr++ = c_file_name;
1058 #ifdef COLLECT_EXPORT_LIST
1059 /* Generate a list of directories from LIBPATH. */
1060 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1061 /* Add to this list also two standard directories where
1062 AIX loader always searches for libraries. */
1063 add_prefix (&libpath_lib_dirs, "/lib");
1064 add_prefix (&libpath_lib_dirs, "/usr/lib");
1067 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1069 AIX support needs to know if -shared has been specified before
1070 parsing commandline arguments. */
1072 p = getenv ("COLLECT_GCC_OPTIONS");
1075 const char *q = extract_string (&p);
1076 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1077 *c_ptr++ = obstack_copy0 (&permanent_obstack, q, strlen (q));
1078 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1079 *c_ptr++ = obstack_copy0 (&permanent_obstack, q, strlen (q));
1080 if (strncmp (q, "-shared", sizeof ("-shared") - 1) == 0)
1082 if (*q == '-' && q[1] == 'B')
1084 *c_ptr++ = obstack_copy0 (&permanent_obstack, q, strlen (q));
1087 q = extract_string (&p);
1088 *c_ptr++ = obstack_copy0 (&permanent_obstack, q, strlen (q));
1092 obstack_free (&temporary_obstack, temporary_firstobj);
1093 *c_ptr++ = "-fno-exceptions";
1096 /* !!! When GCC calls collect2,
1097 it does not know whether it is calling collect2 or ld.
1098 So collect2 cannot meaningfully understand any options
1099 except those ld understands.
1100 If you propose to make GCC pass some other option,
1101 just imagine what will happen if ld is really ld!!! */
1103 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1104 /* After the first file, put in the c++ rt0. */
1107 while ((arg = *++argv) != (char *) 0)
1109 *ld1++ = *ld2++ = arg;
1115 #ifdef COLLECT_EXPORT_LIST
1116 /* We want to disable automatic exports on AIX when user
1117 explicitly puts an export list in command line */
1119 if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1121 else if (arg[2] == '6' && arg[3] == '4')
1127 if (!strcmp (arg, "-debug"))
1129 /* Already parsed. */
1138 /* place o_file BEFORE this argument! */
1144 #ifdef COLLECT_EXPORT_LIST
1146 /* Resolving full library name. */
1147 const char *s = resolve_lib_name (arg+2);
1149 /* Saving a full library name. */
1150 add_to_list (&libs, s);
1155 #ifdef COLLECT_EXPORT_LIST
1156 /* Saving directories where to search for libraries. */
1158 add_prefix (&cmdline_lib_dirs, arg+2);
1161 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1163 if (is_in_args (arg, (const char **) ld1_argv, ld1-1))
1166 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1171 output_file = *ld1++ = *ld2++ = *++argv;
1173 #ifdef SWITCHES_NEED_SPACES
1174 && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1178 output_file = &arg[2];
1187 if (arg[2] == '\0' && do_collecting)
1189 /* We must strip after the nm run, otherwise C++ linking
1190 will not work. Thus we strip in the second ld run, or
1191 else with strip if there is no second ld run. */
1203 else if ((p = strrchr (arg, '.')) != (char *) 0
1204 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1205 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1206 || strcmp (p, ".obj") == 0))
1215 /* place o_file BEFORE this argument! */
1221 if (p[1] == 'o' || p[1] == 'l')
1223 #ifdef COLLECT_EXPORT_LIST
1224 /* libraries can be specified directly, i.e. without -l flag. */
1227 /* Saving a full library name. */
1228 add_to_list (&libs, arg);
1234 #ifdef COLLECT_EXPORT_LIST
1235 /* This is added only for debugging purposes. */
1238 fprintf (stderr, "List of libraries:\n");
1239 dump_list (stderr, "\t", libs.first);
1242 /* The AIX linker will discard static constructors in object files if
1243 nothing else in the file is referenced, so look at them first. */
1245 const char **export_object_lst = (const char **)object_lst;
1247 while (export_object_lst < object)
1248 scan_prog_file (*export_object_lst++, PASS_OBJ);
1251 struct id *list = libs.first;
1253 for (; list; list = list->next)
1254 scan_prog_file (list->name, PASS_FIRST);
1259 char *buf = concat ("-bE:", export_file, NULL);
1264 exportf = fopen (export_file, "w");
1265 if (exportf == (FILE *) 0)
1266 fatal_perror ("fopen %s", export_file);
1267 write_aix_file (exportf, exports.first);
1268 if (fclose (exportf))
1269 fatal_perror ("fclose %s", export_file);
1274 *c_ptr = *ld1 = *object = (char *) 0;
1278 notice ("collect2 version %s", version_string);
1279 #ifdef TARGET_VERSION
1282 fprintf (stderr, "\n");
1288 fprintf (stderr, "ld_file_name = %s\n",
1289 (ld_file_name ? ld_file_name : "not found"));
1290 fprintf (stderr, "c_file_name = %s\n",
1291 (c_file_name ? c_file_name : "not found"));
1292 fprintf (stderr, "nm_file_name = %s\n",
1293 (nm_file_name ? nm_file_name : "not found"));
1295 fprintf (stderr, "ldd_file_name = %s\n",
1296 (ldd_file_name ? ldd_file_name : "not found"));
1298 fprintf (stderr, "strip_file_name = %s\n",
1299 (strip_file_name ? strip_file_name : "not found"));
1300 fprintf (stderr, "c_file = %s\n",
1301 (c_file ? c_file : "not found"));
1302 fprintf (stderr, "o_file = %s\n",
1303 (o_file ? o_file : "not found"));
1305 ptr = getenv ("COLLECT_GCC_OPTIONS");
1307 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1309 ptr = getenv ("COLLECT_GCC");
1311 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1313 ptr = getenv ("COMPILER_PATH");
1315 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1317 ptr = getenv (LIBRARY_PATH_ENV);
1319 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1321 fprintf (stderr, "\n");
1324 /* Load the program, searching all libraries and attempting to provide
1325 undefined symbols from repository information. */
1327 /* On AIX we do this later. */
1328 #ifndef COLLECT_EXPORT_LIST
1329 do_tlink (ld1_argv, object_lst);
1332 /* If -r or they will be run via some other method, do not build the
1333 constructor or destructor list, just return now. */
1335 #ifndef COLLECT_EXPORT_LIST
1340 #ifdef COLLECT_EXPORT_LIST
1341 /* Do the link we avoided above if we are exiting. */
1342 do_tlink (ld1_argv, object_lst);
1344 /* But make sure we delete the export file we may have created. */
1345 if (export_file != 0 && export_file[0])
1346 maybe_unlink (export_file);
1348 maybe_unlink (c_file);
1349 maybe_unlink (o_file);
1353 /* Examine the namelist with nm and search it for static constructors
1354 and destructors to call.
1355 Write the constructor and destructor tables to a .s file and reload. */
1357 /* On AIX we already scanned for global constructors/destructors. */
1358 #ifndef COLLECT_EXPORT_LIST
1359 scan_prog_file (output_file, PASS_FIRST);
1362 #ifdef SCAN_LIBRARIES
1363 scan_libraries (output_file);
1368 notice ("%d constructor(s) found\n", constructors.number);
1369 notice ("%d destructor(s) found\n", destructors.number);
1370 notice ("%d frame table(s) found\n", frame_tables.number);
1373 if (constructors.number == 0 && destructors.number == 0
1374 && frame_tables.number == 0
1375 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1376 /* If we will be running these functions ourselves, we want to emit
1377 stubs into the shared library so that we do not have to relink
1378 dependent programs when we add static objects. */
1383 #ifdef COLLECT_EXPORT_LIST
1384 /* Do tlink without additional code generation */
1385 do_tlink (ld1_argv, object_lst);
1387 /* Strip now if it was requested on the command line. */
1390 char **real_strip_argv = (char **) xcalloc (sizeof (char *), 3);
1391 const char ** strip_argv = (const char **) real_strip_argv;
1393 strip_argv[0] = strip_file_name;
1394 strip_argv[1] = output_file;
1395 strip_argv[2] = (char *) 0;
1396 fork_execute ("strip", real_strip_argv);
1399 #ifdef COLLECT_EXPORT_LIST
1400 maybe_unlink (export_file);
1402 maybe_unlink (c_file);
1403 maybe_unlink (o_file);
1407 /* Sort ctor and dtor lists by priority. */
1408 sort_ids (&constructors);
1409 sort_ids (&destructors);
1411 maybe_unlink(output_file);
1412 outf = fopen (c_file, "w");
1413 if (outf == (FILE *) 0)
1414 fatal_perror ("fopen %s", c_file);
1416 write_c_file (outf, c_file);
1419 fatal_perror ("fclose %s", c_file);
1421 /* Tell the linker that we have initializer and finalizer functions. */
1422 #ifdef LD_INIT_SWITCH
1423 #ifdef COLLECT_EXPORT_LIST
1424 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1426 *ld2++ = LD_INIT_SWITCH;
1428 *ld2++ = LD_FINI_SWITCH;
1433 #ifdef COLLECT_EXPORT_LIST
1436 /* If we did not add export flag to link arguments before, add it to
1437 second link phase now. No new exports should have been added. */
1438 if (! exports.first)
1439 *ld2++ = concat ("-bE:", export_file, NULL);
1441 add_to_list (&exports, initname);
1442 add_to_list (&exports, fininame);
1443 add_to_list (&exports, "_GLOBAL__DI");
1444 add_to_list (&exports, "_GLOBAL__DD");
1445 exportf = fopen (export_file, "w");
1446 if (exportf == (FILE *) 0)
1447 fatal_perror ("fopen %s", export_file);
1448 write_aix_file (exportf, exports.first);
1449 if (fclose (exportf))
1450 fatal_perror ("fclose %s", export_file);
1454 /* End of arguments to second link phase. */
1459 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1460 output_file, c_file);
1461 write_c_file (stderr, "stderr");
1462 fprintf (stderr, "========== end of c_file\n\n");
1463 #ifdef COLLECT_EXPORT_LIST
1464 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1465 write_aix_file (stderr, exports.first);
1466 fprintf (stderr, "========== end of export_file\n\n");
1470 /* Assemble the constructor and destructor tables.
1471 Link the tables in with the rest of the program. */
1473 fork_execute ("gcc", c_argv);
1474 #ifdef COLLECT_EXPORT_LIST
1475 /* On AIX we must call tlink because of possible templates resolution */
1476 do_tlink (ld2_argv, object_lst);
1478 /* Otherwise, simply call ld because tlink is already done */
1479 fork_execute ("ld", ld2_argv);
1481 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1482 constructors/destructors in shared libraries. */
1483 scan_prog_file (output_file, PASS_SECOND);
1486 maybe_unlink (c_file);
1487 maybe_unlink (o_file);
1489 #ifdef COLLECT_EXPORT_LIST
1490 maybe_unlink (export_file);
1497 /* Wait for a process to finish, and exit if a non-zero status is found. */
1505 pwait (pexecute_pid, &status, 0);
1508 if (WIFSIGNALED (status))
1510 int sig = WTERMSIG (status);
1511 error ("%s terminated with signal %d [%s]%s",
1512 prog, sig, strsignal(sig),
1513 status & 0200 ? "" : ", core dumped");
1514 collect_exit (FATAL_EXIT_CODE);
1517 if (WIFEXITED (status))
1518 return WEXITSTATUS (status);
1527 int ret = collect_wait (prog);
1530 error ("%s returned %d exit status", prog, ret);
1536 /* Execute a program, and wait for the reply. */
1539 collect_execute (prog, argv, redir)
1546 int redir_handle = -1;
1547 int stdout_save = -1;
1548 int stderr_save = -1;
1556 fprintf (stderr, "%s", argv[0]);
1558 notice ("[cannot find %s]", prog);
1560 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1561 fprintf (stderr, " %s", str);
1563 fprintf (stderr, "\n");
1569 /* If we cannot find a program we need, complain error. Do this here
1570 since we might not end up needing something that we could not find. */
1573 fatal ("cannot find `%s'", prog);
1577 /* Open response file. */
1578 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT);
1580 /* Duplicate the stdout and stderr file handles
1581 so they can be restored later. */
1582 stdout_save = dup (STDOUT_FILENO);
1583 if (stdout_save == -1)
1584 fatal_perror ("redirecting stdout: %s", redir);
1585 stderr_save = dup (STDERR_FILENO);
1586 if (stderr_save == -1)
1587 fatal_perror ("redirecting stdout: %s", redir);
1589 /* Redirect stdout & stderr to our response file. */
1590 dup2 (redir_handle, STDOUT_FILENO);
1591 dup2 (redir_handle, STDERR_FILENO);
1594 pexecute_pid = pexecute (argv[0], argv, argv[0], NULL,
1595 &errmsg_fmt, &errmsg_arg,
1596 (PEXECUTE_FIRST | PEXECUTE_LAST | PEXECUTE_SEARCH));
1600 /* Restore stdout and stderr to their previous settings. */
1601 dup2 (stdout_save, STDOUT_FILENO);
1602 dup2 (stderr_save, STDERR_FILENO);
1604 /* Close reponse file. */
1605 close (redir_handle);
1608 if (pexecute_pid == -1)
1609 fatal_perror (errmsg_fmt, errmsg_arg);
1613 fork_execute (prog, argv)
1617 collect_execute (prog, argv, NULL);
1621 /* Unlink a file unless we are debugging. */
1630 notice ("[Leaving %s]\n", file);
1634 static long sequence_number = 0;
1636 /* Add a name to a linked list. */
1639 add_to_list (head_ptr, name)
1640 struct head *head_ptr;
1644 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
1646 strcpy (newid->name, name);
1648 if (head_ptr->first)
1649 head_ptr->last->next = newid;
1651 head_ptr->first = newid;
1653 /* Check for duplicate symbols. */
1654 for (p = head_ptr->first;
1655 strcmp (name, p->name) != 0;
1660 head_ptr->last->next = 0;
1665 newid->sequence = ++sequence_number;
1666 head_ptr->last = newid;
1670 /* Grab the init priority number from an init function name that
1671 looks like "_GLOBAL_.I.12345.foo". */
1674 extract_init_priority (name)
1679 while (name[pos] == '_')
1681 pos += 10; /* strlen ("GLOBAL__X_") */
1683 /* Extract init_p number from ctor/dtor name. */
1684 pri = atoi (name + pos);
1685 return pri ? pri : DEFAULT_INIT_PRIORITY;
1688 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1689 ctors will be run from right to left, dtors from left to right. */
1693 struct head *head_ptr;
1695 /* id holds the current element to insert. id_next holds the next
1696 element to insert. id_ptr iterates through the already sorted elements
1697 looking for the place to insert id. */
1698 struct id *id, *id_next, **id_ptr;
1700 id = head_ptr->first;
1702 /* We don't have any sorted elements yet. */
1703 head_ptr->first = NULL;
1705 for (; id; id = id_next)
1708 id->sequence = extract_init_priority (id->name);
1710 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
1712 /* If the sequence numbers are the same, we put the id from the
1713 file later on the command line later in the list. */
1714 || id->sequence > (*id_ptr)->sequence
1715 /* Hack: do lexical compare, too.
1716 || (id->sequence == (*id_ptr)->sequence
1717 && strcmp (id->name, (*id_ptr)->name) > 0) */
1726 /* Now set the sequence numbers properly so write_c_file works. */
1727 for (id = head_ptr->first; id; id = id->next)
1728 id->sequence = ++sequence_number;
1731 /* Write: `prefix', the names on list LIST, `suffix'. */
1734 write_list (stream, prefix, list)
1741 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1746 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1747 /* Given a STRING, return nonzero if it occurs in the list in range
1748 [ARGS_BEGIN,ARGS_END). */
1751 is_in_args (string, args_begin, args_end)
1753 const char **args_begin;
1754 const char **args_end;
1756 const char **args_pointer;
1757 for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
1758 if (strcmp (string, *args_pointer) == 0)
1762 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1764 #ifdef COLLECT_EXPORT_LIST
1765 /* This function is really used only on AIX, but may be useful. */
1767 is_in_list (prefix, list)
1773 if (!strcmp (prefix, list->name)) return 1;
1780 /* Added for debugging purpose. */
1781 #ifdef COLLECT_EXPORT_LIST
1783 dump_list (stream, prefix, list)
1790 fprintf (stream, "%s%s,\n", prefix, list->name);
1798 dump_prefix_list (stream, prefix, list)
1801 struct prefix_list *list;
1805 fprintf (stream, "%s%s,\n", prefix, list->prefix);
1812 write_list_with_asm (stream, prefix, list)
1819 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1820 prefix, list->sequence, list->name);
1825 /* Write out the constructor and destructor tables statically (for a shared
1826 object), along with the functions to execute them. */
1829 write_c_file_stat (stream, name)
1831 const char *name ATTRIBUTE_UNUSED;
1835 int frames = (frame_tables.number > 0);
1837 /* Figure out name of output_file, stripping off .so version. */
1838 p = strrchr (output_file, '/');
1854 if (strncmp (q, ".so", 3) == 0)
1863 /* q points to null at end of the string (or . of the .so version) */
1864 prefix = xmalloc (q - p + 1);
1865 strncpy (prefix, p, q - p);
1867 for (r = prefix; *r; r++)
1868 if (!ISALNUM ((unsigned char)*r))
1871 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
1872 output_file, prefix);
1874 initname = concat ("_GLOBAL__FI_", prefix, NULL);
1875 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
1879 /* Write the tables as C code */
1881 fprintf (stream, "static int count;\n");
1882 fprintf (stream, "typedef void entry_pt();\n");
1883 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1887 write_list_with_asm (stream, "extern void *", frame_tables.first);
1889 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1890 write_list (stream, "\t\t&", frame_tables.first);
1891 fprintf (stream, "\t0\n};\n");
1893 /* This must match what's in frame.h. */
1894 fprintf (stream, "struct object {\n");
1895 fprintf (stream, " void *pc_begin;\n");
1896 fprintf (stream, " void *pc_end;\n");
1897 fprintf (stream, " void *fde_begin;\n");
1898 fprintf (stream, " void *fde_array;\n");
1899 fprintf (stream, " __SIZE_TYPE__ count;\n");
1900 fprintf (stream, " struct object *next;\n");
1901 fprintf (stream, "};\n");
1903 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1904 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1906 fprintf (stream, "static void reg_frame () {\n");
1907 fprintf (stream, "\tstatic struct object ob;\n");
1908 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1909 fprintf (stream, "\t}\n");
1911 fprintf (stream, "static void dereg_frame () {\n");
1912 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1913 fprintf (stream, "\t}\n");
1916 fprintf (stream, "void %s() {\n", initname);
1917 if (constructors.number > 0 || frames)
1919 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1920 write_list (stream, "\t\t", constructors.first);
1922 fprintf (stream, "\treg_frame,\n");
1923 fprintf (stream, "\t};\n");
1924 fprintf (stream, "\tentry_pt **p;\n");
1925 fprintf (stream, "\tif (count++ != 0) return;\n");
1926 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1927 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1930 fprintf (stream, "\t++count;\n");
1931 fprintf (stream, "}\n");
1932 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1933 fprintf (stream, "void %s() {\n", fininame);
1934 if (destructors.number > 0 || frames)
1936 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1937 write_list (stream, "\t\t", destructors.first);
1939 fprintf (stream, "\tdereg_frame,\n");
1940 fprintf (stream, "\t};\n");
1941 fprintf (stream, "\tentry_pt **p;\n");
1942 fprintf (stream, "\tif (--count != 0) return;\n");
1943 fprintf (stream, "\tp = dtors;\n");
1944 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1945 destructors.number + frames);
1947 fprintf (stream, "}\n");
1951 fprintf (stream, "void _GLOBAL__DI() {\n\t%s();\n}\n", initname);
1952 fprintf (stream, "void _GLOBAL__DD() {\n\t%s();\n}\n", fininame);
1956 /* Write the constructor/destructor tables. */
1958 #ifndef LD_INIT_SWITCH
1960 write_c_file_glob (stream, name)
1962 const char *name ATTRIBUTE_UNUSED;
1964 /* Write the tables as C code */
1966 int frames = (frame_tables.number > 0);
1968 fprintf (stream, "typedef void entry_pt();\n\n");
1970 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1974 write_list_with_asm (stream, "extern void *", frame_tables.first);
1976 fprintf (stream, "\tstatic void *frame_table[] = {\n");
1977 write_list (stream, "\t\t&", frame_tables.first);
1978 fprintf (stream, "\t0\n};\n");
1980 /* This must match what's in frame.h. */
1981 fprintf (stream, "struct object {\n");
1982 fprintf (stream, " void *pc_begin;\n");
1983 fprintf (stream, " void *pc_end;\n");
1984 fprintf (stream, " void *fde_begin;\n");
1985 fprintf (stream, " void *fde_array;\n");
1986 fprintf (stream, " __SIZE_TYPE__ count;\n");
1987 fprintf (stream, " struct object *next;\n");
1988 fprintf (stream, "};\n");
1990 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1991 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1993 fprintf (stream, "static void reg_frame () {\n");
1994 fprintf (stream, "\tstatic struct object ob;\n");
1995 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1996 fprintf (stream, "\t}\n");
1998 fprintf (stream, "static void dereg_frame () {\n");
1999 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2000 fprintf (stream, "\t}\n");
2003 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2004 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2005 write_list (stream, "\t", constructors.first);
2007 fprintf (stream, "\treg_frame,\n");
2008 fprintf (stream, "\t0\n};\n\n");
2010 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2012 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2013 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2014 write_list (stream, "\t", destructors.first);
2016 fprintf (stream, "\tdereg_frame,\n");
2017 fprintf (stream, "\t0\n};\n\n");
2019 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2020 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2022 #endif /* ! LD_INIT_SWITCH */
2025 write_c_file (stream, name)
2029 fprintf (stream, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
2030 #ifndef LD_INIT_SWITCH
2032 write_c_file_glob (stream, name);
2035 write_c_file_stat (stream, name);
2036 fprintf (stream, "#ifdef __cplusplus\n}\n#endif\n");
2039 #ifdef COLLECT_EXPORT_LIST
2041 write_aix_file (stream, list)
2045 for (; list; list = list->next)
2047 fputs (list->name, stream);
2048 putc ('\n', stream);
2053 #ifdef OBJECT_FORMAT_NONE
2055 /* Generic version to scan the name list of the loaded program for
2056 the symbols g++ uses for static constructors and destructors.
2058 The constructor table begins at __CTOR_LIST__ and contains a count
2059 of the number of pointers (or -1 if the constructors are built in a
2060 separate section by the linker), followed by the pointers to the
2061 constructor functions, terminated with a null pointer. The
2062 destructor table has the same format, and begins at __DTOR_LIST__. */
2065 scan_prog_file (prog_name, which_pass)
2066 const char *prog_name;
2067 enum pass which_pass;
2069 void (*int_handler) PARAMS ((int));
2070 void (*quit_handler) PARAMS ((int));
2071 char *real_nm_argv[4];
2072 const char **nm_argv = (const char **) real_nm_argv;
2079 if (which_pass == PASS_SECOND)
2082 /* If we do not have an `nm', complain. */
2083 if (nm_file_name == 0)
2084 fatal ("cannot find `nm'");
2086 nm_argv[argc++] = nm_file_name;
2087 if (NM_FLAGS[0] != '\0')
2088 nm_argv[argc++] = NM_FLAGS;
2090 nm_argv[argc++] = prog_name;
2091 nm_argv[argc++] = (char *) 0;
2093 if (pipe (pipe_fd) < 0)
2094 fatal_perror ("pipe");
2096 inf = fdopen (pipe_fd[0], "r");
2097 if (inf == (FILE *) 0)
2098 fatal_perror ("fdopen");
2100 /* Trace if needed. */
2103 const char **p_argv;
2106 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2107 fprintf (stderr, " %s", str);
2109 fprintf (stderr, "\n");
2115 /* Spawn child nm on pipe */
2118 fatal_perror (VFORK_STRING);
2120 if (pid == 0) /* child context */
2123 if (dup2 (pipe_fd[1], 1) < 0)
2124 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2126 if (close (pipe_fd[0]) < 0)
2127 fatal_perror ("close %d", pipe_fd[0]);
2129 if (close (pipe_fd[1]) < 0)
2130 fatal_perror ("close %d", pipe_fd[1]);
2132 execv (nm_file_name, real_nm_argv);
2133 fatal_perror ("execvp %s", nm_file_name);
2136 /* Parent context from here on. */
2137 int_handler = (void (*) PARAMS ((int))) signal (SIGINT, SIG_IGN);
2139 quit_handler = (void (*) PARAMS ((int))) signal (SIGQUIT, SIG_IGN);
2142 if (close (pipe_fd[1]) < 0)
2143 fatal_perror ("close %d", pipe_fd[1]);
2146 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2148 /* Read each line of nm output. */
2149 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2154 /* If it contains a constructor or destructor name, add the name
2155 to the appropriate list. */
2157 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2158 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2165 /* Find the end of the symbol name.
2166 Do not include `|', because Encore nm can tack that on the end. */
2167 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2173 switch (is_ctor_dtor (name))
2176 if (which_pass != PASS_LIB)
2177 add_to_list (&constructors, name);
2181 if (which_pass != PASS_LIB)
2182 add_to_list (&destructors, name);
2186 if (which_pass != PASS_LIB)
2187 fatal ("init function found in object %s", prog_name);
2188 #ifndef LD_INIT_SWITCH
2189 add_to_list (&constructors, name);
2194 if (which_pass != PASS_LIB)
2195 fatal ("fini function found in object %s", prog_name);
2196 #ifndef LD_FINI_SWITCH
2197 add_to_list (&destructors, name);
2202 if (which_pass != PASS_LIB)
2203 add_to_list (&frame_tables, name);
2206 default: /* not a constructor or destructor */
2211 fprintf (stderr, "\t%s\n", buf);
2215 fprintf (stderr, "\n");
2217 if (fclose (inf) != 0)
2218 fatal_perror ("fclose");
2220 do_wait (nm_file_name);
2222 signal (SIGINT, int_handler);
2224 signal (SIGQUIT, quit_handler);
2228 #if SUNOS4_SHARED_LIBRARIES
2230 /* Routines to scan the SunOS 4 _DYNAMIC structure to find shared libraries
2231 that the output file depends upon and their initialization/finalization
2232 routines, if any. */
2237 #include <sys/mman.h>
2238 #include <sys/param.h>
2240 #include <sys/dir.h>
2242 /* pointers to the object file */
2243 unsigned object; /* address of memory mapped file */
2244 unsigned objsize; /* size of memory mapped to file */
2245 char * code; /* pointer to code segment */
2246 char * data; /* pointer to data segment */
2247 struct nlist *symtab; /* pointer to symbol table */
2248 struct link_dynamic *ld;
2249 struct link_dynamic_2 *ld_2;
2250 struct head libraries;
2252 /* Map the file indicated by NAME into memory and store its address. */
2254 static void mapfile PARAMS ((const char *));
2262 if ((fp = open (name, O_RDONLY)) == -1)
2263 fatal ("unable to open file '%s'", name);
2264 if (fstat (fp, &s) == -1)
2265 fatal ("unable to stat file '%s'", name);
2267 objsize = s.st_size;
2268 object = (unsigned) mmap (0, objsize, PROT_READ|PROT_WRITE, MAP_PRIVATE,
2270 if (object == (unsigned)-1)
2271 fatal ("unable to mmap file '%s'", name);
2276 /* Helpers for locatelib. */
2278 static const char *libname;
2280 static int libselect PARAMS ((struct direct *));
2286 return (strncmp (libname, d->d_name, strlen (libname)) == 0);
2289 /* If one file has an additional numeric extension past LIBNAME, then put
2290 that one first in the sort. If both files have additional numeric
2291 extensions, then put the one with the higher number first in the sort.
2293 We must verify that the extension is numeric, because Sun saves the
2294 original versions of patched libraries with a .FCS extension. Files with
2295 invalid extensions must go last in the sort, so that they will not be used. */
2296 static int libcompare PARAMS ((struct direct **, struct direct **));
2300 struct direct **d1, **d2;
2302 int i1, i2 = strlen (libname);
2303 char *e1 = (*d1)->d_name + i2;
2304 char *e2 = (*d2)->d_name + i2;
2306 while (*e1 && *e2 && *e1 == '.' && *e2 == '.'
2307 && e1[1] && ISDIGIT (e1[1]) && e2[1] && ISDIGIT (e2[1]))
2311 i1 = strtol (e1, &e1, 10);
2312 i2 = strtol (e2, &e2, 10);
2319 /* It has a valid numeric extension, prefer this one. */
2320 if (*e1 == '.' && e1[1] && ISDIGIT (e1[1]))
2322 /* It has a invalid numeric extension, must prefer the other one. */
2328 /* It has a valid numeric extension, prefer this one. */
2329 if (*e2 == '.' && e2[1] && ISDIGIT (e2[1]))
2331 /* It has a invalid numeric extension, must prefer the other one. */
2339 /* Given the name NAME of a dynamic dependency, find its pathname and add
2340 it to the list of libraries. */
2341 static void locatelib PARAMS ((const char *));
2347 static const char **l;
2349 char buf[MAXPATHLEN];
2357 /* counting elements in array, need 1 extra for null */
2359 ld_rules = (char *) (ld_2->ld_rules + code);
2363 for (; *ld_rules != 0; ld_rules++)
2364 if (*ld_rules == ':')
2366 ld_rules = (char *) (ld_2->ld_rules + code);
2367 ldr = xstrdup (ld_rules);
2369 p = getenv ("LD_LIBRARY_PATH");
2374 for (q = p ; *q != 0; q++)
2379 l = (const char **) xmalloc ((cnt + 3) * sizeof (char *));
2384 for (; *ldr != 0; ldr++)
2394 for (; *q != 0; q++)
2401 /* built in directories are /lib, /usr/lib, and /usr/local/lib */
2404 *pp++ = "/usr/local/lib";
2408 for (pp = l; *pp != 0 ; pp++)
2410 struct direct **namelist;
2412 if ((entries = scandir (*pp, &namelist, libselect, libcompare)) > 0)
2414 sprintf (buf, "%s/%s", *pp, namelist[entries - 1]->d_name);
2415 add_to_list (&libraries, buf);
2417 fprintf (stderr, "%s\n", buf);
2424 notice ("not found\n");
2426 fatal ("dynamic dependency %s not found", name);
2430 /* Scan the _DYNAMIC structure of the output file to find shared libraries
2431 that it depends upon and any constructors or destructors they contain. */
2434 scan_libraries (prog_name)
2435 const char *prog_name;
2437 struct exec *header;
2439 struct link_object *lo;
2440 char buff[MAXPATHLEN];
2443 mapfile (prog_name);
2444 header = (struct exec *)object;
2445 if (N_BADMAG (*header))
2446 fatal ("bad magic number in file '%s'", prog_name);
2447 if (header->a_dynamic == 0)
2450 code = (char *) (N_TXTOFF (*header) + (long) header);
2451 data = (char *) (N_DATOFF (*header) + (long) header);
2452 symtab = (struct nlist *) (N_SYMOFF (*header) + (long) header);
2454 if (header->a_magic == ZMAGIC && header->a_entry == 0x20)
2457 ld = (struct link_dynamic *) (symtab->n_value + code);
2463 ld = (struct link_dynamic *) data;
2468 notice ("dynamic dependencies.\n");
2470 ld_2 = (struct link_dynamic_2 *) ((long) ld->ld_un.ld_2 + (long)base);
2471 for (lo = (struct link_object *) ld_2->ld_need; lo;
2472 lo = (struct link_object *) lo->lo_next)
2475 lo = (struct link_object *) ((long) lo + code);
2476 name = (char *) (code + lo->lo_name);
2480 fprintf (stderr, "\t-l%s.%d => ", name, lo->lo_major);
2481 sprintf (buff, "lib%s.so.%d.%d", name, lo->lo_major, lo->lo_minor);
2487 fprintf (stderr, "\t%s\n", name);
2488 add_to_list (&libraries, name);
2493 fprintf (stderr, "\n");
2495 /* now iterate through the library list adding their symbols to
2497 for (list = libraries.first; list; list = list->next)
2498 scan_prog_file (list->name, PASS_LIB);
2501 #else /* SUNOS4_SHARED_LIBRARIES */
2504 /* Use the List Dynamic Dependencies program to find shared libraries that
2505 the output file depends upon and their initialization/finalization
2506 routines, if any. */
2509 scan_libraries (prog_name)
2510 const char *prog_name;
2512 static struct head libraries; /* list of shared libraries found */
2514 void (*int_handler) PARAMS ((int));
2515 void (*quit_handler) PARAMS ((int));
2516 char *real_ldd_argv[4];
2517 const char **ldd_argv = (const char **) real_ldd_argv;
2524 /* If we do not have an `ldd', complain. */
2525 if (ldd_file_name == 0)
2527 error ("cannot find `ldd'");
2531 ldd_argv[argc++] = ldd_file_name;
2532 ldd_argv[argc++] = prog_name;
2533 ldd_argv[argc++] = (char *) 0;
2535 if (pipe (pipe_fd) < 0)
2536 fatal_perror ("pipe");
2538 inf = fdopen (pipe_fd[0], "r");
2539 if (inf == (FILE *) 0)
2540 fatal_perror ("fdopen");
2542 /* Trace if needed. */
2545 const char **p_argv;
2548 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2549 fprintf (stderr, " %s", str);
2551 fprintf (stderr, "\n");
2557 /* Spawn child ldd on pipe */
2560 fatal_perror (VFORK_STRING);
2562 if (pid == 0) /* child context */
2565 if (dup2 (pipe_fd[1], 1) < 0)
2566 fatal_perror ("dup2 %d 1", pipe_fd[1]);
2568 if (close (pipe_fd[0]) < 0)
2569 fatal_perror ("close %d", pipe_fd[0]);
2571 if (close (pipe_fd[1]) < 0)
2572 fatal_perror ("close %d", pipe_fd[1]);
2574 execv (ldd_file_name, real_ldd_argv);
2575 fatal_perror ("execv %s", ldd_file_name);
2578 /* Parent context from here on. */
2579 int_handler = (void (*) PARAMS ((int))) signal (SIGINT, SIG_IGN);
2581 quit_handler = (void (*) PARAMS ((int))) signal (SIGQUIT, SIG_IGN);
2584 if (close (pipe_fd[1]) < 0)
2585 fatal_perror ("close %d", pipe_fd[1]);
2588 notice ("\nldd output with constructors/destructors.\n");
2590 /* Read each line of ldd output. */
2591 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2594 char *name, *end, *p = buf;
2596 /* Extract names of libraries and add to list. */
2597 PARSE_LDD_OUTPUT (p);
2602 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2603 fatal ("dynamic dependency %s not found", buf);
2605 /* Find the end of the symbol name. */
2607 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2612 if (access (name, R_OK) == 0)
2613 add_to_list (&libraries, name);
2615 fatal ("unable to open dynamic dependency '%s'", buf);
2618 fprintf (stderr, "\t%s\n", buf);
2621 fprintf (stderr, "\n");
2623 if (fclose (inf) != 0)
2624 fatal_perror ("fclose");
2626 do_wait (ldd_file_name);
2628 signal (SIGINT, int_handler);
2630 signal (SIGQUIT, quit_handler);
2633 /* now iterate through the library list adding their symbols to
2635 for (list = libraries.first; list; list = list->next)
2636 scan_prog_file (list->name, PASS_LIB);
2639 #endif /* LDD_SUFFIX */
2640 #endif /* SUNOS4_SHARED_LIBRARIES */
2642 #endif /* OBJECT_FORMAT_NONE */
2646 * COFF specific stuff.
2649 #ifdef OBJECT_FORMAT_COFF
2651 #if defined(EXTENDED_COFF)
2653 # define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2654 # define GCC_SYMENT SYMR
2655 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2656 # define GCC_SYMINC(X) (1)
2657 # define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2658 # define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2662 # define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2663 # define GCC_SYMENT SYMENT
2664 # define GCC_OK_SYMBOL(X) \
2665 (((X).n_sclass == C_EXT) && \
2666 ((X).n_scnum > N_UNDEF) && \
2668 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2669 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2670 # define GCC_UNDEF_SYMBOL(X) \
2671 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2672 # define GCC_SYMINC(X) ((X).n_numaux+1)
2673 # define GCC_SYMZERO(X) 0
2675 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2677 # define GCC_CHECK_HDR(X) \
2678 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2679 || (HEADER (X).f_magic == 0767 && aix64_flag))
2681 # define GCC_CHECK_HDR(X) \
2682 ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2683 || (HEADER (X).f_magic == 0757 && aix64_flag))
2688 extern char *ldgetname ();
2690 /* COFF version to scan the name list of the loaded program for
2691 the symbols g++ uses for static constructors and destructors.
2693 The constructor table begins at __CTOR_LIST__ and contains a count
2694 of the number of pointers (or -1 if the constructors are built in a
2695 separate section by the linker), followed by the pointers to the
2696 constructor functions, terminated with a null pointer. The
2697 destructor table has the same format, and begins at __DTOR_LIST__. */
2700 scan_prog_file (prog_name, which_pass)
2701 const char *prog_name;
2702 enum pass which_pass;
2704 LDFILE *ldptr = NULL;
2705 int sym_index, sym_count;
2708 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2711 #ifdef COLLECT_EXPORT_LIST
2712 /* We do not need scanning for some standard C libraries. */
2713 if (which_pass == PASS_FIRST && ignore_library (prog_name))
2716 /* On AIX we have a loop, because there is not much difference
2717 between an object and an archive. This trick allows us to
2718 eliminate scan_libraries() function. */
2722 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2723 non-const char * filename parameter, even though it will not
2724 modify that string. So we must cast away const-ness here,
2725 which will cause -Wcast-qual to burp. */
2726 if ((ldptr = ldopen ((char *)prog_name, ldptr)) != NULL)
2728 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2729 fatal ("%s: not a COFF file", prog_name);
2731 if (GCC_CHECK_HDR (ldptr))
2733 sym_count = GCC_SYMBOLS (ldptr);
2734 sym_index = GCC_SYMZERO (ldptr);
2736 #ifdef COLLECT_EXPORT_LIST
2737 /* Is current archive member a shared object? */
2738 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2741 while (sym_index < sym_count)
2745 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2747 sym_index += GCC_SYMINC (symbol);
2749 if (GCC_OK_SYMBOL (symbol))
2753 if ((name = ldgetname (ldptr, &symbol)) == NULL)
2754 continue; /* should never happen */
2756 #ifdef XCOFF_DEBUGGING_INFO
2757 /* All AIX function names have a duplicate entry
2758 beginning with a dot. */
2763 switch (is_ctor_dtor (name))
2767 add_to_list (&constructors, name);
2768 #ifdef COLLECT_EXPORT_LIST
2769 if (which_pass == PASS_OBJ)
2770 add_to_list (&exports, name);
2776 add_to_list (&destructors, name);
2777 #ifdef COLLECT_EXPORT_LIST
2778 if (which_pass == PASS_OBJ)
2779 add_to_list (&exports, name);
2783 #ifdef COLLECT_EXPORT_LIST
2785 #ifndef LD_INIT_SWITCH
2787 add_to_list (&constructors, name);
2792 #ifndef LD_INIT_SWITCH
2794 add_to_list (&destructors, name);
2801 add_to_list (&frame_tables, name);
2802 #ifdef COLLECT_EXPORT_LIST
2803 if (which_pass == PASS_OBJ)
2804 add_to_list (&exports, name);
2808 default: /* not a constructor or destructor */
2809 #ifdef COLLECT_EXPORT_LIST
2810 /* If we are building a shared object on AIX we need
2811 to explicitly export all global symbols. */
2814 if (which_pass == PASS_OBJ && (! export_flag))
2815 add_to_list (&exports, name);
2822 #if !defined(EXTENDED_COFF)
2823 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2824 symbol.n_scnum, symbol.n_sclass,
2825 (symbol.n_type ? "0" : ""), symbol.n_type,
2829 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2830 symbol.iss, (long) symbol.value, symbol.index, name);
2835 #ifdef COLLECT_EXPORT_LIST
2838 /* If archive contains both 32-bit and 64-bit objects,
2839 we want to skip objects in other mode so mismatch normal. */
2841 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
2842 prog_name, HEADER (ldptr).f_magic, aix64_flag);
2848 fatal ("%s: cannot open as COFF file", prog_name);
2850 #ifdef COLLECT_EXPORT_LIST
2851 /* On AIX loop continues while there are more members in archive. */
2853 while (ldclose (ldptr) == FAILURE);
2855 /* Otherwise we simply close ldptr. */
2856 (void) ldclose(ldptr);
2861 #ifdef COLLECT_EXPORT_LIST
2862 /* Given a library name without "lib" prefix, this function
2863 returns a full library name including a path. */
2865 resolve_lib_name (name)
2871 for (i = 0; libpaths[i]; i++)
2872 if (libpaths[i]->max_len > l)
2873 l = libpaths[i]->max_len;
2875 lib_buf = xmalloc (l + strlen(name) + 10);
2877 for (i = 0; libpaths[i]; i++)
2879 struct prefix_list *list = libpaths[i]->plist;
2880 for (; list; list = list->next)
2882 /* The following lines are needed because path_prefix list
2883 may contain directories both with trailing '/' and
2886 if (list->prefix[strlen(list->prefix)-1] != '/')
2888 for (j = 0; libexts[j]; j++)
2890 sprintf (lib_buf, "%s%slib%s.%s",
2891 list->prefix, p, name, libexts[j]);
2892 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2893 if (file_exists (lib_buf))
2895 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2902 fprintf (stderr, "not found\n");
2904 fatal ("Library lib%s not found", name);
2908 /* Array of standard AIX libraries which should not
2909 be scanned for ctors/dtors. */
2910 static const char *const aix_std_libs[] = {
2918 "/usr/lib/libc_r.a",
2919 "/usr/lib/libm_r.a",
2920 "/usr/lib/threads/libc.a",
2921 "/usr/ccs/lib/libc.a",
2922 "/usr/ccs/lib/libm.a",
2923 "/usr/ccs/lib/libc_r.a",
2924 "/usr/ccs/lib/libm_r.a",
2928 /* This function checks the filename and returns 1
2929 if this name matches the location of a standard AIX library. */
2931 ignore_library (name)
2934 const char *const *p = &aix_std_libs[0];
2935 while (*p++ != NULL)
2936 if (! strcmp (name, *p)) return 1;
2941 #endif /* OBJECT_FORMAT_COFF */
2945 * OSF/rose specific stuff.
2948 #ifdef OBJECT_FORMAT_ROSE
2950 /* Union of the various load commands */
2952 typedef union load_union
2954 ldc_header_t hdr; /* common header */
2955 load_cmd_map_command_t map; /* map indexing other load cmds */
2956 interpreter_command_t iprtr; /* interpreter pathname */
2957 strings_command_t str; /* load commands strings section */
2958 region_command_t region; /* region load command */
2959 reloc_command_t reloc; /* relocation section */
2960 package_command_t pkg; /* package load command */
2961 symbols_command_t sym; /* symbol sections */
2962 entry_command_t ent; /* program start section */
2963 gen_info_command_t info; /* object information */
2964 func_table_command_t func; /* function constructors/destructors */
2967 /* Structure to point to load command and data section in memory. */
2969 typedef struct load_all
2971 load_union_t *load; /* load command */
2972 char *section; /* pointer to section */
2975 /* Structure to contain information about a file mapped into memory. */
2979 char *start; /* start of map */
2980 char *name; /* filename */
2981 long size; /* size of the file */
2982 long rounded_size; /* size rounded to page boundary */
2983 int fd; /* file descriptor */
2984 int rw; /* != 0 if opened read/write */
2985 int use_mmap; /* != 0 if mmap'ed */
2988 extern int decode_mach_o_hdr ();
2989 extern int encode_mach_o_hdr ();
2991 static void add_func_table PARAMS ((mo_header_t *, load_all_t *,
2992 symbol_info_t *, int));
2993 static void print_header PARAMS ((mo_header_t *));
2994 static void print_load_command PARAMS ((load_union_t *, size_t, int));
2995 static void bad_header PARAMS ((int));
2996 static struct file_info *read_file PARAMS ((const char *, int, int));
2997 static void end_file PARAMS ((struct file_info *));
2999 /* OSF/rose specific version to scan the name list of the loaded
3000 program for the symbols g++ uses for static constructors and
3003 The constructor table begins at __CTOR_LIST__ and contains a count
3004 of the number of pointers (or -1 if the constructors are built in a
3005 separate section by the linker), followed by the pointers to the
3006 constructor functions, terminated with a null pointer. The
3007 destructor table has the same format, and begins at __DTOR_LIST__. */
3010 scan_prog_file (prog_name, which_pass)
3011 const char *prog_name;
3012 enum pass which_pass;
3016 load_all_t *load_array;
3017 load_all_t *load_end;
3018 load_all_t *load_cmd;
3019 int symbol_load_cmds;
3025 struct file_info *obj_file;
3027 mo_lcid_t cmd_strings = -1;
3028 symbol_info_t *main_sym = 0;
3029 int rw = (which_pass != PASS_FIRST);
3031 prog_fd = open (prog_name, (rw) ? O_RDWR : O_RDONLY);
3033 fatal_perror ("open %s", prog_name);
3035 obj_file = read_file (prog_name, prog_fd, rw);
3036 obj = obj_file->start;
3038 status = decode_mach_o_hdr (obj, MO_SIZEOF_RAW_HDR, MOH_HEADER_VERSION, &hdr);
3039 if (status != MO_HDR_CONV_SUCCESS)
3040 bad_header (status);
3043 /* Do some basic sanity checks. Note we explicitly use the big endian magic number,
3044 since the hardware will automatically swap bytes for us on loading little endian
3047 #ifndef CROSS_COMPILE
3048 if (hdr.moh_magic != MOH_MAGIC_MSB
3049 || hdr.moh_header_version != MOH_HEADER_VERSION
3050 || hdr.moh_byte_order != OUR_BYTE_ORDER
3051 || hdr.moh_data_rep_id != OUR_DATA_REP_ID
3052 || hdr.moh_cpu_type != OUR_CPU_TYPE
3053 || hdr.moh_cpu_subtype != OUR_CPU_SUBTYPE
3054 || hdr.moh_vendor_type != OUR_VENDOR_TYPE)
3056 fatal ("incompatibilities between object file & expected values");
3061 print_header (&hdr);
3063 offset = hdr.moh_first_cmd_off;
3064 load_end = load_array
3065 = (load_all_t *) xcalloc (sizeof (load_all_t), hdr.moh_n_load_cmds + 2);
3067 /* Build array of load commands, calculating the offsets */
3068 for (i = 0; i < hdr.moh_n_load_cmds; i++)
3070 load_union_t *load_hdr; /* load command header */
3072 load_cmd = load_end++;
3073 load_hdr = (load_union_t *) (obj + offset);
3075 /* If modifying the program file, copy the header. */
3078 load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
3079 memcpy ((char *)ptr, (char *)load_hdr, load_hdr->hdr.ldci_cmd_size);
3082 /* null out old command map, because we will rewrite at the end. */
3083 if (ptr->hdr.ldci_cmd_type == LDC_CMD_MAP)
3085 cmd_strings = ptr->map.lcm_ld_cmd_strings;
3086 ptr->hdr.ldci_cmd_type = LDC_UNDEFINED;
3090 load_cmd->load = load_hdr;
3091 if (load_hdr->hdr.ldci_section_off > 0)
3092 load_cmd->section = obj + load_hdr->hdr.ldci_section_off;
3095 print_load_command (load_hdr, offset, i);
3097 offset += load_hdr->hdr.ldci_cmd_size;
3100 /* If the last command is the load command map and is not undefined,
3101 decrement the count of load commands. */
3102 if (rw && load_end[-1].load->hdr.ldci_cmd_type == LDC_UNDEFINED)
3105 hdr.moh_n_load_cmds--;
3108 /* Go through and process each symbol table section. */
3109 symbol_load_cmds = 0;
3110 for (load_cmd = load_array; load_cmd < load_end; load_cmd++)
3112 load_union_t *load_hdr = load_cmd->load;
3114 if (load_hdr->hdr.ldci_cmd_type == LDC_SYMBOLS)
3120 const char *kind = "unknown";
3122 switch (load_hdr->sym.symc_kind)
3124 case SYMC_IMPORTS: kind = "imports"; break;
3125 case SYMC_DEFINED_SYMBOLS: kind = "defined"; break;
3126 case SYMC_STABS: kind = "stabs"; break;
3129 notice ("\nProcessing symbol table #%d, offset = 0x%.8lx, kind = %s\n",
3130 symbol_load_cmds, load_hdr->hdr.ldci_section_off, kind);
3133 if (load_hdr->sym.symc_kind != SYMC_DEFINED_SYMBOLS)
3136 str_sect = load_array[load_hdr->sym.symc_strings_section].section;
3137 if (str_sect == (char *) 0)
3138 fatal ("string section missing");
3140 if (load_cmd->section == (char *) 0)
3141 fatal ("section pointer missing");
3143 num_syms = load_hdr->sym.symc_nentries;
3144 for (i = 0; i < num_syms; i++)
3146 symbol_info_t *sym = ((symbol_info_t *) load_cmd->section) + i;
3147 char *name = sym->si_name.symbol_name + str_sect;
3154 char *n = name + strlen (name) - strlen (NAME__MAIN);
3156 if ((n - name) < 0 || strcmp (n, NAME__MAIN))
3166 switch (is_ctor_dtor (name))
3169 add_to_list (&constructors, name);
3173 add_to_list (&destructors, name);
3176 default: /* not a constructor or destructor */
3182 fprintf (stderr, "\ttype = 0x%.4x, sc = 0x%.2x, flags = 0x%.8x, name = %.30s\n",
3183 sym->si_type, sym->si_sc_type, sym->si_flags, name);
3188 if (symbol_load_cmds == 0)
3189 fatal ("no symbol table found");
3191 /* Update the program file now, rewrite header and load commands. At present,
3192 we assume that there is enough space after the last load command to insert
3193 one more. Since the first section written out is page aligned, and the
3194 number of load commands is small, this is ok for the present. */
3198 load_union_t *load_map;
3201 if (cmd_strings == -1)
3202 fatal ("no cmd_strings found");
3204 /* Add __main to initializer list.
3205 If we are building a program instead of a shared library, do not
3206 do anything, since in the current version, you cannot do mallocs
3207 and such in the constructors. */
3209 if (main_sym != (symbol_info_t *) 0
3210 && ((hdr.moh_flags & MOH_EXECABLE_F) == 0))
3211 add_func_table (&hdr, load_array, main_sym, FNTC_INITIALIZATION);
3214 notice ("\nUpdating header and load commands.\n\n");
3216 hdr.moh_n_load_cmds++;
3217 size = sizeof (load_cmd_map_command_t) + (sizeof (mo_offset_t) * (hdr.moh_n_load_cmds - 1));
3219 /* Create new load command map. */
3221 notice ("load command map, %d cmds, new size %ld.\n",
3222 (int) hdr.moh_n_load_cmds, (long) size);
3224 load_map = (load_union_t *) xcalloc (1, size);
3225 load_map->map.ldc_header.ldci_cmd_type = LDC_CMD_MAP;
3226 load_map->map.ldc_header.ldci_cmd_size = size;
3227 load_map->map.lcm_ld_cmd_strings = cmd_strings;
3228 load_map->map.lcm_nentries = hdr.moh_n_load_cmds;
3229 load_array[hdr.moh_n_load_cmds-1].load = load_map;
3231 offset = hdr.moh_first_cmd_off;
3232 for (i = 0; i < hdr.moh_n_load_cmds; i++)
3234 load_map->map.lcm_map[i] = offset;
3235 if (load_array[i].load->hdr.ldci_cmd_type == LDC_CMD_MAP)
3236 hdr.moh_load_map_cmd_off = offset;
3238 offset += load_array[i].load->hdr.ldci_cmd_size;
3241 hdr.moh_sizeofcmds = offset - MO_SIZEOF_RAW_HDR;
3244 print_header (&hdr);
3247 status = encode_mach_o_hdr (&hdr, obj, MO_SIZEOF_RAW_HDR);
3248 if (status != MO_HDR_CONV_SUCCESS)
3249 bad_header (status);
3252 notice ("writing load commands.\n\n");
3254 /* Write load commands */
3255 offset = hdr.moh_first_cmd_off;
3256 for (i = 0; i < hdr.moh_n_load_cmds; i++)
3258 load_union_t *load_hdr = load_array[i].load;
3259 size_t size = load_hdr->hdr.ldci_cmd_size;
3262 print_load_command (load_hdr, offset, i);
3264 bcopy ((char *) load_hdr, (char *) (obj + offset), size);
3269 end_file (obj_file);
3271 if (close (prog_fd))
3272 fatal_perror ("close %s", prog_name);
3275 fprintf (stderr, "\n");
3279 /* Add a function table to the load commands to call a function
3280 on initiation or termination of the process. */
3283 add_func_table (hdr_p, load_array, sym, type)
3284 mo_header_t *hdr_p; /* pointer to global header */
3285 load_all_t *load_array; /* array of ptrs to load cmds */
3286 symbol_info_t *sym; /* pointer to symbol entry */
3287 int type; /* fntc_type value */
3289 /* Add a new load command. */
3290 int num_cmds = ++hdr_p->moh_n_load_cmds;
3291 int load_index = num_cmds - 1;
3292 size_t size = sizeof (func_table_command_t) + sizeof (mo_addr_t);
3293 load_union_t *ptr = xcalloc (1, size);
3294 load_all_t *load_cmd;
3297 /* Set the unresolved address bit in the header to force the loader to be
3298 used, since kernel exec does not call the initialization functions. */
3299 hdr_p->moh_flags |= MOH_UNRESOLVED_F;
3301 load_cmd = &load_array[load_index];
3302 load_cmd->load = ptr;
3303 load_cmd->section = (char *) 0;
3305 /* Fill in func table load command. */
3306 ptr->func.ldc_header.ldci_cmd_type = LDC_FUNC_TABLE;
3307 ptr->func.ldc_header.ldci_cmd_size = size;
3308 ptr->func.ldc_header.ldci_section_off = 0;
3309 ptr->func.ldc_header.ldci_section_len = 0;
3310 ptr->func.fntc_type = type;
3311 ptr->func.fntc_nentries = 1;
3313 /* copy address, turn it from abs. address to (region,offset) if necessary. */
3314 /* Is the symbol already expressed as (region, offset)? */
3315 if ((sym->si_flags & SI_ABSOLUTE_VALUE_F) == 0)
3317 ptr->func.fntc_entry_loc[i].adr_lcid = sym->si_value.def_val.adr_lcid;
3318 ptr->func.fntc_entry_loc[i].adr_sctoff = sym->si_value.def_val.adr_sctoff;
3321 /* If not, figure out which region it's in. */
3324 mo_vm_addr_t addr = sym->si_value.abs_val;
3327 for (i = 0; i < load_index; i++)
3329 if (load_array[i].load->hdr.ldci_cmd_type == LDC_REGION)
3331 region_command_t *region_ptr = &load_array[i].load->region;
3333 if ((region_ptr->regc_flags & REG_ABS_ADDR_F) != 0
3334 && addr >= region_ptr->regc_addr.vm_addr
3335 && addr <= region_ptr->regc_addr.vm_addr + region_ptr->regc_vm_size)
3337 ptr->func.fntc_entry_loc[0].adr_lcid = i;
3338 ptr->func.fntc_entry_loc[0].adr_sctoff = addr - region_ptr->regc_addr.vm_addr;
3346 fatal ("could not convert 0x%l.8x into a region", addr);
3350 notice ("%s function, region %d, offset = %ld (0x%.8lx)\n",
3351 type == FNTC_INITIALIZATION ? "init" : "term",
3352 (int) ptr->func.fntc_entry_loc[i].adr_lcid,
3353 (long) ptr->func.fntc_entry_loc[i].adr_sctoff,
3354 (long) ptr->func.fntc_entry_loc[i].adr_sctoff);
3359 /* Print the global header for an OSF/rose object. */
3362 print_header (hdr_ptr)
3363 mo_header_t *hdr_ptr;
3365 fprintf (stderr, "\nglobal header:\n");
3366 fprintf (stderr, "\tmoh_magic = 0x%.8lx\n", hdr_ptr->moh_magic);
3367 fprintf (stderr, "\tmoh_major_version = %d\n", (int)hdr_ptr->moh_major_version);
3368 fprintf (stderr, "\tmoh_minor_version = %d\n", (int)hdr_ptr->moh_minor_version);
3369 fprintf (stderr, "\tmoh_header_version = %d\n", (int)hdr_ptr->moh_header_version);
3370 fprintf (stderr, "\tmoh_max_page_size = %d\n", (int)hdr_ptr->moh_max_page_size);
3371 fprintf (stderr, "\tmoh_byte_order = %d\n", (int)hdr_ptr->moh_byte_order);
3372 fprintf (stderr, "\tmoh_data_rep_id = %d\n", (int)hdr_ptr->moh_data_rep_id);
3373 fprintf (stderr, "\tmoh_cpu_type = %d\n", (int)hdr_ptr->moh_cpu_type);
3374 fprintf (stderr, "\tmoh_cpu_subtype = %d\n", (int)hdr_ptr->moh_cpu_subtype);
3375 fprintf (stderr, "\tmoh_vendor_type = %d\n", (int)hdr_ptr->moh_vendor_type);
3376 fprintf (stderr, "\tmoh_load_map_cmd_off = %d\n", (int)hdr_ptr->moh_load_map_cmd_off);
3377 fprintf (stderr, "\tmoh_first_cmd_off = %d\n", (int)hdr_ptr->moh_first_cmd_off);
3378 fprintf (stderr, "\tmoh_sizeofcmds = %d\n", (int)hdr_ptr->moh_sizeofcmds);
3379 fprintf (stderr, "\tmon_n_load_cmds = %d\n", (int)hdr_ptr->moh_n_load_cmds);
3380 fprintf (stderr, "\tmoh_flags = 0x%.8lx", (long)hdr_ptr->moh_flags);
3382 if (hdr_ptr->moh_flags & MOH_RELOCATABLE_F)
3383 fprintf (stderr, ", relocatable");
3385 if (hdr_ptr->moh_flags & MOH_LINKABLE_F)
3386 fprintf (stderr, ", linkable");
3388 if (hdr_ptr->moh_flags & MOH_EXECABLE_F)
3389 fprintf (stderr, ", execable");
3391 if (hdr_ptr->moh_flags & MOH_EXECUTABLE_F)
3392 fprintf (stderr, ", executable");
3394 if (hdr_ptr->moh_flags & MOH_UNRESOLVED_F)
3395 fprintf (stderr, ", unresolved");
3397 fprintf (stderr, "\n\n");
3402 /* Print a short summary of a load command. */
3405 print_load_command (load_hdr, offset, number)
3406 load_union_t *load_hdr;
3410 mo_long_t type = load_hdr->hdr.ldci_cmd_type;
3411 const char *type_str = (char *) 0;
3415 case LDC_UNDEFINED: type_str = "UNDEFINED"; break;
3416 case LDC_CMD_MAP: type_str = "CMD_MAP"; break;
3417 case LDC_INTERPRETER: type_str = "INTERPRETER"; break;
3418 case LDC_STRINGS: type_str = "STRINGS"; break;
3419 case LDC_REGION: type_str = "REGION"; break;
3420 case LDC_RELOC: type_str = "RELOC"; break;
3421 case LDC_PACKAGE: type_str = "PACKAGE"; break;
3422 case LDC_SYMBOLS: type_str = "SYMBOLS"; break;
3423 case LDC_ENTRY: type_str = "ENTRY"; break;
3424 case LDC_FUNC_TABLE: type_str = "FUNC_TABLE"; break;
3425 case LDC_GEN_INFO: type_str = "GEN_INFO"; break;
3429 "cmd %2d, sz: 0x%.2lx, coff: 0x%.3lx, doff: 0x%.6lx, dlen: 0x%.6lx",
3431 (long) load_hdr->hdr.ldci_cmd_size,
3433 (long) load_hdr->hdr.ldci_section_off,
3434 (long) load_hdr->hdr.ldci_section_len);
3436 if (type_str == (char *) 0)
3437 fprintf (stderr, ", ty: unknown (%ld)\n", (long) type);
3439 else if (type != LDC_REGION)
3440 fprintf (stderr, ", ty: %s\n", type_str);
3444 const char *region = "";
3445 switch (load_hdr->region.regc_usage_type)
3447 case REG_TEXT_T: region = ", .text"; break;
3448 case REG_DATA_T: region = ", .data"; break;
3449 case REG_BSS_T: region = ", .bss"; break;
3450 case REG_GLUE_T: region = ", .glue"; break;
3451 #if defined (REG_RDATA_T) && defined (REG_SDATA_T) && defined (REG_SBSS_T) /*mips*/
3452 case REG_RDATA_T: region = ", .rdata"; break;
3453 case REG_SDATA_T: region = ", .sdata"; break;
3454 case REG_SBSS_T: region = ", .sbss"; break;
3458 fprintf (stderr, ", ty: %s, vaddr: 0x%.8lx, vlen: 0x%.6lx%s\n",
3460 (long) load_hdr->region.regc_vm_addr,
3461 (long) load_hdr->region.regc_vm_size,
3469 /* Fatal error when {en,de}code_mach_o_header fails. */
3477 case MO_ERROR_BAD_MAGIC: fatal ("bad magic number");
3478 case MO_ERROR_BAD_HDR_VERS: fatal ("bad header version");
3479 case MO_ERROR_BAD_RAW_HDR_VERS: fatal ("bad raw header version");
3480 case MO_ERROR_BUF2SML: fatal ("raw header buffer too small");
3481 case MO_ERROR_OLD_RAW_HDR_FILE: fatal ("old raw header file");
3482 case MO_ERROR_UNSUPPORTED_VERS: fatal ("unsupported version");
3484 fatal ("unknown {de,en}code_mach_o_hdr return value %d", status);
3489 /* Read a file into a memory buffer. */
3491 static struct file_info *
3492 read_file (name, fd, rw)
3493 const char *name; /* filename */
3494 int fd; /* file descriptor */
3495 int rw; /* read/write */
3497 struct stat stat_pkt;
3498 struct file_info *p = (struct file_info *) xcalloc (sizeof (struct file_info), 1);
3500 static int page_size;
3503 if (fstat (fd, &stat_pkt) < 0)
3504 fatal_perror ("fstat %s", name);
3507 p->size = stat_pkt.st_size;
3508 p->rounded_size = stat_pkt.st_size;
3514 fprintf (stderr, "mmap %s, %s\n", name, (rw) ? "read/write" : "read-only");
3517 page_size = sysconf (_SC_PAGE_SIZE);
3519 p->rounded_size = ((p->size + page_size - 1) / page_size) * page_size;
3520 p->start = mmap ((caddr_t) 0,
3521 (rw) ? p->rounded_size : p->size,
3522 (rw) ? (PROT_READ | PROT_WRITE) : PROT_READ,
3523 MAP_FILE | MAP_VARIABLE | MAP_SHARED,
3527 if (p->start != (char *) 0 && p->start != (char *) -1)
3531 #endif /* USE_MMAP */
3536 fprintf (stderr, "read %s\n", name);
3539 p->start = xmalloc (p->size);
3540 if (lseek (fd, 0L, SEEK_SET) < 0)
3541 fatal_perror ("lseek %s 0", name);
3543 len = read (fd, p->start, p->size);
3545 fatal_perror ("read %s", name);
3548 fatal ("read %ld bytes, expected %ld, from %s", len, p->size, name);
3554 /* Do anything necessary to write a file back from memory. */
3558 struct file_info *ptr; /* file information block */
3566 fprintf (stderr, "msync %s\n", ptr->name);
3568 if (msync (ptr->start, ptr->rounded_size, MS_ASYNC))
3569 fatal_perror ("msync %s", ptr->name);
3573 fprintf (stderr, "munmap %s\n", ptr->name);
3575 if (munmap (ptr->start, ptr->size))
3576 fatal_perror ("munmap %s", ptr->name);
3579 #endif /* USE_MMAP */
3586 fprintf (stderr, "write %s\n", ptr->name);
3588 if (lseek (ptr->fd, 0L, SEEK_SET) < 0)
3589 fatal_perror ("lseek %s 0", ptr->name);
3591 len = write (ptr->fd, ptr->start, ptr->size);
3593 fatal_perror ("write %s", ptr->name);
3595 if (len != ptr->size)
3596 fatal ("wrote %ld bytes, expected %ld, to %s", len, ptr->size, ptr->name);
3605 #endif /* OBJECT_FORMAT_ROSE */