gcc.cc source code [gcc/gcc.cc]

1	/ Compiler driver program that can handle many languages.*
2	Copyright (C) 1987-2023 Free Software Foundation, Inc.
3
4	This file is part of GCC.
5
6	GCC is free software; you can redistribute it and/or modify it under
7	the terms of the GNU General Public License as published by the Free
8	Software Foundation; either version 3, or (at your option) any later
9	version.
10
11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14	for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with GCC; see the file COPYING3. If not see
18	<http://www.gnu.org/licenses/>. /*
19
20	/ This program is the user interface to the C compiler and possibly to*
21	other compilers. It is used because compilation is a complicated procedure
22	which involves running several programs and passing temporary files between
23	them, forwarding the users switches to those programs selectively,
24	and deleting the temporary files at the end.
25
26	CC recognizes how to compile each input file by suffixes in the file names.
27	Once it knows which kind of compilation to perform, the procedure for
28	compilation is specified by a string called a "spec". /*
29
30	#define INCLUDE_STRING
31	#include "config.h"
32	#include "system.h"
33	#include "coretypes.h"
34	#include "multilib.h" /* before tm.h */
35	#include "tm.h"
36	#include "xregex.h"
37	#include "obstack.h"
38	#include "intl.h"
39	#include "prefix.h"
40	#include "opt-suggestions.h"
41	#include "gcc.h"
42	#include "diagnostic.h"
43	#include "flags.h"
44	#include "opts.h"
45	#include "filenames.h"
46	#include "spellcheck.h"
47	#include "opts-jobserver.h"
48	#include "common/common-target.h"
49	#include "gcc-urlifier.h"
50
51	#ifndef MATH_LIBRARY
52	#define MATH_LIBRARY "m"
53	#endif
54
55
56	/ Manage the manipulation of env vars.*
57
58	We poison "getenv" and "putenv", so that all enviroment-handling is
59	done through this class. Note that poisoning happens in the
60	preprocessor at the identifier level, and doesn't distinguish between
61	env.getenv ();
62	and
63	getenv ();
64	Hence we need to use "get" for the accessor method, not "getenv". /*
65
66	struct env_manager
67	{
68	public:
69	void init (bool can_restore, bool debug);
70	const char get (const* char *name);
71	void xput (const char *string);
72	void restore ();
73
74	private:
75	bool m_can_restore;
76	bool m_debug;
77	struct kv
78	{
79	char *m_key;
80	char *m_value;
81	};
82	vec<kv> m_keys;
83
84	};
85
86	/ The singleton instance of class env_manager. /
87
88	static env_manager env;
89
90	/ Initializer for class env_manager.*
91
92	We can't do this as a constructor since we have a statically
93	allocated instance ("env" above). /*
94
95	void
96	env_manager::init (bool can_restore, bool debug)
97	{
98	m_can_restore = can_restore;
99	m_debug = debug;
100	}
101
102	/ Get the value of NAME within the environment. Essentially*
103	a wrapper for ::getenv, but adding logging, and the possibility
104	of caching results. /*
105
106	const char *
107	env_manager::get (const char *name)
108	{
109	const char *result = ::getenv (name: name);
110	if (m_debug)
111	fprintf (stderr, format: "env_manager::getenv (%s) -> %s\n", name, result);
112	return result;
113	}
114
115	/ Put the given KEY=VALUE entry STRING into the environment.*
116	If the env_manager was initialized with CAN_RESTORE set, then
117	also record the old value of KEY within the environment, so that it
118	can be later restored. /*
119
120	void
121	env_manager::xput (const char *string)
122	{
123	if (m_debug)
124	fprintf (stderr, format: "env_manager::xput (%s)\n", string);
125	if (verbose_flag)
126	fnotice (stderr, "%s\n", string);
127
128	if (m_can_restore)
129	{
130	char equals = strchr (s: const_cast* <char *> (string), c: `'='`);
131	gcc_assert (equals);
132
133	struct kv kv;
134	kv.m_key = xstrndup (string, equals - string);
135	const char *cur_value = ::getenv (name: kv.m_key);
136	if (m_debug)
137	fprintf (stderr, format: "saving old value: %s\n",cur_value);
138	kv.m_value = cur_value ? xstrdup (cur_value) : NULL;
139	m_keys.safe_push (obj: kv);
140	}
141
142	::putenv (CONST_CAST (char *, string));
143	}
144
145	/ Undo any xputenv changes made since last restore.*
146	Can only be called if the env_manager was initialized with
147	CAN_RESTORE enabled. /*
148
149	void
150	env_manager::restore ()
151	{
152	unsigned int i;
153	struct kv *item;
154
155	gcc_assert (m_can_restore);
156
157	FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item)
158	{
159	if (m_debug)
160	printf (format: "restoring saved key: %s value: %s\n", item->m_key, item->m_value);
161	if (item->m_value)
162	::setenv (name: item->m_key, value: item->m_value, replace: `1`);
163	else
164	::unsetenv (name: item->m_key);
165	free (ptr: item->m_key);
166	free (ptr: item->m_value);
167	}
168
169	m_keys.truncate (size: `0`);
170	}
171
172	/ Forbid other uses of getenv and putenv. /
173	#if (GCC_VERSION >= 3000)
174	#pragma GCC poison getenv putenv
175	#endif
176
177
178
179	/ By default there is no special suffix for target executables. /
180	#ifdef TARGET_EXECUTABLE_SUFFIX
181	#define HAVE_TARGET_EXECUTABLE_SUFFIX
182	#else
183	#define TARGET_EXECUTABLE_SUFFIX ""
184	#endif
185
186	/ By default there is no special suffix for host executables. /
187	#ifdef HOST_EXECUTABLE_SUFFIX
188	#define HAVE_HOST_EXECUTABLE_SUFFIX
189	#else
190	#define HOST_EXECUTABLE_SUFFIX ""
191	#endif
192
193	/ By default, the suffix for target object files is ".o". /
194	#ifdef TARGET_OBJECT_SUFFIX
195	#define HAVE_TARGET_OBJECT_SUFFIX
196	#else
197	#define TARGET_OBJECT_SUFFIX ".o"
198	#endif
199
200	static const char dir_separator_str[] = { DIR_SEPARATOR, `0` };
201
202	/ Most every one is fine with LIBRARY_PATH. For some, it conflicts. /
203	#ifndef LIBRARY_PATH_ENV
204	#define LIBRARY_PATH_ENV "LIBRARY_PATH"
205	#endif
206
207	/ If a stage of compilation returns an exit status >= 1,*
208	compilation of that file ceases. /*
209
210	#define MIN_FATAL_STATUS 1
211
212	/ Flag set by cppspec.cc to 1. /
213	int is_cpp_driver;
214
215	/ Flag set to nonzero if an @file argument has been supplied to gcc. /
216	static bool at_file_supplied;
217
218	/ Definition of string containing the arguments given to configure. /
219	#include "configargs.h"
220
221	/ Flag saying to print the command line options understood by gcc and its*
222	sub-processes. /*
223
224	static int print_help_list;
225
226	/ Flag saying to print the version of gcc and its sub-processes. /
227
228	static int print_version;
229
230	/ Flag that stores string prefix for which we provide bash completion. /
231
232	static const char *completion = NULL;
233
234	/ Flag indicating whether we should ONLY print the command and*
235	arguments (like verbose_flag) without executing the command.
236	Displayed arguments are quoted so that the generated command
237	line is suitable for execution. This is intended for use in
238	shell scripts to capture the driver-generated command line. /*
239	static int verbose_only_flag;
240
241	/ Flag indicating how to print command line options of sub-processes. /
242
243	static int print_subprocess_help;
244
245	/ Linker suffix passed to -fuse-ld=... /
246	static const char *use_ld;
247
248	/ Whether we should report subprocess execution times to a file. /
249
250	FILE *report_times_to_file = NULL;
251
252	/ Nonzero means place this string before uses of /, so that include*
253	and library files can be found in an alternate location. /*
254
255	#ifdef TARGET_SYSTEM_ROOT
256	#define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
257	#else
258	#define DEFAULT_TARGET_SYSTEM_ROOT (0)
259	#endif
260	static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
261
262	/ Nonzero means pass the updated target_system_root to the compiler. /
263
264	static int target_system_root_changed;
265
266	/ Nonzero means append this string to target_system_root. /
267
268	static const char *target_sysroot_suffix = `0`;
269
270	/ Nonzero means append this string to target_system_root for headers. /
271
272	static const char *target_sysroot_hdrs_suffix = `0`;
273
274	/ Nonzero means write "temp" files in source directory*
275	and use the source file's name in them, and don't delete them. /*
276
277	static enum save_temps {
278	SAVE_TEMPS_NONE, / no -save-temps /
279	SAVE_TEMPS_CWD, / -save-temps in current directory /
280	SAVE_TEMPS_DUMP, / -save-temps in dumpdir /
281	SAVE_TEMPS_OBJ / -save-temps in object directory /
282	} save_temps_flag;
283
284	/ Set this iff the dumppfx implied by a -save-temps=* option is to*
285	override a -dumpdir option, if any. /*
286	static bool save_temps_overrides_dumpdir = false;
287
288	/ -dumpdir, -dumpbase and -dumpbase-ext flags passed in, possibly*
289	rearranged as they are to be passed down, e.g., dumpbase and
290	dumpbase_ext may be cleared if integrated with dumpdir or
291	dropped. /*
292	static char dumpdir, dumpbase, *dumpbase_ext;
293
294	/ Usually the length of the string in dumpdir. However, during*
295	linking, it may be shortened to omit a driver-added trailing dash,
296	by then replaced with a trailing period, that is still to be passed
297	to sub-processes in -dumpdir, but not to be generally used in spec
298	filename expansions. See maybe_run_linker. /*
299	static size_t dumpdir_length = `0`;
300
301	/ Set if the last character in dumpdir is (or was) a dash that the*
302	driver added to dumpdir after dumpbase or linker output name. /*
303	static bool dumpdir_trailing_dash_added = false;
304
305	/ Basename of dump and aux outputs, computed from dumpbase (given or*
306	derived from output name), to override input_basename in non-%w %b
307	et al. /*
308	static char *outbase;
309	static size_t outbase_length = `0`;
310
311	/ The compiler version. /
312
313	static const char *compiler_version;
314
315	/ The target version. /
316
317	static const char *const spec_version = DEFAULT_TARGET_VERSION;
318
319	/ The target machine. /
320
321	static const char *spec_machine = DEFAULT_TARGET_MACHINE;
322	static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
323
324	/ List of offload targets. Separated by colon. Empty string for*
325	-foffload=disable. /*
326
327	static char *offload_targets = NULL;
328
329	#if OFFLOAD_DEFAULTED
330	/ Set to true if -foffload has not been used and offload_targets*
331	is set to the configured in default. /*
332	static bool offload_targets_default;
333	#endif
334
335	/ Nonzero if cross-compiling.*
336	When -b is used, the value comes from the `specs' file. /*
337
338	#ifdef CROSS_DIRECTORY_STRUCTURE
339	static const char *cross_compile = "1";
340	#else
341	static const char *cross_compile = "0";
342	#endif
343
344	/ Greatest exit code of sub-processes that has been encountered up to*
345	now. /*
346	static int greatest_status = `1`;
347
348	/ This is the obstack which we use to allocate many strings. /
349
350	static struct obstack obstack;
351
352	/ This is the obstack to build an environment variable to pass to*
353	collect2 that describes all of the relevant switches of what to
354	pass the compiler in building the list of pointers to constructors
355	and destructors. /*
356
357	static struct obstack collect_obstack;
358
359	/ Forward declaration for prototypes. /
360	struct path_prefix;
361	struct prefix_list;
362
363	static void init_spec (void);
364	static void store_arg (const char , int, int*);
365	static void insert_wrapper (const char *);
366	static char load_specs (const* char *);
367	static void read_specs (const char , bool, bool*);
368	static void set_spec (const char , const* char , bool*);
369	static struct compiler lookup_compiler (const* char , size_t, const* char *);
370	static char build_search_list (const* struct path_prefix , const* char *,
371	bool, bool);
372	static void xputenv (const char *);
373	static void putenv_from_prefixes (const struct path_prefix , const* char *,
374	bool);
375	static int access_check (const char , int*);
376	static char find_a_file (const* struct path_prefix , const* char , int, bool*);
377	static char find_a_program (const* char *);
378	static void add_prefix (struct path_prefix , const* char , const* char *,
379	int, int, int);
380	static void add_sysrooted_prefix (struct path_prefix , const* char *,
381	const char , int, int, int*);
382	static char skip_whitespace (char* *);
383	static void delete_if_ordinary (const char *);
384	static void delete_temp_files (void);
385	static void delete_failure_queue (void);
386	static void clear_failure_queue (void);
387	static int check_live_switch (int, int);
388	static const char handle_braces (const* char *);
389	static inline bool input_suffix_matches (const char , const* char *);
390	static inline bool switch_matches (const char , const* char , int*);
391	static inline void mark_matching_switches (const char , const* char , int*);
392	static inline void process_marked_switches (void);
393	static const char process_brace_body (const* char , const* char , const* char , int, int*);
394	static const struct spec_function lookup_spec_function (const* char *);
395	static const char eval_spec_function (const* char , const* char , const* char *);
396	static const char handle_spec_function (const* char , bool* , const* char *);
397	static char save_string (const* char , int*);
398	static void set_collect_gcc_options (void);
399	static int do_spec_1 (const char , int, const* char *);
400	static int do_spec_2 (const char , const* char *);
401	static void do_option_spec (const char , const* char *);
402	static void do_self_spec (const char *);
403	static const char find_file (const* char *);
404	static int is_directory (const char , bool*);
405	static const char validate_switches (const* char , bool, bool*);
406	static void validate_all_switches (void);
407	static inline void validate_switches_from_spec (const char , bool*);
408	static void give_switch (int, int);
409	static int default_arg (const char , int*);
410	static void set_multilib_dir (void);
411	static void print_multilib_info (void);
412	static void display_help (void);
413	static void add_preprocessor_option (const char , int*);
414	static void add_assembler_option (const char , int*);
415	static void add_linker_option (const char , int*);
416	static void process_command (unsigned int, struct cl_decoded_option *);
417	static int execute (void);
418	static void alloc_args (void);
419	static void clear_args (void);
420	static void fatal_signal (int);
421	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
422	static void init_gcc_specs (struct obstack , const* char , const* char *,
423	const char *);
424	#endif
425	#if defined(HAVE_TARGET_OBJECT_SUFFIX) \|\| defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
426	static const char convert_filename (const* char , int, int*);
427	#endif
428
429	static void try_generate_repro (const char **argv);
430	static const char getenv_spec_function (int, const* char **);
431	static const char if_exists_spec_function (int, const* char **);
432	static const char if_exists_else_spec_function (int, const* char **);
433	static const char if_exists_then_else_spec_function (int, const* char **);
434	static const char sanitize_spec_function (int, const* char **);
435	static const char replace_outfile_spec_function (int, const* char **);
436	static const char remove_outfile_spec_function (int, const* char **);
437	static const char version_compare_spec_function (int, const* char **);
438	static const char include_spec_function (int, const* char **);
439	static const char find_file_spec_function (int, const* char **);
440	static const char find_plugindir_spec_function (int, const* char **);
441	static const char print_asm_header_spec_function (int, const* char **);
442	static const char compare_debug_dump_opt_spec_function (int, const* char **);
443	static const char compare_debug_self_opt_spec_function (int, const* char **);
444	static const char pass_through_libs_spec_func (int, const* char **);
445	static const char dumps_spec_func (int, const* char **);
446	static const char greater_than_spec_func (int, const* char **);
447	static const char debug_level_greater_than_spec_func (int, const* char **);
448	static const char dwarf_version_greater_than_spec_func (int, const* char **);
449	static const char find_fortran_preinclude_file (int, const* char **);
450	static const char join_spec_func (int, const* char **);
451	static char convert_white_space (char* *);
452	static char quote_spec (char* *);
453	static char quote_spec_arg (char* *);
454	static bool not_actual_file_p (const char *);
455
456
457	/ The Specs Language*
458
459	Specs are strings containing lines, each of which (if not blank)
460	is made up of a program name, and arguments separated by spaces.
461	The program name must be exact and start from root, since no path
462	is searched and it is unreliable to depend on the current working directory.
463	Redirection of input or output is not supported; the subprograms must
464	accept filenames saying what files to read and write.
465
466	In addition, the specs can contain %-sequences to substitute variable text
467	or for conditional text. Here is a table of all defined %-sequences.
468	Note that spaces are not generated automatically around the results of
469	expanding these sequences; therefore, you can concatenate them together
470	or with constant text in a single argument.
471
472	%% substitute one % into the program name or argument.
473	%" substitute an empty argument.
474	%i substitute the name of the input file being processed.
475	%b substitute the basename for outputs related with the input file
476	being processed. This is often a substring of the input file name,
477	up to (and not including) the last period but, unless %w is active,
478	it is affected by the directory selected by -save-temps=, by*
479	-dumpdir, and, in case of multiple compilations, even by -dumpbase
480	and -dumpbase-ext and, in case of linking, by the linker output
481	name. When %w is active, it derives the main output name only from
482	the input file base name; when it is not, it names aux/dump output
483	file.
484	%B same as %b, but include the input file suffix (text after the last
485	period).
486	%gSUFFIX
487	substitute a file name that has suffix SUFFIX and is chosen
488	once per compilation, and mark the argument a la %d. To reduce
489	exposure to denial-of-service attacks, the file name is now
490	chosen in a way that is hard to predict even when previously
491	chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
492	might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
493	the regexp "[.0-9A-Za-z]%O"; "%O" is treated exactly as if it*
494	had been pre-processed. Previously, %g was simply substituted
495	with a file name chosen once per compilation, without regard
496	to any appended suffix (which was therefore treated just like
497	ordinary text), making such attacks more likely to succeed.
498	%\|SUFFIX
499	like %g, but if -pipe is in effect, expands simply to "-".
500	%mSUFFIX
501	like %g, but if -pipe is in effect, expands to nothing. (We have both
502	%\| and %m to accommodate differences between system assemblers; see
503	the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
504	%uSUFFIX
505	like %g, but generates a new temporary file name even if %uSUFFIX
506	was already seen.
507	%USUFFIX
508	substitutes the last file name generated with %uSUFFIX, generating a
509	new one if there is no such last file name. In the absence of any
510	%uSUFFIX, this is just like %gSUFFIX, except they don't share
511	the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
512	would involve the generation of two distinct file names, one
513	for each `%g.s' and another for each `%U.s'. Previously, %U was
514	simply substituted with a file name chosen for the previous %u,
515	without regard to any appended suffix.
516	%jSUFFIX
517	substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
518	writable, and if save-temps is off; otherwise, substitute the name
519	of a temporary file, just like %u. This temporary file is not
520	meant for communication between processes, but rather as a junk
521	disposal mechanism.
522	%.SUFFIX
523	substitutes .SUFFIX for the suffixes of a matched switch's args when
524	it is subsequently output with %. SUFFIX is terminated by the next*
525	space or %.
526	%d marks the argument containing or following the %d as a
527	temporary file name, so that file will be deleted if GCC exits
528	successfully. Unlike %g, this contributes no text to the argument.
529	%w marks the argument containing or following the %w as the
530	"output file" of this compilation. This puts the argument
531	into the sequence of arguments that %o will substitute later.
532	%V indicates that this compilation produces no "output file".
533	%W{...}
534	like %{...} but marks the last argument supplied within as a file
535	to be deleted on failure.
536	%@{...}
537	like %{...} but puts the result into a FILE and substitutes @FILE
538	if an @file argument has been supplied.
539	%o substitutes the names of all the output files, with spaces
540	automatically placed around them. You should write spaces
541	around the %o as well or the results are undefined.
542	%o is for use in the specs for running the linker.
543	Input files whose names have no recognized suffix are not compiled
544	at all, but they are included among the output files, so they will
545	be linked.
546	%O substitutes the suffix for object files. Note that this is
547	handled specially when it immediately follows %g, %u, or %U
548	(with or without a suffix argument) because of the need for
549	those to form complete file names. The handling is such that
550	%O is treated exactly as if it had already been substituted,
551	except that %g, %u, and %U do not currently support additional
552	SUFFIX characters following %O as they would following, for
553	example, `.o'.
554	%I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
555	(made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
556	and -B options) and -imultilib as necessary.
557	%s current argument is the name of a library or startup file of some sort.
558	Search for that file in a standard list of directories
559	and substitute the full name found.
560	%T current argument is the name of a linker script.
561	Search for that file in the current list of directories to scan for
562	libraries. If the file is located, insert a --script option into the
563	command line followed by the full path name found. If the file is
564	not found then generate an error message.
565	Note: the current working directory is not searched.
566	%eSTR Print STR as an error message. STR is terminated by a newline.
567	Use this when inconsistent options are detected.
568	%nSTR Print STR as a notice. STR is terminated by a newline.
569	%x{OPTION} Accumulate an option for %X.
570	%X Output the accumulated linker options specified by compilations.
571	%Y Output the accumulated assembler options specified by compilations.
572	%Z Output the accumulated preprocessor options specified by compilations.
573	%a process ASM_SPEC as a spec.
574	This allows config.h to specify part of the spec for running as.
575	%A process ASM_FINAL_SPEC as a spec. A capital A is actually
576	used here. This can be used to run a post-processor after the
577	assembler has done its job.
578	%D Dump out a -L option for each directory in startfile_prefixes.
579	If multilib_dir is set, extra entries are generated with it affixed.
580	%l process LINK_SPEC as a spec.
581	%L process LIB_SPEC as a spec.
582	%M Output multilib_os_dir.
583	%P Output a RUNPATH_OPTION for each directory in startfile_prefixes.
584	%G process LIBGCC_SPEC as a spec.
585	%R Output the concatenation of target_system_root and
586	target_sysroot_suffix.
587	%S process STARTFILE_SPEC as a spec. A capital S is actually used here.
588	%E process ENDFILE_SPEC as a spec. A capital E is actually used here.
589	%C process CPP_SPEC as a spec.
590	%1 process CC1_SPEC as a spec.
591	%2 process CC1PLUS_SPEC as a spec.
592	% substitute the variable part of a matched option. (See below.)*
593	Note that each comma in the substituted string is replaced by
594	a single space. A space is appended after the last substition
595	unless there is more text in current sequence.
596	%<S remove all occurrences of -S from the command line.
597	Note - this command is position dependent. % commands in the
598	spec string before this one will see -S, % commands in the
599	spec string after this one will not.
600	%>S Similar to "%<S", but keep it in the GCC command line.
601	%<S remove all occurrences of all switches beginning with -S from the*
602	command line.
603	%:function(args)
604	Call the named function FUNCTION, passing it ARGS. ARGS is
605	first processed as a nested spec string, then split into an
606	argument vector in the usual fashion. The function returns
607	a string which is processed as if it had appeared literally
608	as part of the current spec.
609	%{S} substitutes the -S switch, if that switch was given to GCC.
610	If that switch was not specified, this substitutes nothing.
611	Here S is a metasyntactic variable.
612	%{S} substitutes all the switches specified to GCC whose names start*
613	with -S. This is used for -o, -I, etc; switches that take
614	arguments. GCC considers `-o foo' as being one switch whose
615	name starts with `o'. %{o} would substitute this text,*
616	including the space; thus, two arguments would be generated.
617	%{S&T} likewise, but preserve order of S and T options (the order
618	of S and T in the spec is not significant). Can be any number
619	of ampersand-separated variables; for each the wild card is
620	optional. Useful for CPP as %{D&U&A}.*
621
622	%{S:X} substitutes X, if the -S switch was given to GCC.
623	%{!S:X} substitutes X, if the -S switch was NOT given to GCC.
624	%{S:X} substitutes X if one or more switches whose names start*
625	with -S was given to GCC. Normally X is substituted only
626	once, no matter how many such switches appeared. However,
627	if % appears somewhere in X, then X will be substituted*
628	once for each matching switch, with the % replaced by the*
629	part of that switch that matched the ''. A space will be*
630	appended after the last substition unless there is more
631	text in current sequence.
632	%{.S:X} substitutes X, if processing a file with suffix S.
633	%{!.S:X} substitutes X, if NOT processing a file with suffix S.
634	%{,S:X} substitutes X, if processing a file which will use spec S.
635	%{!,S:X} substitutes X, if NOT processing a file which will use spec S.
636
637	%{S\|T:X} substitutes X if either -S or -T was given to GCC. This may be
638	combined with '!', '.', ',', and '' as above binding stronger*
639	than the OR.
640	If % appears in X, all of the alternatives must be starred, and*
641	only the first matching alternative is substituted.
642	%{%:function(args):X}
643	Call function named FUNCTION with args ARGS. If the function
644	returns non-NULL, then X is substituted, if it returns
645	NULL, it isn't substituted.
646	%{S:X; if S was given to GCC, substitutes X;
647	T:Y; else if T was given to GCC, substitutes Y;
648	:D} else substitutes D. There can be as many clauses as you need.
649	This may be combined with '.', '!', ',', '\|', and '' as above.*
650
651	%(Spec) processes a specification defined in a specs file as Spec:*
652
653	The switch matching text S in a %{S}, %{S:X}, or similar construct can use
654	a backslash to ignore the special meaning of the character following it,
655	thus allowing literal matching of a character that is otherwise specially
656	treated. For example, %{std=iso9899\:1999:X} substitutes X if the
657	-std=iso9899:1999 option is given.
658
659	The conditional text X in a %{S:X} or similar construct may contain
660	other nested % constructs or spaces, or even newlines. They are
661	processed as usual, as described above. Trailing white space in X is
662	ignored. White space may also appear anywhere on the left side of the
663	colon in these constructs, except between . or and the corresponding*
664	word.
665
666	The -O, -f, -g, -m, and -W switches are handled specifically in these
667	constructs. If another value of -O or the negated form of a -f, -m, or
668	-W switch is found later in the command line, the earlier switch
669	value is ignored, except with {S} where S is just one letter; this*
670	passes all matching options.
671
672	The character \| at the beginning of the predicate text is used to indicate
673	that a command should be piped to the following command, but only if -pipe
674	is specified.
675
676	Note that it is built into GCC which switches take arguments and which
677	do not. You might think it would be useful to generalize this to
678	allow each compiler's spec to say which switches take arguments. But
679	this cannot be done in a consistent fashion. GCC cannot even decide
680	which input files have been specified without knowing which switches
681	take arguments, and it must know which input files to compile in order
682	to tell which compilers to run.
683
684	GCC also knows implicitly that arguments starting in `-l' are to be
685	treated as compiler output files, and passed to the linker in their
686	proper position among the other output files. /*
687
688	/ Define the macros used for specs %a, %l, %L, %S, %C, %1. /
689
690	/ config.h can define ASM_SPEC to provide extra args to the assembler*
691	or extra switch-translations. /*
692	#ifndef ASM_SPEC
693	#define ASM_SPEC ""
694	#endif
695
696	/ config.h can define ASM_FINAL_SPEC to run a post processor after*
697	the assembler has run. /*
698	#ifndef ASM_FINAL_SPEC
699	#define ASM_FINAL_SPEC \
700	"%{gsplit-dwarf: \n\
701	objcopy --extract-dwo \
702	%{c:%{o:%}%{!o*:%w%b%O}}%{!c:%U%O} \
703	%b.dwo \n\
704	objcopy --strip-dwo \
705	%{c:%{o:%}%{!o*:%w%b%O}}%{!c:%U%O} \
706	}"
707	#endif
708
709	/ config.h can define CPP_SPEC to provide extra args to the C preprocessor*
710	or extra switch-translations. /*
711	#ifndef CPP_SPEC
712	#define CPP_SPEC ""
713	#endif
714
715	/ Operating systems can define OS_CC1_SPEC to provide extra args to cc1 and*
716	cc1plus or extra switch-translations. The OS_CC1_SPEC is appended
717	to CC1_SPEC in the initialization of cc1_spec. /*
718	#ifndef OS_CC1_SPEC
719	#define OS_CC1_SPEC ""
720	#endif
721
722	/ config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus*
723	or extra switch-translations. /*
724	#ifndef CC1_SPEC
725	#define CC1_SPEC ""
726	#endif
727
728	/ config.h can define CC1PLUS_SPEC to provide extra args to cc1plus*
729	or extra switch-translations. /*
730	#ifndef CC1PLUS_SPEC
731	#define CC1PLUS_SPEC ""
732	#endif
733
734	/ config.h can define LINK_SPEC to provide extra args to the linker*
735	or extra switch-translations. /*
736	#ifndef LINK_SPEC
737	#define LINK_SPEC ""
738	#endif
739
740	/ config.h can define LIB_SPEC to override the default libraries. /
741	#ifndef LIB_SPEC
742	#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
743	#endif
744
745	/ When using -fsplit-stack we need to wrap pthread_create, in order*
746	to initialize the stack guard. We always use wrapping, rather than
747	shared library ordering, and we keep the wrapper function in
748	libgcc. This is not yet a real spec, though it could become one;
749	it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
750	only works with GNU ld and gold. /*
751	#ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
752	#define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
753	#else
754	#define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
755	#endif
756
757	#ifndef LIBASAN_SPEC
758	#define STATIC_LIBASAN_LIBS \
759	" %{static-libasan\|static:%:include(libsanitizer.spec)%(link_libasan)}"
760	#ifdef LIBASAN_EARLY_SPEC
761	#define LIBASAN_SPEC STATIC_LIBASAN_LIBS
762	#elif defined(HAVE_LD_STATIC_DYNAMIC)
763	#define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
764	"} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
765	STATIC_LIBASAN_LIBS
766	#else
767	#define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
768	#endif
769	#endif
770
771	#ifndef LIBASAN_EARLY_SPEC
772	#define LIBASAN_EARLY_SPEC ""
773	#endif
774
775	#ifndef LIBHWASAN_SPEC
776	#define STATIC_LIBHWASAN_LIBS \
777	" %{static-libhwasan\|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
778	#ifdef LIBHWASAN_EARLY_SPEC
779	#define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
780	#elif defined(HAVE_LD_STATIC_DYNAMIC)
781	#define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
782	"} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
783	STATIC_LIBHWASAN_LIBS
784	#else
785	#define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
786	#endif
787	#endif
788
789	#ifndef LIBHWASAN_EARLY_SPEC
790	#define LIBHWASAN_EARLY_SPEC ""
791	#endif
792
793	#ifndef LIBTSAN_SPEC
794	#define STATIC_LIBTSAN_LIBS \
795	" %{static-libtsan\|static:%:include(libsanitizer.spec)%(link_libtsan)}"
796	#ifdef LIBTSAN_EARLY_SPEC
797	#define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
798	#elif defined(HAVE_LD_STATIC_DYNAMIC)
799	#define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
800	"} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
801	STATIC_LIBTSAN_LIBS
802	#else
803	#define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
804	#endif
805	#endif
806
807	#ifndef LIBTSAN_EARLY_SPEC
808	#define LIBTSAN_EARLY_SPEC ""
809	#endif
810
811	#ifndef LIBLSAN_SPEC
812	#define STATIC_LIBLSAN_LIBS \
813	" %{static-liblsan\|static:%:include(libsanitizer.spec)%(link_liblsan)}"
814	#ifdef LIBLSAN_EARLY_SPEC
815	#define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
816	#elif defined(HAVE_LD_STATIC_DYNAMIC)
817	#define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
818	"} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
819	STATIC_LIBLSAN_LIBS
820	#else
821	#define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
822	#endif
823	#endif
824
825	#ifndef LIBLSAN_EARLY_SPEC
826	#define LIBLSAN_EARLY_SPEC ""
827	#endif
828
829	#ifndef LIBUBSAN_SPEC
830	#define STATIC_LIBUBSAN_LIBS \
831	" %{static-libubsan\|static:%:include(libsanitizer.spec)%(link_libubsan)}"
832	#ifdef HAVE_LD_STATIC_DYNAMIC
833	#define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
834	"} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
835	STATIC_LIBUBSAN_LIBS
836	#else
837	#define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
838	#endif
839	#endif
840
841	/ Linker options for compressed debug sections. /
842	#if HAVE_LD_COMPRESS_DEBUG == 0
843	/ No linker support. /
844	#define LINK_COMPRESS_DEBUG_SPEC \
845	" %{gz*:%e-gz is not supported in this configuration} "
846	#elif HAVE_LD_COMPRESS_DEBUG == 1
847	/ ELF gABI style. /
848	#define LINK_COMPRESS_DEBUG_SPEC \
849	" %{gz\|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
850	" %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
851	" %{gz=zstd:%e-gz=zstd is not supported in this configuration} " \
852	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
853	#elif HAVE_LD_COMPRESS_DEBUG == 2
854	/ ELF gABI style and ZSTD. /
855	#define LINK_COMPRESS_DEBUG_SPEC \
856	" %{gz\|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
857	" %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
858	" %{gz=zstd:" LD_COMPRESS_DEBUG_OPTION "=zstd}" \
859	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
860	#else
861	#error Unknown value for HAVE_LD_COMPRESS_DEBUG.
862	#endif
863
864	/ config.h can define LIBGCC_SPEC to override how and when libgcc.a is*
865	included. /*
866	#ifndef LIBGCC_SPEC
867	#if defined(REAL_LIBGCC_SPEC)
868	#define LIBGCC_SPEC REAL_LIBGCC_SPEC
869	#elif defined(LINK_LIBGCC_SPECIAL_1)
870	/ Have gcc do the search for libgcc.a. /
871	#define LIBGCC_SPEC "libgcc.a%s"
872	#else
873	#define LIBGCC_SPEC "-lgcc"
874	#endif
875	#endif
876
877	/ config.h can define STARTFILE_SPEC to override the default crt0 files. /
878	#ifndef STARTFILE_SPEC
879	#define STARTFILE_SPEC \
880	"%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
881	#endif
882
883	/ config.h can define ENDFILE_SPEC to override the default crtn files. /
884	#ifndef ENDFILE_SPEC
885	#define ENDFILE_SPEC ""
886	#endif
887
888	#ifndef LINKER_NAME
889	#define LINKER_NAME "collect2"
890	#endif
891
892	#ifdef HAVE_AS_DEBUG_PREFIX_MAP
893	#define ASM_MAP " %{ffile-prefix-map=:--debug-prefix-map %} %{fdebug-prefix-map=:--debug-prefix-map %}"
894	#else
895	#define ASM_MAP ""
896	#endif
897
898	/ Assembler options for compressed debug sections. /
899	#if HAVE_LD_COMPRESS_DEBUG == 0
900	/ Reject if the linker cannot write compressed debug sections. /
901	#define ASM_COMPRESS_DEBUG_SPEC \
902	" %{gz*:%e-gz is not supported in this configuration} "
903	#else /* HAVE_LD_COMPRESS_DEBUG >= 1 */
904	#if HAVE_AS_COMPRESS_DEBUG == 0
905	/ No assembler support. Ignore silently. /
906	#define ASM_COMPRESS_DEBUG_SPEC \
907	" %{gz*:} "
908	#elif HAVE_AS_COMPRESS_DEBUG == 1
909	/ ELF gABI style. /
910	#define ASM_COMPRESS_DEBUG_SPEC \
911	" %{gz\|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
912	" %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
913	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
914	#elif HAVE_AS_COMPRESS_DEBUG == 2
915	/ ELF gABI style and ZSTD. /
916	#define ASM_COMPRESS_DEBUG_SPEC \
917	" %{gz\|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
918	" %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
919	" %{gz=zstd:" AS_COMPRESS_DEBUG_OPTION "=zstd}" \
920	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
921	#else
922	#error Unknown value for HAVE_AS_COMPRESS_DEBUG.
923	#endif
924	#endif /* HAVE_LD_COMPRESS_DEBUG >= 1 */
925
926	/ Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'*
927	to the assembler, when compiling assembly sources only. /*
928	#ifndef ASM_DEBUG_SPEC
929	# if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
930	/ If --gdwarf-N is supported and as can handle even compiler generated*
931	.debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
932	than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
933	compilations. /*
934	# define ASM_DEBUG_DWARF_OPTION ""
935	# elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
936	# define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
937	"%:dwarf-version-gt(3):--gdwarf-4;" \
938	"%:dwarf-version-gt(2):--gdwarf-3;" \
939	":--gdwarf2}"
940	# else
941	# define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
942	# endif
943	# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
944	# define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
945	ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
946	# endif
947	# endif
948	#ifndef ASM_DEBUG_SPEC
949	# define ASM_DEBUG_SPEC ""
950	#endif
951
952	/ Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'*
953	to the assembler when compiling all sources. /*
954	#ifndef ASM_DEBUG_OPTION_SPEC
955	# if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
956	# define ASM_DEBUG_OPTION_DWARF_OPT \
957	"%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
958	"%:dwarf-version-gt(3):--gdwarf-4 ;" \
959	"%:dwarf-version-gt(2):--gdwarf-3 ;" \
960	":--gdwarf2 }"
961	# if defined(DWARF2_DEBUGGING_INFO)
962	# define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
963	ASM_DEBUG_OPTION_DWARF_OPT "}}"
964	# endif
965	# endif
966	#endif
967	#ifndef ASM_DEBUG_OPTION_SPEC
968	# define ASM_DEBUG_OPTION_SPEC ""
969	#endif
970
971	/ Here is the spec for running the linker, after compiling all files. /
972
973	/ This is overridable by the target in case they need to specify the*
974	-lgcc and -lc order specially, yet not require them to override all
975	of LINK_COMMAND_SPEC. /*
976	#ifndef LINK_GCC_C_SEQUENCE_SPEC
977	#define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
978	#endif
979
980	#ifndef LINK_SSP_SPEC
981	#ifdef TARGET_LIBC_PROVIDES_SSP
982	#define LINK_SSP_SPEC "%{fstack-protector\|fstack-protector-all" \
983	"\|fstack-protector-strong\|fstack-protector-explicit:}"
984	#else
985	#define LINK_SSP_SPEC "%{fstack-protector\|fstack-protector-all" \
986	"\|fstack-protector-strong\|fstack-protector-explicit" \
987	":-lssp_nonshared -lssp}"
988	#endif
989	#endif
990
991	#ifdef ENABLE_DEFAULT_PIE
992	#define PIE_SPEC "!no-pie"
993	#define NO_FPIE1_SPEC "fno-pie"
994	#define FPIE1_SPEC NO_FPIE1_SPEC ":;"
995	#define NO_FPIE2_SPEC "fno-PIE"
996	#define FPIE2_SPEC NO_FPIE2_SPEC ":;"
997	#define NO_FPIE_SPEC NO_FPIE1_SPEC "\|" NO_FPIE2_SPEC
998	#define FPIE_SPEC NO_FPIE_SPEC ":;"
999	#define NO_FPIC1_SPEC "fno-pic"
1000	#define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1001	#define NO_FPIC2_SPEC "fno-PIC"
1002	#define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1003	#define NO_FPIC_SPEC NO_FPIC1_SPEC "\|" NO_FPIC2_SPEC
1004	#define FPIC_SPEC NO_FPIC_SPEC ":;"
1005	#define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "\|" NO_FPIC1_SPEC
1006	#define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1007	#define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "\|" NO_FPIC2_SPEC
1008	#define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1009	#define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "\|" NO_FPIC_SPEC
1010	#define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1011	#else
1012	#define PIE_SPEC "pie"
1013	#define FPIE1_SPEC "fpie"
1014	#define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1015	#define FPIE2_SPEC "fPIE"
1016	#define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1017	#define FPIE_SPEC FPIE1_SPEC "\|" FPIE2_SPEC
1018	#define NO_FPIE_SPEC FPIE_SPEC ":;"
1019	#define FPIC1_SPEC "fpic"
1020	#define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1021	#define FPIC2_SPEC "fPIC"
1022	#define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1023	#define FPIC_SPEC FPIC1_SPEC "\|" FPIC2_SPEC
1024	#define NO_FPIC_SPEC FPIC_SPEC ":;"
1025	#define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "\|" FPIC1_SPEC
1026	#define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1027	#define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "\|" FPIC2_SPEC
1028	#define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1029	#define FPIE_OR_FPIC_SPEC FPIE_SPEC "\|" FPIC_SPEC
1030	#define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1031	#endif
1032
1033	#ifndef LINK_PIE_SPEC
1034	#ifdef HAVE_LD_PIE
1035	#ifndef LD_PIE_SPEC
1036	#define LD_PIE_SPEC "-pie"
1037	#endif
1038	#else
1039	#define LD_PIE_SPEC ""
1040	#endif
1041	#define LINK_PIE_SPEC "%{static\|shared\|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1042	#endif
1043
1044	#ifndef LINK_BUILDID_SPEC
1045	# if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1046	# define LINK_BUILDID_SPEC "%{!r:--build-id} "
1047	# endif
1048	#endif
1049
1050	#ifndef LTO_PLUGIN_SPEC
1051	#define LTO_PLUGIN_SPEC ""
1052	#endif
1053
1054	/ Conditional to test whether the LTO plugin is used or not.*
1055	FIXME: For slim LTO we will need to enable plugin unconditionally. This
1056	still cause problems with PLUGIN_LD != LD and when plugin is built but
1057	not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1058	plugin only when LTO is enabled. We still honor explicit
1059	-fuse-linker-plugin if the linker used understands -plugin. /*
1060
1061	/ The linker has some plugin support. /
1062	#if HAVE_LTO_PLUGIN > 0
1063	/ The linker used has full plugin support, use LTO plugin by default. /
1064	#if HAVE_LTO_PLUGIN == 2
1065	#define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1066	#define PLUGIN_COND_CLOSE "}"
1067	#else
1068	/ The linker used has limited plugin support, use LTO plugin with explicit*
1069	-fuse-linker-plugin. /*
1070	#define PLUGIN_COND "fuse-linker-plugin"
1071	#define PLUGIN_COND_CLOSE ""
1072	#endif
1073	#define LINK_PLUGIN_SPEC \
1074	"%{" PLUGIN_COND": \
1075	-plugin %(linker_plugin_file) \
1076	-plugin-opt=%(lto_wrapper) \
1077	-plugin-opt=-fresolution=%u.res \
1078	" LTO_PLUGIN_SPEC "\
1079	%{flinker-output=*:-plugin-opt=-linker-output-known} \
1080	%{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1081	}" PLUGIN_COND_CLOSE
1082	#else
1083	/ The linker used doesn't support -plugin, reject -fuse-linker-plugin. /
1084	#define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1085	%e-fuse-linker-plugin is not supported in this configuration}"
1086	#endif
1087
1088	/ Linker command line options for -fsanitize= early on the command line. /
1089	#ifndef SANITIZER_EARLY_SPEC
1090	#define SANITIZER_EARLY_SPEC "\
1091	%{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1092	%{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1093	%{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1094	%{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1095	#endif
1096
1097	/ Linker command line options for -fsanitize= late on the command line. /
1098	#ifndef SANITIZER_SPEC
1099	#define SANITIZER_SPEC "\
1100	%{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1101	%{static:%ecannot specify -static with -fsanitize=address}}\
1102	%{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1103	%{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1104	%{%:sanitize(thread):" LIBTSAN_SPEC "\
1105	%{static:%ecannot specify -static with -fsanitize=thread}}\
1106	%{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1107	%{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1108	#endif
1109
1110	#ifndef POST_LINK_SPEC
1111	#define POST_LINK_SPEC ""
1112	#endif
1113
1114	/ This is the spec to use, once the code for creating the vtable*
1115	verification runtime library, libvtv.so, has been created. Currently
1116	the vtable verification runtime functions are in libstdc++, so we use
1117	the spec just below this one. /*
1118	#ifndef VTABLE_VERIFICATION_SPEC
1119	#if ENABLE_VTABLE_VERIFY
1120	#define VTABLE_VERIFICATION_SPEC "\
1121	%{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1122	%{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1123	#else
1124	#define VTABLE_VERIFICATION_SPEC "\
1125	%{fvtable-verify=none:} \
1126	%{fvtable-verify=std: \
1127	%e-fvtable-verify=std is not supported in this configuration} \
1128	%{fvtable-verify=preinit: \
1129	%e-fvtable-verify=preinit is not supported in this configuration}"
1130	#endif
1131	#endif
1132
1133	/ -u* was put back because both BSD and SysV seem to support it. /
1134	/ %{static\|no-pie\|static-pie:} simply prevents an error message:*
1135	1. If the target machine doesn't handle -static.
1136	2. If PIE isn't enabled by default.
1137	3. If the target machine doesn't handle -static-pie.
1138	*/
1139	/ We want %{T} after %{L} and %D so that it can be used to specify linker*
1140	scripts which exist in user specified directories, or in standard
1141	directories. /*
1142	/ We pass any -flto flags on to the linker, which is expected*
1143	to understand them. In practice, this means it had better be collect2. /*
1144	/ %{e} includes -export-dynamic; see comment in common.opt. /*
1145	#ifndef LINK_COMMAND_SPEC
1146	#define LINK_COMMAND_SPEC "\
1147	%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1148	%(linker) " \
1149	LINK_PLUGIN_SPEC \
1150	"%{flto\|flto=:%<fcompare-debug} \
1151	%{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1152	"%{fuse-ld=:-fuse-ld=%} " LINK_COMPRESS_DEBUG_SPEC \
1153	"%X %{o} %{e} %{N} %{n} %{r}\
1154	%{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1155	%{static\|no-pie\|static-pie:} %@{L*} %(link_libgcc) " \
1156	VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1157	%{fopenacc\|fopenmp\|%:gt(%{ftree-parallelize-loops=:%} 1):\
1158	%:include(libgomp.spec)%(link_gomp)}\
1159	%{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1160	" STACK_SPLIT_SPEC "\
1161	%{fprofile-arcs\|fprofile-generate*\|coverage:-lgcov} " SANITIZER_SPEC " \
1162	%{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1163	%{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1164	#endif
1165
1166	#ifndef LINK_LIBGCC_SPEC
1167	/ Generate -L options for startfile prefix list. /
1168	# define LINK_LIBGCC_SPEC "%D"
1169	#endif
1170
1171	#ifndef STARTFILE_PREFIX_SPEC
1172	# define STARTFILE_PREFIX_SPEC ""
1173	#endif
1174
1175	#ifndef SYSROOT_SPEC
1176	# define SYSROOT_SPEC "--sysroot=%R"
1177	#endif
1178
1179	#ifndef SYSROOT_SUFFIX_SPEC
1180	# define SYSROOT_SUFFIX_SPEC ""
1181	#endif
1182
1183	#ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1184	# define SYSROOT_HEADERS_SUFFIX_SPEC ""
1185	#endif
1186
1187	#ifndef RUNPATH_OPTION
1188	# define RUNPATH_OPTION "-rpath"
1189	#endif
1190
1191	static const char *asm_debug = ASM_DEBUG_SPEC;
1192	static const char *asm_debug_option = ASM_DEBUG_OPTION_SPEC;
1193	static const char *cpp_spec = CPP_SPEC;
1194	static const char *cc1_spec = CC1_SPEC OS_CC1_SPEC;
1195	static const char *cc1plus_spec = CC1PLUS_SPEC;
1196	static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
1197	static const char *link_ssp_spec = LINK_SSP_SPEC;
1198	static const char *asm_spec = ASM_SPEC;
1199	static const char *asm_final_spec = ASM_FINAL_SPEC;
1200	static const char *link_spec = LINK_SPEC;
1201	static const char *lib_spec = LIB_SPEC;
1202	static const char *link_gomp_spec = "";
1203	static const char *libgcc_spec = LIBGCC_SPEC;
1204	static const char *endfile_spec = ENDFILE_SPEC;
1205	static const char *startfile_spec = STARTFILE_SPEC;
1206	static const char *linker_name_spec = LINKER_NAME;
1207	static const char *linker_plugin_file_spec = "";
1208	static const char *lto_wrapper_spec = "";
1209	static const char *lto_gcc_spec = "";
1210	static const char *post_link_spec = POST_LINK_SPEC;
1211	static const char *link_command_spec = LINK_COMMAND_SPEC;
1212	static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
1213	static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
1214	static const char *sysroot_spec = SYSROOT_SPEC;
1215	static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
1216	static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
1217	static const char *self_spec = "";
1218
1219	/ Standard options to cpp, cc1, and as, to reduce duplication in specs.*
1220	There should be no need to override these in target dependent files,
1221	but we need to copy them to the specs file so that newer versions
1222	of the GCC driver can correctly drive older tool chains with the
1223	appropriate -B options. /*
1224
1225	/ When cpplib handles traditional preprocessing, get rid of this, and*
1226	call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1227	that we default the front end language better. /*
1228	static const char *trad_capable_cpp =
1229	"cc1 -E %{traditional\|traditional-cpp:-traditional-cpp}";
1230
1231	/ We don't wrap .d files in %W{} since a missing .d file, and*
1232	therefore no dependency entry, confuses make into thinking a .o
1233	file that happens to exist is up-to-date. /*
1234	static const char *cpp_unique_options =
1235	"%{!Q:-quiet} %{nostdinc} %{C} %{CC} %{v} %@{I&F*} %{P} %I\
1236	%{MD:-MD %{!o:%b.d}%{o:%.d%}}\
1237	%{MMD:-MMD %{!o:%b.d}%{o:%.d%}}\
1238	%{M} %{MM} %{MF} %{MG} %{MP} %{MQ} %{MT*}\
1239	%{Mmodules} %{Mno-modules}\
1240	%{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD\|MMD:%{o:-MQ %}}}}}}}\
1241	%{remap} %{%:debug-level-gt(2):-dD}\
1242	%{!iplugindir:%{fplugin:%:find-plugindir()}}\
1243	%{H} %C %{D&U&A} %{i} %Z %i\
1244	%{E\|M\|MM:%W{o*}}\
1245	%{fdeps-format=:%{!fdeps-file=:-fdeps-file=%:join(%{!o:%b.ddi}%{o:%.ddi%})}}\
1246	%{fdeps-format=:%{!fdeps-target=:-fdeps-target=%:join(%{!o:%b.o}%{o:%.o%})}}";
1247
1248	/ This contains cpp options which are common with cc1_options and are passed*
1249	only when preprocessing only to avoid duplication. We pass the cc1 spec
1250	options to the preprocessor so that it the cc1 spec may manipulate
1251	options used to set target flags. Those special target flags settings may
1252	in turn cause preprocessor symbols to be defined specially. /*
1253	static const char *cpp_options =
1254	"%(cpp_unique_options) %1 %{m} %{std&ansi&trigraphs} %{W&pedantic} %{w}\
1255	%{f} %{g:%{%:debug-level-gt(0):%{g*}\
1256	%{!fno-working-directory:-fworking-directory}}} %{O*}\
1257	%{undef} %{save-temps*:-fpch-preprocess}";
1258
1259	/ Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.*
1260
1261	Make it easy for a language to override the argument for the
1262	%:dumps specs function call. /*
1263	#define DUMPS_OPTIONS(EXTS) \
1264	"%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1265
1266	/ This contains cpp options which are not passed when the preprocessor*
1267	output will be used by another program. /*
1268	static const char *cpp_debug_options = DUMPS_OPTIONS ("");
1269
1270	/ NB: This is shared amongst all front-ends, except for Ada. /
1271	static const char *cc1_options =
1272	"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1273	%{!iplugindir:%{fplugin:%:find-plugindir()}}\
1274	%1 %{!Q:-quiet} %(cpp_debug_options) %{m} %{aux-info}\
1275	%{g} %{O} %{W&pedantic} %{w} %{std*&ansi&trigraphs}\
1276	%{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1277	%{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1278	%{-target-help:--target-help}\
1279	%{-version:--version}\
1280	%{-help=:--help=%}\
1281	%{!fsyntax-only:%{S:%W{o}%{!o:-o %w%b.s}}}\
1282	%{fsyntax-only:-o %j} %{-param*}\
1283	%{coverage:-fprofile-arcs -ftest-coverage}\
1284	%{fprofile-arcs\|fprofile-generate*\|coverage:\
1285	%{!fprofile-update=single:\
1286	%{pthread:-fprofile-update=prefer-atomic}}}";
1287
1288	static const char *asm_options =
1289	"%{-target-help:%:print-asm-header()} "
1290	#if HAVE_GNU_AS
1291	/ If GNU AS is used, then convert -w (no warnings), -I, and -v*
1292	to the assembler equivalents. /*
1293	"%{v} %{w:-W} %{I*} "
1294	#endif
1295	"%(asm_debug_option)"
1296	ASM_COMPRESS_DEBUG_SPEC
1297	"%a %Y %{c:%W{o}%{!o:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1298
1299	static const char *invoke_as =
1300	#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1301	"%{!fwpa*:\
1302	%{fcompare-debug=\|fdump-final-insns=:%:compare-debug-dump-opt()}\
1303	%{!S:-o %\|.s \|\n as %(asm_options) %\|.s %A }\
1304	}";
1305	#else
1306	"%{!fwpa*:\
1307	%{fcompare-debug=\|fdump-final-insns=:%:compare-debug-dump-opt()}\
1308	%{!S:-o %\|.s \|\n as %(asm_options) %m.s %A }\
1309	}";
1310	#endif
1311
1312	/ Some compilers have limits on line lengths, and the multilib_select*
1313	and/or multilib_matches strings can be very long, so we build them at
1314	run time. /*
1315	static struct obstack multilib_obstack;
1316	static const char *multilib_select;
1317	static const char *multilib_matches;
1318	static const char *multilib_defaults;
1319	static const char *multilib_exclusions;
1320	static const char *multilib_reuse;
1321
1322	/ Check whether a particular argument is a default argument. /
1323
1324	#ifndef MULTILIB_DEFAULTS
1325	#define MULTILIB_DEFAULTS { "" }
1326	#endif
1327
1328	static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
1329
1330	#ifndef DRIVER_SELF_SPECS
1331	#define DRIVER_SELF_SPECS ""
1332	#endif
1333
1334	/ Linking to libgomp implies pthreads. This is particularly important*
1335	for targets that use different start files and suchlike. /*
1336	#ifndef GOMP_SELF_SPECS
1337	#define GOMP_SELF_SPECS \
1338	"%{fopenacc\|fopenmp\|%:gt(%{ftree-parallelize-loops=:%} 1): " \
1339	"-pthread}"
1340	#endif
1341
1342	/ Likewise for -fgnu-tm. /
1343	#ifndef GTM_SELF_SPECS
1344	#define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1345	#endif
1346
1347	static const char *const driver_self_specs[] = {
1348	"%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1349	DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS,
1350	/ This discards -fmultiflags at the end of self specs processing in the*
1351	driver, so that it is effectively Ignored, without actually marking it as
1352	Ignored, which would get it discarded before self specs could remap it. /*
1353	"%<fmultiflags"
1354	};
1355
1356	#ifndef OPTION_DEFAULT_SPECS
1357	#define OPTION_DEFAULT_SPECS { "", "" }
1358	#endif
1359
1360	struct default_spec
1361	{
1362	const char *name;
1363	const char *spec;
1364	};
1365
1366	static const struct default_spec
1367	option_default_specs[] = { OPTION_DEFAULT_SPECS };
1368
1369	struct user_specs
1370	{
1371	struct user_specs *next;
1372	const char *filename;
1373	};
1374
1375	static struct user_specs user_specs_head, user_specs_tail;
1376
1377
1378	/ Record the mapping from file suffixes for compilation specs. /
1379
1380	struct compiler
1381	{
1382	const char suffix; /* Use this compiler for input files*
1383	whose names end in this suffix. /*
1384
1385	const char spec; /* To use this compiler, run this spec. /
1386
1387	const char cpp_spec; /* If non-NULL, substitute this spec*
1388	for `%C', rather than the usual
1389	cpp_spec. /*
1390	int combinable; / If nonzero, compiler can deal with*
1391	multiple source files at once (IMA). /*
1392	int needs_preprocessing; / If nonzero, source files need to*
1393	be run through a preprocessor. /*
1394	};
1395
1396	/ Pointer to a vector of `struct compiler' that gives the spec for*
1397	compiling a file, based on its suffix.
1398	A file that does not end in any of these suffixes will be passed
1399	unchanged to the loader and nothing else will be done to it.
1400
1401	An entry containing two 0s is used to terminate the vector.
1402
1403	If multiple entries match a file, the last matching one is used. /*
1404
1405	static struct compiler *compilers;
1406
1407	/ Number of entries in `compilers', not counting the null terminator. /
1408
1409	static int n_compilers;
1410
1411	/ The default list of file name suffixes and their compilation specs. /
1412
1413	static const struct compiler default_compilers[] =
1414	{
1415	/ Add lists of suffixes of known languages here. If those languages*
1416	were not present when we built the driver, we will hit these copies
1417	and be given a more meaningful error than "file not used since
1418	linking is not done". /*
1419	{.suffix: ".m", .spec: "#Objective-C", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".mi", .spec: "#Objective-C", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1420	{.suffix: ".mm", .spec: "#Objective-C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".M", .spec: "#Objective-C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1421	{.suffix: ".mii", .spec: "#Objective-C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1422	{.suffix: ".cc", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".cxx", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1423	{.suffix: ".cpp", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".cp", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1424	{.suffix: ".c++", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".C", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1425	{.suffix: ".CPP", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".ii", .spec: "#C++", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1426	{.suffix: ".ads", .spec: "#Ada", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".adb", .spec: "#Ada", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1427	{.suffix: ".f", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".F", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1428	{.suffix: ".for", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".FOR", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1429	{.suffix: ".ftn", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".FTN", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1430	{.suffix: ".fpp", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".FPP", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1431	{.suffix: ".f90", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".F90", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1432	{.suffix: ".f95", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".F95", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1433	{.suffix: ".f03", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".F03", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1434	{.suffix: ".f08", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".F08", .spec: "#Fortran", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1435	{.suffix: ".r", .spec: "#Ratfor", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1436	{.suffix: ".go", .spec: "#Go", .cpp_spec: `0`, .combinable: `1`, .needs_preprocessing: `0`},
1437	{.suffix: ".d", .spec: "#D", .cpp_spec: `0`, .combinable: `1`, .needs_preprocessing: `0`}, {.suffix: ".dd", .spec: "#D", .cpp_spec: `0`, .combinable: `1`, .needs_preprocessing: `0`}, {.suffix: ".di", .spec: "#D", .cpp_spec: `0`, .combinable: `1`, .needs_preprocessing: `0`},
1438	{.suffix: ".mod", .spec: "#Modula-2", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}, {.suffix: ".m2i", .spec: "#Modula-2", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1439	/ Next come the entries for C. /
1440	{.suffix: ".c", .spec: "@c", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `1`},
1441	{.suffix: "@c",
1442	/ cc1 has an integrated ISO C preprocessor. We should invoke the*
1443	external preprocessor if -save-temps is given. /*
1444	.spec: "%{E\|M\|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1445	%{!E:%{!M:%{!MM:\
1446	%{traditional:\
1447	%eGNU C no longer supports -traditional without -E}\
1448	%{save-temps*\|traditional-cpp\|no-integrated-cpp:%(trad_capable_cpp) \
1449	%(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
1450	cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
1451	%(cc1_options)}\
1452	%{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1453	cc1 %(cpp_unique_options) %(cc1_options)}}}\
1454	%{!fsyntax-only:%(invoke_as)}}}}", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `1`},
1455	{.suffix: "-",
1456	.spec: "%{!E:%e-E or -x required when input is from standard input}\
1457	%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1458	{.suffix: ".h", .spec: "@c-header", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1459	{.suffix: "@c-header",
1460	/ cc1 has an integrated ISO C preprocessor. We should invoke the*
1461	external preprocessor if -save-temps is given. /*
1462	.spec: "%{E\|M\|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1463	%{!E:%{!M:%{!MM:\
1464	%{save-temps*\|traditional-cpp\|no-integrated-cpp:%(trad_capable_cpp) \
1465	%(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
1466	cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
1467	%(cc1_options)\
1468	%{!fsyntax-only:%{!S:-o %g.s} \
1469	%{!fdump-ada-spec:%{!o:--output-pch %w%i.gch}\
1470	%W{o:--output-pch %w%}}%{!S:%V}}}\
1471	%{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1472	cc1 %(cpp_unique_options) %(cc1_options)\
1473	%{!fsyntax-only:%{!S:-o %g.s} \
1474	%{!fdump-ada-spec:%{!o:--output-pch %w%i.gch}\
1475	%W{o:--output-pch %w%}}%{!S:%V}}}}}}}}", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1476	{.suffix: ".i", .spec: "@cpp-output", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1477	{.suffix: "@cpp-output",
1478	.spec: "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1479	{.suffix: ".s", .spec: "@assembler", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1480	{.suffix: "@assembler",
1481	.spec: "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1482	{.suffix: ".sx", .spec: "@assembler-with-cpp", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1483	{.suffix: ".S", .spec: "@assembler-with-cpp", .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1484	{.suffix: "@assembler-with-cpp",
1485	#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1486	"%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1487	%{E\|M\|MM:%(cpp_debug_options)}\
1488	%{!M:%{!MM:%{!E:%{!S:-o %\|.s \|\n\
1489	as %(asm_debug) %(asm_options) %\|.s %A }}}}"
1490	#else
1491	.spec: "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1492	%{E\|M\|MM:%(cpp_debug_options)}\
1493	%{!M:%{!MM:%{!E:%{!S:-o %\|.s \|\n\
1494	as %(asm_debug) %(asm_options) %m.s %A }}}}"
1495	#endif
1496	, .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`},
1497
1498	#include "specs.h"
1499	/ Mark end of table. /
1500	{.suffix: `0`, .spec: `0`, .cpp_spec: `0`, .combinable: `0`, .needs_preprocessing: `0`}
1501	};
1502
1503	/ Number of elements in default_compilers, not counting the terminator. /
1504
1505	static const int n_default_compilers = ARRAY_SIZE (default_compilers) - `1`;
1506
1507	typedef char char_p; /* For DEF_VEC_P. /
1508
1509	/ A vector of options to give to the linker.*
1510	These options are accumulated by %x,
1511	and substituted into the linker command with %X. /*
1512	static vec<char_p> linker_options;
1513
1514	/ A vector of options to give to the assembler.*
1515	These options are accumulated by -Wa,
1516	and substituted into the assembler command with %Y. /*
1517	static vec<char_p> assembler_options;
1518
1519	/ A vector of options to give to the preprocessor.*
1520	These options are accumulated by -Wp,
1521	and substituted into the preprocessor command with %Z. /*
1522	static vec<char_p> preprocessor_options;
1523
1524	static char *
1525	skip_whitespace (char *p)
1526	{
1527	while (`1`)
1528	{
1529	/ A fully-blank line is a delimiter in the SPEC file and shouldn't*
1530	be considered whitespace. /*
1531	if (p[`0`] == `'\n'` && p[`1`] == `'\n'` && p[`2`] == `'\n'`)
1532	return p + `1`;
1533	else if (p == `'\n'` \|\| p == `' '` \|\| *p == `'\t'`)
1534	p++;
1535	else if (*p == `'#'`)
1536	{
1537	while (*p != `'\n'`)
1538	p++;
1539	p++;
1540	}
1541	else
1542	break;
1543	}
1544
1545	return p;
1546	}
1547	/ Structures to keep track of prefixes to try when looking for files. /
1548
1549	struct prefix_list
1550	{
1551	const char prefix; /* String to prepend to the path. /
1552	struct prefix_list next; /* Next in linked list. /
1553	int require_machine_suffix; / Don't use without machine_suffix. /
1554	/ 2 means try both machine_suffix and just_machine_suffix. /
1555	int priority; / Sort key - priority within list. /
1556	int os_multilib; / 1 if OS multilib scheme should be used,*
1557	0 for GCC multilib scheme. /*
1558	};
1559
1560	struct path_prefix
1561	{
1562	struct prefix_list plist; /* List of prefixes to try /
1563	int max_len; / Max length of a prefix in PLIST /
1564	const char name; /* Name of this list (used in config stuff) /
1565	};
1566
1567	/ List of prefixes to try when looking for executables. /
1568
1569	static struct path_prefix exec_prefixes = { .plist: `0`, .max_len: `0`, .name: "exec" };
1570
1571	/ List of prefixes to try when looking for startup (crt0) files. /
1572
1573	static struct path_prefix startfile_prefixes = { .plist: `0`, .max_len: `0`, .name: "startfile" };
1574
1575	/ List of prefixes to try when looking for include files. /
1576
1577	static struct path_prefix include_prefixes = { .plist: `0`, .max_len: `0`, .name: "include" };
1578
1579	/ Suffix to attach to directories searched for commands.*
1580	This looks like `MACHINE/VERSION/'. /*
1581
1582	static const char *machine_suffix = `0`;
1583
1584	/ Suffix to attach to directories searched for commands.*
1585	This is just `MACHINE/'. /*
1586
1587	static const char *just_machine_suffix = `0`;
1588
1589	/ Adjusted value of GCC_EXEC_PREFIX envvar. /
1590
1591	static const char *gcc_exec_prefix;
1592
1593	/ Adjusted value of standard_libexec_prefix. /
1594
1595	static const char *gcc_libexec_prefix;
1596
1597	/ Default prefixes to attach to command names. /
1598
1599	#ifndef STANDARD_STARTFILE_PREFIX_1
1600	#define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1601	#endif
1602	#ifndef STANDARD_STARTFILE_PREFIX_2
1603	#define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1604	#endif
1605
1606	#ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1607	#undef MD_EXEC_PREFIX
1608	#undef MD_STARTFILE_PREFIX
1609	#undef MD_STARTFILE_PREFIX_1
1610	#endif
1611
1612	/ If no prefixes defined, use the null string, which will disable them. /
1613	#ifndef MD_EXEC_PREFIX
1614	#define MD_EXEC_PREFIX ""
1615	#endif
1616	#ifndef MD_STARTFILE_PREFIX
1617	#define MD_STARTFILE_PREFIX ""
1618	#endif
1619	#ifndef MD_STARTFILE_PREFIX_1
1620	#define MD_STARTFILE_PREFIX_1 ""
1621	#endif
1622
1623	/ These directories are locations set at configure-time based on the*
1624	--prefix option provided to configure. Their initializers are
1625	defined in Makefile.in. These paths are not directly* used when*
1626	gcc_exec_prefix is set because, in that case, we know where the
1627	compiler has been installed, and use paths relative to that
1628	location instead. /*
1629	static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1630	static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1631	static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1632	static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1633
1634	/ For native compilers, these are well-known paths containing*
1635	components that may be provided by the system. For cross
1636	compilers, these paths are not used. /*
1637	static const char *md_exec_prefix = MD_EXEC_PREFIX;
1638	static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1639	static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1640	static const char *const standard_startfile_prefix_1
1641	= STANDARD_STARTFILE_PREFIX_1;
1642	static const char *const standard_startfile_prefix_2
1643	= STANDARD_STARTFILE_PREFIX_2;
1644
1645	/ A relative path to be used in finding the location of tools*
1646	relative to the driver. /*
1647	static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1648
1649	/ A prefix to be used when this is an accelerator compiler. /
1650	static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
1651
1652	/ Subdirectory to use for locating libraries. Set by*
1653	set_multilib_dir based on the compilation options. /*
1654
1655	static const char *multilib_dir;
1656
1657	/ Subdirectory to use for locating libraries in OS conventions. Set by*
1658	set_multilib_dir based on the compilation options. /*
1659
1660	static const char *multilib_os_dir;
1661
1662	/ Subdirectory to use for locating libraries in multiarch conventions. Set by*
1663	set_multilib_dir based on the compilation options. /*
1664
1665	static const char *multiarch_dir;
1666
1667	/ Structure to keep track of the specs that have been defined so far.*
1668	These are accessed using %(specname) in a compiler or link
1669	spec. /*
1670
1671	struct spec_list
1672	{
1673	/ The following 2 fields must be first /
1674	/ to allow EXTRA_SPECS to be initialized /
1675	const char name; /* name of the spec. /
1676	const char ptr; /* available ptr if no static pointer /
1677
1678	/ The following fields are not initialized /
1679	/ by EXTRA_SPECS /
1680	const char *ptr_spec; /* pointer to the spec itself. /
1681	struct spec_list next; /* Next spec in linked list. /
1682	int name_len; / length of the name /
1683	bool user_p; / whether string come from file spec. /
1684	bool alloc_p; / whether string was allocated /
1685	const char default_ptr; /* The default value of ptr_spec. /*
1686	};
1687
1688	#define INIT_STATIC_SPEC(NAME,PTR) \
1689	{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1690	*PTR }
1691
1692	/ List of statically defined specs. /
1693	static struct spec_list static_specs[] =
1694	{
1695	INIT_STATIC_SPEC ("asm", &asm_spec),
1696	INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1697	INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option),
1698	INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1699	INIT_STATIC_SPEC ("asm_options", &asm_options),
1700	INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1701	INIT_STATIC_SPEC ("cpp", &cpp_spec),
1702	INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1703	INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1704	INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1705	INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1706	INIT_STATIC_SPEC ("cc1", &cc1_spec),
1707	INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1708	INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1709	INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1710	INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1711	INIT_STATIC_SPEC ("endfile", &endfile_spec),
1712	INIT_STATIC_SPEC ("link", &link_spec),
1713	INIT_STATIC_SPEC ("lib", &lib_spec),
1714	INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1715	INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1716	INIT_STATIC_SPEC ("startfile", &startfile_spec),
1717	INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1718	INIT_STATIC_SPEC ("version", &compiler_version),
1719	INIT_STATIC_SPEC ("multilib", &multilib_select),
1720	INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1721	INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1722	INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1723	INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1724	INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1725	INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1726	INIT_STATIC_SPEC ("linker", &linker_name_spec),
1727	INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1728	INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1729	INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1730	INIT_STATIC_SPEC ("post_link", &post_link_spec),
1731	INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1732	INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1733	INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1734	INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1735	INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1736	INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1737	INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1738	INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1739	INIT_STATIC_SPEC ("self_spec", &self_spec),
1740	};
1741
1742	#ifdef EXTRA_SPECS /* additional specs needed */
1743	/ Structure to keep track of just the first two args of a spec_list.*
1744	That is all that the EXTRA_SPECS macro gives us. /*
1745	struct spec_list_1
1746	{
1747	const char *const name;
1748	const char *const ptr;
1749	};
1750
1751	static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1752	static struct spec_list extra_specs = (struct* spec_list *) `0`;
1753	#endif
1754
1755	/ List of dynamically allocates specs that have been defined so far. /
1756
1757	static struct spec_list specs = (struct* spec_list *) `0`;
1758
1759	/ List of static spec functions. /
1760
1761	static const struct spec_function static_spec_functions[] =
1762	{
1763	{ .name: "getenv", .func: getenv_spec_function },
1764	{ .name: "if-exists", .func: if_exists_spec_function },
1765	{ .name: "if-exists-else", .func: if_exists_else_spec_function },
1766	{ .name: "if-exists-then-else", .func: if_exists_then_else_spec_function },
1767	{ .name: "sanitize", .func: sanitize_spec_function },
1768	{ .name: "replace-outfile", .func: replace_outfile_spec_function },
1769	{ .name: "remove-outfile", .func: remove_outfile_spec_function },
1770	{ .name: "version-compare", .func: version_compare_spec_function },
1771	{ .name: "include", .func: include_spec_function },
1772	{ .name: "find-file", .func: find_file_spec_function },
1773	{ .name: "find-plugindir", .func: find_plugindir_spec_function },
1774	{ .name: "print-asm-header", .func: print_asm_header_spec_function },
1775	{ .name: "compare-debug-dump-opt", .func: compare_debug_dump_opt_spec_function },
1776	{ .name: "compare-debug-self-opt", .func: compare_debug_self_opt_spec_function },
1777	{ .name: "pass-through-libs", .func: pass_through_libs_spec_func },
1778	{ .name: "dumps", .func: dumps_spec_func },
1779	{ .name: "gt", .func: greater_than_spec_func },
1780	{ .name: "debug-level-gt", .func: debug_level_greater_than_spec_func },
1781	{ .name: "dwarf-version-gt", .func: dwarf_version_greater_than_spec_func },
1782	{ .name: "fortran-preinclude-file", .func: find_fortran_preinclude_file},
1783	{ .name: "join", .func: join_spec_func},
1784	#ifdef EXTRA_SPEC_FUNCTIONS
1785	EXTRA_SPEC_FUNCTIONS
1786	#endif
1787	{ .name: `0`, .func: `0` }
1788	};
1789
1790	static int processing_spec_function;
1791
1792	/ Add appropriate libgcc specs to OBSTACK, taking into account*
1793	various permutations of -shared-libgcc, -shared, and such. /*
1794
1795	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1796
1797	#ifndef USE_LD_AS_NEEDED
1798	#define USE_LD_AS_NEEDED 0
1799	#endif
1800
1801	static void
1802	init_gcc_specs (struct obstack obstack, const* char *shared_name,
1803	const char static_name, const* char *eh_name)
1804	{
1805	char *buf;
1806
1807	#if USE_LD_AS_NEEDED
1808	buf = concat ("%{static\|static-libgcc\|static-pie:", static_name, " ", eh_name, "}"
1809	"%{!static:%{!static-libgcc:%{!static-pie:"
1810	"%{!shared-libgcc:",
1811	static_name, " " LD_AS_NEEDED_OPTION " ",
1812	shared_name, " " LD_NO_AS_NEEDED_OPTION
1813	"}"
1814	"%{shared-libgcc:",
1815	shared_name, "%{!shared: ", static_name, "}"
1816	"}}"
1817	#else
1818	buf = concat ("%{static\|static-libgcc:", static_name, " ", eh_name, "}"
1819	"%{!static:%{!static-libgcc:"
1820	"%{!shared:"
1821	"%{!shared-libgcc:", static_name, " ", eh_name, "}"
1822	"%{shared-libgcc:", shared_name, " ", static_name, "}"
1823	"}"
1824	#ifdef LINK_EH_SPEC
1825	"%{shared:"
1826	"%{shared-libgcc:", shared_name, "}"
1827	"%{!shared-libgcc:", static_name, "}"
1828	"}"
1829	#else
1830	"%{shared:", shared_name, "}"
1831	#endif
1832	#endif
1833	"}}", NULL);
1834
1835	obstack_grow (obstack, buf, strlen (buf));
1836	free (ptr: buf);
1837	}
1838	#endif /* ENABLE_SHARED_LIBGCC */
1839
1840	/ Initialize the specs lookup routines. /
1841
1842	static void
1843	init_spec (void)
1844	{
1845	struct spec_list next = (struct* spec_list *) `0`;
1846	struct spec_list sl = (struct* spec_list *) `0`;
1847	int i;
1848
1849	if (specs)
1850	return; / Already initialized. /
1851
1852	if (verbose_flag)
1853	fnotice (stderr, "Using built-in specs.\n");
1854
1855	#ifdef EXTRA_SPECS
1856	extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1857
1858	for (i = ARRAY_SIZE (extra_specs_1) - `1`; i >= `0`; i--)
1859	{
1860	sl = &extra_specs[i];
1861	sl->name = extra_specs_1[i].name;
1862	sl->ptr = extra_specs_1[i].ptr;
1863	sl->next = next;
1864	sl->name_len = strlen (s: sl->name);
1865	sl->ptr_spec = &sl->ptr;
1866	gcc_assert (sl->ptr_spec != NULL);
1867	sl->default_ptr = sl->ptr;
1868	next = sl;
1869	}
1870	#endif
1871
1872	for (i = ARRAY_SIZE (static_specs) - `1`; i >= `0`; i--)
1873	{
1874	sl = &static_specs[i];
1875	sl->next = next;
1876	next = sl;
1877	}
1878
1879	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1880	/ ??? If neither -shared-libgcc nor --static-libgcc was*
1881	seen, then we should be making an educated guess. Some proposed
1882	heuristics for ELF include:
1883
1884	(1) If "-Wl,--export-dynamic", then it's a fair bet that the
1885	program will be doing dynamic loading, which will likely
1886	need the shared libgcc.
1887
1888	(2) If "-ldl", then it's also a fair bet that we're doing
1889	dynamic loading.
1890
1891	(3) For each ET_DYN we're linking against (either through -lfoo
1892	or /some/path/foo.so), check to see whether it or one of
1893	its dependencies depends on a shared libgcc.
1894
1895	(4) If "-shared"
1896
1897	If the runtime is fixed to look for program headers instead
1898	of calling __register_frame_info at all, for each object,
1899	use the shared libgcc if any EH symbol referenced.
1900
1901	If crtstuff is fixed to not invoke __register_frame_info
1902	automatically, for each object, use the shared libgcc if
1903	any non-empty unwind section found.
1904
1905	Doing any of this probably requires invoking an external program to
1906	do the actual object file scanning. /*
1907	{
1908	const char *p = libgcc_spec;
1909	int in_sep = `1`;
1910
1911	/ Transform the extant libgcc_spec into one that uses the shared libgcc*
1912	when given the proper command line arguments. /*
1913	while (*p)
1914	{
1915	if (in_sep && *p == `'-'` && startswith (str: p, prefix: "-lgcc"))
1916	{
1917	init_gcc_specs (obstack: &obstack,
1918	shared_name: "-lgcc_s"
1919	#ifdef USE_LIBUNWIND_EXCEPTIONS
1920	" -lunwind"
1921	#endif
1922	,
1923	static_name: "-lgcc",
1924	eh_name: "-lgcc_eh"
1925	#ifdef USE_LIBUNWIND_EXCEPTIONS
1926	# ifdef HAVE_LD_STATIC_DYNAMIC
1927	" %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind"
1928	" %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}"
1929	# else
1930	" -lunwind"
1931	# endif
1932	#endif
1933	);
1934
1935	p += `5`;
1936	in_sep = `0`;
1937	}
1938	else if (in_sep && *p == `'l'` && startswith (str: p, prefix: "libgcc.a%s"))
1939	{
1940	/ Ug. We don't know shared library extensions. Hope that*
1941	systems that use this form don't do shared libraries. /*
1942	init_gcc_specs (obstack: &obstack,
1943	shared_name: "-lgcc_s",
1944	static_name: "libgcc.a%s",
1945	eh_name: "libgcc_eh.a%s"
1946	#ifdef USE_LIBUNWIND_EXCEPTIONS
1947	" -lunwind"
1948	#endif
1949	);
1950	p += `10`;
1951	in_sep = `0`;
1952	}
1953	else
1954	{
1955	obstack_1grow (&obstack, *p);
1956	in_sep = (*p == `' '`);
1957	p += `1`;
1958	}
1959	}
1960
1961	obstack_1grow (&obstack, `'\0'`);
1962	libgcc_spec = XOBFINISH (&obstack, const char *);
1963	}
1964	#endif
1965	#ifdef USE_AS_TRADITIONAL_FORMAT
1966	/ Prepend "--traditional-format" to whatever asm_spec we had before. /
1967	{
1968	static const char tf[] = "--traditional-format ";
1969	obstack_grow (&obstack, tf, sizeof (tf) - `1`);
1970	obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1971	asm_spec = XOBFINISH (&obstack, const char *);
1972	}
1973	#endif
1974
1975	#if defined LINK_EH_SPEC \|\| defined LINK_BUILDID_SPEC \|\| \
1976	defined LINKER_HASH_STYLE
1977	# ifdef LINK_BUILDID_SPEC
1978	/ Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. /
1979	obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - `1`);
1980	# endif
1981	# ifdef LINK_EH_SPEC
1982	/ Prepend LINK_EH_SPEC to whatever link_spec we had before. /
1983	obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - `1`);
1984	# endif
1985	# ifdef LINKER_HASH_STYLE
1986	/ Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had*
1987	before. /*
1988	{
1989	static const char hash_style[] = "--hash-style=";
1990	obstack_grow (&obstack, hash_style, sizeof (hash_style) - `1`);
1991	obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - `1`);
1992	obstack_1grow (&obstack, `' '`);
1993	}
1994	# endif
1995	obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1996	link_spec = XOBFINISH (&obstack, const char *);
1997	#endif
1998
1999	specs = sl;
2000	}
2001
2002	/ Update the entry for SPEC in the static_specs table to point to VALUE,*
2003	ensuring that we free the previous value if necessary. Set alloc_p for the
2004	entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
2005	whether we need to free it later on). /*
2006	static void
2007	set_static_spec (const char *spec, const* char value, bool* alloc_p)
2008	{
2009	struct spec_list *sl = NULL;
2010
2011	for (unsigned i = `0`; i < ARRAY_SIZE (static_specs); i++)
2012	{
2013	if (static_specs[i].ptr_spec == spec)
2014	{
2015	sl = static_specs + i;
2016	break;
2017	}
2018	}
2019
2020	gcc_assert (sl);
2021
2022	if (sl->alloc_p)
2023	{
2024	const char old = spec;
2025	free (ptr: const_cast <char *> (old));
2026	}
2027
2028	*spec = value;
2029	sl->alloc_p = alloc_p;
2030	}
2031
2032	/ Update a static spec to a new string, taking ownership of that*
2033	string's memory. /*
2034	static void set_static_spec_owned (const char *spec, const* char *val)
2035	{
2036	return set_static_spec (spec, value: val, alloc_p: true);
2037	}
2038
2039	/ Update a static spec to point to a new value, but don't take*
2040	ownership of (i.e. don't free) that string. /*
2041	static void set_static_spec_shared (const char *spec, const* char *val)
2042	{
2043	return set_static_spec (spec, value: val, alloc_p: false);
2044	}
2045
2046
2047	/ Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is*
2048	removed; If the spec starts with a + then SPEC is added to the end of the
2049	current spec. /*
2050
2051	static void
2052	set_spec (const char name, const* char spec, bool* user_p)
2053	{
2054	struct spec_list *sl;
2055	const char *old_spec;
2056	int name_len = strlen (s: name);
2057	int i;
2058
2059	/ If this is the first call, initialize the statically allocated specs. /
2060	if (!specs)
2061	{
2062	struct spec_list next = (struct* spec_list *) `0`;
2063	for (i = ARRAY_SIZE (static_specs) - `1`; i >= `0`; i--)
2064	{
2065	sl = &static_specs[i];
2066	sl->next = next;
2067	next = sl;
2068	}
2069	specs = sl;
2070	}
2071
2072	/ See if the spec already exists. /
2073	for (sl = specs; sl; sl = sl->next)
2074	if (name_len == sl->name_len && !strcmp (s1: sl->name, s2: name))
2075	break;
2076
2077	if (!sl)
2078	{
2079	/ Not found - make it. /
2080	sl = XNEW (struct spec_list);
2081	sl->name = xstrdup (name);
2082	sl->name_len = name_len;
2083	sl->ptr_spec = &sl->ptr;
2084	sl->alloc_p = `0`;
2085	*(sl->ptr_spec) = "";
2086	sl->next = specs;
2087	sl->default_ptr = NULL;
2088	specs = sl;
2089	}
2090
2091	old_spec = *(sl->ptr_spec);
2092	(sl->ptr_spec) = ((spec[`0`] == `'+'` && ISSPACE ((unsigned* char)spec[`1`]))
2093	? concat (old_spec, spec + `1`, NULL)
2094	: xstrdup (spec));
2095
2096	#ifdef DEBUG_SPECS
2097	if (verbose_flag)
2098	fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
2099	#endif
2100
2101	/ Free the old spec. /
2102	if (old_spec && sl->alloc_p)
2103	free (CONST_CAST (char *, old_spec));
2104
2105	sl->user_p = user_p;
2106	sl->alloc_p = true;
2107	}
2108
2109	/ Accumulate a command (program name and args), and run it. /
2110
2111	typedef const char const_char_p; /* For DEF_VEC_P. /
2112
2113	/ Vector of pointers to arguments in the current line of specifications. /
2114	static vec<const_char_p> argbuf;
2115
2116	/ Likewise, but for the current @file. /
2117	static vec<const_char_p> at_file_argbuf;
2118
2119	/ Whether an @file is currently open. /
2120	static bool in_at_file = false;
2121
2122	/ Were the options -c, -S or -E passed. /
2123	static int have_c = `0`;
2124
2125	/ Was the option -o passed. /
2126	static int have_o = `0`;
2127
2128	/ Was the option -E passed. /
2129	static int have_E = `0`;
2130
2131	/ Pointer to output file name passed in with -o. /
2132	static const char *output_file = `0`;
2133
2134	/ This is the list of suffixes and codes (%g/%u/%U/%j) and the associated*
2135	temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2136	it here. /*
2137
2138	static struct temp_name {
2139	const char suffix; /* suffix associated with the code. /
2140	int length; / strlen (suffix). /
2141	int unique; / Indicates whether %g or %u/%U was used. /
2142	const char filename; /* associated filename. /
2143	int filename_length; / strlen (filename). /
2144	struct temp_name *next;
2145	} *temp_names;
2146
2147	/ Number of commands executed so far. /
2148
2149	static int execution_count;
2150
2151	/ Number of commands that exited with a signal. /
2152
2153	static int signal_count;
2154
2155	/ Allocate the argument vector. /
2156
2157	static void
2158	alloc_args (void)
2159	{
2160	argbuf.create (nelems: `10`);
2161	at_file_argbuf.create (nelems: `10`);
2162	}
2163
2164	/ Clear out the vector of arguments (after a command is executed). /
2165
2166	static void
2167	clear_args (void)
2168	{
2169	argbuf.truncate (size: `0`);
2170	at_file_argbuf.truncate (size: `0`);
2171	}
2172
2173	/ Add one argument to the vector at the end.*
2174	This is done when a space is seen or at the end of the line.
2175	If DELETE_ALWAYS is nonzero, the arg is a filename
2176	and the file should be deleted eventually.
2177	If DELETE_FAILURE is nonzero, the arg is a filename
2178	and the file should be deleted if this compilation fails. /*
2179
2180	static void
2181	store_arg (const char arg, int* delete_always, int delete_failure)
2182	{
2183	if (in_at_file)
2184	at_file_argbuf.safe_push (obj: arg);
2185	else
2186	argbuf.safe_push (obj: arg);
2187
2188	if (delete_always \|\| delete_failure)
2189	{
2190	const char *p;
2191	/ If the temporary file we should delete is specified as*
2192	part of a joined argument extract the filename. /*
2193	if (arg[`0`] == `'-'`
2194	&& (p = strrchr (s: arg, c: `'='`)))
2195	arg = p + `1`;
2196	record_temp_file (arg, delete_always, delete_failure);
2197	}
2198	}
2199
2200	/ Open a temporary @file into which subsequent arguments will be stored. /
2201
2202	static void
2203	open_at_file (void)
2204	{
2205	if (in_at_file)
2206	fatal_error (input_location, "cannot open nested response file");
2207	else
2208	in_at_file = true;
2209	}
2210
2211	/ Create a temporary @file name. /
2212
2213	static char make_at_file (void*)
2214	{
2215	static int fileno = `0`;
2216	char filename[`20`];
2217	const char base, ext;
2218
2219	if (!save_temps_flag)
2220	return make_temp_file ("");
2221
2222	base = dumpbase;
2223	if (!(base && *base))
2224	base = dumpdir;
2225	if (!(base && *base))
2226	base = "a";
2227
2228	sprintf (s: filename, format: ".args.%d", fileno++);
2229	ext = filename;
2230
2231	if (base == dumpdir && dumpdir_trailing_dash_added)
2232	ext++;
2233
2234	return concat (base, ext, NULL);
2235	}
2236
2237	/ Close the temporary @file and add @file to the argument list. /
2238
2239	static void
2240	close_at_file (void)
2241	{
2242	if (!in_at_file)
2243	fatal_error (input_location, "cannot close nonexistent response file");
2244
2245	in_at_file = false;
2246
2247	const unsigned int n_args = at_file_argbuf.length ();
2248	if (n_args == `0`)
2249	return;
2250
2251	char *argv = XALLOCAVEC (char* *, n_args + `1`);
2252	char *temp_file = make_at_file ();
2253	char *at_argument = concat ("@", temp_file, NULL);
2254	FILE *f = fopen (filename: temp_file, modes: "w");
2255	int status;
2256	unsigned int i;
2257
2258	/ Copy the strings over. /
2259	for (i = `0`; i < n_args; i++)
2260	argv[i] = CONST_CAST (char *, at_file_argbuf[i]);
2261	argv[i] = NULL;
2262
2263	at_file_argbuf.truncate (size: `0`);
2264
2265	if (f == NULL)
2266	fatal_error (input_location, "could not open temporary response file %s",
2267	temp_file);
2268
2269	status = writeargv (argv, f);
2270
2271	if (status)
2272	fatal_error (input_location,
2273	"could not write to temporary response file %s",
2274	temp_file);
2275
2276	status = fclose (stream: f);
2277
2278	if (status == EOF)
2279	fatal_error (input_location, "could not close temporary response file %s",
2280	temp_file);
2281
2282	store_arg (arg: at_argument, delete_always: `0`, delete_failure: `0`);
2283
2284	record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
2285	}
2286
2287	/ Load specs from a file name named FILENAME, replacing occurrences of*
2288	various different types of line-endings, \r\n, \n\r and just \r, with
2289	a single \n. /*
2290
2291	static char *
2292	load_specs (const char *filename)
2293	{
2294	int desc;
2295	int readlen;
2296	struct stat statbuf;
2297	char *buffer;
2298	char *buffer_p;
2299	char *specs;
2300	char *specs_p;
2301
2302	if (verbose_flag)
2303	fnotice (stderr, "Reading specs from %s\n", filename);
2304
2305	/ Open and stat the file. /
2306	desc = open (file: filename, O_RDONLY, `0`);
2307	if (desc < `0`)
2308	{
2309	failed:
2310	/ This leaves DESC open, but the OS will save us. /
2311	fatal_error (input_location, "cannot read spec file %qs: %m", filename);
2312	}
2313
2314	if (stat (file: filename, buf: &statbuf) < `0`)
2315	goto failed;
2316
2317	/ Read contents of file into BUFFER. /
2318	buffer = XNEWVEC (char, statbuf.st_size + `1`);
2319	readlen = read (fd: desc, buf: buffer, nbytes: (unsigned) statbuf.st_size);
2320	if (readlen < `0`)
2321	goto failed;
2322	buffer[readlen] = `0`;
2323	close (fd: desc);
2324
2325	specs = XNEWVEC (char, readlen + `1`);
2326	specs_p = specs;
2327	for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2328	{
2329	int skip = `0`;
2330	char c = *buffer_p;
2331	if (c == `'\r'`)
2332	{
2333	if (buffer_p > buffer && (buffer_p - `1`) == `'\n'`) /* \n\r /
2334	skip = `1`;
2335	else if ((buffer_p + `1`) == `'\n'`) /* \r\n /
2336	skip = `1`;
2337	else / \r /
2338	c = `'\n'`;
2339	}
2340	if (! skip)
2341	*specs_p++ = c;
2342	}
2343	*specs_p = `'\0'`;
2344
2345	free (ptr: buffer);
2346	return (specs);
2347	}
2348
2349	/ Read compilation specs from a file named FILENAME,*
2350	replacing the default ones.
2351
2352	A suffix which starts with `' is a definition for*
2353	one of the machine-specific sub-specs. The "suffix" should be
2354	asm, cc1, cpp, link, *startfile, etc.
2355	The corresponding spec is stored in asm_spec, etc.,
2356	rather than in the `compilers' vector.
2357
2358	Anything invalid in the file is a fatal error. /*
2359
2360	static void
2361	read_specs (const char filename, bool* main_p, bool user_p)
2362	{
2363	char *buffer;
2364	char *p;
2365
2366	buffer = load_specs (filename);
2367
2368	/ Scan BUFFER for specs, putting them in the vector. /
2369	p = buffer;
2370	while (`1`)
2371	{
2372	char *suffix;
2373	char *spec;
2374	char in, out, p1, p2, *p3;
2375
2376	/ Advance P in BUFFER to the next nonblank nocomment line. /
2377	p = skip_whitespace (p);
2378	if (*p == `0`)
2379	break;
2380
2381	/ Is this a special command that starts with '%'? /
2382	/ Don't allow this for the main specs file, since it would*
2383	encourage people to overwrite it. /*
2384	if (*p == `'%'` && !main_p)
2385	{
2386	p1 = p;
2387	while (p && p != `'\n'`)
2388	p++;
2389
2390	/ Skip '\n'. /
2391	p++;
2392
2393	if (startswith (str: p1, prefix: "%include")
2394	&& (p1[sizeof "%include" - `1`] == `' '`
2395	\|\| p1[sizeof "%include" - `1`] == `'\t'`))
2396	{
2397	char *new_filename;
2398
2399	p1 += sizeof ("%include");
2400	while (p1 == `' '` \|\| p1 == `'\t'`)
2401	p1++;
2402
2403	if (*p1++ != `'<'` \|\| p[-`2`] != `'>'`)
2404	fatal_error (input_location,
2405	"specs %%include syntax malformed after "
2406	"%ld characters",
2407	(long) (p1 - buffer + `1`));
2408
2409	p[-`2`] = `'\0'`;
2410	new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2411	read_specs (filename: new_filename ? new_filename : p1, main_p: false, user_p);
2412	continue;
2413	}
2414	else if (startswith (str: p1, prefix: "%include_noerr")
2415	&& (p1[sizeof "%include_noerr" - `1`] == `' '`
2416	\|\| p1[sizeof "%include_noerr" - `1`] == `'\t'`))
2417	{
2418	char *new_filename;
2419
2420	p1 += sizeof "%include_noerr";
2421	while (p1 == `' '` \|\| p1 == `'\t'`)
2422	p1++;
2423
2424	if (*p1++ != `'<'` \|\| p[-`2`] != `'>'`)
2425	fatal_error (input_location,
2426	"specs %%include syntax malformed after "
2427	"%ld characters",
2428	(long) (p1 - buffer + `1`));
2429
2430	p[-`2`] = `'\0'`;
2431	new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2432	if (new_filename)
2433	read_specs (filename: new_filename, main_p: false, user_p);
2434	else if (verbose_flag)
2435	fnotice (stderr, "could not find specs file %s\n", p1);
2436	continue;
2437	}
2438	else if (startswith (str: p1, prefix: "%rename")
2439	&& (p1[sizeof "%rename" - `1`] == `' '`
2440	\|\| p1[sizeof "%rename" - `1`] == `'\t'`))
2441	{
2442	int name_len;
2443	struct spec_list *sl;
2444	struct spec_list *newsl;
2445
2446	/ Get original name. /
2447	p1 += sizeof "%rename";
2448	while (p1 == `' '` \|\| p1 == `'\t'`)
2449	p1++;
2450
2451	if (! ISALPHA ((unsigned char) *p1))
2452	fatal_error (input_location,
2453	"specs %%rename syntax malformed after "
2454	"%ld characters",
2455	(long) (p1 - buffer));
2456
2457	p2 = p1;
2458	while (p2 && !ISSPACE ((unsigned* char) *p2))
2459	p2++;
2460
2461	if (p2 != `' '` && p2 != `'\t'`)
2462	fatal_error (input_location,
2463	"specs %%rename syntax malformed after "
2464	"%ld characters",
2465	(long) (p2 - buffer));
2466
2467	name_len = p2 - p1;
2468	*p2++ = `'\0'`;
2469	while (p2 == `' '` \|\| p2 == `'\t'`)
2470	p2++;
2471
2472	if (! ISALPHA ((unsigned char) *p2))
2473	fatal_error (input_location,
2474	"specs %%rename syntax malformed after "
2475	"%ld characters",
2476	(long) (p2 - buffer));
2477
2478	/ Get new spec name. /
2479	p3 = p2;
2480	while (p3 && !ISSPACE ((unsigned* char) *p3))
2481	p3++;
2482
2483	if (p3 != p - `1`)
2484	fatal_error (input_location,
2485	"specs %%rename syntax malformed after "
2486	"%ld characters",
2487	(long) (p3 - buffer));
2488	*p3 = `'\0'`;
2489
2490	for (sl = specs; sl; sl = sl->next)
2491	if (name_len == sl->name_len && !strcmp (s1: sl->name, s2: p1))
2492	break;
2493
2494	if (!sl)
2495	fatal_error (input_location,
2496	"specs %s spec was not found to be renamed", p1);
2497
2498	if (strcmp (s1: p1, s2: p2) == `0`)
2499	continue;
2500
2501	for (newsl = specs; newsl; newsl = newsl->next)
2502	if (strcmp (s1: newsl->name, s2: p2) == `0`)
2503	fatal_error (input_location,
2504	"%s: attempt to rename spec %qs to "
2505	"already defined spec %qs",
2506	filename, p1, p2);
2507
2508	if (verbose_flag)
2509	{
2510	fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2511	#ifdef DEBUG_SPECS
2512	fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2513	#endif
2514	}
2515
2516	set_spec (name: p2, spec: *(sl->ptr_spec), user_p);
2517	if (sl->alloc_p)
2518	free (CONST_CAST (char , (sl->ptr_spec)));
2519
2520	*(sl->ptr_spec) = "";
2521	sl->alloc_p = `0`;
2522	continue;
2523	}
2524	else
2525	fatal_error (input_location,
2526	"specs unknown %% command after %ld characters",
2527	(long) (p1 - buffer));
2528	}
2529
2530	/ Find the colon that should end the suffix. /
2531	p1 = p;
2532	while (p1 && p1 != `':'` && *p1 != `'\n'`)
2533	p1++;
2534
2535	/ The colon shouldn't be missing. /
2536	if (*p1 != `':'`)
2537	fatal_error (input_location,
2538	"specs file malformed after %ld characters",
2539	(long) (p1 - buffer));
2540
2541	/ Skip back over trailing whitespace. /
2542	p2 = p1;
2543	while (p2 > buffer && (p2[-`1`] == `' '` \|\| p2[-`1`] == `'\t'`))
2544	p2--;
2545
2546	/ Copy the suffix to a string. /
2547	suffix = save_string (p, p2 - p);
2548	/ Find the next line. /
2549	p = skip_whitespace (p: p1 + `1`);
2550	if (p[`1`] == `0`)
2551	fatal_error (input_location,
2552	"specs file malformed after %ld characters",
2553	(long) (p - buffer));
2554
2555	p1 = p;
2556	/ Find next blank line or end of string. /
2557	while (p1 && !(p1 == `'\n'` && (p1[`1`] == `'\n'` \|\| p1[`1`] == `'\0'`)))
2558	p1++;
2559
2560	/ Specs end at the blank line and do not include the newline. /
2561	spec = save_string (p, p1 - p);
2562	p = p1;
2563
2564	/ Delete backslash-newline sequences from the spec. /
2565	in = spec;
2566	out = spec;
2567	while (*in != `0`)
2568	{
2569	if (in[`0`] == `'\\'` && in[`1`] == `'\n'`)
2570	in += `2`;
2571	else if (in[`0`] == `'#'`)
2572	while (in && in != `'\n'`)
2573	in++;
2574
2575	else
2576	out++ = in++;
2577	}
2578	*out = `0`;
2579
2580	if (suffix[`0`] == `'*'`)
2581	{
2582	if (! strcmp (s1: suffix, s2: "*link_command"))
2583	link_command_spec = spec;
2584	else
2585	{
2586	set_spec (name: suffix + `1`, spec, user_p);
2587	free (ptr: spec);
2588	}
2589	}
2590	else
2591	{
2592	/ Add this pair to the vector. /
2593	compilers
2594	= XRESIZEVEC (struct compiler, compilers, n_compilers + `2`);
2595
2596	compilers[n_compilers].suffix = suffix;
2597	compilers[n_compilers].spec = spec;
2598	n_compilers++;
2599	memset (s: &compilers[n_compilers], c: `0`, n: sizeof compilers[n_compilers]);
2600	}
2601
2602	if (*suffix == `0`)
2603	link_command_spec = spec;
2604	}
2605
2606	if (link_command_spec == `0`)
2607	fatal_error (input_location, "spec file has no spec for linking");
2608
2609	XDELETEVEC (buffer);
2610	}
2611
2612	/ Record the names of temporary files we tell compilers to write,*
2613	and delete them at the end of the run. /*
2614
2615	/ This is the common prefix we use to make temp file names.*
2616	It is chosen once for each run of this program.
2617	It is substituted into a spec by %g or %j.
2618	Thus, all temp file names contain this prefix.
2619	In practice, all temp file names start with this prefix.
2620
2621	This prefix comes from the envvar TMPDIR if it is defined;
2622	otherwise, from the P_tmpdir macro if that is defined;
2623	otherwise, in /usr/tmp or /tmp;
2624	or finally the current directory if all else fails. /*
2625
2626	static const char *temp_filename;
2627
2628	/ Length of the prefix. /
2629
2630	static int temp_filename_length;
2631
2632	/ Define the list of temporary files to delete. /
2633
2634	struct temp_file
2635	{
2636	const char *name;
2637	struct temp_file *next;
2638	};
2639
2640	/ Queue of files to delete on success or failure of compilation. /
2641	static struct temp_file *always_delete_queue;
2642	/ Queue of files to delete on failure of compilation. /
2643	static struct temp_file *failure_delete_queue;
2644
2645	/ Record FILENAME as a file to be deleted automatically.*
2646	ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2647	otherwise delete it in any case.
2648	FAIL_DELETE nonzero means delete it if a compilation step fails;
2649	otherwise delete it in any case. /*
2650
2651	void
2652	record_temp_file (const char filename, int* always_delete, int fail_delete)
2653	{
2654	char *const name = xstrdup (filename);
2655
2656	if (always_delete)
2657	{
2658	struct temp_file *temp;
2659	for (temp = always_delete_queue; temp; temp = temp->next)
2660	if (! filename_cmp (s1: name, s2: temp->name))
2661	{
2662	free (ptr: name);
2663	goto already1;
2664	}
2665
2666	temp = XNEW (struct temp_file);
2667	temp->next = always_delete_queue;
2668	temp->name = name;
2669	always_delete_queue = temp;
2670
2671	already1:;
2672	}
2673
2674	if (fail_delete)
2675	{
2676	struct temp_file *temp;
2677	for (temp = failure_delete_queue; temp; temp = temp->next)
2678	if (! filename_cmp (s1: name, s2: temp->name))
2679	{
2680	free (ptr: name);
2681	goto already2;
2682	}
2683
2684	temp = XNEW (struct temp_file);
2685	temp->next = failure_delete_queue;
2686	temp->name = name;
2687	failure_delete_queue = temp;
2688
2689	already2:;
2690	}
2691	}
2692
2693	/ Delete all the temporary files whose names we previously recorded. /
2694
2695	#ifndef DELETE_IF_ORDINARY
2696	#define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2697	do \
2698	{ \
2699	if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2700	if (unlink (NAME) < 0) \
2701	if (VERBOSE_FLAG) \
2702	error ("%s: %m", (NAME)); \
2703	} while (0)
2704	#endif
2705
2706	static void
2707	delete_if_ordinary (const char *name)
2708	{
2709	struct stat st;
2710	#ifdef DEBUG
2711	int i, c;
2712
2713	printf ("Delete %s? (y or n) ", name);
2714	fflush (stdout);
2715	i = getchar ();
2716	if (i != `'\n'`)
2717	while ((c = getchar ()) != `'\n'` && c != EOF)
2718	;
2719
2720	if (i == `'y'` \|\| i == `'Y'`)
2721	#endif /* DEBUG */
2722	DELETE_IF_ORDINARY (name, st, verbose_flag);
2723	}
2724
2725	static void
2726	delete_temp_files (void)
2727	{
2728	struct temp_file *temp;
2729
2730	for (temp = always_delete_queue; temp; temp = temp->next)
2731	delete_if_ordinary (name: temp->name);
2732	always_delete_queue = `0`;
2733	}
2734
2735	/ Delete all the files to be deleted on error. /
2736
2737	static void
2738	delete_failure_queue (void)
2739	{
2740	struct temp_file *temp;
2741
2742	for (temp = failure_delete_queue; temp; temp = temp->next)
2743	delete_if_ordinary (name: temp->name);
2744	}
2745
2746	static void
2747	clear_failure_queue (void)
2748	{
2749	failure_delete_queue = `0`;
2750	}
2751
2752	/ Call CALLBACK for each path in PATHS, breaking out early if CALLBACK*
2753	returns non-NULL.
2754	If DO_MULTI is true iterate over the paths twice, first with multilib
2755	suffix then without, otherwise iterate over the paths once without
2756	adding a multilib suffix. When DO_MULTI is true, some attempt is made
2757	to avoid visiting the same path twice, but we could do better. For
2758	instance, /usr/lib/../lib is considered different from /usr/lib.
2759	At least EXTRA_SPACE chars past the end of the path passed to
2760	CALLBACK are available for use by the callback.
2761	CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2762
2763	Returns the value returned by CALLBACK. /*
2764
2765	static void *
2766	for_each_path (const struct path_prefix *paths,
2767	bool do_multi,
2768	size_t extra_space,
2769	void (callback) (char , void* *),
2770	void *callback_info)
2771	{
2772	struct prefix_list *pl;
2773	const char *multi_dir = NULL;
2774	const char *multi_os_dir = NULL;
2775	const char *multiarch_suffix = NULL;
2776	const char *multi_suffix;
2777	const char *just_multi_suffix;
2778	char *path = NULL;
2779	void *ret = NULL;
2780	bool skip_multi_dir = false;
2781	bool skip_multi_os_dir = false;
2782
2783	multi_suffix = machine_suffix;
2784	just_multi_suffix = just_machine_suffix;
2785	if (do_multi && multilib_dir && strcmp (s1: multilib_dir, s2: ".") != `0`)
2786	{
2787	multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2788	multi_suffix = concat (multi_suffix, multi_dir, NULL);
2789	just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2790	}
2791	if (do_multi && multilib_os_dir && strcmp (s1: multilib_os_dir, s2: ".") != `0`)
2792	multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2793	if (multiarch_dir)
2794	multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2795
2796	while (`1`)
2797	{
2798	size_t multi_dir_len = `0`;
2799	size_t multi_os_dir_len = `0`;
2800	size_t multiarch_len = `0`;
2801	size_t suffix_len;
2802	size_t just_suffix_len;
2803	size_t len;
2804
2805	if (multi_dir)
2806	multi_dir_len = strlen (s: multi_dir);
2807	if (multi_os_dir)
2808	multi_os_dir_len = strlen (s: multi_os_dir);
2809	if (multiarch_suffix)
2810	multiarch_len = strlen (s: multiarch_suffix);
2811	suffix_len = strlen (s: multi_suffix);
2812	just_suffix_len = strlen (s: just_multi_suffix);
2813
2814	if (path == NULL)
2815	{
2816	len = paths->max_len + extra_space + `1`;
2817	len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2818	path = XNEWVEC (char, len);
2819	}
2820
2821	for (pl = paths->plist; pl != `0`; pl = pl->next)
2822	{
2823	len = strlen (s: pl->prefix);
2824	memcpy (dest: path, src: pl->prefix, n: len);
2825
2826	/ Look first in MACHINE/VERSION subdirectory. /
2827	if (!skip_multi_dir)
2828	{
2829	memcpy (dest: path + len, src: multi_suffix, n: suffix_len + `1`);
2830	ret = callback (path, callback_info);
2831	if (ret)
2832	break;
2833	}
2834
2835	/ Some paths are tried with just the machine (ie. target)*
2836	subdir. This is used for finding as, ld, etc. /*
2837	if (!skip_multi_dir
2838	&& pl->require_machine_suffix == `2`)
2839	{
2840	memcpy (dest: path + len, src: just_multi_suffix, n: just_suffix_len + `1`);
2841	ret = callback (path, callback_info);
2842	if (ret)
2843	break;
2844	}
2845
2846	/ Now try the multiarch path. /
2847	if (!skip_multi_dir
2848	&& !pl->require_machine_suffix && multiarch_dir)
2849	{
2850	memcpy (dest: path + len, src: multiarch_suffix, n: multiarch_len + `1`);
2851	ret = callback (path, callback_info);
2852	if (ret)
2853	break;
2854	}
2855
2856	/ Now try the base path. /
2857	if (!pl->require_machine_suffix
2858	&& !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2859	{
2860	const char *this_multi;
2861	size_t this_multi_len;
2862
2863	if (pl->os_multilib)
2864	{
2865	this_multi = multi_os_dir;
2866	this_multi_len = multi_os_dir_len;
2867	}
2868	else
2869	{
2870	this_multi = multi_dir;
2871	this_multi_len = multi_dir_len;
2872	}
2873
2874	if (this_multi_len)
2875	memcpy (dest: path + len, src: this_multi, n: this_multi_len + `1`);
2876	else
2877	path[len] = `'\0'`;
2878
2879	ret = callback (path, callback_info);
2880	if (ret)
2881	break;
2882	}
2883	}
2884	if (pl)
2885	break;
2886
2887	if (multi_dir == NULL && multi_os_dir == NULL)
2888	break;
2889
2890	/ Run through the paths again, this time without multilibs.*
2891	Don't repeat any we have already seen. /*
2892	if (multi_dir)
2893	{
2894	free (CONST_CAST (char *, multi_dir));
2895	multi_dir = NULL;
2896	free (CONST_CAST (char *, multi_suffix));
2897	multi_suffix = machine_suffix;
2898	free (CONST_CAST (char *, just_multi_suffix));
2899	just_multi_suffix = just_machine_suffix;
2900	}
2901	else
2902	skip_multi_dir = true;
2903	if (multi_os_dir)
2904	{
2905	free (CONST_CAST (char *, multi_os_dir));
2906	multi_os_dir = NULL;
2907	}
2908	else
2909	skip_multi_os_dir = true;
2910	}
2911
2912	if (multi_dir)
2913	{
2914	free (CONST_CAST (char *, multi_dir));
2915	free (CONST_CAST (char *, multi_suffix));
2916	free (CONST_CAST (char *, just_multi_suffix));
2917	}
2918	if (multi_os_dir)
2919	free (CONST_CAST (char *, multi_os_dir));
2920	if (ret != path)
2921	free (ptr: path);
2922	return ret;
2923	}
2924
2925	/ Callback for build_search_list. Adds path to obstack being built. /
2926
2927	struct add_to_obstack_info {
2928	struct obstack *ob;
2929	bool check_dir;
2930	bool first_time;
2931	};
2932
2933	static void *
2934	add_to_obstack (char path, void* *data)
2935	{
2936	struct add_to_obstack_info info = (struct* add_to_obstack_info *) data;
2937
2938	if (info->check_dir && !is_directory (path, false))
2939	return NULL;
2940
2941	if (!info->first_time)
2942	obstack_1grow (info->ob, PATH_SEPARATOR);
2943
2944	obstack_grow (info->ob, path, strlen (path));
2945
2946	info->first_time = false;
2947	return NULL;
2948	}
2949
2950	/ Add or change the value of an environment variable, outputting the*
2951	change to standard error if in verbose mode. /*
2952	static void
2953	xputenv (const char *string)
2954	{
2955	env.xput (string);
2956	}
2957
2958	/ Build a list of search directories from PATHS.*
2959	PREFIX is a string to prepend to the list.
2960	If CHECK_DIR_P is true we ensure the directory exists.
2961	If DO_MULTI is true, multilib paths are output first, then
2962	non-multilib paths.
2963	This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2964	It is also used by the --print-search-dirs flag. /*
2965
2966	static char *
2967	build_search_list (const struct path_prefix paths, const* char *prefix,
2968	bool check_dir, bool do_multi)
2969	{
2970	struct add_to_obstack_info info;
2971
2972	info.ob = &collect_obstack;
2973	info.check_dir = check_dir;
2974	info.first_time = true;
2975
2976	obstack_grow (&collect_obstack, prefix, strlen (prefix));
2977	obstack_1grow (&collect_obstack, `'='`);
2978
2979	for_each_path (paths, do_multi, extra_space: `0`, callback: add_to_obstack, callback_info: &info);
2980
2981	obstack_1grow (&collect_obstack, `'\0'`);
2982	return XOBFINISH (&collect_obstack, char *);
2983	}
2984
2985	/ Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables*
2986	for collect. /*
2987
2988	static void
2989	putenv_from_prefixes (const struct path_prefix paths, const* char *env_var,
2990	bool do_multi)
2991	{
2992	xputenv (string: build_search_list (paths, prefix: env_var, check_dir: true, do_multi));
2993	}
2994
2995	/ Check whether NAME can be accessed in MODE. This is like access,*
2996	except that it never considers directories to be executable. /*
2997
2998	static int
2999	access_check (const char name, int* mode)
3000	{
3001	if (mode == X_OK)
3002	{
3003	struct stat st;
3004
3005	if (stat (file: name, buf: &st) < `0`
3006	\|\| S_ISDIR (st.st_mode))
3007	return -`1`;
3008	}
3009
3010	return access (name: name, type: mode);
3011	}
3012
3013	/ Callback for find_a_file. Appends the file name to the directory*
3014	path. If the resulting file exists in the right mode, return the
3015	full pathname to the file. /*
3016
3017	struct file_at_path_info {
3018	const char *name;
3019	const char *suffix;
3020	int name_len;
3021	int suffix_len;
3022	int mode;
3023	};
3024
3025	static void *
3026	file_at_path (char path, void* *data)
3027	{
3028	struct file_at_path_info info = (struct* file_at_path_info *) data;
3029	size_t len = strlen (s: path);
3030
3031	memcpy (dest: path + len, src: info->name, n: info->name_len);
3032	len += info->name_len;
3033
3034	/ Some systems have a suffix for executable files.*
3035	So try appending that first. /*
3036	if (info->suffix_len)
3037	{
3038	memcpy (dest: path + len, src: info->suffix, n: info->suffix_len + `1`);
3039	if (access_check (name: path, mode: info->mode) == `0`)
3040	return path;
3041	}
3042
3043	path[len] = `'\0'`;
3044	if (access_check (name: path, mode: info->mode) == `0`)
3045	return path;
3046
3047	return NULL;
3048	}
3049
3050	/ Search for NAME using the prefix list PREFIXES. MODE is passed to*
3051	access to check permissions. If DO_MULTI is true, search multilib
3052	paths then non-multilib paths, otherwise do not search multilib paths.
3053	Return 0 if not found, otherwise return its name, allocated with malloc. /*
3054
3055	static char *
3056	find_a_file (const struct path_prefix pprefix, const* char name, int* mode,
3057	bool do_multi)
3058	{
3059	struct file_at_path_info info;
3060
3061	/ Find the filename in question (special case for absolute paths). /
3062
3063	if (IS_ABSOLUTE_PATH (name))
3064	{
3065	if (access (name: name, type: mode) == `0`)
3066	return xstrdup (name);
3067
3068	return NULL;
3069	}
3070
3071	info.name = name;
3072	info.suffix = (mode & X_OK) != `0` ? HOST_EXECUTABLE_SUFFIX : "";
3073	info.name_len = strlen (s: info.name);
3074	info.suffix_len = strlen (s: info.suffix);
3075	info.mode = mode;
3076
3077	return (char*) for_each_path (paths: pprefix, do_multi,
3078	extra_space: info.name_len + info.suffix_len,
3079	callback: file_at_path, callback_info: &info);
3080	}
3081
3082	/ Specialization of find_a_file for programs that also takes into account*
3083	configure-specified default programs. /*
3084
3085	static char*
3086	find_a_program (const char *name)
3087	{
3088	/ Do not search if default matches query. /
3089
3090	#ifdef DEFAULT_ASSEMBLER
3091	if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, X_OK) == `0`)
3092	return xstrdup (DEFAULT_ASSEMBLER);
3093	#endif
3094
3095	#ifdef DEFAULT_LINKER
3096	if (! strcmp (name, "ld") && access (DEFAULT_LINKER, X_OK) == `0`)
3097	return xstrdup (DEFAULT_LINKER);
3098	#endif
3099
3100	#ifdef DEFAULT_DSYMUTIL
3101	if (! strcmp (name, "dsymutil") && access (DEFAULT_DSYMUTIL, X_OK) == `0`)
3102	return xstrdup (DEFAULT_DSYMUTIL);
3103	#endif
3104
3105	return find_a_file (pprefix: &exec_prefixes, name, X_OK, do_multi: false);
3106	}
3107
3108	/ Ranking of prefixes in the sort list. -B prefixes are put before*
3109	all others. /*
3110
3111	enum path_prefix_priority
3112	{
3113	PREFIX_PRIORITY_B_OPT,
3114	PREFIX_PRIORITY_LAST
3115	};
3116
3117	/ Add an entry for PREFIX in PLIST. The PLIST is kept in ascending*
3118	order according to PRIORITY. Within each PRIORITY, new entries are
3119	appended.
3120
3121	If WARN is nonzero, we will warn if no file is found
3122	through this prefix. WARN should point to an int
3123	which will be set to 1 if this entry is used.
3124
3125	COMPONENT is the value to be passed to update_path.
3126
3127	REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3128	the complete value of machine_suffix.
3129	2 means try both machine_suffix and just_machine_suffix. /*
3130
3131	static void
3132	add_prefix (struct path_prefix pprefix, const* char *prefix,
3133	const char component, /* enum prefix_priority / int priority,
3134	int require_machine_suffix, int os_multilib)
3135	{
3136	struct prefix_list pl, *prev;
3137	int len;
3138
3139	for (prev = &pprefix->plist;
3140	(prev) != NULL && (prev)->priority <= priority;
3141	prev = &(*prev)->next)
3142	;
3143
3144	/ Keep track of the longest prefix. /
3145
3146	prefix = update_path (path: prefix, key: component);
3147	len = strlen (s: prefix);
3148	if (len > pprefix->max_len)
3149	pprefix->max_len = len;
3150
3151	pl = XNEW (struct prefix_list);
3152	pl->prefix = prefix;
3153	pl->require_machine_suffix = require_machine_suffix;
3154	pl->priority = priority;
3155	pl->os_multilib = os_multilib;
3156
3157	/ Insert after PREV. /
3158	pl->next = (*prev);
3159	(*prev) = pl;
3160	}
3161
3162	/ Same as add_prefix, but prepending target_system_root to prefix. /
3163	/ The target_system_root prefix has been relocated by gcc_exec_prefix. /
3164	static void
3165	add_sysrooted_prefix (struct path_prefix pprefix, const* char *prefix,
3166	const char *component,
3167	/ enum prefix_priority / int priority,
3168	int require_machine_suffix, int os_multilib)
3169	{
3170	if (!IS_ABSOLUTE_PATH (prefix))
3171	fatal_error (input_location, "system path %qs is not absolute", prefix);
3172
3173	if (target_system_root)
3174	{
3175	char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3176	size_t sysroot_len = strlen (s: target_system_root);
3177
3178	if (sysroot_len > `0`
3179	&& target_system_root[sysroot_len - `1`] == DIR_SEPARATOR)
3180	sysroot_no_trailing_dir_separator[sysroot_len - `1`] = `'\0'`;
3181
3182	if (target_sysroot_suffix)
3183	prefix = concat (sysroot_no_trailing_dir_separator,
3184	target_sysroot_suffix, prefix, NULL);
3185	else
3186	prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3187
3188	free (ptr: sysroot_no_trailing_dir_separator);
3189
3190	/ We have to override this because GCC's notion of sysroot*
3191	moves along with GCC. /*
3192	component = "GCC";
3193	}
3194
3195	add_prefix (pprefix, prefix, component, priority,
3196	require_machine_suffix, os_multilib);
3197	}
3198
3199	/ Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. /
3200
3201	static void
3202	add_sysrooted_hdrs_prefix (struct path_prefix pprefix, const* char *prefix,
3203	const char *component,
3204	/ enum prefix_priority / int priority,
3205	int require_machine_suffix, int os_multilib)
3206	{
3207	if (!IS_ABSOLUTE_PATH (prefix))
3208	fatal_error (input_location, "system path %qs is not absolute", prefix);
3209
3210	if (target_system_root)
3211	{
3212	char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3213	size_t sysroot_len = strlen (s: target_system_root);
3214
3215	if (sysroot_len > `0`
3216	&& target_system_root[sysroot_len - `1`] == DIR_SEPARATOR)
3217	sysroot_no_trailing_dir_separator[sysroot_len - `1`] = `'\0'`;
3218
3219	if (target_sysroot_hdrs_suffix)
3220	prefix = concat (sysroot_no_trailing_dir_separator,
3221	target_sysroot_hdrs_suffix, prefix, NULL);
3222	else
3223	prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3224
3225	free (ptr: sysroot_no_trailing_dir_separator);
3226
3227	/ We have to override this because GCC's notion of sysroot*
3228	moves along with GCC. /*
3229	component = "GCC";
3230	}
3231
3232	add_prefix (pprefix, prefix, component, priority,
3233	require_machine_suffix, os_multilib);
3234	}
3235
3236
3237	/ Execute the command specified by the arguments on the current line of spec.*
3238	When using pipes, this includes several piped-together commands
3239	with `\|' between them.
3240
3241	Return 0 if successful, -1 if failed. /*
3242
3243	static int
3244	execute (void)
3245	{
3246	int i;
3247	int n_commands; / # of command. /
3248	char *string;
3249	struct pex_obj *pex;
3250	struct command
3251	{
3252	const char prog; /* program name. /
3253	const char *argv; /* vector of args. /
3254	};
3255	const char *arg;
3256
3257	struct command commands; /* each command buffer with above info. /
3258
3259	gcc_assert (!processing_spec_function);
3260
3261	if (wrapper_string)
3262	{
3263	string = find_a_program (name: argbuf [`0`]);
3264	if (string)
3265	argbuf [`0`] = string;
3266	insert_wrapper (wrapper_string);
3267	}
3268
3269	/ Count # of piped commands. /
3270	for (n_commands = `1`, i = `0`; argbuf.iterate (ix: i, ptr: &arg); i++)
3271	if (strcmp (s1: arg, s2: "\|") == `0`)
3272	n_commands++;
3273
3274	/ Get storage for each command. /
3275	commands = XALLOCAVEC (struct command, n_commands);
3276
3277	/ Split argbuf into its separate piped processes,*
3278	and record info about each one.
3279	Also search for the programs that are to be run. /*
3280
3281	argbuf.safe_push (obj: `0`);
3282
3283	commands[`0`].prog = argbuf [`0`]; / first command. /
3284	commands[`0`].argv = argbuf.address ();
3285
3286	if (!wrapper_string)
3287	{
3288	string = find_a_program(name: commands[`0`].prog);
3289	if (string)
3290	commands[`0`].argv[`0`] = string;
3291	}
3292
3293	for (n_commands = `1`, i = `0`; argbuf.iterate (ix: i, ptr: &arg); i++)
3294	if (arg && strcmp (s1: arg, s2: "\|") == `0`)
3295	{ / each command. /
3296	#if defined (__MSDOS__) \|\| defined (OS2) \|\| defined (VMS)
3297	fatal_error (input_location, "%<-pipe%> not supported");
3298	#endif
3299	argbuf [i] = `0`; / Termination of command args. /
3300	commands[n_commands].prog = argbuf [i + `1`];
3301	commands[n_commands].argv
3302	= &(argbuf.address ())[i + `1`];
3303	string = find_a_program(name: commands[n_commands].prog);
3304	if (string)
3305	commands[n_commands].argv[`0`] = string;
3306	n_commands++;
3307	}
3308
3309	/ If -v, print what we are about to do, and maybe query. /
3310
3311	if (verbose_flag)
3312	{
3313	/ For help listings, put a blank line between sub-processes. /
3314	if (print_help_list)
3315	fputc (c: `'\n'`, stderr);
3316
3317	/ Print each piped command as a separate line. /
3318	for (i = `0`; i < n_commands; i++)
3319	{
3320	const char *const *j;
3321
3322	if (verbose_only_flag)
3323	{
3324	for (j = commands[i].argv; *j; j++)
3325	{
3326	const char *p;
3327	for (p = j; p; ++p)
3328	if (!ISALNUM ((unsigned char) *p)
3329	&& p != `'_'` && p != `'/'` && p != `'-'` && p != `'.'`)
3330	break;
3331	if (p \|\| !j)
3332	{
3333	fprintf (stderr, format: " \"");
3334	for (p = j; p; ++p)
3335	{
3336	if (p == `'"'` \|\| p == `'\\'` \|\| *p == `'$'`)
3337	fputc (c: `'\\'`, stderr);
3338	fputc (c: *p, stderr);
3339	}
3340	fputc (c: `'"'`, stderr);
3341	}
3342	/ If it's empty, print "". /
3343	else if (!**j)
3344	fprintf (stderr, format: " \"\"");
3345	else
3346	fprintf (stderr, format: " %s", *j);
3347	}
3348	}
3349	else
3350	for (j = commands[i].argv; *j; j++)
3351	/ If it's empty, print "". /
3352	if (!**j)
3353	fprintf (stderr, format: " \"\"");
3354	else
3355	fprintf (stderr, format: " %s", *j);
3356
3357	/ Print a pipe symbol after all but the last command. /
3358	if (i + `1` != n_commands)
3359	fprintf (stderr, format: " \|");
3360	fprintf (stderr, format: "\n");
3361	}
3362	fflush (stderr);
3363	if (verbose_only_flag != `0`)
3364	{
3365	/ verbose_only_flag should act as if the spec was*
3366	executed, so increment execution_count before
3367	returning. This prevents spurious warnings about
3368	unused linker input files, etc. /*
3369	execution_count++;
3370	return `0`;
3371	}
3372	#ifdef DEBUG
3373	fnotice (stderr, "\nGo ahead? (y or n) ");
3374	fflush (stderr);
3375	i = getchar ();
3376	if (i != `'\n'`)
3377	while (getchar () != `'\n'`)
3378	;
3379
3380	if (i != `'y'` && i != `'Y'`)
3381	return `0`;
3382	#endif /* DEBUG */
3383	}
3384
3385	#ifdef ENABLE_VALGRIND_CHECKING
3386	/ Run the each command through valgrind. To simplify prepending the*
3387	path to valgrind and the option "-q" (for quiet operation unless
3388	something triggers), we allocate a separate argv array. /*
3389
3390	for (i = `0`; i < n_commands; i++)
3391	{
3392	const char **argv;
3393	int argc;
3394	int j;
3395
3396	for (argc = `0`; commands[i].argv[argc] != NULL; argc++)
3397	;
3398
3399	argv = XALLOCAVEC (const char *, argc + `3`);
3400
3401	argv[`0`] = VALGRIND_PATH;
3402	argv[`1`] = "-q";
3403	for (j = `2`; j < argc + `2`; j++)
3404	argv[j] = commands[i].argv[j - `2`];
3405	argv[j] = NULL;
3406
3407	commands[i].argv = argv;
3408	commands[i].prog = argv[`0`];
3409	}
3410	#endif
3411
3412	/ Run each piped subprocess. /
3413
3414	pex = pex_init (PEX_USE_PIPES \| ((report_times \|\| report_times_to_file)
3415	? PEX_RECORD_TIMES : `0`),
3416	pname: progname, tempbase: temp_filename);
3417	if (pex == NULL)
3418	fatal_error (input_location, "%<pex_init%> failed: %m");
3419
3420	for (i = `0`; i < n_commands; i++)
3421	{
3422	const char *errmsg;
3423	int err;
3424	const char *string = commands[i].argv[`0`];
3425
3426	errmsg = pex_run (obj: pex,
3427	flags: ((i + `1` == n_commands ? PEX_LAST : `0`)
3428	\| (string == commands[i].prog ? PEX_SEARCH : `0`)),
3429	executable: string, CONST_CAST (char **, commands[i].argv),
3430	NULL, NULL, err: &err);
3431	if (errmsg != NULL)
3432	{
3433	errno = err;
3434	fatal_error (input_location,
3435	err ? G_("cannot execute %qs: %s: %m")
3436	: G_("cannot execute %qs: %s"),
3437	string, errmsg);
3438	}
3439
3440	if (i && string != commands[i].prog)
3441	free (CONST_CAST (char *, string));
3442	}
3443
3444	execution_count++;
3445
3446	/ Wait for all the subprocesses to finish. /
3447
3448	{
3449	int *statuses;
3450	struct pex_time *times = NULL;
3451	int ret_code = `0`;
3452
3453	statuses = XALLOCAVEC (int, n_commands);
3454	if (!pex_get_status (pex, count: n_commands, vector: statuses))
3455	fatal_error (input_location, "failed to get exit status: %m");
3456
3457	if (report_times \|\| report_times_to_file)
3458	{
3459	times = XALLOCAVEC (struct pex_time, n_commands);
3460	if (!pex_get_times (pex, count: n_commands, vector: times))
3461	fatal_error (input_location, "failed to get process times: %m");
3462	}
3463
3464	pex_free (pex);
3465
3466	for (i = `0`; i < n_commands; ++i)
3467	{
3468	int status = statuses[i];
3469
3470	if (WIFSIGNALED (status))
3471	switch (WTERMSIG (status))
3472	{
3473	case SIGINT:
3474	case SIGTERM:
3475	/ SIGQUIT and SIGKILL are not available on MinGW. /
3476	#ifdef SIGQUIT
3477	case SIGQUIT:
3478	#endif
3479	#ifdef SIGKILL
3480	case SIGKILL:
3481	#endif
3482	/ The user (or environment) did something to the*
3483	inferior. Making this an ICE confuses the user into
3484	thinking there's a compiler bug. Much more likely is
3485	the user or OOM killer nuked it. /*
3486	fatal_error (input_location,
3487	"%s signal terminated program %s",
3488	strsignal (WTERMSIG (status)),
3489	commands[i].prog);
3490	break;
3491
3492	#ifdef SIGPIPE
3493	case SIGPIPE:
3494	/ SIGPIPE is a special case. It happens in -pipe mode*
3495	when the compiler dies before the preprocessor is
3496	done, or the assembler dies before the compiler is
3497	done. There's generally been an error already, and
3498	this is just fallout. So don't generate another
3499	error unless we would otherwise have succeeded. /*
3500	if (signal_count \|\| greatest_status >= MIN_FATAL_STATUS)
3501	{
3502	signal_count++;
3503	ret_code = -`1`;
3504	break;
3505	}
3506	#endif
3507	/ FALLTHROUGH /
3508
3509	default:
3510	/ The inferior failed to catch the signal. /
3511	internal_error_no_backtrace ("%s signal terminated program %s",
3512	strsignal (WTERMSIG (status)),
3513	commands[i].prog);
3514	}
3515	else if (WIFEXITED (status)
3516	&& WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3517	{
3518	/ For ICEs in cc1, cc1obj, cc1plus see if it is*
3519	reproducible or not. /*
3520	const char *p;
3521	if (flag_report_bug
3522	&& WEXITSTATUS (status) == ICE_EXIT_CODE
3523	&& i == `0`
3524	&& (p = strrchr (s: commands[`0`].argv[`0`], DIR_SEPARATOR))
3525	&& startswith (str: p + `1`, prefix: "cc1"))
3526	try_generate_repro (argv: commands[`0`].argv);
3527	if (WEXITSTATUS (status) > greatest_status)
3528	greatest_status = WEXITSTATUS (status);
3529	ret_code = -`1`;
3530	}
3531
3532	if (report_times \|\| report_times_to_file)
3533	{
3534	struct pex_time *pt = &times[i];
3535	double ut, st;
3536
3537	ut = ((double) pt->user_seconds
3538	+ (double) pt->user_microseconds / `1.0e6`);
3539	st = ((double) pt->system_seconds
3540	+ (double) pt->system_microseconds / `1.0e6`);
3541
3542	if (ut + st != `0`)
3543	{
3544	if (report_times)
3545	fnotice (stderr, "# %s %.2f %.2f\n",
3546	commands[i].prog, ut, st);
3547
3548	if (report_times_to_file)
3549	{
3550	int c = `0`;
3551	const char *const *j;
3552
3553	fprintf (stream: report_times_to_file, format: "%g %g", ut, st);
3554
3555	for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3556	{
3557	const char *p;
3558	for (p = j; p; ++p)
3559	if (p == `'"'` \|\| p == `'\\'` \|\| *p == `'$'`
3560	\|\| ISSPACE (*p))
3561	break;
3562
3563	if (*p)
3564	{
3565	fprintf (stream: report_times_to_file, format: " \"");
3566	for (p = j; p; ++p)
3567	{
3568	if (p == `'"'` \|\| p == `'\\'` \|\| *p == `'$'`)
3569	fputc (c: `'\\'`, stream: report_times_to_file);
3570	fputc (c: *p, stream: report_times_to_file);
3571	}
3572	fputc (c: `'"'`, stream: report_times_to_file);
3573	}
3574	else
3575	fprintf (stream: report_times_to_file, format: " %s", *j);
3576	}
3577
3578	fputc (c: `'\n'`, stream: report_times_to_file);
3579	}
3580	}
3581	}
3582	}
3583
3584	if (commands[`0`].argv[`0`] != commands[`0`].prog)
3585	free (CONST_CAST (char *, commands[`0`].argv[`0`]));
3586
3587	return ret_code;
3588	}
3589	}
3590
3591	static struct switchstr *switches;
3592
3593	static int n_switches;
3594
3595	static int n_switches_alloc;
3596
3597	/ Set to zero if -fcompare-debug is disabled, positive if it's*
3598	enabled and we're running the first compilation, negative if it's
3599	enabled and we're running the second compilation. For most of the
3600	time, it's in the range -1..1, but it can be temporarily set to 2
3601	or 3 to indicate that the -fcompare-debug flags didn't come from
3602	the command-line, but rather from the GCC_COMPARE_DEBUG environment
3603	variable, until a synthesized -fcompare-debug flag is added to the
3604	command line. /*
3605	int compare_debug;
3606
3607	/ Set to nonzero if we've seen the -fcompare-debug-second flag. /
3608	int compare_debug_second;
3609
3610	/ Set to the flags that should be passed to the second compilation in*
3611	a -fcompare-debug compilation. /*
3612	const char *compare_debug_opt;
3613
3614	static struct switchstr *switches_debug_check[`2`];
3615
3616	static int n_switches_debug_check[`2`];
3617
3618	static int n_switches_alloc_debug_check[`2`];
3619
3620	static char *debug_check_temp_file[`2`];
3621
3622	/ Language is one of three things:*
3623
3624	1) The name of a real programming language.
3625	2) NULL, indicating that no one has figured out
3626	what it is yet.
3627	3) '', indicating that the file should be passed*
3628	to the linker. /*
3629	struct infile
3630	{
3631	const char *name;
3632	const char *language;
3633	struct compiler *incompiler;
3634	bool compiled;
3635	bool preprocessed;
3636	};
3637
3638	/ Also a vector of input files specified. /
3639
3640	static struct infile *infiles;
3641
3642	int n_infiles;
3643
3644	static int n_infiles_alloc;
3645
3646	/ True if undefined environment variables encountered during spec processing*
3647	are ok to ignore, typically when we're running for --help or --version. /*
3648
3649	static bool spec_undefvar_allowed;
3650
3651	/ True if multiple input files are being compiled to a single*
3652	assembly file. /*
3653
3654	static bool combine_inputs;
3655
3656	/ This counts the number of libraries added by lang_specific_driver, so that*
3657	we can tell if there were any user supplied any files or libraries. /*
3658
3659	static int added_libraries;
3660
3661	/ And a vector of corresponding output files is made up later. /
3662
3663	const char **outfiles;
3664
3665	#if defined(HAVE_TARGET_OBJECT_SUFFIX) \|\| defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3666
3667	/ Convert NAME to a new name if it is the standard suffix. DO_EXE*
3668	is true if we should look for an executable suffix. DO_OBJ
3669	is true if we should look for an object suffix. /*
3670
3671	static const char *
3672	convert_filename (const char name, int* do_exe ATTRIBUTE_UNUSED,
3673	int do_obj ATTRIBUTE_UNUSED)
3674	{
3675	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3676	int i;
3677	#endif
3678	int len;
3679
3680	if (name == NULL)
3681	return NULL;
3682
3683	len = strlen (name);
3684
3685	#ifdef HAVE_TARGET_OBJECT_SUFFIX
3686	/ Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". /
3687	if (do_obj && len > `2`
3688	&& name[len - `2`] == `'.'`
3689	&& name[len - `1`] == `'o'`)
3690	{
3691	obstack_grow (&obstack, name, len - `2`);
3692	obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3693	name = XOBFINISH (&obstack, const char *);
3694	}
3695	#endif
3696
3697	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3698	/ If there is no filetype, make it the executable suffix (which includes*
3699	the "."). But don't get confused if we have just "-o". /*
3700	if (! do_exe \|\| TARGET_EXECUTABLE_SUFFIX[`0`] == `0` \|\| not_actual_file_p (name))
3701	return name;
3702
3703	for (i = len - `1`; i >= `0`; i--)
3704	if (IS_DIR_SEPARATOR (name[i]))
3705	break;
3706
3707	for (i++; i < len; i++)
3708	if (name[i] == `'.'`)
3709	return name;
3710
3711	obstack_grow (&obstack, name, len);
3712	obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3713	strlen (TARGET_EXECUTABLE_SUFFIX));
3714	name = XOBFINISH (&obstack, const char *);
3715	#endif
3716
3717	return name;
3718	}
3719	#endif
3720
3721	/ Display the command line switches accepted by gcc. /
3722	static void
3723	display_help (void)
3724	{
3725	printf (_("Usage: %s [options] file...\n"), progname);
3726	fputs (_("Options:\n"), stdout);
3727
3728	fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout);
3729	fputs (_(" --help Display this information.\n"), stdout);
3730	fputs (_(" --target-help Display target specific command line options "
3731	"(including assembler and linker options).\n"), stdout);
3732	fputs (_(" --help={common\|optimizers\|params\|target\|warnings\|[^]{joined\|separate\|undocumented}}[,...].\n"), stdout);
3733	fputs (_(" Display specific types of command line options.\n"), stdout);
3734	if (! verbose_flag)
3735	fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
3736	fputs (_(" --version Display compiler version information.\n"), stdout);
3737	fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout);
3738	fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout);
3739	fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout);
3740	fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout);
3741	fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout);
3742	fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout);
3743	fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout);
3744	fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout);
3745	fputs (_("\
3746	-print-multiarch Display the target's normalized GNU triplet, used as\n\
3747	a component in the library path.\n"), stdout);
3748	fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout);
3749	fputs (_("\
3750	-print-multi-lib Display the mapping between command line options and\n\
3751	multiple library search directories.\n"), stdout);
3752	fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
3753	fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout);
3754	fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
3755	fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout);
3756	fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout);
3757	fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout);
3758	fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout);
3759	fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout);
3760	fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout);
3761	fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout);
3762	fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout);
3763	fputs (_("\
3764	-no-canonical-prefixes Do not canonicalize paths when building relative\n\
3765	prefixes to other gcc components.\n"), stdout);
3766	fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout);
3767	fputs (_(" -time Time the execution of each subprocess.\n"), stdout);
3768	fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout);
3769	fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout);
3770	fputs (_("\
3771	--sysroot=<directory> Use <directory> as the root directory for headers\n\
3772	and libraries.\n"), stdout);
3773	fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout);
3774	fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout);
3775	fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout);
3776	fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout);
3777	fputs (_(" -S Compile only; do not assemble or link.\n"), stdout);
3778	fputs (_(" -c Compile and assemble, but do not link.\n"), stdout);
3779	fputs (_(" -o <file> Place the output into <file>.\n"), stdout);
3780	fputs (_(" -pie Create a dynamically linked position independent\n\
3781	executable.\n"), stdout);
3782	fputs (_(" -shared Create a shared library.\n"), stdout);
3783	fputs (_("\
3784	-x <language> Specify the language of the following input files.\n\
3785	Permissible languages include: c c++ assembler none\n\
3786	'none' means revert to the default behavior of\n\
3787	guessing the language based on the file's extension.\n\
3788	"), stdout);
3789
3790	printf (_("\
3791	\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3792	passed on to the various sub-processes invoked by %s. In order to pass\n\
3793	other options on to these processes the -W<letter> options must be used.\n\
3794	"), progname);
3795
3796	/ The rest of the options are displayed by invocations of the various*
3797	sub-processes. /*
3798	}
3799
3800	static void
3801	add_preprocessor_option (const char option, int* len)
3802	{
3803	preprocessor_options.safe_push (obj: save_string (option, len));
3804	}
3805
3806	static void
3807	add_assembler_option (const char option, int* len)
3808	{
3809	assembler_options.safe_push (obj: save_string (option, len));
3810	}
3811
3812	static void
3813	add_linker_option (const char option, int* len)
3814	{
3815	linker_options.safe_push (obj: save_string (option, len));
3816	}
3817
3818	/ Allocate space for an input file in infiles. /
3819
3820	static void
3821	alloc_infile (void)
3822	{
3823	if (n_infiles_alloc == `0`)
3824	{
3825	n_infiles_alloc = `16`;
3826	infiles = XNEWVEC (struct infile, n_infiles_alloc);
3827	}
3828	else if (n_infiles_alloc == n_infiles)
3829	{
3830	n_infiles_alloc *= `2`;
3831	infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3832	}
3833	}
3834
3835	/ Store an input file with the given NAME and LANGUAGE in*
3836	infiles. /*
3837
3838	static void
3839	add_infile (const char name, const* char *language)
3840	{
3841	alloc_infile ();
3842	infiles[n_infiles].name = name;
3843	infiles[n_infiles++].language = language;
3844	}
3845
3846	/ Allocate space for a switch in switches. /
3847
3848	static void
3849	alloc_switch (void)
3850	{
3851	if (n_switches_alloc == `0`)
3852	{
3853	n_switches_alloc = `16`;
3854	switches = XNEWVEC (struct switchstr, n_switches_alloc);
3855	}
3856	else if (n_switches_alloc == n_switches)
3857	{
3858	n_switches_alloc *= `2`;
3859	switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3860	}
3861	}
3862
3863	/ Save an option OPT with N_ARGS arguments in array ARGS, marking it*
3864	as validated if VALIDATED and KNOWN if it is an internal switch. /*
3865
3866	static void
3867	save_switch (const char opt, size_t n_args, const* char *const *args,
3868	bool validated, bool known)
3869	{
3870	alloc_switch ();
3871	switches[n_switches].part1 = opt + `1`;
3872	if (n_args == `0`)
3873	switches[n_switches].args = `0`;
3874	else
3875	{
3876	switches[n_switches].args = XNEWVEC (const char *, n_args + `1`);
3877	memcpy (dest: switches[n_switches].args, src: args, n: n_args * sizeof (const char *));
3878	switches[n_switches].args[n_args] = NULL;
3879	}
3880
3881	switches[n_switches].live_cond = `0`;
3882	switches[n_switches].validated = validated;
3883	switches[n_switches].known = known;
3884	switches[n_switches].ordering = `0`;
3885	n_switches++;
3886	}
3887
3888	/ Set the SOURCE_DATE_EPOCH environment variable to the current time if it is*
3889	not set already. /*
3890
3891	static void
3892	set_source_date_epoch_envvar ()
3893	{
3894	/ Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations*
3895	of 64 bit integers. /*
3896	char source_date_epoch[`21`];
3897	time_t tt;
3898
3899	errno = `0`;
3900	tt = time (NULL);
3901	if (tt < (time_t) `0` \|\| errno != `0`)
3902	tt = (time_t) `0`;
3903
3904	snprintf (s: source_date_epoch, maxlen: `21`, format: "%llu", (unsigned long long) tt);
3905	/ Using setenv instead of xputenv because we want the variable to remain*
3906	after finalizing so that it's still set in the second run when using
3907	-fcompare-debug. /*
3908	setenv (name: "SOURCE_DATE_EPOCH", value: source_date_epoch, replace: `0`);
3909	}
3910
3911	/ Handle an option DECODED that is unknown to the option-processing*
3912	machinery. /*
3913
3914	static bool
3915	driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3916	{
3917	const char *opt = decoded->arg;
3918	if (opt[`1`] == `'W'` && opt[`2`] == `'n'` && opt[`3`] == `'o'` && opt[`4`] == `'-'`
3919	&& !(decoded->errors & CL_ERR_NEGATIVE))
3920	{
3921	/ Leave unknown -Wno-* options for the compiler proper, to be*
3922	diagnosed only if there are warnings. /*
3923	save_switch (opt: decoded->canonical_option[`0`],
3924	n_args: decoded->canonical_option_num_elements - `1`,
3925	args: &decoded->canonical_option[`1`], validated: false, known: true);
3926	return false;
3927	}
3928	if (decoded->opt_index == OPT_SPECIAL_unknown)
3929	{
3930	/ Give it a chance to define it a spec file. /
3931	save_switch (opt: decoded->canonical_option[`0`],
3932	n_args: decoded->canonical_option_num_elements - `1`,
3933	args: &decoded->canonical_option[`1`], validated: false, known: false);
3934	return false;
3935	}
3936	else
3937	return true;
3938	}
3939
3940	/ Handle an option DECODED that is not marked as CL_DRIVER.*
3941	LANG_MASK will always be CL_DRIVER. /*
3942
3943	static void
3944	driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3945	unsigned int lang_mask ATTRIBUTE_UNUSED)
3946	{
3947	/ At this point, non-driver options are accepted (and expected to*
3948	be passed down by specs) unless marked to be rejected by the
3949	driver. Options to be rejected by the driver but accepted by the
3950	compilers proper are treated just like completely unknown
3951	options. /*
3952	const struct cl_option *option = &cl_options[decoded->opt_index];
3953
3954	if (option->cl_reject_driver)
3955	error ("unrecognized command-line option %qs",
3956	decoded->orig_option_with_args_text);
3957	else
3958	save_switch (opt: decoded->canonical_option[`0`],
3959	n_args: decoded->canonical_option_num_elements - `1`,
3960	args: &decoded->canonical_option[`1`], validated: false, known: true);
3961	}
3962
3963	static const char *spec_lang = `0`;
3964	static int last_language_n_infiles;
3965
3966
3967	/ Check that GCC is configured to support the offload target. /
3968
3969	static bool
3970	check_offload_target_name (const char *target, ptrdiff_t len)
3971	{
3972	const char n, c = OFFLOAD_TARGETS;
3973	while (c)
3974	{
3975	n = strchr (s: c, c: `','`);
3976	if (n == NULL)
3977	n = strchr (s: c, c: `'\0'`);
3978	if (len == n - c && strncmp (s1: target, s2: c, n: n - c) == `0`)
3979	break;
3980	c = *n ? n + `1` : NULL;
3981	}
3982	if (!c)
3983	{
3984	auto_vec<const char*> candidates;
3985	size_t olen = strlen (OFFLOAD_TARGETS) + `1`;
3986	char cand = XALLOCAVEC (char*, olen);
3987	memcpy (dest: cand, OFFLOAD_TARGETS, n: olen);
3988	for (c = strtok (s: cand, delim: ","); c; c = strtok (NULL, delim: ","))
3989	candidates.safe_push (obj: c);
3990	candidates.safe_push (obj: "default");
3991	candidates.safe_push (obj: "disable");
3992
3993	char target2 = XALLOCAVEC (char*, len + `1`);
3994	memcpy (dest: target2, src: target, n: len);
3995	target2[len] = `'\0'`;
3996
3997	error ("GCC is not configured to support %qs as %<-foffload=%> argument",
3998	target2);
3999
4000	char *s;
4001	const char *hint = candidates_list_and_hint (arg: target2, str&: s, candidates);
4002	if (hint)
4003	inform (UNKNOWN_LOCATION,
4004	"valid %<-foffload=%> arguments are: %s; "
4005	"did you mean %qs?", s, hint);
4006	else
4007	inform (UNKNOWN_LOCATION, "valid %<-foffload=%> arguments are: %s", s);
4008	XDELETEVEC (s);
4009	return false;
4010	}
4011	return true;
4012	}
4013
4014	/ Sanity check for -foffload-options. /
4015
4016	static void
4017	check_foffload_target_names (const char *arg)
4018	{
4019	const char cur, next, *end;
4020	/ If option argument starts with '-' then no target is specified and we*
4021	do not need to parse it. /*
4022	if (arg[`0`] == `'-'`)
4023	return;
4024	end = strchr (s: arg, c: `'='`);
4025	if (end == NULL)
4026	{
4027	error ("%<=%>options missing after %<-foffload-options=%>target");
4028	return;
4029	}
4030
4031	cur = arg;
4032	while (cur < end)
4033	{
4034	next = strchr (s: cur, c: `','`);
4035	if (next == NULL)
4036	next = end;
4037	next = (next > end) ? end : next;
4038
4039	/ Retain non-supported targets after printing an error as those will not*
4040	be processed; each enabled target only processes its triplet. /*
4041	check_offload_target_name (target: cur, len: next - cur);
4042	cur = next + `1`;
4043	}
4044	}
4045
4046	/ Parse -foffload option argument. /
4047
4048	static void
4049	handle_foffload_option (const char *arg)
4050	{
4051	const char c, cur, n, next, *end;
4052	char *target;
4053
4054	/ If option argument starts with '-' then no target is specified and we*
4055	do not need to parse it. /*
4056	if (arg[`0`] == `'-'`)
4057	return;
4058
4059	end = strchr (s: arg, c: `'='`);
4060	if (end == NULL)
4061	end = strchr (s: arg, c: `'\0'`);
4062	cur = arg;
4063
4064	while (cur < end)
4065	{
4066	next = strchr (s: cur, c: `','`);
4067	if (next == NULL)
4068	next = end;
4069	next = (next > end) ? end : next;
4070
4071	target = XNEWVEC (char, next - cur + `1`);
4072	memcpy (dest: target, src: cur, n: next - cur);
4073	target[next - cur] = `'\0'`;
4074
4075	/ Reset offloading list and continue. /
4076	if (strcmp (s1: target, s2: "default") == `0`)
4077	{
4078	free (ptr: offload_targets);
4079	offload_targets = NULL;
4080	goto next_item;
4081	}
4082
4083	/ If 'disable' is passed to the option, clean the list of*
4084	offload targets and return, even if more targets follow.
4085	Likewise if GCC is not configured to support that offload target. /*
4086	if (strcmp (s1: target, s2: "disable") == `0`
4087	\|\| !check_offload_target_name (target, len: next - cur))
4088	{
4089	free (ptr: offload_targets);
4090	offload_targets = xstrdup ("");
4091	return;
4092	}
4093
4094	if (!offload_targets)
4095	{
4096	offload_targets = target;
4097	target = NULL;
4098	}
4099	else
4100	{
4101	/ Check that the target hasn't already presented in the list. /
4102	c = offload_targets;
4103	do
4104	{
4105	n = strchr (s: c, c: `':'`);
4106	if (n == NULL)
4107	n = strchr (s: c, c: `'\0'`);
4108
4109	if (next - cur == n - c && strncmp (s1: c, s2: target, n: n - c) == `0`)
4110	break;
4111
4112	c = n + `1`;
4113	}
4114	while (*n);
4115
4116	/ If duplicate is not found, append the target to the list. /
4117	if (c > n)
4118	{
4119	size_t offload_targets_len = strlen (s: offload_targets);
4120	offload_targets
4121	= XRESIZEVEC (char, offload_targets,
4122	offload_targets_len + `1` + next - cur + `1`);
4123	offload_targets[offload_targets_len++] = `':'`;
4124	memcpy (dest: offload_targets + offload_targets_len, src: target, n: next - cur + `1`);
4125	}
4126	}
4127	next_item:
4128	cur = next + `1`;
4129	XDELETEVEC (target);
4130	}
4131	}
4132
4133	/ Forward certain options to offloading compilation. /
4134
4135	static void
4136	forward_offload_option (size_t opt_index, const char arg, bool* validated)
4137	{
4138	switch (opt_index)
4139	{
4140	case OPT_l:
4141	/ Use a '_GCC_' prefix and standard name ('-l_GCC_m' irrespective of the*
4142	host's 'MATH_LIBRARY', for example), so that the 'mkoffload's can tell
4143	this has been synthesized here, and translate/drop as necessary. /*
4144	/ Note that certain libraries ('-lc', '-lgcc', '-lgomp', for example)*
4145	are injected by default in offloading compilation, and therefore not
4146	forwarded here. /*
4147	/ GCC libraries. /
4148	if (/ '-lgfortran' / strcmp (s1: arg, s2: "gfortran") == `0` )
4149	save_switch (opt: concat ("-foffload-options=-l_GCC_", arg, NULL),
4150	n_args: `0`, NULL, validated, known: true);
4151	/ Other libraries. /
4152	else
4153	{
4154	/ The case will need special consideration where on the host*
4155	'!need_math', but for offloading compilation still need
4156	'-foffload-options=-l_GCC_m'. The problem is that we don't get
4157	here anything like '-lm', because it's not synthesized in
4158	'gcc/fortran/gfortranspec.cc:lang_specific_driver', for example.
4159	Generally synthesizing '-foffload-options=-l_GCC_m' etc. in the
4160	language specific drivers is non-trivial, needs very careful
4161	review of their options handling. However, this issue is not
4162	actually relevant for the current set of supported host/offloading
4163	configurations. /*
4164	int need_math = (MATH_LIBRARY[`0`] != `'\0'`);
4165	if (/ '-lm' / (need_math && strcmp (s1: arg, MATH_LIBRARY) == `0`))
4166	save_switch (opt: "-foffload-options=-l_GCC_m",
4167	n_args: `0`, NULL, validated, known: true);
4168	}
4169	break;
4170	default:
4171	gcc_unreachable ();
4172	}
4173	}
4174
4175	/ Handle a driver option; arguments and return value as for*
4176	handle_option. /*
4177
4178	static bool
4179	driver_handle_option (struct gcc_options *opts,
4180	struct gcc_options *opts_set,
4181	const struct cl_decoded_option *decoded,
4182	unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
4183	location_t loc,
4184	const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
4185	diagnostic_context *dc,
4186	void () (void*))
4187	{
4188	size_t opt_index = decoded->opt_index;
4189	const char *arg = decoded->arg;
4190	const char *compare_debug_replacement_opt;
4191	int value = decoded->value;
4192	bool validated = false;
4193	bool do_save = true;
4194
4195	gcc_assert (opts == &global_options);
4196	gcc_assert (opts_set == &global_options_set);
4197	gcc_assert (kind == DK_UNSPECIFIED);
4198	gcc_assert (loc == UNKNOWN_LOCATION);
4199	gcc_assert (dc == global_dc);
4200
4201	switch (opt_index)
4202	{
4203	case OPT_dumpspecs:
4204	{
4205	struct spec_list *sl;
4206	init_spec ();
4207	for (sl = specs; sl; sl = sl->next)
4208	printf (format: "%s:\n%s\n\n", sl->name, (sl->ptr_spec));
4209	if (link_command_spec)
4210	printf (format: "*link_command:\n%s\n\n", link_command_spec);
4211	exit (status: `0`);
4212	}
4213
4214	case OPT_dumpversion:
4215	printf (format: "%s\n", spec_version);
4216	exit (status: `0`);
4217
4218	case OPT_dumpmachine:
4219	printf (format: "%s\n", spec_machine);
4220	exit (status: `0`);
4221
4222	case OPT_dumpfullversion:
4223	printf ("%s\n", BASEVER);
4224	exit (status: `0`);
4225
4226	case OPT__version:
4227	print_version = `1`;
4228
4229	/ CPP driver cannot obtain switch from cc1_options. /
4230	if (is_cpp_driver)
4231	add_preprocessor_option (option: "--version", len: strlen (s: "--version"));
4232	add_assembler_option (option: "--version", len: strlen (s: "--version"));
4233	add_linker_option (option: "--version", len: strlen (s: "--version"));
4234	break;
4235
4236	case OPT__completion_:
4237	validated = true;
4238	completion = decoded->arg;
4239	break;
4240
4241	case OPT__help:
4242	print_help_list = `1`;
4243
4244	/ CPP driver cannot obtain switch from cc1_options. /
4245	if (is_cpp_driver)
4246	add_preprocessor_option (option: "--help", len: `6`);
4247	add_assembler_option (option: "--help", len: `6`);
4248	add_linker_option (option: "--help", len: `6`);
4249	break;
4250
4251	case OPT__help_:
4252	print_subprocess_help = `2`;
4253	break;
4254
4255	case OPT__target_help:
4256	print_subprocess_help = `1`;
4257
4258	/ CPP driver cannot obtain switch from cc1_options. /
4259	if (is_cpp_driver)
4260	add_preprocessor_option (option: "--target-help", len: `13`);
4261	add_assembler_option (option: "--target-help", len: `13`);
4262	add_linker_option (option: "--target-help", len: `13`);
4263	break;
4264
4265	case OPT__no_sysroot_suffix:
4266	case OPT_pass_exit_codes:
4267	case OPT_print_search_dirs:
4268	case OPT_print_file_name_:
4269	case OPT_print_prog_name_:
4270	case OPT_print_multi_lib:
4271	case OPT_print_multi_directory:
4272	case OPT_print_sysroot:
4273	case OPT_print_multi_os_directory:
4274	case OPT_print_multiarch:
4275	case OPT_print_sysroot_headers_suffix:
4276	case OPT_time:
4277	case OPT_wrapper:
4278	/ These options set the variables specified in common.opt*
4279	automatically, and do not need to be saved for spec
4280	processing. /*
4281	do_save = false;
4282	break;
4283
4284	case OPT_print_libgcc_file_name:
4285	print_file_name = "libgcc.a";
4286	do_save = false;
4287	break;
4288
4289	case OPT_fuse_ld_bfd:
4290	use_ld = ".bfd";
4291	break;
4292
4293	case OPT_fuse_ld_gold:
4294	use_ld = ".gold";
4295	break;
4296
4297	case OPT_fuse_ld_mold:
4298	use_ld = ".mold";
4299	break;
4300
4301	case OPT_fcompare_debug_second:
4302	compare_debug_second = `1`;
4303	break;
4304
4305	case OPT_fcompare_debug:
4306	switch (value)
4307	{
4308	case `0`:
4309	compare_debug_replacement_opt = "-fcompare-debug=";
4310	arg = "";
4311	goto compare_debug_with_arg;
4312
4313	case `1`:
4314	compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
4315	arg = "-gtoggle";
4316	goto compare_debug_with_arg;
4317
4318	default:
4319	gcc_unreachable ();
4320	}
4321	break;
4322
4323	case OPT_fcompare_debug_:
4324	compare_debug_replacement_opt = decoded->canonical_option[`0`];
4325	compare_debug_with_arg:
4326	gcc_assert (decoded->canonical_option_num_elements == `1`);
4327	gcc_assert (arg != NULL);
4328	if (*arg)
4329	compare_debug = `1`;
4330	else
4331	compare_debug = -`1`;
4332	if (compare_debug < `0`)
4333	compare_debug_opt = NULL;
4334	else
4335	compare_debug_opt = arg;
4336	save_switch (opt: compare_debug_replacement_opt, n_args: `0`, NULL, validated, known: true);
4337	set_source_date_epoch_envvar ();
4338	return true;
4339
4340	case OPT_fdiagnostics_color_:
4341	diagnostic_color_init (context: dc, value);
4342	break;
4343
4344	case OPT_fdiagnostics_urls_:
4345	diagnostic_urls_init (context: dc, value);
4346	break;
4347
4348	case OPT_fdiagnostics_format_:
4349	{
4350	const char *basename = (opts->x_dump_base_name ? opts->x_dump_base_name
4351	: opts->x_main_input_basename);
4352	diagnostic_output_format_init (dc, base_file_name: basename,
4353	(enum diagnostics_output_format)value);
4354	break;
4355	}
4356
4357	case OPT_fdiagnostics_text_art_charset_:
4358	dc->set_text_art_charset ((enum diagnostic_text_art_charset)value);
4359	break;
4360
4361	case OPT_Wa_:
4362	{
4363	int prev, j;
4364	/ Pass the rest of this option to the assembler. /
4365
4366	/ Split the argument at commas. /
4367	prev = `0`;
4368	for (j = `0`; arg[j]; j++)
4369	if (arg[j] == `','`)
4370	{
4371	add_assembler_option (option: arg + prev, len: j - prev);
4372	prev = j + `1`;
4373	}
4374
4375	/ Record the part after the last comma. /
4376	add_assembler_option (option: arg + prev, len: j - prev);
4377	}
4378	do_save = false;
4379	break;
4380
4381	case OPT_Wp_:
4382	{
4383	int prev, j;
4384	/ Pass the rest of this option to the preprocessor. /
4385
4386	/ Split the argument at commas. /
4387	prev = `0`;
4388	for (j = `0`; arg[j]; j++)
4389	if (arg[j] == `','`)
4390	{
4391	add_preprocessor_option (option: arg + prev, len: j - prev);
4392	prev = j + `1`;
4393	}
4394
4395	/ Record the part after the last comma. /
4396	add_preprocessor_option (option: arg + prev, len: j - prev);
4397	}
4398	do_save = false;
4399	break;
4400
4401	case OPT_Wl_:
4402	{
4403	int prev, j;
4404	/ Split the argument at commas. /
4405	prev = `0`;
4406	for (j = `0`; arg[j]; j++)
4407	if (arg[j] == `','`)
4408	{
4409	add_infile (name: save_string (arg + prev, j - prev), language: "*");
4410	prev = j + `1`;
4411	}
4412	/ Record the part after the last comma. /
4413	add_infile (name: arg + prev, language: "*");
4414	}
4415	do_save = false;
4416	break;
4417
4418	case OPT_Xlinker:
4419	add_infile (name: arg, language: "*");
4420	do_save = false;
4421	break;
4422
4423	case OPT_Xpreprocessor:
4424	add_preprocessor_option (option: arg, len: strlen (s: arg));
4425	do_save = false;
4426	break;
4427
4428	case OPT_Xassembler:
4429	add_assembler_option (option: arg, len: strlen (s: arg));
4430	do_save = false;
4431	break;
4432
4433	case OPT_l:
4434	/ POSIX allows separation of -l and the lib arg; canonicalize*
4435	by concatenating -l with its arg /*
4436	add_infile (name: concat ("-l", arg, NULL), language: "*");
4437
4438	/ Forward to offloading compilation '-l[...]' flags for standard,*
4439	well-known libraries. /*
4440	/ Doing this processing here means that we don't get to see libraries*
4441	injected via specs, such as '-lquadmath' injected via
4442	'[build]/[target]/libgfortran/libgfortran.spec'. However, this issue
4443	is not actually relevant for the current set of host/offloading
4444	configurations. /*
4445	if (ENABLE_OFFLOADING)
4446	forward_offload_option (opt_index, arg, validated);
4447
4448	do_save = false;
4449	break;
4450
4451	case OPT_L:
4452	/ Similarly, canonicalize -L for linkers that may not accept*
4453	separate arguments. /*
4454	save_switch (opt: concat ("-L", arg, NULL), n_args: `0`, NULL, validated, known: true);
4455	return true;
4456
4457	case OPT_F:
4458	/ Likewise -F. /
4459	save_switch (opt: concat ("-F", arg, NULL), n_args: `0`, NULL, validated, known: true);
4460	return true;
4461
4462	case OPT_save_temps:
4463	if (!save_temps_flag)
4464	save_temps_flag = SAVE_TEMPS_DUMP;
4465	validated = true;
4466	break;
4467
4468	case OPT_save_temps_:
4469	if (strcmp (s1: arg, s2: "cwd") == `0`)
4470	save_temps_flag = SAVE_TEMPS_CWD;
4471	else if (strcmp (s1: arg, s2: "obj") == `0`
4472	\|\| strcmp (s1: arg, s2: "object") == `0`)
4473	save_temps_flag = SAVE_TEMPS_OBJ;
4474	else
4475	fatal_error (input_location, "%qs is an unknown %<-save-temps%> option",
4476	decoded->orig_option_with_args_text);
4477	save_temps_overrides_dumpdir = true;
4478	break;
4479
4480	case OPT_dumpdir:
4481	free (ptr: dumpdir);
4482	dumpdir = xstrdup (arg);
4483	save_temps_overrides_dumpdir = false;
4484	break;
4485
4486	case OPT_dumpbase:
4487	free (ptr: dumpbase);
4488	dumpbase = xstrdup (arg);
4489	break;
4490
4491	case OPT_dumpbase_ext:
4492	free (ptr: dumpbase_ext);
4493	dumpbase_ext = xstrdup (arg);
4494	break;
4495
4496	case OPT_no_canonical_prefixes:
4497	/ Already handled as a special case, so ignored here. /
4498	do_save = false;
4499	break;
4500
4501	case OPT_pipe:
4502	validated = true;
4503	/ These options set the variables specified in common.opt*
4504	automatically, but do need to be saved for spec
4505	processing. /*
4506	break;
4507
4508	case OPT_specs_:
4509	{
4510	struct user_specs user = XNEW (struct* user_specs);
4511
4512	user->next = (struct user_specs *) `0`;
4513	user->filename = arg;
4514	if (user_specs_tail)
4515	user_specs_tail->next = user;
4516	else
4517	user_specs_head = user;
4518	user_specs_tail = user;
4519	}
4520	validated = true;
4521	break;
4522
4523	case OPT__sysroot_:
4524	target_system_root = arg;
4525	target_system_root_changed = `1`;
4526	/ Saving this option is useful to let self-specs decide to*
4527	provide a default one. /*
4528	do_save = true;
4529	validated = true;
4530	break;
4531
4532	case OPT_time_:
4533	if (report_times_to_file)
4534	fclose (stream: report_times_to_file);
4535	report_times_to_file = fopen (filename: arg, modes: "a");
4536	do_save = false;
4537	break;
4538
4539	case OPT____:
4540	/ "-###"*
4541	This is similar to -v except that there is no execution
4542	of the commands and the echoed arguments are quoted. It
4543	is intended for use in shell scripts to capture the
4544	driver-generated command line. /*
4545	verbose_only_flag++;
4546	verbose_flag = `1`;
4547	do_save = false;
4548	break;
4549
4550	case OPT_B:
4551	{
4552	size_t len = strlen (s: arg);
4553
4554	/ Catch the case where the user has forgotten to append a*
4555	directory separator to the path. Note, they may be using
4556	-B to add an executable name prefix, eg "i386-elf-", in
4557	order to distinguish between multiple installations of
4558	GCC in the same directory. Hence we must check to see
4559	if appending a directory separator actually makes a
4560	valid directory name. /*
4561	if (!IS_DIR_SEPARATOR (arg[len - `1`])
4562	&& is_directory (arg, false))
4563	{
4564	char tmp = XNEWVEC (char*, len + `2`);
4565	strcpy (dest: tmp, src: arg);
4566	tmp[len] = DIR_SEPARATOR;
4567	tmp[++len] = `0`;
4568	arg = tmp;
4569	}
4570
4571	add_prefix (pprefix: &exec_prefixes, prefix: arg, NULL,
4572	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: `0`, os_multilib: `0`);
4573	add_prefix (pprefix: &startfile_prefixes, prefix: arg, NULL,
4574	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: `0`, os_multilib: `0`);
4575	add_prefix (pprefix: &include_prefixes, prefix: arg, NULL,
4576	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: `0`, os_multilib: `0`);
4577	}
4578	validated = true;
4579	break;
4580
4581	case OPT_E:
4582	have_E = true;
4583	break;
4584
4585	case OPT_x:
4586	spec_lang = arg;
4587	if (!strcmp (s1: spec_lang, s2: "none"))
4588	/ Suppress the warning if -xnone comes after the last input*
4589	file, because alternate command interfaces like g++ might
4590	find it useful to place -xnone after each input file. /*
4591	spec_lang = `0`;
4592	else
4593	last_language_n_infiles = n_infiles;
4594	do_save = false;
4595	break;
4596
4597	case OPT_o:
4598	have_o = `1`;
4599	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) \|\| defined(HAVE_TARGET_OBJECT_SUFFIX)
4600	arg = convert_filename (arg, ! have_c, `0`);
4601	#endif
4602	output_file = arg;
4603	/ On some systems, ld cannot handle "-o" without a space. So*
4604	split the option from its argument. /*
4605	save_switch (opt: "-o", n_args: `1`, args: &arg, validated, known: true);
4606	return true;
4607
4608	#ifdef ENABLE_DEFAULT_PIE
4609	case OPT_pie:
4610	/ -pie is turned on by default. /
4611	#endif
4612
4613	case OPT_static_libgcc:
4614	case OPT_shared_libgcc:
4615	case OPT_static_libgfortran:
4616	case OPT_static_libquadmath:
4617	case OPT_static_libphobos:
4618	case OPT_static_libgm2:
4619	case OPT_static_libstdc__:
4620	/ These are always valid; gcc.cc itself understands the first two*
4621	gfortranspec.cc understands -static-libgfortran,
4622	libgfortran.spec handles -static-libquadmath,
4623	d-spec.cc understands -static-libphobos,
4624	gm2spec.cc understands -static-libgm2,
4625	and g++spec.cc understands -static-libstdc++. /*
4626	validated = true;
4627	break;
4628
4629	case OPT_fwpa:
4630	flag_wpa = "";
4631	break;
4632
4633	case OPT_foffload_options_:
4634	check_foffload_target_names (arg);
4635	break;
4636
4637	case OPT_foffload_:
4638	handle_foffload_option (arg);
4639	if (arg[`0`] == `'-'` \|\| NULL != strchr (s: arg, c: `'='`))
4640	save_switch (opt: concat ("-foffload-options=", arg, NULL),
4641	n_args: `0`, NULL, validated, known: true);
4642	do_save = false;
4643	break;
4644
4645	case OPT_gcodeview:
4646	add_infile (name: "--pdb=", language: "*");
4647	break;
4648
4649	default:
4650	/ Various driver options need no special processing at this*
4651	point, having been handled in a prescan above or being
4652	handled by specs. /*
4653	break;
4654	}
4655
4656	if (do_save)
4657	save_switch (opt: decoded->canonical_option[`0`],
4658	n_args: decoded->canonical_option_num_elements - `1`,
4659	args: &decoded->canonical_option[`1`], validated, known: true);
4660	return true;
4661	}
4662
4663	/ Return true if F2 is F1 followed by a single suffix, i.e., by a*
4664	period and additional characters other than a period. /*
4665
4666	static inline bool
4667	adds_single_suffix_p (const char f2, const* char *f1)
4668	{
4669	size_t len = strlen (s: f1);
4670
4671	return (strncmp (s1: f1, s2: f2, n: len) == `0`
4672	&& f2[len] == `'.'`
4673	&& strchr (s: f2 + len + `1`, c: `'.'`) == NULL);
4674	}
4675
4676	/ Put the driver's standard set of option handlers in HANDLERS. /*
4677
4678	static void
4679	set_option_handlers (struct cl_option_handlers *handlers)
4680	{
4681	handlers->unknown_option_callback = driver_unknown_option_callback;
4682	handlers->wrong_lang_callback = driver_wrong_lang_callback;
4683	handlers->num_handlers = `3`;
4684	handlers->handlers[`0`].handler = driver_handle_option;
4685	handlers->handlers[`0`].mask = CL_DRIVER;
4686	handlers->handlers[`1`].handler = common_handle_option;
4687	handlers->handlers[`1`].mask = CL_COMMON;
4688	handlers->handlers[`2`].handler = target_handle_option;
4689	handlers->handlers[`2`].mask = CL_TARGET;
4690	}
4691
4692
4693	/ Return the index into infiles for the single non-library*
4694	non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4695	more than one. /*
4696	static inline int
4697	single_input_file_index ()
4698	{
4699	int ret = -`1`;
4700
4701	for (int i = `0`; i < n_infiles; i++)
4702	{
4703	if (infiles[i].language
4704	&& (infiles[i].language[`0`] == `'*'`
4705	\|\| (flag_wpa
4706	&& strcmp (s1: infiles[i].language, s2: "lto") == `0`)))
4707	continue;
4708
4709	if (ret != -`1`)
4710	return -`2`;
4711
4712	ret = i;
4713	}
4714
4715	return ret;
4716	}
4717
4718	/ Create the vector `switches' and its contents.*
4719	Store its length in `n_switches'. /*
4720
4721	static void
4722	process_command (unsigned int decoded_options_count,
4723	struct cl_decoded_option *decoded_options)
4724	{
4725	const char *temp;
4726	char *temp1;
4727	char tooldir_prefix, tooldir_prefix2;
4728	char (get_relative_prefix) (const char , const* char *,
4729	const char *) = NULL;
4730	struct cl_option_handlers handlers;
4731	unsigned int j;
4732
4733	gcc_exec_prefix = env.get (name: "GCC_EXEC_PREFIX");
4734
4735	n_switches = `0`;
4736	n_infiles = `0`;
4737	added_libraries = `0`;
4738
4739	/ Figure compiler version from version string. /
4740
4741	compiler_version = temp1 = xstrdup (version_string);
4742
4743	for (; *temp1; ++temp1)
4744	{
4745	if (*temp1 == `' '`)
4746	{
4747	*temp1 = `'\0'`;
4748	break;
4749	}
4750	}
4751
4752	/ Handle any -no-canonical-prefixes flag early, to assign the function*
4753	that builds relative prefixes. This function creates default search
4754	paths that are needed later in normal option handling. /*
4755
4756	for (j = `1`; j < decoded_options_count; j++)
4757	{
4758	if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
4759	{
4760	get_relative_prefix = make_relative_prefix_ignore_links;
4761	break;
4762	}
4763	}
4764	if (! get_relative_prefix)
4765	get_relative_prefix = make_relative_prefix;
4766
4767	/ Set up the default search paths. If there is no GCC_EXEC_PREFIX,*
4768	see if we can create it from the pathname specified in
4769	decoded_options[0].arg. /*
4770
4771	gcc_libexec_prefix = standard_libexec_prefix;
4772	#ifndef VMS
4773	/ FIXME: make_relative_prefix doesn't yet work for VMS. /
4774	if (!gcc_exec_prefix)
4775	{
4776	gcc_exec_prefix = get_relative_prefix (decoded_options[`0`].arg,
4777	standard_bindir_prefix,
4778	standard_exec_prefix);
4779	gcc_libexec_prefix = get_relative_prefix (decoded_options[`0`].arg,
4780	standard_bindir_prefix,
4781	standard_libexec_prefix);
4782	if (gcc_exec_prefix)
4783	xputenv (string: concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
4784	}
4785	else
4786	{
4787	/ make_relative_prefix requires a program name, but*
4788	GCC_EXEC_PREFIX is typically a directory name with a trailing
4789	/ (which is ignored by make_relative_prefix), so append a
4790	program name. /*
4791	char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
4792	gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
4793	standard_exec_prefix,
4794	standard_libexec_prefix);
4795
4796	/ The path is unrelocated, so fallback to the original setting. /
4797	if (!gcc_libexec_prefix)
4798	gcc_libexec_prefix = standard_libexec_prefix;
4799
4800	free (ptr: tmp_prefix);
4801	}
4802	#else
4803	#endif
4804	/ From this point onward, gcc_exec_prefix is non-null if the toolchain*
4805	is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4806	or an automatically created GCC_EXEC_PREFIX from
4807	decoded_options[0].arg. /*
4808
4809	/ Do language-specific adjustment/addition of flags. /
4810	lang_specific_driver (&decoded_options, &decoded_options_count,
4811	&added_libraries);
4812
4813	if (gcc_exec_prefix)
4814	{
4815	int len = strlen (s: gcc_exec_prefix);
4816
4817	if (len > (int) sizeof ("/lib/gcc/") - `1`
4818	&& (IS_DIR_SEPARATOR (gcc_exec_prefix[len-`1`])))
4819	{
4820	temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + `1`;
4821	if (IS_DIR_SEPARATOR (*temp)
4822	&& filename_ncmp (s1: temp + `1`, s2: "lib", n: `3`) == `0`
4823	&& IS_DIR_SEPARATOR (temp[`4`])
4824	&& filename_ncmp (s1: temp + `5`, s2: "gcc", n: `3`) == `0`)
4825	len -= sizeof ("/lib/gcc/") - `1`;
4826	}
4827
4828	set_std_prefix (gcc_exec_prefix, len);
4829	add_prefix (pprefix: &exec_prefixes, prefix: gcc_libexec_prefix, component: "GCC",
4830	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `0`);
4831	add_prefix (pprefix: &startfile_prefixes, prefix: gcc_exec_prefix, component: "GCC",
4832	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `0`);
4833	}
4834
4835	/ COMPILER_PATH and LIBRARY_PATH have values*
4836	that are lists of directory names with colons. /*
4837
4838	temp = env.get (name: "COMPILER_PATH");
4839	if (temp)
4840	{
4841	const char startp, endp;
4842	char nstore = (char* *) alloca (strlen (temp) + `3`);
4843
4844	startp = endp = temp;
4845	while (`1`)
4846	{
4847	if (endp == PATH_SEPARATOR \|\| endp == `0`)
4848	{
4849	strncpy (dest: nstore, src: startp, n: endp - startp);
4850	if (endp == startp)
4851	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4852	else if (!IS_DIR_SEPARATOR (endp[-`1`]))
4853	{
4854	nstore[endp - startp] = DIR_SEPARATOR;
4855	nstore[endp - startp + `1`] = `0`;
4856	}
4857	else
4858	nstore[endp - startp] = `0`;
4859	add_prefix (pprefix: &exec_prefixes, prefix: nstore, component: `0`,
4860	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `0`);
4861	add_prefix (pprefix: &include_prefixes, prefix: nstore, component: `0`,
4862	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `0`);
4863	if (*endp == `0`)
4864	break;
4865	endp = startp = endp + `1`;
4866	}
4867	else
4868	endp++;
4869	}
4870	}
4871
4872	temp = env.get (LIBRARY_PATH_ENV);
4873	if (temp && *cross_compile == `'0'`)
4874	{
4875	const char startp, endp;
4876	char nstore = (char* *) alloca (strlen (temp) + `3`);
4877
4878	startp = endp = temp;
4879	while (`1`)
4880	{
4881	if (endp == PATH_SEPARATOR \|\| endp == `0`)
4882	{
4883	strncpy (dest: nstore, src: startp, n: endp - startp);
4884	if (endp == startp)
4885	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4886	else if (!IS_DIR_SEPARATOR (endp[-`1`]))
4887	{
4888	nstore[endp - startp] = DIR_SEPARATOR;
4889	nstore[endp - startp + `1`] = `0`;
4890	}
4891	else
4892	nstore[endp - startp] = `0`;
4893	add_prefix (pprefix: &startfile_prefixes, prefix: nstore, NULL,
4894	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `1`);
4895	if (*endp == `0`)
4896	break;
4897	endp = startp = endp + `1`;
4898	}
4899	else
4900	endp++;
4901	}
4902	}
4903
4904	/ Use LPATH like LIBRARY_PATH (for the CMU build program). /
4905	temp = env.get (name: "LPATH");
4906	if (temp && *cross_compile == `'0'`)
4907	{
4908	const char startp, endp;
4909	char nstore = (char* *) alloca (strlen (temp) + `3`);
4910
4911	startp = endp = temp;
4912	while (`1`)
4913	{
4914	if (endp == PATH_SEPARATOR \|\| endp == `0`)
4915	{
4916	strncpy (dest: nstore, src: startp, n: endp - startp);
4917	if (endp == startp)
4918	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4919	else if (!IS_DIR_SEPARATOR (endp[-`1`]))
4920	{
4921	nstore[endp - startp] = DIR_SEPARATOR;
4922	nstore[endp - startp + `1`] = `0`;
4923	}
4924	else
4925	nstore[endp - startp] = `0`;
4926	add_prefix (pprefix: &startfile_prefixes, prefix: nstore, NULL,
4927	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `1`);
4928	if (*endp == `0`)
4929	break;
4930	endp = startp = endp + `1`;
4931	}
4932	else
4933	endp++;
4934	}
4935	}
4936
4937	/ Process the options and store input files and switches in their*
4938	vectors. /*
4939
4940	last_language_n_infiles = -`1`;
4941
4942	set_option_handlers (&handlers);
4943
4944	for (j = `1`; j < decoded_options_count; j++)
4945	{
4946	switch (decoded_options[j].opt_index)
4947	{
4948	case OPT_S:
4949	case OPT_c:
4950	case OPT_E:
4951	have_c = `1`;
4952	break;
4953	}
4954	if (have_c)
4955	break;
4956	}
4957
4958	for (j = `1`; j < decoded_options_count; j++)
4959	{
4960	if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
4961	{
4962	const char *arg = decoded_options[j].arg;
4963
4964	#ifdef HAVE_TARGET_OBJECT_SUFFIX
4965	arg = convert_filename (arg, `0`, access (arg, F_OK));
4966	#endif
4967	add_infile (name: arg, language: spec_lang);
4968
4969	continue;
4970	}
4971
4972	read_cmdline_option (opts: &global_options, opts_set: &global_options_set,
4973	decoded: decoded_options + j, UNKNOWN_LOCATION,
4974	CL_DRIVER, handlers: &handlers, dc: global_dc);
4975	}
4976
4977	/ If the user didn't specify any, default to all configured offload*
4978	targets. /*
4979	if (ENABLE_OFFLOADING && offload_targets == NULL)
4980	{
4981	handle_foffload_option (OFFLOAD_TARGETS);
4982	#if OFFLOAD_DEFAULTED
4983	offload_targets_default = true;
4984	#endif
4985	}
4986
4987	/ Handle -gtoggle as it would later in toplev.cc:process_options to*
4988	make the debug-level-gt spec function work as expected. /*
4989	if (flag_gtoggle)
4990	{
4991	if (debug_info_level == DINFO_LEVEL_NONE)
4992	debug_info_level = DINFO_LEVEL_NORMAL;
4993	else
4994	debug_info_level = DINFO_LEVEL_NONE;
4995	}
4996
4997	if (output_file
4998	&& strcmp (s1: output_file, s2: "-") != `0`
4999	&& strcmp (s1: output_file, HOST_BIT_BUCKET) != `0`)
5000	{
5001	int i;
5002	for (i = `0`; i < n_infiles; i++)
5003	if ((!infiles[i].language \|\| infiles[i].language[`0`] != `'*'`)
5004	&& canonical_filename_eq (a: infiles[i].name, b: output_file))
5005	fatal_error (input_location,
5006	"input file %qs is the same as output file",
5007	output_file);
5008	}
5009
5010	if (output_file != NULL && output_file[`0`] == `'\0'`)
5011	fatal_error (input_location, "output filename may not be empty");
5012
5013	/ -dumpdir and -save-temps=* both specify the location of aux/dump*
5014	outputs; the one that appears last prevails. When compiling
5015	multiple sources, an explicit dumpbase (minus -ext) may be
5016	combined with an explicit or implicit dumpdir, whereas when
5017	linking, a specified or implied link output name (minus
5018	extension) may be combined with a prevailing -save-temps= or an*
5019	otherwise implied dumpdir, but not override a prevailing
5020	-dumpdir. Primary outputs (e.g., linker output when linking
5021	without -o, or .i, .s or .o outputs when processing multiple
5022	inputs with -E, -S or -c, respectively) are NOT affected by these
5023	-save-temps=/-dump options, always landing in the current*
5024	directory and with the same basename as the input when an output
5025	name is not given, but when they're intermediate outputs, they
5026	are named like other aux outputs, so the options affect their
5027	location and name.
5028
5029	Here are some examples. There are several more in the
5030	documentation of -o and -dump, and some quite exhaustive tests*
5031	in gcc.misc-tests/outputs.exp.
5032
5033	When compiling any number of sources, no -dump nor*
5034	-save-temps=, all outputs in cwd without prefix:*
5035
5036	# gcc -c b.c -gsplit-dwarf
5037	-> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5038
5039	# gcc -c b.c d.c -gsplit-dwarf
5040	-> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5041	&& cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
5042
5043	When compiling and linking, no -dump nor -save-temps=, .o
5044	outputs are temporary, aux outputs land in the dir of the output,
5045	prefixed with the basename of the linker output:
5046
5047	# gcc b.c d.c -o ab -gsplit-dwarf
5048	-> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5049	&& cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5050	&& link ... -o ab
5051
5052	# gcc b.c d.c [-o a.out] -gsplit-dwarf
5053	-> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5054	&& cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5055	&& link ... [-o a.out]
5056
5057	When compiling and linking, a prevailing -dumpdir fully overrides
5058	the prefix of aux outputs given by the output name:
5059
5060	# gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5061	-> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5062	&& cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5063	&& link ... [-o whatever]
5064
5065	When compiling multiple inputs, an explicit -dumpbase is combined
5066	with -dumpdir, affecting aux outputs, but not the .o outputs:
5067
5068	# gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5069	-> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5070	&& cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5071
5072	When compiling and linking with -save-temps, the .o outputs that
5073	would have been temporary become aux outputs, so they get
5074	affected by -dump flags:*
5075
5076	# gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5077	-> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5078	&& cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5079	&& link
5080
5081	If -save-temps= prevails over -dumpdir, however, the explicit*
5082	-dumpdir is discarded, as if it wasn't there. The basename of
5083	the implicit linker output, a.out or a.exe, becomes a- as the aux
5084	output prefix for all compilations:
5085
5086	# gcc [-dumpdir f] -save-temps=cwd b.c d.c
5087	-> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5088	&& cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5089	&& link
5090
5091	A single -dumpbase, applying to multiple inputs, overrides the
5092	linker output name, implied or explicit, as the aux output prefix:
5093
5094	# gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5095	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5096	&& cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5097	&& link
5098
5099	# gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5100	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5101	&& cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5102	&& link -o dir/h.out
5103
5104	Now, if the linker output is NOT overridden as a prefix, but
5105	-save-temps= overrides implicit or explicit -dumpdir, the*
5106	effective dump dir combines the dir selected by the -save-temps=*
5107	option with the basename of the specified or implied link output:
5108
5109	# gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5110	-> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5111	&& cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5112	&& link -o dir/h.out
5113
5114	# gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5115	-> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5116	&& cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5117	&& link -o dir/h.out
5118
5119	But then again, a single -dumpbase applying to multiple inputs
5120	gets used instead of the linker output basename in the combined
5121	dumpdir:
5122
5123	# gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5124	-> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5125	&& cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5126	&& link -o dir/h.out
5127
5128	With a single input being compiled, the output basename does NOT
5129	affect the dumpdir prefix.
5130
5131	# gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5132	-> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5133
5134	but when compiling and linking even a single file, it does:
5135
5136	# gcc -save-temps=obj b.c -o dir/h.out
5137	-> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5138
5139	unless an explicit -dumpdir prevails:
5140
5141	# gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5142	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5143
5144	*/
5145
5146	bool explicit_dumpdir = dumpdir;
5147
5148	if ((!save_temps_overrides_dumpdir && explicit_dumpdir)
5149	\|\| (output_file && not_actual_file_p (output_file)))
5150	{
5151	/ Do nothing. /
5152	}
5153
5154	/ If -save-temps=obj and -o name, create the prefix to use for %b.*
5155	Otherwise just make -save-temps=obj the same as -save-temps=cwd. /*
5156	else if (save_temps_flag != SAVE_TEMPS_CWD && output_file != NULL)
5157	{
5158	free (ptr: dumpdir);
5159	dumpdir = NULL;
5160	temp = lbasename (output_file);
5161	if (temp != output_file)
5162	dumpdir = xstrndup (output_file,
5163	strlen (s: output_file) - strlen (s: temp));
5164	}
5165	else if (dumpdir)
5166	{
5167	free (ptr: dumpdir);
5168	dumpdir = NULL;
5169	}
5170
5171	if (save_temps_flag)
5172	save_temps_flag = SAVE_TEMPS_DUMP;
5173
5174	/ If there is any pathname component in an explicit -dumpbase, it*
5175	overrides dumpdir entirely, so discard it right away. Although
5176	the presence of an explicit -dumpdir matters for the driver, it
5177	shouldn't matter for other processes, that get all that's needed
5178	from the -dumpdir and -dumpbase always passed to them. /*
5179	if (dumpdir && dumpbase && lbasename (dumpbase) != dumpbase)
5180	{
5181	free (ptr: dumpdir);
5182	dumpdir = NULL;
5183	}
5184
5185	/ Check that dumpbase_ext matches the end of dumpbase, drop it*
5186	otherwise. /*
5187	if (dumpbase_ext && dumpbase && *dumpbase)
5188	{
5189	int lendb = strlen (s: dumpbase);
5190	int lendbx = strlen (s: dumpbase_ext);
5191
5192	/ -dumpbase-ext must be a suffix proper; discard it if it*
5193	matches all of -dumpbase, as that would make for an empty
5194	basename. /*
5195	if (lendbx >= lendb
5196	\|\| strcmp (s1: dumpbase + lendb - lendbx, s2: dumpbase_ext) != `0`)
5197	{
5198	free (ptr: dumpbase_ext);
5199	dumpbase_ext = NULL;
5200	}
5201	}
5202
5203	/ -dumpbase with multiple sources goes into dumpdir. With a single*
5204	source, it does only if linking and if dumpdir was not explicitly
5205	specified. /*
5206	if (dumpbase && *dumpbase
5207	&& (single_input_file_index () == -`2`
5208	\|\| (!have_c && !explicit_dumpdir)))
5209	{
5210	char *prefix;
5211
5212	if (dumpbase_ext)
5213	/ We checked that they match above. /
5214	dumpbase[strlen (s: dumpbase) - strlen (s: dumpbase_ext)] = `'\0'`;
5215
5216	if (dumpdir)
5217	prefix = concat (dumpdir, dumpbase, "-", NULL);
5218	else
5219	prefix = concat (dumpbase, "-", NULL);
5220
5221	free (ptr: dumpdir);
5222	free (ptr: dumpbase);
5223	free (ptr: dumpbase_ext);
5224	dumpbase = dumpbase_ext = NULL;
5225	dumpdir = prefix;
5226	dumpdir_trailing_dash_added = true;
5227	}
5228
5229	/ If dumpbase was not brought into dumpdir but we're linking, bring*
5230	output_file into dumpdir unless dumpdir was explicitly specified.
5231	The test for !explicit_dumpdir is further below, because we want
5232	to use the obase computation for a ghost outbase, passed to
5233	GCC_COLLECT_OPTIONS. /*
5234	else if (!have_c && (!explicit_dumpdir \|\| (dumpbase && !*dumpbase)))
5235	{
5236	/ If we get here, we know dumpbase was not specified, or it was*
5237	specified as an empty string. If it was anything else, it
5238	would have combined with dumpdir above, because the condition
5239	for dumpbase to be used when present is broader than the
5240	condition that gets us here. /*
5241	gcc_assert (!dumpbase \|\| !*dumpbase);
5242
5243	const char *obase;
5244	char *tofree = NULL;
5245	if (!output_file \|\| not_actual_file_p (output_file))
5246	obase = "a";
5247	else
5248	{
5249	obase = lbasename (output_file);
5250	size_t blen = strlen (s: obase), xlen;
5251	/ Drop the suffix if it's dumpbase_ext, if given,*
5252	otherwise .exe or the target executable suffix, or if the
5253	output was explicitly named a.out, but not otherwise. /*
5254	if (dumpbase_ext
5255	? (blen > (xlen = strlen (s: dumpbase_ext))
5256	&& strcmp (s1: (temp = (obase + blen - xlen)),
5257	s2: dumpbase_ext) == `0`)
5258	: ((temp = strrchr (s: obase + `1`, c: `'.'`))
5259	&& (xlen = strlen (s: temp))
5260	&& (strcmp (s1: temp, s2: ".exe") == `0`
5261	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5262	\|\| strcmp (temp, TARGET_EXECUTABLE_SUFFIX) == `0`
5263	#endif
5264	\|\| strcmp (s1: obase, s2: "a.out") == `0`)))
5265	{
5266	tofree = xstrndup (obase, blen - xlen);
5267	obase = tofree;
5268	}
5269	}
5270
5271	/ We wish to save this basename to the -dumpdir passed through*
5272	GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5273	but we do NOT wish to add it to e.g. %b, so we keep
5274	outbase_length as zero. /*
5275	gcc_assert (!outbase);
5276	outbase_length = `0`;
5277
5278	/ If we're building [dir1/]foo[.exe] out of a single input*
5279	[dir2/]foo.c that shares the same basename, dump to
5280	[dir2/]foo.c. rather than duplicating the basename into*
5281	[dir2/]foo-foo.c.. /
5282	int idxin;
5283	if (dumpbase
5284	\|\| ((idxin = single_input_file_index ()) >= `0`
5285	&& adds_single_suffix_p (f2: lbasename (infiles[idxin].name),
5286	f1: obase)))
5287	{
5288	if (obase == tofree)
5289	outbase = tofree;
5290	else
5291	{
5292	outbase = xstrdup (obase);
5293	free (ptr: tofree);
5294	}
5295	obase = tofree = NULL;
5296	}
5297	else
5298	{
5299	if (dumpdir)
5300	{
5301	char *p = concat (dumpdir, obase, "-", NULL);
5302	free (ptr: dumpdir);
5303	dumpdir = p;
5304	}
5305	else
5306	dumpdir = concat (obase, "-", NULL);
5307
5308	dumpdir_trailing_dash_added = true;
5309
5310	free (ptr: tofree);
5311	obase = tofree = NULL;
5312	}
5313
5314	if (!explicit_dumpdir \|\| dumpbase)
5315	{
5316	/ Absent -dumpbase and present -dumpbase-ext have been applied*
5317	to the linker output name, so compute fresh defaults for each
5318	compilation. /*
5319	free (ptr: dumpbase_ext);
5320	dumpbase_ext = NULL;
5321	}
5322	}
5323
5324	/ Now, if we're compiling, or if we haven't used the dumpbase*
5325	above, then outbase (%B) is derived from dumpbase, if given, or
5326	from the output name, given or implied. We can't precompute
5327	implied output names, but that's ok, since they're derived from
5328	input names. Just make sure we skip this if dumpbase is the
5329	empty string: we want to use input names then, so don't set
5330	outbase. /*
5331	if ((dumpbase \|\| have_c)
5332	&& !(dumpbase && !*dumpbase))
5333	{
5334	gcc_assert (!outbase);
5335
5336	if (dumpbase)
5337	{
5338	gcc_assert (single_input_file_index () != -`2`);
5339	/ We do not want lbasename here; dumpbase with dirnames*
5340	overrides dumpdir entirely, even if dumpdir is
5341	specified. /*
5342	if (dumpbase_ext)
5343	/ We've already checked above that the suffix matches. /
5344	outbase = xstrndup (dumpbase,
5345	strlen (s: dumpbase) - strlen (s: dumpbase_ext));
5346	else
5347	outbase = xstrdup (dumpbase);
5348	}
5349	else if (output_file && !not_actual_file_p (output_file))
5350	{
5351	outbase = xstrdup (lbasename (output_file));
5352	char *p = strrchr (s: outbase + `1`, c: `'.'`);
5353	if (p)
5354	*p = `'\0'`;
5355	}
5356
5357	if (outbase)
5358	outbase_length = strlen (s: outbase);
5359	}
5360
5361	/ If there is any pathname component in an explicit -dumpbase, do*
5362	not use dumpdir, but retain it to pass it on to the compiler. /*
5363	if (dumpdir)
5364	dumpdir_length = strlen (s: dumpdir);
5365	else
5366	dumpdir_length = `0`;
5367
5368	/ Check that dumpbase_ext, if still present, still matches the end*
5369	of dumpbase, if present, and drop it otherwise. We only retained
5370	it above when dumpbase was absent to maybe use it to drop the
5371	extension from output_name before combining it with dumpdir. We
5372	won't deal with -dumpbase-ext when -dumpbase is not explicitly
5373	given, even if just to activate backward-compatible dumpbase:
5374	dropping it on the floor is correct, expected and documented
5375	behavior. Attempting to deal with a -dumpbase-ext that might
5376	match the end of some input filename, or of the combination of
5377	the output basename with the suffix of the input filename,
5378	possible with an intermediate .gk extension for -fcompare-debug,
5379	is just calling for trouble. /*
5380	if (dumpbase_ext)
5381	{
5382	if (!dumpbase \|\| !*dumpbase)
5383	{
5384	free (ptr: dumpbase_ext);
5385	dumpbase_ext = NULL;
5386	}
5387	else
5388	gcc_assert (strcmp (dumpbase + strlen (dumpbase)
5389	- strlen (dumpbase_ext), dumpbase_ext) == `0`);
5390	}
5391
5392	if (save_temps_flag && use_pipes)
5393	{
5394	/ -save-temps overrides -pipe, so that temp files are produced /
5395	if (save_temps_flag)
5396	warning (`0`, "%<-pipe%> ignored because %<-save-temps%> specified");
5397	use_pipes = `0`;
5398	}
5399
5400	if (!compare_debug)
5401	{
5402	const char *gcd = env.get (name: "GCC_COMPARE_DEBUG");
5403
5404	if (gcd && gcd[`0`] == `'-'`)
5405	{
5406	compare_debug = `2`;
5407	compare_debug_opt = gcd;
5408	}
5409	else if (gcd && *gcd && strcmp (s1: gcd, s2: "0"))
5410	{
5411	compare_debug = `3`;
5412	compare_debug_opt = "-gtoggle";
5413	}
5414	}
5415	else if (compare_debug < `0`)
5416	{
5417	compare_debug = `0`;
5418	gcc_assert (!compare_debug_opt);
5419	}
5420
5421	/ Set up the search paths. We add directories that we expect to*
5422	contain GNU Toolchain components before directories specified by
5423	the machine description so that we will find GNU components (like
5424	the GNU assembler) before those of the host system. /*
5425
5426	/ If we don't know where the toolchain has been installed, use the*
5427	configured-in locations. /*
5428	if (!gcc_exec_prefix)
5429	{
5430	#ifndef OS2
5431	add_prefix (pprefix: &exec_prefixes, prefix: standard_libexec_prefix, component: "GCC",
5432	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `1`, os_multilib: `0`);
5433	add_prefix (pprefix: &exec_prefixes, prefix: standard_libexec_prefix, component: "BINUTILS",
5434	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `2`, os_multilib: `0`);
5435	add_prefix (pprefix: &exec_prefixes, prefix: standard_exec_prefix, component: "BINUTILS",
5436	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `2`, os_multilib: `0`);
5437	#endif
5438	add_prefix (pprefix: &startfile_prefixes, prefix: standard_exec_prefix, component: "BINUTILS",
5439	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `1`, os_multilib: `0`);
5440	}
5441
5442	gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
5443	tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
5444	dir_separator_str, NULL);
5445
5446	/ Look for tools relative to the location from which the driver is*
5447	running, or, if that is not available, the configured prefix. /*
5448	tooldir_prefix
5449	= concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
5450	spec_host_machine, dir_separator_str, spec_version,
5451	accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
5452	free (ptr: tooldir_prefix2);
5453
5454	add_prefix (pprefix: &exec_prefixes,
5455	prefix: concat (tooldir_prefix, "bin", dir_separator_str, NULL),
5456	component: "BINUTILS", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `0`);
5457	add_prefix (pprefix: &startfile_prefixes,
5458	prefix: concat (tooldir_prefix, "lib", dir_separator_str, NULL),
5459	component: "BINUTILS", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: `0`, os_multilib: `1`);
5460	free (ptr: tooldir_prefix);
5461
5462	#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5463	/ If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,*
5464	then consider it to relocate with the rest of the GCC installation
5465	if GCC_EXEC_PREFIX is set.
5466	``make_relative_prefix'' is not compiled for VMS, so don't call it. /*
5467	if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
5468	{
5469	char *tmp_prefix = get_relative_prefix (decoded_options[`0`].arg,
5470	standard_bindir_prefix,
5471	target_system_root);
5472	if (tmp_prefix && access_check (tmp_prefix, F_OK) == `0`)
5473	{
5474	target_system_root = tmp_prefix;
5475	target_system_root_changed = `1`;
5476	}
5477	}
5478	#endif
5479
5480	/ More prefixes are enabled in main, after we read the specs file*
5481	and determine whether this is cross-compilation or not. /*
5482
5483	if (n_infiles != `0` && n_infiles == last_language_n_infiles && spec_lang != `0`)
5484	warning (`0`, "%<-x %s%> after last input file has no effect", spec_lang);
5485
5486	/ Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG*
5487	environment variable. /*
5488	if (compare_debug == `2` \|\| compare_debug == `3`)
5489	{
5490	const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
5491	save_switch (opt, n_args: `0`, NULL, validated: false, known: true);
5492	compare_debug = `1`;
5493	}
5494
5495	/ Ensure we only invoke each subprocess once. /
5496	if (n_infiles == `0`
5497	&& (print_subprocess_help \|\| print_help_list \|\| print_version))
5498	{
5499	/ Create a dummy input file, so that we can pass*
5500	the help option on to the various sub-processes. /*
5501	add_infile (name: "help-dummy", language: "c");
5502	}
5503
5504	/ Decide if undefined variable references are allowed in specs. /
5505
5506	/ -v alone is safe. --version and --help alone or together are safe. Note*
5507	that -v would make them unsafe, as they'd then be run for subprocesses as
5508	well, the location of which might depend on variables possibly coming
5509	from self-specs. Note also that the command name is counted in
5510	decoded_options_count. /*
5511
5512	unsigned help_version_count = `0`;
5513
5514	if (print_version)
5515	help_version_count++;
5516
5517	if (print_help_list)
5518	help_version_count++;
5519
5520	spec_undefvar_allowed =
5521	((verbose_flag && decoded_options_count == `2`)
5522	\|\| help_version_count == decoded_options_count - `1`);
5523
5524	alloc_switch ();
5525	switches[n_switches].part1 = `0`;
5526	alloc_infile ();
5527	infiles[n_infiles].name = `0`;
5528	}
5529
5530	/ Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS*
5531	and place that in the environment. /*
5532
5533	static void
5534	set_collect_gcc_options (void)
5535	{
5536	int i;
5537	int first_time;
5538
5539	/ Build COLLECT_GCC_OPTIONS to have all of the options specified to*
5540	the compiler. /*
5541	obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5542	sizeof ("COLLECT_GCC_OPTIONS=") - `1`);
5543
5544	first_time = true;
5545	for (i = `0`; (int) i < n_switches; i++)
5546	{
5547	const char *const *args;
5548	const char p, q;
5549	if (!first_time)
5550	obstack_grow (&collect_obstack, " ", `1`);
5551
5552	first_time = false;
5553
5554	/ Ignore elided switches. /
5555	if ((switches[i].live_cond
5556	& (SWITCH_IGNORE \| SWITCH_KEEP_FOR_GCC))
5557	== SWITCH_IGNORE)
5558	continue;
5559
5560	obstack_grow (&collect_obstack, "'-", `2`);
5561	q = switches[i].part1;
5562	while ((p = strchr (s: q, c: `'\''`)))
5563	{
5564	obstack_grow (&collect_obstack, q, p - q);
5565	obstack_grow (&collect_obstack, "'\\''", `4`);
5566	q = ++p;
5567	}
5568	obstack_grow (&collect_obstack, q, strlen (q));
5569	obstack_grow (&collect_obstack, "'", `1`);
5570
5571	for (args = switches[i].args; args && *args; args++)
5572	{
5573	obstack_grow (&collect_obstack, " '", `2`);
5574	q = *args;
5575	while ((p = strchr (s: q, c: `'\''`)))
5576	{
5577	obstack_grow (&collect_obstack, q, p - q);
5578	obstack_grow (&collect_obstack, "'\\''", `4`);
5579	q = ++p;
5580	}
5581	obstack_grow (&collect_obstack, q, strlen (q));
5582	obstack_grow (&collect_obstack, "'", `1`);
5583	}
5584	}
5585
5586	if (dumpdir)
5587	{
5588	if (!first_time)
5589	obstack_grow (&collect_obstack, " ", `1`);
5590	first_time = false;
5591
5592	obstack_grow (&collect_obstack, "'-dumpdir' '", `12`);
5593	const char p, q;
5594
5595	q = dumpdir;
5596	while ((p = strchr (s: q, c: `'\''`)))
5597	{
5598	obstack_grow (&collect_obstack, q, p - q);
5599	obstack_grow (&collect_obstack, "'\\''", `4`);
5600	q = ++p;
5601	}
5602	obstack_grow (&collect_obstack, q, strlen (q));
5603
5604	obstack_grow (&collect_obstack, "'", `1`);
5605	}
5606
5607	obstack_grow (&collect_obstack, "\0", `1`);
5608	xputenv (XOBFINISH (&collect_obstack, char *));
5609	}
5610
5611	/ Process a spec string, accumulating and running commands. /
5612
5613	/ These variables describe the input file name.*
5614	input_file_number is the index on outfiles of this file,
5615	so that the output file name can be stored for later use by %o.
5616	input_basename is the start of the part of the input file
5617	sans all directory names, and basename_length is the number
5618	of characters starting there excluding the suffix .c or whatever. /*
5619
5620	static const char *gcc_input_filename;
5621	static int input_file_number;
5622	size_t input_filename_length;
5623	static int basename_length;
5624	static int suffixed_basename_length;
5625	static const char *input_basename;
5626	static const char *input_suffix;
5627	#ifndef HOST_LACKS_INODE_NUMBERS
5628	static struct stat input_stat;
5629	#endif
5630	static int input_stat_set;
5631
5632	/ The compiler used to process the current input file. /
5633	static struct compiler *input_file_compiler;
5634
5635	/ These are variables used within do_spec and do_spec_1. /
5636
5637	/ Nonzero if an arg has been started and not yet terminated*
5638	(with space, tab or newline). /*
5639	static int arg_going;
5640
5641	/ Nonzero means %d or %g has been seen; the next arg to be terminated*
5642	is a temporary file name. /*
5643	static int delete_this_arg;
5644
5645	/ Nonzero means %w has been seen; the next arg to be terminated*
5646	is the output file name of this compilation. /*
5647	static int this_is_output_file;
5648
5649	/ Nonzero means %s has been seen; the next arg to be terminated*
5650	is the name of a library file and we should try the standard
5651	search dirs for it. /*
5652	static int this_is_library_file;
5653
5654	/ Nonzero means %T has been seen; the next arg to be terminated*
5655	is the name of a linker script and we should try all of the
5656	standard search dirs for it. If it is found insert a --script
5657	command line switch and then substitute the full path in place,
5658	otherwise generate an error message. /*
5659	static int this_is_linker_script;
5660
5661	/ Nonzero means that the input of this command is coming from a pipe. /
5662	static int input_from_pipe;
5663
5664	/ Nonnull means substitute this for any suffix when outputting a switches*
5665	arguments. /*
5666	static const char *suffix_subst;
5667
5668	/ If there is an argument being accumulated, terminate it and store it. /
5669
5670	static void
5671	end_going_arg (void)
5672	{
5673	if (arg_going)
5674	{
5675	const char *string;
5676
5677	obstack_1grow (&obstack, `0`);
5678	string = XOBFINISH (&obstack, const char *);
5679	if (this_is_library_file)
5680	string = find_file (string);
5681	if (this_is_linker_script)
5682	{
5683	char * full_script_path = find_a_file (pprefix: &startfile_prefixes, name: string, R_OK, do_multi: true);
5684
5685	if (full_script_path == NULL)
5686	{
5687	error ("unable to locate default linker script %qs in the library search paths", string);
5688	/ Script was not found on search path. /
5689	return;
5690	}
5691	store_arg (arg: "--script", delete_always: false, delete_failure: false);
5692