1	/* Collect static initialization info into data structures that can be
2	traversed by C++ initialization and finalization routines.
3	Copyright (C) 1992-2023 Free Software Foundation, Inc.
4	Contributed by Chris Smith (csmith@convex.com).
5	Heavily modified by Michael Meissner (meissner@cygnus.com),
6	Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
7
8	This file is part of GCC.
9
10	GCC is free software; you can redistribute it and/or modify it under
11	the terms of the GNU General Public License as published by the Free
12	Software Foundation; either version 3, or (at your option) any later
13	version.
14
15	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16	WARRANTY; without even the implied warranty of MERCHANTABILITY or
17	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18	for more details.
19
20	You should have received a copy of the GNU General Public License
21	along with GCC; see the file COPYING3. If not see
22	<http://www.gnu.org/licenses/>. */
23
24
25	/* Build tables of static constructors and destructors and run ld. */
26
27	#include "config.h"
28	#include "system.h"
29	#include "coretypes.h"
30	#include "tm.h"
31	#include "filenames.h"
32	#include "file-find.h"
33	#include "simple-object.h"
34	#include "lto-section-names.h"
35
36	/* TARGET_64BIT may be defined to use driver specific functionality. */
37	#undef TARGET_64BIT
38	#define TARGET_64BIT TARGET_64BIT_DEFAULT
39
40	#ifndef LIBRARY_PATH_ENV
41	#define LIBRARY_PATH_ENV "LIBRARY_PATH"
42	#endif
43
44	#define COLLECT
45
46	#include "collect2.h"
47	#include "collect2-aix.h"
48	#include "collect-utils.h"
49	#include "diagnostic.h"
50	#include "demangle.h"
51	#include "obstack.h"
52	#include "intl.h"
53	#include "version.h"
54
55	/* On certain systems, we have code that works by scanning the object file
56	directly. But this code uses system-specific header files and library
57	functions, so turn it off in a cross-compiler. Likewise, the names of
58	the utilities are not correct for a cross-compiler; we have to hope that
59	cross-versions are in the proper directories. */
60
61	#ifdef CROSS_DIRECTORY_STRUCTURE
62	#ifndef CROSS_AIX_SUPPORT
63	#undef OBJECT_FORMAT_COFF
64	#endif
65	#undef MD_EXEC_PREFIX
66	#undef REAL_LD_FILE_NAME
67	#undef REAL_NM_FILE_NAME
68	#undef REAL_STRIP_FILE_NAME
69	#endif
70
71	/* If we cannot use a special method, use the ordinary one:
72	run nm to find what symbols are present.
73	In a cross-compiler, this means you need a cross nm,
74	but that is not quite as unpleasant as special headers. */
75
76	#if !defined (OBJECT_FORMAT_COFF)
77	#define OBJECT_FORMAT_NONE
78	#endif
79
80	#ifdef OBJECT_FORMAT_COFF
81
82	#ifndef CROSS_DIRECTORY_STRUCTURE
83	#include <a.out.h>
84	#include <ar.h>
85
86	#ifdef UMAX
87	#include <sgs.h>
88	#endif
89
90	/* Many versions of ldfcn.h define these. */
91	#ifdef FREAD
92	#undef FREAD
93	#undef FWRITE
94	#endif
95
96	#include <ldfcn.h>
97	#endif
98
99	/* Some systems have an ISCOFF macro, but others do not. In some cases
100	the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
101	that either do not have an ISCOFF macro in /usr/include or for those
102	where it is wrong. */
103
104	#ifndef MY_ISCOFF
105	#define MY_ISCOFF(X) ISCOFF (X)
106	#endif
107
108	#endif /* OBJECT_FORMAT_COFF */
109
110	#ifdef OBJECT_FORMAT_NONE
111
112	/* Default flags to pass to nm. */
113	#ifndef NM_FLAGS
114	#define NM_FLAGS "-n"
115	#endif
116
117	#endif /* OBJECT_FORMAT_NONE */
118
119	/* Some systems use __main in a way incompatible with its use in gcc, in these
120	cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
121	give the same symbol without quotes for an alternative entry point. */
122	#ifndef NAME__MAIN
123	#define NAME__MAIN "__main"
124	#endif
125
126	/* This must match tree.h. */
127	#define DEFAULT_INIT_PRIORITY 65535
128
129	#ifndef COLLECT_SHARED_INIT_FUNC
130	#define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
131	fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
132	#endif
133	#ifndef COLLECT_SHARED_FINI_FUNC
134	#define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
135	fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
136	#endif
137
138	#ifdef LDD_SUFFIX
139	#define SCAN_LIBRARIES
140	#endif
141
142	#ifndef SHLIB_SUFFIX
143	#define SHLIB_SUFFIX ".so"
144	#endif
145
146	#ifdef USE_COLLECT2
147	int do_collecting = 1;
148	#else
149	int do_collecting = 0;
150	#endif
151
152	/* Cook up an always defined indication of whether we proceed the
153	"EXPORT_LIST" way. */
154
155	#ifdef COLLECT_EXPORT_LIST
156	#define DO_COLLECT_EXPORT_LIST 1
157	#else
158	#define DO_COLLECT_EXPORT_LIST 0
159	#endif
160
161	/* Nonzero if we should suppress the automatic demangling of identifiers
162	in linker error messages. Set from COLLECT_NO_DEMANGLE. */
163	int no_demangle;
164
165	/* Linked lists of constructor and destructor names. */
166
167	struct id
168	{
169	struct id *next;
170	int sequence;
171	char name[1];
172	};
173
174	struct head
175	{
176	struct id *first;
177	struct id *last;
178	int number;
179	};
180
181	static int rflag; /* true if -r */
182	static int strip_flag; /* true if -s */
183	#ifdef COLLECT_EXPORT_LIST
184	static int export_flag; /* true if -bE */
185	static int aix64_flag; /* true if -b64 */
186	static int aixrtl_flag; /* true if -brtl */
187	static int aixlazy_flag; /* true if -blazy */
188	static int visibility_flag; /* true if -fvisibility */
189	#endif
190
191	enum lto_mode_d {
192	LTO_MODE_NONE, /* Not doing LTO. */
193	LTO_MODE_LTO, /* Normal LTO. */
194	LTO_MODE_WHOPR /* WHOPR. */
195	};
196
197	/* Current LTO mode. */
198	#ifdef ENABLE_LTO
199	static enum lto_mode_d lto_mode = LTO_MODE_WHOPR;
200	#else
201	static enum lto_mode_d lto_mode = LTO_MODE_NONE;
202	#endif
203
204	bool helpflag; /* true if --help */
205
206	static int shared_obj; /* true if -shared */
207	static int static_obj; /* true if -static */
208
209	static const char *c_file; /* <xxx>.c for constructor/destructor list. */
210	static const char *o_file; /* <xxx>.o for constructor/destructor list. */
211	#ifdef COLLECT_EXPORT_LIST
212	static const char *export_file; /* <xxx>.x for AIX export list. */
213	#endif
214	static char **lto_o_files; /* Output files for LTO. */
215	static const char *output_file; /* Output file for ld. */
216	static const char *nm_file_name; /* pathname of nm */
217	#ifdef LDD_SUFFIX
218	static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
219	#endif
220	static const char *strip_file_name; /* pathname of strip */
221	const char *c_file_name; /* pathname of gcc */
222	static char *initname, *fininame; /* names of init and fini funcs */
223
224
225	#ifdef TARGET_AIX_VERSION
226	static char *aix_shared_initname;
227	static char *aix_shared_fininame; /* init/fini names as per the scheme
228	described in config/rs6000/aix.h */
229	#endif
230
231	static struct head constructors; /* list of constructors found */
232	static struct head destructors; /* list of destructors found */
233	#ifdef COLLECT_EXPORT_LIST
234	static struct head exports; /* list of exported symbols */
235	#endif
236	static struct head frame_tables; /* list of frame unwind info tables */
237
238	bool at_file_supplied; /* Whether to use @file arguments */
239
240	struct obstack temporary_obstack;
241	char * temporary_firstobj;
242
243	/* A string that must be prepended to a target OS path in order to find
244	it on the host system. */
245	#ifdef TARGET_SYSTEM_ROOT
246	static const char *target_system_root = TARGET_SYSTEM_ROOT;
247	#else
248	static const char *target_system_root = "";
249	#endif
250
251	/* Whether we may unlink the output file, which should be set as soon as we
252	know we have successfully produced it. This is typically useful to prevent
253	blindly attempting to unlink a read-only output that the target linker
254	would leave untouched. */
255	bool may_unlink_output_file = false;
256
257	#ifdef COLLECT_EXPORT_LIST
258	/* Lists to keep libraries to be scanned for global constructors/destructors. */
259	static struct head libs; /* list of libraries */
260	static struct head static_libs; /* list of statically linked libraries */
261	static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
262	static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
263	static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
264	&libpath_lib_dirs, NULL};
265	#endif
266
267	/* List of names of object files containing LTO information.
268	These are a subset of the object file names appearing on the
269	command line, and must be identical, in the sense of pointer
270	equality, with the names passed to maybe_run_lto_and_relink(). */
271
272	struct lto_object
273	{
274	const char *name; /* Name of object file. */
275	struct lto_object *next; /* Next in linked list. */
276	};
277
278	struct lto_object_list
279	{
280	struct lto_object *first; /* First list element. */
281	struct lto_object *last; /* Last list element. */
282	};
283
284	static struct lto_object_list lto_objects;
285
286	/* Special kinds of symbols that a name may denote. */
287
288	enum symkind {
289	SYM_REGULAR = 0, /* nothing special */
290
291	SYM_CTOR = 1, /* constructor */
292	SYM_DTOR = 2, /* destructor */
293	SYM_INIT = 3, /* shared object routine that calls all the ctors */
294	SYM_FINI = 4, /* shared object routine that calls all the dtors */
295	SYM_DWEH = 5, /* DWARF exception handling table */
296	SYM_AIXI = 6,
297	SYM_AIXD = 7
298	};
299
300	const char tool_name[] = "collect2";
301
302	static symkind is_ctor_dtor (const char *);
303
304	static void maybe_unlink_list (char **);
305	static void add_to_list (struct head *, const char *);
306	static int extract_init_priority (const char *);
307	static void sort_ids (struct head *);
308	static void write_list (FILE *, const char *, struct id *);
309	#ifdef COLLECT_EXPORT_LIST
310	static void dump_list (FILE *, const char *, struct id *);
311	#endif
312	#if 0
313	static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
314	#endif
315	static void write_list_with_asm (FILE *, const char *, struct id *);
316	static void write_c_file (FILE *, const char *);
317	static void write_c_file_stat (FILE *, const char *);
318	#ifndef LD_INIT_SWITCH
319	static void write_c_file_glob (FILE *, const char *);
320	#endif
321	#ifdef SCAN_LIBRARIES
322	static void scan_libraries (const char *);
323	#endif
324	#ifdef COLLECT_EXPORT_LIST
325	static int is_in_list (const char *, struct id *);
326	static void write_aix_file (FILE *, struct id *);
327	static char *resolve_lib_name (const char *);
328	#endif
329	static char *extract_string (const char **);
330	static void post_ld_pass (bool);
331	static void process_args (int *argcp, char **argv);
332
333	/* Enumerations describing which pass this is for scanning the
334	program file ... */
335
336	enum scanpass {
337	PASS_FIRST, /* without constructors */
338	PASS_OBJ, /* individual objects */
339	PASS_LIB, /* looking for shared libraries */
340	PASS_SECOND, /* with constructors linked in */
341	PASS_LTOINFO /* looking for objects with LTO info */
342	};
343
344	/* ... and which kinds of symbols are to be considered. */
345
346	enum scanfilter_masks {
347	SCAN_NOTHING = 0,
348
349	SCAN_CTOR = 1 << SYM_CTOR,
350	SCAN_DTOR = 1 << SYM_DTOR,
351	SCAN_INIT = 1 << SYM_INIT,
352	SCAN_FINI = 1 << SYM_FINI,
353	SCAN_DWEH = 1 << SYM_DWEH,
354	SCAN_AIXI = 1 << SYM_AIXI,
355	SCAN_AIXD = 1 << SYM_AIXD,
356	SCAN_ALL = ~0
357	};
358
359	/* This type is used for parameters and variables which hold
360	combinations of the flags in enum scanfilter_masks. */
361	typedef int scanfilter;
362
363	/* Scan the name list of the loaded program for the symbols g++ uses for
364	static constructors and destructors.
365
366	The SCANPASS argument tells which collect processing pass this is for and
367	the SCANFILTER argument tells which kinds of symbols to consider in this
368	pass. Symbols of a special kind not in the filter mask are considered as
369	regular ones.
370
371	The constructor table begins at __CTOR_LIST__ and contains a count of the
372	number of pointers (or -1 if the constructors are built in a separate
373	section by the linker), followed by the pointers to the constructor
374	functions, terminated with a null pointer. The destructor table has the
375	same format, and begins at __DTOR_LIST__. */
376
377	static void scan_prog_file (const char *, scanpass, scanfilter);
378
379
380	/* Delete tempfiles and exit function. */
381
382	void
383	tool_cleanup (bool from_signal)
384	{
385	/* maybe_unlink may call notice, which is not signal safe. */
386	if (from_signal)
387	verbose = false;
388
389	if (c_file != 0 && c_file[0])
390	maybe_unlink (c_file);
391
392	if (o_file != 0 && o_file[0])
393	maybe_unlink (o_file);
394
395	#ifdef COLLECT_EXPORT_LIST
396	if (export_file != 0 && export_file[0])
397	maybe_unlink (export_file);
398	#endif
399
400	if (lto_o_files)
401	maybe_unlink_list (lto_o_files);
402	}
403
404	static void
405	collect_atexit (void)
406	{
407	tool_cleanup (from_signal: false);
408	}
409
410	/* Notify user of a non-error, without translating the format string. */
411	void
412	notice_translated (const char *cmsgid, ...)
413	{
414	va_list ap;
415
416	va_start (ap, cmsgid);
417	vfprintf (stderr, format: cmsgid, arg: ap);
418	va_end (ap);
419	}
420
421	int
422	file_exists (const char *name)
423	{
424	return access (name: name, R_OK) == 0;
425	}
426
427	/* Parse a reasonable subset of shell quoting syntax. */
428
429	static char *
430	extract_string (const char **pp)
431	{
432	const char *p = *pp;
433	int backquote = 0;
434	int inside = 0;
435
436	for (;;)
437	{
438	char c = *p;
439	if (c == '\0')
440	break;
441	++p;
442	if (backquote)
443	obstack_1grow (&temporary_obstack, c);
444	else if (! inside && c == ' ')
445	break;
446	else if (! inside && c == '\\')
447	backquote = 1;
448	else if (c == '\'')
449	inside = !inside;
450	else
451	obstack_1grow (&temporary_obstack, c);
452	}
453
454	obstack_1grow (&temporary_obstack, '\0');
455	*pp = p;
456	return XOBFINISH (&temporary_obstack, char *);
457	}
458
459	/* Return the kind of symbol denoted by name S. */
460
461	static symkind
462	is_ctor_dtor (const char *s)
463	{
464	struct names { const char *const name; const int len; symkind ret;
465	const int two_underscores; };
466
467	const struct names *p;
468	int ch;
469	const char *orig_s = s;
470
471	static const struct names special[] = {
472	#ifndef NO_DOLLAR_IN_LABEL
473	{ "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
474	{ "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
475	#else
476	#ifndef NO_DOT_IN_LABEL
477	{ .name: "GLOBAL__I.", .len: sizeof ("GLOBAL__I.")-1, .ret: SYM_CTOR, .two_underscores: 0 },
478	{ .name: "GLOBAL__D.", .len: sizeof ("GLOBAL__D.")-1, .ret: SYM_DTOR, .two_underscores: 0 },
479	#endif /* NO_DOT_IN_LABEL */
480	#endif /* NO_DOLLAR_IN_LABEL */
481	{ .name: "GLOBAL__I_", .len: sizeof ("GLOBAL__I_")-1, .ret: SYM_CTOR, .two_underscores: 0 },
482	{ .name: "GLOBAL__D_", .len: sizeof ("GLOBAL__D_")-1, .ret: SYM_DTOR, .two_underscores: 0 },
483	{ .name: "GLOBAL__F_", .len: sizeof ("GLOBAL__F_")-1, .ret: SYM_DWEH, .two_underscores: 0 },
484	{ .name: "GLOBAL__FI_", .len: sizeof ("GLOBAL__FI_")-1, .ret: SYM_INIT, .two_underscores: 0 },
485	{ .name: "GLOBAL__FD_", .len: sizeof ("GLOBAL__FD_")-1, .ret: SYM_FINI, .two_underscores: 0 },
486	#ifdef TARGET_AIX_VERSION
487	{ "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI, 0 },
488	{ "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD, 0 },
489	#endif
490	{ NULL, .len: 0, .ret: SYM_REGULAR, .two_underscores: 0 }
491	};
492
493	while ((ch = *s) == '_')
494	++s;
495
496	if (s == orig_s)
497	return SYM_REGULAR;
498
499	for (p = &special[0]; p->len > 0; p++)
500	{
501	if (ch == p->name[0]
502	&& (!p->two_underscores || ((s - orig_s) >= 2))
503	&& strncmp (s1: s, s2: p->name, n: p->len) == 0)
504	{
505	return p->ret;
506	}
507	}
508	return SYM_REGULAR;
509	}
510
511	/* We maintain two prefix lists: one from COMPILER_PATH environment variable
512	and one from the PATH variable. */
513
514	static struct path_prefix cpath, path;
515
516	#ifdef CROSS_DIRECTORY_STRUCTURE
517	/* This is the name of the target machine. We use it to form the name
518	of the files to execute. */
519
520	static const char *const target_machine = TARGET_MACHINE;
521	#endif
522
523	/* Search for NAME using prefix list PPREFIX. We only look for executable
524	files.
525
526	Return 0 if not found, otherwise return its name, allocated with malloc. */
527
528	#ifdef OBJECT_FORMAT_NONE
529
530	/* Add an entry for the object file NAME to object file list LIST.
531	New entries are added at the end of the list. The original pointer
532	value of NAME is preserved, i.e., no string copy is performed. */
533
534	static void
535	add_lto_object (struct lto_object_list *list, const char *name)
536	{
537	struct lto_object *n = XNEW (struct lto_object);
538	n->name = name;
539	n->next = NULL;
540
541	if (list->last)
542	list->last->next = n;
543	else
544	list->first = n;
545
546	list->last = n;
547	}
548	#endif /* OBJECT_FORMAT_NONE */
549
550
551	/* Perform a link-time recompilation and relink if any of the object
552	files contain LTO info. The linker command line LTO_LD_ARGV
553	represents the linker command that would produce a final executable
554	without the use of LTO. OBJECT_LST is a vector of object file names
555	appearing in LTO_LD_ARGV that are to be considered for link-time
556	recompilation, where OBJECT is a pointer to the last valid element.
557	(This awkward convention avoids an impedance mismatch with the
558	usage of similarly-named variables in main().) The elements of
559	OBJECT_LST must be identical, i.e., pointer equal, to the
560	corresponding arguments in LTO_LD_ARGV.
561
562	Upon entry, at least one linker run has been performed without the
563	use of any LTO info that might be present. Any recompilations
564	necessary for template instantiations have been performed, and
565	initializer/finalizer tables have been created if needed and
566	included in the linker command line LTO_LD_ARGV. If any of the
567	object files contain LTO info, we run the LTO back end on all such
568	files, and perform the final link with the LTO back end output
569	substituted for the LTO-optimized files. In some cases, a final
570	link with all link-time generated code has already been performed,
571	so there is no need to relink if no LTO info is found. In other
572	cases, our caller has not produced the final executable, and is
573	relying on us to perform the required link whether LTO info is
574	present or not. In that case, the FORCE argument should be true.
575	Note that the linker command line argument LTO_LD_ARGV passed into
576	this function may be modified in place. */
577
578	static void
579	maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
580	const char **object, bool force)
581	{
582	const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
583
584	int num_lto_c_args = 1; /* Allow space for the terminating NULL. */
585
586	while (object_file < object)
587	{
588	/* If file contains LTO info, add it to the list of LTO objects. */
589	scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
590
591	/* Increment the argument count by the number of object file arguments
592	we will add. An upper bound suffices, so just count all of the
593	object files regardless of whether they contain LTO info. */
594	num_lto_c_args++;
595	}
596
597	if (lto_objects.first)
598	{
599	char **lto_c_argv;
600	const char **lto_c_ptr;
601	char **p;
602	char **lto_o_ptr;
603	struct lto_object *list;
604	char *lto_wrapper = getenv (name: "COLLECT_LTO_WRAPPER");
605	struct pex_obj *pex;
606	const char *prog = "lto-wrapper";
607	int lto_ld_argv_size = 0;
608	char **out_lto_ld_argv;
609	int out_lto_ld_argv_size;
610	size_t num_files;
611
612	if (!lto_wrapper)
613	fatal_error (input_location, "environment variable "
614	"%<COLLECT_LTO_WRAPPER%> must be set");
615
616	num_lto_c_args++;
617
618	/* There is at least one object file containing LTO info,
619	so we need to run the LTO back end and relink.
620
621	To do so we build updated ld arguments with first
622	LTO object replaced by all partitions and other LTO
623	objects removed. */
624
625	lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
626	lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
627
628	*lto_c_ptr++ = lto_wrapper;
629
630	/* Add LTO objects to the wrapper command line. */
631	for (list = lto_objects.first; list; list = list->next)
632	*lto_c_ptr++ = list->name;
633
634	*lto_c_ptr = NULL;
635
636	/* Run the LTO back end. */
637	pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH,
638	at_file_supplied, "lto_args");
639	{
640	int c;
641	FILE *stream;
642	size_t i;
643	char *start, *end;
644
645	stream = pex_read_output (pex, binary: 0);
646	gcc_assert (stream);
647
648	num_files = 0;
649	while ((c = getc (stream: stream)) != EOF)
650	{
651	obstack_1grow (&temporary_obstack, c);
652	if (c == '\n')
653	++num_files;
654	}
655
656	/* signal handler may access uninitialized memory
657	and delete whatever it points to, if lto_o_files
658	is not allocated with calloc. */
659	lto_o_files = XCNEWVEC (char *, num_files + 1);
660	lto_o_files[num_files] = NULL;
661	start = XOBFINISH (&temporary_obstack, char *);
662	for (i = 0; i < num_files; ++i)
663	{
664	end = start;
665	while (*end != '\n')
666	++end;
667	*end = '\0';
668
669	lto_o_files[i] = xstrdup (start);
670
671	start = end + 1;
672	}
673
674	obstack_free (&temporary_obstack, temporary_firstobj);
675	}
676	do_wait (prog, pex);
677	pex = NULL;
678
679	/* Compute memory needed for new LD arguments. At most number of original arguments
680	plus number of partitions. */
681	for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
682	;
683	out_lto_ld_argv = XCNEWVEC (char *, num_files + lto_ld_argv_size + 1);
684	out_lto_ld_argv_size = 0;
685
686	/* After running the LTO back end, we will relink, substituting
687	the LTO output for the object files that we submitted to the
688	LTO. Here, we modify the linker command line for the relink. */
689
690	/* Copy all arguments until we find first LTO file. */
691	p = lto_ld_argv;
692	while (*p != NULL)
693	{
694	for (list = lto_objects.first; list; list = list->next)
695	if (*p == list->name) /* Note test for pointer equality! */
696	break;
697	if (list)
698	break;
699	out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
700	}
701
702	/* Now insert all LTO partitions. */
703	lto_o_ptr = lto_o_files;
704	while (*lto_o_ptr)
705	out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
706
707	/* ... and copy the rest. */
708	while (*p != NULL)
709	{
710	for (list = lto_objects.first; list; list = list->next)
711	if (*p == list->name) /* Note test for pointer equality! */
712	break;
713	if (!list)
714	out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
715	p++;
716	}
717	out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
718
719	/* Run the linker again, this time replacing the object files
720	optimized by the LTO with the temporary file generated by the LTO. */
721	fork_execute ("ld", out_lto_ld_argv, HAVE_GNU_LD && at_file_supplied,
722	"ld_args");
723	/* We assume that temp files were created, and therefore we need to take
724	that into account (maybe run dsymutil). */
725	post_ld_pass (/*temp_file*/true);
726	free (ptr: lto_ld_argv);
727
728	maybe_unlink_list (lto_o_files);
729	}
730	else if (force)
731	{
732	/* Our caller is relying on us to do the link
733	even though there is no LTO back end work to be done. */
734	fork_execute ("ld", lto_ld_argv, HAVE_GNU_LD && at_file_supplied,
735	"ld_args");
736	/* No LTO objects were found, so no new temp file. */
737	post_ld_pass (/*temp_file*/false);
738	}
739	else
740	post_ld_pass (false); /* No LTO objects were found, no temp file. */
741	}
742	/* Entry point for linker invoation. Called from main in collect2.cc.
743	LD_ARGV is an array of arguments for the linker. */
744
745	static void
746	do_link (char **ld_argv, const char *atsuffix)
747	{
748	struct pex_obj *pex;
749	const char *prog = "ld";
750	pex = collect_execute (prog, ld_argv, NULL, NULL,
751	PEX_LAST | PEX_SEARCH,
752	HAVE_GNU_LD && at_file_supplied, atsuffix);
753	int ret = collect_wait (prog, pex);
754	if (ret)
755	{
756	error ("ld returned %d exit status", ret);
757	exit (status: ret);
758	}
759	else
760	{
761	/* We have just successfully produced an output file, so assume that we
762	may unlink it if need be for now on. */
763	may_unlink_output_file = true;
764	}
765	}
766
767	/* Main program. */
768
769	int
770	main (int argc, char **argv)
771	{
772	enum linker_select
773	{
774	USE_DEFAULT_LD,
775	USE_PLUGIN_LD,
776	USE_GOLD_LD,
777	USE_BFD_LD,
778	USE_LLD_LD,
779	USE_MOLD_LD,
780	USE_LD_MAX
781	} selected_linker = USE_DEFAULT_LD;
782	static const char *const ld_suffixes[USE_LD_MAX] =
783	{
784	"ld",
785	PLUGIN_LD_SUFFIX,
786	"ld.gold",
787	"ld.bfd",
788	"ld.lld",
789	"ld.mold"
790	};
791	static const char *const real_ld_suffix = "real-ld";
792	static const char *const collect_ld_suffix = "collect-ld";
793	static const char *const nm_suffix = "nm";
794	static const char *const gnm_suffix = "gnm";
795	#ifdef LDD_SUFFIX
796	static const char *const ldd_suffix = LDD_SUFFIX;
797	#endif
798	static const char *const strip_suffix = "strip";
799	static const char *const gstrip_suffix = "gstrip";
800
801	const char *full_ld_suffixes[USE_LD_MAX];
802	#ifdef CROSS_DIRECTORY_STRUCTURE
803	/* If we look for a program in the compiler directories, we just use
804	the short name, since these directories are already system-specific.
805	But it we look for a program in the system directories, we need to
806	qualify the program name with the target machine. */
807
808	const char *const full_nm_suffix =
809	concat (target_machine, "-", nm_suffix, NULL);
810	const char *const full_gnm_suffix =
811	concat (target_machine, "-", gnm_suffix, NULL);
812	#ifdef LDD_SUFFIX
813	const char *const full_ldd_suffix =
814	concat (target_machine, "-", ldd_suffix, NULL);
815	#endif
816	const char *const full_strip_suffix =
817	concat (target_machine, "-", strip_suffix, NULL);
818	const char *const full_gstrip_suffix =
819	concat (target_machine, "-", gstrip_suffix, NULL);
820	#else
821	#ifdef LDD_SUFFIX
822	const char *const full_ldd_suffix = ldd_suffix;
823	#endif
824	const char *const full_nm_suffix = nm_suffix;
825	const char *const full_gnm_suffix = gnm_suffix;
826	const char *const full_strip_suffix = strip_suffix;
827	const char *const full_gstrip_suffix = gstrip_suffix;
828	#endif /* CROSS_DIRECTORY_STRUCTURE */
829
830	const char *arg;
831	FILE *outf;
832	#ifdef COLLECT_EXPORT_LIST
833	FILE *exportf;
834	#endif
835	const char *ld_file_name;
836	const char *p;
837	char **c_argv;
838	const char **c_ptr;
839	char **ld1_argv;
840	const char **ld1;
841	bool use_plugin = false;
842	bool use_collect_ld = false;
843
844	/* The kinds of symbols we will have to consider when scanning the
845	outcome of a first pass link. This is ALL to start with, then might
846	be adjusted before getting to the first pass link per se, typically on
847	AIX where we perform an early scan of objects and libraries to fetch
848	the list of global ctors/dtors and make sure they are not garbage
849	collected. */
850	scanfilter ld1_filter = SCAN_ALL;
851
852	char **ld2_argv;
853	const char **ld2;
854	char **object_lst;
855	const char **object;
856	#ifdef TARGET_AIX_VERSION
857	int object_nbr = argc;
858	#endif
859	int first_file;
860	int num_c_args;
861	char **old_argv;
862	#ifdef COLLECT_EXPORT_LIST
863	bool is_static = false;
864	#endif
865	int i;
866
867	for (i = 0; i < USE_LD_MAX; i++)
868	#ifdef CROSS_DIRECTORY_STRUCTURE
869	/* lld and mold are platform-agnostic and not prefixed with target
870	triple. */
871	if (!(i == USE_LLD_LD || i == USE_MOLD_LD))
872	full_ld_suffixes[i] = concat (target_machine, "-", ld_suffixes[i],
873	NULL);
874	else
875	#endif
876	full_ld_suffixes[i] = ld_suffixes[i];
877
878	p = argv[0] + strlen (s: argv[0]);
879	while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
880	--p;
881	progname = p;
882
883	xmalloc_set_program_name (progname);
884
885	old_argv = argv;
886	expandargv (&argc, &argv);
887	if (argv != old_argv)
888	at_file_supplied = 1;
889
890	process_args (argcp: &argc, argv);
891
892	num_c_args = argc + 9;
893
894	#ifndef HAVE_LD_DEMANGLE
895	no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
896
897	/* Suppress demangling by the real linker, which may be broken. */
898	putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
899	#endif
900
901	#if defined (COLLECT2_HOST_INITIALIZATION)
902	/* Perform system dependent initialization, if necessary. */
903	COLLECT2_HOST_INITIALIZATION;
904	#endif
905
906	setup_signals ();
907
908	/* Unlock the stdio streams. */
909	unlock_std_streams ();
910
911	gcc_init_libintl ();
912
913	diagnostic_initialize (context: global_dc, n_opts: 0);
914
915	if (atexit (func: collect_atexit) != 0)
916	fatal_error (input_location, "atexit failed");
917
918	/* Do not invoke xcalloc before this point, since locale needs to be
919	set first, in case a diagnostic is issued. */
920
921	ld1_argv = XCNEWVEC (char *, argc + 4);
922	ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
923	ld2_argv = XCNEWVEC (char *, argc + 11);
924	ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
925	object_lst = XCNEWVEC (char *, argc);
926	object = CONST_CAST2 (const char **, char **, object_lst);
927
928	#ifdef DEBUG
929	debug = true;
930	#endif
931
932	save_temps = false;
933	verbose = false;
934
935	#ifndef DEFAULT_A_OUT_NAME
936	output_file = "a.out";
937	#else
938	output_file = DEFAULT_A_OUT_NAME;
939	#endif
940
941	/* Parse command line / environment for flags we want early.
942	This allows the debug flag to be set before functions like find_a_file()
943	are called. */
944	{
945	bool no_partition = false;
946
947	for (i = 1; argv[i] != NULL; i ++)
948	{
949	if (! strcmp (s1: argv[i], s2: "-debug"))
950	debug = true;
951	else if (startswith (str: argv[i], prefix: "-fno-lto"))
952	lto_mode = LTO_MODE_NONE;
953	else if (! strcmp (s1: argv[i], s2: "-plugin"))
954	{
955	use_plugin = true;
956	if (selected_linker == USE_DEFAULT_LD)
957	selected_linker = USE_PLUGIN_LD;
958	}
959	else if (strcmp (s1: argv[i], s2: "-fuse-ld=bfd") == 0)
960	selected_linker = USE_BFD_LD;
961	else if (strcmp (s1: argv[i], s2: "-fuse-ld=gold") == 0)
962	selected_linker = USE_GOLD_LD;
963	else if (strcmp (s1: argv[i], s2: "-fuse-ld=lld") == 0)
964	selected_linker = USE_LLD_LD;
965	else if (strcmp (s1: argv[i], s2: "-fuse-ld=mold") == 0)
966	selected_linker = USE_MOLD_LD;
967	else if (startswith (str: argv[i], prefix: "-o"))
968	{
969	/* Parse the output filename if it's given so that we can make
970	meaningful temp filenames. */
971	if (argv[i][2] != '\0')
972	output_file = &argv[i][2];
973	else if (argv[i+1] != NULL)
974	output_file = argv[++i];
975	}
976
977	#ifdef COLLECT_EXPORT_LIST
978	/* These flags are position independent, although their order
979	is important - subsequent flags override earlier ones. */
980	else if (strcmp (argv[i], "-b64") == 0)
981	aix64_flag = 1;
982	/* -bexport:filename always needs the :filename */
983	else if (startswith (argv[i], "-bE:")
984	|| startswith (argv[i], "-bexport:"))
985	export_flag = 1;
986	else if (strcmp (argv[i], "-brtl") == 0
987	|| strcmp (argv[i], "-bsvr4") == 0
988	|| strcmp (argv[i], "-G") == 0)
989	aixrtl_flag = 1;
990	else if (strcmp (argv[i], "-bnortl") == 0)
991	aixrtl_flag = 0;
992	else if (strcmp (argv[i], "-blazy") == 0)
993	aixlazy_flag = 1;
994	#endif
995	}
996
997	obstack_begin (&temporary_obstack, 0);
998	temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
999
1000	#ifndef HAVE_LD_DEMANGLE
1001	current_demangling_style = auto_demangling;
1002	#endif
1003
1004	/* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
1005	The LTO options are passed here as are other options that might
1006	be unsuitable for ld (e.g. -save-temps). */
1007	p = getenv (name: "COLLECT_GCC_OPTIONS");
1008	while (p && *p)
1009	{
1010	const char *q = extract_string (pp: &p);
1011	if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1012	num_c_args++;
1013	if (startswith (str: q, prefix: "-flto-partition=none"))
1014	no_partition = true;
1015	else if (startswith (str: q, prefix: "-fno-lto"))
1016	lto_mode = LTO_MODE_NONE;
1017	else if (startswith (str: q, prefix: "-save-temps"))
1018	/* FIXME: Honour =obj. */
1019	save_temps = true;
1020	else if (strcmp (s1: q, s2: "-dumpdir") == 0)
1021	dumppfx = xstrdup (extract_string (pp: &p));
1022	else if (strcmp (s1: q, s2: "-o") == 0
1023	|| strcmp (s1: q, s2: "-B") == 0
1024	|| strcmp (s1: q, s2: "-isystem") == 0)
1025	(void) extract_string (pp: &p);
1026	}
1027	obstack_free (&temporary_obstack, temporary_firstobj);
1028
1029	verbose = verbose || debug;
1030	save_temps = save_temps || debug;
1031	find_file_set_debug (debug);
1032	if (use_plugin)
1033	lto_mode = LTO_MODE_NONE;
1034	if (no_partition && lto_mode == LTO_MODE_WHOPR)
1035	lto_mode = LTO_MODE_LTO;
1036	}
1037
1038	/* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1039	-fno-exceptions -w -fno-whole-program */
1040	num_c_args += 6;
1041
1042	c_argv = XCNEWVEC (char *, num_c_args);
1043	c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1044
1045	if (argc < 2)
1046	fatal_error (input_location, "no arguments");
1047
1048	/* Extract COMPILER_PATH and PATH into our prefix list. */
1049	prefix_from_env ("COMPILER_PATH", &cpath);
1050	prefix_from_env ("PATH", &path);
1051
1052	/* Try to discover a valid linker/nm/strip to use. */
1053
1054	/* Maybe we know the right file to use (if not cross). */
1055	ld_file_name = 0;
1056	#ifdef DEFAULT_LINKER
1057	if (selected_linker == USE_BFD_LD || selected_linker == USE_GOLD_LD ||
1058	selected_linker == USE_LLD_LD || selected_linker == USE_MOLD_LD)
1059	{
1060	char *linker_name;
1061	# ifdef HOST_EXECUTABLE_SUFFIX
1062	int len = (sizeof (DEFAULT_LINKER)
1063	- sizeof (HOST_EXECUTABLE_SUFFIX));
1064	linker_name = NULL;
1065	if (len > 0)
1066	{
1067	char *default_linker = xstrdup (DEFAULT_LINKER);
1068	/* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1069	HOST_EXECUTABLE_SUFFIX. */
1070	if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
1071	{
1072	default_linker[len] = '\0';
1073	linker_name = concat (default_linker,
1074	&ld_suffixes[selected_linker][2],
1075	HOST_EXECUTABLE_SUFFIX, NULL);
1076	}
1077	}
1078	if (linker_name == NULL)
1079	# endif
1080	linker_name = concat (DEFAULT_LINKER,
1081	&ld_suffixes[selected_linker][2],
1082	NULL);
1083	if (access (linker_name, X_OK) == 0)
1084	ld_file_name = linker_name;
1085	}
1086	if (ld_file_name == 0 && access (DEFAULT_LINKER, X_OK) == 0)
1087	ld_file_name = DEFAULT_LINKER;
1088	if (ld_file_name == 0)
1089	#endif
1090	#ifdef REAL_LD_FILE_NAME
1091	ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME, X_OK);
1092	if (ld_file_name == 0)
1093	#endif
1094	/* Search the (target-specific) compiler dirs for ld'. */
1095	ld_file_name = find_a_file (&cpath, real_ld_suffix, X_OK);
1096	/* Likewise for `collect-ld'. */
1097	if (ld_file_name == 0)
1098	{
1099	ld_file_name = find_a_file (&cpath, collect_ld_suffix, X_OK);
1100	use_collect_ld = ld_file_name != 0;
1101	}
1102	/* Search the compiler directories for `ld'. We have protection against
1103	recursive calls in find_a_file. */
1104	if (ld_file_name == 0)
1105	ld_file_name = find_a_file (&cpath, ld_suffixes[selected_linker], X_OK);
1106	/* Search the ordinary system bin directories
1107	for `ld' (if native linking) or `TARGET-ld' (if cross). */
1108	if (ld_file_name == 0)
1109	ld_file_name = find_a_file (&path, full_ld_suffixes[selected_linker], X_OK);
1110
1111	#ifdef REAL_NM_FILE_NAME
1112	nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME, X_OK);
1113	if (nm_file_name == 0)
1114	#endif
1115	nm_file_name = find_a_file (&cpath, gnm_suffix, X_OK);
1116	if (nm_file_name == 0)
1117	nm_file_name = find_a_file (&path, full_gnm_suffix, X_OK);
1118	if (nm_file_name == 0)
1119	nm_file_name = find_a_file (&cpath, nm_suffix, X_OK);
1120	if (nm_file_name == 0)
1121	nm_file_name = find_a_file (&path, full_nm_suffix, X_OK);
1122
1123	#ifdef LDD_SUFFIX
1124	ldd_file_name = find_a_file (&cpath, ldd_suffix, X_OK);
1125	if (ldd_file_name == 0)
1126	ldd_file_name = find_a_file (&path, full_ldd_suffix, X_OK);
1127	#endif
1128
1129	#ifdef REAL_STRIP_FILE_NAME
1130	strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME, X_OK);
1131	if (strip_file_name == 0)
1132	#endif
1133	strip_file_name = find_a_file (&cpath, gstrip_suffix, X_OK);
1134	if (strip_file_name == 0)
1135	strip_file_name = find_a_file (&path, full_gstrip_suffix, X_OK);
1136	if (strip_file_name == 0)
1137	strip_file_name = find_a_file (&cpath, strip_suffix, X_OK);
1138	if (strip_file_name == 0)
1139	strip_file_name = find_a_file (&path, full_strip_suffix, X_OK);
1140
1141	/* Determine the full path name of the C compiler to use. */
1142	c_file_name = getenv (name: "COLLECT_GCC");
1143	if (c_file_name == 0)
1144	{
1145	#ifdef CROSS_DIRECTORY_STRUCTURE
1146	c_file_name = concat (target_machine, "-gcc", NULL);
1147	#else
1148	c_file_name = "gcc";
1149	#endif
1150	}
1151
1152	p = find_a_file (&cpath, c_file_name, X_OK);
1153
1154	/* Here it should be safe to use the system search path since we should have
1155	already qualified the name of the compiler when it is needed. */
1156	if (p == 0)
1157	p = find_a_file (&path, c_file_name, X_OK);
1158
1159	if (p)
1160	c_file_name = p;
1161
1162	*ld1++ = *ld2++ = ld_file_name;
1163
1164	/* Make temp file names. */
1165	if (save_temps)
1166	{
1167	c_file = concat (output_file, ".cdtor.c", NULL);
1168	o_file = concat (output_file, ".cdtor.o", NULL);
1169	#ifdef COLLECT_EXPORT_LIST
1170	export_file = concat (output_file, ".x", NULL);
1171	#endif
1172	}
1173	else
1174	{
1175	c_file = make_temp_file (".cdtor.c");
1176	o_file = make_temp_file (".cdtor.o");
1177	#ifdef COLLECT_EXPORT_LIST
1178	export_file = make_temp_file (".x");
1179	#endif
1180	}
1181	/* Build the command line to compile the ctor/dtor list. */
1182	*c_ptr++ = c_file_name;
1183	*c_ptr++ = "-x";
1184	*c_ptr++ = "c";
1185	*c_ptr++ = "-c";
1186	*c_ptr++ = "-o";
1187	*c_ptr++ = o_file;
1188
1189	#ifdef COLLECT_EXPORT_LIST
1190	/* Generate a list of directories from LIBPATH. */
1191	prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1192	/* Add to this list also two standard directories where
1193	AIX loader always searches for libraries. */
1194	add_prefix (&libpath_lib_dirs, "/lib");
1195	add_prefix (&libpath_lib_dirs, "/usr/lib");
1196	#endif
1197
1198	/* Get any options that the upper GCC wants to pass to the sub-GCC.
1199
1200	AIX support needs to know if -shared has been specified before
1201	parsing commandline arguments. */
1202
1203	p = getenv (name: "COLLECT_GCC_OPTIONS");
1204	while (p && *p)
1205	{
1206	const char *q = extract_string (pp: &p);
1207	if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1208	*c_ptr++ = xstrdup (q);
1209	if (strcmp (s1: q, s2: "-EL") == 0 || strcmp (s1: q, s2: "-EB") == 0)
1210	*c_ptr++ = xstrdup (q);
1211	if (strcmp (s1: q, s2: "-shared") == 0)
1212	shared_obj = 1;
1213	if (strcmp (s1: q, s2: "-static") == 0)
1214	static_obj = 1;
1215	if (*q == '-' && q[1] == 'B')
1216	{
1217	*c_ptr++ = xstrdup (q);
1218	if (q[2] == 0)
1219	{
1220	q = extract_string (pp: &p);
1221	*c_ptr++ = xstrdup (q);
1222	}
1223	}
1224	else if (strcmp (s1: q, s2: "-o") == 0
1225	|| strcmp (s1: q, s2: "-dumpdir") == 0
1226	|| strcmp (s1: q, s2: "-isystem") == 0)
1227	(void) extract_string (pp: &p);
1228	#ifdef COLLECT_EXPORT_LIST
1229	/* Detect any invocation with -fvisibility. */
1230	if (startswith (q, "-fvisibility"))
1231	visibility_flag = 1;
1232	#endif
1233	}
1234	obstack_free (&temporary_obstack, temporary_firstobj);
1235	*c_ptr++ = "-fno-profile-arcs";
1236	*c_ptr++ = "-fno-test-coverage";
1237	*c_ptr++ = "-fno-branch-probabilities";
1238	*c_ptr++ = "-fno-exceptions";
1239	*c_ptr++ = "-w";
1240	*c_ptr++ = "-fno-whole-program";
1241
1242	/* !!! When GCC calls collect2,
1243	it does not know whether it is calling collect2 or ld.
1244	So collect2 cannot meaningfully understand any options
1245	except those ld understands.
1246	If you propose to make GCC pass some other option,
1247	just imagine what will happen if ld is really ld!!! */
1248
1249	/* Parse arguments. Remember output file spec, pass the rest to ld. */
1250	/* After the first file, put in the c++ rt0. */
1251
1252	#ifdef COLLECT_EXPORT_LIST
1253	is_static = static_obj;
1254	#endif
1255	first_file = 1;
1256	while ((arg = *++argv) != (char *) 0)
1257	{
1258	*ld1++ = *ld2++ = arg;
1259
1260	if (arg[0] == '-')
1261	{
1262	switch (arg[1])
1263	{
1264	case 'd':
1265	if (!strcmp (s1: arg, s2: "-debug"))
1266	{
1267	/* Already parsed. */
1268	ld1--;
1269	ld2--;
1270	}
1271	if (!strcmp (s1: arg, s2: "-dynamic-linker") && argv[1])
1272	{
1273	++argv;
1274	*ld1++ = *ld2++ = *argv;
1275	}
1276	break;
1277
1278	case 'f':
1279	if (startswith (str: arg, prefix: "-flto"))
1280	{
1281	#ifdef ENABLE_LTO
1282	/* Do not pass LTO flag to the linker. */
1283	ld1--;
1284	ld2--;
1285	#else
1286	error ("LTO support has not been enabled in this "
1287	"configuration");
1288	#endif
1289	}
1290	else if (!use_collect_ld
1291	&& startswith (str: arg, prefix: "-fuse-ld="))
1292	{
1293	/* Do not pass -fuse-ld={bfd|gold|lld|mold} to the linker. */
1294	ld1--;
1295	ld2--;
1296	}
1297	else if (startswith (str: arg, prefix: "-fno-lto"))
1298	{
1299	/* Do not pass -fno-lto to the linker. */
1300	ld1--;
1301	ld2--;
1302	}
1303	#ifdef TARGET_AIX_VERSION
1304	else
1305	{
1306	/* File containing a list of input files to process. */
1307
1308	FILE *stream;
1309	char buf[MAXPATHLEN + 2];
1310	/* Number of additionnal object files. */
1311	int add_nbr = 0;
1312	/* Maximum of additionnal object files before vector
1313	expansion. */
1314	int add_max = 0;
1315	const char *list_filename = arg + 2;
1316
1317	/* Accept -fFILENAME and -f FILENAME. */
1318	if (*list_filename == '\0' && argv[1])
1319	{
1320	++argv;
1321	list_filename = *argv;
1322	*ld1++ = *ld2++ = *argv;
1323	}
1324
1325	stream = fopen (list_filename, "r");
1326	if (stream == NULL)
1327	fatal_error (input_location, "cannot open %s: %m",
1328	list_filename);
1329
1330	while (fgets (buf, sizeof buf, stream) != NULL)
1331	{
1332	/* Remove end of line. */
1333	int len = strlen (buf);
1334	if (len >= 1 && buf[len - 1] =='\n')
1335	buf[len - 1] = '\0';
1336
1337	/* Put on object vector.
1338	Note: we only expanse vector here, so we must keep
1339	extra space for remaining arguments. */
1340	if (add_nbr >= add_max)
1341	{
1342	int pos =
1343	object - CONST_CAST2 (const char **, char **,
1344	object_lst);
1345	add_max = (add_max == 0) ? 16 : add_max * 2;
1346	object_lst = XRESIZEVEC (char *, object_lst,
1347	object_nbr + add_max);
1348	object = CONST_CAST2 (const char **, char **,
1349	object_lst) + pos;
1350	object_nbr += add_max;
1351	}
1352	*object++ = xstrdup (buf);
1353	add_nbr++;
1354	}
1355	fclose (stream);
1356	}
1357	#endif
1358	break;
1359
1360	#ifdef COLLECT_EXPORT_LIST
1361	case 'b':
1362	if (!strcmp (arg, "-bstatic"))
1363	{
1364	is_static = true;
1365	}
1366	else if (!strcmp (arg, "-bdynamic") || !strcmp (arg, "-bshared"))
1367	{
1368	is_static = false;
1369	}
1370	break;
1371	#endif
1372	case 'l':
1373	if (first_file)
1374	{
1375	/* place o_file BEFORE this argument! */
1376	first_file = 0;
1377	ld2--;
1378	*ld2++ = o_file;
1379	*ld2++ = arg;
1380	}
1381	#ifdef COLLECT_EXPORT_LIST
1382	{
1383	/* Resolving full library name. */
1384	const char *s = resolve_lib_name (arg+2);
1385
1386	/* Saving a full library name. */
1387	add_to_list (&libs, s);
1388	if (is_static)
1389	add_to_list (&static_libs, s);
1390	}
1391	#endif
1392	break;
1393
1394	#ifdef COLLECT_EXPORT_LIST
1395	/* Saving directories where to search for libraries. */
1396	case 'L':
1397	add_prefix (&cmdline_lib_dirs, arg+2);
1398	break;
1399	#endif
1400
1401	case 'o':
1402	if (arg[2] != '\0')
1403	output_file = &arg[2];
1404	else if (argv[1])
1405	output_file = *ld1++ = *ld2++ = *++argv;
1406	break;
1407
1408	case 'r':
1409	if (arg[2] == '\0')
1410	rflag = 1;
1411	break;
1412
1413	case 's':
1414	if (arg[2] == '\0' && do_collecting)
1415	{
1416	/* We must strip after the nm run, otherwise C++ linking
1417	will not work. Thus we strip in the second ld run, or
1418	else with strip if there is no second ld run. */
1419	strip_flag = 1;
1420	ld1--;
1421	}
1422	break;
1423
1424	case 'v':
1425	if (arg[2] == '\0')
1426	verbose = true;
1427	break;
1428
1429	case '-':
1430	if (strcmp (s1: arg, s2: "--no-demangle") == 0)
1431	{
1432	#ifndef HAVE_LD_DEMANGLE
1433	no_demangle = 1;
1434	ld1--;
1435	ld2--;
1436	#endif
1437	}
1438	else if (startswith (str: arg, prefix: "--demangle"))
1439	{
1440	#ifndef HAVE_LD_DEMANGLE
1441	no_demangle = 0;
1442	if (arg[10] == '=')
1443	{
1444	enum demangling_styles style
1445	= cplus_demangle_name_to_style (arg+11);
1446	if (style == unknown_demangling)
1447	error ("unknown demangling style %qs", arg+11);
1448	else
1449	current_demangling_style = style;
1450	}
1451	ld1--;
1452	ld2--;
1453	#endif
1454	}
1455	else if (startswith (str: arg, prefix: "--sysroot="))
1456	target_system_root = arg + 10;
1457	else if (strcmp (s1: arg, s2: "--version") == 0)
1458	verbose = true;
1459	else if (strcmp (s1: arg, s2: "--help") == 0)
1460	helpflag = true;
1461	break;
1462	}
1463	}
1464	else if ((p = strrchr (s: arg, c: '.')) != (char *) 0
1465	&& (strcmp (s1: p, s2: ".o") == 0 || strcmp (s1: p, s2: ".a") == 0
1466	|| strcmp (s1: p, s2: ".so") == 0 || strcmp (s1: p, s2: ".lo") == 0
1467	|| strcmp (s1: p, s2: ".obj") == 0))
1468	{
1469	if (first_file)
1470	{
1471	first_file = 0;
1472	if (p[1] == 'o')
1473	*ld2++ = o_file;
1474	else
1475	{
1476	/* place o_file BEFORE this argument! */
1477	ld2--;
1478	*ld2++ = o_file;
1479	*ld2++ = arg;
1480	}
1481	}
1482	if (p[1] == 'o' || p[1] == 'l')
1483	*object++ = arg;
1484	#ifdef COLLECT_EXPORT_LIST
1485	/* libraries can be specified directly, i.e. without -l flag. */
1486	else
1487	{
1488	/* Saving a full library name. */
1489	add_to_list (&libs, arg);
1490	if (is_static)
1491	add_to_list (&static_libs, arg);
1492	}
1493	#endif
1494	}
1495	}
1496
1497	#ifdef COLLECT_EXPORT_LIST
1498	/* This is added only for debugging purposes. */
1499	if (debug)
1500	{
1501	fprintf (stderr, "List of libraries:\n");
1502	dump_list (stderr, "\t", libs.first);
1503	fprintf (stderr, "List of statically linked libraries:\n");
1504	dump_list (stderr, "\t", static_libs.first);
1505	}
1506
1507	/* The AIX linker will discard static constructors in object files if
1508	nothing else in the file is referenced, so look at them first. Unless
1509	we are building a shared object, ignore the eh frame tables, as we
1510	would otherwise reference them all, hence drag all the corresponding
1511	objects even if nothing else is referenced. */
1512	{
1513	const char **export_object_lst
1514	= CONST_CAST2 (const char **, char **, object_lst);
1515
1516	struct id *list = libs.first;
1517
1518	/* Compute the filter to use from the current one, do scan, then adjust
1519	the "current" filter to remove what we just included here. This will
1520	control whether we need a first pass link later on or not, and what
1521	will remain to be scanned there. */
1522
1523	scanfilter this_filter = ld1_filter;
1524	#if HAVE_AS_REF
1525	if (!shared_obj)
1526	this_filter &= ~SCAN_DWEH;
1527	#endif
1528
1529	/* Scan object files. */
1530	while (export_object_lst < object)
1531	scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1532
1533	/* Scan libraries. */
1534	for (; list; list = list->next)
1535	scan_prog_file (list->name, PASS_FIRST, this_filter);
1536
1537	ld1_filter = ld1_filter & ~this_filter;
1538	}
1539
1540	if (exports.first)
1541	{
1542	char *buf = concat ("-bE:", export_file, NULL);
1543
1544	*ld1++ = buf;
1545	*ld2++ = buf;
1546
1547	exportf = fopen (export_file, "w");
1548	if (exportf == (FILE *) 0)
1549	fatal_error (input_location, "fopen %s: %m", export_file);
1550	write_aix_file (exportf, exports.first);
1551	if (fclose (exportf))
1552	fatal_error (input_location, "fclose %s: %m", export_file);
1553	}
1554	#endif
1555
1556	*c_ptr++ = c_file;
1557	*c_ptr = *ld1 = *object = (char *) 0;
1558
1559	if (verbose)
1560	notice ("collect2 version %s\n", version_string);
1561
1562	if (helpflag)
1563	{
1564	printf (format: "Usage: collect2 [options]\n");
1565	printf (format: " Wrap linker and generate constructor code if needed.\n");
1566	printf (format: " Options:\n");
1567	printf (format: " -debug Enable debug output\n");
1568	printf (format: " --help Display this information\n");
1569	printf (format: " -v, --version Display this program's version number\n");
1570	printf (format: "\n");
1571	printf (format: "Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1572	printf (format: "Report bugs: %s\n", bug_report_url);
1573	printf (format: "\n");
1574	}
1575
1576	if (debug)
1577	{
1578	const char *ptr;
1579	fprintf (stderr, format: "ld_file_name = %s\n",
1580	(ld_file_name ? ld_file_name : "not found"));
1581	fprintf (stderr, format: "c_file_name = %s\n",
1582	(c_file_name ? c_file_name : "not found"));
1583	fprintf (stderr, format: "nm_file_name = %s\n",
1584	(nm_file_name ? nm_file_name : "not found"));
1585	#ifdef LDD_SUFFIX
1586	fprintf (stderr, "ldd_file_name = %s\n",
1587	(ldd_file_name ? ldd_file_name : "not found"));
1588	#endif
1589	fprintf (stderr, format: "strip_file_name = %s\n",
1590	(strip_file_name ? strip_file_name : "not found"));
1591	fprintf (stderr, format: "c_file = %s\n",
1592	(c_file ? c_file : "not found"));
1593	fprintf (stderr, format: "o_file = %s\n",
1594	(o_file ? o_file : "not found"));
1595
1596	ptr = getenv (name: "COLLECT_GCC_OPTIONS");
1597	if (ptr)
1598	fprintf (stderr, format: "COLLECT_GCC_OPTIONS = %s\n", ptr);
1599
1600	ptr = getenv (name: "COLLECT_GCC");
1601	if (ptr)
1602	fprintf (stderr, format: "COLLECT_GCC = %s\n", ptr);
1603
1604	ptr = getenv (name: "COMPILER_PATH");
1605	if (ptr)
1606	fprintf (stderr, format: "COMPILER_PATH = %s\n", ptr);
1607
1608	ptr = getenv (LIBRARY_PATH_ENV);
1609	if (ptr)
1610	fprintf (stderr, format: "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1611
1612	fprintf (stderr, format: "\n");
1613	}
1614
1615	/* Load the program, searching all libraries and attempting to provide
1616	undefined symbols from repository information.
1617
1618	If -r or they will be run via some other method, do not build the
1619	constructor or destructor list, just return now. */
1620	{
1621	bool early_exit
1622	= rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1623
1624	/* Perform the first pass link now, if we're about to exit or if we need
1625	to scan for things we haven't collected yet before pursuing further.
1626
1627	On AIX, the latter typically includes nothing for shared objects or
1628	frame tables for an executable, out of what the required early scan on
1629	objects and libraries has performed above. In the !shared_obj case, we
1630	expect the relevant tables to be dragged together with their associated
1631	functions from precise cross reference insertions by the compiler. */
1632
1633	if (early_exit || ld1_filter != SCAN_NOTHING)
1634	do_link (ld_argv: ld1_argv, atsuffix: "ld1_args");
1635
1636	if (early_exit)
1637	{
1638	#ifdef COLLECT_EXPORT_LIST
1639	/* Make sure we delete the export file we may have created. */
1640	if (export_file != 0 && export_file[0])
1641	maybe_unlink (export_file);
1642	#endif
1643	if (lto_mode != LTO_MODE_NONE)
1644	maybe_run_lto_and_relink (lto_ld_argv: ld1_argv, object_lst, object, force: false);
1645	else
1646	post_ld_pass (/*temp_file*/false);
1647
1648	return 0;
1649	}
1650	}
1651
1652	/* Unless we have done it all already, examine the namelist and search for
1653	static constructors and destructors to call. Write the constructor and
1654	destructor tables to a .s file and reload. */
1655
1656	if (ld1_filter != SCAN_NOTHING)
1657	scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1658
1659	#ifdef SCAN_LIBRARIES
1660	scan_libraries (output_file);
1661	#endif
1662
1663	if (debug)
1664	{
1665	notice_translated (cmsgid: ngettext (msgid1: "%d constructor found\n",
1666	msgid2: "%d constructors found\n",
1667	n: constructors.number),
1668	constructors.number);
1669	notice_translated (cmsgid: ngettext (msgid1: "%d destructor found\n",
1670	msgid2: "%d destructors found\n",
1671	n: destructors.number),
1672	destructors.number);
1673	notice_translated (cmsgid: ngettext (msgid1: "%d frame table found\n",
1674	msgid2: "%d frame tables found\n",
1675	n: frame_tables.number),
1676	frame_tables.number);
1677	}
1678
1679	/* If the scan exposed nothing of special interest, there's no need to
1680	generate the glue code and relink so return now. */
1681
1682	if (constructors.number == 0 && destructors.number == 0
1683	&& frame_tables.number == 0
1684	#if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1685	/* If we will be running these functions ourselves, we want to emit
1686	stubs into the shared library so that we do not have to relink
1687	dependent programs when we add static objects. */
1688	&& ! shared_obj
1689	#endif
1690	)
1691	{
1692	/* Do link without additional code generation now if we didn't
1693	do it earlier for scanning purposes. */
1694	if (ld1_filter == SCAN_NOTHING)
1695	do_link (ld_argv: ld1_argv, atsuffix: "ld1_args");
1696
1697	if (lto_mode)
1698	maybe_run_lto_and_relink (lto_ld_argv: ld1_argv, object_lst, object, force: false);
1699
1700	/* Strip now if it was requested on the command line. */
1701	if (strip_flag)
1702	{
1703	char **real_strip_argv = XCNEWVEC (char *, 3);
1704	const char ** strip_argv = CONST_CAST2 (const char **, char **,
1705	real_strip_argv);
1706
1707	strip_argv[0] = strip_file_name;
1708	strip_argv[1] = output_file;
1709	strip_argv[2] = (char *) 0;
1710	fork_execute ("strip", real_strip_argv, false, NULL);
1711	}
1712
1713	#ifdef COLLECT_EXPORT_LIST
1714	maybe_unlink (export_file);
1715	#endif
1716	post_ld_pass (/*temp_file*/false);
1717	return 0;
1718	}
1719
1720	/* Sort ctor and dtor lists by priority. */
1721	sort_ids (&constructors);
1722	sort_ids (&destructors);
1723
1724	maybe_unlink (output_file);
1725	outf = fopen (filename: c_file, modes: "w");
1726	if (outf == (FILE *) 0)
1727	fatal_error (input_location, "fopen %s: %m", c_file);
1728
1729	write_c_file (outf, c_file);
1730
1731	if (fclose (stream: outf))
1732	fatal_error (input_location, "fclose %s: %m", c_file);
1733
1734	/* Tell the linker that we have initializer and finalizer functions. */
1735	#ifdef LD_INIT_SWITCH
1736	#ifdef COLLECT_EXPORT_LIST
1737	*ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1738	#else
1739	*ld2++ = LD_INIT_SWITCH;
1740	*ld2++ = initname;
1741	*ld2++ = LD_FINI_SWITCH;
1742	*ld2++ = fininame;
1743	#endif
1744	#endif
1745
1746	#ifdef COLLECT_EXPORT_LIST
1747	if (shared_obj)
1748	{
1749	/* If we did not add export flag to link arguments before, add it to
1750	second link phase now. No new exports should have been added. */
1751	if (! exports.first)
1752	*ld2++ = concat ("-bE:", export_file, NULL);
1753
1754	#ifdef TARGET_AIX_VERSION
1755	add_to_list (&exports, aix_shared_initname);
1756	add_to_list (&exports, aix_shared_fininame);
1757	#endif
1758
1759	#ifndef LD_INIT_SWITCH
1760	add_to_list (&exports, initname);
1761	add_to_list (&exports, fininame);
1762	add_to_list (&exports, "_GLOBAL__DI");
1763	add_to_list (&exports, "_GLOBAL__DD");
1764	#endif
1765	exportf = fopen (export_file, "w");
1766	if (exportf == (FILE *) 0)
1767	fatal_error (input_location, "fopen %s: %m", export_file);
1768	write_aix_file (exportf, exports.first);
1769	if (fclose (exportf))
1770	fatal_error (input_location, "fclose %s: %m", export_file);
1771	}
1772	#endif
1773
1774	/* End of arguments to second link phase. */
1775	*ld2 = (char*) 0;
1776
1777	if (debug)
1778	{
1779	fprintf (stderr, format: "\n========== output_file = %s, c_file = %s\n",
1780	output_file, c_file);
1781	write_c_file (stderr, "stderr");
1782	fprintf (stderr, format: "========== end of c_file\n\n");
1783	#ifdef COLLECT_EXPORT_LIST
1784	fprintf (stderr, "\n========== export_file = %s\n", export_file);
1785	write_aix_file (stderr, exports.first);
1786	fprintf (stderr, "========== end of export_file\n\n");
1787	#endif
1788	}
1789
1790	/* Assemble the constructor and destructor tables.
1791	Link the tables in with the rest of the program. */
1792
1793	fork_execute ("gcc", c_argv, at_file_supplied, "gcc_args");
1794	#ifdef COLLECT_EXPORT_LIST
1795	/* On AIX we must call link because of possible templates resolution. */
1796	do_link (ld2_argv, "ld2_args");
1797
1798	if (lto_mode)
1799	maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1800	#else
1801	/* Otherwise, simply call ld because link is already done. */
1802	if (lto_mode)
1803	maybe_run_lto_and_relink (lto_ld_argv: ld2_argv, object_lst, object, force: true);
1804	else
1805	{
1806	fork_execute ("ld", ld2_argv, HAVE_GNU_LD && at_file_supplied, "ld_args");
1807	post_ld_pass (/*temp_file*/false);
1808	}
1809
1810	/* Let scan_prog_file do any final mods (OSF/rose needs this for
1811	constructors/destructors in shared libraries. */
1812	scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1813	#endif
1814
1815	return 0;
1816	}
1817
1818
1819	/* Unlink FILE unless we are debugging or this is the output_file
1820	and we may not unlink it. */
1821
1822	void
1823	maybe_unlink (const char *file)
1824	{
1825	if (save_temps && file_exists (name: file))
1826	{
1827	if (verbose)
1828	notice ("[Leaving %s]\n", file);
1829	return;
1830	}
1831
1832	if (file == output_file && !may_unlink_output_file)
1833	return;
1834
1835	unlink_if_ordinary (file);
1836	}
1837
1838	/* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
1839
1840	static void
1841	maybe_unlink_list (char **file_list)
1842	{
1843	char **tmp = file_list;
1844
1845	while (*tmp)
1846	maybe_unlink (file: *(tmp++));
1847	}
1848
1849
1850	static long sequence_number = 0;
1851
1852	/* Add a name to a linked list. */
1853
1854	static void
1855	add_to_list (struct head *head_ptr, const char *name)
1856	{
1857	struct id *newid
1858	= (struct id *) xcalloc (sizeof (struct id) + strlen (s: name), 1);
1859	struct id *p;
1860	strcpy (dest: newid->name, src: name);
1861
1862	if (head_ptr->first)
1863	head_ptr->last->next = newid;
1864	else
1865	head_ptr->first = newid;
1866
1867	/* Check for duplicate symbols. */
1868	for (p = head_ptr->first;
1869	strcmp (s1: name, s2: p->name) != 0;
1870	p = p->next)
1871	;
1872	if (p != newid)
1873	{
1874	head_ptr->last->next = 0;
1875	free (ptr: newid);
1876	return;
1877	}
1878
1879	newid->sequence = ++sequence_number;
1880	head_ptr->last = newid;
1881	head_ptr->number++;
1882	}
1883
1884	/* Grab the init priority number from an init function name that
1885	looks like "_GLOBAL_.I.12345.foo". */
1886
1887	static int
1888	extract_init_priority (const char *name)
1889	{
1890	int pos = 0, pri;
1891
1892	#ifdef TARGET_AIX_VERSION
1893	/* Run dependent module initializers before any constructors in this
1894	module. */
1895	switch (is_ctor_dtor (name))
1896	{
1897	case SYM_AIXI:
1898	case SYM_AIXD:
1899	return INT_MIN;
1900	default:
1901	break;
1902	}
1903	#endif
1904
1905	while (name[pos] == '_')
1906	++pos;
1907	pos += 10; /* strlen ("GLOBAL__X_") */
1908
1909	/* Extract init_p number from ctor/dtor name. */
1910	pri = atoi (nptr: name + pos);
1911	return pri ? pri : DEFAULT_INIT_PRIORITY;
1912	}
1913
1914	/* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1915	ctors will be run from right to left, dtors from left to right. */
1916
1917	static void
1918	sort_ids (struct head *head_ptr)
1919	{
1920	/* id holds the current element to insert. id_next holds the next
1921	element to insert. id_ptr iterates through the already sorted elements
1922	looking for the place to insert id. */
1923	struct id *id, *id_next, **id_ptr;
1924
1925	id = head_ptr->first;
1926
1927	/* We don't have any sorted elements yet. */
1928	head_ptr->first = NULL;
1929
1930	for (; id; id = id_next)
1931	{
1932	id_next = id->next;
1933	id->sequence = extract_init_priority (name: id->name);
1934
1935	for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
1936	if (*id_ptr == NULL
1937	/* If the sequence numbers are the same, we put the id from the
1938	file later on the command line later in the list. */
1939	|| id->sequence > (*id_ptr)->sequence
1940	/* Hack: do lexical compare, too.
1941	|| (id->sequence == (*id_ptr)->sequence
1942	&& strcmp (id->name, (*id_ptr)->name) > 0) */
1943	)
1944	{
1945	id->next = *id_ptr;
1946	*id_ptr = id;
1947	break;
1948	}
1949	}
1950
1951	/* Now set the sequence numbers properly so write_c_file works. */
1952	for (id = head_ptr->first; id; id = id->next)
1953	id->sequence = ++sequence_number;
1954	}
1955
1956	/* Write: `prefix', the names on list LIST, `suffix'. */
1957
1958	static void
1959	write_list (FILE *stream, const char *prefix, struct id *list)
1960	{
1961	while (list)
1962	{
1963	fprintf (stream: stream, format: "%sx%d,\n", prefix, list->sequence);
1964	list = list->next;
1965	}
1966	}
1967
1968	#ifdef COLLECT_EXPORT_LIST
1969	/* This function is really used only on AIX, but may be useful. */
1970	static int
1971	is_in_list (const char *prefix, struct id *list)
1972	{
1973	while (list)
1974	{
1975	if (!strcmp (prefix, list->name)) return 1;
1976	list = list->next;
1977	}
1978	return 0;
1979	}
1980	#endif /* COLLECT_EXPORT_LIST */
1981
1982	/* Added for debugging purpose. */
1983	#ifdef COLLECT_EXPORT_LIST
1984	static void
1985	dump_list (FILE *stream, const char *prefix, struct id *list)
1986	{
1987	while (list)
1988	{
1989	fprintf (stream, "%s%s,\n", prefix, list->name);
1990	list = list->next;
1991	}
1992	}
1993	#endif
1994
1995	#if 0
1996	static void
1997	dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
1998	{
1999	while (list)
2000	{
2001	fprintf (stream, "%s%s,\n", prefix, list->prefix);
2002	list = list->next;
2003	}
2004	}
2005	#endif
2006
2007	static void
2008	write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2009	{
2010	while (list)
2011	{
2012	fprintf (stream: stream, format: "%sx%d __asm__ (\"%s\");\n",
2013	prefix, list->sequence, list->name);
2014	list = list->next;
2015	}
2016	}
2017
2018	/* Write out the constructor and destructor tables statically (for a shared
2019	object), along with the functions to execute them. */
2020
2021	static void
2022	write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2023	{
2024	const char *p, *q;
2025	char *prefix, *r;
2026	int frames = (frame_tables.number > 0);
2027
2028	/* Figure out name of output_file, stripping off .so version. */
2029	q = p = lbasename (output_file);
2030
2031	while (q)
2032	{
2033	q = strchr (s: q,c: '.');
2034	if (q == 0)
2035	{
2036	q = p + strlen (s: p);
2037	break;
2038	}
2039	else
2040	{
2041	if (filename_ncmp (s1: q, SHLIB_SUFFIX, n: strlen (SHLIB_SUFFIX)) == 0)
2042	{
2043	q += strlen (SHLIB_SUFFIX);
2044	break;
2045	}
2046	else
2047	q++;
2048	}
2049	}
2050	/* q points to null at end of the string (or . of the .so version) */
2051	prefix = XNEWVEC (char, q - p + 1);
2052	strncpy (dest: prefix, src: p, n: q - p);
2053	prefix[q - p] = 0;
2054	for (r = prefix; *r; r++)
2055	if (!ISALNUM ((unsigned char)*r))
2056	*r = '_';
2057	if (debug)
2058	notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2059	output_file, prefix);
2060
2061	initname = concat ("_GLOBAL__FI_", prefix, NULL);
2062	fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2063	#ifdef TARGET_AIX_VERSION
2064	aix_shared_initname = concat ("_GLOBAL__AIXI_", prefix, NULL);
2065	aix_shared_fininame = concat ("_GLOBAL__AIXD_", prefix, NULL);
2066	#endif
2067
2068	free (ptr: prefix);
2069
2070	/* Write the tables as C code. */
2071
2072	/* This count variable is used to prevent multiple calls to the
2073	constructors/destructors.
2074	This guard against multiple calls is important on AIX as the initfini
2075	functions are deliberately invoked multiple times as part of the
2076	mechanisms GCC uses to order constructors across different dependent
2077	shared libraries (see config/rs6000/aix.h).
2078	*/
2079	fprintf (stream: stream, format: "static int count;\n");
2080	fprintf (stream: stream, format: "typedef void entry_pt();\n");
2081	write_list_with_asm (stream, prefix: "extern entry_pt ", list: constructors.first);
2082
2083	if (frames)
2084	{
2085	write_list_with_asm (stream, prefix: "extern void *", list: frame_tables.first);
2086
2087	fprintf (stream: stream, format: "\tstatic void *frame_table[] = {\n");
2088	write_list (stream, prefix: "\t\t&", list: frame_tables.first);
2089	fprintf (stream: stream, format: "\t0\n};\n");
2090
2091	/* This must match what's in frame.h. */
2092	fprintf (stream: stream, format: "struct object {\n");
2093	fprintf (stream: stream, format: " void *pc_begin;\n");
2094	fprintf (stream: stream, format: " void *pc_end;\n");
2095	fprintf (stream: stream, format: " void *fde_begin;\n");
2096	fprintf (stream: stream, format: " void *fde_array;\n");
2097	fprintf (stream: stream, format: " __SIZE_TYPE__ count;\n");
2098	fprintf (stream: stream, format: " struct object *next;\n");
2099	fprintf (stream: stream, format: "};\n");
2100
2101	fprintf (stream: stream, format: "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
2102	fprintf (stream: stream, format: "extern void __register_frame_info_table (void *, struct object *);\n");
2103	fprintf (stream: stream, format: "extern void *__deregister_frame_info (void *);\n");
2104	#ifdef TARGET_AIX_VERSION
2105	fprintf (stream, "extern void *__gcc_unwind_dbase;\n");
2106	#endif
2107
2108	fprintf (stream: stream, format: "static void reg_frame () {\n");
2109	fprintf (stream: stream, format: "\tstatic struct object ob;\n");
2110	#ifdef TARGET_AIX_VERSION
2111	/* Use __gcc_unwind_dbase as the base address for data on AIX.
2112	This might not be the start of the segment, signed offsets assumed.
2113	*/
2114	fprintf (stream, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2115	#else
2116	fprintf (stream: stream, format: "\t__register_frame_info_table (frame_table, &ob);\n");
2117	#endif
2118	fprintf (stream: stream, format: "\t}\n");
2119
2120	fprintf (stream: stream, format: "static void dereg_frame () {\n");
2121	fprintf (stream: stream, format: "\t__deregister_frame_info (frame_table);\n");
2122	fprintf (stream: stream, format: "\t}\n");
2123	}
2124
2125	#ifdef COLLECT_EXPORT_LIST
2126	/* Set visibility of initializers to default. */
2127	if (visibility_flag)
2128	fprintf (stream, "#pragma GCC visibility push(default)\n");
2129	#endif
2130	fprintf (stream: stream, format: "void %s() {\n", initname);
2131	if (constructors.number > 0 || frames)
2132	{
2133	fprintf (stream: stream, format: "\tstatic entry_pt *ctors[] = {\n");
2134	write_list (stream, prefix: "\t\t", list: constructors.first);
2135	if (frames)
2136	fprintf (stream: stream, format: "\treg_frame,\n");
2137	fprintf (stream: stream, format: "\t};\n");
2138	fprintf (stream: stream, format: "\tentry_pt **p;\n");
2139	fprintf (stream: stream, format: "\tif (count++ != 0) return;\n");
2140	fprintf (stream: stream, format: "\tp = ctors + %d;\n", constructors.number + frames);
2141	fprintf (stream: stream, format: "\twhile (p > ctors) (*--p)();\n");
2142	}
2143	else
2144	fprintf (stream: stream, format: "\t++count;\n");
2145	fprintf (stream: stream, format: "}\n");
2146	write_list_with_asm (stream, prefix: "extern entry_pt ", list: destructors.first);
2147	fprintf (stream: stream, format: "void %s() {\n", fininame);
2148	if (destructors.number > 0 || frames)
2149	{
2150	fprintf (stream: stream, format: "\tstatic entry_pt *dtors[] = {\n");
2151	write_list (stream, prefix: "\t\t", list: destructors.first);
2152	if (frames)
2153	fprintf (stream: stream, format: "\tdereg_frame,\n");
2154	fprintf (stream: stream, format: "\t};\n");
2155	fprintf (stream: stream, format: "\tentry_pt **p;\n");
2156	fprintf (stream: stream, format: "\tif (--count != 0) return;\n");
2157	fprintf (stream: stream, format: "\tp = dtors;\n");
2158	fprintf (stream: stream, format: "\twhile (p < dtors + %d) (*p++)();\n",
2159	destructors.number + frames);
2160	}
2161	fprintf (stream: stream, format: "}\n");
2162	#ifdef COLLECT_EXPORT_LIST
2163	if (visibility_flag)
2164	fprintf (stream, "#pragma GCC visibility pop\n");
2165	#endif
2166
2167	if (shared_obj)
2168	{
2169	#ifdef COLLECT_EXPORT_LIST
2170	/* Set visibility of initializers to default. */
2171	if (visibility_flag)
2172	fprintf (stream, "#pragma GCC visibility push(default)\n");
2173	#endif
2174	COLLECT_SHARED_INIT_FUNC (stream, initname);
2175	COLLECT_SHARED_FINI_FUNC (stream, fininame);
2176	#ifdef COLLECT_EXPORT_LIST
2177	if (visibility_flag)
2178	fprintf (stream, "#pragma GCC visibility pop\n");
2179	#endif
2180	}
2181	}
2182
2183	/* Write the constructor/destructor tables. */
2184
2185	#ifndef LD_INIT_SWITCH
2186	static void
2187	write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2188	{
2189	/* Write the tables as C code. */
2190
2191	int frames = (frame_tables.number > 0);
2192
2193	fprintf (stream: stream, format: "typedef void entry_pt();\n\n");
2194
2195	write_list_with_asm (stream, prefix: "extern entry_pt ", list: constructors.first);
2196
2197	if (frames)
2198	{
2199	write_list_with_asm (stream, prefix: "extern void *", list: frame_tables.first);
2200
2201	fprintf (stream: stream, format: "\tstatic void *frame_table[] = {\n");
2202	write_list (stream, prefix: "\t\t&", list: frame_tables.first);
2203	fprintf (stream: stream, format: "\t0\n};\n");
2204
2205	/* This must match what's in frame.h. */
2206	fprintf (stream: stream, format: "struct object {\n");
2207	fprintf (stream: stream, format: " void *pc_begin;\n");
2208	fprintf (stream: stream, format: " void *pc_end;\n");
2209	fprintf (stream: stream, format: " void *fde_begin;\n");
2210	fprintf (stream: stream, format: " void *fde_array;\n");
2211	fprintf (stream: stream, format: " __SIZE_TYPE__ count;\n");
2212	fprintf (stream: stream, format: " struct object *next;\n");
2213	fprintf (stream: stream, format: "};\n");
2214
2215	fprintf (stream: stream, format: "extern void __register_frame_info_table (void *, struct object *);\n");
2216	fprintf (stream: stream, format: "extern void *__deregister_frame_info (void *);\n");
2217
2218	fprintf (stream: stream, format: "static void reg_frame () {\n");
2219	fprintf (stream: stream, format: "\tstatic struct object ob;\n");
2220	fprintf (stream: stream, format: "\t__register_frame_info_table (frame_table, &ob);\n");
2221	fprintf (stream: stream, format: "\t}\n");
2222
2223	fprintf (stream: stream, format: "static void dereg_frame () {\n");
2224	fprintf (stream: stream, format: "\t__deregister_frame_info (frame_table);\n");
2225	fprintf (stream: stream, format: "\t}\n");
2226	}
2227
2228	fprintf (stream: stream, format: "\nentry_pt * __CTOR_LIST__[] = {\n");
2229	fprintf (stream: stream, format: "\t(entry_pt *) %d,\n", constructors.number + frames);
2230	write_list (stream, prefix: "\t", list: constructors.first);
2231	if (frames)
2232	fprintf (stream: stream, format: "\treg_frame,\n");
2233	fprintf (stream: stream, format: "\t0\n};\n\n");
2234
2235	write_list_with_asm (stream, prefix: "extern entry_pt ", list: destructors.first);
2236
2237	fprintf (stream: stream, format: "\nentry_pt * __DTOR_LIST__[] = {\n");
2238	fprintf (stream: stream, format: "\t(entry_pt *) %d,\n", destructors.number + frames);
2239	write_list (stream, prefix: "\t", list: destructors.first);
2240	if (frames)
2241	fprintf (stream: stream, format: "\tdereg_frame,\n");
2242	fprintf (stream: stream, format: "\t0\n};\n\n");
2243
2244	fprintf (stream: stream, format: "extern entry_pt %s;\n", NAME__MAIN);
2245	fprintf (stream: stream, format: "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2246	}
2247	#endif /* ! LD_INIT_SWITCH */
2248
2249	static void
2250	write_c_file (FILE *stream, const char *name)
2251	{
2252	#ifndef LD_INIT_SWITCH
2253	if (! shared_obj)
2254	write_c_file_glob (stream, name);
2255	else
2256	#endif
2257	write_c_file_stat (stream, name);
2258	}
2259
2260	#ifdef COLLECT_EXPORT_LIST
2261	static void
2262	write_aix_file (FILE *stream, struct id *list)
2263	{
2264	for (; list; list = list->next)
2265	{
2266	fputs (list->name, stream);
2267	putc ('\n', stream);
2268	}
2269	}
2270	#endif
2271
2272	#ifdef OBJECT_FORMAT_NONE
2273
2274	/* Check to make sure the file is an LTO object file. */
2275
2276	static int
2277	has_lto_section (void *data, const char *name ATTRIBUTE_UNUSED,
2278	off_t offset ATTRIBUTE_UNUSED,
2279	off_t length ATTRIBUTE_UNUSED)
2280	{
2281	int *found = (int *) data;
2282
2283	if (!startswith (str: name, LTO_SECTION_NAME_PREFIX)
2284	&& !startswith (str: name, OFFLOAD_SECTION_NAME_PREFIX))
2285	return 1;
2286
2287	*found = 1;
2288
2289	/* Stop iteration. */
2290	return 0;
2291	}
2292
2293	static bool
2294	is_lto_object_file (const char *prog_name)
2295	{
2296	const char *errmsg;
2297	int err;
2298	int found = 0;
2299	off_t inoff = 0;
2300	int infd = open (file: prog_name, O_RDONLY | O_BINARY);
2301
2302	if (infd == -1)
2303	return false;
2304
2305	simple_object_read *inobj = simple_object_start_read (descriptor: infd, offset: inoff,
2306	LTO_SEGMENT_NAME,
2307	errmsg: &errmsg, err: &err);
2308	if (!inobj)
2309	{
2310	close (fd: infd);
2311	return false;
2312	}
2313
2314	errmsg = simple_object_find_sections (simple_object: inobj, pfn: has_lto_section,
2315	data: (void *) &found, err: &err);
2316	simple_object_release_read (inobj);
2317	close (fd: infd);
2318	if (! errmsg && found)
2319	return true;
2320
2321	if (errmsg)
2322	fatal_error (0, "%s: %s", errmsg, xstrerror (err));
2323	return false;
2324	}
2325
2326	/* Generic version to scan the name list of the loaded program for
2327	the symbols g++ uses for static constructors and destructors. */
2328
2329	static void
2330	scan_prog_file (const char *prog_name, scanpass which_pass,
2331	scanfilter filter)
2332	{
2333	void (*int_handler) (int);
2334	#ifdef SIGQUIT
2335	void (*quit_handler) (int);
2336	#endif
2337	char *real_nm_argv[4];
2338	const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2339	int argc = 0;
2340	struct pex_obj *pex;
2341	const char *errmsg;
2342	int err;
2343	char *p, buf[1024];
2344	FILE *inf;
2345
2346	if (which_pass == PASS_SECOND)
2347	return;
2348
2349	/* LTO objects must be in a known format. This check prevents
2350	us from accepting an archive containing LTO objects, which
2351	gcc cannot currently handle. */
2352	if (which_pass == PASS_LTOINFO)
2353	{
2354	if(is_lto_object_file (prog_name)) {
2355	add_lto_object (list: &lto_objects, name: prog_name);
2356	}
2357	return;
2358	}
2359
2360	/* If we do not have an `nm', complain. */
2361	if (nm_file_name == 0)
2362	fatal_error (input_location, "cannot find %<nm%>");
2363
2364	nm_argv[argc++] = nm_file_name;
2365	if (NM_FLAGS[0] != '\0')
2366	nm_argv[argc++] = NM_FLAGS;
2367
2368	nm_argv[argc++] = prog_name;
2369	nm_argv[argc++] = (char *) 0;
2370
2371	/* Trace if needed. */
2372	if (verbose)
2373	{
2374	const char **p_argv;
2375	const char *str;
2376
2377	for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2378	fprintf (stderr, format: " %s", str);
2379
2380	fprintf (stderr, format: "\n");
2381	}
2382
2383	fflush (stdout);
2384	fflush (stderr);
2385
2386	pex = pex_init (PEX_USE_PIPES, pname: "collect2", NULL);
2387	if (pex == NULL)
2388	fatal_error (input_location, "%<pex_init%> failed: %m");
2389
2390	errmsg = pex_run (obj: pex, flags: 0, executable: nm_file_name, argv: real_nm_argv, NULL, HOST_BIT_BUCKET,
2391	err: &err);
2392	if (errmsg != NULL)
2393	{
2394	if (err != 0)
2395	{
2396	errno = err;
2397	fatal_error (input_location, "%s: %m", _(errmsg));
2398	}
2399	else
2400	fatal_error (input_location, errmsg);
2401	}
2402
2403	int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2404	#ifdef SIGQUIT
2405	quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2406	#endif
2407
2408	inf = pex_read_output (pex, binary: 0);
2409	if (inf == NULL)
2410	fatal_error (input_location, "cannot open nm output: %m");
2411
2412	if (debug)
2413	fprintf (stderr, format: "\nnm output with constructors/destructors.\n");
2414
2415	/* Read each line of nm output. */
2416	while (fgets (s: buf, n: sizeof buf, stream: inf) != (char *) 0)
2417	{
2418	int ch, ch2;
2419	char *name, *end;
2420
2421	if (debug)
2422	fprintf (stderr, format: "\t%s\n", buf);
2423
2424	/* If it contains a constructor or destructor name, add the name
2425	to the appropriate list unless this is a kind of symbol we're
2426	not supposed to even consider. */
2427
2428	for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2429	if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2430	break;
2431
2432	if (ch != '_')
2433	continue;
2434
2435	name = p;
2436	/* Find the end of the symbol name.
2437	Do not include `|', because Encore nm can tack that on the end. */
2438	for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2439	end++)
2440	continue;
2441
2442
2443	*end = '\0';
2444
2445	switch (is_ctor_dtor (s: name))
2446	{
2447	case SYM_CTOR:
2448	if (! (filter & SCAN_CTOR))
2449	break;
2450	if (which_pass != PASS_LIB)
2451	add_to_list (head_ptr: &constructors, name);
2452	break;
2453
2454	case SYM_DTOR:
2455	if (! (filter & SCAN_DTOR))
2456	break;
2457	if (which_pass != PASS_LIB)
2458	add_to_list (head_ptr: &destructors, name);
2459	break;
2460
2461	case SYM_INIT:
2462	if (! (filter & SCAN_INIT))
2463	break;
2464	if (which_pass != PASS_LIB)
2465	fatal_error (input_location, "init function found in object %s",
2466	prog_name);
2467	#ifndef LD_INIT_SWITCH
2468	add_to_list (head_ptr: &constructors, name);
2469	#endif
2470	break;
2471
2472	case SYM_FINI:
2473	if (! (filter & SCAN_FINI))
2474	break;
2475	if (which_pass != PASS_LIB)
2476	fatal_error (input_location, "fini function found in object %s",
2477	prog_name);
2478	#ifndef LD_FINI_SWITCH
2479	add_to_list (head_ptr: &destructors, name);
2480	#endif
2481	break;
2482
2483	case SYM_DWEH:
2484	if (! (filter & SCAN_DWEH))
2485	break;
2486	if (which_pass != PASS_LIB)
2487	add_to_list (head_ptr: &frame_tables, name);
2488	break;
2489
2490	default: /* not a constructor or destructor */
2491	continue;
2492	}
2493	}
2494
2495	if (debug)
2496	fprintf (stderr, format: "\n");
2497
2498	do_wait (nm_file_name, pex);
2499
2500	signal (SIGINT, handler: int_handler);
2501	#ifdef SIGQUIT
2502	signal (SIGQUIT, handler: quit_handler);
2503	#endif
2504	}
2505
2506	#ifdef LDD_SUFFIX
2507
2508	/* Use the List Dynamic Dependencies program to find shared libraries that
2509	the output file depends upon and their initialization/finalization
2510	routines, if any. */
2511
2512	static void
2513	scan_libraries (const char *prog_name)
2514	{
2515	static struct head libraries; /* list of shared libraries found */
2516	struct id *list;
2517	void (*int_handler) (int);
2518	#ifdef SIGQUIT
2519	void (*quit_handler) (int);
2520	#endif
2521	char *real_ldd_argv[4];
2522	const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2523	int argc = 0;
2524	struct pex_obj *pex;
2525	const char *errmsg;
2526	int err;
2527	char buf[1024];
2528	FILE *inf;
2529
2530	/* If we do not have an `ldd', complain. */
2531	if (ldd_file_name == 0)
2532	{
2533	error ("cannot find %<ldd%>");
2534	return;
2535	}
2536
2537	ldd_argv[argc++] = ldd_file_name;
2538	ldd_argv[argc++] = prog_name;
2539	ldd_argv[argc++] = (char *) 0;
2540
2541	/* Trace if needed. */
2542	if (verbose)
2543	{
2544	const char **p_argv;
2545	const char *str;
2546
2547	for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2548	fprintf (stderr, " %s", str);
2549
2550	fprintf (stderr, "\n");
2551	}
2552
2553	fflush (stdout);
2554	fflush (stderr);
2555
2556	pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2557	if (pex == NULL)
2558	fatal_error (input_location, "%<pex_init%> failed: %m");
2559
2560	errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2561	if (errmsg != NULL)
2562	{
2563	if (err != 0)
2564	{
2565	errno = err;
2566	fatal_error (input_location, "%s: %m", _(errmsg));
2567	}
2568	else
2569	fatal_error (input_location, errmsg);
2570	}
2571
2572	int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2573	#ifdef SIGQUIT
2574	quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2575	#endif
2576
2577	inf = pex_read_output (pex, 0);
2578	if (inf == NULL)
2579	fatal_error (input_location, "cannot open ldd output: %m");
2580
2581	if (debug)
2582	notice ("\nldd output with constructors/destructors.\n");
2583
2584	/* Read each line of ldd output. */
2585	while (fgets (buf, sizeof buf, inf) != (char *) 0)
2586	{
2587	int ch2;
2588	char *name, *end, *p = buf;
2589
2590	/* Extract names of libraries and add to list. */
2591	PARSE_LDD_OUTPUT (p);
2592	if (p == 0)
2593	continue;
2594
2595	name = p;
2596	if (startswith (name, "not found"))
2597	fatal_error (input_location, "dynamic dependency %s not found", buf);
2598
2599	/* Find the end of the symbol name. */
2600	for (end = p;
2601	(ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2602	end++)
2603	continue;
2604	*end = '\0';
2605
2606	if (access (name, R_OK) == 0)
2607	add_to_list (&libraries, name);
2608	else
2609	fatal_error (input_location, "unable to open dynamic dependency "
2610	"%qs", buf);
2611
2612	if (debug)
2613	fprintf (stderr, "\t%s\n", buf);
2614	}
2615	if (debug)
2616	fprintf (stderr, "\n");
2617
2618	do_wait (ldd_file_name, pex);
2619
2620	signal (SIGINT, int_handler);
2621	#ifdef SIGQUIT
2622	signal (SIGQUIT, quit_handler);
2623	#endif
2624
2625	/* Now iterate through the library list adding their symbols to
2626	the list. */
2627	for (list = libraries.first; list; list = list->next)
2628	scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2629	}
2630
2631	#endif /* LDD_SUFFIX */
2632
2633	#endif /* OBJECT_FORMAT_NONE */
2634
2635
2636	/*
2637	* COFF specific stuff.
2638	*/
2639
2640	#ifdef OBJECT_FORMAT_COFF
2641
2642	# define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2643	# define GCC_SYMENT SYMENT
2644	# if defined (C_WEAKEXT)
2645	# define GCC_OK_SYMBOL(X) \
2646	(((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2647	((X).n_scnum > N_UNDEF) && \
2648	(aix64_flag \
2649	|| (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2650	|| ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2651	# define GCC_UNDEF_SYMBOL(X) \
2652	(((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2653	((X).n_scnum == N_UNDEF))
2654	# else
2655	# define GCC_OK_SYMBOL(X) \
2656	(((X).n_sclass == C_EXT) && \
2657	((X).n_scnum > N_UNDEF) && \
2658	(aix64_flag \
2659	|| (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2660	|| ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2661	# define GCC_UNDEF_SYMBOL(X) \
2662	(((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2663	# endif
2664	# define GCC_SYMINC(X) ((X).n_numaux+1)
2665	# define GCC_SYMZERO(X) 0
2666
2667	/* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2668	#if TARGET_AIX_VERSION >= 51
2669	# define GCC_CHECK_HDR(X) \
2670	(((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2671	|| (HEADER (X).f_magic == 0767 && aix64_flag)) \
2672	&& !(HEADER (X).f_flags & F_LOADONLY))
2673	#else
2674	# define GCC_CHECK_HDR(X) \
2675	(((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2676	|| (HEADER (X).f_magic == 0757 && aix64_flag)) \
2677	&& !(HEADER (X).f_flags & F_LOADONLY))
2678	#endif
2679
2680	#ifdef COLLECT_EXPORT_LIST
2681	/* Array of standard AIX libraries which should not
2682	be scanned for ctors/dtors. */
2683	static const char *const aix_std_libs[] = {
2684	"/unix",
2685	"/lib/libc.a",
2686	"/lib/libm.a",
2687	"/lib/libc_r.a",
2688	"/lib/libm_r.a",
2689	"/usr/lib/libc.a",
2690	"/usr/lib/libm.a",
2691	"/usr/lib/libc_r.a",
2692	"/usr/lib/libm_r.a",
2693	"/usr/lib/threads/libc.a",
2694	"/usr/ccs/lib/libc.a",
2695	"/usr/ccs/lib/libm.a",
2696	"/usr/ccs/lib/libc_r.a",
2697	"/usr/ccs/lib/libm_r.a",
2698	NULL
2699	};
2700
2701	/* This function checks the filename and returns 1
2702	if this name matches the location of a standard AIX library. */
2703	static int ignore_library (const char *);
2704	static int
2705	ignore_library (const char *name)
2706	{
2707	const char *const *p;
2708	size_t length;
2709
2710	if (target_system_root[0] != '\0')
2711	{
2712	length = strlen (target_system_root);
2713	if (strncmp (name, target_system_root, length) != 0)
2714	return 0;
2715	name += length;
2716	}
2717	for (p = &aix_std_libs[0]; *p != NULL; ++p)
2718	if (strcmp (name, *p) == 0)
2719	return 1;
2720	return 0;
2721	}
2722	#endif /* COLLECT_EXPORT_LIST */
2723
2724	#if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2725	extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2726	#endif
2727
2728	/* COFF version to scan the name list of the loaded program for
2729	the symbols g++ uses for static constructors and destructors. */
2730
2731	static void
2732	scan_prog_file (const char *prog_name, scanpass which_pass,
2733	scanfilter filter)
2734	{
2735	LDFILE *ldptr = NULL;
2736	int sym_index, sym_count;
2737	int is_shared = 0;
2738
2739	if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2740	return;
2741
2742	#ifdef COLLECT_EXPORT_LIST
2743	/* We do not need scanning for some standard C libraries. */
2744	if (which_pass == PASS_FIRST && ignore_library (prog_name))
2745	return;
2746
2747	/* On AIX we have a loop, because there is not much difference
2748	between an object and an archive. This trick allows us to
2749	eliminate scan_libraries() function. */
2750	do
2751	{
2752	#endif
2753	/* Some platforms (e.g. OSF4) declare ldopen as taking a
2754	non-const char * filename parameter, even though it will not
2755	modify that string. So we must cast away const-ness here,
2756	using CONST_CAST to prevent complaints from -Wcast-qual. */
2757	if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
2758	{
2759	if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2760	{
2761	warning (0, "%s: not a COFF file", prog_name);
2762	continue;
2763	}
2764
2765	if (GCC_CHECK_HDR (ldptr))
2766	{
2767	sym_count = GCC_SYMBOLS (ldptr);
2768	sym_index = GCC_SYMZERO (ldptr);
2769
2770	#ifdef COLLECT_EXPORT_LIST
2771	/* Is current archive member a shared object? */
2772	is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2773	#endif
2774
2775	while (sym_index < sym_count)
2776	{
2777	GCC_SYMENT symbol;
2778
2779	if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2780	break;
2781	sym_index += GCC_SYMINC (symbol);
2782
2783	if (GCC_OK_SYMBOL (symbol))
2784	{
2785	char *name;
2786
2787	if ((name = ldgetname (ldptr, &symbol)) == NULL)
2788	continue; /* Should never happen. */
2789
2790	#ifdef XCOFF_DEBUGGING_INFO
2791	/* All AIX function names have a duplicate entry
2792	beginning with a dot. */
2793	if (*name == '.')
2794	++name;
2795	#endif
2796
2797	switch (is_ctor_dtor (name))
2798	{
2799	#if TARGET_AIX_VERSION
2800	/* Add AIX shared library initalisers/finalisers
2801	to the constructors/destructors list of the
2802	current module. */
2803	case SYM_AIXI:
2804	if (! (filter & SCAN_CTOR))
2805	break;
2806	if (is_shared && !aixlazy_flag
2807	#ifdef COLLECT_EXPORT_LIST
2808	&& ! static_obj
2809	&& ! is_in_list (prog_name, static_libs.first)
2810	#endif
2811	)
2812	add_to_list (&constructors, name);
2813	break;
2814
2815	case SYM_AIXD:
2816	if (! (filter & SCAN_DTOR))
2817	break;
2818	if (is_shared && !aixlazy_flag)
2819	add_to_list (&destructors, name);
2820	break;
2821	#endif
2822
2823	case SYM_CTOR:
2824	if (! (filter & SCAN_CTOR))
2825	break;
2826	if (! is_shared)
2827	add_to_list (&constructors, name);
2828	#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2829	if (which_pass == PASS_OBJ)
2830	add_to_list (&exports, name);
2831	#endif
2832	break;
2833
2834	case SYM_DTOR:
2835	if (! (filter & SCAN_DTOR))
2836	break;
2837	if (! is_shared)
2838	add_to_list (&destructors, name);
2839	#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2840	if (which_pass == PASS_OBJ)
2841	add_to_list (&exports, name);
2842	#endif
2843	break;
2844
2845	#ifdef COLLECT_EXPORT_LIST
2846	case SYM_INIT:
2847	if (! (filter & SCAN_INIT))
2848	break;
2849	#ifndef LD_INIT_SWITCH
2850	if (is_shared)
2851	add_to_list (&constructors, name);
2852	#endif
2853	break;
2854
2855	case SYM_FINI:
2856	if (! (filter & SCAN_FINI))
2857	break;
2858	#ifndef LD_INIT_SWITCH
2859	if (is_shared)
2860	add_to_list (&destructors, name);
2861	#endif
2862	break;
2863	#endif
2864
2865	case SYM_DWEH:
2866	if (! (filter & SCAN_DWEH))
2867	break;
2868	if (! is_shared)
2869	add_to_list (&frame_tables, name);
2870	#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2871	if (which_pass == PASS_OBJ)
2872	add_to_list (&exports, name);
2873	#endif
2874	break;
2875
2876	default: /* not a constructor or destructor */
2877	#ifdef COLLECT_EXPORT_LIST
2878	/* Explicitly export all global symbols when
2879	building a shared object on AIX, but do not
2880	re-export symbols from another shared object
2881	and do not export symbols if the user
2882	provides an explicit export list. */
2883	if (shared_obj && !is_shared
2884	&& which_pass == PASS_OBJ && !export_flag)
2885	{
2886	/* Do not auto-export __dso_handle or
2887	__gcc_unwind_dbase. They are required
2888	to be local to each module. */
2889	if (strcmp(name, "__dso_handle") != 0
2890	&& strcmp(name, "__gcc_unwind_dbase") != 0)
2891	{
2892	add_to_list (&exports, name);
2893	}
2894	}
2895	#endif
2896	continue;
2897	}
2898
2899	if (debug)
2900	fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2901	symbol.n_scnum, symbol.n_sclass,
2902	(symbol.n_type ? "0" : ""), symbol.n_type,
2903	name);
2904	}
2905	}
2906	}
2907	#ifdef COLLECT_EXPORT_LIST
2908	else
2909	{
2910	/* If archive contains both 32-bit and 64-bit objects,
2911	we want to skip objects in other mode so mismatch normal. */
2912	if (debug)
2913	fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
2914	prog_name, HEADER (ldptr).f_magic, aix64_flag);
2915	}
2916	#endif
2917	}
2918	else
2919	{
2920	fatal_error (input_location, "%s: cannot open as COFF file",
2921	prog_name);
2922	}
2923	#ifdef COLLECT_EXPORT_LIST
2924	/* On AIX loop continues while there are more members in archive. */
2925	}
2926	while (ldclose (ldptr) == FAILURE);
2927	#else
2928	/* Otherwise we simply close ldptr. */
2929	(void) ldclose (ldptr);
2930	#endif
2931	}
2932	#endif /* OBJECT_FORMAT_COFF */
2933
2934	#ifdef COLLECT_EXPORT_LIST
2935	/* Given a library name without "lib" prefix, this function
2936	returns a full library name including a path. */
2937	static char *
2938	resolve_lib_name (const char *name)
2939	{
2940	char *lib_buf;
2941	int i, j, l = 0;
2942	/* Library extensions for AIX dynamic linking. */
2943	const char * const libexts[2] = {"a", "so"};
2944
2945	for (i = 0; libpaths[i]; i++)
2946	if (libpaths[i]->max_len > l)
2947	l = libpaths[i]->max_len;
2948
2949	lib_buf = XNEWVEC (char, l + strlen (name) + 10);
2950
2951	for (i = 0; libpaths[i]; i++)
2952	{
2953	struct prefix_list *list = libpaths[i]->plist;
2954	for (; list; list = list->next)
2955	{
2956	/* The following lines are needed because path_prefix list
2957	may contain directories both with trailing DIR_SEPARATOR and
2958	without it. */
2959	const char *p = "";
2960	if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1]))
2961	p = "/";
2962	for (j = 0; j < 2; j++)
2963	{
2964	sprintf (lib_buf, "%s%slib%s.%s",
2965	list->prefix, p, name,
2966	libexts[(j + aixrtl_flag) % 2]);
2967	if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2968	if (file_exists (lib_buf))
2969	{
2970	if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2971	return (lib_buf);
2972	}
2973	}
2974	}
2975	}
2976	if (debug)
2977	fprintf (stderr, "not found\n");
2978	else
2979	fatal_error (input_location, "library lib%s not found", name);
2980	return (NULL);
2981	}
2982	#endif /* COLLECT_EXPORT_LIST */
2983
2984	#ifdef COLLECT_RUN_DSYMUTIL
2985	static int flag_dsym = false;
2986	static int flag_idsym = false;
2987
2988	static void
2989	process_args (int *argcp, char **argv) {
2990	int i, j;
2991	int argc = *argcp;
2992	for (i=0; i<argc; ++i)
2993	{
2994	if (strcmp (argv[i], "-dsym") == 0)
2995	{
2996	flag_dsym = true;
2997	/* Remove the flag, as we handle all processing for it. */
2998	j = i;
2999	do
3000	argv[j] = argv[j+1];
3001	while (++j < argc);
3002	--i;
3003	argc = --(*argcp);
3004	}
3005	else if (strcmp (argv[i], "-idsym") == 0)
3006	{
3007	flag_idsym = true;
3008	/* Remove the flag, as we handle all processing for it. */
3009	j = i;
3010	do
3011	argv[j] = argv[j+1];
3012	while (++j < argc);
3013	--i;
3014	argc = --(*argcp);
3015	}
3016	}
3017	}
3018
3019	static void
3020	do_dsymutil (const char *output_file) {
3021	const char *dsymutil = 0;
3022	struct pex_obj *pex;
3023	char **real_argv = XCNEWVEC (char *, verbose ? 4 : 3);
3024	const char ** argv = CONST_CAST2 (const char **, char **,
3025	real_argv);
3026	/* For cross-builds search the PATH using target-qualified name if we
3027	have not already found a suitable dsymutil. In practice, all modern
3028	versions of dsymutil handle all supported archs, however the approach
3029	here is consistent with the way other installations work (and one can
3030	always symlink a multitarget dsymutil with a target-specific name). */
3031	const char *dsname = "dsymutil";
3032	#ifdef CROSS_DIRECTORY_STRUCTURE
3033	const char *qname = concat (target_machine, "-", dsname, NULL);
3034	#else
3035	const char *qname = dsname;
3036	#endif
3037	#ifdef DEFAULT_DSYMUTIL
3038	/* Configured default takes priority. */
3039	if (dsymutil == 0 && access (DEFAULT_DSYMUTIL, X_OK) == 0)
3040	dsymutil = DEFAULT_DSYMUTIL;
3041	if (dsymutil == 0)
3042	#endif
3043	#ifdef DSYMUTIL
3044	/* Followed by one supplied in the target header, somewhat like the
3045	REAL_XX_NAME used elsewhere. */
3046	dsymutil = find_a_file (&cpath, DSYMUTIL, X_OK);
3047	if (dsymutil == 0)
3048	dsymutil = find_a_file (&path, DSYMUTIL, X_OK);
3049	if (dsymutil == 0)
3050	#endif
3051	dsymutil = find_a_file (&cpath, dsname, X_OK);
3052	if (dsymutil == 0)
3053	dsymutil = find_a_file (&path, qname, X_OK);
3054
3055	argv[0] = dsymutil;
3056	argv[1] = output_file;
3057	if (verbose)
3058	{
3059	argv[2] = "-v";
3060	argv[3] = (char *) 0;
3061	}
3062	else
3063	argv[2] = (char *) 0;
3064
3065	pex = collect_execute (dsymutil, real_argv, NULL, NULL,
3066	PEX_LAST | PEX_SEARCH, false, NULL);
3067	do_wait (dsymutil, pex);
3068	}
3069
3070	static void
3071	post_ld_pass (bool temp_file) {
3072	if (!(temp_file && flag_idsym) && !flag_dsym)
3073	return;
3074
3075	do_dsymutil (output_file);
3076	}
3077	#else
3078	static void
3079	process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3080	static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }
3081	#endif
3082