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	string = full_script_path;
5693	}
5694	store_arg (arg: string, delete_always: delete_this_arg, delete_failure: this_is_output_file);
5695	if (this_is_output_file)
5696	outfiles[input_file_number] = string;
5697	arg_going = 0;
5698	}
5699	}
5700
5701
5702	/* Parse the WRAPPER string which is a comma separated list of the command line
5703	and insert them into the beginning of argbuf. */
5704
5705	static void
5706	insert_wrapper (const char *wrapper)
5707	{
5708	int n = 0;
5709	int i;
5710	char *buf = xstrdup (wrapper);
5711	char *p = buf;
5712	unsigned int old_length = argbuf.length ();
5713
5714	do
5715	{
5716	n++;
5717	while (*p == ',')
5718	p++;
5719	}
5720	while ((p = strchr (s: p, c: ',')) != NULL);
5721
5722	argbuf.safe_grow (len: old_length + n, exact: true);
5723	memmove (dest: argbuf.address () + n,
5724	src: argbuf.address (),
5725	n: old_length * sizeof (const_char_p));
5726
5727	i = 0;
5728	p = buf;
5729	do
5730	{
5731	while (*p == ',')
5732	{
5733	*p = 0;
5734	p++;
5735	}
5736	argbuf[i] = p;
5737	i++;
5738	}
5739	while ((p = strchr (s: p, c: ',')) != NULL);
5740	gcc_assert (i == n);
5741	}
5742
5743	/* Process the spec SPEC and run the commands specified therein.
5744	Returns 0 if the spec is successfully processed; -1 if failed. */
5745
5746	int
5747	do_spec (const char *spec)
5748	{
5749	int value;
5750
5751	value = do_spec_2 (spec, NULL);
5752
5753	/* Force out any unfinished command.
5754	If -pipe, this forces out the last command if it ended in `|'. */
5755	if (value == 0)
5756	{
5757	if (argbuf.length () > 0
5758	&& !strcmp (s1: argbuf.last (), s2: "|"))
5759	argbuf.pop ();
5760
5761	set_collect_gcc_options ();
5762
5763	if (argbuf.length () > 0)
5764	value = execute ();
5765	}
5766
5767	return value;
5768	}
5769
5770	/* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5771	of a matched * pattern which may be re-injected by way of %*. */
5772
5773	static int
5774	do_spec_2 (const char *spec, const char *soft_matched_part)
5775	{
5776	int result;
5777
5778	clear_args ();
5779	arg_going = 0;
5780	delete_this_arg = 0;
5781	this_is_output_file = 0;
5782	this_is_library_file = 0;
5783	this_is_linker_script = 0;
5784	input_from_pipe = 0;
5785	suffix_subst = NULL;
5786
5787	result = do_spec_1 (spec, 0, soft_matched_part);
5788
5789	end_going_arg ();
5790
5791	return result;
5792	}
5793
5794	/* Process the given spec string and add any new options to the end
5795	of the switches/n_switches array. */
5796
5797	static void
5798	do_option_spec (const char *name, const char *spec)
5799	{
5800	unsigned int i, value_count, value_len;
5801	const char *p, *q, *value;
5802	char *tmp_spec, *tmp_spec_p;
5803
5804	if (configure_default_options[0].name == NULL)
5805	return;
5806
5807	for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
5808	if (strcmp (s1: configure_default_options[i].name, s2: name) == 0)
5809	break;
5810	if (i == ARRAY_SIZE (configure_default_options))
5811	return;
5812
5813	value = configure_default_options[i].value;
5814	value_len = strlen (s: value);
5815
5816	/* Compute the size of the final spec. */
5817	value_count = 0;
5818	p = spec;
5819	while ((p = strstr (haystack: p, needle: "%(VALUE)")) != NULL)
5820	{
5821	p ++;
5822	value_count ++;
5823	}
5824
5825	/* Replace each %(VALUE) by the specified value. */
5826	tmp_spec = (char *) alloca (strlen (spec) + 1
5827	+ value_count * (value_len - strlen ("%(VALUE)")));
5828	tmp_spec_p = tmp_spec;
5829	q = spec;
5830	while ((p = strstr (haystack: q, needle: "%(VALUE)")) != NULL)
5831	{
5832	memcpy (dest: tmp_spec_p, src: q, n: p - q);
5833	tmp_spec_p = tmp_spec_p + (p - q);
5834	memcpy (dest: tmp_spec_p, src: value, n: value_len);
5835	tmp_spec_p += value_len;
5836	q = p + strlen (s: "%(VALUE)");
5837	}
5838	strcpy (dest: tmp_spec_p, src: q);
5839
5840	do_self_spec (tmp_spec);
5841	}
5842
5843	/* Process the given spec string and add any new options to the end
5844	of the switches/n_switches array. */
5845
5846	static void
5847	do_self_spec (const char *spec)
5848	{
5849	int i;
5850
5851	do_spec_2 (spec, NULL);
5852	do_spec_1 (" ", 0, NULL);
5853
5854	/* Mark %<S switches processed by do_self_spec to be ignored permanently.
5855	do_self_specs adds the replacements to switches array, so it shouldn't
5856	be processed afterwards. */
5857	for (i = 0; i < n_switches; i++)
5858	if ((switches[i].live_cond & SWITCH_IGNORE))
5859	switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
5860
5861	if (argbuf.length () > 0)
5862	{
5863	const char **argbuf_copy;
5864	struct cl_decoded_option *decoded_options;
5865	struct cl_option_handlers handlers;
5866	unsigned int decoded_options_count;
5867	unsigned int j;
5868
5869	/* Create a copy of argbuf with a dummy argv[0] entry for
5870	decode_cmdline_options_to_array. */
5871	argbuf_copy = XNEWVEC (const char *,
5872	argbuf.length () + 1);
5873	argbuf_copy[0] = "";
5874	memcpy (dest: argbuf_copy + 1, src: argbuf.address (),
5875	n: argbuf.length () * sizeof (const char *));
5876
5877	decode_cmdline_options_to_array (argc: argbuf.length () + 1,
5878	argv: argbuf_copy,
5879	CL_DRIVER, decoded_options: &decoded_options,
5880	decoded_options_count: &decoded_options_count);
5881	free (ptr: argbuf_copy);
5882
5883	set_option_handlers (&handlers);
5884
5885	for (j = 1; j < decoded_options_count; j++)
5886	{
5887	switch (decoded_options[j].opt_index)
5888	{
5889	case OPT_SPECIAL_input_file:
5890	/* Specs should only generate options, not input
5891	files. */
5892	if (strcmp (s1: decoded_options[j].arg, s2: "-") != 0)
5893	fatal_error (input_location,
5894	"switch %qs does not start with %<-%>",
5895	decoded_options[j].arg);
5896	else
5897	fatal_error (input_location,
5898	"spec-generated switch is just %<-%>");
5899	break;
5900
5901	case OPT_fcompare_debug_second:
5902	case OPT_fcompare_debug:
5903	case OPT_fcompare_debug_:
5904	case OPT_o:
5905	/* Avoid duplicate processing of some options from
5906	compare-debug specs; just save them here. */
5907	save_switch (opt: decoded_options[j].canonical_option[0],
5908	n_args: (decoded_options[j].canonical_option_num_elements
5909	- 1),
5910	args: &decoded_options[j].canonical_option[1], validated: false, known: true);
5911	break;
5912
5913	default:
5914	read_cmdline_option (opts: &global_options, opts_set: &global_options_set,
5915	decoded: decoded_options + j, UNKNOWN_LOCATION,
5916	CL_DRIVER, handlers: &handlers, dc: global_dc);
5917	break;
5918	}
5919	}
5920
5921	free (ptr: decoded_options);
5922
5923	alloc_switch ();
5924	switches[n_switches].part1 = 0;
5925	}
5926	}
5927
5928	/* Callback for processing %D and %I specs. */
5929
5930	struct spec_path_info {
5931	const char *option;
5932	const char *append;
5933	size_t append_len;
5934	bool omit_relative;
5935	bool separate_options;
5936	bool realpaths;
5937	};
5938
5939	static void *
5940	spec_path (char *path, void *data)
5941	{
5942	struct spec_path_info *info = (struct spec_path_info *) data;
5943	size_t len = 0;
5944	char save = 0;
5945
5946	/* The path must exist; we want to resolve it to the realpath so that this
5947	can be embedded as a runpath. */
5948	if (info->realpaths)
5949	path = lrealpath (path);
5950
5951	/* However, if we failed to resolve it - perhaps because there was a bogus
5952	-B option on the command line, then punt on this entry. */
5953	if (!path)
5954	return NULL;
5955
5956	if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5957	return NULL;
5958
5959	if (info->append_len != 0)
5960	{
5961	len = strlen (s: path);
5962	memcpy (dest: path + len, src: info->append, n: info->append_len + 1);
5963	}
5964
5965	if (!is_directory (path, true))
5966	return NULL;
5967
5968	do_spec_1 (info->option, 1, NULL);
5969	if (info->separate_options)
5970	do_spec_1 (" ", 0, NULL);
5971
5972	if (info->append_len == 0)
5973	{
5974	len = strlen (s: path);
5975	save = path[len - 1];
5976	if (IS_DIR_SEPARATOR (path[len - 1]))
5977	path[len - 1] = '\0';
5978	}
5979
5980	do_spec_1 (path, 1, NULL);
5981	do_spec_1 (" ", 0, NULL);
5982
5983	/* Must not damage the original path. */
5984	if (info->append_len == 0)
5985	path[len - 1] = save;
5986
5987	return NULL;
5988	}
5989
5990	/* True if we should compile INFILE. */
5991
5992	static bool
5993	compile_input_file_p (struct infile *infile)
5994	{
5995	if ((!infile->language) || (infile->language[0] != '*'))
5996	if (infile->incompiler == input_file_compiler)
5997	return true;
5998	return false;
5999	}
6000
6001	/* Process each member of VEC as a spec. */
6002
6003	static void
6004	do_specs_vec (vec<char_p> vec)
6005	{
6006	for (char *opt : vec)
6007	{
6008	do_spec_1 (opt, 1, NULL);
6009	/* Make each accumulated option a separate argument. */
6010	do_spec_1 (" ", 0, NULL);
6011	}
6012	}
6013
6014	/* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
6015
6016	static void
6017	putenv_COLLECT_AS_OPTIONS (vec<char_p> vec)
6018	{
6019	if (vec.is_empty ())
6020	return;
6021
6022	obstack_init (&collect_obstack);
6023	obstack_grow (&collect_obstack, "COLLECT_AS_OPTIONS=",
6024	strlen ("COLLECT_AS_OPTIONS="));
6025
6026	char *opt;
6027	unsigned ix;
6028
6029	FOR_EACH_VEC_ELT (vec, ix, opt)
6030	{
6031	obstack_1grow (&collect_obstack, '\'');
6032	obstack_grow (&collect_obstack, opt, strlen (opt));
6033	obstack_1grow (&collect_obstack, '\'');
6034	if (ix < vec.length () - 1)
6035	obstack_1grow(&collect_obstack, ' ');
6036	}
6037
6038	obstack_1grow (&collect_obstack, '\0');
6039	xputenv (XOBFINISH (&collect_obstack, char *));
6040	}
6041
6042	/* Process the sub-spec SPEC as a portion of a larger spec.
6043	This is like processing a whole spec except that we do
6044	not initialize at the beginning and we do not supply a
6045	newline by default at the end.
6046	INSWITCH nonzero means don't process %-sequences in SPEC;
6047	in this case, % is treated as an ordinary character.
6048	This is used while substituting switches.
6049	INSWITCH nonzero also causes SPC not to terminate an argument.
6050
6051	Value is zero unless a line was finished
6052	and the command on that line reported an error. */
6053
6054	static int
6055	do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
6056	{
6057	const char *p = spec;
6058	int c;
6059	int i;
6060	int value;
6061
6062	/* If it's an empty string argument to a switch, keep it as is. */
6063	if (inswitch && !*p)
6064	arg_going = 1;
6065
6066	while ((c = *p++))
6067	/* If substituting a switch, treat all chars like letters.
6068	Otherwise, NL, SPC, TAB and % are special. */
6069	switch (inswitch ? 'a' : c)
6070	{
6071	case '\n':
6072	end_going_arg ();
6073
6074	if (argbuf.length () > 0
6075	&& !strcmp (s1: argbuf.last (), s2: "|"))
6076	{
6077	/* A `|' before the newline means use a pipe here,
6078	but only if -pipe was specified.
6079	Otherwise, execute now and don't pass the `|' as an arg. */
6080	if (use_pipes)
6081	{
6082	input_from_pipe = 1;
6083	break;
6084	}
6085	else
6086	argbuf.pop ();
6087	}
6088
6089	set_collect_gcc_options ();
6090
6091	if (argbuf.length () > 0)
6092	{
6093	value = execute ();
6094	if (value)
6095	return value;
6096	}
6097	/* Reinitialize for a new command, and for a new argument. */
6098	clear_args ();
6099	arg_going = 0;
6100	delete_this_arg = 0;
6101	this_is_output_file = 0;
6102	this_is_library_file = 0;
6103	this_is_linker_script = 0;
6104	input_from_pipe = 0;
6105	break;
6106
6107	case '|':
6108	end_going_arg ();
6109
6110	/* Use pipe */
6111	obstack_1grow (&obstack, c);
6112	arg_going = 1;
6113	break;
6114
6115	case '\t':
6116	case ' ':
6117	end_going_arg ();
6118
6119	/* Reinitialize for a new argument. */
6120	delete_this_arg = 0;
6121	this_is_output_file = 0;
6122	this_is_library_file = 0;
6123	this_is_linker_script = 0;
6124	break;
6125
6126	case '%':
6127	switch (c = *p++)
6128	{
6129	case 0:
6130	fatal_error (input_location, "spec %qs invalid", spec);
6131
6132	case 'b':
6133	/* Don't use %b in the linker command. */
6134	gcc_assert (suffixed_basename_length);
6135	if (!this_is_output_file && dumpdir_length)
6136	obstack_grow (&obstack, dumpdir, dumpdir_length);
6137	if (this_is_output_file || !outbase_length)
6138	obstack_grow (&obstack, input_basename, basename_length);
6139	else
6140	obstack_grow (&obstack, outbase, outbase_length);
6141	if (compare_debug < 0)
6142	obstack_grow (&obstack, ".gk", 3);
6143	arg_going = 1;
6144	break;
6145
6146	case 'B':
6147	/* Don't use %B in the linker command. */
6148	gcc_assert (suffixed_basename_length);
6149	if (!this_is_output_file && dumpdir_length)
6150	obstack_grow (&obstack, dumpdir, dumpdir_length);
6151	if (this_is_output_file || !outbase_length)
6152	obstack_grow (&obstack, input_basename, basename_length);
6153	else
6154	obstack_grow (&obstack, outbase, outbase_length);
6155	if (compare_debug < 0)
6156	obstack_grow (&obstack, ".gk", 3);
6157	obstack_grow (&obstack, input_basename + basename_length,
6158	suffixed_basename_length - basename_length);
6159
6160	arg_going = 1;
6161	break;
6162
6163	case 'd':
6164	delete_this_arg = 2;
6165	break;
6166
6167	/* Dump out the directories specified with LIBRARY_PATH,
6168	followed by the absolute directories
6169	that we search for startfiles. */
6170	case 'D':
6171	{
6172	struct spec_path_info info;
6173
6174	info.option = "-L";
6175	info.append_len = 0;
6176	#ifdef RELATIVE_PREFIX_NOT_LINKDIR
6177	/* Used on systems which record the specified -L dirs
6178	and use them to search for dynamic linking.
6179	Relative directories always come from -B,
6180	and it is better not to use them for searching
6181	at run time. In particular, stage1 loses. */
6182	info.omit_relative = true;
6183	#else
6184	info.omit_relative = false;
6185	#endif
6186	info.separate_options = false;
6187	info.realpaths = false;
6188
6189	for_each_path (paths: &startfile_prefixes, do_multi: true, extra_space: 0, callback: spec_path, callback_info: &info);
6190	}
6191	break;
6192
6193	case 'P':
6194	{
6195	struct spec_path_info info;
6196
6197	info.option = RUNPATH_OPTION;
6198	info.append_len = 0;
6199	info.omit_relative = false;
6200	info.separate_options = true;
6201	/* We want to embed the actual paths that have the libraries. */
6202	info.realpaths = true;
6203
6204	for_each_path (paths: &startfile_prefixes, do_multi: true, extra_space: 0, callback: spec_path, callback_info: &info);
6205	}
6206	break;
6207
6208	case 'e':
6209	/* %efoo means report an error with `foo' as error message
6210	and don't execute any more commands for this file. */
6211	{
6212	const char *q = p;
6213	char *buf;
6214	while (*p != 0 && *p != '\n')
6215	p++;
6216	buf = (char *) alloca (p - q + 1);
6217	strncpy (dest: buf, src: q, n: p - q);
6218	buf[p - q] = 0;
6219	error ("%s", _(buf));
6220	return -1;
6221	}
6222	break;
6223	case 'n':
6224	/* %nfoo means report a notice with `foo' on stderr. */
6225	{
6226	const char *q = p;
6227	char *buf;
6228	while (*p != 0 && *p != '\n')
6229	p++;
6230	buf = (char *) alloca (p - q + 1);
6231	strncpy (dest: buf, src: q, n: p - q);
6232	buf[p - q] = 0;
6233	inform (UNKNOWN_LOCATION, "%s", _(buf));
6234	if (*p)
6235	p++;
6236	}
6237	break;
6238
6239	case 'j':
6240	{
6241	struct stat st;
6242
6243	/* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6244	defined, and it is not a directory, and it is
6245	writable, use it. Otherwise, treat this like any
6246	other temporary file. */
6247
6248	if ((!save_temps_flag)
6249	&& (stat (HOST_BIT_BUCKET, buf: &st) == 0) && (!S_ISDIR (st.st_mode))
6250	&& (access (HOST_BIT_BUCKET, W_OK) == 0))
6251	{
6252	obstack_grow (&obstack, HOST_BIT_BUCKET,
6253	strlen (HOST_BIT_BUCKET));
6254	delete_this_arg = 0;
6255	arg_going = 1;
6256	break;
6257	}
6258	}
6259	goto create_temp_file;
6260	case '|':
6261	if (use_pipes)
6262	{
6263	obstack_1grow (&obstack, '-');
6264	delete_this_arg = 0;
6265	arg_going = 1;
6266
6267	/* consume suffix */
6268	while (*p == '.' || ISALNUM ((unsigned char) *p))
6269	p++;
6270	if (p[0] == '%' && p[1] == 'O')
6271	p += 2;
6272
6273	break;
6274	}
6275	goto create_temp_file;
6276	case 'm':
6277	if (use_pipes)
6278	{
6279	/* consume suffix */
6280	while (*p == '.' || ISALNUM ((unsigned char) *p))
6281	p++;
6282	if (p[0] == '%' && p[1] == 'O')
6283	p += 2;
6284
6285	break;
6286	}
6287	goto create_temp_file;
6288	case 'g':
6289	case 'u':
6290	case 'U':
6291	create_temp_file:
6292	{
6293	struct temp_name *t;
6294	int suffix_length;
6295	const char *suffix = p;
6296	char *saved_suffix = NULL;
6297
6298	while (*p == '.' || ISALNUM ((unsigned char) *p))
6299	p++;
6300	suffix_length = p - suffix;
6301	if (p[0] == '%' && p[1] == 'O')
6302	{
6303	p += 2;
6304	/* We don't support extra suffix characters after %O. */
6305	if (*p == '.' || ISALNUM ((unsigned char) *p))
6306	fatal_error (input_location,
6307	"spec %qs has invalid %<%%0%c%>", spec, *p);
6308	if (suffix_length == 0)
6309	suffix = TARGET_OBJECT_SUFFIX;
6310	else
6311	{
6312	saved_suffix
6313	= XNEWVEC (char, suffix_length
6314	+ strlen (TARGET_OBJECT_SUFFIX) + 1);
6315	strncpy (dest: saved_suffix, src: suffix, n: suffix_length);
6316	strcpy (dest: saved_suffix + suffix_length,
6317	TARGET_OBJECT_SUFFIX);
6318	}
6319	suffix_length += strlen (TARGET_OBJECT_SUFFIX);
6320	}
6321
6322	if (compare_debug < 0)
6323	{
6324	suffix = concat (".gk", suffix, NULL);
6325	suffix_length += 3;
6326	}
6327
6328	/* If -save-temps was specified, use that for the
6329	temp file. */
6330	if (save_temps_flag)
6331	{
6332	char *tmp;
6333	bool adjusted_suffix = false;
6334	if (suffix_length
6335	&& !outbase_length && !basename_length
6336	&& !dumpdir_trailing_dash_added)
6337	{
6338	adjusted_suffix = true;
6339	suffix++;
6340	suffix_length--;
6341	}
6342	temp_filename_length
6343	= dumpdir_length + suffix_length + 1;
6344	if (outbase_length)
6345	temp_filename_length += outbase_length;
6346	else
6347	temp_filename_length += basename_length;
6348	tmp = (char *) alloca (temp_filename_length);
6349	if (dumpdir_length)
6350	memcpy (dest: tmp, src: dumpdir, n: dumpdir_length);
6351	if (outbase_length)
6352	memcpy (dest: tmp + dumpdir_length, src: outbase,
6353	n: outbase_length);
6354	else if (basename_length)
6355	memcpy (dest: tmp + dumpdir_length, src: input_basename,
6356	n: basename_length);
6357	memcpy (dest: tmp + temp_filename_length - suffix_length - 1,
6358	src: suffix, n: suffix_length);
6359	if (adjusted_suffix)
6360	{
6361	adjusted_suffix = false;
6362	suffix--;
6363	suffix_length++;
6364	}
6365	tmp[temp_filename_length - 1] = '\0';
6366	temp_filename = tmp;
6367
6368	if (filename_cmp (s1: temp_filename, s2: gcc_input_filename) != 0)
6369	{
6370	#ifndef HOST_LACKS_INODE_NUMBERS
6371	struct stat st_temp;
6372
6373	/* Note, set_input() resets input_stat_set to 0. */
6374	if (input_stat_set == 0)
6375	{
6376	input_stat_set = stat (file: gcc_input_filename,
6377	buf: &input_stat);
6378	if (input_stat_set >= 0)
6379	input_stat_set = 1;
6380	}
6381
6382	/* If we have the stat for the gcc_input_filename
6383	and we can do the stat for the temp_filename
6384	then the they could still refer to the same
6385	file if st_dev/st_ino's are the same. */
6386	if (input_stat_set != 1
6387	|| stat (file: temp_filename, buf: &st_temp) < 0
6388	|| input_stat.st_dev != st_temp.st_dev
6389	|| input_stat.st_ino != st_temp.st_ino)
6390	#else
6391	/* Just compare canonical pathnames. */
6392	char* input_realname = lrealpath (gcc_input_filename);
6393	char* temp_realname = lrealpath (temp_filename);
6394	bool files_differ = filename_cmp (input_realname, temp_realname);
6395	free (input_realname);
6396	free (temp_realname);
6397	if (files_differ)
6398	#endif
6399	{
6400	temp_filename
6401	= save_string (temp_filename,
6402	temp_filename_length - 1);
6403	obstack_grow (&obstack, temp_filename,
6404	temp_filename_length);
6405	arg_going = 1;
6406	delete_this_arg = 0;
6407	break;
6408	}
6409	}
6410	}
6411
6412	/* See if we already have an association of %g/%u/%U and
6413	suffix. */
6414	for (t = temp_names; t; t = t->next)
6415	if (t->length == suffix_length
6416	&& strncmp (s1: t->suffix, s2: suffix, n: suffix_length) == 0
6417	&& t->unique == (c == 'u' || c == 'U' || c == 'j'))
6418	break;
6419
6420	/* Make a new association if needed. %u and %j
6421	require one. */
6422	if (t == 0 || c == 'u' || c == 'j')
6423	{
6424	if (t == 0)
6425	{
6426	t = XNEW (struct temp_name);
6427	t->next = temp_names;
6428	temp_names = t;
6429	}
6430	t->length = suffix_length;
6431	if (saved_suffix)
6432	{
6433	t->suffix = saved_suffix;
6434	saved_suffix = NULL;
6435	}
6436	else
6437	t->suffix = save_string (suffix, suffix_length);
6438	t->unique = (c == 'u' || c == 'U' || c == 'j');
6439	temp_filename = make_temp_file (t->suffix);
6440	temp_filename_length = strlen (s: temp_filename);
6441	t->filename = temp_filename;
6442	t->filename_length = temp_filename_length;
6443	}
6444
6445	free (ptr: saved_suffix);
6446
6447	obstack_grow (&obstack, t->filename, t->filename_length);
6448	delete_this_arg = 1;
6449	}
6450	arg_going = 1;
6451	break;
6452
6453	case 'i':
6454	if (combine_inputs)
6455	{
6456	/* We are going to expand `%i' into `@FILE', where FILE
6457	is a newly-created temporary filename. The filenames
6458	that would usually be expanded in place of %o will be
6459	written to the temporary file. */
6460	if (at_file_supplied)
6461	open_at_file ();
6462
6463	for (i = 0; (int) i < n_infiles; i++)
6464	if (compile_input_file_p (infile: &infiles[i]))
6465	{
6466	store_arg (arg: infiles[i].name, delete_always: 0, delete_failure: 0);
6467	infiles[i].compiled = true;
6468	}
6469
6470	if (at_file_supplied)
6471	close_at_file ();
6472	}
6473	else
6474	{
6475	obstack_grow (&obstack, gcc_input_filename,
6476	input_filename_length);
6477	arg_going = 1;
6478	}
6479	break;
6480
6481	case 'I':
6482	{
6483	struct spec_path_info info;
6484
6485	if (multilib_dir)
6486	{
6487	do_spec_1 (spec: "-imultilib", inswitch: 1, NULL);
6488	/* Make this a separate argument. */
6489	do_spec_1 (spec: " ", inswitch: 0, NULL);
6490	do_spec_1 (spec: multilib_dir, inswitch: 1, NULL);
6491	do_spec_1 (spec: " ", inswitch: 0, NULL);
6492	}
6493
6494	if (multiarch_dir)
6495	{
6496	do_spec_1 (spec: "-imultiarch", inswitch: 1, NULL);
6497	/* Make this a separate argument. */
6498	do_spec_1 (spec: " ", inswitch: 0, NULL);
6499	do_spec_1 (spec: multiarch_dir, inswitch: 1, NULL);
6500	do_spec_1 (spec: " ", inswitch: 0, NULL);
6501	}
6502
6503	if (gcc_exec_prefix)
6504	{
6505	do_spec_1 (spec: "-iprefix", inswitch: 1, NULL);
6506	/* Make this a separate argument. */
6507	do_spec_1 (spec: " ", inswitch: 0, NULL);
6508	do_spec_1 (spec: gcc_exec_prefix, inswitch: 1, NULL);
6509	do_spec_1 (spec: " ", inswitch: 0, NULL);
6510	}
6511
6512	if (target_system_root_changed ||
6513	(target_system_root && target_sysroot_hdrs_suffix))
6514	{
6515	do_spec_1 (spec: "-isysroot", inswitch: 1, NULL);
6516	/* Make this a separate argument. */
6517	do_spec_1 (spec: " ", inswitch: 0, NULL);
6518	do_spec_1 (spec: target_system_root, inswitch: 1, NULL);
6519	if (target_sysroot_hdrs_suffix)
6520	do_spec_1 (spec: target_sysroot_hdrs_suffix, inswitch: 1, NULL);
6521	do_spec_1 (spec: " ", inswitch: 0, NULL);
6522	}
6523
6524	info.option = "-isystem";
6525	info.append = "include";
6526	info.append_len = strlen (s: info.append);
6527	info.omit_relative = false;
6528	info.separate_options = true;
6529	info.realpaths = false;
6530
6531	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6532	callback: spec_path, callback_info: &info);
6533
6534	info.append = "include-fixed";
6535	if (*sysroot_hdrs_suffix_spec)
6536	info.append = concat (info.append, dir_separator_str,
6537	multilib_dir, NULL);
6538	else if (multiarch_dir)
6539	{
6540	/* For multiarch, search include-fixed/<multiarch-dir>
6541	before include-fixed. */
6542	info.append = concat (info.append, dir_separator_str,
6543	multiarch_dir, NULL);
6544	info.append_len = strlen (s: info.append);
6545	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6546	callback: spec_path, callback_info: &info);
6547
6548	info.append = "include-fixed";
6549	}
6550	info.append_len = strlen (s: info.append);
6551	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6552	callback: spec_path, callback_info: &info);
6553	}
6554	break;
6555
6556	case 'o':
6557	/* We are going to expand `%o' into `@FILE', where FILE
6558	is a newly-created temporary filename. The filenames
6559	that would usually be expanded in place of %o will be
6560	written to the temporary file. */
6561	if (at_file_supplied)
6562	open_at_file ();
6563
6564	for (i = 0; i < n_infiles + lang_specific_extra_outfiles; i++)
6565	if (outfiles[i])
6566	store_arg (arg: outfiles[i], delete_always: 0, delete_failure: 0);
6567
6568	if (at_file_supplied)
6569	close_at_file ();
6570	break;
6571
6572	case 'O':
6573	obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
6574	arg_going = 1;
6575	break;
6576
6577	case 's':
6578	this_is_library_file = 1;
6579	break;
6580
6581	case 'T':
6582	this_is_linker_script = 1;
6583	break;
6584
6585	case 'V':
6586	outfiles[input_file_number] = NULL;
6587	break;
6588
6589	case 'w':
6590	this_is_output_file = 1;
6591	break;
6592
6593	case 'W':
6594	{
6595	unsigned int cur_index = argbuf.length ();
6596	/* Handle the {...} following the %W. */
6597	if (*p != '{')
6598	fatal_error (input_location,
6599	"spec %qs has invalid %<%%W%c%>", spec, *p);
6600	p = handle_braces (p + 1);
6601	if (p == 0)
6602	return -1;
6603	end_going_arg ();
6604	/* If any args were output, mark the last one for deletion
6605	on failure. */
6606	if (argbuf.length () != cur_index)
6607	record_temp_file (filename: argbuf.last (), always_delete: 0, fail_delete: 1);
6608	break;
6609	}
6610
6611	case '@':
6612	/* Handle the {...} following the %@. */
6613	if (*p != '{')
6614	fatal_error (input_location,
6615	"spec %qs has invalid %<%%@%c%>", spec, *p);
6616	if (at_file_supplied)
6617	open_at_file ();
6618	p = handle_braces (p + 1);
6619	if (at_file_supplied)
6620	close_at_file ();
6621	if (p == 0)
6622	return -1;
6623	break;
6624
6625	/* %x{OPTION} records OPTION for %X to output. */
6626	case 'x':
6627	{
6628	const char *p1 = p;
6629	char *string;
6630
6631	/* Skip past the option value and make a copy. */
6632	if (*p != '{')
6633	fatal_error (input_location,
6634	"spec %qs has invalid %<%%x%c%>", spec, *p);
6635	while (*p++ != '}')
6636	;
6637	string = save_string (p1 + 1, p - p1 - 2);
6638
6639	/* See if we already recorded this option. */
6640	for (const char *opt : linker_options)
6641	if (! strcmp (s1: string, s2: opt))
6642	{
6643	free (ptr: string);
6644	return 0;
6645	}
6646
6647	/* This option is new; add it. */
6648	add_linker_option (option: string, len: strlen (s: string));
6649	free (ptr: string);
6650	}
6651	break;
6652
6653	/* Dump out the options accumulated previously using %x. */
6654	case 'X':
6655	do_specs_vec (vec: linker_options);
6656	break;
6657
6658	/* Dump out the options accumulated previously using -Wa,. */
6659	case 'Y':
6660	do_specs_vec (vec: assembler_options);
6661	break;
6662
6663	/* Dump out the options accumulated previously using -Wp,. */
6664	case 'Z':
6665	do_specs_vec (vec: preprocessor_options);
6666	break;
6667
6668	/* Here are digits and numbers that just process
6669	a certain constant string as a spec. */
6670
6671	case '1':
6672	value = do_spec_1 (spec: cc1_spec, inswitch: 0, NULL);
6673	if (value != 0)
6674	return value;
6675	break;
6676
6677	case '2':
6678	value = do_spec_1 (spec: cc1plus_spec, inswitch: 0, NULL);
6679	if (value != 0)
6680	return value;
6681	break;
6682
6683	case 'a':
6684	value = do_spec_1 (spec: asm_spec, inswitch: 0, NULL);
6685	if (value != 0)
6686	return value;
6687	break;
6688
6689	case 'A':
6690	value = do_spec_1 (spec: asm_final_spec, inswitch: 0, NULL);
6691	if (value != 0)
6692	return value;
6693	break;
6694
6695	case 'C':
6696	{
6697	const char *const spec
6698	= (input_file_compiler->cpp_spec
6699	? input_file_compiler->cpp_spec
6700	: cpp_spec);
6701	value = do_spec_1 (spec, inswitch: 0, NULL);
6702	if (value != 0)
6703	return value;
6704	}
6705	break;
6706
6707	case 'E':
6708	value = do_spec_1 (spec: endfile_spec, inswitch: 0, NULL);
6709	if (value != 0)
6710	return value;
6711	break;
6712
6713	case 'l':
6714	value = do_spec_1 (spec: link_spec, inswitch: 0, NULL);
6715	if (value != 0)
6716	return value;
6717	break;
6718
6719	case 'L':
6720	value = do_spec_1 (spec: lib_spec, inswitch: 0, NULL);
6721	if (value != 0)
6722	return value;
6723	break;
6724
6725	case 'M':
6726	if (multilib_os_dir == NULL)
6727	obstack_1grow (&obstack, '.');
6728	else
6729	obstack_grow (&obstack, multilib_os_dir,
6730	strlen (multilib_os_dir));
6731	break;
6732
6733	case 'G':
6734	value = do_spec_1 (spec: libgcc_spec, inswitch: 0, NULL);
6735	if (value != 0)
6736	return value;
6737	break;
6738
6739	case 'R':
6740	/* We assume there is a directory
6741	separator at the end of this string. */
6742	if (target_system_root)
6743	{
6744	obstack_grow (&obstack, target_system_root,
6745	strlen (target_system_root));
6746	if (target_sysroot_suffix)
6747	obstack_grow (&obstack, target_sysroot_suffix,
6748	strlen (target_sysroot_suffix));
6749	}
6750	break;
6751
6752	case 'S':
6753	value = do_spec_1 (spec: startfile_spec, inswitch: 0, NULL);
6754	if (value != 0)
6755	return value;
6756	break;
6757
6758	/* Here we define characters other than letters and digits. */
6759
6760	case '{':
6761	p = handle_braces (p);
6762	if (p == 0)
6763	return -1;
6764	break;
6765
6766	case ':':
6767	p = handle_spec_function (p, NULL, soft_matched_part);
6768	if (p == 0)
6769	return -1;
6770	break;
6771
6772	case '%':
6773	obstack_1grow (&obstack, '%');
6774	break;
6775
6776	case '.':
6777	{
6778	unsigned len = 0;
6779
6780	while (p[len] && p[len] != ' ' && p[len] != '%')
6781	len++;
6782	suffix_subst = save_string (p - 1, len + 1);
6783	p += len;
6784	}
6785	break;
6786
6787	/* Henceforth ignore the option(s) matching the pattern
6788	after the %<. */
6789	case '<':
6790	case '>':
6791	{
6792	unsigned len = 0;
6793	int have_wildcard = 0;
6794	int i;
6795	int switch_option;
6796
6797	if (c == '>')
6798	switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
6799	else
6800	switch_option = SWITCH_IGNORE;
6801
6802	while (p[len] && p[len] != ' ' && p[len] != '\t')
6803	len++;
6804
6805	if (p[len-1] == '*')
6806	have_wildcard = 1;
6807
6808	for (i = 0; i < n_switches; i++)
6809	if (!strncmp (s1: switches[i].part1, s2: p, n: len - have_wildcard)
6810	&& (have_wildcard || switches[i].part1[len] == '\0'))
6811	{
6812	switches[i].live_cond |= switch_option;
6813	/* User switch be validated from validate_all_switches.
6814	when the definition is seen from the spec file.
6815	If not defined anywhere, will be rejected. */
6816	if (switches[i].known)
6817	switches[i].validated = true;
6818	}
6819
6820	p += len;
6821	}
6822	break;
6823
6824	case '*':
6825	if (soft_matched_part)
6826	{
6827	if (soft_matched_part[0])
6828	do_spec_1 (spec: soft_matched_part, inswitch: 1, NULL);
6829	/* Only insert a space after the substitution if it is at the
6830	end of the current sequence. So if:
6831
6832	"%{foo=*:bar%*}%{foo=*:one%*two}"
6833
6834	matches -foo=hello then it will produce:
6835
6836	barhello onehellotwo
6837	*/
6838	if (*p == 0 || *p == '}')
6839	do_spec_1 (spec: " ", inswitch: 0, NULL);
6840	}
6841	else
6842	/* Catch the case where a spec string contains something like
6843	'%{foo:%*}'. i.e. there is no * in the pattern on the left
6844	hand side of the :. */
6845	error ("spec failure: %<%%*%> has not been initialized by pattern match");
6846	break;
6847
6848	/* Process a string found as the value of a spec given by name.
6849	This feature allows individual machine descriptions
6850	to add and use their own specs. */
6851	case '(':
6852	{
6853	const char *name = p;
6854	struct spec_list *sl;
6855	int len;
6856
6857	/* The string after the S/P is the name of a spec that is to be
6858	processed. */
6859	while (*p && *p != ')')
6860	p++;
6861
6862	/* See if it's in the list. */
6863	for (len = p - name, sl = specs; sl; sl = sl->next)
6864	if (sl->name_len == len && !strncmp (s1: sl->name, s2: name, n: len))
6865	{
6866	name = *(sl->ptr_spec);
6867	#ifdef DEBUG_SPECS
6868	fnotice (stderr, "Processing spec (%s), which is '%s'\n",
6869	sl->name, name);
6870	#endif
6871	break;
6872	}
6873
6874	if (sl)
6875	{
6876	value = do_spec_1 (spec: name, inswitch: 0, NULL);
6877	if (value != 0)
6878	return value;
6879	}
6880
6881	/* Discard the closing paren. */
6882	if (*p)
6883	p++;
6884	}
6885	break;
6886
6887	case '"':
6888	/* End a previous argument, if there is one, then issue an
6889	empty argument. */
6890	end_going_arg ();
6891	arg_going = 1;
6892	end_going_arg ();
6893	break;
6894
6895	default:
6896	error ("spec failure: unrecognized spec option %qc", c);
6897	break;
6898	}
6899	break;
6900
6901	case '\\':
6902	/* Backslash: treat next character as ordinary. */
6903	c = *p++;
6904
6905	/* When adding more cases that previously matched default, make
6906	sure to adjust quote_spec_char_p as well. */
6907
6908	/* Fall through. */
6909	default:
6910	/* Ordinary character: put it into the current argument. */
6911	obstack_1grow (&obstack, c);
6912	arg_going = 1;
6913	}
6914
6915	/* End of string. If we are processing a spec function, we need to
6916	end any pending argument. */
6917	if (processing_spec_function)
6918	end_going_arg ();
6919
6920	return 0;
6921	}
6922
6923	/* Look up a spec function. */
6924
6925	static const struct spec_function *
6926	lookup_spec_function (const char *name)
6927	{
6928	const struct spec_function *sf;
6929
6930	for (sf = static_spec_functions; sf->name != NULL; sf++)
6931	if (strcmp (s1: sf->name, s2: name) == 0)
6932	return sf;
6933
6934	return NULL;
6935	}
6936
6937	/* Evaluate a spec function. */
6938
6939	static const char *
6940	eval_spec_function (const char *func, const char *args,
6941	const char *soft_matched_part)
6942	{
6943	const struct spec_function *sf;
6944	const char *funcval;
6945
6946	/* Saved spec processing context. */
6947	vec<const_char_p> save_argbuf;
6948
6949	int save_arg_going;
6950	int save_delete_this_arg;
6951	int save_this_is_output_file;
6952	int save_this_is_library_file;
6953	int save_input_from_pipe;
6954	int save_this_is_linker_script;
6955	const char *save_suffix_subst;
6956
6957	int save_growing_size;
6958	void *save_growing_value = NULL;
6959
6960	sf = lookup_spec_function (name: func);
6961	if (sf == NULL)
6962	fatal_error (input_location, "unknown spec function %qs", func);
6963
6964	/* Push the spec processing context. */
6965	save_argbuf = argbuf;
6966
6967	save_arg_going = arg_going;
6968	save_delete_this_arg = delete_this_arg;
6969	save_this_is_output_file = this_is_output_file;
6970	save_this_is_library_file = this_is_library_file;
6971	save_this_is_linker_script = this_is_linker_script;
6972	save_input_from_pipe = input_from_pipe;
6973	save_suffix_subst = suffix_subst;
6974
6975	/* If we have some object growing now, finalize it so the args and function
6976	eval proceed from a cleared context. This is needed to prevent the first
6977	constructed arg from mistakenly including the growing value. We'll push
6978	this value back on the obstack once the function evaluation is done, to
6979	restore a consistent processing context for our caller. This is fine as
6980	the address of growing objects isn't guaranteed to remain stable until
6981	they are finalized, and we expect this situation to be rare enough for
6982	the extra copy not to be an issue. */
6983	save_growing_size = obstack_object_size (&obstack);
6984	if (save_growing_size > 0)
6985	save_growing_value = obstack_finish (&obstack);
6986
6987	/* Create a new spec processing context, and build the function
6988	arguments. */
6989
6990	alloc_args ();
6991	if (do_spec_2 (spec: args, soft_matched_part) < 0)
6992	fatal_error (input_location, "error in arguments to spec function %qs",
6993	func);
6994
6995	/* argbuf_index is an index for the next argument to be inserted, and
6996	so contains the count of the args already inserted. */
6997
6998	funcval = (*sf->func) (argbuf.length (),
6999	argbuf.address ());
7000
7001	/* Pop the spec processing context. */
7002	argbuf.release ();
7003	argbuf = save_argbuf;
7004
7005	arg_going = save_arg_going;
7006	delete_this_arg = save_delete_this_arg;
7007	this_is_output_file = save_this_is_output_file;
7008	this_is_library_file = save_this_is_library_file;
7009	this_is_linker_script = save_this_is_linker_script;
7010	input_from_pipe = save_input_from_pipe;
7011	suffix_subst = save_suffix_subst;
7012
7013	if (save_growing_size > 0)
7014	obstack_grow (&obstack, save_growing_value, save_growing_size);
7015
7016	return funcval;
7017	}
7018
7019	/* Handle a spec function call of the form:
7020
7021	%:function(args)
7022
7023	ARGS is processed as a spec in a separate context and split into an
7024	argument vector in the normal fashion. The function returns a string
7025	containing a spec which we then process in the caller's context, or
7026	NULL if no processing is required.
7027
7028	If RETVAL_NONNULL is not NULL, then store a bool whether function
7029	returned non-NULL.
7030
7031	SOFT_MATCHED_PART holds the current value of a matched * pattern, which
7032	may be re-expanded with a %* as part of the function arguments. */
7033
7034	static const char *
7035	handle_spec_function (const char *p, bool *retval_nonnull,
7036	const char *soft_matched_part)
7037	{
7038	char *func, *args;
7039	const char *endp, *funcval;
7040	int count;
7041
7042	processing_spec_function++;
7043
7044	/* Get the function name. */
7045	for (endp = p; *endp != '\0'; endp++)
7046	{
7047	if (*endp == '(') /* ) */
7048	break;
7049	/* Only allow [A-Za-z0-9], -, and _ in function names. */
7050	if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
7051	fatal_error (input_location, "malformed spec function name");
7052	}
7053	if (*endp != '(') /* ) */
7054	fatal_error (input_location, "no arguments for spec function");
7055	func = save_string (p, endp - p);
7056	p = ++endp;
7057
7058	/* Get the arguments. */
7059	for (count = 0; *endp != '\0'; endp++)
7060	{
7061	/* ( */
7062	if (*endp == ')')
7063	{
7064	if (count == 0)
7065	break;
7066	count--;
7067	}
7068	else if (*endp == '(') /* ) */
7069	count++;
7070	}
7071	/* ( */
7072	if (*endp != ')')
7073	fatal_error (input_location, "malformed spec function arguments");
7074	args = save_string (p, endp - p);
7075	p = ++endp;
7076
7077	/* p now points to just past the end of the spec function expression. */
7078
7079	funcval = eval_spec_function (func, args, soft_matched_part);
7080	if (funcval != NULL && do_spec_1 (spec: funcval, inswitch: 0, NULL) < 0)
7081	p = NULL;
7082	if (retval_nonnull)
7083	*retval_nonnull = funcval != NULL;
7084
7085	free (ptr: func);
7086	free (ptr: args);
7087
7088	processing_spec_function--;
7089
7090	return p;
7091	}
7092
7093	/* Inline subroutine of handle_braces. Returns true if the current
7094	input suffix matches the atom bracketed by ATOM and END_ATOM. */
7095	static inline bool
7096	input_suffix_matches (const char *atom, const char *end_atom)
7097	{
7098	return (input_suffix
7099	&& !strncmp (s1: input_suffix, s2: atom, n: end_atom - atom)
7100	&& input_suffix[end_atom - atom] == '\0');
7101	}
7102
7103	/* Subroutine of handle_braces. Returns true if the current
7104	input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7105	static bool
7106	input_spec_matches (const char *atom, const char *end_atom)
7107	{
7108	return (input_file_compiler
7109	&& input_file_compiler->suffix
7110	&& input_file_compiler->suffix[0] != '\0'
7111	&& !strncmp (s1: input_file_compiler->suffix + 1, s2: atom,
7112	n: end_atom - atom)
7113	&& input_file_compiler->suffix[end_atom - atom + 1] == '\0');
7114	}
7115
7116	/* Subroutine of handle_braces. Returns true if a switch
7117	matching the atom bracketed by ATOM and END_ATOM appeared on the
7118	command line. */
7119	static bool
7120	switch_matches (const char *atom, const char *end_atom, int starred)
7121	{
7122	int i;
7123	int len = end_atom - atom;
7124	int plen = starred ? len : -1;
7125
7126	for (i = 0; i < n_switches; i++)
7127	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
7128	&& (starred || switches[i].part1[len] == '\0')
7129	&& check_live_switch (i, plen))
7130	return true;
7131
7132	/* Check if a switch with separated form matching the atom.
7133	We check -D and -U switches. */
7134	else if (switches[i].args != 0)
7135	{
7136	if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
7137	&& *switches[i].part1 == atom[0])
7138	{
7139	if (!strncmp (s1: switches[i].args[0], s2: &atom[1], n: len - 1)
7140	&& (starred || (switches[i].part1[1] == '\0'
7141	&& switches[i].args[0][len - 1] == '\0'))
7142	&& check_live_switch (i, (starred ? 1 : -1)))
7143	return true;
7144	}
7145	}
7146
7147	return false;
7148	}
7149
7150	/* Inline subroutine of handle_braces. Mark all of the switches which
7151	match ATOM (extends to END_ATOM; STARRED indicates whether there
7152	was a star after the atom) for later processing. */
7153	static inline void
7154	mark_matching_switches (const char *atom, const char *end_atom, int starred)
7155	{
7156	int i;
7157	int len = end_atom - atom;
7158	int plen = starred ? len : -1;
7159
7160	for (i = 0; i < n_switches; i++)
7161	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
7162	&& (starred || switches[i].part1[len] == '\0')
7163	&& check_live_switch (i, plen))
7164	switches[i].ordering = 1;
7165	}
7166
7167	/* Inline subroutine of handle_braces. Process all the currently
7168	marked switches through give_switch, and clear the marks. */
7169	static inline void
7170	process_marked_switches (void)
7171	{
7172	int i;
7173
7174	for (i = 0; i < n_switches; i++)
7175	if (switches[i].ordering == 1)
7176	{
7177	switches[i].ordering = 0;
7178	give_switch (i, 0);
7179	}
7180	}
7181
7182	/* Handle a %{ ... } construct. P points just inside the leading {.
7183	Returns a pointer one past the end of the brace block, or 0
7184	if we call do_spec_1 and that returns -1. */
7185
7186	static const char *
7187	handle_braces (const char *p)
7188	{
7189	const char *atom, *end_atom;
7190	const char *d_atom = NULL, *d_end_atom = NULL;
7191	char *esc_buf = NULL, *d_esc_buf = NULL;
7192	int esc;
7193	const char *orig = p;
7194
7195	bool a_is_suffix;
7196	bool a_is_spectype;
7197	bool a_is_starred;
7198	bool a_is_negated;
7199	bool a_matched;
7200
7201	bool a_must_be_last = false;
7202	bool ordered_set = false;
7203	bool disjunct_set = false;
7204	bool disj_matched = false;
7205	bool disj_starred = true;
7206	bool n_way_choice = false;
7207	bool n_way_matched = false;
7208
7209	#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7210
7211	do
7212	{
7213	if (a_must_be_last)
7214	goto invalid;
7215
7216	/* Scan one "atom" (S in the description above of %{}, possibly
7217	with '!', '.', '@', ',', or '*' modifiers). */
7218	a_matched = false;
7219	a_is_suffix = false;
7220	a_is_starred = false;
7221	a_is_negated = false;
7222	a_is_spectype = false;
7223
7224	SKIP_WHITE ();
7225	if (*p == '!')
7226	p++, a_is_negated = true;
7227
7228	SKIP_WHITE ();
7229	if (*p == '%' && p[1] == ':')
7230	{
7231	atom = NULL;
7232	end_atom = NULL;
7233	p = handle_spec_function (p: p + 2, retval_nonnull: &a_matched, NULL);
7234	}
7235	else
7236	{
7237	if (*p == '.')
7238	p++, a_is_suffix = true;
7239	else if (*p == ',')
7240	p++, a_is_spectype = true;
7241
7242	atom = p;
7243	esc = 0;
7244	while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7245	|| *p == ',' || *p == '.' || *p == '@' || *p == '\\')
7246	{
7247	if (*p == '\\')
7248	{
7249	p++;
7250	if (!*p)
7251	fatal_error (input_location,
7252	"braced spec %qs ends in escape", orig);
7253	esc++;
7254	}
7255	p++;
7256	}
7257	end_atom = p;
7258
7259	if (esc)
7260	{
7261	const char *ap;
7262	char *ep;
7263
7264	if (esc_buf && esc_buf != d_esc_buf)
7265	free (ptr: esc_buf);
7266	esc_buf = NULL;
7267	ep = esc_buf = (char *) xmalloc (end_atom - atom - esc + 1);
7268	for (ap = atom; ap != end_atom; ap++, ep++)
7269	{
7270	if (*ap == '\\')
7271	ap++;
7272	*ep = *ap;
7273	}
7274	*ep = '\0';
7275	atom = esc_buf;
7276	end_atom = ep;
7277	}
7278
7279	if (*p == '*')
7280	p++, a_is_starred = 1;
7281	}
7282
7283	SKIP_WHITE ();
7284	switch (*p)
7285	{
7286	case '&': case '}':
7287	/* Substitute the switch(es) indicated by the current atom. */
7288	ordered_set = true;
7289	if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
7290	|| a_is_spectype || atom == end_atom)
7291	goto invalid;
7292
7293	mark_matching_switches (atom, end_atom, starred: a_is_starred);
7294
7295	if (*p == '}')
7296	process_marked_switches ();
7297	break;
7298
7299	case '|': case ':':
7300	/* Substitute some text if the current atom appears as a switch
7301	or suffix. */
7302	disjunct_set = true;
7303	if (ordered_set)
7304	goto invalid;
7305
7306	if (atom && atom == end_atom)
7307	{
7308	if (!n_way_choice || disj_matched || *p == '|'
7309	|| a_is_negated || a_is_suffix || a_is_spectype
7310	|| a_is_starred)
7311	goto invalid;
7312
7313	/* An empty term may appear as the last choice of an
7314	N-way choice set; it means "otherwise". */
7315	a_must_be_last = true;
7316	disj_matched = !n_way_matched;
7317	disj_starred = false;
7318	}
7319	else
7320	{
7321	if ((a_is_suffix || a_is_spectype) && a_is_starred)
7322	goto invalid;
7323
7324	if (!a_is_starred)
7325	disj_starred = false;
7326
7327	/* Don't bother testing this atom if we already have a
7328	match. */
7329	if (!disj_matched && !n_way_matched)
7330	{
7331	if (atom == NULL)
7332	/* a_matched is already set by handle_spec_function. */;
7333	else if (a_is_suffix)
7334	a_matched = input_suffix_matches (atom, end_atom);
7335	else if (a_is_spectype)
7336	a_matched = input_spec_matches (atom, end_atom);
7337	else
7338	a_matched = switch_matches (atom, end_atom, starred: a_is_starred);
7339
7340	if (a_matched != a_is_negated)
7341	{
7342	disj_matched = true;
7343	d_atom = atom;
7344	d_end_atom = end_atom;
7345	d_esc_buf = esc_buf;
7346	}
7347	}
7348	}
7349
7350	if (*p == ':')
7351	{
7352	/* Found the body, that is, the text to substitute if the
7353	current disjunction matches. */
7354	p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
7355	disj_matched && !n_way_matched);
7356	if (p == 0)
7357	goto done;
7358
7359	/* If we have an N-way choice, reset state for the next
7360	disjunction. */
7361	if (*p == ';')
7362	{
7363	n_way_choice = true;
7364	n_way_matched |= disj_matched;
7365	disj_matched = false;
7366	disj_starred = true;
7367	d_atom = d_end_atom = NULL;
7368	}
7369	}
7370	break;
7371
7372	default:
7373	goto invalid;
7374	}
7375	}
7376	while (*p++ != '}');
7377
7378	done:
7379	if (d_esc_buf && d_esc_buf != esc_buf)
7380	free (ptr: d_esc_buf);
7381	if (esc_buf)
7382	free (ptr: esc_buf);
7383
7384	return p;
7385
7386	invalid:
7387	fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p);
7388
7389	#undef SKIP_WHITE
7390	}
7391
7392	/* Subroutine of handle_braces. Scan and process a brace substitution body
7393	(X in the description of %{} syntax). P points one past the colon;
7394	ATOM and END_ATOM bracket the first atom which was found to be true
7395	(present) in the current disjunction; STARRED indicates whether all
7396	the atoms in the current disjunction were starred (for syntax validation);
7397	MATCHED indicates whether the disjunction matched or not, and therefore
7398	whether or not the body is to be processed through do_spec_1 or just
7399	skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7400	returns -1. */
7401
7402	static const char *
7403	process_brace_body (const char *p, const char *atom, const char *end_atom,
7404	int starred, int matched)
7405	{
7406	const char *body, *end_body;
7407	unsigned int nesting_level;
7408	bool have_subst = false;
7409
7410	/* Locate the closing } or ;, honoring nested braces.
7411	Trim trailing whitespace. */
7412	body = p;
7413	nesting_level = 1;
7414	for (;;)
7415	{
7416	if (*p == '{')
7417	nesting_level++;
7418	else if (*p == '}')
7419	{
7420	if (!--nesting_level)
7421	break;
7422	}
7423	else if (*p == ';' && nesting_level == 1)
7424	break;
7425	else if (*p == '%' && p[1] == '*' && nesting_level == 1)
7426	have_subst = true;
7427	else if (*p == '\0')
7428	goto invalid;
7429	p++;
7430	}
7431
7432	end_body = p;
7433	while (end_body[-1] == ' ' || end_body[-1] == '\t')
7434	end_body--;
7435
7436	if (have_subst && !starred)
7437	goto invalid;
7438
7439	if (matched)
7440	{
7441	/* Copy the substitution body to permanent storage and execute it.
7442	If have_subst is false, this is a simple matter of running the
7443	body through do_spec_1... */
7444	char *string = save_string (body, end_body - body);
7445	if (!have_subst)
7446	{
7447	if (do_spec_1 (spec: string, inswitch: 0, NULL) < 0)
7448	{
7449	free (ptr: string);
7450	return 0;
7451	}
7452	}
7453	else
7454	{
7455	/* ... but if have_subst is true, we have to process the
7456	body once for each matching switch, with %* set to the
7457	variant part of the switch. */
7458	unsigned int hard_match_len = end_atom - atom;
7459	int i;
7460
7461	for (i = 0; i < n_switches; i++)
7462	if (!strncmp (s1: switches[i].part1, s2: atom, n: hard_match_len)
7463	&& check_live_switch (i, hard_match_len))
7464	{
7465	if (do_spec_1 (spec: string, inswitch: 0,
7466	soft_matched_part: &switches[i].part1[hard_match_len]) < 0)
7467	{
7468	free (ptr: string);
7469	return 0;
7470	}
7471	/* Pass any arguments this switch has. */
7472	give_switch (i, 1);
7473	suffix_subst = NULL;
7474	}
7475	}
7476	free (ptr: string);
7477	}
7478
7479	return p;
7480
7481	invalid:
7482	fatal_error (input_location, "braced spec body %qs is invalid", body);
7483	}
7484
7485	/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7486	on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7487	spec, or -1 if either exact match or %* is used.
7488
7489	A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7490	whose value does not begin with "no-" is obsoleted by the same value
7491	with the "no-", similarly for a switch with the "no-" prefix. */
7492
7493	static int
7494	check_live_switch (int switchnum, int prefix_length)
7495	{
7496	const char *name = switches[switchnum].part1;
7497	int i;
7498
7499	/* If we already processed this switch and determined if it was
7500	live or not, return our past determination. */
7501	if (switches[switchnum].live_cond != 0)
7502	return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
7503	&& (switches[switchnum].live_cond & SWITCH_FALSE) == 0
7504	&& (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
7505	== 0);
7506
7507	/* In the common case of {<at-most-one-letter>*}, a negating
7508	switch would always match, so ignore that case. We will just
7509	send the conflicting switches to the compiler phase. */
7510	if (prefix_length >= 0 && prefix_length <= 1)
7511	return 1;
7512
7513	/* Now search for duplicate in a manner that depends on the name. */
7514	switch (*name)
7515	{
7516	case 'O':
7517	for (i = switchnum + 1; i < n_switches; i++)
7518	if (switches[i].part1[0] == 'O')
7519	{
7520	switches[switchnum].validated = true;
7521	switches[switchnum].live_cond = SWITCH_FALSE;
7522	return 0;
7523	}
7524	break;
7525
7526	case 'W': case 'f': case 'm': case 'g':
7527	if (startswith (str: name + 1, prefix: "no-"))
7528	{
7529	/* We have Xno-YYY, search for XYYY. */
7530	for (i = switchnum + 1; i < n_switches; i++)
7531	if (switches[i].part1[0] == name[0]
7532	&& ! strcmp (s1: &switches[i].part1[1], s2: &name[4]))
7533	{
7534	/* --specs are validated with the validate_switches mechanism. */
7535	if (switches[switchnum].known)
7536	switches[switchnum].validated = true;
7537	switches[switchnum].live_cond = SWITCH_FALSE;
7538	return 0;
7539	}
7540	}
7541	else
7542	{
7543	/* We have XYYY, search for Xno-YYY. */
7544	for (i = switchnum + 1; i < n_switches; i++)
7545	if (switches[i].part1[0] == name[0]
7546	&& switches[i].part1[1] == 'n'
7547	&& switches[i].part1[2] == 'o'
7548	&& switches[i].part1[3] == '-'
7549	&& !strcmp (s1: &switches[i].part1[4], s2: &name[1]))
7550	{
7551	/* --specs are validated with the validate_switches mechanism. */
7552	if (switches[switchnum].known)
7553	switches[switchnum].validated = true;
7554	switches[switchnum].live_cond = SWITCH_FALSE;
7555	return 0;
7556	}
7557	}
7558	break;
7559	}
7560
7561	/* Otherwise the switch is live. */
7562	switches[switchnum].live_cond |= SWITCH_LIVE;
7563	return 1;
7564	}
7565
7566	/* Pass a switch to the current accumulating command
7567	in the same form that we received it.
7568	SWITCHNUM identifies the switch; it is an index into
7569	the vector of switches gcc received, which is `switches'.
7570	This cannot fail since it never finishes a command line.
7571
7572	If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7573
7574	static void
7575	give_switch (int switchnum, int omit_first_word)
7576	{
7577	if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
7578	return;
7579
7580	if (!omit_first_word)
7581	{
7582	do_spec_1 (spec: "-", inswitch: 0, NULL);
7583	do_spec_1 (spec: switches[switchnum].part1, inswitch: 1, NULL);
7584	}
7585
7586	if (switches[switchnum].args != 0)
7587	{
7588	const char **p;
7589	for (p = switches[switchnum].args; *p; p++)
7590	{
7591	const char *arg = *p;
7592
7593	do_spec_1 (spec: " ", inswitch: 0, NULL);
7594	if (suffix_subst)
7595	{
7596	unsigned length = strlen (s: arg);
7597	int dot = 0;
7598
7599	while (length-- && !IS_DIR_SEPARATOR (arg[length]))
7600	if (arg[length] == '.')
7601	{
7602	(CONST_CAST (char *, arg))[length] = 0;
7603	dot = 1;
7604	break;
7605	}
7606	do_spec_1 (spec: arg, inswitch: 1, NULL);
7607	if (dot)
7608	(CONST_CAST (char *, arg))[length] = '.';
7609	do_spec_1 (spec: suffix_subst, inswitch: 1, NULL);
7610	}
7611	else
7612	do_spec_1 (spec: arg, inswitch: 1, NULL);
7613	}
7614	}
7615
7616	do_spec_1 (spec: " ", inswitch: 0, NULL);
7617	switches[switchnum].validated = true;
7618	}
7619
7620	/* Print GCC configuration (e.g. version, thread model, target,
7621	configuration_arguments) to a given FILE. */
7622
7623	static void
7624	print_configuration (FILE *file)
7625	{
7626	int n;
7627	const char *thrmod;
7628
7629	fnotice (file, "Target: %s\n", spec_machine);
7630	fnotice (file, "Configured with: %s\n", configuration_arguments);
7631
7632	#ifdef THREAD_MODEL_SPEC
7633	/* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7634	but there's no point in doing all this processing just to get
7635	thread_model back. */
7636	obstack_init (&obstack);
7637	do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7638	obstack_1grow (&obstack, '\0');
7639	thrmod = XOBFINISH (&obstack, const char *);
7640	#else
7641	thrmod = thread_model;
7642	#endif
7643
7644	fnotice (file, "Thread model: %s\n", thrmod);
7645	fnotice (file, "Supported LTO compression algorithms: zlib");
7646	#ifdef HAVE_ZSTD_H
7647	fnotice (file, " zstd");
7648	#endif
7649	fnotice (file, "\n");
7650
7651	/* compiler_version is truncated at the first space when initialized
7652	from version string, so truncate version_string at the first space
7653	before comparing. */
7654	for (n = 0; version_string[n]; n++)
7655	if (version_string[n] == ' ')
7656	break;
7657
7658	if (! strncmp (version_string, s2: compiler_version, n: n)
7659	&& compiler_version[n] == 0)
7660	fnotice (file, "gcc version %s %s\n", version_string,
7661	pkgversion_string);
7662	else
7663	fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n",
7664	version_string, pkgversion_string, compiler_version);
7665
7666	}
7667
7668	#define RETRY_ICE_ATTEMPTS 3
7669
7670	/* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7671
7672	static bool
7673	files_equal_p (char *file1, char *file2)
7674	{
7675	struct stat st1, st2;
7676	off_t n, len;
7677	int fd1, fd2;
7678	const int bufsize = 8192;
7679	char *buf = XNEWVEC (char, bufsize);
7680
7681	fd1 = open (file: file1, O_RDONLY);
7682	fd2 = open (file: file2, O_RDONLY);
7683
7684	if (fd1 < 0 || fd2 < 0)
7685	goto error;
7686
7687	if (fstat (fd: fd1, buf: &st1) < 0 || fstat (fd: fd2, buf: &st2) < 0)
7688	goto error;
7689
7690	if (st1.st_size != st2.st_size)
7691	goto error;
7692
7693	for (n = st1.st_size; n; n -= len)
7694	{
7695	len = n;
7696	if ((int) len > bufsize / 2)
7697	len = bufsize / 2;
7698
7699	if (read (fd: fd1, buf: buf, nbytes: len) != (int) len
7700	|| read (fd: fd2, buf: buf + bufsize / 2, nbytes: len) != (int) len)
7701	{
7702	goto error;
7703	}
7704
7705	if (memcmp (s1: buf, s2: buf + bufsize / 2, n: len) != 0)
7706	goto error;
7707	}
7708
7709	free (ptr: buf);
7710	close (fd: fd1);
7711	close (fd: fd2);
7712
7713	return 1;
7714
7715	error:
7716	free (ptr: buf);
7717	close (fd: fd1);
7718	close (fd: fd2);
7719	return 0;
7720	}
7721
7722	/* Check that compiler's output doesn't differ across runs.
7723	TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7724	stdout and stderr for each compiler run. Return true if all of
7725	TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7726
7727	static bool
7728	check_repro (char **temp_stdout_files, char **temp_stderr_files)
7729	{
7730	int i;
7731	for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i)
7732	{
7733	if (!files_equal_p (file1: temp_stdout_files[i], file2: temp_stdout_files[i + 1])
7734	|| !files_equal_p (file1: temp_stderr_files[i], file2: temp_stderr_files[i + 1]))
7735	{
7736	fnotice (stderr, "The bug is not reproducible, so it is"
7737	" likely a hardware or OS problem.\n");
7738	break;
7739	}
7740	}
7741	return i == RETRY_ICE_ATTEMPTS - 2;
7742	}
7743
7744	enum attempt_status {
7745	ATTEMPT_STATUS_FAIL_TO_RUN,
7746	ATTEMPT_STATUS_SUCCESS,
7747	ATTEMPT_STATUS_ICE
7748	};
7749
7750
7751	/* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7752	to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7753	and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7754	GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7755	compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7756	ATTEMPT_STATUS_SUCCESS otherwise. */
7757
7758	static enum attempt_status
7759	run_attempt (const char **new_argv, const char *out_temp,
7760	const char *err_temp, int emit_system_info, int append)
7761	{
7762
7763	if (emit_system_info)
7764	{
7765	FILE *file_out = fopen (filename: err_temp, modes: "a");
7766	print_configuration (file: file_out);
7767	fputs (s: "\n", stream: file_out);
7768	fclose (stream: file_out);
7769	}
7770
7771	int exit_status;
7772	const char *errmsg;
7773	struct pex_obj *pex;
7774	int err;
7775	int pex_flags = PEX_USE_PIPES | PEX_LAST;
7776	enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN;
7777
7778	if (append)
7779	pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND;
7780
7781	pex = pex_init (PEX_USE_PIPES, pname: new_argv[0], NULL);
7782	if (!pex)
7783	fatal_error (input_location, "%<pex_init%> failed: %m");
7784
7785	errmsg = pex_run (obj: pex, flags: pex_flags, executable: new_argv[0],
7786	CONST_CAST2 (char *const *, const char **, &new_argv[1]),
7787	outname: out_temp, errname: err_temp, err: &err);
7788	if (errmsg != NULL)
7789	{
7790	errno = err;
7791	fatal_error (input_location,
7792	err ? G_ ("cannot execute %qs: %s: %m")
7793	: G_ ("cannot execute %qs: %s"),
7794	new_argv[0], errmsg);
7795	}
7796
7797	if (!pex_get_status (pex, count: 1, vector: &exit_status))
7798	goto out;
7799
7800	switch (WEXITSTATUS (exit_status))
7801	{
7802	case ICE_EXIT_CODE:
7803	status = ATTEMPT_STATUS_ICE;
7804	break;
7805
7806	case SUCCESS_EXIT_CODE:
7807	status = ATTEMPT_STATUS_SUCCESS;
7808	break;
7809
7810	default:
7811	;
7812	}
7813
7814	out:
7815	pex_free (pex);
7816	return status;
7817	}
7818
7819	/* This routine reads lines from IN file, adds C++ style comments
7820	at the begining of each line and writes result into OUT. */
7821
7822	static void
7823	insert_comments (const char *file_in, const char *file_out)
7824	{
7825	FILE *in = fopen (filename: file_in, modes: "rb");
7826	FILE *out = fopen (filename: file_out, modes: "wb");
7827	char line[256];
7828
7829	bool add_comment = true;
7830	while (fgets (s: line, n: sizeof (line), stream: in))
7831	{
7832	if (add_comment)
7833	fputs (s: "// ", stream: out);
7834	fputs (s: line, stream: out);
7835	add_comment = strchr (s: line, c: '\n') != NULL;
7836	}
7837
7838	fclose (stream: in);
7839	fclose (stream: out);
7840	}
7841
7842	/* This routine adds preprocessed source code into the given ERR_FILE.
7843	To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7844	add information in report file. RUN_ATTEMPT should return
7845	ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7846
7847	static void
7848	do_report_bug (const char **new_argv, const int nargs,
7849	char **out_file, char **err_file)
7850	{
7851	int i, status;
7852	int fd = open (file: *out_file, O_RDWR | O_APPEND);
7853	if (fd < 0)
7854	return;
7855	write (fd: fd, buf: "\n//", n: 3);
7856	for (i = 0; i < nargs; i++)
7857	{
7858	write (fd: fd, buf: " ", n: 1);
7859	write (fd: fd, buf: new_argv[i], n: strlen (s: new_argv[i]));
7860	}
7861	write (fd: fd, buf: "\n\n", n: 2);
7862	close (fd: fd);
7863	new_argv[nargs] = "-E";
7864	new_argv[nargs + 1] = NULL;
7865
7866	status = run_attempt (new_argv, out_temp: *out_file, err_temp: *err_file, emit_system_info: 0, append: 1);
7867
7868	if (status == ATTEMPT_STATUS_SUCCESS)
7869	{
7870	fnotice (stderr, "Preprocessed source stored into %s file,"
7871	" please attach this to your bugreport.\n", *out_file);
7872	/* Make sure it is not deleted. */
7873	free (ptr: *out_file);
7874	*out_file = NULL;
7875	}
7876	}
7877
7878	/* Try to reproduce ICE. If bug is reproducible, generate report .err file
7879	containing GCC configuration, backtrace, compiler's command line options
7880	and preprocessed source code. */
7881
7882	static void
7883	try_generate_repro (const char **argv)
7884	{
7885	int i, nargs, out_arg = -1, quiet = 0, attempt;
7886	const char **new_argv;
7887	char *temp_files[RETRY_ICE_ATTEMPTS * 2];
7888	char **temp_stdout_files = &temp_files[0];
7889	char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS];
7890
7891	if (gcc_input_filename == NULL || ! strcmp (s1: gcc_input_filename, s2: "-"))
7892	return;
7893
7894	for (nargs = 0; argv[nargs] != NULL; ++nargs)
7895	/* Only retry compiler ICEs, not preprocessor ones. */
7896	if (! strcmp (s1: argv[nargs], s2: "-E"))
7897	return;
7898	else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o')
7899	{
7900	if (out_arg == -1)
7901	out_arg = nargs;
7902	else
7903	return;
7904	}
7905	/* If the compiler is going to output any time information,
7906	it might varry between invocations. */
7907	else if (! strcmp (s1: argv[nargs], s2: "-quiet"))
7908	quiet = 1;
7909	else if (! strcmp (s1: argv[nargs], s2: "-ftime-report"))
7910	return;
7911
7912	if (out_arg == -1 || !quiet)
7913	return;
7914
7915	memset (s: temp_files, c: '\0', n: sizeof (temp_files));
7916	new_argv = XALLOCAVEC (const char *, nargs + 4);
7917	memcpy (dest: new_argv, src: argv, n: (nargs + 1) * sizeof (const char *));
7918	new_argv[nargs++] = "-frandom-seed=0";
7919	new_argv[nargs++] = "-fdump-noaddr";
7920	new_argv[nargs] = NULL;
7921	if (new_argv[out_arg][2] == '\0')
7922	new_argv[out_arg + 1] = "-";
7923	else
7924	new_argv[out_arg] = "-o-";
7925
7926	int status;
7927	for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt)
7928	{
7929	int emit_system_info = 0;
7930	int append = 0;
7931	temp_stdout_files[attempt] = make_temp_file (".out");
7932	temp_stderr_files[attempt] = make_temp_file (".err");
7933
7934	if (attempt == RETRY_ICE_ATTEMPTS - 1)
7935	{
7936	append = 1;
7937	emit_system_info = 1;
7938	}
7939
7940	status = run_attempt (new_argv, out_temp: temp_stdout_files[attempt],
7941	err_temp: temp_stderr_files[attempt], emit_system_info,
7942	append);
7943
7944	if (status != ATTEMPT_STATUS_ICE)
7945	{
7946	fnotice (stderr, "The bug is not reproducible, so it is"
7947	" likely a hardware or OS problem.\n");
7948	goto out;
7949	}
7950	}
7951
7952	if (!check_repro (temp_stdout_files, temp_stderr_files))
7953	goto out;
7954
7955	{
7956	/* Insert commented out backtrace into report file. */
7957	char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
7958	insert_comments (file_in: temp_stderr_files[RETRY_ICE_ATTEMPTS - 1],
7959	file_out: *stderr_commented);
7960
7961	/* In final attempt we append compiler options and preprocesssed code to last
7962	generated .out file with configuration and backtrace. */
7963	char **err = &temp_stderr_files[RETRY_ICE_ATTEMPTS - 1];
7964	do_report_bug (new_argv, nargs, out_file: stderr_commented, err_file: err);
7965	}
7966
7967	out:
7968	for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++)
7969	if (temp_files[i])
7970	{
7971	unlink (name: temp_stdout_files[i]);
7972	free (ptr: temp_stdout_files[i]);
7973	}
7974	}
7975
7976	/* Search for a file named NAME trying various prefixes including the
7977	user's -B prefix and some standard ones.
7978	Return the absolute file name found. If nothing is found, return NAME. */
7979
7980	static const char *
7981	find_file (const char *name)
7982	{
7983	char *newname = find_a_file (pprefix: &startfile_prefixes, name, R_OK, do_multi: true);
7984	return newname ? newname : name;
7985	}
7986
7987	/* Determine whether a directory exists. If LINKER, return 0 for
7988	certain fixed names not needed by the linker. */
7989
7990	static int
7991	is_directory (const char *path1, bool linker)
7992	{
7993	int len1;
7994	char *path;
7995	char *cp;
7996	struct stat st;
7997
7998	/* Ensure the string ends with "/.". The resulting path will be a
7999	directory even if the given path is a symbolic link. */
8000	len1 = strlen (s: path1);
8001	path = (char *) alloca (3 + len1);
8002	memcpy (dest: path, src: path1, n: len1);
8003	cp = path + len1;
8004	if (!IS_DIR_SEPARATOR (cp[-1]))
8005	*cp++ = DIR_SEPARATOR;
8006	*cp++ = '.';
8007	*cp = '\0';
8008
8009	/* Exclude directories that the linker is known to search. */
8010	if (linker
8011	&& IS_DIR_SEPARATOR (path[0])
8012	&& ((cp - path == 6
8013	&& filename_ncmp (s1: path + 1, s2: "lib", n: 3) == 0)
8014	|| (cp - path == 10
8015	&& filename_ncmp (s1: path + 1, s2: "usr", n: 3) == 0
8016	&& IS_DIR_SEPARATOR (path[4])
8017	&& filename_ncmp (s1: path + 5, s2: "lib", n: 3) == 0)))
8018	return 0;
8019
8020	return (stat (file: path, buf: &st) >= 0 && S_ISDIR (st.st_mode));
8021	}
8022
8023	/* Set up the various global variables to indicate that we're processing
8024	the input file named FILENAME. */
8025
8026	void
8027	set_input (const char *filename)
8028	{
8029	const char *p;
8030
8031	gcc_input_filename = filename;
8032	input_filename_length = strlen (s: gcc_input_filename);
8033	input_basename = lbasename (gcc_input_filename);
8034
8035	/* Find a suffix starting with the last period,
8036	and set basename_length to exclude that suffix. */
8037	basename_length = strlen (s: input_basename);
8038	suffixed_basename_length = basename_length;
8039	p = input_basename + basename_length;
8040	while (p != input_basename && *p != '.')
8041	--p;
8042	if (*p == '.' && p != input_basename)
8043	{
8044	basename_length = p - input_basename;
8045	input_suffix = p + 1;
8046	}
8047	else
8048	input_suffix = "";
8049
8050	/* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
8051	we will need to do a stat on the gcc_input_filename. The
8052	INPUT_STAT_SET signals that the stat is needed. */
8053	input_stat_set = 0;
8054	}
8055
8056	/* On fatal signals, delete all the temporary files. */
8057
8058	static void
8059	fatal_signal (int signum)
8060	{
8061	signal (sig: signum, SIG_DFL);
8062	delete_failure_queue ();
8063	delete_temp_files ();
8064	/* Get the same signal again, this time not handled,
8065	so its normal effect occurs. */
8066	kill (pid: getpid (), sig: signum);
8067	}
8068
8069	/* Compare the contents of the two files named CMPFILE[0] and
8070	CMPFILE[1]. Return zero if they're identical, nonzero
8071	otherwise. */
8072
8073	static int
8074	compare_files (char *cmpfile[])
8075	{
8076	int ret = 0;
8077	FILE *temp[2] = { NULL, NULL };
8078	int i;
8079
8080	#if HAVE_MMAP_FILE
8081	{
8082	size_t length[2];
8083	void *map[2] = { NULL, NULL };
8084
8085	for (i = 0; i < 2; i++)
8086	{
8087	struct stat st;
8088
8089	if (stat (file: cmpfile[i], buf: &st) < 0 || !S_ISREG (st.st_mode))
8090	{
8091	error ("%s: could not determine length of compare-debug file %s",
8092	gcc_input_filename, cmpfile[i]);
8093	ret = 1;
8094	break;
8095	}
8096
8097	length[i] = st.st_size;
8098	}
8099
8100	if (!ret && length[0] != length[1])
8101	{
8102	error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename);
8103	ret = 1;
8104	}
8105
8106	if (!ret)
8107	for (i = 0; i < 2; i++)
8108	{
8109	int fd = open (file: cmpfile[i], O_RDONLY);
8110	if (fd < 0)
8111	{
8112	error ("%s: could not open compare-debug file %s",
8113	gcc_input_filename, cmpfile[i]);
8114	ret = 1;
8115	break;
8116	}
8117
8118	map[i] = mmap (NULL, len: length[i], PROT_READ, MAP_PRIVATE, fd: fd, offset: 0);
8119	close (fd: fd);
8120
8121	if (map[i] == (void *) MAP_FAILED)
8122	{
8123	ret = -1;
8124	break;
8125	}
8126	}
8127
8128	if (!ret)
8129	{
8130	if (memcmp (s1: map[0], s2: map[1], n: length[0]) != 0)
8131	{
8132	error ("%s: %<-fcompare-debug%> failure", gcc_input_filename);
8133	ret = 1;
8134	}
8135	}
8136
8137	for (i = 0; i < 2; i++)
8138	if (map[i])
8139	munmap (addr: (caddr_t) map[i], len: length[i]);
8140
8141	if (ret >= 0)
8142	return ret;
8143
8144	ret = 0;
8145	}
8146	#endif
8147
8148	for (i = 0; i < 2; i++)
8149	{
8150	temp[i] = fopen (filename: cmpfile[i], modes: "r");
8151	if (!temp[i])
8152	{
8153	error ("%s: could not open compare-debug file %s",
8154	gcc_input_filename, cmpfile[i]);
8155	ret = 1;
8156	break;
8157	}
8158	}
8159
8160	if (!ret && temp[0] && temp[1])
8161	for (;;)
8162	{
8163	int c0, c1;
8164	c0 = fgetc (stream: temp[0]);
8165	c1 = fgetc (stream: temp[1]);
8166
8167	if (c0 != c1)
8168	{
8169	error ("%s: %<-fcompare-debug%> failure",
8170	gcc_input_filename);
8171	ret = 1;
8172	break;
8173	}
8174
8175	if (c0 == EOF)
8176	break;
8177	}
8178
8179	for (i = 1; i >= 0; i--)
8180	{
8181	if (temp[i])
8182	fclose (stream: temp[i]);
8183	}
8184
8185	return ret;
8186	}
8187
8188	driver::driver (bool can_finalize, bool debug) :
8189	explicit_link_files (NULL),
8190	decoded_options (NULL)
8191	{
8192	env.init (can_restore: can_finalize, debug);
8193	}
8194
8195	driver::~driver ()
8196	{
8197	XDELETEVEC (explicit_link_files);
8198	XDELETEVEC (decoded_options);
8199	}
8200
8201	/* driver::main is implemented as a series of driver:: method calls. */
8202
8203	int
8204	driver::main (int argc, char **argv)
8205	{
8206	bool early_exit;
8207
8208	set_progname (argv[0]);
8209	expand_at_files (argc: &argc, argv: &argv);
8210	decode_argv (argc, argv: const_cast <const char **> (argv));
8211	global_initializations ();
8212	build_multilib_strings ();
8213	set_up_specs ();
8214	putenv_COLLECT_AS_OPTIONS (vec: assembler_options);
8215	putenv_COLLECT_GCC (argv0: argv[0]);
8216	maybe_putenv_COLLECT_LTO_WRAPPER ();
8217	maybe_putenv_OFFLOAD_TARGETS ();
8218	handle_unrecognized_options ();
8219
8220	if (completion)
8221	{
8222	m_option_proposer.suggest_completion (option_prefix: completion);
8223	return 0;
8224	}
8225
8226	if (!maybe_print_and_exit ())
8227	return 0;
8228
8229	early_exit = prepare_infiles ();
8230	if (early_exit)
8231	return get_exit_code ();
8232
8233	do_spec_on_infiles ();
8234	maybe_run_linker (argv0: argv[0]);
8235	final_actions ();
8236	return get_exit_code ();
8237	}
8238
8239	/* Locate the final component of argv[0] after any leading path, and set
8240	the program name accordingly. */
8241
8242	void
8243	driver::set_progname (const char *argv0) const
8244	{
8245	const char *p = argv0 + strlen (s: argv0);
8246	while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
8247	--p;
8248	progname = p;
8249
8250	xmalloc_set_program_name (progname);
8251	}
8252
8253	/* Expand any @ files within the command-line args,
8254	setting at_file_supplied if any were expanded. */
8255
8256	void
8257	driver::expand_at_files (int *argc, char ***argv) const
8258	{
8259	char **old_argv = *argv;
8260
8261	expandargv (argc, argv);
8262
8263	/* Determine if any expansions were made. */
8264	if (*argv != old_argv)
8265	at_file_supplied = true;
8266	}
8267
8268	/* Decode the command-line arguments from argc/argv into the
8269	decoded_options array. */
8270
8271	void
8272	driver::decode_argv (int argc, const char **argv)
8273	{
8274	init_opts_obstack ();
8275	init_options_struct (opts: &global_options, opts_set: &global_options_set);
8276
8277	decode_cmdline_options_to_array (argc, argv,
8278	CL_DRIVER,
8279	decoded_options: &decoded_options, decoded_options_count: &decoded_options_count);
8280	}
8281
8282	/* Perform various initializations and setup. */
8283
8284	void
8285	driver::global_initializations ()
8286	{
8287	/* Unlock the stdio streams. */
8288	unlock_std_streams ();
8289
8290	gcc_init_libintl ();
8291
8292	diagnostic_initialize (context: global_dc, n_opts: 0);
8293	diagnostic_color_init (context: global_dc);
8294	diagnostic_urls_init (context: global_dc);
8295	global_dc->set_urlifier (make_gcc_urlifier ());
8296
8297	#ifdef GCC_DRIVER_HOST_INITIALIZATION
8298	/* Perform host dependent initialization when needed. */
8299	GCC_DRIVER_HOST_INITIALIZATION;
8300	#endif
8301
8302	if (atexit (func: delete_temp_files) != 0)
8303	fatal_error (input_location, "atexit failed");
8304
8305	if (signal (SIGINT, SIG_IGN) != SIG_IGN)
8306	signal (SIGINT, handler: fatal_signal);
8307	#ifdef SIGHUP
8308	if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
8309	signal (SIGHUP, handler: fatal_signal);
8310	#endif
8311	if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
8312	signal (SIGTERM, handler: fatal_signal);
8313	#ifdef SIGPIPE
8314	if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
8315	signal (SIGPIPE, handler: fatal_signal);
8316	#endif
8317	#ifdef SIGCHLD
8318	/* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8319	receive the signal. A different setting is inheritable */
8320	signal (SIGCHLD, SIG_DFL);
8321	#endif
8322
8323	/* Parsing and gimplification sometimes need quite large stack.
8324	Increase stack size limits if possible. */
8325	stack_limit_increase (64 * 1024 * 1024);
8326
8327	/* Allocate the argument vector. */
8328	alloc_args ();
8329
8330	obstack_init (&obstack);
8331	}
8332
8333	/* Build multilib_select, et. al from the separate lines that make up each
8334	multilib selection. */
8335
8336	void
8337	driver::build_multilib_strings () const
8338	{
8339	{
8340	const char *p;
8341	const char *const *q = multilib_raw;
8342	int need_space;
8343
8344	obstack_init (&multilib_obstack);
8345	while ((p = *q++) != (char *) 0)
8346	obstack_grow (&multilib_obstack, p, strlen (p));
8347
8348	obstack_1grow (&multilib_obstack, 0);
8349	multilib_select = XOBFINISH (&multilib_obstack, const char *);
8350
8351	q = multilib_matches_raw;
8352	while ((p = *q++) != (char *) 0)
8353	obstack_grow (&multilib_obstack, p, strlen (p));
8354
8355	obstack_1grow (&multilib_obstack, 0);
8356	multilib_matches = XOBFINISH (&multilib_obstack, const char *);
8357
8358	q = multilib_exclusions_raw;
8359	while ((p = *q++) != (char *) 0)
8360	obstack_grow (&multilib_obstack, p, strlen (p));
8361
8362	obstack_1grow (&multilib_obstack, 0);
8363	multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
8364
8365	q = multilib_reuse_raw;
8366	while ((p = *q++) != (char *) 0)
8367	obstack_grow (&multilib_obstack, p, strlen (p));
8368
8369	obstack_1grow (&multilib_obstack, 0);
8370	multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
8371
8372	need_space = false;
8373	for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
8374	{
8375	if (need_space)
8376	obstack_1grow (&multilib_obstack, ' ');
8377	obstack_grow (&multilib_obstack,
8378	multilib_defaults_raw[i],
8379	strlen (multilib_defaults_raw[i]));
8380	need_space = true;
8381	}
8382
8383	obstack_1grow (&multilib_obstack, 0);
8384	multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
8385	}
8386	}
8387
8388	/* Set up the spec-handling machinery. */
8389
8390	void
8391	driver::set_up_specs () const
8392	{
8393	const char *spec_machine_suffix;
8394	char *specs_file;
8395	size_t i;
8396
8397	#ifdef INIT_ENVIRONMENT
8398	/* Set up any other necessary machine specific environment variables. */
8399	xputenv (INIT_ENVIRONMENT);
8400	#endif
8401
8402	/* Make a table of what switches there are (switches, n_switches).
8403	Make a table of specified input files (infiles, n_infiles).
8404	Decode switches that are handled locally. */
8405
8406	process_command (decoded_options_count, decoded_options);
8407
8408	/* Initialize the vector of specs to just the default.
8409	This means one element containing 0s, as a terminator. */
8410
8411	compilers = XNEWVAR (struct compiler, sizeof default_compilers);
8412	memcpy (dest: compilers, src: default_compilers, n: sizeof default_compilers);
8413	n_compilers = n_default_compilers;
8414
8415	/* Read specs from a file if there is one. */
8416
8417	machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,
8418	accel_dir_suffix, dir_separator_str, NULL);
8419	just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
8420
8421	specs_file = find_a_file (pprefix: &startfile_prefixes, name: "specs", R_OK, do_multi: true);
8422	/* Read the specs file unless it is a default one. */
8423	if (specs_file != 0 && strcmp (s1: specs_file, s2: "specs"))
8424	read_specs (filename: specs_file, main_p: true, user_p: false);
8425	else
8426	init_spec ();
8427
8428	#ifdef ACCEL_COMPILER
8429	spec_machine_suffix = machine_suffix;
8430	#else
8431	spec_machine_suffix = just_machine_suffix;
8432	#endif
8433
8434	/* We need to check standard_exec_prefix/spec_machine_suffix/specs
8435	for any override of as, ld and libraries. */
8436	specs_file = (char *) alloca (strlen (standard_exec_prefix)
8437	+ strlen (spec_machine_suffix) + sizeof ("specs"));
8438	strcpy (dest: specs_file, src: standard_exec_prefix);
8439	strcat (dest: specs_file, src: spec_machine_suffix);
8440	strcat (dest: specs_file, src: "specs");
8441	if (access (name: specs_file, R_OK) == 0)
8442	read_specs (filename: specs_file, main_p: true, user_p: false);
8443
8444	/* Process any configure-time defaults specified for the command line
8445	options, via OPTION_DEFAULT_SPECS. */
8446	for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
8447	do_option_spec (name: option_default_specs[i].name,
8448	spec: option_default_specs[i].spec);
8449
8450	/* Process DRIVER_SELF_SPECS, adding any new options to the end
8451	of the command line. */
8452
8453	for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
8454	do_self_spec (driver_self_specs[i]);
8455
8456	/* If not cross-compiling, look for executables in the standard
8457	places. */
8458	if (*cross_compile == '0')
8459	{
8460	if (*md_exec_prefix)
8461	{
8462	add_prefix (pprefix: &exec_prefixes, prefix: md_exec_prefix, component: "GCC",
8463	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
8464	}
8465	}
8466
8467	/* Process sysroot_suffix_spec. */
8468	if (*sysroot_suffix_spec != 0
8469	&& !no_sysroot_suffix
8470	&& do_spec_2 (spec: sysroot_suffix_spec, NULL) == 0)
8471	{
8472	if (argbuf.length () > 1)
8473	error ("spec failure: more than one argument to "
8474	"%<SYSROOT_SUFFIX_SPEC%>");
8475	else if (argbuf.length () == 1)
8476	target_sysroot_suffix = xstrdup (argbuf.last ());
8477	}
8478
8479	#ifdef HAVE_LD_SYSROOT
8480	/* Pass the --sysroot option to the linker, if it supports that. If
8481	there is a sysroot_suffix_spec, it has already been processed by
8482	this point, so target_system_root really is the system root we
8483	should be using. */
8484	if (target_system_root)
8485	{
8486	obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8487	obstack_grow0 (&obstack, link_spec, strlen (link_spec));
8488	set_spec (name: "link", XOBFINISH (&obstack, const char *), user_p: false);
8489	}
8490	#endif
8491
8492	/* Process sysroot_hdrs_suffix_spec. */
8493	if (*sysroot_hdrs_suffix_spec != 0
8494	&& !no_sysroot_suffix
8495	&& do_spec_2 (spec: sysroot_hdrs_suffix_spec, NULL) == 0)
8496	{
8497	if (argbuf.length () > 1)
8498	error ("spec failure: more than one argument "
8499	"to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8500	else if (argbuf.length () == 1)
8501	target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
8502	}
8503
8504	/* Look for startfiles in the standard places. */
8505	if (*startfile_prefix_spec != 0
8506	&& do_spec_2 (spec: startfile_prefix_spec, NULL) == 0
8507	&& do_spec_1 (spec: " ", inswitch: 0, NULL) == 0)
8508	{
8509	for (const char *arg : argbuf)
8510	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: arg, component: "BINUTILS",
8511	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8512	}
8513	/* We should eventually get rid of all these and stick to
8514	startfile_prefix_spec exclusively. */
8515	else if (*cross_compile == '0' || target_system_root)
8516	{
8517	if (*md_startfile_prefix)
8518	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: md_startfile_prefix,
8519	component: "GCC", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8520
8521	if (*md_startfile_prefix_1)
8522	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: md_startfile_prefix_1,
8523	component: "GCC", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8524
8525	/* If standard_startfile_prefix is relative, base it on
8526	standard_exec_prefix. This lets us move the installed tree
8527	as a unit. If GCC_EXEC_PREFIX is defined, base
8528	standard_startfile_prefix on that as well.
8529
8530	If the prefix is relative, only search it for native compilers;
8531	otherwise we will search a directory containing host libraries. */
8532	if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
8533	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8534	prefix: standard_startfile_prefix, component: "BINUTILS",
8535	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8536	else if (*cross_compile == '0')
8537	{
8538	add_prefix (pprefix: &startfile_prefixes,
8539	prefix: concat (gcc_exec_prefix
8540	? gcc_exec_prefix : standard_exec_prefix,
8541	machine_suffix,
8542	standard_startfile_prefix, NULL),
8543	NULL, priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8544	}
8545
8546	/* Sysrooted prefixes are relocated because target_system_root is
8547	also relocated by gcc_exec_prefix. */
8548	if (*standard_startfile_prefix_1)
8549	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8550	prefix: standard_startfile_prefix_1, component: "BINUTILS",
8551	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8552	if (*standard_startfile_prefix_2)
8553	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8554	prefix: standard_startfile_prefix_2, component: "BINUTILS",
8555	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8556	}
8557
8558	/* Process any user specified specs in the order given on the command
8559	line. */
8560	for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next)
8561	{
8562	char *filename = find_a_file (pprefix: &startfile_prefixes, name: uptr->filename,
8563	R_OK, do_multi: true);
8564	read_specs (filename: filename ? filename : uptr->filename, main_p: false, user_p: true);
8565	}
8566
8567	/* Process any user self specs. */
8568	{
8569	struct spec_list *sl;
8570	for (sl = specs; sl; sl = sl->next)
8571	if (sl->name_len == sizeof "self_spec" - 1
8572	&& !strcmp (s1: sl->name, s2: "self_spec"))
8573	do_self_spec (spec: *sl->ptr_spec);
8574	}
8575
8576	if (compare_debug)
8577	{
8578	enum save_temps save;
8579
8580	if (!compare_debug_second)
8581	{
8582	n_switches_debug_check[1] = n_switches;
8583	n_switches_alloc_debug_check[1] = n_switches_alloc;
8584	switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
8585	n_switches_alloc);
8586
8587	do_self_spec (spec: "%:compare-debug-self-opt()");
8588	n_switches_debug_check[0] = n_switches;
8589	n_switches_alloc_debug_check[0] = n_switches_alloc;
8590	switches_debug_check[0] = switches;
8591
8592	n_switches = n_switches_debug_check[1];
8593	n_switches_alloc = n_switches_alloc_debug_check[1];
8594	switches = switches_debug_check[1];
8595	}
8596
8597	/* Avoid crash when computing %j in this early. */
8598	save = save_temps_flag;
8599	save_temps_flag = SAVE_TEMPS_NONE;
8600
8601	compare_debug = -compare_debug;
8602	do_self_spec (spec: "%:compare-debug-self-opt()");
8603
8604	save_temps_flag = save;
8605
8606	if (!compare_debug_second)
8607	{
8608	n_switches_debug_check[1] = n_switches;
8609	n_switches_alloc_debug_check[1] = n_switches_alloc;
8610	switches_debug_check[1] = switches;
8611	compare_debug = -compare_debug;
8612	n_switches = n_switches_debug_check[0];
8613	n_switches_alloc = n_switches_debug_check[0];
8614	switches = switches_debug_check[0];
8615	}
8616	}
8617
8618
8619	/* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8620	if (gcc_exec_prefix)
8621	gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine,
8622	dir_separator_str, spec_version,
8623	accel_dir_suffix, dir_separator_str, NULL);
8624
8625	/* Now we have the specs.
8626	Set the `valid' bits for switches that match anything in any spec. */
8627
8628	validate_all_switches ();
8629
8630	/* Now that we have the switches and the specs, set
8631	the subdirectory based on the options. */
8632	set_multilib_dir ();
8633	}
8634
8635	/* Set up to remember the pathname of gcc and any options
8636	needed for collect. We use argv[0] instead of progname because
8637	we need the complete pathname. */
8638
8639	void
8640	driver::putenv_COLLECT_GCC (const char *argv0) const
8641	{
8642	obstack_init (&collect_obstack);
8643	obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8644	obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1);
8645	xputenv (XOBFINISH (&collect_obstack, char *));
8646	}
8647
8648	/* Set up to remember the pathname of the lto wrapper. */
8649
8650	void
8651	driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8652	{
8653	char *lto_wrapper_file;
8654
8655	if (have_c)
8656	lto_wrapper_file = NULL;
8657	else
8658	lto_wrapper_file = find_a_program (name: "lto-wrapper");
8659	if (lto_wrapper_file)
8660	{
8661	lto_wrapper_file = convert_white_space (lto_wrapper_file);
8662	set_static_spec_owned (spec: &lto_wrapper_spec, val: lto_wrapper_file);
8663	obstack_init (&collect_obstack);
8664	obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
8665	sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8666	obstack_grow (&collect_obstack, lto_wrapper_spec,
8667	strlen (lto_wrapper_spec) + 1);
8668	xputenv (XOBFINISH (&collect_obstack, char *));
8669	}
8670
8671	}
8672
8673	/* Set up to remember the names of offload targets. */
8674
8675	void
8676	driver::maybe_putenv_OFFLOAD_TARGETS () const
8677	{
8678	if (offload_targets && offload_targets[0] != '\0')
8679	{
8680	obstack_grow (&collect_obstack, "OFFLOAD_TARGET_NAMES=",
8681	sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8682	obstack_grow (&collect_obstack, offload_targets,
8683	strlen (offload_targets) + 1);
8684	xputenv (XOBFINISH (&collect_obstack, char *));
8685	#if OFFLOAD_DEFAULTED
8686	if (offload_targets_default)
8687	xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8688	#endif
8689	}
8690
8691	free (ptr: offload_targets);
8692	offload_targets = NULL;
8693	}
8694
8695	/* Reject switches that no pass was interested in. */
8696
8697	void
8698	driver::handle_unrecognized_options ()
8699	{
8700	for (size_t i = 0; (int) i < n_switches; i++)
8701	if (! switches[i].validated)
8702	{
8703	const char *hint = m_option_proposer.suggest_option (bad_opt: switches[i].part1);
8704	if (hint)
8705	error ("unrecognized command-line option %<-%s%>;"
8706	" did you mean %<-%s%>?",
8707	switches[i].part1, hint);
8708	else
8709	error ("unrecognized command-line option %<-%s%>",
8710	switches[i].part1);
8711	}
8712	}
8713
8714	/* Handle the various -print-* options, returning 0 if the driver
8715	should exit, or nonzero if the driver should continue. */
8716
8717	int
8718	driver::maybe_print_and_exit () const
8719	{
8720	if (print_search_dirs)
8721	{
8722	printf (_("install: %s%s\n"),
8723	gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
8724	gcc_exec_prefix ? "" : machine_suffix);
8725	printf (_("programs: %s\n"),
8726	build_search_list (paths: &exec_prefixes, prefix: "", check_dir: false, do_multi: false));
8727	printf (_("libraries: %s\n"),
8728	build_search_list (paths: &startfile_prefixes, prefix: "", check_dir: false, do_multi: true));
8729	return (0);
8730	}
8731
8732	if (print_file_name)
8733	{
8734	printf (format: "%s\n", find_file (print_file_name));
8735	return (0);
8736	}
8737
8738	if (print_prog_name)
8739	{
8740	if (use_ld != NULL && ! strcmp (print_prog_name, s2: "ld"))
8741	{
8742	/* Append USE_LD to the default linker. */
8743	#ifdef DEFAULT_LINKER
8744	char *ld;
8745	# ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8746	int len = (sizeof (DEFAULT_LINKER)
8747	- sizeof (HOST_EXECUTABLE_SUFFIX));
8748	ld = NULL;
8749	if (len > 0)
8750	{
8751	char *default_linker = xstrdup (DEFAULT_LINKER);
8752	/* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8753	HOST_EXECUTABLE_SUFFIX. */
8754	if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
8755	{
8756	default_linker[len] = '\0';
8757	ld = concat (default_linker, use_ld,
8758	HOST_EXECUTABLE_SUFFIX, NULL);
8759	}
8760	}
8761	if (ld == NULL)
8762	# endif
8763	ld = concat (DEFAULT_LINKER, use_ld, NULL);
8764	if (access (ld, X_OK) == 0)
8765	{
8766	printf ("%s\n", ld);
8767	return (0);
8768	}
8769	#endif
8770	print_prog_name = concat (print_prog_name, use_ld, NULL);
8771	}
8772	char *newname = find_a_program (print_prog_name);
8773	printf (format: "%s\n", (newname ? newname : print_prog_name));
8774	return (0);
8775	}
8776
8777	if (print_multi_lib)
8778	{
8779	print_multilib_info ();
8780	return (0);
8781	}
8782
8783	if (print_multi_directory)
8784	{
8785	if (multilib_dir == NULL)
8786	printf (format: ".\n");
8787	else
8788	printf (format: "%s\n", multilib_dir);
8789	return (0);
8790	}
8791
8792	if (print_multiarch)
8793	{
8794	if (multiarch_dir == NULL)
8795	printf (format: "\n");
8796	else
8797	printf (format: "%s\n", multiarch_dir);
8798	return (0);
8799	}
8800
8801	if (print_sysroot)
8802	{
8803	if (target_system_root)
8804	{
8805	if (target_sysroot_suffix)
8806	printf (format: "%s%s\n", target_system_root, target_sysroot_suffix);
8807	else
8808	printf (format: "%s\n", target_system_root);
8809	}
8810	return (0);
8811	}
8812
8813	if (print_multi_os_directory)
8814	{
8815	if (multilib_os_dir == NULL)
8816	printf (format: ".\n");
8817	else
8818	printf (format: "%s\n", multilib_os_dir);
8819	return (0);
8820	}
8821
8822	if (print_sysroot_headers_suffix)
8823	{
8824	if (*sysroot_hdrs_suffix_spec)
8825	{
8826	printf(format: "%s\n", (target_sysroot_hdrs_suffix
8827	? target_sysroot_hdrs_suffix
8828	: ""));
8829	return (0);
8830	}
8831	else
8832	/* The error status indicates that only one set of fixed
8833	headers should be built. */
8834	fatal_error (input_location,
8835	"not configured with sysroot headers suffix");
8836	}
8837
8838	if (print_help_list)
8839	{
8840	display_help ();
8841
8842	if (! verbose_flag)
8843	{
8844	printf (_("\nFor bug reporting instructions, please see:\n"));
8845	printf (format: "%s.\n", bug_report_url);
8846
8847	return (0);
8848	}
8849
8850	/* We do not exit here. Instead we have created a fake input file
8851	called 'help-dummy' which needs to be compiled, and we pass this
8852	on the various sub-processes, along with the --help switch.
8853	Ensure their output appears after ours. */
8854	fputc (c: '\n', stdout);
8855	fflush (stdout);
8856	}
8857
8858	if (print_version)
8859	{
8860	printf (_("%s %s%s\n"), progname, pkgversion_string,
8861	version_string);
8862	printf (format: "Copyright %s 2023 Free Software Foundation, Inc.\n",
8863	_("(C)"));
8864	fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8865	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8866	stdout);
8867	if (! verbose_flag)
8868	return 0;
8869
8870	/* We do not exit here. We use the same mechanism of --help to print
8871	the version of the sub-processes. */
8872	fputc (c: '\n', stdout);
8873	fflush (stdout);
8874	}
8875
8876	if (verbose_flag)
8877	{
8878	print_configuration (stderr);
8879	if (n_infiles == 0)
8880	return (0);
8881	}
8882
8883	return 1;
8884	}
8885
8886	/* Figure out what to do with each input file.
8887	Return true if we need to exit early from "main", false otherwise. */
8888
8889	bool
8890	driver::prepare_infiles ()
8891	{
8892	size_t i;
8893	int lang_n_infiles = 0;
8894
8895	if (n_infiles == added_libraries)
8896	fatal_error (input_location, "no input files");
8897
8898	if (seen_error ())
8899	/* Early exit needed from main. */
8900	return true;
8901
8902	/* Make a place to record the compiler output file names
8903	that correspond to the input files. */
8904
8905	i = n_infiles;
8906	i += lang_specific_extra_outfiles;
8907	outfiles = XCNEWVEC (const char *, i);
8908
8909	/* Record which files were specified explicitly as link input. */
8910
8911	explicit_link_files = XCNEWVEC (char, n_infiles);
8912
8913	combine_inputs = have_o || flag_wpa;
8914
8915	for (i = 0; (int) i < n_infiles; i++)
8916	{
8917	const char *name = infiles[i].name;
8918	struct compiler *compiler = lookup_compiler (name,
8919	strlen (s: name),
8920	infiles[i].language);
8921
8922	if (compiler && !(compiler->combinable))
8923	combine_inputs = false;
8924
8925	if (lang_n_infiles > 0 && compiler != input_file_compiler
8926	&& infiles[i].language && infiles[i].language[0] != '*')
8927	infiles[i].incompiler = compiler;
8928	else if (compiler)
8929	{
8930	lang_n_infiles++;
8931	input_file_compiler = compiler;
8932	infiles[i].incompiler = compiler;
8933	}
8934	else
8935	{
8936	/* Since there is no compiler for this input file, assume it is a
8937	linker file. */
8938	explicit_link_files[i] = 1;
8939	infiles[i].incompiler = NULL;
8940	}
8941	infiles[i].compiled = false;
8942	infiles[i].preprocessed = false;
8943	}
8944
8945	if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
8946	fatal_error (input_location,
8947	"cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8948	"with multiple files");
8949
8950	/* No early exit needed from main; we can continue. */
8951	return false;
8952	}
8953
8954	/* Run the spec machinery on each input file. */
8955
8956	void
8957	driver::do_spec_on_infiles () const
8958	{
8959	size_t i;
8960
8961	for (i = 0; (int) i < n_infiles; i++)
8962	{
8963	int this_file_error = 0;
8964
8965	/* Tell do_spec what to substitute for %i. */
8966
8967	input_file_number = i;
8968	set_input (infiles[i].name);
8969
8970	if (infiles[i].compiled)
8971	continue;
8972
8973	/* Use the same thing in %o, unless cp->spec says otherwise. */
8974
8975	outfiles[i] = gcc_input_filename;
8976
8977	/* Figure out which compiler from the file's suffix. */
8978
8979	input_file_compiler
8980	= lookup_compiler (infiles[i].name, input_filename_length,
8981	infiles[i].language);
8982
8983	if (input_file_compiler)
8984	{
8985	/* Ok, we found an applicable compiler. Run its spec. */
8986
8987	if (input_file_compiler->spec[0] == '#')
8988	{
8989	error ("%s: %s compiler not installed on this system",
8990	gcc_input_filename, &input_file_compiler->spec[1]);
8991	this_file_error = 1;
8992	}
8993	else
8994	{
8995	int value;
8996
8997	if (compare_debug)
8998	{
8999	free (ptr: debug_check_temp_file[0]);
9000	debug_check_temp_file[0] = NULL;
9001
9002	free (ptr: debug_check_temp_file[1]);
9003	debug_check_temp_file[1] = NULL;
9004	}
9005
9006	value = do_spec (spec: input_file_compiler->spec);
9007	infiles[i].compiled = true;
9008	if (value < 0)
9009	this_file_error = 1;
9010	else if (compare_debug && debug_check_temp_file[0])
9011	{
9012	if (verbose_flag)
9013	inform (UNKNOWN_LOCATION,
9014	"recompiling with %<-fcompare-debug%>");
9015
9016	compare_debug = -compare_debug;
9017	n_switches = n_switches_debug_check[1];
9018	n_switches_alloc = n_switches_alloc_debug_check[1];
9019	switches = switches_debug_check[1];
9020
9021	value = do_spec (spec: input_file_compiler->spec);
9022
9023	compare_debug = -compare_debug;
9024	n_switches = n_switches_debug_check[0];
9025	n_switches_alloc = n_switches_alloc_debug_check[0];
9026	switches = switches_debug_check[0];
9027
9028	if (value < 0)
9029	{
9030	error ("during %<-fcompare-debug%> recompilation");
9031	this_file_error = 1;
9032	}
9033
9034	gcc_assert (debug_check_temp_file[1]
9035	&& filename_cmp (debug_check_temp_file[0],
9036	debug_check_temp_file[1]));
9037
9038	if (verbose_flag)
9039	inform (UNKNOWN_LOCATION, "comparing final insns dumps");
9040
9041	if (compare_files (cmpfile: debug_check_temp_file))
9042	this_file_error = 1;
9043	}
9044
9045	if (compare_debug)
9046	{
9047	free (ptr: debug_check_temp_file[0]);
9048	debug_check_temp_file[0] = NULL;
9049
9050	free (ptr: debug_check_temp_file[1]);
9051	debug_check_temp_file[1] = NULL;
9052	}
9053	}
9054	}
9055
9056	/* If this file's name does not contain a recognized suffix,
9057	record it as explicit linker input. */
9058
9059	else
9060	explicit_link_files[i] = 1;
9061
9062	/* Clear the delete-on-failure queue, deleting the files in it
9063	if this compilation failed. */
9064
9065	if (this_file_error)
9066	{
9067	delete_failure_queue ();
9068	errorcount++;
9069	}
9070	/* If this compilation succeeded, don't delete those files later. */
9071	clear_failure_queue ();
9072	}
9073
9074	/* Reset the input file name to the first compile/object file name, for use
9075	with %b in LINK_SPEC. We use the first input file that we can find
9076	a compiler to compile it instead of using infiles.language since for
9077	languages other than C we use aliases that we then lookup later. */
9078	if (n_infiles > 0)
9079	{
9080	int i;
9081
9082	for (i = 0; i < n_infiles ; i++)
9083	if (infiles[i].incompiler
9084	|| (infiles[i].language && infiles[i].language[0] != '*'))
9085	{
9086	set_input (infiles[i].name);
9087	break;
9088	}
9089	}
9090
9091	if (!seen_error ())
9092	{
9093	/* Make sure INPUT_FILE_NUMBER points to first available open
9094	slot. */
9095	input_file_number = n_infiles;
9096	if (lang_specific_pre_link ())
9097	errorcount++;
9098	}
9099	}
9100
9101	/* If we have to run the linker, do it now. */
9102
9103	void
9104	driver::maybe_run_linker (const char *argv0) const
9105	{
9106	size_t i;
9107	int linker_was_run = 0;
9108	int num_linker_inputs;
9109
9110	/* Determine if there are any linker input files. */
9111	num_linker_inputs = 0;
9112	for (i = 0; (int) i < n_infiles; i++)
9113	if (explicit_link_files[i] || outfiles[i] != NULL)
9114	num_linker_inputs++;
9115
9116	/* Arrange for temporary file names created during linking to take
9117	on names related with the linker output rather than with the
9118	inputs when appropriate. */
9119	if (outbase && *outbase)
9120	{
9121	if (dumpdir)
9122	{
9123	char *tofree = dumpdir;
9124	gcc_checking_assert (strlen (dumpdir) == dumpdir_length);
9125	dumpdir = concat (dumpdir, outbase, ".", NULL);
9126	free (ptr: tofree);
9127	}
9128	else
9129	dumpdir = concat (outbase, ".", NULL);
9130	dumpdir_length += strlen (s: outbase) + 1;
9131	dumpdir_trailing_dash_added = true;
9132	}
9133	else if (dumpdir_trailing_dash_added)
9134	{
9135	gcc_assert (dumpdir[dumpdir_length - 1] == '-');
9136	dumpdir[dumpdir_length - 1] = '.';
9137	}
9138
9139	if (dumpdir_trailing_dash_added)
9140	{
9141	gcc_assert (dumpdir_length > 0);
9142	gcc_assert (dumpdir[dumpdir_length - 1] == '.');
9143	dumpdir_length--;
9144	}
9145
9146	free (ptr: outbase);
9147	input_basename = outbase = NULL;
9148	outbase_length = suffixed_basename_length = basename_length = 0;
9149
9150	/* Run ld to link all the compiler output files. */
9151
9152	if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
9153	{
9154	int tmp = execution_count;
9155
9156	detect_jobserver ();
9157
9158	if (! have_c)
9159	{
9160	#if HAVE_LTO_PLUGIN > 0
9161	#if HAVE_LTO_PLUGIN == 2
9162	const char *fno_use_linker_plugin = "fno-use-linker-plugin";
9163	#else
9164	const char *fuse_linker_plugin = "fuse-linker-plugin";
9165	#endif
9166	#endif
9167
9168	/* We'll use ld if we can't find collect2. */
9169	if (! strcmp (s1: linker_name_spec, s2: "collect2"))
9170	{
9171	char *s = find_a_program (name: "collect2");
9172	if (s == NULL)
9173	set_static_spec_shared (spec: &linker_name_spec, val: "ld");
9174	}
9175
9176	#if HAVE_LTO_PLUGIN > 0
9177	#if HAVE_LTO_PLUGIN == 2
9178	if (!switch_matches (atom: fno_use_linker_plugin,
9179	end_atom: fno_use_linker_plugin
9180	+ strlen (s: fno_use_linker_plugin), starred: 0))
9181	#else
9182	if (switch_matches (fuse_linker_plugin,
9183	fuse_linker_plugin
9184	+ strlen (fuse_linker_plugin), 0))
9185	#endif
9186	{
9187	char *temp_spec = find_a_file (pprefix: &exec_prefixes,
9188	LTOPLUGINSONAME, R_OK,
9189	do_multi: false);
9190	if (!temp_spec)
9191	fatal_error (input_location,
9192	"%<-fuse-linker-plugin%>, but %s not found",
9193	LTOPLUGINSONAME);
9194	linker_plugin_file_spec = convert_white_space (temp_spec);
9195	}
9196	#endif
9197	set_static_spec_shared (spec: &lto_gcc_spec, val: argv0);
9198	}
9199
9200	/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9201	for collect. */
9202	putenv_from_prefixes (paths: &exec_prefixes, env_var: "COMPILER_PATH", do_multi: false);
9203	putenv_from_prefixes (paths: &startfile_prefixes, LIBRARY_PATH_ENV, do_multi: true);
9204
9205	if (print_subprocess_help == 1)
9206	{
9207	printf (_("\nLinker options\n==============\n\n"));
9208	printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9209	" to the linker.\n\n"));
9210	fflush (stdout);
9211	}
9212	int value = do_spec (spec: link_command_spec);
9213	if (value < 0)
9214	errorcount = 1;
9215	linker_was_run = (tmp != execution_count);
9216	}
9217
9218	/* If options said don't run linker,
9219	complain about input files to be given to the linker. */
9220
9221	if (! linker_was_run && !seen_error ())
9222	for (i = 0; (int) i < n_infiles; i++)
9223	if (explicit_link_files[i]
9224	&& !(infiles[i].language && infiles[i].language[0] == '*'))
9225	{
9226	warning (0, "%s: linker input file unused because linking not done",
9227	outfiles[i]);
9228	if (access (name: outfiles[i], F_OK) < 0)
9229	/* This is can be an indication the user specifed an errorneous
9230	separated option value, (or used the wrong prefix for an
9231	option). */
9232	error ("%s: linker input file not found: %m", outfiles[i]);
9233	}
9234	}
9235
9236	/* The end of "main". */
9237
9238	void
9239	driver::final_actions () const
9240	{
9241	/* Delete some or all of the temporary files we made. */
9242
9243	if (seen_error ())
9244	delete_failure_queue ();
9245	delete_temp_files ();
9246
9247	if (print_help_list)
9248	{
9249	printf (format: ("\nFor bug reporting instructions, please see:\n"));
9250	printf (format: "%s\n", bug_report_url);
9251	}
9252	}
9253
9254	/* Detect whether jobserver is active and working. If not drop
9255	--jobserver-auth from MAKEFLAGS. */
9256
9257	void
9258	driver::detect_jobserver () const
9259	{
9260	jobserver_info jinfo;
9261	if (!jinfo.is_active && !jinfo.skipped_makeflags.empty ())
9262	xputenv (string: xstrdup (jinfo.skipped_makeflags.c_str ()));
9263	}
9264
9265	/* Determine what the exit code of the driver should be. */
9266
9267	int
9268	driver::get_exit_code () const
9269	{
9270	return (signal_count != 0 ? 2
9271	: seen_error () ? (pass_exit_codes ? greatest_status : 1)
9272	: 0);
9273	}
9274
9275	/* Find the proper compilation spec for the file name NAME,
9276	whose length is LENGTH. LANGUAGE is the specified language,
9277	or 0 if this file is to be passed to the linker. */
9278
9279	static struct compiler *
9280	lookup_compiler (const char *name, size_t length, const char *language)
9281	{
9282	struct compiler *cp;
9283
9284	/* If this was specified by the user to be a linker input, indicate that. */
9285	if (language != 0 && language[0] == '*')
9286	return 0;
9287
9288	/* Otherwise, look for the language, if one is spec'd. */
9289	if (language != 0)
9290	{
9291	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9292	if (cp->suffix[0] == '@' && !strcmp (s1: cp->suffix + 1, s2: language))
9293	{
9294	if (name != NULL && strcmp (s1: name, s2: "-") == 0
9295	&& (strcmp (s1: cp->suffix, s2: "@c-header") == 0
9296	|| strcmp (s1: cp->suffix, s2: "@c++-header") == 0)
9297	&& !have_E)
9298	fatal_error (input_location,
9299	"cannot use %<-%> as input filename for a "
9300	"precompiled header");
9301
9302	return cp;
9303	}
9304
9305	error ("language %s not recognized", language);
9306	return 0;
9307	}
9308
9309	/* Look for a suffix. */
9310	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9311	{
9312	if (/* The suffix `-' matches only the file name `-'. */
9313	(!strcmp (s1: cp->suffix, s2: "-") && !strcmp (s1: name, s2: "-"))
9314	|| (strlen (s: cp->suffix) < length
9315	/* See if the suffix matches the end of NAME. */
9316	&& !strcmp (s1: cp->suffix,
9317	s2: name + length - strlen (s: cp->suffix))
9318	))
9319	break;
9320	}
9321
9322	#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9323	/* Look again, but case-insensitively this time. */
9324	if (cp < compilers)
9325	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9326	{
9327	if (/* The suffix `-' matches only the file name `-'. */
9328	(!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
9329	|| (strlen (cp->suffix) < length
9330	/* See if the suffix matches the end of NAME. */
9331	&& ((!strcmp (cp->suffix,
9332	name + length - strlen (cp->suffix))
9333	|| !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9334	&& !strcasecmp (cp->suffix,
9335	name + length - strlen (cp->suffix)))
9336	))
9337	break;
9338	}
9339	#endif
9340
9341	if (cp >= compilers)
9342	{
9343	if (cp->spec[0] != '@')
9344	/* A non-alias entry: return it. */
9345	return cp;
9346
9347	/* An alias entry maps a suffix to a language.
9348	Search for the language; pass 0 for NAME and LENGTH
9349	to avoid infinite recursion if language not found. */
9350	return lookup_compiler (NULL, length: 0, language: cp->spec + 1);
9351	}
9352	return 0;
9353	}
9354
9355	static char *
9356	save_string (const char *s, int len)
9357	{
9358	char *result = XNEWVEC (char, len + 1);
9359
9360	gcc_checking_assert (strlen (s) >= (unsigned int) len);
9361	memcpy (dest: result, src: s, n: len);
9362	result[len] = 0;
9363	return result;
9364	}
9365
9366
9367	static inline void
9368	validate_switches_from_spec (const char *spec, bool user)
9369	{
9370	const char *p = spec;
9371	char c;
9372	while ((c = *p++))
9373	if (c == '%'
9374	&& (*p == '{'
9375	|| *p == '<'
9376	|| (*p == 'W' && *++p == '{')
9377	|| (*p == '@' && *++p == '{')))
9378	/* We have a switch spec. */
9379	p = validate_switches (p + 1, user, *p == '{');
9380	}
9381
9382	static void
9383	validate_all_switches (void)
9384	{
9385	struct compiler *comp;
9386	struct spec_list *spec;
9387
9388	for (comp = compilers; comp->spec; comp++)
9389	validate_switches_from_spec (spec: comp->spec, user: false);
9390
9391	/* Look through the linked list of specs read from the specs file. */
9392	for (spec = specs; spec; spec = spec->next)
9393	validate_switches_from_spec (spec: *spec->ptr_spec, user: spec->user_p);
9394
9395	validate_switches_from_spec (spec: link_command_spec, user: false);
9396	}
9397
9398	/* Look at the switch-name that comes after START and mark as valid
9399	all supplied switches that match it. If BRACED, handle other
9400	switches after '|' and '&', and specs after ':' until ';' or '}',
9401	going back for more switches after ';'. Without BRACED, handle
9402	only one atom. Return a pointer to whatever follows the handled
9403	items, after the closing brace if BRACED. */
9404
9405	static const char *
9406	validate_switches (const char *start, bool user_spec, bool braced)
9407	{
9408	const char *p = start;
9409	const char *atom;
9410	size_t len;
9411	int i;
9412	bool suffix;
9413	bool starred;
9414
9415	#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9416
9417	next_member:
9418	suffix = false;
9419	starred = false;
9420
9421	SKIP_WHITE ();
9422
9423	if (*p == '!')
9424	p++;
9425
9426	SKIP_WHITE ();
9427	if (*p == '.' || *p == ',')
9428	suffix = true, p++;
9429
9430	atom = p;
9431	while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
9432	|| *p == ',' || *p == '.' || *p == '@')
9433	p++;
9434	len = p - atom;
9435
9436	if (*p == '*')
9437	starred = true, p++;
9438
9439	SKIP_WHITE ();
9440
9441	if (!suffix)
9442	{
9443	/* Mark all matching switches as valid. */
9444	for (i = 0; i < n_switches; i++)
9445	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
9446	&& (starred || switches[i].part1[len] == '\0')
9447	&& (switches[i].known || user_spec))
9448	switches[i].validated = true;
9449	}
9450
9451	if (!braced)
9452	return p;
9453
9454	if (*p) p++;
9455	if (*p && (p[-1] == '|' || p[-1] == '&'))
9456	goto next_member;
9457
9458	if (*p && p[-1] == ':')
9459	{
9460	while (*p && *p != ';' && *p != '}')
9461	{
9462	if (*p == '%')
9463	{
9464	p++;
9465	if (*p == '{' || *p == '<')
9466	p = validate_switches (start: p+1, user_spec, braced: *p == '{');
9467	else if (p[0] == 'W' && p[1] == '{')
9468	p = validate_switches (start: p+2, user_spec, braced: true);
9469	else if (p[0] == '@' && p[1] == '{')
9470	p = validate_switches (start: p+2, user_spec, braced: true);
9471	}
9472	else
9473	p++;
9474	}
9475
9476	if (*p) p++;
9477	if (*p && p[-1] == ';')
9478	goto next_member;
9479	}
9480
9481	return p;
9482	#undef SKIP_WHITE
9483	}
9484
9485	struct mdswitchstr
9486	{
9487	const char *str;
9488	int len;
9489	};
9490
9491	static struct mdswitchstr *mdswitches;
9492	static int n_mdswitches;
9493
9494	/* Check whether a particular argument was used. The first time we
9495	canonicalize the switches to keep only the ones we care about. */
9496
9497	struct used_arg_t
9498	{
9499	public:
9500	int operator () (const char *p, int len);
9501	void finalize ();
9502
9503	private:
9504	struct mswitchstr
9505	{
9506	const char *str;
9507	const char *replace;
9508	int len;
9509	int rep_len;
9510	};
9511
9512	mswitchstr *mswitches;
9513	int n_mswitches;
9514
9515	};
9516
9517	used_arg_t used_arg;
9518
9519	int
9520	used_arg_t::operator () (const char *p, int len)
9521	{
9522	int i, j;
9523
9524	if (!mswitches)
9525	{
9526	struct mswitchstr *matches;
9527	const char *q;
9528	int cnt = 0;
9529
9530	/* Break multilib_matches into the component strings of string
9531	and replacement string. */
9532	for (q = multilib_matches; *q != '\0'; q++)
9533	if (*q == ';')
9534	cnt++;
9535
9536	matches
9537	= (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
9538	i = 0;
9539	q = multilib_matches;
9540	while (*q != '\0')
9541	{
9542	matches[i].str = q;
9543	while (*q != ' ')
9544	{
9545	if (*q == '\0')
9546	{
9547	invalid_matches:
9548	fatal_error (input_location, "multilib spec %qs is invalid",
9549	multilib_matches);
9550	}
9551	q++;
9552	}
9553	matches[i].len = q - matches[i].str;
9554
9555	matches[i].replace = ++q;
9556	while (*q != ';' && *q != '\0')
9557	{
9558	if (*q == ' ')
9559	goto invalid_matches;
9560	q++;
9561	}
9562	matches[i].rep_len = q - matches[i].replace;
9563	i++;
9564	if (*q == ';')
9565	q++;
9566	}
9567
9568	/* Now build a list of the replacement string for switches that we care
9569	about. Make sure we allocate at least one entry. This prevents
9570	xmalloc from calling fatal, and prevents us from re-executing this
9571	block of code. */
9572	mswitches
9573	= XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
9574	for (i = 0; i < n_switches; i++)
9575	if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
9576	{
9577	int xlen = strlen (s: switches[i].part1);
9578	for (j = 0; j < cnt; j++)
9579	if (xlen == matches[j].len
9580	&& ! strncmp (s1: switches[i].part1, s2: matches[j].str, n: xlen))
9581	{
9582	mswitches[n_mswitches].str = matches[j].replace;
9583	mswitches[n_mswitches].len = matches[j].rep_len;
9584	mswitches[n_mswitches].replace = (char *) 0;
9585	mswitches[n_mswitches].rep_len = 0;
9586	n_mswitches++;
9587	break;
9588	}
9589	}
9590
9591	/* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9592	on the command line nor any options mutually incompatible with
9593	them. */
9594	for (i = 0; i < n_mdswitches; i++)
9595	{
9596	const char *r;
9597
9598	for (q = multilib_options; *q != '\0'; *q && q++)
9599	{
9600	while (*q == ' ')
9601	q++;
9602
9603	r = q;
9604	while (strncmp (s1: q, s2: mdswitches[i].str, n: mdswitches[i].len) != 0
9605	|| strchr (s: " /", c: q[mdswitches[i].len]) == NULL)
9606	{
9607	while (*q != ' ' && *q != '/' && *q != '\0')
9608	q++;
9609	if (*q != '/')
9610	break;
9611	q++;
9612	}
9613
9614	if (*q != ' ' && *q != '\0')
9615	{
9616	while (*r != ' ' && *r != '\0')
9617	{
9618	q = r;
9619	while (*q != ' ' && *q != '/' && *q != '\0')
9620	q++;
9621
9622	if (used_arg (r, q - r))
9623	break;
9624
9625	if (*q != '/')
9626	{
9627	mswitches[n_mswitches].str = mdswitches[i].str;
9628	mswitches[n_mswitches].len = mdswitches[i].len;
9629	mswitches[n_mswitches].replace = (char *) 0;
9630	mswitches[n_mswitches].rep_len = 0;
9631	n_mswitches++;
9632	break;
9633	}
9634
9635	r = q + 1;
9636	}
9637	break;
9638	}
9639	}
9640	}
9641	}
9642
9643	for (i = 0; i < n_mswitches; i++)
9644	if (len == mswitches[i].len && ! strncmp (s1: p, s2: mswitches[i].str, n: len))
9645	return 1;
9646
9647	return 0;
9648	}
9649
9650	void used_arg_t::finalize ()
9651	{
9652	XDELETEVEC (mswitches);
9653	mswitches = NULL;
9654	n_mswitches = 0;
9655	}
9656
9657
9658	static int
9659	default_arg (const char *p, int len)
9660	{
9661	int i;
9662
9663	for (i = 0; i < n_mdswitches; i++)
9664	if (len == mdswitches[i].len && ! strncmp (s1: p, s2: mdswitches[i].str, n: len))
9665	return 1;
9666
9667	return 0;
9668	}
9669
9670	/* Work out the subdirectory to use based on the options. The format of
9671	multilib_select is a list of elements. Each element is a subdirectory
9672	name followed by a list of options followed by a semicolon. The format
9673	of multilib_exclusions is the same, but without the preceding
9674	directory. First gcc will check the exclusions, if none of the options
9675	beginning with an exclamation point are present, and all of the other
9676	options are present, then we will ignore this completely. Passing
9677	that, gcc will consider each multilib_select in turn using the same
9678	rules for matching the options. If a match is found, that subdirectory
9679	will be used.
9680	A subdirectory name is optionally followed by a colon and the corresponding
9681	multiarch name. */
9682
9683	static void
9684	set_multilib_dir (void)
9685	{
9686	const char *p;
9687	unsigned int this_path_len;
9688	const char *this_path, *this_arg;
9689	const char *start, *end;
9690	int not_arg;
9691	int ok, ndfltok, first;
9692
9693	n_mdswitches = 0;
9694	start = multilib_defaults;
9695	while (*start == ' ' || *start == '\t')
9696	start++;
9697	while (*start != '\0')
9698	{
9699	n_mdswitches++;
9700	while (*start != ' ' && *start != '\t' && *start != '\0')
9701	start++;
9702	while (*start == ' ' || *start == '\t')
9703	start++;
9704	}
9705
9706	if (n_mdswitches)
9707	{
9708	int i = 0;
9709
9710	mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
9711	for (start = multilib_defaults; *start != '\0'; start = end + 1)
9712	{
9713	while (*start == ' ' || *start == '\t')
9714	start++;
9715
9716	if (*start == '\0')
9717	break;
9718
9719	for (end = start + 1;
9720	*end != ' ' && *end != '\t' && *end != '\0'; end++)
9721	;
9722
9723	obstack_grow (&multilib_obstack, start, end - start);
9724	obstack_1grow (&multilib_obstack, 0);
9725	mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
9726	mdswitches[i++].len = end - start;
9727
9728	if (*end == '\0')
9729	break;
9730	}
9731	}
9732
9733	p = multilib_exclusions;
9734	while (*p != '\0')
9735	{
9736	/* Ignore newlines. */
9737	if (*p == '\n')
9738	{
9739	++p;
9740	continue;
9741	}
9742
9743	/* Check the arguments. */
9744	ok = 1;
9745	while (*p != ';')
9746	{
9747	if (*p == '\0')
9748	{
9749	invalid_exclusions:
9750	fatal_error (input_location, "multilib exclusions %qs is invalid",
9751	multilib_exclusions);
9752	}
9753
9754	if (! ok)
9755	{
9756	++p;
9757	continue;
9758	}
9759
9760	this_arg = p;
9761	while (*p != ' ' && *p != ';')
9762	{
9763	if (*p == '\0')
9764	goto invalid_exclusions;
9765	++p;
9766	}
9767
9768	if (*this_arg != '!')
9769	not_arg = 0;
9770	else
9771	{
9772	not_arg = 1;
9773	++this_arg;
9774	}
9775
9776	ok = used_arg (this_arg, p - this_arg);
9777	if (not_arg)
9778	ok = ! ok;
9779
9780	if (*p == ' ')
9781	++p;
9782	}
9783
9784	if (ok)
9785	return;
9786
9787	++p;
9788	}
9789
9790	first = 1;
9791	p = multilib_select;
9792
9793	/* Append multilib reuse rules if any. With those rules, we can reuse
9794	one multilib for certain different options sets. */
9795	if (strlen (s: multilib_reuse) > 0)
9796	p = concat (p, multilib_reuse, NULL);
9797
9798	while (*p != '\0')
9799	{
9800	/* Ignore newlines. */
9801	if (*p == '\n')
9802	{
9803	++p;
9804	continue;
9805	}
9806
9807	/* Get the initial path. */
9808	this_path = p;
9809	while (*p != ' ')
9810	{
9811	if (*p == '\0')
9812	{
9813	invalid_select:
9814	fatal_error (input_location, "multilib select %qs %qs is invalid",
9815	multilib_select, multilib_reuse);
9816	}
9817	++p;
9818	}
9819	this_path_len = p - this_path;
9820
9821	/* Check the arguments. */
9822	ok = 1;
9823	ndfltok = 1;
9824	++p;
9825	while (*p != ';')
9826	{
9827	if (*p == '\0')
9828	goto invalid_select;
9829
9830	if (! ok)
9831	{
9832	++p;
9833	continue;
9834	}
9835
9836	this_arg = p;
9837	while (*p != ' ' && *p != ';')
9838	{
9839	if (*p == '\0')
9840	goto invalid_select;
9841	++p;
9842	}
9843
9844	if (*this_arg != '!')
9845	not_arg = 0;
9846	else
9847	{
9848	not_arg = 1;
9849	++this_arg;
9850	}
9851
9852	/* If this is a default argument, we can just ignore it.
9853	This is true even if this_arg begins with '!'. Beginning
9854	with '!' does not mean that this argument is necessarily
9855	inappropriate for this library: it merely means that
9856	there is a more specific library which uses this
9857	argument. If this argument is a default, we need not
9858	consider that more specific library. */
9859	ok = used_arg (this_arg, p - this_arg);
9860	if (not_arg)
9861	ok = ! ok;
9862
9863	if (! ok)
9864	ndfltok = 0;
9865
9866	if (default_arg (p: this_arg, len: p - this_arg))
9867	ok = 1;
9868
9869	if (*p == ' ')
9870	++p;
9871	}
9872
9873	if (ok && first)
9874	{
9875	if (this_path_len != 1
9876	|| this_path[0] != '.')
9877	{
9878	char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
9879	char *q;
9880
9881	strncpy (dest: new_multilib_dir, src: this_path, n: this_path_len);
9882	new_multilib_dir[this_path_len] = '\0';
9883	q = strchr (s: new_multilib_dir, c: ':');
9884	if (q != NULL)
9885	*q = '\0';
9886	multilib_dir = new_multilib_dir;
9887	}
9888	first = 0;
9889	}
9890
9891	if (ndfltok)
9892	{
9893	const char *q = this_path, *end = this_path + this_path_len;
9894
9895	while (q < end && *q != ':')
9896	q++;
9897	if (q < end)
9898	{
9899	const char *q2 = q + 1, *ml_end = end;
9900	char *new_multilib_os_dir;
9901
9902	while (q2 < end && *q2 != ':')
9903	q2++;
9904	if (*q2 == ':')
9905	ml_end = q2;
9906	if (ml_end - q == 1)
9907	multilib_os_dir = xstrdup (".");
9908	else
9909	{
9910	new_multilib_os_dir = XNEWVEC (char, ml_end - q);
9911	memcpy (dest: new_multilib_os_dir, src: q + 1, n: ml_end - q - 1);
9912	new_multilib_os_dir[ml_end - q - 1] = '\0';
9913	multilib_os_dir = new_multilib_os_dir;
9914	}
9915
9916	if (q2 < end && *q2 == ':')
9917	{
9918	char *new_multiarch_dir = XNEWVEC (char, end - q2);
9919	memcpy (dest: new_multiarch_dir, src: q2 + 1, n: end - q2 - 1);
9920	new_multiarch_dir[end - q2 - 1] = '\0';
9921	multiarch_dir = new_multiarch_dir;
9922	}
9923	break;
9924	}
9925	}
9926
9927	++p;
9928	}
9929
9930	multilib_dir =
9931	targetm_common.compute_multilib (
9932	switches,
9933	n_switches,
9934	multilib_dir,
9935	multilib_defaults,
9936	multilib_select,
9937	multilib_matches,
9938	multilib_exclusions,
9939	multilib_reuse);
9940
9941	if (multilib_dir == NULL && multilib_os_dir != NULL
9942	&& strcmp (s1: multilib_os_dir, s2: ".") == 0)
9943	{
9944	free (CONST_CAST (char *, multilib_os_dir));
9945	multilib_os_dir = NULL;
9946	}
9947	else if (multilib_dir != NULL && multilib_os_dir == NULL)
9948	multilib_os_dir = multilib_dir;
9949	}
9950
9951	/* Print out the multiple library subdirectory selection
9952	information. This prints out a series of lines. Each line looks
9953	like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9954	required. Only the desired options are printed out, the negative
9955	matches. The options are print without a leading dash. There are
9956	no spaces to make it easy to use the information in the shell.
9957	Each subdirectory is printed only once. This assumes the ordering
9958	generated by the genmultilib script. Also, we leave out ones that match
9959	the exclusions. */
9960
9961	static void
9962	print_multilib_info (void)
9963	{
9964	const char *p = multilib_select;
9965	const char *last_path = 0, *this_path;
9966	int skip;
9967	int not_arg;
9968	unsigned int last_path_len = 0;
9969
9970	while (*p != '\0')
9971	{
9972	skip = 0;
9973	/* Ignore newlines. */
9974	if (*p == '\n')
9975	{
9976	++p;
9977	continue;
9978	}
9979
9980	/* Get the initial path. */
9981	this_path = p;
9982	while (*p != ' ')
9983	{
9984	if (*p == '\0')
9985	{
9986	invalid_select:
9987	fatal_error (input_location,
9988	"multilib select %qs is invalid", multilib_select);
9989	}
9990
9991	++p;
9992	}
9993
9994	/* When --disable-multilib was used but target defines
9995	MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9996	with .:: for multiarch configurations) are there just to find
9997	multilib_os_dir, so skip them from output. */
9998	if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
9999	skip = 1;
10000
10001	/* Check for matches with the multilib_exclusions. We don't bother
10002	with the '!' in either list. If any of the exclusion rules match
10003	all of its options with the select rule, we skip it. */
10004	{
10005	const char *e = multilib_exclusions;
10006	const char *this_arg;
10007
10008	while (*e != '\0')
10009	{
10010	int m = 1;
10011	/* Ignore newlines. */
10012	if (*e == '\n')
10013	{
10014	++e;
10015	continue;
10016	}
10017
10018	/* Check the arguments. */
10019	while (*e != ';')
10020	{
10021	const char *q;
10022	int mp = 0;
10023
10024	if (*e == '\0')
10025	{
10026	invalid_exclusion:
10027	fatal_error (input_location,
10028	"multilib exclusion %qs is invalid",
10029	multilib_exclusions);
10030	}
10031
10032	if (! m)
10033	{
10034	++e;
10035	continue;
10036	}
10037
10038	this_arg = e;
10039
10040	while (*e != ' ' && *e != ';')
10041	{
10042	if (*e == '\0')
10043	goto invalid_exclusion;
10044	++e;
10045	}
10046
10047	q = p + 1;
10048	while (*q != ';')
10049	{
10050	const char *arg;
10051	int len = e - this_arg;
10052
10053	if (*q == '\0')
10054	goto invalid_select;
10055
10056	arg = q;
10057
10058	while (*q != ' ' && *q != ';')
10059	{
10060	if (*q == '\0')
10061	goto invalid_select;
10062	++q;
10063	}
10064
10065	if (! strncmp (s1: arg, s2: this_arg,
10066	n: (len < q - arg) ? q - arg : len)
10067	|| default_arg (p: this_arg, len: e - this_arg))
10068	{
10069	mp = 1;
10070	break;
10071	}
10072
10073	if (*q == ' ')
10074	++q;
10075	}
10076
10077	if (! mp)
10078	m = 0;
10079
10080	if (*e == ' ')
10081	++e;
10082	}
10083
10084	if (m)
10085	{
10086	skip = 1;
10087	break;
10088	}
10089
10090	if (*e != '\0')
10091	++e;
10092	}
10093	}
10094
10095	if (! skip)
10096	{
10097	/* If this is a duplicate, skip it. */
10098	skip = (last_path != 0
10099	&& (unsigned int) (p - this_path) == last_path_len
10100	&& ! filename_ncmp (s1: last_path, s2: this_path, n: last_path_len));
10101
10102	last_path = this_path;
10103	last_path_len = p - this_path;
10104	}
10105
10106	/* If all required arguments are default arguments, and no default
10107	arguments appear in the ! argument list, then we can skip it.
10108	We will already have printed a directory identical to this one
10109	which does not require that default argument. */
10110	if (! skip)
10111	{
10112	const char *q;
10113	bool default_arg_ok = false;
10114
10115	q = p + 1;
10116	while (*q != ';')
10117	{
10118	const char *arg;
10119
10120	if (*q == '\0')
10121	goto invalid_select;
10122
10123	if (*q == '!')
10124	{
10125	not_arg = 1;
10126	q++;
10127	}
10128	else
10129	not_arg = 0;
10130	arg = q;
10131
10132	while (*q != ' ' && *q != ';')
10133	{
10134	if (*q == '\0')
10135	goto invalid_select;
10136	++q;
10137	}
10138
10139	if (default_arg (p: arg, len: q - arg))
10140	{
10141	/* Stop checking if any default arguments appeared in not
10142	list. */
10143	if (not_arg)
10144	{
10145	default_arg_ok = false;
10146	break;
10147	}
10148
10149	default_arg_ok = true;
10150	}
10151	else if (!not_arg)
10152	{
10153	/* Stop checking if any required argument is not provided by
10154	default arguments. */
10155	default_arg_ok = false;
10156	break;
10157	}
10158
10159	if (*q == ' ')
10160	++q;
10161	}
10162
10163	/* Make sure all default argument is OK for this multi-lib set. */
10164	if (default_arg_ok)
10165	skip = 1;
10166	else
10167	skip = 0;
10168	}
10169
10170	if (! skip)
10171	{
10172	const char *p1;
10173
10174	for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
10175	putchar (c: *p1);
10176	putchar (c: ';');
10177	}
10178
10179	++p;
10180	while (*p != ';')
10181	{
10182	int use_arg;
10183
10184	if (*p == '\0')
10185	goto invalid_select;
10186
10187	if (skip)
10188	{
10189	++p;
10190	continue;
10191	}
10192
10193	use_arg = *p != '!';
10194
10195	if (use_arg)
10196	putchar (c: '@');
10197
10198	while (*p != ' ' && *p != ';')
10199	{
10200	if (*p == '\0')
10201	goto invalid_select;
10202	if (use_arg)
10203	putchar (c: *p);
10204	++p;
10205	}
10206
10207	if (*p == ' ')
10208	++p;
10209	}
10210
10211	if (! skip)
10212	{
10213	/* If there are extra options, print them now. */
10214	if (multilib_extra && *multilib_extra)
10215	{
10216	int print_at = true;
10217	const char *q;
10218
10219	for (q = multilib_extra; *q != '\0'; q++)
10220	{
10221	if (*q == ' ')
10222	print_at = true;
10223	else
10224	{
10225	if (print_at)
10226	putchar (c: '@');
10227	putchar (c: *q);
10228	print_at = false;
10229	}
10230	}
10231	}
10232
10233	putchar (c: '\n');
10234	}
10235
10236	++p;
10237	}
10238	}
10239
10240	/* getenv built-in spec function.
10241
10242	Returns the value of the environment variable given by its first argument,
10243	concatenated with the second argument. If the variable is not defined, a
10244	fatal error is issued unless such undefs are internally allowed, in which
10245	case the variable name prefixed by a '/' is used as the variable value.
10246
10247	The leading '/' allows using the result at a spot where a full path would
10248	normally be expected and when the actual value doesn't really matter since
10249	undef vars are allowed. */
10250
10251	static const char *
10252	getenv_spec_function (int argc, const char **argv)
10253	{
10254	const char *value;
10255	const char *varname;
10256
10257	char *result;
10258	char *ptr;
10259	size_t len;
10260
10261	if (argc != 2)
10262	return NULL;
10263
10264	varname = argv[0];
10265	value = env.get (name: varname);
10266
10267	/* If the variable isn't defined and this is allowed, craft our expected
10268	return value. Assume variable names used in specs strings don't contain
10269	any active spec character so don't need escaping. */
10270	if (!value && spec_undefvar_allowed)
10271	{
10272	result = XNEWVAR (char, strlen(varname) + 2);
10273	sprintf (s: result, format: "/%s", varname);
10274	return result;
10275	}
10276
10277	if (!value)
10278	fatal_error (input_location,
10279	"environment variable %qs not defined", varname);
10280
10281	/* We have to escape every character of the environment variable so
10282	they are not interpreted as active spec characters. A
10283	particularly painful case is when we are reading a variable
10284	holding a windows path complete with \ separators. */
10285	len = strlen (s: value) * 2 + strlen (s: argv[1]) + 1;
10286	result = XNEWVAR (char, len);
10287	for (ptr = result; *value; ptr += 2)
10288	{
10289	ptr[0] = '\\';
10290	ptr[1] = *value++;
10291	}
10292
10293	strcpy (dest: ptr, src: argv[1]);
10294
10295	return result;
10296	}
10297
10298	/* if-exists built-in spec function.
10299
10300	Checks to see if the file specified by the absolute pathname in
10301	ARGS exists. Returns that pathname if found.
10302
10303	The usual use for this function is to check for a library file
10304	(whose name has been expanded with %s). */
10305
10306	static const char *
10307	if_exists_spec_function (int argc, const char **argv)
10308	{
10309	/* Must have only one argument. */
10310	if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10311	return argv[0];
10312
10313	return NULL;
10314	}
10315
10316	/* if-exists-else built-in spec function.
10317
10318	This is like if-exists, but takes an additional argument which
10319	is returned if the first argument does not exist. */
10320
10321	static const char *
10322	if_exists_else_spec_function (int argc, const char **argv)
10323	{
10324	/* Must have exactly two arguments. */
10325	if (argc != 2)
10326	return NULL;
10327
10328	if (IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10329	return argv[0];
10330
10331	return argv[1];
10332	}
10333
10334	/* if-exists-then-else built-in spec function.
10335
10336	Checks to see if the file specified by the absolute pathname in
10337	the first arg exists. Returns the second arg if so, otherwise returns
10338	the third arg if it is present. */
10339
10340	static const char *
10341	if_exists_then_else_spec_function (int argc, const char **argv)
10342	{
10343
10344	/* Must have two or three arguments. */
10345	if (argc != 2 && argc != 3)
10346	return NULL;
10347
10348	if (IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10349	return argv[1];
10350
10351	if (argc == 3)
10352	return argv[2];
10353
10354	return NULL;
10355	}
10356
10357	/* sanitize built-in spec function.
10358
10359	This returns non-NULL, if sanitizing address, thread or
10360	any of the undefined behavior sanitizers. */
10361
10362	static const char *
10363	sanitize_spec_function (int argc, const char **argv)
10364	{
10365	if (argc != 1)
10366	return NULL;
10367
10368	if (strcmp (s1: argv[0], s2: "address") == 0)
10369	return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL;
10370	if (strcmp (s1: argv[0], s2: "hwaddress") == 0)
10371	return (flag_sanitize & SANITIZE_USER_HWADDRESS) ? "" : NULL;
10372	if (strcmp (s1: argv[0], s2: "kernel-address") == 0)
10373	return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL;
10374	if (strcmp (s1: argv[0], s2: "kernel-hwaddress") == 0)
10375	return (flag_sanitize & SANITIZE_KERNEL_HWADDRESS) ? "" : NULL;
10376	if (strcmp (s1: argv[0], s2: "thread") == 0)
10377	return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
10378	if (strcmp (s1: argv[0], s2: "undefined") == 0)
10379	return ((flag_sanitize
10380	& ~flag_sanitize_trap
10381	& (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)))
10382	? "" : NULL;
10383	if (strcmp (s1: argv[0], s2: "leak") == 0)
10384	return ((flag_sanitize
10385	& (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
10386	== SANITIZE_LEAK) ? "" : NULL;
10387	return NULL;
10388	}
10389
10390	/* replace-outfile built-in spec function.
10391
10392	This looks for the first argument in the outfiles array's name and
10393	replaces it with the second argument. */
10394
10395	static const char *
10396	replace_outfile_spec_function (int argc, const char **argv)
10397	{
10398	int i;
10399	/* Must have exactly two arguments. */
10400	if (argc != 2)
10401	abort ();
10402
10403	for (i = 0; i < n_infiles; i++)
10404	{
10405	if (outfiles[i] && !filename_cmp (s1: outfiles[i], s2: argv[0]))
10406	outfiles[i] = xstrdup (argv[1]);
10407	}
10408	return NULL;
10409	}
10410
10411	/* remove-outfile built-in spec function.
10412	*
10413	* This looks for the first argument in the outfiles array's name and
10414	* removes it. */
10415
10416	static const char *
10417	remove_outfile_spec_function (int argc, const char **argv)
10418	{
10419	int i;
10420	/* Must have exactly one argument. */
10421	if (argc != 1)
10422	abort ();
10423
10424	for (i = 0; i < n_infiles; i++)
10425	{
10426	if (outfiles[i] && !filename_cmp (s1: outfiles[i], s2: argv[0]))
10427	outfiles[i] = NULL;
10428	}
10429	return NULL;
10430	}
10431
10432	/* Given two version numbers, compares the two numbers.
10433	A version number must match the regular expression
10434	([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10435	*/
10436	static int
10437	compare_version_strings (const char *v1, const char *v2)
10438	{
10439	int rresult;
10440	regex_t r;
10441
10442	if (regcomp (preg: &r, pattern: "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10443	REG_EXTENDED | REG_NOSUB) != 0)
10444	abort ();
10445	rresult = regexec (preg: &r, string: v1, nmatch: 0, NULL, eflags: 0);
10446	if (rresult == REG_NOMATCH)
10447	fatal_error (input_location, "invalid version number %qs", v1);
10448	else if (rresult != 0)
10449	abort ();
10450	rresult = regexec (preg: &r, string: v2, nmatch: 0, NULL, eflags: 0);
10451	if (rresult == REG_NOMATCH)
10452	fatal_error (input_location, "invalid version number %qs", v2);
10453	else if (rresult != 0)
10454	abort ();
10455
10456	return strverscmp (s1: v1, s2: v2);
10457	}
10458
10459
10460	/* version_compare built-in spec function.
10461
10462	This takes an argument of the following form:
10463
10464	<comparison-op> <arg1> [<arg2>] <switch> <result>
10465
10466	and produces "result" if the comparison evaluates to true,
10467	and nothing if it doesn't.
10468
10469	The supported <comparison-op> values are:
10470
10471	>= true if switch is a later (or same) version than arg1
10472	!> opposite of >=
10473	< true if switch is an earlier version than arg1
10474	!< opposite of <
10475	>< true if switch is arg1 or later, and earlier than arg2
10476	<> true if switch is earlier than arg1 or is arg2 or later
10477
10478	If the switch is not present, the condition is false unless
10479	the first character of the <comparison-op> is '!'.
10480
10481	For example,
10482	%:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10483	adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10484
10485	static const char *
10486	version_compare_spec_function (int argc, const char **argv)
10487	{
10488	int comp1, comp2;
10489	size_t switch_len;
10490	const char *switch_value = NULL;
10491	int nargs = 1, i;
10492	bool result;
10493
10494	if (argc < 3)
10495	fatal_error (input_location, "too few arguments to %%:version-compare");
10496	if (argv[0][0] == '\0')
10497	abort ();
10498	if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
10499	nargs = 2;
10500	if (argc != nargs + 3)
10501	fatal_error (input_location, "too many arguments to %%:version-compare");
10502
10503	switch_len = strlen (s: argv[nargs + 1]);
10504	for (i = 0; i < n_switches; i++)
10505	if (!strncmp (s1: switches[i].part1, s2: argv[nargs + 1], n: switch_len)
10506	&& check_live_switch (switchnum: i, prefix_length: switch_len))
10507	switch_value = switches[i].part1 + switch_len;
10508
10509	if (switch_value == NULL)
10510	comp1 = comp2 = -1;
10511	else
10512	{
10513	comp1 = compare_version_strings (v1: switch_value, v2: argv[1]);
10514	if (nargs == 2)
10515	comp2 = compare_version_strings (v1: switch_value, v2: argv[2]);
10516	else
10517	comp2 = -1; /* This value unused. */
10518	}
10519
10520	switch (argv[0][0] << 8 | argv[0][1])
10521	{
10522	case '>' << 8 | '=':
10523	result = comp1 >= 0;
10524	break;
10525	case '!' << 8 | '<':
10526	result = comp1 >= 0 || switch_value == NULL;
10527	break;
10528	case '<' << 8:
10529	result = comp1 < 0;
10530	break;
10531	case '!' << 8 | '>':
10532	result = comp1 < 0 || switch_value == NULL;
10533	break;
10534	case '>' << 8 | '<':
10535	result = comp1 >= 0 && comp2 < 0;
10536	break;
10537	case '<' << 8 | '>':
10538	result = comp1 < 0 || comp2 >= 0;
10539	break;
10540
10541	default:
10542	fatal_error (input_location,
10543	"unknown operator %qs in %%:version-compare", argv[0]);
10544	}
10545	if (! result)
10546	return NULL;
10547
10548	return argv[nargs + 2];
10549	}
10550
10551	/* %:include builtin spec function. This differs from %include in that it
10552	can be nested inside a spec, and thus be conditionalized. It takes
10553	one argument, the filename, and looks for it in the startfile path.
10554	The result is always NULL, i.e. an empty expansion. */
10555
10556	static const char *
10557	include_spec_function (int argc, const char **argv)
10558	{
10559	char *file;
10560
10561	if (argc != 1)
10562	abort ();
10563
10564	file = find_a_file (pprefix: &startfile_prefixes, name: argv[0], R_OK, do_multi: true);
10565	read_specs (filename: file ? file : argv[0], main_p: false, user_p: false);
10566
10567	return NULL;
10568	}
10569
10570	/* %:find-file spec function. This function replaces its argument by
10571	the file found through find_file, that is the -print-file-name gcc
10572	program option. */
10573	static const char *
10574	find_file_spec_function (int argc, const char **argv)
10575	{
10576	const char *file;
10577
10578	if (argc != 1)
10579	abort ();
10580
10581	file = find_file (name: argv[0]);
10582	return file;
10583	}
10584
10585
10586	/* %:find-plugindir spec function. This function replaces its argument
10587	by the -iplugindir=<dir> option. `dir' is found through find_file, that
10588	is the -print-file-name gcc program option. */
10589	static const char *
10590	find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
10591	{
10592	const char *option;
10593
10594	if (argc != 0)
10595	abort ();
10596
10597	option = concat ("-iplugindir=", find_file (name: "plugin"), NULL);
10598	return option;
10599	}
10600
10601
10602	/* %:print-asm-header spec function. Print a banner to say that the
10603	following output is from the assembler. */
10604
10605	static const char *
10606	print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
10607	const char **argv ATTRIBUTE_UNUSED)
10608	{
10609	printf (_("Assembler options\n=================\n\n"));
10610	printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10611	fflush (stdout);
10612	return NULL;
10613	}
10614
10615	/* Get a random number for -frandom-seed */
10616
10617	static unsigned HOST_WIDE_INT
10618	get_random_number (void)
10619	{
10620	unsigned HOST_WIDE_INT ret = 0;
10621	int fd;
10622
10623	fd = open (file: "/dev/urandom", O_RDONLY);
10624	if (fd >= 0)
10625	{
10626	read (fd: fd, buf: &ret, nbytes: sizeof (HOST_WIDE_INT));
10627	close (fd: fd);
10628	if (ret)
10629	return ret;
10630	}
10631
10632	/* Get some more or less random data. */
10633	#ifdef HAVE_GETTIMEOFDAY
10634	{
10635	struct timeval tv;
10636
10637	gettimeofday (tv: &tv, NULL);
10638	ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
10639	}
10640	#else
10641	{
10642	time_t now = time (NULL);
10643
10644	if (now != (time_t)-1)
10645	ret = (unsigned) now;
10646	}
10647	#endif
10648
10649	return ret ^ getpid ();
10650	}
10651
10652	/* %:compare-debug-dump-opt spec function. Save the last argument,
10653	expected to be the last -fdump-final-insns option, or generate a
10654	temporary. */
10655
10656	static const char *
10657	compare_debug_dump_opt_spec_function (int arg,
10658	const char **argv ATTRIBUTE_UNUSED)
10659	{
10660	char *ret;
10661	char *name;
10662	int which;
10663	static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
10664
10665	if (arg != 0)
10666	fatal_error (input_location,
10667	"too many arguments to %%:compare-debug-dump-opt");
10668
10669	do_spec_2 (spec: "%{fdump-final-insns=*:%*}", NULL);
10670	do_spec_1 (spec: " ", inswitch: 0, NULL);
10671
10672	if (argbuf.length () > 0
10673	&& strcmp (s1: argv[argbuf.length () - 1], s2: ".") != 0)
10674	{
10675	if (!compare_debug)
10676	return NULL;
10677
10678	name = xstrdup (argv[argbuf.length () - 1]);
10679	ret = NULL;
10680	}
10681	else
10682	{
10683	if (argbuf.length () > 0)
10684	do_spec_2 (spec: "%B.gkd", NULL);
10685	else if (!compare_debug)
10686	return NULL;
10687	else
10688	do_spec_2 (spec: "%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL);
10689
10690	do_spec_1 (spec: " ", inswitch: 0, NULL);
10691
10692	gcc_assert (argbuf.length () > 0);
10693
10694	name = xstrdup (argbuf.last ());
10695
10696	char *arg = quote_spec (xstrdup (name));
10697	ret = concat ("-fdump-final-insns=", arg, NULL);
10698	free (ptr: arg);
10699	}
10700
10701	which = compare_debug < 0;
10702	debug_check_temp_file[which] = name;
10703
10704	if (!which)
10705	{
10706	unsigned HOST_WIDE_INT value = get_random_number ();
10707
10708	sprintf (s: random_seed, HOST_WIDE_INT_PRINT_HEX, value);
10709	}
10710
10711	if (*random_seed)
10712	{
10713	char *tmp = ret;
10714	ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
10715	ret, NULL);
10716	free (ptr: tmp);
10717	}
10718
10719	if (which)
10720	*random_seed = 0;
10721
10722	return ret;
10723	}
10724
10725	/* %:compare-debug-self-opt spec function. Expands to the options
10726	that are to be passed in the second compilation of
10727	compare-debug. */
10728
10729	static const char *
10730	compare_debug_self_opt_spec_function (int arg,
10731	const char **argv ATTRIBUTE_UNUSED)
10732	{
10733	if (arg != 0)
10734	fatal_error (input_location,
10735	"too many arguments to %%:compare-debug-self-opt");
10736
10737	if (compare_debug >= 0)
10738	return NULL;
10739
10740	return concat ("\
10741	%<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10742	%<fdump-final-insns=* -w -S -o %j \
10743	%{!fcompare-debug-second:-fcompare-debug-second} \
10744	", compare_debug_opt, NULL);
10745	}
10746
10747	/* %:pass-through-libs spec function. Finds all -l options and input
10748	file names in the lib spec passed to it, and makes a list of them
10749	prepended with the plugin option to cause them to be passed through
10750	to the final link after all the new object files have been added. */
10751
10752	const char *
10753	pass_through_libs_spec_func (int argc, const char **argv)
10754	{
10755	char *prepended = xstrdup (" ");
10756	int n;
10757	/* Shlemiel the painter's algorithm. Innately horrible, but at least
10758	we know that there will never be more than a handful of strings to
10759	concat, and it's only once per run, so it's not worth optimising. */
10760	for (n = 0; n < argc; n++)
10761	{
10762	char *old = prepended;
10763	/* Anything that isn't an option is a full path to an output
10764	file; pass it through if it ends in '.a'. Among options,
10765	pass only -l. */
10766	if (argv[n][0] == '-' && argv[n][1] == 'l')
10767	{
10768	const char *lopt = argv[n] + 2;
10769	/* Handle both joined and non-joined -l options. If for any
10770	reason there's a trailing -l with no joined or following
10771	arg just discard it. */
10772	if (!*lopt && ++n >= argc)
10773	break;
10774	else if (!*lopt)
10775	lopt = argv[n];
10776	prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
10777	lopt, " ", NULL);
10778	}
10779	else if (!strcmp (s1: ".a", s2: argv[n] + strlen (s: argv[n]) - 2))
10780	{
10781	prepended = concat (prepended, "-plugin-opt=-pass-through=",
10782	argv[n], " ", NULL);
10783	}
10784	if (prepended != old)
10785	free (ptr: old);
10786	}
10787	return prepended;
10788	}
10789
10790	static bool
10791	not_actual_file_p (const char *name)
10792	{
10793	return (strcmp (s1: name, s2: "-") == 0
10794	|| strcmp (s1: name, HOST_BIT_BUCKET) == 0);
10795	}
10796
10797	/* %:dumps spec function. Take an optional argument that overrides
10798	the default extension for -dumpbase and -dumpbase-ext.
10799	Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10800	const char *
10801	dumps_spec_func (int argc, const char **argv ATTRIBUTE_UNUSED)
10802	{
10803	const char *ext = dumpbase_ext;
10804	char *p;
10805
10806	char *args[3] = { NULL, NULL, NULL };
10807	int nargs = 0;
10808
10809	/* Do not compute a default for -dumpbase-ext when -dumpbase was
10810	given explicitly. */
10811	if (dumpbase && *dumpbase && !ext)
10812	ext = "";
10813
10814	if (argc == 1)
10815	{
10816	/* Do not override the explicitly-specified -dumpbase-ext with
10817	the specs-provided overrider. */
10818	if (!ext)
10819	ext = argv[0];
10820	}
10821	else if (argc != 0)
10822	fatal_error (input_location, "too many arguments for %%:dumps");
10823
10824	if (dumpdir)
10825	{
10826	p = quote_spec_arg (xstrdup (dumpdir));
10827	args[nargs++] = concat (" -dumpdir ", p, NULL);
10828	free (ptr: p);
10829	}
10830
10831	if (!ext)
10832	ext = input_basename + basename_length;
10833
10834	/* Use the precomputed outbase, or compute dumpbase from
10835	input_basename, just like %b would. */
10836	char *base;
10837
10838	if (dumpbase && *dumpbase)
10839	{
10840	base = xstrdup (dumpbase);
10841	p = base + outbase_length;
10842	gcc_checking_assert (strncmp (base, outbase, outbase_length) == 0);
10843	gcc_checking_assert (strcmp (p, ext) == 0);
10844	}
10845	else if (outbase_length)
10846	{
10847	base = xstrndup (outbase, outbase_length);
10848	p = NULL;
10849	}
10850	else
10851	{
10852	base = xstrndup (input_basename, suffixed_basename_length);
10853	p = base + basename_length;
10854	}
10855
10856	if (compare_debug < 0 || !p || strcmp (s1: p, s2: ext) != 0)
10857	{
10858	if (p)
10859	*p = '\0';
10860
10861	const char *gk;
10862	if (compare_debug < 0)
10863	gk = ".gk";
10864	else
10865	gk = "";
10866
10867	p = concat (base, gk, ext, NULL);
10868
10869	free (ptr: base);
10870	base = p;
10871	}
10872
10873	base = quote_spec_arg (base);
10874	args[nargs++] = concat (" -dumpbase ", base, NULL);
10875	free (ptr: base);
10876
10877	if (*ext)
10878	{
10879	p = quote_spec_arg (xstrdup (ext));
10880	args[nargs++] = concat (" -dumpbase-ext ", p, NULL);
10881	free (ptr: p);
10882	}
10883
10884	const char *ret = concat (args[0], args[1], args[2], NULL);
10885	while (nargs > 0)
10886	free (ptr: args[--nargs]);
10887
10888	return ret;
10889	}
10890
10891	/* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10892	Otherwise, return NULL. */
10893
10894	static const char *
10895	greater_than_spec_func (int argc, const char **argv)
10896	{
10897	char *converted;
10898
10899	if (argc == 1)
10900	return NULL;
10901
10902	gcc_assert (argc >= 2);
10903
10904	long arg = strtol (nptr: argv[argc - 2], endptr: &converted, base: 10);
10905	gcc_assert (converted != argv[argc - 2]);
10906
10907	long lim = strtol (nptr: argv[argc - 1], endptr: &converted, base: 10);
10908	gcc_assert (converted != argv[argc - 1]);
10909
10910	if (arg > lim)
10911	return "";
10912
10913	return NULL;
10914	}
10915
10916	/* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10917	Otherwise, return NULL. */
10918
10919	static const char *
10920	debug_level_greater_than_spec_func (int argc, const char **argv)
10921	{
10922	char *converted;
10923
10924	if (argc != 1)
10925	fatal_error (input_location,
10926	"wrong number of arguments to %%:debug-level-gt");
10927
10928	long arg = strtol (nptr: argv[0], endptr: &converted, base: 10);
10929	gcc_assert (converted != argv[0]);
10930
10931	if (debug_info_level > arg)
10932	return "";
10933
10934	return NULL;
10935	}
10936
10937	/* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10938	Otherwise, return NULL. */
10939
10940	static const char *
10941	dwarf_version_greater_than_spec_func (int argc, const char **argv)
10942	{
10943	char *converted;
10944
10945	if (argc != 1)
10946	fatal_error (input_location,
10947	"wrong number of arguments to %%:dwarf-version-gt");
10948
10949	long arg = strtol (nptr: argv[0], endptr: &converted, base: 10);
10950	gcc_assert (converted != argv[0]);
10951
10952	if (dwarf_version > arg)
10953	return "";
10954
10955	return NULL;
10956	}
10957
10958	static void
10959	path_prefix_reset (path_prefix *prefix)
10960	{
10961	struct prefix_list *iter, *next;
10962	iter = prefix->plist;
10963	while (iter)
10964	{
10965	next = iter->next;
10966	free (ptr: const_cast <char *> (iter->prefix));
10967	XDELETE (iter);
10968	iter = next;
10969	}
10970	prefix->plist = 0;
10971	prefix->max_len = 0;
10972	}
10973
10974	/* The function takes 3 arguments: OPTION name, file name and location
10975	where we search for Fortran modules.
10976	When the FILE is found by find_file, return OPTION=path_to_file. */
10977
10978	static const char *
10979	find_fortran_preinclude_file (int argc, const char **argv)
10980	{
10981	char *result = NULL;
10982	if (argc != 3)
10983	return NULL;
10984
10985	struct path_prefix prefixes = { .plist: 0, .max_len: 0, .name: "preinclude" };
10986
10987	/* Search first for 'finclude' folder location for a header file
10988	installed by the compiler (similar to omp_lib.h). */
10989	add_prefix (pprefix: &prefixes, prefix: argv[2], NULL, priority: 0, require_machine_suffix: 0, os_multilib: 0);
10990	#ifdef TOOL_INCLUDE_DIR
10991	/* Then search: <prefix>/<target>/<include>/finclude */
10992	add_prefix (&prefixes, TOOL_INCLUDE_DIR "/finclude/",
10993	NULL, 0, 0, 0);
10994	#endif
10995	#ifdef NATIVE_SYSTEM_HEADER_DIR
10996	/* Then search: <sysroot>/usr/include/finclude/<multilib> */
10997	add_sysrooted_hdrs_prefix (&prefixes, NATIVE_SYSTEM_HEADER_DIR "/finclude/",
10998	NULL, 0, 0, 0);
10999	#endif
11000
11001	const char *path = find_a_file (pprefix: &include_prefixes, name: argv[1], R_OK, do_multi: false);
11002	if (path != NULL)
11003	result = concat (argv[0], path, NULL);
11004	else
11005	{
11006	path = find_a_file (pprefix: &prefixes, name: argv[1], R_OK, do_multi: false);
11007	if (path != NULL)
11008	result = concat (argv[0], path, NULL);
11009	}
11010
11011	path_prefix_reset (prefix: &prefixes);
11012	return result;
11013	}
11014
11015	/* The function takes any number of arguments and joins them together.
11016
11017	This seems to be necessary to build "-fjoined=foo.b" from "-fseparate foo.a"
11018	with a %{fseparate*:-fjoined=%.b$*} rule without adding undesired spaces:
11019	when doing $* replacement we first replace $* with the rest of the switch
11020	(in this case ""), and then add any arguments as arguments after the result,
11021	resulting in "-fjoined= foo.b". Using this function with e.g.
11022	%{fseparate*:-fjoined=%:join(%.b$*)} gets multiple words as separate argv
11023	elements instead of separated by spaces, and we paste them together. */
11024
11025	static const char *
11026	join_spec_func (int argc, const char **argv)
11027	{
11028	if (argc == 1)
11029	return argv[0];
11030	for (int i = 0; i < argc; ++i)
11031	obstack_grow (&obstack, argv[i], strlen (argv[i]));
11032	obstack_1grow (&obstack, '\0');
11033	return XOBFINISH (&obstack, const char *);
11034	}
11035
11036	/* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
11037	so as to precede every one of them with a backslash. Return the
11038	original string or the reallocated one. */
11039
11040	static inline char *
11041	quote_string (char *orig, bool (*quote_p)(char, void *), void *p)
11042	{
11043	int len, number_of_space = 0;
11044
11045	for (len = 0; orig[len]; len++)
11046	if (quote_p (orig[len], p))
11047	number_of_space++;
11048
11049	if (number_of_space)
11050	{
11051	char *new_spec = (char *) xmalloc (len + number_of_space + 1);
11052	int j, k;
11053	for (j = 0, k = 0; j <= len; j++, k++)
11054	{
11055	if (quote_p (orig[j], p))
11056	new_spec[k++] = '\\';
11057	new_spec[k] = orig[j];
11058	}
11059	free (ptr: orig);
11060	return new_spec;
11061	}
11062	else
11063	return orig;
11064	}
11065
11066	/* Return true iff C is any of the characters convert_white_space
11067	should quote. */
11068
11069	static inline bool
11070	whitespace_to_convert_p (char c, void *)
11071	{
11072	return (c == ' ' || c == '\t');
11073	}
11074
11075	/* Insert backslash before spaces in ORIG (usually a file path), to
11076	avoid being broken by spec parser.
11077
11078	This function is needed as do_spec_1 treats white space (' ' and '\t')
11079	as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
11080	the file name should be treated as a single argument rather than being
11081	broken into multiple. Solution is to insert '\\' before the space in a
11082	file name.
11083
11084	This function converts and only converts all occurrence of ' '
11085	to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
11086	"a b" -> "a\\ b"
11087	"a b" -> "a\\ \\ b"
11088	"a\tb" -> "a\\\tb"
11089	"a\\ b" -> "a\\\\ b"
11090
11091	orig: input null-terminating string that was allocated by xalloc. The
11092	memory it points to might be freed in this function. Behavior undefined
11093	if ORIG wasn't xalloced or was freed already at entry.
11094
11095	Return: ORIG if no conversion needed. Otherwise a newly allocated string
11096	that was converted from ORIG. */
11097
11098	static char *
11099	convert_white_space (char *orig)
11100	{
11101	return quote_string (orig, quote_p: whitespace_to_convert_p, NULL);
11102	}
11103
11104	/* Return true iff C matches any of the spec active characters. */
11105	static inline bool
11106	quote_spec_char_p (char c, void *)
11107	{
11108	switch (c)
11109	{
11110	case ' ':
11111	case '\t':
11112	case '\n':
11113	case '|':
11114	case '%':
11115	case '\\':
11116	return true;
11117
11118	default:
11119	return false;
11120	}
11121	}
11122
11123	/* Like convert_white_space, but deactivate all active spec chars by
11124	quoting them. */
11125
11126	static inline char *
11127	quote_spec (char *orig)
11128	{
11129	return quote_string (orig, quote_p: quote_spec_char_p, NULL);
11130	}
11131
11132	/* Like quote_spec, but also turn an empty string into the spec for an
11133	empty argument. */
11134
11135	static inline char *
11136	quote_spec_arg (char *orig)
11137	{
11138	if (!*orig)
11139	{
11140	free (ptr: orig);
11141	return xstrdup ("%\"");
11142	}
11143
11144	return quote_spec (orig);
11145	}
11146
11147	/* Restore all state within gcc.cc to the initial state, so that the driver
11148	code can be safely re-run in-process.
11149
11150	Many const char * variables are referenced by static specs (see
11151	INIT_STATIC_SPEC above). These variables are restored to their default
11152	values by a simple loop over the static specs.
11153
11154	For other variables, we directly restore them all to their initial
11155	values (often implicitly 0).
11156
11157	Free the various obstacks in this file, along with "opts_obstack"
11158	from opts.cc.
11159
11160	This function also restores any environment variables that were changed. */
11161
11162	void
11163	driver::finalize ()
11164	{
11165	env.restore ();
11166	diagnostic_finish (context: global_dc);
11167
11168	is_cpp_driver = 0;
11169	at_file_supplied = 0;
11170	print_help_list = 0;
11171	print_version = 0;
11172	verbose_only_flag = 0;
11173	print_subprocess_help = 0;
11174	use_ld = NULL;
11175	report_times_to_file = NULL;
11176	target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
11177	target_system_root_changed = 0;
11178	target_sysroot_suffix = 0;
11179	target_sysroot_hdrs_suffix = 0;
11180	save_temps_flag = SAVE_TEMPS_NONE;
11181	save_temps_overrides_dumpdir = false;
11182	dumpdir_trailing_dash_added = false;
11183	free (ptr: dumpdir);
11184	free (ptr: dumpbase);
11185	free (ptr: dumpbase_ext);
11186	free (ptr: outbase);
11187	dumpdir = dumpbase = dumpbase_ext = outbase = NULL;
11188	dumpdir_length = outbase_length = 0;
11189	spec_machine = DEFAULT_TARGET_MACHINE;
11190	greatest_status = 1;
11191
11192	obstack_free (&obstack, NULL);
11193	obstack_free (&opts_obstack, NULL); /* in opts.cc */
11194	obstack_free (&collect_obstack, NULL);
11195
11196	link_command_spec = LINK_COMMAND_SPEC;
11197
11198	obstack_free (&multilib_obstack, NULL);
11199
11200	user_specs_head = NULL;
11201	user_specs_tail = NULL;
11202
11203	/* Within the "compilers" vec, the fields "suffix" and "spec" were
11204	statically allocated for the default compilers, but dynamically
11205	allocated for additional compilers. Delete them for the latter. */
11206	for (int i = n_default_compilers; i < n_compilers; i++)
11207	{
11208	free (ptr: const_cast <char *> (compilers[i].suffix));
11209	free (ptr: const_cast <char *> (compilers[i].spec));
11210	}
11211	XDELETEVEC (compilers);
11212	compilers = NULL;
11213	n_compilers = 0;
11214
11215	linker_options.truncate (size: 0);
11216	assembler_options.truncate (size: 0);
11217	preprocessor_options.truncate (size: 0);
11218
11219	path_prefix_reset (prefix: &exec_prefixes);
11220	path_prefix_reset (prefix: &startfile_prefixes);
11221	path_prefix_reset (prefix: &include_prefixes);
11222
11223	machine_suffix = 0;
11224	just_machine_suffix = 0;
11225	gcc_exec_prefix = 0;
11226	gcc_libexec_prefix = 0;
11227	set_static_spec_shared (spec: &md_exec_prefix, MD_EXEC_PREFIX);
11228	set_static_spec_shared (spec: &md_startfile_prefix, MD_STARTFILE_PREFIX);
11229	set_static_spec_shared (spec: &md_startfile_prefix_1, MD_STARTFILE_PREFIX_1);
11230	multilib_dir = 0;
11231	multilib_os_dir = 0;
11232	multiarch_dir = 0;
11233
11234	/* Free any specs dynamically-allocated by set_spec.
11235	These will be at the head of the list, before the
11236	statically-allocated ones. */
11237	if (specs)
11238	{
11239	while (specs != static_specs)
11240	{
11241	spec_list *next = specs->next;
11242	free (ptr: const_cast <char *> (specs->name));
11243	XDELETE (specs);
11244	specs = next;
11245	}
11246	specs = 0;
11247	}
11248	for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
11249	{
11250	spec_list *sl = &static_specs[i];
11251	if (sl->alloc_p)
11252	{
11253	free (ptr: const_cast <char *> (*(sl->ptr_spec)));
11254	sl->alloc_p = false;
11255	}
11256	*(sl->ptr_spec) = sl->default_ptr;
11257	}
11258	#ifdef EXTRA_SPECS
11259	extra_specs = NULL;
11260	#endif
11261
11262	processing_spec_function = 0;
11263
11264	clear_args ();
11265
11266	have_c = 0;
11267	have_o = 0;
11268
11269	temp_names = NULL;
11270	execution_count = 0;
11271	signal_count = 0;
11272
11273	temp_filename = NULL;
11274	temp_filename_length = 0;
11275	always_delete_queue = NULL;
11276	failure_delete_queue = NULL;
11277
11278	XDELETEVEC (switches);
11279	switches = NULL;
11280	n_switches = 0;
11281	n_switches_alloc = 0;
11282
11283	compare_debug = 0;
11284	compare_debug_second = 0;
11285	compare_debug_opt = NULL;
11286	for (int i = 0; i < 2; i++)
11287	{
11288	switches_debug_check[i] = NULL;
11289	n_switches_debug_check[i] = 0;
11290	n_switches_alloc_debug_check[i] = 0;
11291	debug_check_temp_file[i] = NULL;
11292	}
11293
11294	XDELETEVEC (infiles);
11295	infiles = NULL;
11296	n_infiles = 0;
11297	n_infiles_alloc = 0;
11298
11299	combine_inputs = false;
11300	added_libraries = 0;
11301	XDELETEVEC (outfiles);
11302	outfiles = NULL;
11303	spec_lang = 0;
11304	last_language_n_infiles = 0;
11305	gcc_input_filename = NULL;
11306	input_file_number = 0;
11307	input_filename_length = 0;
11308	basename_length = 0;
11309	suffixed_basename_length = 0;
11310	input_basename = NULL;
11311	input_suffix = NULL;
11312	/* We don't need to purge "input_stat", just to unset "input_stat_set". */
11313	input_stat_set = 0;
11314	input_file_compiler = NULL;
11315	arg_going = 0;
11316	delete_this_arg = 0;
11317	this_is_output_file = 0;
11318	this_is_library_file = 0;
11319	this_is_linker_script = 0;
11320	input_from_pipe = 0;
11321	suffix_subst = NULL;
11322
11323	mdswitches = NULL;
11324	n_mdswitches = 0;
11325
11326	used_arg.finalize ();
11327	}
11328
11329	/* PR jit/64810.
11330	Targets can provide configure-time default options in
11331	OPTION_DEFAULT_SPECS. The jit needs to access these, but
11332	they are expressed in the spec language.
11333
11334	Run just enough of the driver to be able to expand these
11335	specs, and then call the callback CB on each
11336	such option. The options strings are *without* a leading
11337	'-' character e.g. ("march=x86-64"). Finally, clean up. */
11338
11339	void
11340	driver_get_configure_time_options (void (*cb) (const char *option,
11341	void *user_data),
11342	void *user_data)
11343	{
11344	size_t i;
11345
11346	obstack_init (&obstack);
11347	init_opts_obstack ();
11348	n_switches = 0;
11349
11350	for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
11351	do_option_spec (name: option_default_specs[i].name,
11352	spec: option_default_specs[i].spec);
11353
11354	for (i = 0; (int) i < n_switches; i++)
11355	{
11356	gcc_assert (switches[i].part1);
11357	(*cb) (switches[i].part1, user_data);
11358	}
11359
11360	obstack_free (&opts_obstack, NULL);
11361	obstack_free (&obstack, NULL);
11362	n_switches = 0;
11363	}
11364