Context Navigation

source: trunk/third/gcc/collect2.c @ 8834

Visit:

Revision 8834, 85.0 KB checked in by ghudson, 28 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r8833, which included commits to RCS files with non-trunk default branches.

Line
1	/* Collect static initialization info into data structures
2	that can be traversed by C++ initialization and finalization
3	routines.
4
5	Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
6	Contributed by Chris Smith (csmith@convex.com).
7	Heavily modified by Michael Meissner (meissner@cygnus.com),
8	Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
9
10	This file is part of GNU CC.
11
12	GNU CC is free software; you can redistribute it and/or modify
13	it under the terms of the GNU General Public License as published by
14	the Free Software Foundation; either version 2, or (at your option)
15	any later version.
16
17	GNU CC is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.
21
22	You should have received a copy of the GNU General Public License
23	along with GNU CC; see the file COPYING. If not, write to
24	the Free Software Foundation, 59 Temple Place - Suite 330,
25	Boston, MA 02111-1307, USA. */
26
27
28	/* Build tables of static constructors and destructors and run ld. */
29
30	#include "config.h"
31	#include <sys/types.h>
32	#include <stdio.h>
33	#include <ctype.h>
34	#include <errno.h>
35	#include <signal.h>
36	#include <sys/file.h>
37	#include <sys/stat.h>
38	#ifdef NO_WAIT_H
39	#include <sys/wait.h>
40	#endif
41
42	#define COLLECT
43
44	#include "demangle.h"
45	#include "obstack.h"
46
47	#ifndef errno
48	extern int errno;
49	#endif
50
51	#ifndef HAVE_STRERROR
52	#if defined(bsd4_4)
53	extern const char *const sys_errlist[];
54	#else
55	extern char *sys_errlist[];
56	#endif
57	extern int sys_nerr;
58	#else
59	char *strerror();
60	#endif
61
62	/* Obstack allocation and deallocation routines. */
63	#define obstack_chunk_alloc xmalloc
64	#define obstack_chunk_free free
65
66	#if !defined (__STDC__) && !defined (const)
67	#define const
68	#endif
69
70	#ifdef USG
71	#define vfork fork
72	#endif
73
74	/* Add prototype support. */
75	#ifndef PROTO
76	#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
77	#define PROTO(ARGS) ARGS
78	#else
79	#define PROTO(ARGS) ()
80	#endif
81	#endif
82
83	#ifndef R_OK
84	#define R_OK 4
85	#define W_OK 2
86	#define X_OK 1
87	#endif
88
89	#ifndef WIFSIGNALED
90	#define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f)
91	#endif
92	#ifndef WTERMSIG
93	#define WTERMSIG(S) ((S) & 0x7f)
94	#endif
95	#ifndef WIFEXITED
96	#define WIFEXITED(S) (((S) & 0xff) == 0)
97	#endif
98	#ifndef WEXITSTATUS
99	#define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
100	#endif
101
102	/* On MSDOS, write temp files in current dir
103	because there's no place else we can expect to use. */
104	#ifdef __MSDOS__
105	#ifndef P_tmpdir
106	#define P_tmpdir "./"
107	#endif
108	#endif
109
110	/* On certain systems, we have code that works by scanning the object file
111	directly. But this code uses system-specific header files and library
112	functions, so turn it off in a cross-compiler. Likewise, the names of
113	the utilities aren't correct for a cross-compiler; we have to hope that
114	cross-versions are in the proper directories. */
115
116	#ifdef CROSS_COMPILE
117	#undef SUNOS4_SHARED_LIBRARIES
118	#undef OBJECT_FORMAT_COFF
119	#undef OBJECT_FORMAT_ROSE
120	#undef MD_EXEC_PREFIX
121	#undef REAL_LD_FILE_NAME
122	#undef REAL_NM_FILE_NAME
123	#undef REAL_STRIP_FILE_NAME
124	#endif
125
126	/* If we can't use a special method, use the ordinary one:
127	run nm to find what symbols are present.
128	In a cross-compiler, this means you need a cross nm,
129	but that isn't quite as unpleasant as special headers. */
130
131	#if !defined (OBJECT_FORMAT_COFF) && !defined (OBJECT_FORMAT_ROSE)
132	#define OBJECT_FORMAT_NONE
133	#endif
134
135	#ifdef OBJECT_FORMAT_COFF
136
137	#include <a.out.h>
138	#include <ar.h>
139
140	#ifdef UMAX
141	#include <sgs.h>
142	#endif
143
144	/* Many versions of ldfcn.h define these. */
145	#ifdef FREAD
146	#undef FREAD
147	#undef FWRITE
148	#endif
149
150	#include <ldfcn.h>
151
152	/* Some systems have an ISCOFF macro, but others do not. In some cases
153	the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
154	that either do not have an ISCOFF macro in /usr/include or for those
155	where it is wrong. */
156
157	#ifndef MY_ISCOFF
158	#define MY_ISCOFF(X) ISCOFF (X)
159	#endif
160
161	#ifdef XCOFF_DEBUGGING_INFO
162	#define XCOFF_SCAN_LIBS
163	#endif
164
165	#endif /* OBJECT_FORMAT_COFF */
166
167	#ifdef OBJECT_FORMAT_ROSE
168
169	#ifdef _OSF_SOURCE
170	#define USE_MMAP
171	#endif
172
173	#ifdef USE_MMAP
174	#include <sys/mman.h>
175	#endif
176
177	#include <unistd.h>
178	#include <mach_o_format.h>
179	#include <mach_o_header.h>
180	#include <mach_o_vals.h>
181	#include <mach_o_types.h>
182
183	#endif /* OBJECT_FORMAT_ROSE */
184
185	#ifdef OBJECT_FORMAT_NONE
186
187	/* Default flags to pass to nm. */
188	#ifndef NM_FLAGS
189	#define NM_FLAGS "-p"
190	#endif
191
192	#endif /* OBJECT_FORMAT_NONE */
193
194	/* Some systems use __main in a way incompatible with its use in gcc, in these
195	cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
196	give the same symbol without quotes for an alternative entry point. You
197	must define both, or neither. */
198	#ifndef NAME__MAIN
199	#define NAME__MAIN "__main"
200	#define SYMBOL__MAIN __main
201	#endif
202
203	#if defined (LDD_SUFFIX) \|\| SUNOS4_SHARED_LIBRARIES \|\| defined(XCOFF_SCAN_LIBS)
204	#define SCAN_LIBRARIES
205	#endif
206
207	#ifdef USE_COLLECT2
208	int do_collecting = 1;
209	#else
210	int do_collecting = 0;
211	#endif
212
213	/* Linked lists of constructor and destructor names. */
214
215	struct id
216	{
217	struct id *next;
218	int sequence;
219	char name[1];
220	};
221
222	struct head
223	{
224	struct id *first;
225	struct id *last;
226	int number;
227	};
228
229	/* Enumeration giving which pass this is for scanning the program file. */
230
231	enum pass {
232	PASS_FIRST, /* without constructors */
233	PASS_OBJ, /* individual objects */
234	PASS_LIB, /* looking for shared libraries */
235	PASS_SECOND /* with constructors linked in */
236	};
237
238	#ifndef NO_SYS_SIGLIST
239	#ifndef DONT_DECLARE_SYS_SIGLIST
240	extern char *sys_siglist[];
241	#endif
242	#endif
243	extern char *version_string;
244
245	int vflag; /* true if -v */
246	static int rflag; /* true if -r */
247	static int strip_flag; /* true if -s */
248
249	int debug; /* true if -debug */
250
251	static int shared_obj; /* true if -shared */
252
253	static int temp_filename_length; /* Length of temp_filename */
254	static char temp_filename; / Base of temp filenames */
255	static char c_file; / <xxx>.c for constructor/destructor list. */
256	static char o_file; / <xxx>.o for constructor/destructor list. */
257	static char export_file; / <xxx>.x for AIX export list. */
258	char ldout; / File for ld errors. */
259	static char output_file; / Output file for ld. */
260	static char nm_file_name; / pathname of nm */
261	static char ldd_file_name; / pathname of ldd (or equivalent) */
262	static char strip_file_name; / pathname of strip */
263	char c_file_name; / pathname of gcc */
264	static char initname, fininame; /* names of init and fini funcs */
265
266	static struct head constructors; /* list of constructors found */
267	static struct head destructors; /* list of destructors found */
268	static struct head exports; /* list of exported symbols */
269
270	struct obstack temporary_obstack;
271	struct obstack permanent_obstack;
272	char * temporary_firstobj;
273
274	/* Defined in the automatically-generated underscore.c. */
275	extern int prepends_underscore;
276
277	extern char *getenv ();
278	extern char *mktemp ();
279	extern FILE *fdopen ();
280
281	/* Structure to hold all the directories in which to search for files to
282	execute. */
283
284	struct prefix_list
285	{
286	char prefix; / String to prepend to the path. */
287	struct prefix_list next; / Next in linked list. */
288	};
289
290	struct path_prefix
291	{
292	struct prefix_list plist; / List of prefixes to try */
293	int max_len; /* Max length of a prefix in PLIST */
294	char name; / Name of this list (used in config stuff) */
295	};
296
297	void collect_exit PROTO((int));
298	void collect_execute PROTO((char , char , char ));
299	void dump_file PROTO((char *));
300	static void handler PROTO((int));
301	static int is_ctor_dtor PROTO((char *));
302	static void choose_temp_base PROTO((void));
303	static int is_in_prefix_list PROTO((struct path_prefix , char , int));
304	static char find_a_file PROTO((struct path_prefix , char *));
305	static void add_prefix PROTO((struct path_prefix , char ));
306	static void prefix_from_env PROTO((char , struct path_prefix ));
307	static void prefix_from_string PROTO((char , struct path_prefix ));
308	static void do_wait PROTO((char *));
309	static void fork_execute PROTO((char , char *));
310	static void maybe_unlink PROTO((char *));
311	static void add_to_list PROTO((struct head , char ));
312	static void write_list PROTO((FILE , char , struct id *));
313	static void write_list_with_asm PROTO((FILE , char , struct id *));
314	static void write_c_file PROTO((FILE , char ));
315	static void write_export_file PROTO((FILE *));
316	static void scan_prog_file PROTO((char *, enum pass));
317	static void scan_libraries PROTO((char *));
318
319	char *xcalloc ();
320	char *xmalloc ();
321
322	extern char *index ();
323	extern char *rindex ();
324	extern void free ();
325
326	#ifdef NO_DUP2
327	int
328	dup2 (oldfd, newfd)
329	int oldfd;
330	int newfd;
331	{
332	int fdtmp[256];
333	int fdx = 0;
334	int fd;
335
336	if (oldfd == newfd)
337	return oldfd;
338	close (newfd);
339	while ((fd = dup (oldfd)) != newfd && fd >= 0) /* good enough for low fd's */
340	fdtmp[fdx++] = fd;
341	while (fdx > 0)
342	close (fdtmp[--fdx]);
343
344	return fd;
345	}
346	#endif
347
348	char *
349	my_strerror (e)
350	int e;
351	{
352
353	#ifdef HAVE_STRERROR
354	return strerror (e);
355
356	#else
357
358	static char buffer[30];
359	if (!e)
360	return "";
361
362	if (e > 0 && e < sys_nerr)
363	return sys_errlist[e];
364
365	sprintf (buffer, "Unknown error %d", e);
366	return buffer;
367	#endif
368	}
369
370	/* Delete tempfiles and exit function. */
371
372	void
373	collect_exit (status)
374	int status;
375	{
376	if (c_file != 0 && c_file[0])
377	maybe_unlink (c_file);
378
379	if (o_file != 0 && o_file[0])
380	maybe_unlink (o_file);
381
382	if (export_file != 0 && export_file[0])
383	maybe_unlink (export_file);
384
385	if (ldout != 0 && ldout[0])
386	{
387	dump_file (ldout);
388	maybe_unlink (ldout);
389	}
390
391	if (status != 0 && output_file != 0 && output_file[0])
392	maybe_unlink (output_file);
393
394	exit (status);
395	}
396
397
398	/* Die when sys call fails. */
399
400	void
401	fatal_perror (string, arg1, arg2, arg3)
402	char string, arg1, arg2, arg3;
403	{
404	int e = errno;
405
406	fprintf (stderr, "collect2: ");
407	fprintf (stderr, string, arg1, arg2, arg3);
408	fprintf (stderr, ": %s\n", my_strerror (e));
409	collect_exit (1);
410	}
411
412	/* Just die. */
413
414	void
415	fatal (string, arg1, arg2, arg3)
416	char string, arg1, arg2, arg3;
417	{
418	fprintf (stderr, "collect2: ");
419	fprintf (stderr, string, arg1, arg2, arg3);
420	fprintf (stderr, "\n");
421	collect_exit (1);
422	}
423
424	/* Write error message. */
425
426	void
427	error (string, arg1, arg2, arg3, arg4)
428	char string, arg1, arg2, arg3, *arg4;
429	{
430	fprintf (stderr, "collect2: ");
431	fprintf (stderr, string, arg1, arg2, arg3, arg4);
432	fprintf (stderr, "\n");
433	}
434
435	/* In case obstack is linked in, and abort is defined to fancy_abort,
436	provide a default entry. */
437
438	void
439	fancy_abort ()
440	{
441	fatal ("internal error");
442	}
443
444
445	static void
446	handler (signo)
447	int signo;
448	{
449	if (c_file != 0 && c_file[0])
450	maybe_unlink (c_file);
451
452	if (o_file != 0 && o_file[0])
453	maybe_unlink (o_file);
454
455	if (ldout != 0 && ldout[0])
456	maybe_unlink (ldout);
457
458	signal (signo, SIG_DFL);
459	kill (getpid (), signo);
460	}
461
462
463	char *
464	xcalloc (size1, size2)
465	int size1, size2;
466	{
467	char ptr = (char ) calloc (size1, size2);
468	if (ptr)
469	return ptr;
470
471	fatal ("out of memory");
472	return (char *)0;
473	}
474
475	char *
476	xmalloc (size)
477	unsigned size;
478	{
479	char ptr = (char ) malloc (size);
480	if (ptr)
481	return ptr;
482
483	fatal ("out of memory");
484	return (char *)0;
485	}
486
487	char *
488	xrealloc (ptr, size)
489	char *ptr;
490	unsigned size;
491	{
492	register char value = (char ) realloc (ptr, size);
493	if (value == 0)
494	fatal ("virtual memory exhausted");
495	return value;
496	}
497
498	int
499	file_exists (name)
500	char *name;
501	{
502	return access (name, R_OK) == 0;
503	}
504
505	/* Make a copy of a string INPUT with size SIZE. */
506
507	char *
508	savestring (input, size)
509	char *input;
510	int size;
511	{
512	char output = (char ) xmalloc (size + 1);
513	bcopy (input, output, size);
514	output[size] = 0;
515	return output;
516	}
517
518	void
519	dump_file (name)
520	char *name;
521	{
522	FILE *stream = fopen (name, "r");
523	int no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
524
525	if (stream == 0)
526	return;
527	while (1)
528	{
529	int c;
530	while (c = getc (stream),
531	c != EOF && (isalnum (c) \|\| c == '_' \|\| c == '$' \|\| c == '.'))
532	obstack_1grow (&temporary_obstack, c);
533	if (obstack_object_size (&temporary_obstack) > 0)
534	{
535	char word, p, *result;
536	obstack_1grow (&temporary_obstack, '\0');
537	word = obstack_finish (&temporary_obstack);
538
539	if (*word == '.')
540	++word, putc ('.', stderr);
541	p = word;
542	if (*p == '_' && prepends_underscore)
543	++p;
544
545	if (no_demangle)
546	result = 0;
547	else
548	result = cplus_demangle (p, DMGL_PARAMS \| DMGL_ANSI);
549
550	if (result)
551	{
552	int diff;
553	fputs (result, stderr);
554
555	diff = strlen (word) - strlen (result);
556	while (diff > 0)
557	--diff, putc (' ', stderr);
558	while (diff < 0 && c == ' ')
559	++diff, c = getc (stream);
560
561	free (result);
562	}
563	else
564	fputs (word, stderr);
565
566	fflush (stderr);
567	obstack_free (&temporary_obstack, temporary_firstobj);
568	}
569	if (c == EOF)
570	break;
571	putc (c, stderr);
572	}
573	}
574
575	/* Decide whether the given symbol is:
576	a constructor (1), a destructor (2), or neither (0). */
577
578	static int
579	is_ctor_dtor (s)
580	char *s;
581	{
582	struct names { char *name; int len; int ret; int two_underscores; };
583
584	register struct names *p;
585	register int ch;
586	register char *orig_s = s;
587
588	static struct names special[] = {
589	#ifdef NO_DOLLAR_IN_LABEL
590	#ifdef NO_DOT_IN_LABEL
591	{ "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
592	{ "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
593	#else
594	{ "GLOBAL_.I.", sizeof ("GLOBAL_.I.")-1, 1, 0 },
595	{ "GLOBAL_.D.", sizeof ("GLOBAL_.D.")-1, 2, 0 },
596	#endif
597	#else
598	{ "GLOBAL_$I$", sizeof ("GLOBAL_$I$")-1, 1, 0 },
599	{ "GLOBAL_$D$", sizeof ("GLOBAL_$D$")-1, 2, 0 },
600	#endif
601	{ "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
602	{ "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
603	#ifdef CFRONT_LOSSAGE /* Don't collect cfront initialization functions.
604	cfront has its own linker procedure to collect them;
605	if collect2 gets them too, they get collected twice
606	when the cfront procedure is run and the compiler used
607	for linking happens to be GCC. */
608	{ "sti__", sizeof ("sti__")-1, 1, 1 },
609	{ "std__", sizeof ("std__")-1, 2, 1 },
610	#endif /* CFRONT_LOSSAGE */
611	{ NULL, 0, 0, 0 }
612	};
613
614	while ((ch = *s) == '_')
615	++s;
616
617	if (s == orig_s)
618	return 0;
619
620	for (p = &special[0]; p->len > 0; p++)
621	{
622	if (ch == p->name[0]
623	&& (!p->two_underscores \|\| ((s - orig_s) >= 2))
624	&& strncmp(s, p->name, p->len) == 0)
625	{
626	return p->ret;
627	}
628	}
629	return 0;
630	}
631
632
633	/* Compute a string to use as the base of all temporary file names.
634	It is substituted for %g. */
635
636	static void
637	choose_temp_base ()
638	{
639	char *base = getenv ("TMPDIR");
640	int len;
641
642	if (base == (char *)0)
643	{
644	#ifdef P_tmpdir
645	if (access (P_tmpdir, R_OK \| W_OK) == 0)
646	base = P_tmpdir;
647	#endif
648	if (base == (char *)0)
649	{
650	if (access ("/usr/tmp", R_OK \| W_OK) == 0)
651	base = "/usr/tmp/";
652	else
653	base = "/tmp/";
654	}
655	}
656
657	len = strlen (base);
658	temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
659	strcpy (temp_filename, base);
660	if (len > 0 && temp_filename[len-1] != '/')
661	temp_filename[len++] = '/';
662	strcpy (temp_filename + len, "ccXXXXXX");
663
664	mktemp (temp_filename);
665	temp_filename_length = strlen (temp_filename);
666	}
667
668	/* Routine to add variables to the environment. */
669
670	#ifndef HAVE_PUTENV
671
672	int
673	putenv (str)
674	char *str;
675	{
676	#ifndef VMS /* nor about VMS */
677
678	extern char **environ;
679	char **old_environ = environ;
680	char **envp;
681	int num_envs = 0;
682	int name_len = 1;
683	char *p = str;
684	int ch;
685
686	while ((ch = *p++) != '\0' && ch != '=')
687	name_len++;
688
689	if (!ch)
690	abort ();
691
692	/* Search for replacing an existing environment variable, and
693	count the number of total environment variables. */
694	for (envp = old_environ; *envp; envp++)
695	{
696	num_envs++;
697	if (!strncmp (str, *envp, name_len))
698	{
699	*envp = str;
700	return 0;
701	}
702	}
703
704	/* Add a new environment variable */
705	environ = (char *) xmalloc (sizeof (char ) * (num_envs+2));
706	*environ = str;
707	bcopy ((char ) old_environ, (char ) (environ + 1),
708	sizeof (char ) (num_envs+1));
709
710	return 0;
711	#endif /* VMS */
712	}
713
714	#endif /* HAVE_PUTENV */
715
716	/* By default, colon separates directories in a path. */
717	#ifndef PATH_SEPARATOR
718	#define PATH_SEPARATOR ':'
719	#endif
720
721	/* We maintain two prefix lists: one from COMPILER_PATH environment variable
722	and one from the PATH variable. */
723
724	static struct path_prefix cpath, path;
725
726	#ifdef CROSS_COMPILE
727	/* This is the name of the target machine. We use it to form the name
728	of the files to execute. */
729
730	static char *target_machine = TARGET_MACHINE;
731	#endif
732
733	/* Names under which we were executed. Never return one of those files in our
734	searches. */
735
736	static struct path_prefix our_file_names;
737
738	/* Determine if STRING is in PPREFIX.
739
740	This utility is currently only used to look up file names. Prefix lists
741	record directory names. This matters to us because the latter has a
742	trailing slash, so I've added a flag to handle both. */
743
744	static int
745	is_in_prefix_list (pprefix, string, filep)
746	struct path_prefix *pprefix;
747	char *string;
748	int filep;
749	{
750	struct prefix_list *pl;
751
752	if (filep)
753	{
754	int len = strlen (string);
755
756	for (pl = pprefix->plist; pl; pl = pl->next)
757	{
758	if (strncmp (pl->prefix, string, len) == 0
759	&& strcmp (pl->prefix + len, "/") == 0)
760	return 1;
761	}
762	}
763	else
764	{
765	for (pl = pprefix->plist; pl; pl = pl->next)
766	{
767	if (strcmp (pl->prefix, string) == 0)
768	return 1;
769	}
770	}
771
772	return 0;
773	}
774
775	/* Search for NAME using prefix list PPREFIX. We only look for executable
776	files.
777
778	Return 0 if not found, otherwise return its name, allocated with malloc. */
779
780	static char *
781	find_a_file (pprefix, name)
782	struct path_prefix *pprefix;
783	char *name;
784	{
785	char *temp;
786	struct prefix_list *pl;
787	int len = pprefix->max_len + strlen (name) + 1;
788
789	#ifdef EXECUTABLE_SUFFIX
790	len += strlen (EXECUTABLE_SUFFIX);
791	#endif
792
793	temp = xmalloc (len);
794
795	/* Determine the filename to execute (special case for absolute paths). */
796
797	if (*name == '/')
798	{
799	if (access (name, X_OK) == 0)
800	{
801	strcpy (temp, name);
802	return temp;
803	}
804	}
805	else
806	for (pl = pprefix->plist; pl; pl = pl->next)
807	{
808	strcpy (temp, pl->prefix);
809	strcat (temp, name);
810	if (! is_in_prefix_list (&our_file_names, temp, 1)
811	/* This is a kludge, but there seems no way around it. */
812	&& strcmp (temp, "./ld") != 0
813	&& access (temp, X_OK) == 0)
814	return temp;
815
816	#ifdef EXECUTABLE_SUFFIX
817	/* Some systems have a suffix for executable files.
818	So try appending that. */
819	strcat (temp, EXECUTABLE_SUFFIX);
820	if (! is_in_prefix_list (&our_file_names, temp, 1)
821	&& access (temp, X_OK) == 0)
822	return temp;
823	#endif
824	}
825
826	free (temp);
827	return 0;
828	}
829
830	/* Add an entry for PREFIX to prefix list PPREFIX. */
831
832	static void
833	add_prefix (pprefix, prefix)
834	struct path_prefix *pprefix;
835	char *prefix;
836	{
837	struct prefix_list pl, *prev;
838	int len;
839
840	if (pprefix->plist)
841	{
842	for (pl = pprefix->plist; pl->next; pl = pl->next)
843	;
844	prev = &pl->next;
845	}
846	else
847	prev = &pprefix->plist;
848
849	/* Keep track of the longest prefix */
850
851	len = strlen (prefix);
852	if (len > pprefix->max_len)
853	pprefix->max_len = len;
854
855	pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
856	pl->prefix = savestring (prefix, len);
857
858	if (*prev)
859	pl->next = *prev;
860	else
861	pl->next = (struct prefix_list *) 0;
862	*prev = pl;
863	}
864
865	/* Take the value of the environment variable ENV, break it into a path, and
866	add of the entries to PPREFIX. */
867
868	static void
869	prefix_from_env (env, pprefix)
870	char *env;
871	struct path_prefix *pprefix;
872	{
873	char *p = getenv (env);
874
875	if (p)
876	prefix_from_string (p, pprefix);
877	}
878
879	static void
880	prefix_from_string (p, pprefix)
881	char *p;
882	struct path_prefix *pprefix;
883	{
884	char startp, endp;
885	char nstore = (char ) xmalloc (strlen (p) + 3);
886
887	startp = endp = p;
888	while (1)
889	{
890	if (endp == PATH_SEPARATOR \|\| endp == 0)
891	{
892	strncpy (nstore, startp, endp-startp);
893	if (endp == startp)
894	{
895	strcpy (nstore, "./");
896	}
897	else if (endp[-1] != '/')
898	{
899	nstore[endp-startp] = '/';
900	nstore[endp-startp+1] = 0;
901	}
902	else
903	nstore[endp-startp] = 0;
904
905	add_prefix (pprefix, nstore);
906	if (*endp == 0)
907	break;
908	endp = startp = endp + 1;
909	}
910	else
911	endp++;
912	}
913	}
914
915	/* Main program. */
916
917	int
918	main (argc, argv)
919	int argc;
920	char *argv[];
921	{
922	char *ld_suffix = "ld";
923	char *full_ld_suffix = ld_suffix;
924	char *real_ld_suffix = "real-ld";
925	char *full_real_ld_suffix = real_ld_suffix;
926	char *collect_ld_suffix = "collect-ld";
927	char *nm_suffix = "nm";
928	char *full_nm_suffix = nm_suffix;
929	char *gnm_suffix = "gnm";
930	char *full_gnm_suffix = gnm_suffix;
931	#ifdef LDD_SUFFIX
932	char *ldd_suffix = LDD_SUFFIX;
933	char *full_ldd_suffix = ldd_suffix;
934	#endif
935	char *strip_suffix = "strip";
936	char *full_strip_suffix = strip_suffix;
937	char *gstrip_suffix = "gstrip";
938	char *full_gstrip_suffix = gstrip_suffix;
939	char *arg;
940	FILE outf, exportf;
941	char *ld_file_name;
942	char *collect_name;
943	char *collect_names;
944	char *p;
945	char **c_argv;
946	char **c_ptr;
947	char ld1_argv = (char ) xcalloc (sizeof (char *), argc+3);
948	char **ld1 = ld1_argv;
949	char ld2_argv = (char ) xcalloc (sizeof (char *), argc+6);
950	char **ld2 = ld2_argv;
951	char object_lst = (char ) xcalloc (sizeof (char *), argc);
952	char **object = object_lst;
953	int first_file;
954	int num_c_args = argc+7;
955
956	#ifdef DEBUG
957	debug = 1;
958	vflag = 1;
959	#endif
960
961	output_file = "a.out";
962
963	obstack_begin (&temporary_obstack, 0);
964	obstack_begin (&permanent_obstack, 0);
965	temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
966	current_demangling_style = gnu_demangling;
967
968	/* We must check that we do not call ourselves in an infinite
969	recursion loop. We append the name used for us to the COLLECT_NAMES
970	environment variable.
971
972	In practice, collect will rarely invoke itself. This can happen now
973	that we are no longer called gld. A perfect example is when running
974	gcc in a build directory that has been installed. When looking for
975	ld's, we'll find our installed version and believe that's the real ld. */
976
977	/* We must also append COLLECT_NAME to COLLECT_NAMES to watch for the
978	previous version of collect (the one that used COLLECT_NAME and only
979	handled two levels of recursion). If we don't we may mutually recurse
980	forever. This can happen (I think) when bootstrapping the old version
981	and a new one is installed (rare, but we should handle it).
982	??? Hopefully references to COLLECT_NAME can be removed at some point. */
983
984	collect_name = (char *) getenv ("COLLECT_NAME");
985	collect_names = (char *) getenv ("COLLECT_NAMES");
986
987	p = (char *) xmalloc (strlen ("COLLECT_NAMES=")
988	+ (collect_name ? strlen (collect_name) + 1 : 0)
989	+ (collect_names ? strlen (collect_names) + 1 : 0)
990	+ strlen (argv[0]) + 1);
991	strcpy (p, "COLLECT_NAMES=");
992	if (collect_name != 0)
993	sprintf (p + strlen (p), "%s%c", collect_name, PATH_SEPARATOR);
994	if (collect_names != 0)
995	sprintf (p + strlen (p), "%s%c", collect_names, PATH_SEPARATOR);
996	strcat (p, argv[0]);
997	putenv (p);
998
999	prefix_from_env ("COLLECT_NAMES", &our_file_names);
1000
1001	/* Set environment variable COLLECT_NAME to our name so the previous version
1002	of collect won't find us. If it does we'll mutually recurse forever.
1003	This can happen when bootstrapping the new version and an old version is
1004	installed.
1005	??? Hopefully this bit of code can be removed at some point. */
1006
1007	p = xmalloc (strlen ("COLLECT_NAME=") + strlen (argv[0]) + 1);
1008	sprintf (p, "COLLECT_NAME=%s", argv[0]);
1009	putenv (p);
1010
1011	p = (char *) getenv ("COLLECT_GCC_OPTIONS");
1012	if (p)
1013	while (*p)
1014	{
1015	char *q = p;
1016	while (q && q != ' ') q++;
1017	if (*p == '-' && p[1] == 'm')
1018	num_c_args++;
1019
1020	if (*q) q++;
1021	p = q;
1022	}
1023
1024	c_ptr = c_argv = (char *) xcalloc (sizeof (char ), num_c_args);
1025
1026	if (argc < 2)
1027	fatal ("no arguments");
1028
1029	#ifdef SIGQUIT
1030	if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1031	signal (SIGQUIT, handler);
1032	#endif
1033	if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1034	signal (SIGINT, handler);
1035	#ifdef SIGALRM
1036	if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1037	signal (SIGALRM, handler);
1038	#endif
1039	#ifdef SIGHUP
1040	if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1041	signal (SIGHUP, handler);
1042	#endif
1043	if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1044	signal (SIGSEGV, handler);
1045	#ifdef SIGBUS
1046	if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1047	signal (SIGBUS, handler);
1048	#endif
1049
1050	/* Extract COMPILER_PATH and PATH into our prefix list. */
1051	prefix_from_env ("COMPILER_PATH", &cpath);
1052	prefix_from_env ("PATH", &path);
1053
1054	#ifdef CROSS_COMPILE
1055	/* If we look for a program in the compiler directories, we just use
1056	the short name, since these directories are already system-specific.
1057	But it we look for a took in the system directories, we need to
1058	qualify the program name with the target machine. */
1059
1060	full_ld_suffix
1061	= xcalloc (strlen (ld_suffix) + strlen (target_machine) + 2, 1);
1062	strcpy (full_ld_suffix, target_machine);
1063	strcat (full_ld_suffix, "-");
1064	strcat (full_ld_suffix, ld_suffix);
1065
1066	full_real_ld_suffix
1067	= xcalloc (strlen (real_ld_suffix) + strlen (target_machine) + 2, 1);
1068	strcpy (full_real_ld_suffix, target_machine);
1069	strcat (full_real_ld_suffix, "-");
1070	strcat (full_real_ld_suffix, real_ld_suffix);
1071
1072	#if 0
1073	full_gld_suffix
1074	= xcalloc (strlen (gld_suffix) + strlen (target_machine) + 2, 1);
1075	strcpy (full_gld_suffix, target_machine);
1076	strcat (full_gld_suffix, "-");
1077	strcat (full_gld_suffix, gld_suffix);
1078	#endif
1079
1080	full_nm_suffix
1081	= xcalloc (strlen (nm_suffix) + strlen (target_machine) + 2, 1);
1082	strcpy (full_nm_suffix, target_machine);
1083	strcat (full_nm_suffix, "-");
1084	strcat (full_nm_suffix, nm_suffix);
1085
1086	full_gnm_suffix
1087	= xcalloc (strlen (gnm_suffix) + strlen (target_machine) + 2, 1);
1088	strcpy (full_gnm_suffix, target_machine);
1089	strcat (full_gnm_suffix, "-");
1090	strcat (full_gnm_suffix, gnm_suffix);
1091
1092	#ifdef LDD_SUFFIX
1093	full_ldd_suffix
1094	= xcalloc (strlen (ldd_suffix) + strlen (target_machine) + 2, 1);
1095	strcpy (full_ldd_suffix, target_machine);
1096	strcat (full_ldd_suffix, "-");
1097	strcat (full_ldd_suffix, ldd_suffix);
1098	#endif
1099
1100	full_strip_suffix
1101	= xcalloc (strlen (strip_suffix) + strlen (target_machine) + 2, 1);
1102	strcpy (full_strip_suffix, target_machine);
1103	strcat (full_strip_suffix, "-");
1104	strcat (full_strip_suffix, strip_suffix);
1105
1106	full_gstrip_suffix
1107	= xcalloc (strlen (gstrip_suffix) + strlen (target_machine) + 2, 1);
1108	strcpy (full_gstrip_suffix, target_machine);
1109	strcat (full_gstrip_suffix, "-");
1110	strcat (full_gstrip_suffix, gstrip_suffix);
1111	#endif /* CROSS_COMPILE */
1112
1113	/* Try to discover a valid linker/nm/strip to use. */
1114
1115	/* Maybe we know the right file to use (if not cross). */
1116	#ifdef REAL_LD_FILE_NAME
1117	ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1118	if (ld_file_name == 0)
1119	#endif
1120	/* Search the (target-specific) compiler dirs for ld'. */
1121	ld_file_name = find_a_file (&cpath, real_ld_suffix);
1122	/* Likewise for `collect-ld'. */
1123	if (ld_file_name == 0)
1124	ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1125	/* Search the compiler directories for `ld'. We have protection against
1126	recursive calls in find_a_file. */
1127	if (ld_file_name == 0)
1128	ld_file_name = find_a_file (&cpath, ld_suffix);
1129	/* Search the ordinary system bin directories
1130	for `ld' (if native linking) or `TARGET-ld' (if cross). */
1131	if (ld_file_name == 0)
1132	ld_file_name = find_a_file (&path, full_ld_suffix);
1133
1134	/* If we've invoked ourselves, try again with LD_FILE_NAME. */
1135
1136	if (collect_names != 0)
1137	{
1138	if (ld_file_name != 0)
1139	{
1140	argv[0] = ld_file_name;
1141	execvp (argv[0], argv);
1142	}
1143	fatal ("cannot find `ld'");
1144	}
1145
1146	#ifdef REAL_NM_FILE_NAME
1147	nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1148	if (nm_file_name == 0)
1149	#endif
1150	nm_file_name = find_a_file (&cpath, gnm_suffix);
1151	if (nm_file_name == 0)
1152	nm_file_name = find_a_file (&path, full_gnm_suffix);
1153	if (nm_file_name == 0)
1154	nm_file_name = find_a_file (&cpath, nm_suffix);
1155	if (nm_file_name == 0)
1156	nm_file_name = find_a_file (&path, full_nm_suffix);
1157
1158	#ifdef LDD_SUFFIX
1159	ldd_file_name = find_a_file (&cpath, ldd_suffix);
1160	if (ldd_file_name == 0)
1161	ldd_file_name = find_a_file (&path, full_ldd_suffix);
1162	#endif
1163
1164	#ifdef REAL_STRIP_FILE_NAME
1165	strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1166	if (strip_file_name == 0)
1167	#endif
1168	strip_file_name = find_a_file (&cpath, gstrip_suffix);
1169	if (strip_file_name == 0)
1170	strip_file_name = find_a_file (&path, full_gstrip_suffix);
1171	if (strip_file_name == 0)
1172	strip_file_name = find_a_file (&cpath, strip_suffix);
1173	if (strip_file_name == 0)
1174	strip_file_name = find_a_file (&path, full_strip_suffix);
1175
1176	/* Determine the full path name of the C compiler to use. */
1177	c_file_name = getenv ("COLLECT_GCC");
1178	if (c_file_name == 0)
1179	{
1180	#ifdef CROSS_COMPILE
1181	c_file_name = xcalloc (sizeof ("gcc-") + strlen (target_machine) + 1, 1);
1182	strcpy (c_file_name, target_machine);
1183	strcat (c_file_name, "-gcc");
1184	#else
1185	c_file_name = "gcc";
1186	#endif
1187	}
1188
1189	p = find_a_file (&cpath, c_file_name);
1190
1191	/* Here it should be safe to use the system search path since we should have
1192	already qualified the name of the compiler when it is needed. */
1193	if (p == 0)
1194	p = find_a_file (&path, c_file_name);
1195
1196	if (p)
1197	c_file_name = p;
1198
1199	ld1++ = ld2++ = ld_file_name;
1200
1201	/* Make temp file names. */
1202	choose_temp_base ();
1203	c_file = xcalloc (temp_filename_length + sizeof (".c"), 1);
1204	o_file = xcalloc (temp_filename_length + sizeof (".o"), 1);
1205	export_file = xmalloc (temp_filename_length + sizeof (".x"));
1206	ldout = xmalloc (temp_filename_length + sizeof (".ld"));
1207	sprintf (ldout, "%s.ld", temp_filename);
1208	sprintf (c_file, "%s.c", temp_filename);
1209	sprintf (o_file, "%s.o", temp_filename);
1210	sprintf (export_file, "%s.x", temp_filename);
1211	*c_ptr++ = c_file_name;
1212	*c_ptr++ = "-c";
1213	*c_ptr++ = "-o";
1214	*c_ptr++ = o_file;
1215
1216	/* !!! When GCC calls collect2,
1217	it does not know whether it is calling collect2 or ld.
1218	So collect2 cannot meaningfully understand any options
1219	except those ld understands.
1220	If you propose to make GCC pass some other option,
1221	just imagine what will happen if ld is really ld!!! */
1222
1223	/* Parse arguments. Remember output file spec, pass the rest to ld. */
1224	/* After the first file, put in the c++ rt0. */
1225
1226	first_file = 1;
1227	while ((arg = ++argv) != (char )0)
1228	{
1229	ld1++ = ld2++ = arg;
1230
1231	if (arg[0] == '-')
1232	{
1233	switch (arg[1])
1234	{
1235	case 'd':
1236	if (!strcmp (arg, "-debug"))
1237	{
1238	debug = 1;
1239	vflag = 1;
1240	ld1--;
1241	ld2--;
1242	}
1243	break;
1244
1245	case 'l':
1246	if (first_file)
1247	{
1248	/* place o_file BEFORE this argument! */
1249	first_file = 0;
1250	ld2--;
1251	*ld2++ = o_file;
1252	*ld2++ = arg;
1253	}
1254	break;
1255
1256	case 'o':
1257	if (arg[2] == '\0')
1258	output_file = ld1++ = ld2++ = *++argv;
1259	else
1260	output_file = &arg[2];
1261	break;
1262
1263	case 'r':
1264	if (arg[2] == '\0')
1265	rflag = 1;
1266	break;
1267
1268	case 's':
1269	if (arg[2] == '\0' && do_collecting)
1270	{
1271	/* We must strip after the nm run, otherwise C++ linking
1272	won't work. Thus we strip in the second ld run, or
1273	else with strip if there is no second ld run. */
1274	strip_flag = 1;
1275	ld1--;
1276	}
1277	break;
1278
1279	case 'v':
1280	if (arg[2] == '\0')
1281	vflag = 1;
1282	break;
1283	}
1284	}
1285	else if ((p = rindex (arg, '.')) != (char *)0
1286	&& (strcmp (p, ".o") == 0 \|\| strcmp (p, ".a") == 0))
1287	{
1288	if (first_file)
1289	{
1290	first_file = 0;
1291	if (p[1] == 'o')
1292	*ld2++ = o_file;
1293	else
1294	{
1295	/* place o_file BEFORE this argument! */
1296	ld2--;
1297	*ld2++ = o_file;
1298	*ld2++ = arg;
1299	}
1300	}
1301	if (p[1] == 'o')
1302	*object++ = arg;
1303	}
1304	}
1305
1306	/* Get any options that the upper GCC wants to pass to the sub-GCC. */
1307	p = (char *) getenv ("COLLECT_GCC_OPTIONS");
1308	if (p)
1309	while (*p)
1310	{
1311	char *q = p;
1312	while (q && q != ' ') q++;
1313	if (*p == '-' && (p[1] == 'm' \|\| p[1] == 'f'))
1314	*c_ptr++ = savestring (p, q - p);
1315	if (strncmp (p, "-shared", sizeof ("shared") - 1) == 0)
1316	shared_obj = 1;
1317
1318	if (*q) q++;
1319	p = q;
1320	}
1321
1322	#ifdef COLLECT_EXPORT_LIST
1323	/* The AIX linker will discard static constructors in object files if
1324	nothing else in the file is referenced, so look at them first. */
1325	while (object_lst < object)
1326	scan_prog_file (*object_lst++, PASS_OBJ);
1327
1328	{
1329	char *buf = alloca (strlen (export_file) + 5);
1330	sprintf (buf, "-bE:%s", export_file);
1331	*ld1++ = buf;
1332	*ld2++ = buf;
1333	exportf = fopen (export_file, "w");
1334	if (exportf == (FILE *)0)
1335	fatal_perror ("%s", export_file);
1336	write_export_file (exportf);
1337	if (fclose (exportf))
1338	fatal_perror ("closing %s", export_file);
1339	}
1340	#endif
1341
1342	*c_ptr++ = c_file;
1343	object = c_ptr = ld1 = (char )0;
1344
1345	if (vflag)
1346	{
1347	fprintf (stderr, "collect2 version %s", version_string);
1348	#ifdef TARGET_VERSION
1349	TARGET_VERSION;
1350	#endif
1351	fprintf (stderr, "\n");
1352	}
1353
1354	if (debug)
1355	{
1356	char *ptr;
1357	fprintf (stderr, "ld_file_name = %s\n",
1358	(ld_file_name ? ld_file_name : "not found"));
1359	fprintf (stderr, "c_file_name = %s\n",
1360	(c_file_name ? c_file_name : "not found"));
1361	fprintf (stderr, "nm_file_name = %s\n",
1362	(nm_file_name ? nm_file_name : "not found"));
1363	#ifdef LDD_SUFFIX
1364	fprintf (stderr, "ldd_file_name = %s\n",
1365	(ldd_file_name ? ldd_file_name : "not found"));
1366	#endif
1367	fprintf (stderr, "strip_file_name = %s\n",
1368	(strip_file_name ? strip_file_name : "not found"));
1369	fprintf (stderr, "c_file = %s\n",
1370	(c_file ? c_file : "not found"));
1371	fprintf (stderr, "o_file = %s\n",
1372	(o_file ? o_file : "not found"));
1373
1374	ptr = getenv ("COLLECT_NAMES");
1375	if (ptr)
1376	fprintf (stderr, "COLLECT_NAMES = %s\n", ptr);
1377
1378	ptr = getenv ("COLLECT_GCC_OPTIONS");
1379	if (ptr)
1380	fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1381
1382	ptr = getenv ("COLLECT_GCC");
1383	if (ptr)
1384	fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1385
1386	ptr = getenv ("COMPILER_PATH");
1387	if (ptr)
1388	fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1389
1390	ptr = getenv ("LIBRARY_PATH");
1391	if (ptr)
1392	fprintf (stderr, "LIBRARY_PATH = %s\n", ptr);
1393
1394	fprintf (stderr, "\n");
1395	}
1396
1397	/* Load the program, searching all libraries. */
1398
1399	collect_execute ("ld", ld1_argv, ldout);
1400	do_wait ("ld");
1401	dump_file (ldout);
1402	unlink (ldout);
1403
1404	/* If -r or they'll be run via some other method, don't build the
1405	constructor or destructor list, just return now. */
1406	if (rflag \|\| ! do_collecting)
1407	return 0;
1408
1409	/* Examine the namelist with nm and search it for static constructors
1410	and destructors to call.
1411	Write the constructor and destructor tables to a .s file and reload. */
1412
1413	scan_prog_file (output_file, PASS_FIRST);
1414
1415	#ifdef SCAN_LIBRARIES
1416	scan_libraries (output_file);
1417	#endif
1418
1419	if (debug)
1420	{
1421	fprintf (stderr, "%d constructor(s) found\n", constructors.number);
1422	fprintf (stderr, "%d destructor(s) found\n", destructors.number);
1423	}
1424
1425	if (constructors.number == 0 && destructors.number == 0
1426	#ifdef LDD_SUFFIX
1427	/* If we will be running these functions ourselves, we want to emit
1428	stubs into the shared library so that we don't have to relink
1429	dependent programs when we add static objects. */
1430	&& ! shared_obj
1431	#endif
1432	)
1433	{
1434	/* Strip now if it was requested on the command line. */
1435	if (strip_flag)
1436	{
1437	char strip_argv = (char ) xcalloc (sizeof (char *), 3);
1438	strip_argv[0] = strip_file_name;
1439	strip_argv[1] = output_file;
1440	strip_argv[2] = (char *) 0;
1441	fork_execute ("strip", strip_argv);
1442	}
1443
1444	#ifdef COLLECT_EXPORT_LIST
1445	maybe_unlink (export_file);
1446	#endif
1447	return 0;
1448	}
1449
1450	maybe_unlink(output_file);
1451	outf = fopen (c_file, "w");
1452	if (outf == (FILE *)0)
1453	fatal_perror ("%s", c_file);
1454
1455	write_c_file (outf, c_file);
1456
1457	if (fclose (outf))
1458	fatal_perror ("closing %s", c_file);
1459
1460	/* Tell the linker that we have initializer and finalizer functions. */
1461	#ifdef LD_INIT_SWITCH
1462	*ld2++ = LD_INIT_SWITCH;
1463	*ld2++ = initname;
1464	*ld2++ = LD_FINI_SWITCH;
1465	*ld2++ = fininame;
1466	#endif
1467	ld2 = (char)0;
1468
1469	#ifdef COLLECT_EXPORT_LIST
1470	if (shared_obj)
1471	{
1472	add_to_list (&exports, initname);
1473	add_to_list (&exports, fininame);
1474	add_to_list (&exports, "_GLOBAL__DI");
1475	add_to_list (&exports, "_GLOBAL__DD");
1476	exportf = fopen (export_file, "w");
1477	if (exportf == (FILE *)0)
1478	fatal_perror ("%s", export_file);
1479	write_export_file (exportf);
1480	if (fclose (exportf))
1481	fatal_perror ("closing %s", export_file);
1482	}
1483	#endif
1484
1485	if (debug)
1486	{
1487	fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1488	output_file, c_file);
1489	write_c_file (stderr, "stderr");
1490	fprintf (stderr, "========== end of c_file\n\n");
1491	#ifdef COLLECT_EXPORT_LIST
1492	fprintf (stderr, "\n========== export_file = %s\n", export_file);
1493	write_export_file (stderr);
1494	fprintf (stderr, "========== end of export_file\n\n");
1495	#endif
1496	}
1497
1498	/* Assemble the constructor and destructor tables.
1499	Link the tables in with the rest of the program. */
1500
1501	fork_execute ("gcc", c_argv);
1502	fork_execute ("ld", ld2_argv);
1503
1504	/* Let scan_prog_file do any final mods (OSF/rose needs this for
1505	constructors/destructors in shared libraries. */
1506	scan_prog_file (output_file, PASS_SECOND);
1507
1508	maybe_unlink (c_file);
1509	maybe_unlink (o_file);
1510	maybe_unlink (export_file);
1511	return 0;
1512	}
1513
1514
1515	/* Wait for a process to finish, and exit if a non-zero status is found. */
1516
1517	int
1518	collect_wait (prog)
1519	char *prog;
1520	{
1521	int status;
1522
1523	wait (&status);
1524	if (status)
1525	{
1526	if (WIFSIGNALED (status))
1527	{
1528	int sig = WTERMSIG (status);
1529	#ifdef NO_SYS_SIGLIST
1530	error ("%s terminated with signal %d %s",
1531	prog,
1532	sig,
1533	(status & 0200) ? ", core dumped" : "");
1534	#else
1535	error ("%s terminated with signal %d [%s]%s",
1536	prog,
1537	sig,
1538	sys_siglist[sig],
1539	(status & 0200) ? ", core dumped" : "");
1540	#endif
1541
1542	collect_exit (127);
1543	}
1544
1545	if (WIFEXITED (status))
1546	return WEXITSTATUS (status);
1547	}
1548	return 0;
1549	}
1550
1551	static void
1552	do_wait (prog)
1553	char *prog;
1554	{
1555	int ret = collect_wait (prog);
1556	if (ret != 0)
1557	{
1558	error ("%s returned %d exit status", prog, ret);
1559	collect_exit (ret);
1560	}
1561	}
1562
1563
1564	/* Fork and execute a program, and wait for the reply. */
1565
1566	void
1567	collect_execute (prog, argv, redir)
1568	char *prog;
1569	char **argv;
1570	char *redir;
1571	{
1572	int pid;
1573
1574	if (vflag \|\| debug)
1575	{
1576	char **p_argv;
1577	char *str;
1578
1579	if (argv[0])
1580	fprintf (stderr, "%s", argv[0]);
1581	else
1582	fprintf (stderr, "[cannot find %s]", prog);
1583
1584	for (p_argv = &argv[1]; (str = p_argv) != (char )0; p_argv++)
1585	fprintf (stderr, " %s", str);
1586
1587	fprintf (stderr, "\n");
1588	}
1589
1590	fflush (stdout);
1591	fflush (stderr);
1592
1593	/* If we can't find a program we need, complain error. Do this here
1594	since we might not end up needing something that we couldn't find. */
1595
1596	if (argv[0] == 0)
1597	fatal ("cannot find `%s'", prog);
1598
1599	pid = vfork ();
1600	if (pid == -1)
1601	{
1602	#ifdef vfork
1603	fatal_perror ("fork");
1604	#else
1605	fatal_perror ("vfork");
1606	#endif
1607	}
1608
1609	if (pid == 0) /* child context */
1610	{
1611	if (redir)
1612	{
1613	unlink (redir);
1614	if (freopen (redir, "a", stdout) == NULL)
1615	fatal_perror ("redirecting stdout");
1616	if (freopen (redir, "a", stderr) == NULL)
1617	fatal_perror ("redirecting stderr");
1618	}
1619
1620	execvp (argv[0], argv);
1621	fatal_perror ("executing %s", prog);
1622	}
1623	}
1624
1625	static void
1626	fork_execute (prog, argv)
1627	char *prog;
1628	char **argv;
1629	{
1630	collect_execute (prog, argv, NULL);
1631	do_wait (prog);
1632	}
1633
1634	/* Unlink a file unless we are debugging. */
1635
1636	static void
1637	maybe_unlink (file)
1638	char *file;
1639	{
1640	if (!debug)
1641	unlink (file);
1642	else
1643	fprintf (stderr, "[Leaving %s]\n", file);
1644	}
1645
1646
1647	/* Add a name to a linked list. */
1648
1649	static void
1650	add_to_list (head_ptr, name)
1651	struct head *head_ptr;
1652	char *name;
1653	{
1654	struct id *newid
1655	= (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
1656	struct id *p;
1657	static long sequence_number = 0;
1658	strcpy (newid->name, name);
1659
1660	if (head_ptr->first)
1661	head_ptr->last->next = newid;
1662	else
1663	head_ptr->first = newid;
1664
1665	/* Check for duplicate symbols. */
1666	for (p = head_ptr->first;
1667	strcmp (name, p->name) != 0;
1668	p = p->next)
1669	;
1670	if (p != newid)
1671	{
1672	head_ptr->last->next = 0;
1673	free (newid);
1674	return;
1675	}
1676
1677	newid->sequence = ++sequence_number;
1678	head_ptr->last = newid;
1679	head_ptr->number++;
1680	}
1681
1682	/* Write: `prefix', the names on list LIST, `suffix'. */
1683
1684	static void
1685	write_list (stream, prefix, list)
1686	FILE *stream;
1687	char *prefix;
1688	struct id *list;
1689	{
1690	while (list)
1691	{
1692	fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1693	list = list->next;
1694	}
1695	}
1696
1697	static void
1698	write_list_with_asm (stream, prefix, list)
1699	FILE *stream;
1700	char *prefix;
1701	struct id *list;
1702	{
1703	while (list)
1704	{
1705	fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1706	prefix, list->sequence, list->name);
1707	list = list->next;
1708	}
1709	}
1710
1711	/* Write out the constructor and destructor tables statically (for a shared
1712	object), along with the functions to execute them. */
1713
1714	static void
1715	write_c_file_stat (stream, name)
1716	FILE *stream;
1717	char *name;
1718	{
1719	char prefix, p, *q;
1720
1721	/* Figure out name of output_file, stripping off .so version. */
1722	p = rindex (output_file, '/');
1723	if (p == 0)
1724	p = (char *) output_file;
1725	else
1726	p++;
1727	q = p;
1728	while (q)
1729	{
1730	q = index (q,'.');
1731	if (q == 0)
1732	{
1733	q = p + strlen (p);
1734	break;
1735	}
1736	else
1737	{
1738	if (strncmp (q, ".so", 3) == 0)
1739	{
1740	q += 3;
1741	break;
1742	}
1743	else
1744	q++;
1745	}
1746	}
1747	/* q points to null at end of the string (or . of the .so version) */
1748	prefix = xmalloc (q - p + 1);
1749	strncpy (prefix, p, q - p);
1750	prefix[q - p] = 0;
1751	for (q = prefix; *q; q++)
1752	if (!isalnum (*q))
1753	*q = '_';
1754	if (debug)
1755	fprintf (stderr, "\nwrite_c_file - output name is %s, prefix is %s\n",
1756	output_file, prefix);
1757
1758	#define INIT_NAME_FORMAT "_GLOBAL__FI_%s"
1759	initname = xmalloc (strlen (prefix) + sizeof (INIT_NAME_FORMAT) - 2);
1760	sprintf (initname, INIT_NAME_FORMAT, prefix);
1761
1762	#define FINI_NAME_FORMAT "_GLOBAL__FD_%s"
1763	fininame = xmalloc (strlen (prefix) + sizeof (FINI_NAME_FORMAT) - 2);
1764	sprintf (fininame, FINI_NAME_FORMAT, prefix);
1765
1766	free (prefix);
1767
1768	/* Write the tables as C code */
1769
1770	fprintf (stream, "static int count;\n");
1771	fprintf (stream, "typedef void entry_pt();\n");
1772	write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1773	fprintf (stream, "void %s() {\n", initname);
1774	if (constructors.number > 0)
1775	{
1776	fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1777	write_list (stream, "\t\t", constructors.first);
1778	fprintf (stream, "\t};\n");
1779	fprintf (stream, "\tentry_pt **p;\n");
1780	fprintf (stream, "\tif (count++ != 0) return;\n");
1781	fprintf (stream, "\tp = ctors + %d;\n", constructors.number);
1782	fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1783	}
1784	else
1785	fprintf (stream, "\t++count;\n");
1786	fprintf (stream, "}\n");
1787	write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1788	fprintf (stream, "void %s() {\n", fininame);
1789	if (destructors.number > 0)
1790	{
1791	fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1792	write_list (stream, "\t\t", destructors.first);
1793	fprintf (stream, "\t};\n");
1794	fprintf (stream, "\tentry_pt **p;\n");
1795	fprintf (stream, "\tif (--count != 0) return;\n");
1796	fprintf (stream, "\tp = dtors;\n");
1797	fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1798	destructors.number);
1799	}
1800	fprintf (stream, "}\n");
1801
1802	if (shared_obj)
1803	{
1804	fprintf (stream, "void _GLOBAL__DI() {\n\t%s();\n}\n", initname);
1805	fprintf (stream, "void _GLOBAL__DD() {\n\t%s();\n}\n", fininame);
1806	}
1807	}
1808
1809	/* Write the constructor/destructor tables. */
1810
1811	static void
1812	write_c_file_glob (stream, name)
1813	FILE *stream;
1814	char *name;
1815	{
1816	/* Write the tables as C code */
1817
1818	fprintf (stream, "typedef void entry_pt();\n\n");
1819
1820	write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1821
1822	fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
1823	fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number);
1824	write_list (stream, "\t", constructors.first);
1825	fprintf (stream, "\t0\n};\n\n");
1826
1827	write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1828
1829	fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
1830	fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number);
1831	write_list (stream, "\t", destructors.first);
1832	fprintf (stream, "\t0\n};\n\n");
1833
1834	fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
1835	fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
1836	}
1837
1838	static void
1839	write_c_file (stream, name)
1840	FILE *stream;
1841	char *name;
1842	{
1843	#ifndef LD_INIT_SWITCH
1844	if (! shared_obj)
1845	write_c_file_glob (stream, name);
1846	else
1847	#endif
1848	write_c_file_stat (stream, name);
1849	}
1850
1851	static void
1852	write_export_file (stream)
1853	FILE *stream;
1854	{
1855	struct id *list = exports.first;
1856	for (; list; list = list->next)
1857	fprintf (stream, "%s\n", list->name);
1858	}
1859
1860	#ifdef OBJECT_FORMAT_NONE
1861
1862	/* Generic version to scan the name list of the loaded program for
1863	the symbols g++ uses for static constructors and destructors.
1864
1865	The constructor table begins at __CTOR_LIST__ and contains a count
1866	of the number of pointers (or -1 if the constructors are built in a
1867	separate section by the linker), followed by the pointers to the
1868	constructor functions, terminated with a null pointer. The
1869	destructor table has the same format, and begins at __DTOR_LIST__. */
1870
1871	static void
1872	scan_prog_file (prog_name, which_pass)
1873	char *prog_name;
1874	enum pass which_pass;
1875	{
1876	void (*int_handler) ();
1877	void (*quit_handler) ();
1878	char *nm_argv[4];
1879	int pid;
1880	int argc = 0;
1881	int pipe_fd[2];
1882	char *p, buf[1024];
1883	FILE *inf;
1884
1885	if (which_pass == PASS_SECOND)
1886	return;
1887
1888	/* If we don't have an `nm', complain. */
1889	if (nm_file_name == 0)
1890	fatal ("cannot find `nm'");
1891
1892	nm_argv[argc++] = nm_file_name;
1893	if (NM_FLAGS[0] != '\0')
1894	nm_argv[argc++] = NM_FLAGS;
1895
1896	nm_argv[argc++] = prog_name;
1897	nm_argv[argc++] = (char *)0;
1898
1899	if (pipe (pipe_fd) < 0)
1900	fatal_perror ("pipe");
1901
1902	inf = fdopen (pipe_fd[0], "r");
1903	if (inf == (FILE *)0)
1904	fatal_perror ("fdopen");
1905
1906	/* Trace if needed. */
1907	if (vflag)
1908	{
1909	char **p_argv;
1910	char *str;
1911
1912	for (p_argv = &nm_argv[0]; (str = p_argv) != (char )0; p_argv++)
1913	fprintf (stderr, " %s", str);
1914
1915	fprintf (stderr, "\n");
1916	}
1917
1918	fflush (stdout);
1919	fflush (stderr);
1920
1921	/* Spawn child nm on pipe */
1922	pid = vfork ();
1923	if (pid == -1)
1924	{
1925	#ifdef vfork
1926	fatal_perror ("fork");
1927	#else
1928	fatal_perror ("vfork");
1929	#endif
1930	}
1931
1932	if (pid == 0) /* child context */
1933	{
1934	/* setup stdout */
1935	if (dup2 (pipe_fd[1], 1) < 0)
1936	fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
1937
1938	if (close (pipe_fd[0]) < 0)
1939	fatal_perror ("close (%d)", pipe_fd[0]);
1940
1941	if (close (pipe_fd[1]) < 0)
1942	fatal_perror ("close (%d)", pipe_fd[1]);
1943
1944	execv (nm_file_name, nm_argv);
1945	fatal_perror ("executing %s", nm_file_name);
1946	}
1947
1948	/* Parent context from here on. */
1949	int_handler = (void (*) ())signal (SIGINT, SIG_IGN);
1950	#ifdef SIGQUIT
1951	quit_handler = (void (*) ())signal (SIGQUIT, SIG_IGN);
1952	#endif
1953
1954	if (close (pipe_fd[1]) < 0)
1955	fatal_perror ("close (%d)", pipe_fd[1]);
1956
1957	if (debug)
1958	fprintf (stderr, "\nnm output with constructors/destructors.\n");
1959
1960	/* Read each line of nm output. */
1961	while (fgets (buf, sizeof buf, inf) != (char *)0)
1962	{
1963	int ch, ch2;
1964	char name, end;
1965
1966	/* If it contains a constructor or destructor name, add the name
1967	to the appropriate list. */
1968
1969	for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
1970	if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
1971	break;
1972
1973	if (ch != '_')
1974	continue;
1975
1976	name = p;
1977	/* Find the end of the symbol name.
1978	Don't include `\|', because Encore nm can tack that on the end. */
1979	for (end = p; (ch2 = *end) != '\0' && !isspace (ch2) && ch2 != '\|';
1980	end++)
1981	continue;
1982
1983
1984	*end = '\0';
1985	switch (is_ctor_dtor (name))
1986	{
1987	case 1:
1988	if (which_pass != PASS_LIB)
1989	add_to_list (&constructors, name);
1990	break;
1991
1992	case 2:
1993	if (which_pass != PASS_LIB)
1994	add_to_list (&destructors, name);
1995	break;
1996
1997	case 3:
1998	if (which_pass != PASS_LIB)
1999	fatal ("init function found in object %s", prog_name);
2000	#ifndef LD_INIT_SWITCH
2001	add_to_list (&constructors, name);
2002	#endif
2003	break;
2004
2005	case 4:
2006	if (which_pass != PASS_LIB)
2007	fatal ("fini function found in object %s", prog_name);
2008	#ifndef LD_FINI_SWITCH
2009	add_to_list (&destructors, name);
2010	#endif
2011	break;
2012
2013	default: /* not a constructor or destructor */
2014	continue;
2015	}
2016
2017	if (debug)
2018	fprintf (stderr, "\t%s\n", buf);
2019	}
2020
2021	if (debug)
2022	fprintf (stderr, "\n");
2023
2024	if (fclose (inf) != 0)
2025	fatal_perror ("fclose of pipe");
2026
2027	do_wait (nm_file_name);
2028
2029	signal (SIGINT, int_handler);
2030	#ifdef SIGQUIT
2031	signal (SIGQUIT, quit_handler);
2032	#endif
2033	}
2034
2035	#if SUNOS4_SHARED_LIBRARIES
2036
2037	/* Routines to scan the SunOS 4 _DYNAMIC structure to find shared libraries
2038	that the output file depends upon and their initialization/finalization
2039	routines, if any. */
2040
2041	#include <a.out.h>
2042	#include <fcntl.h>
2043	#include <link.h>
2044	#include <sys/mman.h>
2045	#include <sys/param.h>
2046	#include <sys/unistd.h>
2047	#include <sys/dir.h>
2048
2049	/* pointers to the object file */
2050	unsigned object; /* address of memory mapped file */
2051	unsigned objsize; /* size of memory mapped to file */
2052	char * code; /* pointer to code segment */
2053	char * data; /* pointer to data segment */
2054	struct nlist symtab; / pointer to symbol table */
2055	struct link_dynamic *ld;
2056	struct link_dynamic_2 *ld_2;
2057	struct head libraries;
2058
2059	/* Map the file indicated by NAME into memory and store its address. */
2060
2061	static void
2062	mapfile (name)
2063	char *name;
2064	{
2065	int fp;
2066	struct stat s;
2067	if ((fp = open (name, O_RDONLY)) == -1)
2068	fatal ("unable to open file '%s'", name);
2069	if (fstat (fp, &s) == -1)
2070	fatal ("unable to stat file '%s'", name);
2071
2072	objsize = s.st_size;
2073	object = (unsigned) mmap (0, objsize, PROT_READ\|PROT_WRITE, MAP_PRIVATE,
2074	fp, 0);
2075	if (object == -1)
2076	fatal ("unable to mmap file '%s'", name);
2077
2078	close (fp);
2079	}
2080
2081	/* Helpers for locatelib. */
2082
2083	static char *libname;
2084
2085	static int
2086	libselect (d)
2087	struct direct *d;
2088	{
2089	return (strncmp (libname, d->d_name, strlen (libname)) == 0);
2090	}
2091
2092	/* If one file has an additional numeric extension past LIBNAME, then put
2093	that one first in the sort. If both files have additional numeric
2094	extensions, then put the one with the higher number first in the sort.
2095
2096	We must verify that the extension is numeric, because Sun saves the
2097	original versions of patched libraries with a .FCS extension. Files with
2098	invalid extensions must go last in the sort, so that they won't be used. */
2099
2100	static int
2101	libcompare (d1, d2)
2102	struct direct d1, d2;
2103	{
2104	int i1, i2 = strlen (libname);
2105	char e1 = (d1)->d_name + i2;
2106	char e2 = (d2)->d_name + i2;
2107
2108	while (e1 && e2 && e1 == '.' && e2 == '.'
2109	&& e1[1] && isdigit (e1[1]) && e2[1] && isdigit (e2[1]))
2110	{
2111	++e1;
2112	++e2;
2113	i1 = strtol (e1, &e1, 10);
2114	i2 = strtol (e2, &e2, 10);
2115	if (i1 != i2)
2116	return i1 - i2;
2117	}
2118
2119	if (*e1)
2120	{
2121	/* It has a valid numeric extension, prefer this one. */
2122	if (*e1 == '.' && e1[1] && isdigit (e1[1]))
2123	return 1;
2124	/* It has a invalid numeric extension, must prefer the other one. */
2125	else
2126	return -1;
2127	}
2128	else if (*e2)
2129	{
2130	/* It has a valid numeric extension, prefer this one. */
2131	if (*e2 == '.' && e2[1] && isdigit (e2[1]))
2132	return -1;
2133	/* It has a invalid numeric extension, must prefer the other one. */
2134	else
2135	return 1;
2136	}
2137	else
2138	return 0;
2139	}
2140
2141	/* Given the name NAME of a dynamic dependency, find its pathname and add
2142	it to the list of libraries. */
2143
2144	static void
2145	locatelib (name)
2146	char *name;
2147	{
2148	static char **l;
2149	static int cnt;
2150	char buf[MAXPATHLEN];
2151	char p, q;
2152	char **pp;
2153
2154	if (l == 0)
2155	{
2156	char *ld_rules;
2157	char *ldr = 0;
2158	/* counting elements in array, need 1 extra for null */
2159	cnt = 1;
2160	ld_rules = (char *) (ld_2->ld_rules + code);
2161	if (ld_rules)
2162	{
2163	cnt++;
2164	for (; *ld_rules != 0; ld_rules++)
2165	if (*ld_rules == ':')
2166	cnt++;
2167	ld_rules = (char *) (ld_2->ld_rules + code);
2168	ldr = (char *) malloc (strlen (ld_rules) + 1);
2169	strcpy (ldr, ld_rules);
2170	}
2171	p = getenv ("LD_LIBRARY_PATH");
2172	q = 0;
2173	if (p)
2174	{
2175	cnt++;
2176	for (q = p ; *q != 0; q++)
2177	if (*q == ':')
2178	cnt++;
2179	q = (char *) malloc (strlen (p) + 1);
2180	strcpy (q, p);
2181	}
2182	l = (char *) malloc ((cnt + 3) sizeof (char *));
2183	pp = l;
2184	if (ldr)
2185	{
2186	*pp++ = ldr;
2187	for (; *ldr != 0; ldr++)
2188	if (*ldr == ':')
2189	{
2190	*ldr++ = 0;
2191	*pp++ = ldr;
2192	}
2193	}
2194	if (q)
2195	{
2196	*pp++ = q;
2197	for (; *q != 0; q++)
2198	if (*q == ':')
2199	{
2200	*q++ = 0;
2201	*pp++ = q;
2202	}
2203	}
2204	/* built in directories are /lib, /usr/lib, and /usr/local/lib */
2205	*pp++ = "/lib";
2206	*pp++ = "/usr/lib";
2207	*pp++ = "/usr/local/lib";
2208	*pp = 0;
2209	}
2210	libname = name;
2211	for (pp = l; *pp != 0 ; pp++)
2212	{
2213	struct direct **namelist;
2214	int entries;
2215	if ((entries = scandir (*pp, &namelist, libselect, libcompare)) > 0)
2216	{
2217	sprintf (buf, "%s/%s", *pp, namelist[entries - 1]->d_name);
2218	add_to_list (&libraries, buf);
2219	if (debug)
2220	fprintf (stderr, "%s\n", buf);
2221	break;
2222	}
2223	}
2224	if (*pp == 0)
2225	{
2226	if (debug)
2227	fprintf (stderr, "not found\n");
2228	else
2229	fatal ("dynamic dependency %s not found", name);
2230	}
2231	}
2232
2233	/* Scan the _DYNAMIC structure of the output file to find shared libraries
2234	that it depends upon and any constructors or destructors they contain. */
2235
2236	static void
2237	scan_libraries (prog_name)
2238	char *prog_name;
2239	{
2240	struct exec *header;
2241	char *base;
2242	struct link_object *lo;
2243	char buff[MAXPATHLEN];
2244	struct id *list;
2245
2246	mapfile (prog_name);
2247	header = (struct exec *)object;
2248	if (N_BADMAG (*header))
2249	fatal ("bad magic number in file '%s'", prog_name);
2250	if (header->a_dynamic == 0)
2251	return;
2252
2253	code = (char ) (N_TXTOFF (header) + (long) header);
2254	data = (char ) (N_DATOFF (header) + (long) header);
2255	symtab = (struct nlist ) (N_SYMOFF (header) + (long) header);
2256
2257	if (header->a_magic == ZMAGIC && header->a_entry == 0x20)
2258	{
2259	/* shared object */
2260	ld = (struct link_dynamic *) (symtab->n_value + code);
2261	base = code;
2262	}
2263	else
2264	{
2265	/* executable */
2266	ld = (struct link_dynamic *) data;
2267	base = code-PAGSIZ;
2268	}
2269
2270	if (debug)
2271	fprintf (stderr, "dynamic dependencies.\n");
2272
2273	ld_2 = (struct link_dynamic_2 *) ((long) ld->ld_un.ld_2 + (long)base);
2274	for (lo = (struct link_object *) ld_2->ld_need; lo;
2275	lo = (struct link_object *) lo->lo_next)
2276	{
2277	char *name;
2278	lo = (struct link_object *) ((long) lo + code);
2279	name = (char *) (code + lo->lo_name);
2280	if (lo->lo_library)
2281	{
2282	if (debug)
2283	fprintf (stderr, "\t-l%s.%d => ", name, lo->lo_major);
2284	sprintf (buff, "lib%s.so.%d.%d", name, lo->lo_major, lo->lo_minor);
2285	locatelib (buff);
2286	}
2287	else
2288	{
2289	if (debug)
2290	fprintf (stderr, "\t%s\n", name);
2291	add_to_list (&libraries, name);
2292	}
2293	}
2294
2295	if (debug)
2296	fprintf (stderr, "\n");
2297
2298	/* now iterate through the library list adding their symbols to
2299	the list. */
2300	for (list = libraries.first; list; list = list->next)
2301	scan_prog_file (list->name, PASS_LIB);
2302	}
2303
2304	#else /* SUNOS4_SHARED_LIBRARIES */
2305	#ifdef LDD_SUFFIX
2306
2307	/* Use the List Dynamic Dependencies program to find shared libraries that
2308	the output file depends upon and their initialization/finalization
2309	routines, if any. */
2310
2311	static void
2312	scan_libraries (prog_name)
2313	char *prog_name;
2314	{
2315	static struct head libraries; /* list of shared libraries found */
2316	struct id *list;
2317	void (*int_handler) ();
2318	void (*quit_handler) ();
2319	char *ldd_argv[4];
2320	int pid;
2321	int argc = 0;
2322	int pipe_fd[2];
2323	char buf[1024];
2324	FILE *inf;
2325
2326	/* If we don't have an `ldd', complain. */
2327	if (ldd_file_name == 0)
2328	{
2329	error ("cannot find `ldd'");
2330	return;
2331	}
2332
2333	ldd_argv[argc++] = ldd_file_name;
2334	ldd_argv[argc++] = prog_name;
2335	ldd_argv[argc++] = (char *) 0;
2336
2337	if (pipe (pipe_fd) < 0)
2338	fatal_perror ("pipe");
2339
2340	inf = fdopen (pipe_fd[0], "r");
2341	if (inf == (FILE *) 0)
2342	fatal_perror ("fdopen");
2343
2344	/* Trace if needed. */
2345	if (vflag)
2346	{
2347	char **p_argv;
2348	char *str;
2349
2350	for (p_argv = &ldd_argv[0]; (str = p_argv) != (char ) 0; p_argv++)
2351	fprintf (stderr, " %s", str);
2352
2353	fprintf (stderr, "\n");
2354	}
2355
2356	fflush (stdout);
2357	fflush (stderr);
2358
2359	/* Spawn child ldd on pipe */
2360	pid = vfork ();
2361	if (pid == -1)
2362	{
2363	#ifdef vfork
2364	fatal_perror ("fork");
2365	#else
2366	fatal_perror ("vfork");
2367	#endif
2368	}
2369
2370	if (pid == 0) /* child context */
2371	{
2372	/* setup stdout */
2373	if (dup2 (pipe_fd[1], 1) < 0)
2374	fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
2375
2376	if (close (pipe_fd[0]) < 0)
2377	fatal_perror ("close (%d)", pipe_fd[0]);
2378
2379	if (close (pipe_fd[1]) < 0)
2380	fatal_perror ("close (%d)", pipe_fd[1]);
2381
2382	execv (ldd_file_name, ldd_argv);
2383	fatal_perror ("executing %s", ldd_file_name);
2384	}
2385
2386	/* Parent context from here on. */
2387	int_handler = (void (*) ()) signal (SIGINT, SIG_IGN);
2388	#ifdef SIGQUIT
2389	quit_handler = (void (*) ()) signal (SIGQUIT, SIG_IGN);
2390	#endif
2391
2392	if (close (pipe_fd[1]) < 0)
2393	fatal_perror ("close (%d)", pipe_fd[1]);
2394
2395	if (debug)
2396	fprintf (stderr, "\nldd output with constructors/destructors.\n");
2397
2398	/* Read each line of ldd output. */
2399	while (fgets (buf, sizeof buf, inf) != (char *) 0)
2400	{
2401	int ch, ch2;
2402	char name, end, *p = buf;
2403
2404	/* Extract names of libraries and add to list. */
2405	PARSE_LDD_OUTPUT (p);
2406	if (p == 0)
2407	continue;
2408
2409	name = p;
2410	if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2411	fatal ("dynamic dependency %s not found", buf);
2412
2413	/* Find the end of the symbol name. */
2414	for (end = p;
2415	(ch2 = *end) != '\0' && ch2 != '\n' && !isspace (ch2) && ch2 != '\|';
2416	end++)
2417	continue;
2418	*end = '\0';
2419
2420	if (access (name, R_OK) == 0)
2421	add_to_list (&libraries, name);
2422	else
2423	fatal ("unable to open dynamic dependency '%s'", buf);
2424
2425	if (debug)
2426	fprintf (stderr, "\t%s\n", buf);
2427	}
2428	if (debug)
2429	fprintf (stderr, "\n");
2430
2431	if (fclose (inf) != 0)
2432	fatal_perror ("fclose of pipe");
2433
2434	do_wait (ldd_file_name);
2435
2436	signal (SIGINT, int_handler);
2437	#ifdef SIGQUIT
2438	signal (SIGQUIT, quit_handler);
2439	#endif
2440
2441	/* now iterate through the library list adding their symbols to
2442	the list. */
2443	for (list = libraries.first; list; list = list->next)
2444	scan_prog_file (list->name, PASS_LIB);
2445	}
2446
2447	#endif /* LDD_SUFFIX */
2448	#endif /* SUNOS4_SHARED_LIBRARIES */
2449
2450	#endif /* OBJECT_FORMAT_NONE */
2451
2452
2453	/*
2454	* COFF specific stuff.
2455	*/
2456
2457	#ifdef OBJECT_FORMAT_COFF
2458
2459	#if defined(EXTENDED_COFF)
2460	# define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2461	# define GCC_SYMENT SYMR
2462	# define GCC_OK_SYMBOL(X) ((X).st == stProc && (X).sc == scText)
2463	# define GCC_SYMINC(X) (1)
2464	# define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
2465	# define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
2466	#else
2467	# define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
2468	# define GCC_SYMENT SYMENT
2469	# define GCC_OK_SYMBOL(X) \
2470	(((X).n_sclass == C_EXT) && \
2471	(((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \|\| \
2472	((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))
2473	# define GCC_SYMINC(X) ((X).n_numaux+1)
2474	# define GCC_SYMZERO(X) 0
2475	# define GCC_CHECK_HDR(X) (1)
2476	#endif
2477
2478	extern char *ldgetname ();
2479
2480	/* COFF version to scan the name list of the loaded program for
2481	the symbols g++ uses for static constructors and destructors.
2482
2483	The constructor table begins at __CTOR_LIST__ and contains a count
2484	of the number of pointers (or -1 if the constructors are built in a
2485	separate section by the linker), followed by the pointers to the
2486	constructor functions, terminated with a null pointer. The
2487	destructor table has the same format, and begins at __DTOR_LIST__. */
2488
2489	static void
2490	scan_prog_file (prog_name, which_pass)
2491	char *prog_name;
2492	enum pass which_pass;
2493	{
2494	LDFILE *ldptr = NULL;
2495	int sym_index, sym_count;
2496
2497	if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2498	return;
2499
2500	if ((ldptr = ldopen (prog_name, ldptr)) == NULL)
2501	fatal ("%s: can't open as COFF file", prog_name);
2502
2503	if (!MY_ISCOFF (HEADER (ldptr).f_magic))
2504	fatal ("%s: not a COFF file", prog_name);
2505
2506	if (GCC_CHECK_HDR (ldptr))
2507	{
2508	sym_count = GCC_SYMBOLS (ldptr);
2509	sym_index = GCC_SYMZERO (ldptr);
2510	while (sym_index < sym_count)
2511	{
2512	GCC_SYMENT symbol;
2513
2514	if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2515	break;
2516	sym_index += GCC_SYMINC (symbol);
2517
2518	if (GCC_OK_SYMBOL (symbol))
2519	{
2520	char *name;
2521
2522	if ((name = ldgetname (ldptr, &symbol)) == NULL)
2523	continue; /* should never happen */
2524
2525	#ifdef XCOFF_DEBUGGING_INFO
2526	/* All AIX function names have a duplicate entry beginning
2527	with a dot. */
2528	if (*name == '.')
2529	++name;
2530	#endif
2531
2532	switch (is_ctor_dtor (name))
2533	{
2534	case 1:
2535	add_to_list (&constructors, name);
2536	if (which_pass == PASS_OBJ)
2537	add_to_list (&exports, name);
2538	break;
2539
2540	case 2:
2541	add_to_list (&destructors, name);
2542	if (which_pass == PASS_OBJ)
2543	add_to_list (&exports, name);
2544	break;
2545
2546	default: /* not a constructor or destructor */
2547	continue;
2548	}
2549
2550	#if !defined(EXTENDED_COFF)
2551	if (debug)
2552	fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2553	symbol.n_scnum, symbol.n_sclass,
2554	(symbol.n_type ? "0" : ""), symbol.n_type,
2555	name);
2556	#else
2557	if (debug)
2558	fprintf (stderr, "\tiss = %5d, value = %5d, index = %5d, name = %s\n",
2559	symbol.iss, symbol.value, symbol.index, name);
2560	#endif
2561	}
2562	}
2563	}
2564
2565	(void) ldclose(ldptr);
2566	}
2567
2568	#ifdef XCOFF_SCAN_LIBS
2569	/* Scan imported AIX libraries for GCC static ctors and dtors.
2570	FIXME: it is possible to link an executable without the actual import
2571	library by using an "import file" - a text file listing symbols
2572	exported by a library. To support this, we would have to scan
2573	import files as well as actual shared binaries to find GCC ctors.
2574	TODO: use memory mapping instead of 'ld' routines, files are already
2575	memory mapped, but we could eliminate the extra in-memory copies.
2576	Is it worth the effort? */
2577
2578	static void
2579	scan_libraries (prog_name)
2580	char *prog_name;
2581	{
2582	LDFILE *ldptr;
2583	SCNHDR ldsh;
2584	static struct path_prefix libpath; /* we should only do this once */
2585
2586	if ((ldptr = ldopen (prog_name, ldptr)) == NULL)
2587	fatal ("%s: can't open as COFF file", prog_name);
2588
2589	if (!MY_ISCOFF (HEADER (ldptr).f_magic))
2590	fatal ("%s: not a COFF file", prog_name);
2591
2592	/* find and read loader section */
2593	if (ldnshread (ldptr, _LOADER, &ldsh))
2594	{
2595	LDHDR ldh;
2596	char *impbuf;
2597	int entry;
2598
2599	FSEEK (ldptr, ldsh.s_scnptr, BEGINNING);
2600	FREAD (&ldh, sizeof (ldh), 1, ldptr);
2601	/* read import library list */
2602	impbuf = alloca (ldh.l_istlen);
2603	FSEEK (ldptr, ldh.l_impoff + ldsh.s_scnptr, BEGINNING);
2604	FREAD (impbuf, ldh.l_istlen, 1, ldptr);
2605
2606	if (debug)
2607	fprintf (stderr, "LIBPATH=%s\n", impbuf);
2608	prefix_from_string (impbuf, &libpath);
2609
2610	/* skip LIBPATH and empty base and member fields */
2611	impbuf += strlen (impbuf) + 3;
2612	for (entry = 1; entry < ldh.l_nimpid; ++entry)
2613	{
2614	char *impath = impbuf;
2615	char *implib = impath + strlen (impath) + 1;
2616	char *impmem = implib + strlen (implib) + 1;
2617	char *soname = NULL;
2618	char *trial;
2619	int pathlen;
2620	LDFILE *libptr = NULL;
2621	struct prefix_list *pl;
2622	ARCHDR ah;
2623
2624	impbuf = impmem + strlen (impmem) + 1;
2625	if (debug)
2626	fprintf (stderr, "PATH+BASE=%s%s\n", impath, implib);
2627	/* Skip AIX kernel exports */
2628	if (impath == '/' && (impath+1) == '\0'
2629	&& strcmp (implib, "unix") == 0)
2630	continue;
2631	pathlen = strlen (impath);
2632	trial = alloca (MAX (pathlen + 1, libpath.max_len)
2633	+ strlen (implib) + 1);
2634	if (*impath)
2635	{
2636	strcpy (trial, impath);
2637	if (impath[pathlen - 1] != '/')
2638	trial[pathlen++] = '/';
2639	strcpy (trial + pathlen, implib);
2640	if (access (trial, R_OK) == 0)
2641	soname = trial;
2642	}
2643	else
2644	for (pl = libpath.plist; pl; pl = pl->next)
2645	{
2646	strcpy (trial, pl->prefix);
2647	strcat (trial, implib);
2648	if (access (trial, R_OK) == 0)
2649	{
2650	soname = trial;
2651	break;
2652	}
2653	}
2654
2655	if (! soname)
2656	fatal ("%s: library not found", implib);
2657	if (debug)
2658	if (*impmem)
2659	fprintf (stderr, "%s (%s)\n", soname, impmem);
2660	else
2661	fprintf (stderr, "%s\n", soname);
2662
2663	do
2664	{
2665	/* scan imported shared objects for GCC GLOBAL ctors */
2666	short type;
2667	if ((libptr = ldopen (soname, libptr)) == NULL)
2668	fatal ("%s: can't open import library", soname);
2669	if (TYPE (libptr) == ARTYPE)
2670	{
2671	LDFILE *memptr;
2672	if (! *impmem)
2673	fatal ("%s: no archive member specified", soname);
2674	ldahread (libptr, &ah);
2675	if (strcmp (ah.ar_name, impmem))
2676	continue;
2677	}
2678	type = HEADER (libptr).f_magic;
2679	if (HEADER (libptr).f_flags & F_SHROBJ)
2680	{
2681	SCNHDR soldsh;
2682	LDHDR soldh;
2683	long symcnt, i;
2684	char *ldstrings;
2685	LDSYM *lsyms;
2686	if (!ldnshread (libptr, _LOADER, &soldsh))
2687	fatal ("%s: not an import library", soname);
2688	FSEEK (libptr, soldsh.s_scnptr, BEGINNING);
2689	if (FREAD (&soldh, sizeof (soldh), 1, libptr) != 1)
2690	fatal ("%s: can't read loader section", soname);
2691	/fprintf (stderr, "\tscanning %s\n", soname);/
2692	symcnt = soldh.l_nsyms;
2693	lsyms = (LDSYM) alloca (symcnt sizeof (*lsyms));
2694	symcnt = FREAD (lsyms, sizeof (*lsyms), symcnt, libptr);
2695	ldstrings = alloca (soldh.l_stlen);
2696	FSEEK (libptr, soldsh.s_scnptr+soldh.l_stoff, BEGINNING);
2697	FREAD (ldstrings, soldh.l_stlen, 1, libptr);
2698	for (i = 0; i < symcnt; ++i)
2699	{
2700	LDSYM *l = lsyms + i;
2701	if (LDR_EXPORT (*l))
2702	{
2703	char *expname = 0;
2704	if (l->l_zeroes)
2705	expname = l->l_name;
2706	else if (l->l_offset < soldh.l_stlen)
2707	expname = ldstrings + l->l_offset;
2708	switch (is_ctor_dtor (expname))
2709	{
2710	case 3:
2711	if (debug)
2712	fprintf (stderr, "\t%s\n", expname);
2713	add_to_list (&constructors, expname);
2714	break;
2715
2716	case 4:
2717	add_to_list (&destructors, expname);
2718	break;
2719
2720	default: /* not a constructor or destructor */
2721	continue;
2722	}
2723	}
2724	}
2725	}
2726	else
2727	fprintf (stderr, "%s: type = %04X flags = %04X\n",
2728	ah.ar_name, type, HEADER (libptr).f_flags);
2729	}
2730	while (ldclose (libptr) == FAILURE);
2731	/* printf (stderr, "closed %s\n", soname); */
2732	}
2733	}
2734	}
2735	#endif /* XCOFF_SCAN_LIBS */
2736
2737	#endif /* OBJECT_FORMAT_COFF */
2738
2739
2740	/*
2741	* OSF/rose specific stuff.
2742	*/
2743
2744	#ifdef OBJECT_FORMAT_ROSE
2745
2746	/* Union of the various load commands */
2747
2748	typedef union load_union
2749	{
2750	ldc_header_t hdr; /* common header */
2751	load_cmd_map_command_t map; /* map indexing other load cmds */
2752	interpreter_command_t iprtr; /* interpreter pathname */
2753	strings_command_t str; /* load commands strings section */
2754	region_command_t region; /* region load command */
2755	reloc_command_t reloc; /* relocation section */
2756	package_command_t pkg; /* package load command */
2757	symbols_command_t sym; /* symbol sections */
2758	entry_command_t ent; /* program start section */
2759	gen_info_command_t info; /* object information */
2760	func_table_command_t func; /* function constructors/destructors */
2761	} load_union_t;
2762
2763	/* Structure to point to load command and data section in memory. */
2764
2765	typedef struct load_all
2766	{
2767	load_union_t load; / load command */
2768	char section; / pointer to section */
2769	} load_all_t;
2770
2771	/* Structure to contain information about a file mapped into memory. */
2772
2773	struct file_info
2774	{
2775	char start; / start of map */
2776	char name; / filename */
2777	long size; /* size of the file */
2778	long rounded_size; /* size rounded to page boundary */
2779	int fd; /* file descriptor */
2780	int rw; /* != 0 if opened read/write */
2781	int use_mmap; /* != 0 if mmap'ed */
2782	};
2783
2784	extern int decode_mach_o_hdr ();
2785	extern int encode_mach_o_hdr ();
2786
2787	static void add_func_table PROTO((mo_header_t , load_all_t ,
2788	symbol_info_t *, int));
2789	static void print_header PROTO((mo_header_t *));
2790	static void print_load_command PROTO((load_union_t*, size_t, int));
2791	static void bad_header PROTO((int));
2792	static struct file_info read_file PROTO((char , int, int));
2793	static void end_file PROTO((struct file_info *));
2794
2795	/* OSF/rose specific version to scan the name list of the loaded
2796	program for the symbols g++ uses for static constructors and
2797	destructors.
2798
2799	The constructor table begins at __CTOR_LIST__ and contains a count
2800	of the number of pointers (or -1 if the constructors are built in a
2801	separate section by the linker), followed by the pointers to the
2802	constructor functions, terminated with a null pointer. The
2803	destructor table has the same format, and begins at __DTOR_LIST__. */
2804
2805	static void
2806	scan_prog_file (prog_name, which_pass)
2807	char *prog_name;
2808	enum pass which_pass;
2809	{
2810	char *obj;
2811	mo_header_t hdr;
2812	load_all_t *load_array;
2813	load_all_t *load_end;
2814	load_all_t *load_cmd;
2815	int symbol_load_cmds;
2816	off_t offset;
2817	int i;
2818	int num_syms;
2819	int status;
2820	char *str_sect;
2821	struct file_info *obj_file;
2822	int prog_fd;
2823	mo_lcid_t cmd_strings = -1;
2824	symbol_info_t *main_sym = 0;
2825	int rw = (which_pass != PASS_FIRST);
2826
2827	prog_fd = open (prog_name, (rw) ? O_RDWR : O_RDONLY);
2828	if (prog_fd < 0)
2829	fatal_perror ("can't read %s", prog_name);
2830
2831	obj_file = read_file (prog_name, prog_fd, rw);
2832	obj = obj_file->start;
2833
2834	status = decode_mach_o_hdr (obj, MO_SIZEOF_RAW_HDR, MOH_HEADER_VERSION, &hdr);
2835	if (status != MO_HDR_CONV_SUCCESS)
2836	bad_header (status);
2837
2838
2839	/* Do some basic sanity checks. Note we explicitly use the big endian magic number,
2840	since the hardware will automatically swap bytes for us on loading little endian
2841	integers. */
2842
2843	#ifndef CROSS_COMPILE
2844	if (hdr.moh_magic != MOH_MAGIC_MSB
2845	\|\| hdr.moh_header_version != MOH_HEADER_VERSION
2846	\|\| hdr.moh_byte_order != OUR_BYTE_ORDER
2847	\|\| hdr.moh_data_rep_id != OUR_DATA_REP_ID
2848	\|\| hdr.moh_cpu_type != OUR_CPU_TYPE
2849	\|\| hdr.moh_cpu_subtype != OUR_CPU_SUBTYPE
2850	\|\| hdr.moh_vendor_type != OUR_VENDOR_TYPE)
2851	{
2852	fatal ("incompatibilities between object file & expected values");
2853	}
2854	#endif
2855
2856	if (debug)
2857	print_header (&hdr);
2858
2859	offset = hdr.moh_first_cmd_off;
2860	load_end = load_array
2861	= (load_all_t *) xcalloc (sizeof (load_all_t), hdr.moh_n_load_cmds + 2);
2862
2863	/* Build array of load commands, calculating the offsets */
2864	for (i = 0; i < hdr.moh_n_load_cmds; i++)
2865	{
2866	load_union_t load_hdr; / load command header */
2867
2868	load_cmd = load_end++;
2869	load_hdr = (load_union_t *) (obj + offset);
2870
2871	/* If modifying the program file, copy the header. */
2872	if (rw)
2873	{
2874	load_union_t ptr = (load_union_t ) xmalloc (load_hdr->hdr.ldci_cmd_size);
2875	bcopy ((char )load_hdr, (char )ptr, load_hdr->hdr.ldci_cmd_size);
2876	load_hdr = ptr;
2877
2878	/* null out old command map, because we will rewrite at the end. */
2879	if (ptr->hdr.ldci_cmd_type == LDC_CMD_MAP)
2880	{
2881	cmd_strings = ptr->map.lcm_ld_cmd_strings;
2882	ptr->hdr.ldci_cmd_type = LDC_UNDEFINED;
2883	}
2884	}
2885
2886	load_cmd->load = load_hdr;
2887	if (load_hdr->hdr.ldci_section_off > 0)
2888	load_cmd->section = obj + load_hdr->hdr.ldci_section_off;
2889
2890	if (debug)
2891	print_load_command (load_hdr, offset, i);
2892
2893	offset += load_hdr->hdr.ldci_cmd_size;
2894	}
2895
2896	/* If the last command is the load command map and is not undefined,
2897	decrement the count of load commands. */
2898	if (rw && load_end[-1].load->hdr.ldci_cmd_type == LDC_UNDEFINED)
2899	{
2900	load_end--;
2901	hdr.moh_n_load_cmds--;
2902	}
2903
2904	/* Go through and process each symbol table section. */
2905	symbol_load_cmds = 0;
2906	for (load_cmd = load_array; load_cmd < load_end; load_cmd++)
2907	{
2908	load_union_t *load_hdr = load_cmd->load;
2909
2910	if (load_hdr->hdr.ldci_cmd_type == LDC_SYMBOLS)
2911	{
2912	symbol_load_cmds++;
2913
2914	if (debug)
2915	{
2916	char *kind = "unknown";
2917
2918	switch (load_hdr->sym.symc_kind)
2919	{
2920	case SYMC_IMPORTS: kind = "imports"; break;
2921	case SYMC_DEFINED_SYMBOLS: kind = "defined"; break;
2922	case SYMC_STABS: kind = "stabs"; break;
2923	}
2924
2925	fprintf (stderr, "\nProcessing symbol table #%d, offset = 0x%.8lx, kind = %s\n",
2926	symbol_load_cmds, load_hdr->hdr.ldci_section_off, kind);
2927	}
2928
2929	if (load_hdr->sym.symc_kind != SYMC_DEFINED_SYMBOLS)
2930	continue;
2931
2932	str_sect = load_array[load_hdr->sym.symc_strings_section].section;
2933	if (str_sect == (char *)0)
2934	fatal ("string section missing");
2935
2936	if (load_cmd->section == (char *)0)
2937	fatal ("section pointer missing");
2938
2939	num_syms = load_hdr->sym.symc_nentries;
2940	for (i = 0; i < num_syms; i++)
2941	{
2942	symbol_info_t sym = ((symbol_info_t ) load_cmd->section) + i;
2943	char *name = sym->si_name.symbol_name + str_sect;
2944
2945	if (name[0] != '_')
2946	continue;
2947
2948	if (rw)
2949	{
2950	char *n = name + strlen (name) - strlen (NAME__MAIN);
2951
2952	if ((n - name) < 0 \|\| strcmp (n, NAME__MAIN))
2953	continue;
2954	while (n != name)
2955	if (*--n != '_')
2956	continue;
2957
2958	main_sym = sym;
2959	}
2960	else
2961	{
2962	switch (is_ctor_dtor (name))
2963	{
2964	case 1:
2965	add_to_list (&constructors, name);
2966	break;
2967
2968	case 2:
2969	add_to_list (&destructors, name);
2970	break;
2971
2972	default: /* not a constructor or destructor */
2973	continue;
2974	}
2975	}
2976
2977	if (debug)
2978	fprintf (stderr, "\ttype = 0x%.4x, sc = 0x%.2x, flags = 0x%.8x, name = %.30s\n",
2979	sym->si_type, sym->si_sc_type, sym->si_flags, name);
2980	}
2981	}
2982	}
2983
2984	if (symbol_load_cmds == 0)
2985	fatal ("no symbol table found");
2986
2987	/* Update the program file now, rewrite header and load commands. At present,
2988	we assume that there is enough space after the last load command to insert
2989	one more. Since the first section written out is page aligned, and the
2990	number of load commands is small, this is ok for the present. */
2991
2992	if (rw)
2993	{
2994	load_union_t *load_map;
2995	size_t size;
2996
2997	if (cmd_strings == -1)
2998	fatal ("no cmd_strings found");
2999
3000	/* Add __main to initializer list.
3001	If we are building a program instead of a shared library, don't
3002	do anything, since in the current version, you cannot do mallocs
3003	and such in the constructors. */
3004
3005	if (main_sym != (symbol_info_t *)0
3006	&& ((hdr.moh_flags & MOH_EXECABLE_F) == 0))
3007	add_func_table (&hdr, load_array, main_sym, FNTC_INITIALIZATION);
3008
3009	if (debug)
3010	fprintf (stderr, "\nUpdating header and load commands.\n\n");
3011
3012	hdr.moh_n_load_cmds++;
3013	size = sizeof (load_cmd_map_command_t) + (sizeof (mo_offset_t) * (hdr.moh_n_load_cmds - 1));
3014
3015	/* Create new load command map. */
3016	if (debug)
3017	fprintf (stderr, "load command map, %d cmds, new size %ld.\n",
3018	(int)hdr.moh_n_load_cmds, (long)size);
3019
3020	load_map = (load_union_t *) xcalloc (1, size);
3021	load_map->map.ldc_header.ldci_cmd_type = LDC_CMD_MAP;
3022	load_map->map.ldc_header.ldci_cmd_size = size;
3023	load_map->map.lcm_ld_cmd_strings = cmd_strings;
3024	load_map->map.lcm_nentries = hdr.moh_n_load_cmds;
3025	load_array[hdr.moh_n_load_cmds-1].load = load_map;
3026
3027	offset = hdr.moh_first_cmd_off;
3028	for (i = 0; i < hdr.moh_n_load_cmds; i++)
3029	{
3030	load_map->map.lcm_map[i] = offset;
3031	if (load_array[i].load->hdr.ldci_cmd_type == LDC_CMD_MAP)
3032	hdr.moh_load_map_cmd_off = offset;
3033
3034	offset += load_array[i].load->hdr.ldci_cmd_size;
3035	}
3036
3037	hdr.moh_sizeofcmds = offset - MO_SIZEOF_RAW_HDR;
3038
3039	if (debug)
3040	print_header (&hdr);
3041
3042	/* Write header */
3043	status = encode_mach_o_hdr (&hdr, obj, MO_SIZEOF_RAW_HDR);
3044	if (status != MO_HDR_CONV_SUCCESS)
3045	bad_header (status);
3046
3047	if (debug)
3048	fprintf (stderr, "writing load commands.\n\n");
3049
3050	/* Write load commands */
3051	offset = hdr.moh_first_cmd_off;
3052	for (i = 0; i < hdr.moh_n_load_cmds; i++)
3053	{
3054	load_union_t *load_hdr = load_array[i].load;
3055	size_t size = load_hdr->hdr.ldci_cmd_size;
3056
3057	if (debug)
3058	print_load_command (load_hdr, offset, i);
3059
3060	bcopy ((char )load_hdr, (char )(obj + offset), size);
3061	offset += size;
3062	}
3063	}
3064
3065	end_file (obj_file);
3066
3067	if (close (prog_fd))
3068	fatal_perror ("closing %s", prog_name);
3069
3070	if (debug)
3071	fprintf (stderr, "\n");
3072	}
3073
3074
3075	/* Add a function table to the load commands to call a function
3076	on initiation or termination of the process. */
3077
3078	static void
3079	add_func_table (hdr_p, load_array, sym, type)
3080	mo_header_t hdr_p; / pointer to global header */
3081	load_all_t load_array; / array of ptrs to load cmds */
3082	symbol_info_t sym; / pointer to symbol entry */
3083	int type; /* fntc_type value */
3084	{
3085	/* Add a new load command. */
3086	int num_cmds = ++hdr_p->moh_n_load_cmds;
3087	int load_index = num_cmds - 1;
3088	size_t size = sizeof (func_table_command_t) + sizeof (mo_addr_t);
3089	load_union_t *ptr = xcalloc (1, size);
3090	load_all_t *load_cmd;
3091	int i;
3092
3093	/* Set the unresolved address bit in the header to force the loader to be
3094	used, since kernel exec does not call the initialization functions. */
3095	hdr_p->moh_flags \|= MOH_UNRESOLVED_F;
3096
3097	load_cmd = &load_array[load_index];
3098	load_cmd->load = ptr;
3099	load_cmd->section = (char *)0;
3100
3101	/* Fill in func table load command. */
3102	ptr->func.ldc_header.ldci_cmd_type = LDC_FUNC_TABLE;
3103	ptr->func.ldc_header.ldci_cmd_size = size;
3104	ptr->func.ldc_header.ldci_section_off = 0;
3105	ptr->func.ldc_header.ldci_section_len = 0;
3106	ptr->func.fntc_type = type;
3107	ptr->func.fntc_nentries = 1;
3108
3109	/* copy address, turn it from abs. address to (region,offset) if necessary. */
3110	/* Is the symbol already expressed as (region, offset)? */
3111	if ((sym->si_flags & SI_ABSOLUTE_VALUE_F) == 0)
3112	{
3113	ptr->func.fntc_entry_loc[i].adr_lcid = sym->si_value.def_val.adr_lcid;
3114	ptr->func.fntc_entry_loc[i].adr_sctoff = sym->si_value.def_val.adr_sctoff;
3115	}
3116
3117	/* If not, figure out which region it's in. */
3118	else
3119	{
3120	mo_vm_addr_t addr = sym->si_value.abs_val;
3121	int found = 0;
3122
3123	for (i = 0; i < load_index; i++)
3124	{
3125	if (load_array[i].load->hdr.ldci_cmd_type == LDC_REGION)
3126	{
3127	region_command_t *region_ptr = &load_array[i].load->region;
3128
3129	if ((region_ptr->regc_flags & REG_ABS_ADDR_F) != 0
3130	&& addr >= region_ptr->regc_addr.vm_addr
3131	&& addr <= region_ptr->regc_addr.vm_addr + region_ptr->regc_vm_size)
3132	{
3133	ptr->func.fntc_entry_loc[0].adr_lcid = i;
3134	ptr->func.fntc_entry_loc[0].adr_sctoff = addr - region_ptr->regc_addr.vm_addr;
3135	found++;
3136	break;
3137	}
3138	}
3139	}
3140
3141	if (!found)
3142	fatal ("could not convert 0x%l.8x into a region", addr);
3143	}
3144
3145	if (debug)
3146	fprintf (stderr,
3147	"%s function, region %d, offset = %ld (0x%.8lx)\n",
3148	(type == FNTC_INITIALIZATION) ? "init" : "term",
3149	(int)ptr->func.fntc_entry_loc[i].adr_lcid,
3150	(long)ptr->func.fntc_entry_loc[i].adr_sctoff,
3151	(long)ptr->func.fntc_entry_loc[i].adr_sctoff);
3152
3153	}
3154
3155
3156	/* Print the global header for an OSF/rose object. */
3157
3158	static void
3159	print_header (hdr_ptr)
3160	mo_header_t *hdr_ptr;
3161	{
3162	fprintf (stderr, "\nglobal header:\n");
3163	fprintf (stderr, "\tmoh_magic = 0x%.8lx\n", hdr_ptr->moh_magic);
3164	fprintf (stderr, "\tmoh_major_version = %d\n", (int)hdr_ptr->moh_major_version);
3165	fprintf (stderr, "\tmoh_minor_version = %d\n", (int)hdr_ptr->moh_minor_version);
3166	fprintf (stderr, "\tmoh_header_version = %d\n", (int)hdr_ptr->moh_header_version);
3167	fprintf (stderr, "\tmoh_max_page_size = %d\n", (int)hdr_ptr->moh_max_page_size);
3168	fprintf (stderr, "\tmoh_byte_order = %d\n", (int)hdr_ptr->moh_byte_order);
3169	fprintf (stderr, "\tmoh_data_rep_id = %d\n", (int)hdr_ptr->moh_data_rep_id);
3170	fprintf (stderr, "\tmoh_cpu_type = %d\n", (int)hdr_ptr->moh_cpu_type);
3171	fprintf (stderr, "\tmoh_cpu_subtype = %d\n", (int)hdr_ptr->moh_cpu_subtype);
3172	fprintf (stderr, "\tmoh_vendor_type = %d\n", (int)hdr_ptr->moh_vendor_type);
3173	fprintf (stderr, "\tmoh_load_map_cmd_off = %d\n", (int)hdr_ptr->moh_load_map_cmd_off);
3174	fprintf (stderr, "\tmoh_first_cmd_off = %d\n", (int)hdr_ptr->moh_first_cmd_off);
3175	fprintf (stderr, "\tmoh_sizeofcmds = %d\n", (int)hdr_ptr->moh_sizeofcmds);
3176	fprintf (stderr, "\tmon_n_load_cmds = %d\n", (int)hdr_ptr->moh_n_load_cmds);
3177	fprintf (stderr, "\tmoh_flags = 0x%.8lx", (long)hdr_ptr->moh_flags);
3178
3179	if (hdr_ptr->moh_flags & MOH_RELOCATABLE_F)
3180	fprintf (stderr, ", relocatable");
3181
3182	if (hdr_ptr->moh_flags & MOH_LINKABLE_F)
3183	fprintf (stderr, ", linkable");
3184
3185	if (hdr_ptr->moh_flags & MOH_EXECABLE_F)
3186	fprintf (stderr, ", execable");
3187
3188	if (hdr_ptr->moh_flags & MOH_EXECUTABLE_F)
3189	fprintf (stderr, ", executable");
3190
3191	if (hdr_ptr->moh_flags & MOH_UNRESOLVED_F)
3192	fprintf (stderr, ", unresolved");
3193
3194	fprintf (stderr, "\n\n");
3195	return;
3196	}
3197
3198
3199	/* Print a short summary of a load command. */
3200
3201	static void
3202	print_load_command (load_hdr, offset, number)
3203	load_union_t *load_hdr;
3204	size_t offset;
3205	int number;
3206	{
3207	mo_long_t type = load_hdr->hdr.ldci_cmd_type;
3208	char type_str = (char )0;
3209
3210	switch (type)
3211	{
3212	case LDC_UNDEFINED: type_str = "UNDEFINED"; break;
3213	case LDC_CMD_MAP: type_str = "CMD_MAP"; break;
3214	case LDC_INTERPRETER: type_str = "INTERPRETER"; break;
3215	case LDC_STRINGS: type_str = "STRINGS"; break;
3216	case LDC_REGION: type_str = "REGION"; break;
3217	case LDC_RELOC: type_str = "RELOC"; break;
3218	case LDC_PACKAGE: type_str = "PACKAGE"; break;
3219	case LDC_SYMBOLS: type_str = "SYMBOLS"; break;
3220	case LDC_ENTRY: type_str = "ENTRY"; break;
3221	case LDC_FUNC_TABLE: type_str = "FUNC_TABLE"; break;
3222	case LDC_GEN_INFO: type_str = "GEN_INFO"; break;
3223	}
3224
3225	fprintf (stderr,
3226	"cmd %2d, sz: 0x%.2lx, coff: 0x%.3lx, doff: 0x%.6lx, dlen: 0x%.6lx",
3227	number,
3228	(long) load_hdr->hdr.ldci_cmd_size,
3229	(long) offset,
3230	(long) load_hdr->hdr.ldci_section_off,
3231	(long) load_hdr->hdr.ldci_section_len);
3232
3233	if (type_str == (char *)0)
3234	fprintf (stderr, ", ty: unknown (%ld)\n", (long) type);
3235
3236	else if (type != LDC_REGION)
3237	fprintf (stderr, ", ty: %s\n", type_str);
3238
3239	else
3240	{
3241	char *region = "";
3242	switch (load_hdr->region.regc_usage_type)
3243	{
3244	case REG_TEXT_T: region = ", .text"; break;
3245	case REG_DATA_T: region = ", .data"; break;
3246	case REG_BSS_T: region = ", .bss"; break;
3247	case REG_GLUE_T: region = ", .glue"; break;
3248	#if defined (REG_RDATA_T) && defined (REG_SDATA_T) && defined (REG_SBSS_T) /mips/
3249	case REG_RDATA_T: region = ", .rdata"; break;
3250	case REG_SDATA_T: region = ", .sdata"; break;
3251	case REG_SBSS_T: region = ", .sbss"; break;
3252	#endif
3253	}
3254
3255	fprintf (stderr, ", ty: %s, vaddr: 0x%.8lx, vlen: 0x%.6lx%s\n",
3256	type_str,
3257	(long) load_hdr->region.regc_vm_addr,
3258	(long) load_hdr->region.regc_vm_size,
3259	region);
3260	}
3261
3262	return;
3263	}
3264
3265
3266	/* Fatal error when {en,de}code_mach_o_header fails. */
3267
3268	static void
3269	bad_header (status)
3270	int status;
3271	{
3272	char msg = (char )0;
3273
3274	switch (status)
3275	{
3276	case MO_ERROR_BAD_MAGIC: msg = "bad magic number"; break;
3277	case MO_ERROR_BAD_HDR_VERS: msg = "bad header version"; break;
3278	case MO_ERROR_BAD_RAW_HDR_VERS: msg = "bad raw header version"; break;
3279	case MO_ERROR_BUF2SML: msg = "raw header buffer too small"; break;
3280	case MO_ERROR_OLD_RAW_HDR_FILE: msg = "old raw header file"; break;
3281	case MO_ERROR_UNSUPPORTED_VERS: msg = "unsupported version"; break;
3282	}
3283
3284	if (msg == (char *)0)
3285	fatal ("unknown {de,en}code_mach_o_hdr return value %d", status);
3286	else
3287	fatal ("%s", msg);
3288	}
3289
3290
3291	/* Read a file into a memory buffer. */
3292
3293	static struct file_info *
3294	read_file (name, fd, rw)
3295	char name; / filename */
3296	int fd; /* file descriptor */
3297	int rw; /* read/write */
3298	{
3299	struct stat stat_pkt;
3300	struct file_info p = (struct file_info ) xcalloc (sizeof (struct file_info), 1);
3301	#ifdef USE_MMAP
3302	static int page_size;
3303	#endif
3304
3305	if (fstat (fd, &stat_pkt) < 0)
3306	fatal_perror ("fstat %s", name);
3307
3308	p->name = name;
3309	p->size = stat_pkt.st_size;
3310	p->rounded_size = stat_pkt.st_size;
3311	p->fd = fd;
3312	p->rw = rw;
3313
3314	#ifdef USE_MMAP
3315	if (debug)
3316	fprintf (stderr, "mmap %s, %s\n", name, (rw) ? "read/write" : "read-only");
3317
3318	if (page_size == 0)
3319	page_size = sysconf (_SC_PAGE_SIZE);
3320
3321	p->rounded_size = ((p->size + page_size - 1) / page_size) * page_size;
3322	p->start = mmap ((caddr_t)0,
3323	(rw) ? p->rounded_size : p->size,
3324	(rw) ? (PROT_READ \| PROT_WRITE) : PROT_READ,
3325	MAP_FILE \| MAP_VARIABLE \| MAP_SHARED,
3326	fd,
3327	0L);
3328
3329	if (p->start != (char )0 && p->start != (char )-1)
3330	p->use_mmap = 1;
3331
3332	else
3333	#endif /* USE_MMAP */
3334	{
3335	long len;
3336
3337	if (debug)
3338	fprintf (stderr, "read %s\n", name);
3339
3340	p->use_mmap = 0;
3341	p->start = xmalloc (p->size);
3342	if (lseek (fd, 0L, SEEK_SET) < 0)
3343	fatal_perror ("lseek to 0 on %s", name);
3344
3345	len = read (fd, p->start, p->size);
3346	if (len < 0)
3347	fatal_perror ("read %s", name);
3348
3349	if (len != p->size)
3350	fatal ("read %ld bytes, expected %ld, from %s", len, p->size, name);
3351	}
3352
3353	return p;
3354	}
3355
3356	/* Do anything necessary to write a file back from memory. */
3357
3358	static void
3359	end_file (ptr)
3360	struct file_info ptr; / file information block */
3361	{
3362	#ifdef USE_MMAP
3363	if (ptr->use_mmap)
3364	{
3365	if (ptr->rw)
3366	{
3367	if (debug)
3368	fprintf (stderr, "msync %s\n", ptr->name);
3369
3370	if (msync (ptr->start, ptr->rounded_size, MS_ASYNC))
3371	fatal_perror ("msync %s", ptr->name);
3372	}
3373
3374	if (debug)
3375	fprintf (stderr, "munmap %s\n", ptr->name);
3376
3377	if (munmap (ptr->start, ptr->size))
3378	fatal_perror ("munmap %s", ptr->name);
3379	}
3380	else
3381	#endif /* USE_MMAP */
3382	{
3383	if (ptr->rw)
3384	{
3385	long len;
3386
3387	if (debug)
3388	fprintf (stderr, "write %s\n", ptr->name);
3389
3390	if (lseek (ptr->fd, 0L, SEEK_SET) < 0)
3391	fatal_perror ("lseek to 0 on %s", ptr->name);
3392
3393	len = write (ptr->fd, ptr->start, ptr->size);
3394	if (len < 0)
3395	fatal_perror ("write %s", ptr->name);
3396
3397	if (len != ptr->size)
3398	fatal ("wrote %ld bytes, expected %ld, to %s", len, ptr->size, ptr->name);
3399	}
3400
3401	free (ptr->start);
3402	}
3403
3404	free (ptr);
3405	}
3406
3407	#endif /* OBJECT_FORMAT_ROSE */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: