1	/* Compiler driver program that can handle many languages.
2	Copyright (C) 1987-2024 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	/* True if -r, -shared, -pie, or -no-pie were specified on the command
306	line. */
307	static bool any_link_options_p;
308
309	/* True if -static was specified on the command line. */
310	static bool static_p;
311
312	/* Basename of dump and aux outputs, computed from dumpbase (given or
313	derived from output name), to override input_basename in non-%w %b
314	et al. */
315	static char *outbase;
316	static size_t outbase_length = 0;
317
318	/* The compiler version. */
319
320	static const char *compiler_version;
321
322	/* The target version. */
323
324	static const char *const spec_version = DEFAULT_TARGET_VERSION;
325
326	/* The target machine. */
327
328	static const char *spec_machine = DEFAULT_TARGET_MACHINE;
329	static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
330
331	/* List of offload targets. Separated by colon. Empty string for
332	-foffload=disable. */
333
334	static char *offload_targets = NULL;
335
336	#if OFFLOAD_DEFAULTED
337	/* Set to true if -foffload has not been used and offload_targets
338	is set to the configured in default. */
339	static bool offload_targets_default;
340	#endif
341
342	/* Nonzero if cross-compiling.
343	When -b is used, the value comes from the `specs' file. */
344
345	#ifdef CROSS_DIRECTORY_STRUCTURE
346	static const char *cross_compile = "1";
347	#else
348	static const char *cross_compile = "0";
349	#endif
350
351	/* Greatest exit code of sub-processes that has been encountered up to
352	now. */
353	static int greatest_status = 1;
354
355	/* This is the obstack which we use to allocate many strings. */
356
357	static struct obstack obstack;
358
359	/* This is the obstack to build an environment variable to pass to
360	collect2 that describes all of the relevant switches of what to
361	pass the compiler in building the list of pointers to constructors
362	and destructors. */
363
364	static struct obstack collect_obstack;
365
366	/* Forward declaration for prototypes. */
367	struct path_prefix;
368	struct prefix_list;
369
370	static void init_spec (void);
371	static void store_arg (const char *, int, int);
372	static void insert_wrapper (const char *);
373	static char *load_specs (const char *);
374	static void read_specs (const char *, bool, bool);
375	static void set_spec (const char *, const char *, bool);
376	static struct compiler *lookup_compiler (const char *, size_t, const char *);
377	static char *build_search_list (const struct path_prefix *, const char *,
378	bool, bool);
379	static void xputenv (const char *);
380	static void putenv_from_prefixes (const struct path_prefix *, const char *,
381	bool);
382	static int access_check (const char *, int);
383	static char *find_a_file (const struct path_prefix *, const char *, int, bool);
384	static char *find_a_program (const char *);
385	static void add_prefix (struct path_prefix *, const char *, const char *,
386	int, int, int);
387	static void add_sysrooted_prefix (struct path_prefix *, const char *,
388	const char *, int, int, int);
389	static char *skip_whitespace (char *);
390	static void delete_if_ordinary (const char *);
391	static void delete_temp_files (void);
392	static void delete_failure_queue (void);
393	static void clear_failure_queue (void);
394	static int check_live_switch (int, int);
395	static const char *handle_braces (const char *);
396	static inline bool input_suffix_matches (const char *, const char *);
397	static inline bool switch_matches (const char *, const char *, int);
398	static inline void mark_matching_switches (const char *, const char *, int);
399	static inline void process_marked_switches (void);
400	static const char *process_brace_body (const char *, const char *, const char *, int, int);
401	static const struct spec_function *lookup_spec_function (const char *);
402	static const char *eval_spec_function (const char *, const char *, const char *);
403	static const char *handle_spec_function (const char *, bool *, const char *);
404	static char *save_string (const char *, int);
405	static void set_collect_gcc_options (void);
406	static int do_spec_1 (const char *, int, const char *);
407	static int do_spec_2 (const char *, const char *);
408	static void do_option_spec (const char *, const char *);
409	static void do_self_spec (const char *);
410	static const char *find_file (const char *);
411	static int is_directory (const char *, bool);
412	static const char *validate_switches (const char *, bool, bool);
413	static void validate_all_switches (void);
414	static inline void validate_switches_from_spec (const char *, bool);
415	static void give_switch (int, int);
416	static int default_arg (const char *, int);
417	static void set_multilib_dir (void);
418	static void print_multilib_info (void);
419	static void display_help (void);
420	static void add_preprocessor_option (const char *, int);
421	static void add_assembler_option (const char *, int);
422	static void add_linker_option (const char *, int);
423	static void process_command (unsigned int, struct cl_decoded_option *);
424	static int execute (void);
425	static void alloc_args (void);
426	static void clear_args (void);
427	static void fatal_signal (int);
428	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
429	static void init_gcc_specs (struct obstack *, const char *, const char *,
430	const char *);
431	#endif
432	#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
433	static const char *convert_filename (const char *, int, int);
434	#endif
435
436	static void try_generate_repro (const char **argv);
437	static const char *getenv_spec_function (int, const char **);
438	static const char *if_exists_spec_function (int, const char **);
439	static const char *if_exists_else_spec_function (int, const char **);
440	static const char *if_exists_then_else_spec_function (int, const char **);
441	static const char *sanitize_spec_function (int, const char **);
442	static const char *replace_outfile_spec_function (int, const char **);
443	static const char *remove_outfile_spec_function (int, const char **);
444	static const char *version_compare_spec_function (int, const char **);
445	static const char *include_spec_function (int, const char **);
446	static const char *find_file_spec_function (int, const char **);
447	static const char *find_plugindir_spec_function (int, const char **);
448	static const char *print_asm_header_spec_function (int, const char **);
449	static const char *compare_debug_dump_opt_spec_function (int, const char **);
450	static const char *compare_debug_self_opt_spec_function (int, const char **);
451	static const char *pass_through_libs_spec_func (int, const char **);
452	static const char *dumps_spec_func (int, const char **);
453	static const char *greater_than_spec_func (int, const char **);
454	static const char *debug_level_greater_than_spec_func (int, const char **);
455	static const char *dwarf_version_greater_than_spec_func (int, const char **);
456	static const char *find_fortran_preinclude_file (int, const char **);
457	static const char *join_spec_func (int, const char **);
458	static char *convert_white_space (char *);
459	static char *quote_spec (char *);
460	static char *quote_spec_arg (char *);
461	static bool not_actual_file_p (const char *);
462
463
464	/* The Specs Language
465
466	Specs are strings containing lines, each of which (if not blank)
467	is made up of a program name, and arguments separated by spaces.
468	The program name must be exact and start from root, since no path
469	is searched and it is unreliable to depend on the current working directory.
470	Redirection of input or output is not supported; the subprograms must
471	accept filenames saying what files to read and write.
472
473	In addition, the specs can contain %-sequences to substitute variable text
474	or for conditional text. Here is a table of all defined %-sequences.
475	Note that spaces are not generated automatically around the results of
476	expanding these sequences; therefore, you can concatenate them together
477	or with constant text in a single argument.
478
479	%% substitute one % into the program name or argument.
480	%" substitute an empty argument.
481	%i substitute the name of the input file being processed.
482	%b substitute the basename for outputs related with the input file
483	being processed. This is often a substring of the input file name,
484	up to (and not including) the last period but, unless %w is active,
485	it is affected by the directory selected by -save-temps=*, by
486	-dumpdir, and, in case of multiple compilations, even by -dumpbase
487	and -dumpbase-ext and, in case of linking, by the linker output
488	name. When %w is active, it derives the main output name only from
489	the input file base name; when it is not, it names aux/dump output
490	file.
491	%B same as %b, but include the input file suffix (text after the last
492	period).
493	%gSUFFIX
494	substitute a file name that has suffix SUFFIX and is chosen
495	once per compilation, and mark the argument a la %d. To reduce
496	exposure to denial-of-service attacks, the file name is now
497	chosen in a way that is hard to predict even when previously
498	chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
499	might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
500	the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
501	had been pre-processed. Previously, %g was simply substituted
502	with a file name chosen once per compilation, without regard
503	to any appended suffix (which was therefore treated just like
504	ordinary text), making such attacks more likely to succeed.
505	%|SUFFIX
506	like %g, but if -pipe is in effect, expands simply to "-".
507	%mSUFFIX
508	like %g, but if -pipe is in effect, expands to nothing. (We have both
509	%| and %m to accommodate differences between system assemblers; see
510	the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
511	%uSUFFIX
512	like %g, but generates a new temporary file name even if %uSUFFIX
513	was already seen.
514	%USUFFIX
515	substitutes the last file name generated with %uSUFFIX, generating a
516	new one if there is no such last file name. In the absence of any
517	%uSUFFIX, this is just like %gSUFFIX, except they don't share
518	the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
519	would involve the generation of two distinct file names, one
520	for each `%g.s' and another for each `%U.s'. Previously, %U was
521	simply substituted with a file name chosen for the previous %u,
522	without regard to any appended suffix.
523	%jSUFFIX
524	substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
525	writable, and if save-temps is off; otherwise, substitute the name
526	of a temporary file, just like %u. This temporary file is not
527	meant for communication between processes, but rather as a junk
528	disposal mechanism.
529	%.SUFFIX
530	substitutes .SUFFIX for the suffixes of a matched switch's args when
531	it is subsequently output with %*. SUFFIX is terminated by the next
532	space or %.
533	%d marks the argument containing or following the %d as a
534	temporary file name, so that file will be deleted if GCC exits
535	successfully. Unlike %g, this contributes no text to the argument.
536	%w marks the argument containing or following the %w as the
537	"output file" of this compilation. This puts the argument
538	into the sequence of arguments that %o will substitute later.
539	%V indicates that this compilation produces no "output file".
540	%W{...}
541	like %{...} but marks the last argument supplied within as a file
542	to be deleted on failure.
543	%@{...}
544	like %{...} but puts the result into a FILE and substitutes @FILE
545	if an @file argument has been supplied.
546	%o substitutes the names of all the output files, with spaces
547	automatically placed around them. You should write spaces
548	around the %o as well or the results are undefined.
549	%o is for use in the specs for running the linker.
550	Input files whose names have no recognized suffix are not compiled
551	at all, but they are included among the output files, so they will
552	be linked.
553	%O substitutes the suffix for object files. Note that this is
554	handled specially when it immediately follows %g, %u, or %U
555	(with or without a suffix argument) because of the need for
556	those to form complete file names. The handling is such that
557	%O is treated exactly as if it had already been substituted,
558	except that %g, %u, and %U do not currently support additional
559	SUFFIX characters following %O as they would following, for
560	example, `.o'.
561	%I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
562	(made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
563	and -B options) and -imultilib as necessary.
564	%s current argument is the name of a library or startup file of some sort.
565	Search for that file in a standard list of directories
566	and substitute the full name found.
567	%T current argument is the name of a linker script.
568	Search for that file in the current list of directories to scan for
569	libraries. If the file is located, insert a --script option into the
570	command line followed by the full path name found. If the file is
571	not found then generate an error message.
572	Note: the current working directory is not searched.
573	%eSTR Print STR as an error message. STR is terminated by a newline.
574	Use this when inconsistent options are detected.
575	%nSTR Print STR as a notice. STR is terminated by a newline.
576	%x{OPTION} Accumulate an option for %X.
577	%X Output the accumulated linker options specified by compilations.
578	%Y Output the accumulated assembler options specified by compilations.
579	%Z Output the accumulated preprocessor options specified by compilations.
580	%a process ASM_SPEC as a spec.
581	This allows config.h to specify part of the spec for running as.
582	%A process ASM_FINAL_SPEC as a spec. A capital A is actually
583	used here. This can be used to run a post-processor after the
584	assembler has done its job.
585	%D Dump out a -L option for each directory in startfile_prefixes.
586	If multilib_dir is set, extra entries are generated with it affixed.
587	%l process LINK_SPEC as a spec.
588	%L process LIB_SPEC as a spec.
589	%M Output multilib_os_dir.
590	%P Output a RUNPATH_OPTION for each directory in startfile_prefixes.
591	%G process LIBGCC_SPEC as a spec.
592	%R Output the concatenation of target_system_root and
593	target_sysroot_suffix.
594	%S process STARTFILE_SPEC as a spec. A capital S is actually used here.
595	%E process ENDFILE_SPEC as a spec. A capital E is actually used here.
596	%C process CPP_SPEC as a spec.
597	%1 process CC1_SPEC as a spec.
598	%2 process CC1PLUS_SPEC as a spec.
599	%* substitute the variable part of a matched option. (See below.)
600	Note that each comma in the substituted string is replaced by
601	a single space. A space is appended after the last substition
602	unless there is more text in current sequence.
603	%<S remove all occurrences of -S from the command line.
604	Note - this command is position dependent. % commands in the
605	spec string before this one will see -S, % commands in the
606	spec string after this one will not.
607	%>S Similar to "%<S", but keep it in the GCC command line.
608	%<S* remove all occurrences of all switches beginning with -S from the
609	command line.
610	%:function(args)
611	Call the named function FUNCTION, passing it ARGS. ARGS is
612	first processed as a nested spec string, then split into an
613	argument vector in the usual fashion. The function returns
614	a string which is processed as if it had appeared literally
615	as part of the current spec.
616	%{S} substitutes the -S switch, if that switch was given to GCC.
617	If that switch was not specified, this substitutes nothing.
618	Here S is a metasyntactic variable.
619	%{S*} substitutes all the switches specified to GCC whose names start
620	with -S. This is used for -o, -I, etc; switches that take
621	arguments. GCC considers `-o foo' as being one switch whose
622	name starts with `o'. %{o*} would substitute this text,
623	including the space; thus, two arguments would be generated.
624	%{S*&T*} likewise, but preserve order of S and T options (the order
625	of S and T in the spec is not significant). Can be any number
626	of ampersand-separated variables; for each the wild card is
627	optional. Useful for CPP as %{D*&U*&A*}.
628
629	%{S:X} substitutes X, if the -S switch was given to GCC.
630	%{!S:X} substitutes X, if the -S switch was NOT given to GCC.
631	%{S*:X} substitutes X if one or more switches whose names start
632	with -S was given to GCC. Normally X is substituted only
633	once, no matter how many such switches appeared. However,
634	if %* appears somewhere in X, then X will be substituted
635	once for each matching switch, with the %* replaced by the
636	part of that switch that matched the '*'. A space will be
637	appended after the last substition unless there is more
638	text in current sequence.
639	%{.S:X} substitutes X, if processing a file with suffix S.
640	%{!.S:X} substitutes X, if NOT processing a file with suffix S.
641	%{,S:X} substitutes X, if processing a file which will use spec S.
642	%{!,S:X} substitutes X, if NOT processing a file which will use spec S.
643
644	%{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
645	combined with '!', '.', ',', and '*' as above binding stronger
646	than the OR.
647	If %* appears in X, all of the alternatives must be starred, and
648	only the first matching alternative is substituted.
649	%{%:function(args):X}
650	Call function named FUNCTION with args ARGS. If the function
651	returns non-NULL, then X is substituted, if it returns
652	NULL, it isn't substituted.
653	%{S:X; if S was given to GCC, substitutes X;
654	T:Y; else if T was given to GCC, substitutes Y;
655	:D} else substitutes D. There can be as many clauses as you need.
656	This may be combined with '.', '!', ',', '|', and '*' as above.
657
658	%(Spec) processes a specification defined in a specs file as *Spec:
659
660	The switch matching text S in a %{S}, %{S:X}, or similar construct can use
661	a backslash to ignore the special meaning of the character following it,
662	thus allowing literal matching of a character that is otherwise specially
663	treated. For example, %{std=iso9899\:1999:X} substitutes X if the
664	-std=iso9899:1999 option is given.
665
666	The conditional text X in a %{S:X} or similar construct may contain
667	other nested % constructs or spaces, or even newlines. They are
668	processed as usual, as described above. Trailing white space in X is
669	ignored. White space may also appear anywhere on the left side of the
670	colon in these constructs, except between . or * and the corresponding
671	word.
672
673	The -O, -f, -g, -m, and -W switches are handled specifically in these
674	constructs. If another value of -O or the negated form of a -f, -m, or
675	-W switch is found later in the command line, the earlier switch
676	value is ignored, except with {S*} where S is just one letter; this
677	passes all matching options.
678
679	The character | at the beginning of the predicate text is used to indicate
680	that a command should be piped to the following command, but only if -pipe
681	is specified.
682
683	Note that it is built into GCC which switches take arguments and which
684	do not. You might think it would be useful to generalize this to
685	allow each compiler's spec to say which switches take arguments. But
686	this cannot be done in a consistent fashion. GCC cannot even decide
687	which input files have been specified without knowing which switches
688	take arguments, and it must know which input files to compile in order
689	to tell which compilers to run.
690
691	GCC also knows implicitly that arguments starting in `-l' are to be
692	treated as compiler output files, and passed to the linker in their
693	proper position among the other output files. */
694
695	/* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
696
697	/* config.h can define ASM_SPEC to provide extra args to the assembler
698	or extra switch-translations. */
699	#ifndef ASM_SPEC
700	#define ASM_SPEC ""
701	#endif
702
703	/* config.h can define ASM_FINAL_SPEC to run a post processor after
704	the assembler has run. */
705	#ifndef ASM_FINAL_SPEC
706	#define ASM_FINAL_SPEC \
707	"%{gsplit-dwarf: \n\
708	objcopy --extract-dwo \
709	%{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
710	%b.dwo \n\
711	objcopy --strip-dwo \
712	%{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
713	}"
714	#endif
715
716	/* config.h can define CPP_SPEC to provide extra args to the C preprocessor
717	or extra switch-translations. */
718	#ifndef CPP_SPEC
719	#define CPP_SPEC ""
720	#endif
721
722	/* Operating systems can define OS_CC1_SPEC to provide extra args to cc1 and
723	cc1plus or extra switch-translations. The OS_CC1_SPEC is appended
724	to CC1_SPEC in the initialization of cc1_spec. */
725	#ifndef OS_CC1_SPEC
726	#define OS_CC1_SPEC ""
727	#endif
728
729	/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
730	or extra switch-translations. */
731	#ifndef CC1_SPEC
732	#define CC1_SPEC ""
733	#endif
734
735	/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
736	or extra switch-translations. */
737	#ifndef CC1PLUS_SPEC
738	#define CC1PLUS_SPEC ""
739	#endif
740
741	/* config.h can define LINK_SPEC to provide extra args to the linker
742	or extra switch-translations. */
743	#ifndef LINK_SPEC
744	#define LINK_SPEC ""
745	#endif
746
747	/* config.h can define LIB_SPEC to override the default libraries. */
748	#ifndef LIB_SPEC
749	#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
750	#endif
751
752	/* When using -fsplit-stack we need to wrap pthread_create, in order
753	to initialize the stack guard. We always use wrapping, rather than
754	shared library ordering, and we keep the wrapper function in
755	libgcc. This is not yet a real spec, though it could become one;
756	it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
757	only works with GNU ld and gold. */
758	#ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
759	#define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
760	#else
761	#define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
762	#endif
763
764	#ifndef LIBASAN_SPEC
765	#define STATIC_LIBASAN_LIBS \
766	" %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
767	#ifdef LIBASAN_EARLY_SPEC
768	#define LIBASAN_SPEC STATIC_LIBASAN_LIBS
769	#elif defined(HAVE_LD_STATIC_DYNAMIC)
770	#define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
771	"} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
772	STATIC_LIBASAN_LIBS
773	#else
774	#define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
775	#endif
776	#endif
777
778	#ifndef LIBASAN_EARLY_SPEC
779	#define LIBASAN_EARLY_SPEC ""
780	#endif
781
782	#ifndef LIBHWASAN_SPEC
783	#define STATIC_LIBHWASAN_LIBS \
784	" %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
785	#ifdef LIBHWASAN_EARLY_SPEC
786	#define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
787	#elif defined(HAVE_LD_STATIC_DYNAMIC)
788	#define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
789	"} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
790	STATIC_LIBHWASAN_LIBS
791	#else
792	#define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
793	#endif
794	#endif
795
796	#ifndef LIBHWASAN_EARLY_SPEC
797	#define LIBHWASAN_EARLY_SPEC ""
798	#endif
799
800	#ifndef LIBTSAN_SPEC
801	#define STATIC_LIBTSAN_LIBS \
802	" %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
803	#ifdef LIBTSAN_EARLY_SPEC
804	#define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
805	#elif defined(HAVE_LD_STATIC_DYNAMIC)
806	#define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
807	"} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
808	STATIC_LIBTSAN_LIBS
809	#else
810	#define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
811	#endif
812	#endif
813
814	#ifndef LIBTSAN_EARLY_SPEC
815	#define LIBTSAN_EARLY_SPEC ""
816	#endif
817
818	#ifndef LIBLSAN_SPEC
819	#define STATIC_LIBLSAN_LIBS \
820	" %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
821	#ifdef LIBLSAN_EARLY_SPEC
822	#define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
823	#elif defined(HAVE_LD_STATIC_DYNAMIC)
824	#define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
825	"} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
826	STATIC_LIBLSAN_LIBS
827	#else
828	#define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
829	#endif
830	#endif
831
832	#ifndef LIBLSAN_EARLY_SPEC
833	#define LIBLSAN_EARLY_SPEC ""
834	#endif
835
836	#ifndef LIBUBSAN_SPEC
837	#define STATIC_LIBUBSAN_LIBS \
838	" %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
839	#ifdef HAVE_LD_STATIC_DYNAMIC
840	#define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
841	"} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
842	STATIC_LIBUBSAN_LIBS
843	#else
844	#define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
845	#endif
846	#endif
847
848	/* Linker options for compressed debug sections. */
849	#if HAVE_LD_COMPRESS_DEBUG == 0
850	/* No linker support. */
851	#define LINK_COMPRESS_DEBUG_SPEC \
852	" %{gz*:%e-gz is not supported in this configuration} "
853	#elif HAVE_LD_COMPRESS_DEBUG == 1
854	/* ELF gABI style. */
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:%e-gz=zstd is not supported in this configuration} " \
859	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
860	#elif HAVE_LD_COMPRESS_DEBUG == 2
861	/* ELF gABI style and ZSTD. */
862	#define LINK_COMPRESS_DEBUG_SPEC \
863	" %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
864	" %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
865	" %{gz=zstd:" LD_COMPRESS_DEBUG_OPTION "=zstd}" \
866	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
867	#else
868	#error Unknown value for HAVE_LD_COMPRESS_DEBUG.
869	#endif
870
871	/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
872	included. */
873	#ifndef LIBGCC_SPEC
874	#if defined(REAL_LIBGCC_SPEC)
875	#define LIBGCC_SPEC REAL_LIBGCC_SPEC
876	#elif defined(LINK_LIBGCC_SPECIAL_1)
877	/* Have gcc do the search for libgcc.a. */
878	#define LIBGCC_SPEC "libgcc.a%s"
879	#else
880	#define LIBGCC_SPEC "-lgcc"
881	#endif
882	#endif
883
884	/* config.h can define STARTFILE_SPEC to override the default crt0 files. */
885	#ifndef STARTFILE_SPEC
886	#define STARTFILE_SPEC \
887	"%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
888	#endif
889
890	/* config.h can define ENDFILE_SPEC to override the default crtn files. */
891	#ifndef ENDFILE_SPEC
892	#define ENDFILE_SPEC ""
893	#endif
894
895	#ifndef LINKER_NAME
896	#define LINKER_NAME "collect2"
897	#endif
898
899	#ifdef HAVE_AS_DEBUG_PREFIX_MAP
900	#define ASM_MAP " %{ffile-prefix-map=*:--debug-prefix-map %*} %{fdebug-prefix-map=*:--debug-prefix-map %*}"
901	#else
902	#define ASM_MAP ""
903	#endif
904
905	/* Assembler options for compressed debug sections. */
906	#if HAVE_LD_COMPRESS_DEBUG == 0
907	/* Reject if the linker cannot write compressed debug sections. */
908	#define ASM_COMPRESS_DEBUG_SPEC \
909	" %{gz*:%e-gz is not supported in this configuration} "
910	#else /* HAVE_LD_COMPRESS_DEBUG >= 1 */
911	#if HAVE_AS_COMPRESS_DEBUG == 0
912	/* No assembler support. Ignore silently. */
913	#define ASM_COMPRESS_DEBUG_SPEC \
914	" %{gz*:} "
915	#elif HAVE_AS_COMPRESS_DEBUG == 1
916	/* ELF gABI style. */
917	#define ASM_COMPRESS_DEBUG_SPEC \
918	" %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
919	" %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
920	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
921	#elif HAVE_AS_COMPRESS_DEBUG == 2
922	/* ELF gABI style and ZSTD. */
923	#define ASM_COMPRESS_DEBUG_SPEC \
924	" %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
925	" %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
926	" %{gz=zstd:" AS_COMPRESS_DEBUG_OPTION "=zstd}" \
927	" %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
928	#else
929	#error Unknown value for HAVE_AS_COMPRESS_DEBUG.
930	#endif
931	#endif /* HAVE_LD_COMPRESS_DEBUG >= 1 */
932
933	/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
934	to the assembler, when compiling assembly sources only. */
935	#ifndef ASM_DEBUG_SPEC
936	# if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
937	/* If --gdwarf-N is supported and as can handle even compiler generated
938	.debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
939	than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
940	compilations. */
941	# define ASM_DEBUG_DWARF_OPTION ""
942	# elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
943	# define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
944	"%:dwarf-version-gt(3):--gdwarf-4;" \
945	"%:dwarf-version-gt(2):--gdwarf-3;" \
946	":--gdwarf2}"
947	# else
948	# define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
949	# endif
950	# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
951	# define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
952	ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
953	# endif
954	# endif
955	#ifndef ASM_DEBUG_SPEC
956	# define ASM_DEBUG_SPEC ""
957	#endif
958
959	/* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
960	to the assembler when compiling all sources. */
961	#ifndef ASM_DEBUG_OPTION_SPEC
962	# if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
963	# define ASM_DEBUG_OPTION_DWARF_OPT \
964	"%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
965	"%:dwarf-version-gt(3):--gdwarf-4 ;" \
966	"%:dwarf-version-gt(2):--gdwarf-3 ;" \
967	":--gdwarf2 }"
968	# if defined(DWARF2_DEBUGGING_INFO)
969	# define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
970	ASM_DEBUG_OPTION_DWARF_OPT "}}"
971	# endif
972	# endif
973	#endif
974	#ifndef ASM_DEBUG_OPTION_SPEC
975	# define ASM_DEBUG_OPTION_SPEC ""
976	#endif
977
978	/* Here is the spec for running the linker, after compiling all files. */
979
980	/* This is overridable by the target in case they need to specify the
981	-lgcc and -lc order specially, yet not require them to override all
982	of LINK_COMMAND_SPEC. */
983	#ifndef LINK_GCC_C_SEQUENCE_SPEC
984	#define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
985	#endif
986
987	#ifndef LINK_SSP_SPEC
988	#ifdef TARGET_LIBC_PROVIDES_SSP
989	#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
990	"|fstack-protector-strong|fstack-protector-explicit:}"
991	#else
992	#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
993	"|fstack-protector-strong|fstack-protector-explicit" \
994	":-lssp_nonshared -lssp}"
995	#endif
996	#endif
997
998	#ifdef ENABLE_DEFAULT_PIE
999	#define PIE_SPEC "!no-pie"
1000	#define NO_FPIE1_SPEC "fno-pie"
1001	#define FPIE1_SPEC NO_FPIE1_SPEC ":;"
1002	#define NO_FPIE2_SPEC "fno-PIE"
1003	#define FPIE2_SPEC NO_FPIE2_SPEC ":;"
1004	#define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
1005	#define FPIE_SPEC NO_FPIE_SPEC ":;"
1006	#define NO_FPIC1_SPEC "fno-pic"
1007	#define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1008	#define NO_FPIC2_SPEC "fno-PIC"
1009	#define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1010	#define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1011	#define FPIC_SPEC NO_FPIC_SPEC ":;"
1012	#define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1013	#define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1014	#define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1015	#define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1016	#define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1017	#define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1018	#else
1019	#define PIE_SPEC "pie"
1020	#define FPIE1_SPEC "fpie"
1021	#define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1022	#define FPIE2_SPEC "fPIE"
1023	#define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1024	#define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1025	#define NO_FPIE_SPEC FPIE_SPEC ":;"
1026	#define FPIC1_SPEC "fpic"
1027	#define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1028	#define FPIC2_SPEC "fPIC"
1029	#define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1030	#define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1031	#define NO_FPIC_SPEC FPIC_SPEC ":;"
1032	#define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1033	#define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1034	#define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1035	#define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1036	#define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1037	#define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1038	#endif
1039
1040	#ifndef LINK_PIE_SPEC
1041	#ifdef HAVE_LD_PIE
1042	#ifndef LD_PIE_SPEC
1043	#define LD_PIE_SPEC "-pie"
1044	#endif
1045	#else
1046	#define LD_PIE_SPEC ""
1047	#endif
1048	#define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1049	#endif
1050
1051	#ifndef LINK_BUILDID_SPEC
1052	# if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1053	# define LINK_BUILDID_SPEC "%{!r:--build-id} "
1054	# endif
1055	#endif
1056
1057	#ifndef LTO_PLUGIN_SPEC
1058	#define LTO_PLUGIN_SPEC ""
1059	#endif
1060
1061	/* Conditional to test whether the LTO plugin is used or not.
1062	FIXME: For slim LTO we will need to enable plugin unconditionally. This
1063	still cause problems with PLUGIN_LD != LD and when plugin is built but
1064	not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1065	plugin only when LTO is enabled. We still honor explicit
1066	-fuse-linker-plugin if the linker used understands -plugin. */
1067
1068	/* The linker has some plugin support. */
1069	#if HAVE_LTO_PLUGIN > 0
1070	/* The linker used has full plugin support, use LTO plugin by default. */
1071	#if HAVE_LTO_PLUGIN == 2
1072	#define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1073	#define PLUGIN_COND_CLOSE "}"
1074	#else
1075	/* The linker used has limited plugin support, use LTO plugin with explicit
1076	-fuse-linker-plugin. */
1077	#define PLUGIN_COND "fuse-linker-plugin"
1078	#define PLUGIN_COND_CLOSE ""
1079	#endif
1080	#define LINK_PLUGIN_SPEC \
1081	"%{" PLUGIN_COND": \
1082	-plugin %(linker_plugin_file) \
1083	-plugin-opt=%(lto_wrapper) \
1084	-plugin-opt=-fresolution=%u.res \
1085	" LTO_PLUGIN_SPEC "\
1086	%{flinker-output=*:-plugin-opt=-linker-output-known} \
1087	%{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1088	}" PLUGIN_COND_CLOSE
1089	#else
1090	/* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1091	#define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1092	%e-fuse-linker-plugin is not supported in this configuration}"
1093	#endif
1094
1095	/* Linker command line options for -fsanitize= early on the command line. */
1096	#ifndef SANITIZER_EARLY_SPEC
1097	#define SANITIZER_EARLY_SPEC "\
1098	%{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1099	%{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1100	%{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1101	%{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1102	#endif
1103
1104	/* Linker command line options for -fsanitize= late on the command line. */
1105	#ifndef SANITIZER_SPEC
1106	#define SANITIZER_SPEC "\
1107	%{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1108	%{static:%ecannot specify -static with -fsanitize=address}}\
1109	%{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1110	%{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1111	%{%:sanitize(thread):" LIBTSAN_SPEC "\
1112	%{static:%ecannot specify -static with -fsanitize=thread}}\
1113	%{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1114	%{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1115	#endif
1116
1117	#ifndef POST_LINK_SPEC
1118	#define POST_LINK_SPEC ""
1119	#endif
1120
1121	/* This is the spec to use, once the code for creating the vtable
1122	verification runtime library, libvtv.so, has been created. Currently
1123	the vtable verification runtime functions are in libstdc++, so we use
1124	the spec just below this one. */
1125	#ifndef VTABLE_VERIFICATION_SPEC
1126	#if ENABLE_VTABLE_VERIFY
1127	#define VTABLE_VERIFICATION_SPEC "\
1128	%{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1129	%{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1130	#else
1131	#define VTABLE_VERIFICATION_SPEC "\
1132	%{fvtable-verify=none:} \
1133	%{fvtable-verify=std: \
1134	%e-fvtable-verify=std is not supported in this configuration} \
1135	%{fvtable-verify=preinit: \
1136	%e-fvtable-verify=preinit is not supported in this configuration}"
1137	#endif
1138	#endif
1139
1140	/* -u* was put back because both BSD and SysV seem to support it. */
1141	/* %{static|no-pie|static-pie:} simply prevents an error message:
1142	1. If the target machine doesn't handle -static.
1143	2. If PIE isn't enabled by default.
1144	3. If the target machine doesn't handle -static-pie.
1145	*/
1146	/* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1147	scripts which exist in user specified directories, or in standard
1148	directories. */
1149	/* We pass any -flto flags on to the linker, which is expected
1150	to understand them. In practice, this means it had better be collect2. */
1151	/* %{e*} includes -export-dynamic; see comment in common.opt. */
1152	#ifndef LINK_COMMAND_SPEC
1153	#define LINK_COMMAND_SPEC "\
1154	%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1155	%(linker) " \
1156	LINK_PLUGIN_SPEC \
1157	"%{flto|flto=*:%<fcompare-debug*} \
1158	%{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1159	"%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1160	"%X %{o*} %{e*} %{N} %{n} %{r}\
1161	%{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1162	%{static|no-pie|static-pie:} %@{L*} %(link_libgcc) " \
1163	VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1164	%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1165	%:include(libgomp.spec)%(link_gomp)}\
1166	%{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1167	" STACK_SPLIT_SPEC "\
1168	%{fprofile-arcs|fcondition-coverage|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1169	%{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1170	%{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1171	#endif
1172
1173	#ifndef LINK_LIBGCC_SPEC
1174	/* Generate -L options for startfile prefix list. */
1175	# define LINK_LIBGCC_SPEC "%D"
1176	#endif
1177
1178	#ifndef STARTFILE_PREFIX_SPEC
1179	# define STARTFILE_PREFIX_SPEC ""
1180	#endif
1181
1182	#ifndef SYSROOT_SPEC
1183	# define SYSROOT_SPEC "--sysroot=%R"
1184	#endif
1185
1186	#ifndef SYSROOT_SUFFIX_SPEC
1187	# define SYSROOT_SUFFIX_SPEC ""
1188	#endif
1189
1190	#ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1191	# define SYSROOT_HEADERS_SUFFIX_SPEC ""
1192	#endif
1193
1194	#ifndef RUNPATH_OPTION
1195	# define RUNPATH_OPTION "-rpath"
1196	#endif
1197
1198	static const char *asm_debug = ASM_DEBUG_SPEC;
1199	static const char *asm_debug_option = ASM_DEBUG_OPTION_SPEC;
1200	static const char *cpp_spec = CPP_SPEC;
1201	static const char *cc1_spec = CC1_SPEC OS_CC1_SPEC;
1202	static const char *cc1plus_spec = CC1PLUS_SPEC;
1203	static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
1204	static const char *link_ssp_spec = LINK_SSP_SPEC;
1205	static const char *asm_spec = ASM_SPEC;
1206	static const char *asm_final_spec = ASM_FINAL_SPEC;
1207	static const char *link_spec = LINK_SPEC;
1208	static const char *lib_spec = LIB_SPEC;
1209	static const char *link_gomp_spec = "";
1210	static const char *libgcc_spec = LIBGCC_SPEC;
1211	static const char *endfile_spec = ENDFILE_SPEC;
1212	static const char *startfile_spec = STARTFILE_SPEC;
1213	static const char *linker_name_spec = LINKER_NAME;
1214	static const char *linker_plugin_file_spec = "";
1215	static const char *lto_wrapper_spec = "";
1216	static const char *lto_gcc_spec = "";
1217	static const char *post_link_spec = POST_LINK_SPEC;
1218	static const char *link_command_spec = LINK_COMMAND_SPEC;
1219	static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
1220	static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
1221	static const char *sysroot_spec = SYSROOT_SPEC;
1222	static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
1223	static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
1224	static const char *self_spec = "";
1225
1226	/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1227	There should be no need to override these in target dependent files,
1228	but we need to copy them to the specs file so that newer versions
1229	of the GCC driver can correctly drive older tool chains with the
1230	appropriate -B options. */
1231
1232	/* When cpplib handles traditional preprocessing, get rid of this, and
1233	call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1234	that we default the front end language better. */
1235	static const char *trad_capable_cpp =
1236	"cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1237
1238	/* We don't wrap .d files in %W{} since a missing .d file, and
1239	therefore no dependency entry, confuses make into thinking a .o
1240	file that happens to exist is up-to-date. */
1241	static const char *cpp_unique_options =
1242	"%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1243	%{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1244	%{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1245	%{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1246	%{Mmodules} %{Mno-modules}\
1247	%{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1248	%{remap} %{%:debug-level-gt(2):-dD}\
1249	%{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1250	%{H} %C %{D*&U*&A*} %{i*} %Z %i\
1251	%{E|M|MM:%W{o*}}\
1252	%{fdeps-format=*:%{!fdeps-file=*:-fdeps-file=%:join(%{!o:%b.ddi}%{o*:%.ddi%*})}}\
1253	%{fdeps-format=*:%{!fdeps-target=*:-fdeps-target=%:join(%{!o:%b.o}%{o*:%.o%*})}}";
1254
1255	/* This contains cpp options which are common with cc1_options and are passed
1256	only when preprocessing only to avoid duplication. We pass the cc1 spec
1257	options to the preprocessor so that it the cc1 spec may manipulate
1258	options used to set target flags. Those special target flags settings may
1259	in turn cause preprocessor symbols to be defined specially. */
1260	static const char *cpp_options =
1261	"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1262	%{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1263	%{!fno-working-directory:-fworking-directory}}} %{O*}\
1264	%{undef} %{save-temps*:-fpch-preprocess}";
1265
1266	/* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1267
1268	Make it easy for a language to override the argument for the
1269	%:dumps specs function call. */
1270	#define DUMPS_OPTIONS(EXTS) \
1271	"%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1272
1273	/* This contains cpp options which are not passed when the preprocessor
1274	output will be used by another program. */
1275	static const char *cpp_debug_options = DUMPS_OPTIONS ("");
1276
1277	/* NB: This is shared amongst all front-ends, except for Ada. */
1278	static const char *cc1_options =
1279	"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1280	%{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1281	%1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1282	%{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1283	%{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1284	%{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1285	%{-target-help:--target-help}\
1286	%{-version:--version}\
1287	%{-help=*:--help=%*}\
1288	%{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1289	%{fsyntax-only:-o %j} %{-param*}\
1290	%{coverage:-fprofile-arcs -ftest-coverage}\
1291	%{fprofile-arcs|fcondition-coverage|fprofile-generate*|coverage:\
1292	%{!fprofile-update=single:\
1293	%{pthread:-fprofile-update=prefer-atomic}}}";
1294
1295	static const char *asm_options =
1296	"%{-target-help:%:print-asm-header()} "
1297	#if HAVE_GNU_AS
1298	/* If GNU AS is used, then convert -w (no warnings), -I, and -v
1299	to the assembler equivalents. */
1300	"%{v} %{w:-W} %{I*} "
1301	#endif
1302	"%(asm_debug_option)"
1303	ASM_COMPRESS_DEBUG_SPEC
1304	"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1305
1306	static const char *invoke_as =
1307	#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1308	"%{!fwpa*:\
1309	%{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1310	%{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1311	}";
1312	#else
1313	"%{!fwpa*:\
1314	%{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1315	%{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1316	}";
1317	#endif
1318
1319	/* Some compilers have limits on line lengths, and the multilib_select
1320	and/or multilib_matches strings can be very long, so we build them at
1321	run time. */
1322	static struct obstack multilib_obstack;
1323	static const char *multilib_select;
1324	static const char *multilib_matches;
1325	static const char *multilib_defaults;
1326	static const char *multilib_exclusions;
1327	static const char *multilib_reuse;
1328
1329	/* Check whether a particular argument is a default argument. */
1330
1331	#ifndef MULTILIB_DEFAULTS
1332	#define MULTILIB_DEFAULTS { "" }
1333	#endif
1334
1335	static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
1336
1337	#ifndef DRIVER_SELF_SPECS
1338	#define DRIVER_SELF_SPECS ""
1339	#endif
1340
1341	/* Linking to libgomp implies pthreads. This is particularly important
1342	for targets that use different start files and suchlike. */
1343	#ifndef GOMP_SELF_SPECS
1344	#define GOMP_SELF_SPECS \
1345	"%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1346	"-pthread}"
1347	#endif
1348
1349	/* Likewise for -fgnu-tm. */
1350	#ifndef GTM_SELF_SPECS
1351	#define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1352	#endif
1353
1354	static const char *const driver_self_specs[] = {
1355	"%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1356	DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS,
1357	/* This discards -fmultiflags at the end of self specs processing in the
1358	driver, so that it is effectively Ignored, without actually marking it as
1359	Ignored, which would get it discarded before self specs could remap it. */
1360	"%<fmultiflags"
1361	};
1362
1363	#ifndef OPTION_DEFAULT_SPECS
1364	#define OPTION_DEFAULT_SPECS { "", "" }
1365	#endif
1366
1367	struct default_spec
1368	{
1369	const char *name;
1370	const char *spec;
1371	};
1372
1373	static const struct default_spec
1374	option_default_specs[] = { OPTION_DEFAULT_SPECS };
1375
1376	struct user_specs
1377	{
1378	struct user_specs *next;
1379	const char *filename;
1380	};
1381
1382	static struct user_specs *user_specs_head, *user_specs_tail;
1383
1384
1385	/* Record the mapping from file suffixes for compilation specs. */
1386
1387	struct compiler
1388	{
1389	const char *suffix; /* Use this compiler for input files
1390	whose names end in this suffix. */
1391
1392	const char *spec; /* To use this compiler, run this spec. */
1393
1394	const char *cpp_spec; /* If non-NULL, substitute this spec
1395	for `%C', rather than the usual
1396	cpp_spec. */
1397	int combinable; /* If nonzero, compiler can deal with
1398	multiple source files at once (IMA). */
1399	int needs_preprocessing; /* If nonzero, source files need to
1400	be run through a preprocessor. */
1401	};
1402
1403	/* Pointer to a vector of `struct compiler' that gives the spec for
1404	compiling a file, based on its suffix.
1405	A file that does not end in any of these suffixes will be passed
1406	unchanged to the loader and nothing else will be done to it.
1407
1408	An entry containing two 0s is used to terminate the vector.
1409
1410	If multiple entries match a file, the last matching one is used. */
1411
1412	static struct compiler *compilers;
1413
1414	/* Number of entries in `compilers', not counting the null terminator. */
1415
1416	static int n_compilers;
1417
1418	/* The default list of file name suffixes and their compilation specs. */
1419
1420	static const struct compiler default_compilers[] =
1421	{
1422	/* Add lists of suffixes of known languages here. If those languages
1423	were not present when we built the driver, we will hit these copies
1424	and be given a more meaningful error than "file not used since
1425	linking is not done". */
1426	{.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},
1427	{.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},
1428	{.suffix: ".mii", .spec: "#Objective-C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1429	{.suffix: ".cc", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".cxx", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1430	{.suffix: ".cpp", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".cp", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1431	{.suffix: ".c++", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".C", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1432	{.suffix: ".CPP", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".ii", .spec: "#C++", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1433	{.suffix: ".ads", .spec: "#Ada", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".adb", .spec: "#Ada", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1434	{.suffix: ".f", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".F", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1435	{.suffix: ".for", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".FOR", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1436	{.suffix: ".ftn", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".FTN", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1437	{.suffix: ".fpp", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".FPP", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1438	{.suffix: ".f90", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".F90", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1439	{.suffix: ".f95", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".F95", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1440	{.suffix: ".f03", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".F03", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1441	{.suffix: ".f08", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}, {.suffix: ".F08", .spec: "#Fortran", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1442	{.suffix: ".r", .spec: "#Ratfor", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1443	{.suffix: ".go", .spec: "#Go", .cpp_spec: 0, .combinable: 1, .needs_preprocessing: 0},
1444	{.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},
1445	{.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},
1446	/* Next come the entries for C. */
1447	{.suffix: ".c", .spec: "@c", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 1},
1448	{.suffix: "@c",
1449	/* cc1 has an integrated ISO C preprocessor. We should invoke the
1450	external preprocessor if -save-temps is given. */
1451	.spec: "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1452	%{!E:%{!M:%{!MM:\
1453	%{traditional:\
1454	%eGNU C no longer supports -traditional without -E}\
1455	%{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1456	%(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1457	cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1458	%(cc1_options)}\
1459	%{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1460	cc1 %(cpp_unique_options) %(cc1_options)}}}\
1461	%{!fsyntax-only:%(invoke_as)}}}}", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 1},
1462	{.suffix: "-",
1463	.spec: "%{!E:%e-E or -x required when input is from standard input}\
1464	%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1465	{.suffix: ".h", .spec: "@c-header", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1466	{.suffix: "@c-header",
1467	/* cc1 has an integrated ISO C preprocessor. We should invoke the
1468	external preprocessor if -save-temps is given. */
1469	.spec: "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1470	%{!E:%{!M:%{!MM:\
1471	%{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1472	%(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1473	cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1474	%(cc1_options)\
1475	%{!fsyntax-only:%{!S:-o %g.s} \
1476	%{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1477	%W{o*:--output-pch %w%*}}%{!S:%V}}}\
1478	%{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1479	cc1 %(cpp_unique_options) %(cc1_options)\
1480	%{!fsyntax-only:%{!S:-o %g.s} \
1481	%{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1482	%W{o*:--output-pch %w%*}}%{!S:%V}}}}}}}}", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1483	{.suffix: ".i", .spec: "@cpp-output", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1484	{.suffix: "@cpp-output",
1485	.spec: "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1486	{.suffix: ".s", .spec: "@assembler", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1487	{.suffix: "@assembler",
1488	.spec: "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1489	{.suffix: ".sx", .spec: "@assembler-with-cpp", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1490	{.suffix: ".S", .spec: "@assembler-with-cpp", .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1491	{.suffix: "@assembler-with-cpp",
1492	#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1493	"%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1494	%{E|M|MM:%(cpp_debug_options)}\
1495	%{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1496	as %(asm_debug) %(asm_options) %|.s %A }}}}"
1497	#else
1498	.spec: "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1499	%{E|M|MM:%(cpp_debug_options)}\
1500	%{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1501	as %(asm_debug) %(asm_options) %m.s %A }}}}"
1502	#endif
1503	, .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0},
1504
1505	#include "specs.h"
1506	/* Mark end of table. */
1507	{.suffix: 0, .spec: 0, .cpp_spec: 0, .combinable: 0, .needs_preprocessing: 0}
1508	};
1509
1510	/* Number of elements in default_compilers, not counting the terminator. */
1511
1512	static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1513
1514	typedef char *char_p; /* For DEF_VEC_P. */
1515
1516	/* A vector of options to give to the linker.
1517	These options are accumulated by %x,
1518	and substituted into the linker command with %X. */
1519	static vec<char_p> linker_options;
1520
1521	/* A vector of options to give to the assembler.
1522	These options are accumulated by -Wa,
1523	and substituted into the assembler command with %Y. */
1524	static vec<char_p> assembler_options;
1525
1526	/* A vector of options to give to the preprocessor.
1527	These options are accumulated by -Wp,
1528	and substituted into the preprocessor command with %Z. */
1529	static vec<char_p> preprocessor_options;
1530
1531	static char *
1532	skip_whitespace (char *p)
1533	{
1534	while (1)
1535	{
1536	/* A fully-blank line is a delimiter in the SPEC file and shouldn't
1537	be considered whitespace. */
1538	if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1539	return p + 1;
1540	else if (*p == '\n' || *p == ' ' || *p == '\t')
1541	p++;
1542	else if (*p == '#')
1543	{
1544	while (*p != '\n')
1545	p++;
1546	p++;
1547	}
1548	else
1549	break;
1550	}
1551
1552	return p;
1553	}
1554	/* Structures to keep track of prefixes to try when looking for files. */
1555
1556	struct prefix_list
1557	{
1558	const char *prefix; /* String to prepend to the path. */
1559	struct prefix_list *next; /* Next in linked list. */
1560	int require_machine_suffix; /* Don't use without machine_suffix. */
1561	/* 2 means try both machine_suffix and just_machine_suffix. */
1562	int priority; /* Sort key - priority within list. */
1563	int os_multilib; /* 1 if OS multilib scheme should be used,
1564	0 for GCC multilib scheme. */
1565	};
1566
1567	struct path_prefix
1568	{
1569	struct prefix_list *plist; /* List of prefixes to try */
1570	int max_len; /* Max length of a prefix in PLIST */
1571	const char *name; /* Name of this list (used in config stuff) */
1572	};
1573
1574	/* List of prefixes to try when looking for executables. */
1575
1576	static struct path_prefix exec_prefixes = { .plist: 0, .max_len: 0, .name: "exec" };
1577
1578	/* List of prefixes to try when looking for startup (crt0) files. */
1579
1580	static struct path_prefix startfile_prefixes = { .plist: 0, .max_len: 0, .name: "startfile" };
1581
1582	/* List of prefixes to try when looking for include files. */
1583
1584	static struct path_prefix include_prefixes = { .plist: 0, .max_len: 0, .name: "include" };
1585
1586	/* Suffix to attach to directories searched for commands.
1587	This looks like `MACHINE/VERSION/'. */
1588
1589	static const char *machine_suffix = 0;
1590
1591	/* Suffix to attach to directories searched for commands.
1592	This is just `MACHINE/'. */
1593
1594	static const char *just_machine_suffix = 0;
1595
1596	/* Adjusted value of GCC_EXEC_PREFIX envvar. */
1597
1598	static const char *gcc_exec_prefix;
1599
1600	/* Adjusted value of standard_libexec_prefix. */
1601
1602	static const char *gcc_libexec_prefix;
1603
1604	/* Default prefixes to attach to command names. */
1605
1606	#ifndef STANDARD_STARTFILE_PREFIX_1
1607	#define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1608	#endif
1609	#ifndef STANDARD_STARTFILE_PREFIX_2
1610	#define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1611	#endif
1612
1613	#ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1614	#undef MD_EXEC_PREFIX
1615	#undef MD_STARTFILE_PREFIX
1616	#undef MD_STARTFILE_PREFIX_1
1617	#endif
1618
1619	/* If no prefixes defined, use the null string, which will disable them. */
1620	#ifndef MD_EXEC_PREFIX
1621	#define MD_EXEC_PREFIX ""
1622	#endif
1623	#ifndef MD_STARTFILE_PREFIX
1624	#define MD_STARTFILE_PREFIX ""
1625	#endif
1626	#ifndef MD_STARTFILE_PREFIX_1
1627	#define MD_STARTFILE_PREFIX_1 ""
1628	#endif
1629
1630	/* These directories are locations set at configure-time based on the
1631	--prefix option provided to configure. Their initializers are
1632	defined in Makefile.in. These paths are not *directly* used when
1633	gcc_exec_prefix is set because, in that case, we know where the
1634	compiler has been installed, and use paths relative to that
1635	location instead. */
1636	static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1637	static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1638	static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1639	static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1640
1641	/* For native compilers, these are well-known paths containing
1642	components that may be provided by the system. For cross
1643	compilers, these paths are not used. */
1644	static const char *md_exec_prefix = MD_EXEC_PREFIX;
1645	static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1646	static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1647	static const char *const standard_startfile_prefix_1
1648	= STANDARD_STARTFILE_PREFIX_1;
1649	static const char *const standard_startfile_prefix_2
1650	= STANDARD_STARTFILE_PREFIX_2;
1651
1652	/* A relative path to be used in finding the location of tools
1653	relative to the driver. */
1654	static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1655
1656	/* A prefix to be used when this is an accelerator compiler. */
1657	static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
1658
1659	/* Subdirectory to use for locating libraries. Set by
1660	set_multilib_dir based on the compilation options. */
1661
1662	static const char *multilib_dir;
1663
1664	/* Subdirectory to use for locating libraries in OS conventions. Set by
1665	set_multilib_dir based on the compilation options. */
1666
1667	static const char *multilib_os_dir;
1668
1669	/* Subdirectory to use for locating libraries in multiarch conventions. Set by
1670	set_multilib_dir based on the compilation options. */
1671
1672	static const char *multiarch_dir;
1673
1674	/* Structure to keep track of the specs that have been defined so far.
1675	These are accessed using %(specname) in a compiler or link
1676	spec. */
1677
1678	struct spec_list
1679	{
1680	/* The following 2 fields must be first */
1681	/* to allow EXTRA_SPECS to be initialized */
1682	const char *name; /* name of the spec. */
1683	const char *ptr; /* available ptr if no static pointer */
1684
1685	/* The following fields are not initialized */
1686	/* by EXTRA_SPECS */
1687	const char **ptr_spec; /* pointer to the spec itself. */
1688	struct spec_list *next; /* Next spec in linked list. */
1689	int name_len; /* length of the name */
1690	bool user_p; /* whether string come from file spec. */
1691	bool alloc_p; /* whether string was allocated */
1692	const char *default_ptr; /* The default value of *ptr_spec. */
1693	};
1694
1695	#define INIT_STATIC_SPEC(NAME,PTR) \
1696	{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1697	*PTR }
1698
1699	/* List of statically defined specs. */
1700	static struct spec_list static_specs[] =
1701	{
1702	INIT_STATIC_SPEC ("asm", &asm_spec),
1703	INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1704	INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option),
1705	INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1706	INIT_STATIC_SPEC ("asm_options", &asm_options),
1707	INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1708	INIT_STATIC_SPEC ("cpp", &cpp_spec),
1709	INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1710	INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1711	INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1712	INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1713	INIT_STATIC_SPEC ("cc1", &cc1_spec),
1714	INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1715	INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1716	INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1717	INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1718	INIT_STATIC_SPEC ("endfile", &endfile_spec),
1719	INIT_STATIC_SPEC ("link", &link_spec),
1720	INIT_STATIC_SPEC ("lib", &lib_spec),
1721	INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1722	INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1723	INIT_STATIC_SPEC ("startfile", &startfile_spec),
1724	INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1725	INIT_STATIC_SPEC ("version", &compiler_version),
1726	INIT_STATIC_SPEC ("multilib", &multilib_select),
1727	INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1728	INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1729	INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1730	INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1731	INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1732	INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1733	INIT_STATIC_SPEC ("linker", &linker_name_spec),
1734	INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1735	INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1736	INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1737	INIT_STATIC_SPEC ("post_link", &post_link_spec),
1738	INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1739	INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1740	INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1741	INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1742	INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1743	INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1744	INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1745	INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1746	INIT_STATIC_SPEC ("self_spec", &self_spec),
1747	};
1748
1749	#ifdef EXTRA_SPECS /* additional specs needed */
1750	/* Structure to keep track of just the first two args of a spec_list.
1751	That is all that the EXTRA_SPECS macro gives us. */
1752	struct spec_list_1
1753	{
1754	const char *const name;
1755	const char *const ptr;
1756	};
1757
1758	static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1759	static struct spec_list *extra_specs = (struct spec_list *) 0;
1760	#endif
1761
1762	/* List of dynamically allocates specs that have been defined so far. */
1763
1764	static struct spec_list *specs = (struct spec_list *) 0;
1765
1766	/* List of static spec functions. */
1767
1768	static const struct spec_function static_spec_functions[] =
1769	{
1770	{ .name: "getenv", .func: getenv_spec_function },
1771	{ .name: "if-exists", .func: if_exists_spec_function },
1772	{ .name: "if-exists-else", .func: if_exists_else_spec_function },
1773	{ .name: "if-exists-then-else", .func: if_exists_then_else_spec_function },
1774	{ .name: "sanitize", .func: sanitize_spec_function },
1775	{ .name: "replace-outfile", .func: replace_outfile_spec_function },
1776	{ .name: "remove-outfile", .func: remove_outfile_spec_function },
1777	{ .name: "version-compare", .func: version_compare_spec_function },
1778	{ .name: "include", .func: include_spec_function },
1779	{ .name: "find-file", .func: find_file_spec_function },
1780	{ .name: "find-plugindir", .func: find_plugindir_spec_function },
1781	{ .name: "print-asm-header", .func: print_asm_header_spec_function },
1782	{ .name: "compare-debug-dump-opt", .func: compare_debug_dump_opt_spec_function },
1783	{ .name: "compare-debug-self-opt", .func: compare_debug_self_opt_spec_function },
1784	{ .name: "pass-through-libs", .func: pass_through_libs_spec_func },
1785	{ .name: "dumps", .func: dumps_spec_func },
1786	{ .name: "gt", .func: greater_than_spec_func },
1787	{ .name: "debug-level-gt", .func: debug_level_greater_than_spec_func },
1788	{ .name: "dwarf-version-gt", .func: dwarf_version_greater_than_spec_func },
1789	{ .name: "fortran-preinclude-file", .func: find_fortran_preinclude_file},
1790	{ .name: "join", .func: join_spec_func},
1791	#ifdef EXTRA_SPEC_FUNCTIONS
1792	EXTRA_SPEC_FUNCTIONS
1793	#endif
1794	{ .name: 0, .func: 0 }
1795	};
1796
1797	static int processing_spec_function;
1798
1799	/* Add appropriate libgcc specs to OBSTACK, taking into account
1800	various permutations of -shared-libgcc, -shared, and such. */
1801
1802	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1803
1804	#ifndef USE_LD_AS_NEEDED
1805	#define USE_LD_AS_NEEDED 0
1806	#endif
1807
1808	static void
1809	init_gcc_specs (struct obstack *obstack, const char *shared_name,
1810	const char *static_name, const char *eh_name)
1811	{
1812	char *buf;
1813
1814	#if USE_LD_AS_NEEDED
1815	buf = concat ("%{static|static-libgcc|static-pie:", static_name, " ", eh_name, "}"
1816	"%{!static:%{!static-libgcc:%{!static-pie:"
1817	"%{!shared-libgcc:",
1818	static_name, " " LD_AS_NEEDED_OPTION " ",
1819	shared_name, " " LD_NO_AS_NEEDED_OPTION
1820	"}"
1821	"%{shared-libgcc:",
1822	shared_name, "%{!shared: ", static_name, "}"
1823	"}}"
1824	#else
1825	buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1826	"%{!static:%{!static-libgcc:"
1827	"%{!shared:"
1828	"%{!shared-libgcc:", static_name, " ", eh_name, "}"
1829	"%{shared-libgcc:", shared_name, " ", static_name, "}"
1830	"}"
1831	#ifdef LINK_EH_SPEC
1832	"%{shared:"
1833	"%{shared-libgcc:", shared_name, "}"
1834	"%{!shared-libgcc:", static_name, "}"
1835	"}"
1836	#else
1837	"%{shared:", shared_name, "}"
1838	#endif
1839	#endif
1840	"}}", NULL);
1841
1842	obstack_grow (obstack, buf, strlen (buf));
1843	free (ptr: buf);
1844	}
1845	#endif /* ENABLE_SHARED_LIBGCC */
1846
1847	/* Initialize the specs lookup routines. */
1848
1849	static void
1850	init_spec (void)
1851	{
1852	struct spec_list *next = (struct spec_list *) 0;
1853	struct spec_list *sl = (struct spec_list *) 0;
1854	int i;
1855
1856	if (specs)
1857	return; /* Already initialized. */
1858
1859	if (verbose_flag)
1860	fnotice (stderr, "Using built-in specs.\n");
1861
1862	#ifdef EXTRA_SPECS
1863	extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1864
1865	for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1866	{
1867	sl = &extra_specs[i];
1868	sl->name = extra_specs_1[i].name;
1869	sl->ptr = extra_specs_1[i].ptr;
1870	sl->next = next;
1871	sl->name_len = strlen (s: sl->name);
1872	sl->ptr_spec = &sl->ptr;
1873	gcc_assert (sl->ptr_spec != NULL);
1874	sl->default_ptr = sl->ptr;
1875	next = sl;
1876	}
1877	#endif
1878
1879	for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1880	{
1881	sl = &static_specs[i];
1882	sl->next = next;
1883	next = sl;
1884	}
1885
1886	#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1887	/* ??? If neither -shared-libgcc nor --static-libgcc was
1888	seen, then we should be making an educated guess. Some proposed
1889	heuristics for ELF include:
1890
1891	(1) If "-Wl,--export-dynamic", then it's a fair bet that the
1892	program will be doing dynamic loading, which will likely
1893	need the shared libgcc.
1894
1895	(2) If "-ldl", then it's also a fair bet that we're doing
1896	dynamic loading.
1897
1898	(3) For each ET_DYN we're linking against (either through -lfoo
1899	or /some/path/foo.so), check to see whether it or one of
1900	its dependencies depends on a shared libgcc.
1901
1902	(4) If "-shared"
1903
1904	If the runtime is fixed to look for program headers instead
1905	of calling __register_frame_info at all, for each object,
1906	use the shared libgcc if any EH symbol referenced.
1907
1908	If crtstuff is fixed to not invoke __register_frame_info
1909	automatically, for each object, use the shared libgcc if
1910	any non-empty unwind section found.
1911
1912	Doing any of this probably requires invoking an external program to
1913	do the actual object file scanning. */
1914	{
1915	const char *p = libgcc_spec;
1916	int in_sep = 1;
1917
1918	/* Transform the extant libgcc_spec into one that uses the shared libgcc
1919	when given the proper command line arguments. */
1920	while (*p)
1921	{
1922	if (in_sep && *p == '-' && startswith (str: p, prefix: "-lgcc"))
1923	{
1924	init_gcc_specs (obstack: &obstack,
1925	shared_name: "-lgcc_s"
1926	#ifdef USE_LIBUNWIND_EXCEPTIONS
1927	" -lunwind"
1928	#endif
1929	,
1930	static_name: "-lgcc",
1931	eh_name: "-lgcc_eh"
1932	#ifdef USE_LIBUNWIND_EXCEPTIONS
1933	# ifdef HAVE_LD_STATIC_DYNAMIC
1934	" %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind"
1935	" %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}"
1936	# else
1937	" -lunwind"
1938	# endif
1939	#endif
1940	);
1941
1942	p += 5;
1943	in_sep = 0;
1944	}
1945	else if (in_sep && *p == 'l' && startswith (str: p, prefix: "libgcc.a%s"))
1946	{
1947	/* Ug. We don't know shared library extensions. Hope that
1948	systems that use this form don't do shared libraries. */
1949	init_gcc_specs (obstack: &obstack,
1950	shared_name: "-lgcc_s",
1951	static_name: "libgcc.a%s",
1952	eh_name: "libgcc_eh.a%s"
1953	#ifdef USE_LIBUNWIND_EXCEPTIONS
1954	" -lunwind"
1955	#endif
1956	);
1957	p += 10;
1958	in_sep = 0;
1959	}
1960	else
1961	{
1962	obstack_1grow (&obstack, *p);
1963	in_sep = (*p == ' ');
1964	p += 1;
1965	}
1966	}
1967
1968	obstack_1grow (&obstack, '\0');
1969	libgcc_spec = XOBFINISH (&obstack, const char *);
1970	}
1971	#endif
1972	#ifdef USE_AS_TRADITIONAL_FORMAT
1973	/* Prepend "--traditional-format" to whatever asm_spec we had before. */
1974	{
1975	static const char tf[] = "--traditional-format ";
1976	obstack_grow (&obstack, tf, sizeof (tf) - 1);
1977	obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1978	asm_spec = XOBFINISH (&obstack, const char *);
1979	}
1980	#endif
1981
1982	#if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1983	defined LINKER_HASH_STYLE
1984	# ifdef LINK_BUILDID_SPEC
1985	/* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1986	obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
1987	# endif
1988	# ifdef LINK_EH_SPEC
1989	/* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1990	obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
1991	# endif
1992	# ifdef LINKER_HASH_STYLE
1993	/* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1994	before. */
1995	{
1996	static const char hash_style[] = "--hash-style=";
1997	obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
1998	obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
1999	obstack_1grow (&obstack, ' ');
2000	}
2001	# endif
2002	obstack_grow0 (&obstack, link_spec, strlen (link_spec));
2003	link_spec = XOBFINISH (&obstack, const char *);
2004	#endif
2005
2006	specs = sl;
2007	}
2008
2009	/* Update the entry for SPEC in the static_specs table to point to VALUE,
2010	ensuring that we free the previous value if necessary. Set alloc_p for the
2011	entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
2012	whether we need to free it later on). */
2013	static void
2014	set_static_spec (const char **spec, const char *value, bool alloc_p)
2015	{
2016	struct spec_list *sl = NULL;
2017
2018	for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
2019	{
2020	if (static_specs[i].ptr_spec == spec)
2021	{
2022	sl = static_specs + i;
2023	break;
2024	}
2025	}
2026
2027	gcc_assert (sl);
2028
2029	if (sl->alloc_p)
2030	{
2031	const char *old = *spec;
2032	free (ptr: const_cast <char *> (old));
2033	}
2034
2035	*spec = value;
2036	sl->alloc_p = alloc_p;
2037	}
2038
2039	/* Update a static spec to a new string, taking ownership of that
2040	string's memory. */
2041	static void set_static_spec_owned (const char **spec, const char *val)
2042	{
2043	return set_static_spec (spec, value: val, alloc_p: true);
2044	}
2045
2046	/* Update a static spec to point to a new value, but don't take
2047	ownership of (i.e. don't free) that string. */
2048	static void set_static_spec_shared (const char **spec, const char *val)
2049	{
2050	return set_static_spec (spec, value: val, alloc_p: false);
2051	}
2052
2053
2054	/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2055	removed; If the spec starts with a + then SPEC is added to the end of the
2056	current spec. */
2057
2058	static void
2059	set_spec (const char *name, const char *spec, bool user_p)
2060	{
2061	struct spec_list *sl;
2062	const char *old_spec;
2063	int name_len = strlen (s: name);
2064	int i;
2065
2066	/* If this is the first call, initialize the statically allocated specs. */
2067	if (!specs)
2068	{
2069	struct spec_list *next = (struct spec_list *) 0;
2070	for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
2071	{
2072	sl = &static_specs[i];
2073	sl->next = next;
2074	next = sl;
2075	}
2076	specs = sl;
2077	}
2078
2079	/* See if the spec already exists. */
2080	for (sl = specs; sl; sl = sl->next)
2081	if (name_len == sl->name_len && !strcmp (s1: sl->name, s2: name))
2082	break;
2083
2084	if (!sl)
2085	{
2086	/* Not found - make it. */
2087	sl = XNEW (struct spec_list);
2088	sl->name = xstrdup (name);
2089	sl->name_len = name_len;
2090	sl->ptr_spec = &sl->ptr;
2091	sl->alloc_p = 0;
2092	*(sl->ptr_spec) = "";
2093	sl->next = specs;
2094	sl->default_ptr = NULL;
2095	specs = sl;
2096	}
2097
2098	old_spec = *(sl->ptr_spec);
2099	*(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
2100	? concat (old_spec, spec + 1, NULL)
2101	: xstrdup (spec));
2102
2103	#ifdef DEBUG_SPECS
2104	if (verbose_flag)
2105	fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
2106	#endif
2107
2108	/* Free the old spec. */
2109	if (old_spec && sl->alloc_p)
2110	free (CONST_CAST (char *, old_spec));
2111
2112	sl->user_p = user_p;
2113	sl->alloc_p = true;
2114	}
2115
2116	/* Accumulate a command (program name and args), and run it. */
2117
2118	typedef const char *const_char_p; /* For DEF_VEC_P. */
2119
2120	/* Vector of pointers to arguments in the current line of specifications. */
2121	static vec<const_char_p> argbuf;
2122
2123	/* Likewise, but for the current @file. */
2124	static vec<const_char_p> at_file_argbuf;
2125
2126	/* Whether an @file is currently open. */
2127	static bool in_at_file = false;
2128
2129	/* Were the options -c, -S or -E passed. */
2130	static int have_c = 0;
2131
2132	/* Was the option -o passed. */
2133	static int have_o = 0;
2134
2135	/* Was the option -E passed. */
2136	static int have_E = 0;
2137
2138	/* Pointer to output file name passed in with -o. */
2139	static const char *output_file = 0;
2140
2141	/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2142	temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2143	it here. */
2144
2145	static struct temp_name {
2146	const char *suffix; /* suffix associated with the code. */
2147	int length; /* strlen (suffix). */
2148	int unique; /* Indicates whether %g or %u/%U was used. */
2149	const char *filename; /* associated filename. */
2150	int filename_length; /* strlen (filename). */
2151	struct temp_name *next;
2152	} *temp_names;
2153
2154	/* Number of commands executed so far. */
2155
2156	static int execution_count;
2157
2158	/* Number of commands that exited with a signal. */
2159
2160	static int signal_count;
2161
2162	/* Allocate the argument vector. */
2163
2164	static void
2165	alloc_args (void)
2166	{
2167	argbuf.create (nelems: 10);
2168	at_file_argbuf.create (nelems: 10);
2169	}
2170
2171	/* Clear out the vector of arguments (after a command is executed). */
2172
2173	static void
2174	clear_args (void)
2175	{
2176	argbuf.truncate (size: 0);
2177	at_file_argbuf.truncate (size: 0);
2178	}
2179
2180	/* Add one argument to the vector at the end.
2181	This is done when a space is seen or at the end of the line.
2182	If DELETE_ALWAYS is nonzero, the arg is a filename
2183	and the file should be deleted eventually.
2184	If DELETE_FAILURE is nonzero, the arg is a filename
2185	and the file should be deleted if this compilation fails. */
2186
2187	static void
2188	store_arg (const char *arg, int delete_always, int delete_failure)
2189	{
2190	if (in_at_file)
2191	at_file_argbuf.safe_push (obj: arg);
2192	else
2193	argbuf.safe_push (obj: arg);
2194
2195	if (delete_always || delete_failure)
2196	{
2197	const char *p;
2198	/* If the temporary file we should delete is specified as
2199	part of a joined argument extract the filename. */
2200	if (arg[0] == '-'
2201	&& (p = strrchr (s: arg, c: '=')))
2202	arg = p + 1;
2203	record_temp_file (arg, delete_always, delete_failure);
2204	}
2205	}
2206
2207	/* Open a temporary @file into which subsequent arguments will be stored. */
2208
2209	static void
2210	open_at_file (void)
2211	{
2212	if (in_at_file)
2213	fatal_error (input_location, "cannot open nested response file");
2214	else
2215	in_at_file = true;
2216	}
2217
2218	/* Create a temporary @file name. */
2219
2220	static char *make_at_file (void)
2221	{
2222	static int fileno = 0;
2223	char filename[20];
2224	const char *base, *ext;
2225
2226	if (!save_temps_flag)
2227	return make_temp_file ("");
2228
2229	base = dumpbase;
2230	if (!(base && *base))
2231	base = dumpdir;
2232	if (!(base && *base))
2233	base = "a";
2234
2235	sprintf (s: filename, format: ".args.%d", fileno++);
2236	ext = filename;
2237
2238	if (base == dumpdir && dumpdir_trailing_dash_added)
2239	ext++;
2240
2241	return concat (base, ext, NULL);
2242	}
2243
2244	/* Close the temporary @file and add @file to the argument list. */
2245
2246	static void
2247	close_at_file (void)
2248	{
2249	if (!in_at_file)
2250	fatal_error (input_location, "cannot close nonexistent response file");
2251
2252	in_at_file = false;
2253
2254	const unsigned int n_args = at_file_argbuf.length ();
2255	if (n_args == 0)
2256	return;
2257
2258	char **argv = XALLOCAVEC (char *, n_args + 1);
2259	char *temp_file = make_at_file ();
2260	char *at_argument = concat ("@", temp_file, NULL);
2261	FILE *f = fopen (filename: temp_file, modes: "w");
2262	int status;
2263	unsigned int i;
2264
2265	/* Copy the strings over. */
2266	for (i = 0; i < n_args; i++)
2267	argv[i] = CONST_CAST (char *, at_file_argbuf[i]);
2268	argv[i] = NULL;
2269
2270	at_file_argbuf.truncate (size: 0);
2271
2272	if (f == NULL)
2273	fatal_error (input_location, "could not open temporary response file %s",
2274	temp_file);
2275
2276	status = writeargv (argv, f);
2277
2278	if (status)
2279	fatal_error (input_location,
2280	"could not write to temporary response file %s",
2281	temp_file);
2282
2283	status = fclose (stream: f);
2284
2285	if (status == EOF)
2286	fatal_error (input_location, "could not close temporary response file %s",
2287	temp_file);
2288
2289	store_arg (arg: at_argument, delete_always: 0, delete_failure: 0);
2290
2291	record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
2292	}
2293
2294	/* Load specs from a file name named FILENAME, replacing occurrences of
2295	various different types of line-endings, \r\n, \n\r and just \r, with
2296	a single \n. */
2297
2298	static char *
2299	load_specs (const char *filename)
2300	{
2301	int desc;
2302	int readlen;
2303	struct stat statbuf;
2304	char *buffer;
2305	char *buffer_p;
2306	char *specs;
2307	char *specs_p;
2308
2309	if (verbose_flag)
2310	fnotice (stderr, "Reading specs from %s\n", filename);
2311
2312	/* Open and stat the file. */
2313	desc = open (file: filename, O_RDONLY, 0);
2314	if (desc < 0)
2315	{
2316	failed:
2317	/* This leaves DESC open, but the OS will save us. */
2318	fatal_error (input_location, "cannot read spec file %qs: %m", filename);
2319	}
2320
2321	if (stat (file: filename, buf: &statbuf) < 0)
2322	goto failed;
2323
2324	/* Read contents of file into BUFFER. */
2325	buffer = XNEWVEC (char, statbuf.st_size + 1);
2326	readlen = read (fd: desc, buf: buffer, nbytes: (unsigned) statbuf.st_size);
2327	if (readlen < 0)
2328	goto failed;
2329	buffer[readlen] = 0;
2330	close (fd: desc);
2331
2332	specs = XNEWVEC (char, readlen + 1);
2333	specs_p = specs;
2334	for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2335	{
2336	int skip = 0;
2337	char c = *buffer_p;
2338	if (c == '\r')
2339	{
2340	if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2341	skip = 1;
2342	else if (*(buffer_p + 1) == '\n') /* \r\n */
2343	skip = 1;
2344	else /* \r */
2345	c = '\n';
2346	}
2347	if (! skip)
2348	*specs_p++ = c;
2349	}
2350	*specs_p = '\0';
2351
2352	free (ptr: buffer);
2353	return (specs);
2354	}
2355
2356	/* Read compilation specs from a file named FILENAME,
2357	replacing the default ones.
2358
2359	A suffix which starts with `*' is a definition for
2360	one of the machine-specific sub-specs. The "suffix" should be
2361	*asm, *cc1, *cpp, *link, *startfile, etc.
2362	The corresponding spec is stored in asm_spec, etc.,
2363	rather than in the `compilers' vector.
2364
2365	Anything invalid in the file is a fatal error. */
2366
2367	static void
2368	read_specs (const char *filename, bool main_p, bool user_p)
2369	{
2370	char *buffer;
2371	char *p;
2372
2373	buffer = load_specs (filename);
2374
2375	/* Scan BUFFER for specs, putting them in the vector. */
2376	p = buffer;
2377	while (1)
2378	{
2379	char *suffix;
2380	char *spec;
2381	char *in, *out, *p1, *p2, *p3;
2382
2383	/* Advance P in BUFFER to the next nonblank nocomment line. */
2384	p = skip_whitespace (p);
2385	if (*p == 0)
2386	break;
2387
2388	/* Is this a special command that starts with '%'? */
2389	/* Don't allow this for the main specs file, since it would
2390	encourage people to overwrite it. */
2391	if (*p == '%' && !main_p)
2392	{
2393	p1 = p;
2394	while (*p && *p != '\n')
2395	p++;
2396
2397	/* Skip '\n'. */
2398	p++;
2399
2400	if (startswith (str: p1, prefix: "%include")
2401	&& (p1[sizeof "%include" - 1] == ' '
2402	|| p1[sizeof "%include" - 1] == '\t'))
2403	{
2404	char *new_filename;
2405
2406	p1 += sizeof ("%include");
2407	while (*p1 == ' ' || *p1 == '\t')
2408	p1++;
2409
2410	if (*p1++ != '<' || p[-2] != '>')
2411	fatal_error (input_location,
2412	"specs %%include syntax malformed after "
2413	"%td characters", p1 - buffer + 1);
2414
2415	p[-2] = '\0';
2416	new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2417	read_specs (filename: new_filename ? new_filename : p1, main_p: false, user_p);
2418	continue;
2419	}
2420	else if (startswith (str: p1, prefix: "%include_noerr")
2421	&& (p1[sizeof "%include_noerr" - 1] == ' '
2422	|| p1[sizeof "%include_noerr" - 1] == '\t'))
2423	{
2424	char *new_filename;
2425
2426	p1 += sizeof "%include_noerr";
2427	while (*p1 == ' ' || *p1 == '\t')
2428	p1++;
2429
2430	if (*p1++ != '<' || p[-2] != '>')
2431	fatal_error (input_location,
2432	"specs %%include syntax malformed after "
2433	"%td characters", p1 - buffer + 1);
2434
2435	p[-2] = '\0';
2436	new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2437	if (new_filename)
2438	read_specs (filename: new_filename, main_p: false, user_p);
2439	else if (verbose_flag)
2440	fnotice (stderr, "could not find specs file %s\n", p1);
2441	continue;
2442	}
2443	else if (startswith (str: p1, prefix: "%rename")
2444	&& (p1[sizeof "%rename" - 1] == ' '
2445	|| p1[sizeof "%rename" - 1] == '\t'))
2446	{
2447	int name_len;
2448	struct spec_list *sl;
2449	struct spec_list *newsl;
2450
2451	/* Get original name. */
2452	p1 += sizeof "%rename";
2453	while (*p1 == ' ' || *p1 == '\t')
2454	p1++;
2455
2456	if (! ISALPHA ((unsigned char) *p1))
2457	fatal_error (input_location,
2458	"specs %%rename syntax malformed after "
2459	"%td characters", p1 - buffer);
2460
2461	p2 = p1;
2462	while (*p2 && !ISSPACE ((unsigned char) *p2))
2463	p2++;
2464
2465	if (*p2 != ' ' && *p2 != '\t')
2466	fatal_error (input_location,
2467	"specs %%rename syntax malformed after "
2468	"%td characters", p2 - buffer);
2469
2470	name_len = p2 - p1;
2471	*p2++ = '\0';
2472	while (*p2 == ' ' || *p2 == '\t')
2473	p2++;
2474
2475	if (! ISALPHA ((unsigned char) *p2))
2476	fatal_error (input_location,
2477	"specs %%rename syntax malformed after "
2478	"%td characters", p2 - buffer);
2479
2480	/* Get new spec name. */
2481	p3 = p2;
2482	while (*p3 && !ISSPACE ((unsigned char) *p3))
2483	p3++;
2484
2485	if (p3 != p - 1)
2486	fatal_error (input_location,
2487	"specs %%rename syntax malformed after "
2488	"%td characters", p3 - buffer);
2489	*p3 = '\0';
2490
2491	for (sl = specs; sl; sl = sl->next)
2492	if (name_len == sl->name_len && !strcmp (s1: sl->name, s2: p1))
2493	break;
2494
2495	if (!sl)
2496	fatal_error (input_location,
2497	"specs %s spec was not found to be renamed", p1);
2498
2499	if (strcmp (s1: p1, s2: p2) == 0)
2500	continue;
2501
2502	for (newsl = specs; newsl; newsl = newsl->next)
2503	if (strcmp (s1: newsl->name, s2: p2) == 0)
2504	fatal_error (input_location,
2505	"%s: attempt to rename spec %qs to "
2506	"already defined spec %qs",
2507	filename, p1, p2);
2508
2509	if (verbose_flag)
2510	{
2511	fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2512	#ifdef DEBUG_SPECS
2513	fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2514	#endif
2515	}
2516
2517	set_spec (name: p2, spec: *(sl->ptr_spec), user_p);
2518	if (sl->alloc_p)
2519	free (CONST_CAST (char *, *(sl->ptr_spec)));
2520
2521	*(sl->ptr_spec) = "";
2522	sl->alloc_p = 0;
2523	continue;
2524	}
2525	else
2526	fatal_error (input_location,
2527	"specs unknown %% command after %td characters",
2528	p1 - buffer);
2529	}
2530
2531	/* Find the colon that should end the suffix. */
2532	p1 = p;
2533	while (*p1 && *p1 != ':' && *p1 != '\n')
2534	p1++;
2535
2536	/* The colon shouldn't be missing. */
2537	if (*p1 != ':')
2538	fatal_error (input_location,
2539	"specs file malformed after %td characters",
2540	p1 - buffer);
2541
2542	/* Skip back over trailing whitespace. */
2543	p2 = p1;
2544	while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2545	p2--;
2546
2547	/* Copy the suffix to a string. */
2548	suffix = save_string (p, p2 - p);
2549	/* Find the next line. */
2550	p = skip_whitespace (p: p1 + 1);
2551	if (p[1] == 0)
2552	fatal_error (input_location,
2553	"specs file malformed after %td characters",
2554	p - buffer);
2555
2556	p1 = p;
2557	/* Find next blank line or end of string. */
2558	while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2559	p1++;
2560
2561	/* Specs end at the blank line and do not include the newline. */
2562	spec = save_string (p, p1 - p);
2563	p = p1;
2564
2565	/* Delete backslash-newline sequences from the spec. */
2566	in = spec;
2567	out = spec;
2568	while (*in != 0)
2569	{
2570	if (in[0] == '\\' && in[1] == '\n')
2571	in += 2;
2572	else if (in[0] == '#')
2573	while (*in && *in != '\n')
2574	in++;
2575
2576	else
2577	*out++ = *in++;
2578	}
2579	*out = 0;
2580
2581	if (suffix[0] == '*')
2582	{
2583	if (! strcmp (s1: suffix, s2: "*link_command"))
2584	link_command_spec = spec;
2585	else
2586	{
2587	set_spec (name: suffix + 1, spec, user_p);
2588	free (ptr: spec);
2589	}
2590	}
2591	else
2592	{
2593	/* Add this pair to the vector. */
2594	compilers
2595	= XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2596
2597	compilers[n_compilers].suffix = suffix;
2598	compilers[n_compilers].spec = spec;
2599	n_compilers++;
2600	memset (s: &compilers[n_compilers], c: 0, n: sizeof compilers[n_compilers]);
2601	}
2602
2603	if (*suffix == 0)
2604	link_command_spec = spec;
2605	}
2606
2607	if (link_command_spec == 0)
2608	fatal_error (input_location, "spec file has no spec for linking");
2609
2610	XDELETEVEC (buffer);
2611	}
2612
2613	/* Record the names of temporary files we tell compilers to write,
2614	and delete them at the end of the run. */
2615
2616	/* This is the common prefix we use to make temp file names.
2617	It is chosen once for each run of this program.
2618	It is substituted into a spec by %g or %j.
2619	Thus, all temp file names contain this prefix.
2620	In practice, all temp file names start with this prefix.
2621
2622	This prefix comes from the envvar TMPDIR if it is defined;
2623	otherwise, from the P_tmpdir macro if that is defined;
2624	otherwise, in /usr/tmp or /tmp;
2625	or finally the current directory if all else fails. */
2626
2627	static const char *temp_filename;
2628
2629	/* Length of the prefix. */
2630
2631	static int temp_filename_length;
2632
2633	/* Define the list of temporary files to delete. */
2634
2635	struct temp_file
2636	{
2637	const char *name;
2638	struct temp_file *next;
2639	};
2640
2641	/* Queue of files to delete on success or failure of compilation. */
2642	static struct temp_file *always_delete_queue;
2643	/* Queue of files to delete on failure of compilation. */
2644	static struct temp_file *failure_delete_queue;
2645
2646	/* Record FILENAME as a file to be deleted automatically.
2647	ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2648	otherwise delete it in any case.
2649	FAIL_DELETE nonzero means delete it if a compilation step fails;
2650	otherwise delete it in any case. */
2651
2652	void
2653	record_temp_file (const char *filename, int always_delete, int fail_delete)
2654	{
2655	char *const name = xstrdup (filename);
2656
2657	if (always_delete)
2658	{
2659	struct temp_file *temp;
2660	for (temp = always_delete_queue; temp; temp = temp->next)
2661	if (! filename_cmp (s1: name, s2: temp->name))
2662	{
2663	free (ptr: name);
2664	goto already1;
2665	}
2666
2667	temp = XNEW (struct temp_file);
2668	temp->next = always_delete_queue;
2669	temp->name = name;
2670	always_delete_queue = temp;
2671
2672	already1:;
2673	}
2674
2675	if (fail_delete)
2676	{
2677	struct temp_file *temp;
2678	for (temp = failure_delete_queue; temp; temp = temp->next)
2679	if (! filename_cmp (s1: name, s2: temp->name))
2680	{
2681	free (ptr: name);
2682	goto already2;
2683	}
2684
2685	temp = XNEW (struct temp_file);
2686	temp->next = failure_delete_queue;
2687	temp->name = name;
2688	failure_delete_queue = temp;
2689
2690	already2:;
2691	}
2692	}
2693
2694	/* Delete all the temporary files whose names we previously recorded. */
2695
2696	#ifndef DELETE_IF_ORDINARY
2697	#define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2698	do \
2699	{ \
2700	if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2701	if (unlink (NAME) < 0) \
2702	if (VERBOSE_FLAG) \
2703	error ("%s: %m", (NAME)); \
2704	} while (0)
2705	#endif
2706
2707	static void
2708	delete_if_ordinary (const char *name)
2709	{
2710	struct stat st;
2711	#ifdef DEBUG
2712	int i, c;
2713
2714	printf ("Delete %s? (y or n) ", name);
2715	fflush (stdout);
2716	i = getchar ();
2717	if (i != '\n')
2718	while ((c = getchar ()) != '\n' && c != EOF)
2719	;
2720
2721	if (i == 'y' || i == 'Y')
2722	#endif /* DEBUG */
2723	DELETE_IF_ORDINARY (name, st, verbose_flag);
2724	}
2725
2726	static void
2727	delete_temp_files (void)
2728	{
2729	struct temp_file *temp;
2730
2731	for (temp = always_delete_queue; temp; temp = temp->next)
2732	delete_if_ordinary (name: temp->name);
2733	always_delete_queue = 0;
2734	}
2735
2736	/* Delete all the files to be deleted on error. */
2737
2738	static void
2739	delete_failure_queue (void)
2740	{
2741	struct temp_file *temp;
2742
2743	for (temp = failure_delete_queue; temp; temp = temp->next)
2744	delete_if_ordinary (name: temp->name);
2745	}
2746
2747	static void
2748	clear_failure_queue (void)
2749	{
2750	failure_delete_queue = 0;
2751	}
2752
2753	/* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2754	returns non-NULL.
2755	If DO_MULTI is true iterate over the paths twice, first with multilib
2756	suffix then without, otherwise iterate over the paths once without
2757	adding a multilib suffix. When DO_MULTI is true, some attempt is made
2758	to avoid visiting the same path twice, but we could do better. For
2759	instance, /usr/lib/../lib is considered different from /usr/lib.
2760	At least EXTRA_SPACE chars past the end of the path passed to
2761	CALLBACK are available for use by the callback.
2762	CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2763
2764	Returns the value returned by CALLBACK. */
2765
2766	static void *
2767	for_each_path (const struct path_prefix *paths,
2768	bool do_multi,
2769	size_t extra_space,
2770	void *(*callback) (char *, void *),
2771	void *callback_info)
2772	{
2773	struct prefix_list *pl;
2774	const char *multi_dir = NULL;
2775	const char *multi_os_dir = NULL;
2776	const char *multiarch_suffix = NULL;
2777	const char *multi_suffix;
2778	const char *just_multi_suffix;
2779	char *path = NULL;
2780	void *ret = NULL;
2781	bool skip_multi_dir = false;
2782	bool skip_multi_os_dir = false;
2783
2784	multi_suffix = machine_suffix;
2785	just_multi_suffix = just_machine_suffix;
2786	if (do_multi && multilib_dir && strcmp (s1: multilib_dir, s2: ".") != 0)
2787	{
2788	multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2789	multi_suffix = concat (multi_suffix, multi_dir, NULL);
2790	just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2791	}
2792	if (do_multi && multilib_os_dir && strcmp (s1: multilib_os_dir, s2: ".") != 0)
2793	multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2794	if (multiarch_dir)
2795	multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2796
2797	while (1)
2798	{
2799	size_t multi_dir_len = 0;
2800	size_t multi_os_dir_len = 0;
2801	size_t multiarch_len = 0;
2802	size_t suffix_len;
2803	size_t just_suffix_len;
2804	size_t len;
2805
2806	if (multi_dir)
2807	multi_dir_len = strlen (s: multi_dir);
2808	if (multi_os_dir)
2809	multi_os_dir_len = strlen (s: multi_os_dir);
2810	if (multiarch_suffix)
2811	multiarch_len = strlen (s: multiarch_suffix);
2812	suffix_len = strlen (s: multi_suffix);
2813	just_suffix_len = strlen (s: just_multi_suffix);
2814
2815	if (path == NULL)
2816	{
2817	len = paths->max_len + extra_space + 1;
2818	len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2819	path = XNEWVEC (char, len);
2820	}
2821
2822	for (pl = paths->plist; pl != 0; pl = pl->next)
2823	{
2824	len = strlen (s: pl->prefix);
2825	memcpy (dest: path, src: pl->prefix, n: len);
2826
2827	/* Look first in MACHINE/VERSION subdirectory. */
2828	if (!skip_multi_dir)
2829	{
2830	memcpy (dest: path + len, src: multi_suffix, n: suffix_len + 1);
2831	ret = callback (path, callback_info);
2832	if (ret)
2833	break;
2834	}
2835
2836	/* Some paths are tried with just the machine (ie. target)
2837	subdir. This is used for finding as, ld, etc. */
2838	if (!skip_multi_dir
2839	&& pl->require_machine_suffix == 2)
2840	{
2841	memcpy (dest: path + len, src: just_multi_suffix, n: just_suffix_len + 1);
2842	ret = callback (path, callback_info);
2843	if (ret)
2844	break;
2845	}
2846
2847	/* Now try the multiarch path. */
2848	if (!skip_multi_dir
2849	&& !pl->require_machine_suffix && multiarch_dir)
2850	{
2851	memcpy (dest: path + len, src: multiarch_suffix, n: multiarch_len + 1);
2852	ret = callback (path, callback_info);
2853	if (ret)
2854	break;
2855	}
2856
2857	/* Now try the base path. */
2858	if (!pl->require_machine_suffix
2859	&& !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2860	{
2861	const char *this_multi;
2862	size_t this_multi_len;
2863
2864	if (pl->os_multilib)
2865	{
2866	this_multi = multi_os_dir;
2867	this_multi_len = multi_os_dir_len;
2868	}
2869	else
2870	{
2871	this_multi = multi_dir;
2872	this_multi_len = multi_dir_len;
2873	}
2874
2875	if (this_multi_len)
2876	memcpy (dest: path + len, src: this_multi, n: this_multi_len + 1);
2877	else
2878	path[len] = '\0';
2879
2880	ret = callback (path, callback_info);
2881	if (ret)
2882	break;
2883	}
2884	}
2885	if (pl)
2886	break;
2887
2888	if (multi_dir == NULL && multi_os_dir == NULL)
2889	break;
2890
2891	/* Run through the paths again, this time without multilibs.
2892	Don't repeat any we have already seen. */
2893	if (multi_dir)
2894	{
2895	free (CONST_CAST (char *, multi_dir));
2896	multi_dir = NULL;
2897	free (CONST_CAST (char *, multi_suffix));
2898	multi_suffix = machine_suffix;
2899	free (CONST_CAST (char *, just_multi_suffix));
2900	just_multi_suffix = just_machine_suffix;
2901	}
2902	else
2903	skip_multi_dir = true;
2904	if (multi_os_dir)
2905	{
2906	free (CONST_CAST (char *, multi_os_dir));
2907	multi_os_dir = NULL;
2908	}
2909	else
2910	skip_multi_os_dir = true;
2911	}
2912
2913	if (multi_dir)
2914	{
2915	free (CONST_CAST (char *, multi_dir));
2916	free (CONST_CAST (char *, multi_suffix));
2917	free (CONST_CAST (char *, just_multi_suffix));
2918	}
2919	if (multi_os_dir)
2920	free (CONST_CAST (char *, multi_os_dir));
2921	if (ret != path)
2922	free (ptr: path);
2923	return ret;
2924	}
2925
2926	/* Callback for build_search_list. Adds path to obstack being built. */
2927
2928	struct add_to_obstack_info {
2929	struct obstack *ob;
2930	bool check_dir;
2931	bool first_time;
2932	};
2933
2934	static void *
2935	add_to_obstack (char *path, void *data)
2936	{
2937	struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2938
2939	if (info->check_dir && !is_directory (path, false))
2940	return NULL;
2941
2942	if (!info->first_time)
2943	obstack_1grow (info->ob, PATH_SEPARATOR);
2944
2945	obstack_grow (info->ob, path, strlen (path));
2946
2947	info->first_time = false;
2948	return NULL;
2949	}
2950
2951	/* Add or change the value of an environment variable, outputting the
2952	change to standard error if in verbose mode. */
2953	static void
2954	xputenv (const char *string)
2955	{
2956	env.xput (string);
2957	}
2958
2959	/* Build a list of search directories from PATHS.
2960	PREFIX is a string to prepend to the list.
2961	If CHECK_DIR_P is true we ensure the directory exists.
2962	If DO_MULTI is true, multilib paths are output first, then
2963	non-multilib paths.
2964	This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2965	It is also used by the --print-search-dirs flag. */
2966
2967	static char *
2968	build_search_list (const struct path_prefix *paths, const char *prefix,
2969	bool check_dir, bool do_multi)
2970	{
2971	struct add_to_obstack_info info;
2972
2973	info.ob = &collect_obstack;
2974	info.check_dir = check_dir;
2975	info.first_time = true;
2976
2977	obstack_grow (&collect_obstack, prefix, strlen (prefix));
2978	obstack_1grow (&collect_obstack, '=');
2979
2980	for_each_path (paths, do_multi, extra_space: 0, callback: add_to_obstack, callback_info: &info);
2981
2982	obstack_1grow (&collect_obstack, '\0');
2983	return XOBFINISH (&collect_obstack, char *);
2984	}
2985
2986	/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2987	for collect. */
2988
2989	static void
2990	putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2991	bool do_multi)
2992	{
2993	xputenv (string: build_search_list (paths, prefix: env_var, check_dir: true, do_multi));
2994	}
2995
2996	/* Check whether NAME can be accessed in MODE. This is like access,
2997	except that it never considers directories to be executable. */
2998
2999	static int
3000	access_check (const char *name, int mode)
3001	{
3002	if (mode == X_OK)
3003	{
3004	struct stat st;
3005
3006	if (stat (file: name, buf: &st) < 0
3007	|| S_ISDIR (st.st_mode))
3008	return -1;
3009	}
3010
3011	return access (name: name, type: mode);
3012	}
3013
3014	/* Callback for find_a_file. Appends the file name to the directory
3015	path. If the resulting file exists in the right mode, return the
3016	full pathname to the file. */
3017
3018	struct file_at_path_info {
3019	const char *name;
3020	const char *suffix;
3021	int name_len;
3022	int suffix_len;
3023	int mode;
3024	};
3025
3026	static void *
3027	file_at_path (char *path, void *data)
3028	{
3029	struct file_at_path_info *info = (struct file_at_path_info *) data;
3030	size_t len = strlen (s: path);
3031
3032	memcpy (dest: path + len, src: info->name, n: info->name_len);
3033	len += info->name_len;
3034
3035	/* Some systems have a suffix for executable files.
3036	So try appending that first. */
3037	if (info->suffix_len)
3038	{
3039	memcpy (dest: path + len, src: info->suffix, n: info->suffix_len + 1);
3040	if (access_check (name: path, mode: info->mode) == 0)
3041	return path;
3042	}
3043
3044	path[len] = '\0';
3045	if (access_check (name: path, mode: info->mode) == 0)
3046	return path;
3047
3048	return NULL;
3049	}
3050
3051	/* Search for NAME using the prefix list PREFIXES. MODE is passed to
3052	access to check permissions. If DO_MULTI is true, search multilib
3053	paths then non-multilib paths, otherwise do not search multilib paths.
3054	Return 0 if not found, otherwise return its name, allocated with malloc. */
3055
3056	static char *
3057	find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
3058	bool do_multi)
3059	{
3060	struct file_at_path_info info;
3061
3062	/* Find the filename in question (special case for absolute paths). */
3063
3064	if (IS_ABSOLUTE_PATH (name))
3065	{
3066	if (access (name: name, type: mode) == 0)
3067	return xstrdup (name);
3068
3069	return NULL;
3070	}
3071
3072	info.name = name;
3073	info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
3074	info.name_len = strlen (s: info.name);
3075	info.suffix_len = strlen (s: info.suffix);
3076	info.mode = mode;
3077
3078	return (char*) for_each_path (paths: pprefix, do_multi,
3079	extra_space: info.name_len + info.suffix_len,
3080	callback: file_at_path, callback_info: &info);
3081	}
3082
3083	/* Specialization of find_a_file for programs that also takes into account
3084	configure-specified default programs. */
3085
3086	static char*
3087	find_a_program (const char *name)
3088	{
3089	/* Do not search if default matches query. */
3090
3091	#ifdef DEFAULT_ASSEMBLER
3092	if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, X_OK) == 0)
3093	return xstrdup (DEFAULT_ASSEMBLER);
3094	#endif
3095
3096	#ifdef DEFAULT_LINKER
3097	if (! strcmp (name, "ld") && access (DEFAULT_LINKER, X_OK) == 0)
3098	return xstrdup (DEFAULT_LINKER);
3099	#endif
3100
3101	#ifdef DEFAULT_DSYMUTIL
3102	if (! strcmp (name, "dsymutil") && access (DEFAULT_DSYMUTIL, X_OK) == 0)
3103	return xstrdup (DEFAULT_DSYMUTIL);
3104	#endif
3105
3106	return find_a_file (pprefix: &exec_prefixes, name, X_OK, do_multi: false);
3107	}
3108
3109	/* Ranking of prefixes in the sort list. -B prefixes are put before
3110	all others. */
3111
3112	enum path_prefix_priority
3113	{
3114	PREFIX_PRIORITY_B_OPT,
3115	PREFIX_PRIORITY_LAST
3116	};
3117
3118	/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3119	order according to PRIORITY. Within each PRIORITY, new entries are
3120	appended.
3121
3122	If WARN is nonzero, we will warn if no file is found
3123	through this prefix. WARN should point to an int
3124	which will be set to 1 if this entry is used.
3125
3126	COMPONENT is the value to be passed to update_path.
3127
3128	REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3129	the complete value of machine_suffix.
3130	2 means try both machine_suffix and just_machine_suffix. */
3131
3132	static void
3133	add_prefix (struct path_prefix *pprefix, const char *prefix,
3134	const char *component, /* enum prefix_priority */ int priority,
3135	int require_machine_suffix, int os_multilib)
3136	{
3137	struct prefix_list *pl, **prev;
3138	int len;
3139
3140	for (prev = &pprefix->plist;
3141	(*prev) != NULL && (*prev)->priority <= priority;
3142	prev = &(*prev)->next)
3143	;
3144
3145	/* Keep track of the longest prefix. */
3146
3147	prefix = update_path (path: prefix, key: component);
3148	len = strlen (s: prefix);
3149	if (len > pprefix->max_len)
3150	pprefix->max_len = len;
3151
3152	pl = XNEW (struct prefix_list);
3153	pl->prefix = prefix;
3154	pl->require_machine_suffix = require_machine_suffix;
3155	pl->priority = priority;
3156	pl->os_multilib = os_multilib;
3157
3158	/* Insert after PREV. */
3159	pl->next = (*prev);
3160	(*prev) = pl;
3161	}
3162
3163	/* Same as add_prefix, but prepending target_system_root to prefix. */
3164	/* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3165	static void
3166	add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
3167	const char *component,
3168	/* enum prefix_priority */ int priority,
3169	int require_machine_suffix, int os_multilib)
3170	{
3171	if (!IS_ABSOLUTE_PATH (prefix))
3172	fatal_error (input_location, "system path %qs is not absolute", prefix);
3173
3174	if (target_system_root)
3175	{
3176	char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3177	size_t sysroot_len = strlen (s: target_system_root);
3178
3179	if (sysroot_len > 0
3180	&& target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
3181	sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
3182
3183	if (target_sysroot_suffix)
3184	prefix = concat (sysroot_no_trailing_dir_separator,
3185	target_sysroot_suffix, prefix, NULL);
3186	else
3187	prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3188
3189	free (ptr: sysroot_no_trailing_dir_separator);
3190
3191	/* We have to override this because GCC's notion of sysroot
3192	moves along with GCC. */
3193	component = "GCC";
3194	}
3195
3196	add_prefix (pprefix, prefix, component, priority,
3197	require_machine_suffix, os_multilib);
3198	}
3199
3200	/* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3201
3202	static void
3203	add_sysrooted_hdrs_prefix (struct path_prefix *pprefix, const char *prefix,
3204	const char *component,
3205	/* enum prefix_priority */ int priority,
3206	int require_machine_suffix, int os_multilib)
3207	{
3208	if (!IS_ABSOLUTE_PATH (prefix))
3209	fatal_error (input_location, "system path %qs is not absolute", prefix);
3210
3211	if (target_system_root)
3212	{
3213	char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3214	size_t sysroot_len = strlen (s: target_system_root);
3215
3216	if (sysroot_len > 0
3217	&& target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
3218	sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
3219
3220	if (target_sysroot_hdrs_suffix)
3221	prefix = concat (sysroot_no_trailing_dir_separator,
3222	target_sysroot_hdrs_suffix, prefix, NULL);
3223	else
3224	prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3225
3226	free (ptr: sysroot_no_trailing_dir_separator);
3227
3228	/* We have to override this because GCC's notion of sysroot
3229	moves along with GCC. */
3230	component = "GCC";
3231	}
3232
3233	add_prefix (pprefix, prefix, component, priority,
3234	require_machine_suffix, os_multilib);
3235	}
3236
3237
3238	/* Execute the command specified by the arguments on the current line of spec.
3239	When using pipes, this includes several piped-together commands
3240	with `|' between them.
3241
3242	Return 0 if successful, -1 if failed. */
3243
3244	static int
3245	execute (void)
3246	{
3247	int i;
3248	int n_commands; /* # of command. */
3249	char *string;
3250	struct pex_obj *pex;
3251	struct command
3252	{
3253	const char *prog; /* program name. */
3254	const char **argv; /* vector of args. */
3255	};
3256	const char *arg;
3257
3258	struct command *commands; /* each command buffer with above info. */
3259
3260	gcc_assert (!processing_spec_function);
3261
3262	if (wrapper_string)
3263	{
3264	string = find_a_program (name: argbuf[0]);
3265	if (string)
3266	argbuf[0] = string;
3267	insert_wrapper (wrapper_string);
3268	}
3269
3270	/* Count # of piped commands. */
3271	for (n_commands = 1, i = 0; argbuf.iterate (ix: i, ptr: &arg); i++)
3272	if (strcmp (s1: arg, s2: "|") == 0)
3273	n_commands++;
3274
3275	/* Get storage for each command. */
3276	commands = XALLOCAVEC (struct command, n_commands);
3277
3278	/* Split argbuf into its separate piped processes,
3279	and record info about each one.
3280	Also search for the programs that are to be run. */
3281
3282	argbuf.safe_push (obj: 0);
3283
3284	commands[0].prog = argbuf[0]; /* first command. */
3285	commands[0].argv = argbuf.address ();
3286
3287	if (!wrapper_string)
3288	{
3289	string = find_a_program(name: commands[0].prog);
3290	if (string)
3291	commands[0].argv[0] = string;
3292	}
3293
3294	for (n_commands = 1, i = 0; argbuf.iterate (ix: i, ptr: &arg); i++)
3295	if (arg && strcmp (s1: arg, s2: "|") == 0)
3296	{ /* each command. */
3297	#if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3298	fatal_error (input_location, "%<-pipe%> not supported");
3299	#endif
3300	argbuf[i] = 0; /* Termination of command args. */
3301	commands[n_commands].prog = argbuf[i + 1];
3302	commands[n_commands].argv
3303	= &(argbuf.address ())[i + 1];
3304	string = find_a_program(name: commands[n_commands].prog);
3305	if (string)
3306	commands[n_commands].argv[0] = string;
3307	n_commands++;
3308	}
3309
3310	/* If -v, print what we are about to do, and maybe query. */
3311
3312	if (verbose_flag)
3313	{
3314	/* For help listings, put a blank line between sub-processes. */
3315	if (print_help_list)
3316	fputc (c: '\n', stderr);
3317
3318	/* Print each piped command as a separate line. */
3319	for (i = 0; i < n_commands; i++)
3320	{
3321	const char *const *j;
3322
3323	if (verbose_only_flag)
3324	{
3325	for (j = commands[i].argv; *j; j++)
3326	{
3327	const char *p;
3328	for (p = *j; *p; ++p)
3329	if (!ISALNUM ((unsigned char) *p)
3330	&& *p != '_' && *p != '/' && *p != '-' && *p != '.')
3331	break;
3332	if (*p || !*j)
3333	{
3334	fprintf (stderr, format: " \"");
3335	for (p = *j; *p; ++p)
3336	{
3337	if (*p == '"' || *p == '\\' || *p == '$')
3338	fputc (c: '\\', stderr);
3339	fputc (c: *p, stderr);
3340	}
3341	fputc (c: '"', stderr);
3342	}
3343	/* If it's empty, print "". */
3344	else if (!**j)
3345	fprintf (stderr, format: " \"\"");
3346	else
3347	fprintf (stderr, format: " %s", *j);
3348	}
3349	}
3350	else
3351	for (j = commands[i].argv; *j; j++)
3352	/* If it's empty, print "". */
3353	if (!**j)
3354	fprintf (stderr, format: " \"\"");
3355	else
3356	fprintf (stderr, format: " %s", *j);
3357
3358	/* Print a pipe symbol after all but the last command. */
3359	if (i + 1 != n_commands)
3360	fprintf (stderr, format: " |");
3361	fprintf (stderr, format: "\n");
3362	}
3363	fflush (stderr);
3364	if (verbose_only_flag != 0)
3365	{
3366	/* verbose_only_flag should act as if the spec was
3367	executed, so increment execution_count before
3368	returning. This prevents spurious warnings about
3369	unused linker input files, etc. */
3370	execution_count++;
3371	return 0;
3372	}
3373	#ifdef DEBUG
3374	fnotice (stderr, "\nGo ahead? (y or n) ");
3375	fflush (stderr);
3376	i = getchar ();
3377	if (i != '\n')
3378	while (getchar () != '\n')
3379	;
3380
3381	if (i != 'y' && i != 'Y')
3382	return 0;
3383	#endif /* DEBUG */
3384	}
3385
3386	#ifdef ENABLE_VALGRIND_CHECKING
3387	/* Run the each command through valgrind. To simplify prepending the
3388	path to valgrind and the option "-q" (for quiet operation unless
3389	something triggers), we allocate a separate argv array. */
3390
3391	for (i = 0; i < n_commands; i++)
3392	{
3393	const char **argv;
3394	int argc;
3395	int j;
3396
3397	for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3398	;
3399
3400	argv = XALLOCAVEC (const char *, argc + 3);
3401
3402	argv[0] = VALGRIND_PATH;
3403	argv[1] = "-q";
3404	for (j = 2; j < argc + 2; j++)
3405	argv[j] = commands[i].argv[j - 2];
3406	argv[j] = NULL;
3407
3408	commands[i].argv = argv;
3409	commands[i].prog = argv[0];
3410	}
3411	#endif
3412
3413	/* Run each piped subprocess. */
3414
3415	pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3416	? PEX_RECORD_TIMES : 0),
3417	pname: progname, tempbase: temp_filename);
3418	if (pex == NULL)
3419	fatal_error (input_location, "%<pex_init%> failed: %m");
3420
3421	for (i = 0; i < n_commands; i++)
3422	{
3423	const char *errmsg;
3424	int err;
3425	const char *string = commands[i].argv[0];
3426
3427	errmsg = pex_run (obj: pex,
3428	flags: ((i + 1 == n_commands ? PEX_LAST : 0)
3429	| (string == commands[i].prog ? PEX_SEARCH : 0)),
3430	executable: string, CONST_CAST (char **, commands[i].argv),
3431	NULL, NULL, err: &err);
3432	if (errmsg != NULL)
3433	{
3434	errno = err;
3435	fatal_error (input_location,
3436	err ? G_("cannot execute %qs: %s: %m")
3437	: G_("cannot execute %qs: %s"),
3438	string, errmsg);
3439	}
3440
3441	if (i && string != commands[i].prog)
3442	free (CONST_CAST (char *, string));
3443	}
3444
3445	execution_count++;
3446
3447	/* Wait for all the subprocesses to finish. */
3448
3449	{
3450	int *statuses;
3451	struct pex_time *times = NULL;
3452	int ret_code = 0;
3453
3454	statuses = XALLOCAVEC (int, n_commands);
3455	if (!pex_get_status (pex, count: n_commands, vector: statuses))
3456	fatal_error (input_location, "failed to get exit status: %m");
3457
3458	if (report_times || report_times_to_file)
3459	{
3460	times = XALLOCAVEC (struct pex_time, n_commands);
3461	if (!pex_get_times (pex, count: n_commands, vector: times))
3462	fatal_error (input_location, "failed to get process times: %m");
3463	}
3464
3465	pex_free (pex);
3466
3467	for (i = 0; i < n_commands; ++i)
3468	{
3469	int status = statuses[i];
3470
3471	if (WIFSIGNALED (status))
3472	switch (WTERMSIG (status))
3473	{
3474	case SIGINT:
3475	case SIGTERM:
3476	/* SIGQUIT and SIGKILL are not available on MinGW. */
3477	#ifdef SIGQUIT
3478	case SIGQUIT:
3479	#endif
3480	#ifdef SIGKILL
3481	case SIGKILL:
3482	#endif
3483	/* The user (or environment) did something to the
3484	inferior. Making this an ICE confuses the user into
3485	thinking there's a compiler bug. Much more likely is
3486	the user or OOM killer nuked it. */
3487	fatal_error (input_location,
3488	"%s signal terminated program %s",
3489	strsignal (WTERMSIG (status)),
3490	commands[i].prog);
3491	break;
3492
3493	#ifdef SIGPIPE
3494	case SIGPIPE:
3495	/* SIGPIPE is a special case. It happens in -pipe mode
3496	when the compiler dies before the preprocessor is
3497	done, or the assembler dies before the compiler is
3498	done. There's generally been an error already, and
3499	this is just fallout. So don't generate another
3500	error unless we would otherwise have succeeded. */
3501	if (signal_count || greatest_status >= MIN_FATAL_STATUS)
3502	{
3503	signal_count++;
3504	ret_code = -1;
3505	break;
3506	}
3507	#endif
3508	/* FALLTHROUGH */
3509
3510	default:
3511	/* The inferior failed to catch the signal. */
3512	internal_error_no_backtrace ("%s signal terminated program %s",
3513	strsignal (WTERMSIG (status)),
3514	commands[i].prog);
3515	}
3516	else if (WIFEXITED (status)
3517	&& WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3518	{
3519	/* For ICEs in cc1, cc1obj, cc1plus see if it is
3520	reproducible or not. */
3521	const char *p;
3522	if (flag_report_bug
3523	&& WEXITSTATUS (status) == ICE_EXIT_CODE
3524	&& i == 0
3525	&& (p = strrchr (s: commands[0].argv[0], DIR_SEPARATOR))
3526	&& startswith (str: p + 1, prefix: "cc1"))
3527	try_generate_repro (argv: commands[0].argv);
3528	if (WEXITSTATUS (status) > greatest_status)
3529	greatest_status = WEXITSTATUS (status);
3530	ret_code = -1;
3531	}
3532
3533	if (report_times || report_times_to_file)
3534	{
3535	struct pex_time *pt = &times[i];
3536	double ut, st;
3537
3538	ut = ((double) pt->user_seconds
3539	+ (double) pt->user_microseconds / 1.0e6);
3540	st = ((double) pt->system_seconds
3541	+ (double) pt->system_microseconds / 1.0e6);
3542
3543	if (ut + st != 0)
3544	{
3545	if (report_times)
3546	fnotice (stderr, "# %s %.2f %.2f\n",
3547	commands[i].prog, ut, st);
3548
3549	if (report_times_to_file)
3550	{
3551	int c = 0;
3552	const char *const *j;
3553
3554	fprintf (stream: report_times_to_file, format: "%g %g", ut, st);
3555
3556	for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3557	{
3558	const char *p;
3559	for (p = *j; *p; ++p)
3560	if (*p == '"' || *p == '\\' || *p == '$'
3561	|| ISSPACE (*p))
3562	break;
3563
3564	if (*p)
3565	{
3566	fprintf (stream: report_times_to_file, format: " \"");
3567	for (p = *j; *p; ++p)
3568	{
3569	if (*p == '"' || *p == '\\' || *p == '$')
3570	fputc (c: '\\', stream: report_times_to_file);
3571	fputc (c: *p, stream: report_times_to_file);
3572	}
3573	fputc (c: '"', stream: report_times_to_file);
3574	}
3575	else
3576	fprintf (stream: report_times_to_file, format: " %s", *j);
3577	}
3578
3579	fputc (c: '\n', stream: report_times_to_file);
3580	}
3581	}
3582	}
3583	}
3584
3585	if (commands[0].argv[0] != commands[0].prog)
3586	free (CONST_CAST (char *, commands[0].argv[0]));
3587
3588	return ret_code;
3589	}
3590	}
3591
3592	static struct switchstr *switches;
3593
3594	static int n_switches;
3595
3596	static int n_switches_alloc;
3597
3598	/* Set to zero if -fcompare-debug is disabled, positive if it's
3599	enabled and we're running the first compilation, negative if it's
3600	enabled and we're running the second compilation. For most of the
3601	time, it's in the range -1..1, but it can be temporarily set to 2
3602	or 3 to indicate that the -fcompare-debug flags didn't come from
3603	the command-line, but rather from the GCC_COMPARE_DEBUG environment
3604	variable, until a synthesized -fcompare-debug flag is added to the
3605	command line. */
3606	int compare_debug;
3607
3608	/* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3609	int compare_debug_second;
3610
3611	/* Set to the flags that should be passed to the second compilation in
3612	a -fcompare-debug compilation. */
3613	const char *compare_debug_opt;
3614
3615	static struct switchstr *switches_debug_check[2];
3616
3617	static int n_switches_debug_check[2];
3618
3619	static int n_switches_alloc_debug_check[2];
3620
3621	static char *debug_check_temp_file[2];
3622
3623	/* Language is one of three things:
3624
3625	1) The name of a real programming language.
3626	2) NULL, indicating that no one has figured out
3627	what it is yet.
3628	3) '*', indicating that the file should be passed
3629	to the linker. */
3630	struct infile
3631	{
3632	const char *name;
3633	const char *language;
3634	struct compiler *incompiler;
3635	bool compiled;
3636	bool preprocessed;
3637	};
3638
3639	/* Also a vector of input files specified. */
3640
3641	static struct infile *infiles;
3642
3643	int n_infiles;
3644
3645	static int n_infiles_alloc;
3646
3647	/* True if undefined environment variables encountered during spec processing
3648	are ok to ignore, typically when we're running for --help or --version. */
3649
3650	static bool spec_undefvar_allowed;
3651
3652	/* True if multiple input files are being compiled to a single
3653	assembly file. */
3654
3655	static bool combine_inputs;
3656
3657	/* This counts the number of libraries added by lang_specific_driver, so that
3658	we can tell if there were any user supplied any files or libraries. */
3659
3660	static int added_libraries;
3661
3662	/* And a vector of corresponding output files is made up later. */
3663
3664	const char **outfiles;
3665
3666	#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3667
3668	/* Convert NAME to a new name if it is the standard suffix. DO_EXE
3669	is true if we should look for an executable suffix. DO_OBJ
3670	is true if we should look for an object suffix. */
3671
3672	static const char *
3673	convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3674	int do_obj ATTRIBUTE_UNUSED)
3675	{
3676	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3677	int i;
3678	#endif
3679	int len;
3680
3681	if (name == NULL)
3682	return NULL;
3683
3684	len = strlen (name);
3685
3686	#ifdef HAVE_TARGET_OBJECT_SUFFIX
3687	/* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3688	if (do_obj && len > 2
3689	&& name[len - 2] == '.'
3690	&& name[len - 1] == 'o')
3691	{
3692	obstack_grow (&obstack, name, len - 2);
3693	obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3694	name = XOBFINISH (&obstack, const char *);
3695	}
3696	#endif
3697
3698	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3699	/* If there is no filetype, make it the executable suffix (which includes
3700	the "."). But don't get confused if we have just "-o". */
3701	if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || not_actual_file_p (name))
3702	return name;
3703
3704	for (i = len - 1; i >= 0; i--)
3705	if (IS_DIR_SEPARATOR (name[i]))
3706	break;
3707
3708	for (i++; i < len; i++)
3709	if (name[i] == '.')
3710	return name;
3711
3712	obstack_grow (&obstack, name, len);
3713	obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3714	strlen (TARGET_EXECUTABLE_SUFFIX));
3715	name = XOBFINISH (&obstack, const char *);
3716	#endif
3717
3718	return name;
3719	}
3720	#endif
3721
3722	/* Display the command line switches accepted by gcc. */
3723	static void
3724	display_help (void)
3725	{
3726	printf (_("Usage: %s [options] file...\n"), progname);
3727	fputs (_("Options:\n"), stdout);
3728
3729	fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout);
3730	fputs (_(" --help Display this information.\n"), stdout);
3731	fputs (_(" --target-help Display target specific command line options "
3732	"(including assembler and linker options).\n"), stdout);
3733	fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout);
3734	fputs (_(" Display specific types of command line options.\n"), stdout);
3735	if (! verbose_flag)
3736	fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
3737	fputs (_(" --version Display compiler version information.\n"), stdout);
3738	fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout);
3739	fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout);
3740	fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout);
3741	fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout);
3742	fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout);
3743	fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout);
3744	fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout);
3745	fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout);
3746	fputs (_("\
3747	-print-multiarch Display the target's normalized GNU triplet, used as\n\
3748	a component in the library path.\n"), stdout);
3749	fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout);
3750	fputs (_("\
3751	-print-multi-lib Display the mapping between command line options and\n\
3752	multiple library search directories.\n"), stdout);
3753	fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
3754	fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout);
3755	fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
3756	fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout);
3757	fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout);
3758	fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout);
3759	fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout);
3760	fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout);
3761	fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout);
3762	fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout);
3763	fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout);
3764	fputs (_("\
3765	-no-canonical-prefixes Do not canonicalize paths when building relative\n\
3766	prefixes to other gcc components.\n"), stdout);
3767	fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout);
3768	fputs (_(" -time Time the execution of each subprocess.\n"), stdout);
3769	fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout);
3770	fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout);
3771	fputs (_("\
3772	--sysroot=<directory> Use <directory> as the root directory for headers\n\
3773	and libraries.\n"), stdout);
3774	fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout);
3775	fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout);
3776	fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout);
3777	fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout);
3778	fputs (_(" -S Compile only; do not assemble or link.\n"), stdout);
3779	fputs (_(" -c Compile and assemble, but do not link.\n"), stdout);
3780	fputs (_(" -o <file> Place the output into <file>.\n"), stdout);
3781	fputs (_(" -pie Create a dynamically linked position independent\n\
3782	executable.\n"), stdout);
3783	fputs (_(" -shared Create a shared library.\n"), stdout);
3784	fputs (_("\
3785	-x <language> Specify the language of the following input files.\n\
3786	Permissible languages include: c c++ assembler none\n\
3787	'none' means revert to the default behavior of\n\
3788	guessing the language based on the file's extension.\n\
3789	"), stdout);
3790
3791	printf (_("\
3792	\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3793	passed on to the various sub-processes invoked by %s. In order to pass\n\
3794	other options on to these processes the -W<letter> options must be used.\n\
3795	"), progname);
3796
3797	/* The rest of the options are displayed by invocations of the various
3798	sub-processes. */
3799	}
3800
3801	static void
3802	add_preprocessor_option (const char *option, int len)
3803	{
3804	preprocessor_options.safe_push (obj: save_string (option, len));
3805	}
3806
3807	static void
3808	add_assembler_option (const char *option, int len)
3809	{
3810	assembler_options.safe_push (obj: save_string (option, len));
3811	}
3812
3813	static void
3814	add_linker_option (const char *option, int len)
3815	{
3816	linker_options.safe_push (obj: save_string (option, len));
3817	}
3818
3819	/* Allocate space for an input file in infiles. */
3820
3821	static void
3822	alloc_infile (void)
3823	{
3824	if (n_infiles_alloc == 0)
3825	{
3826	n_infiles_alloc = 16;
3827	infiles = XNEWVEC (struct infile, n_infiles_alloc);
3828	}
3829	else if (n_infiles_alloc == n_infiles)
3830	{
3831	n_infiles_alloc *= 2;
3832	infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3833	}
3834	}
3835
3836	/* Store an input file with the given NAME and LANGUAGE in
3837	infiles. */
3838
3839	static void
3840	add_infile (const char *name, const char *language)
3841	{
3842	alloc_infile ();
3843	infiles[n_infiles].name = name;
3844	infiles[n_infiles++].language = language;
3845	}
3846
3847	/* Allocate space for a switch in switches. */
3848
3849	static void
3850	alloc_switch (void)
3851	{
3852	if (n_switches_alloc == 0)
3853	{
3854	n_switches_alloc = 16;
3855	switches = XNEWVEC (struct switchstr, n_switches_alloc);
3856	}
3857	else if (n_switches_alloc == n_switches)
3858	{
3859	n_switches_alloc *= 2;
3860	switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3861	}
3862	}
3863
3864	/* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3865	as validated if VALIDATED and KNOWN if it is an internal switch. */
3866
3867	static void
3868	save_switch (const char *opt, size_t n_args, const char *const *args,
3869	bool validated, bool known)
3870	{
3871	alloc_switch ();
3872	switches[n_switches].part1 = opt + 1;
3873	if (n_args == 0)
3874	switches[n_switches].args = 0;
3875	else
3876	{
3877	switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3878	memcpy (dest: switches[n_switches].args, src: args, n: n_args * sizeof (const char *));
3879	switches[n_switches].args[n_args] = NULL;
3880	}
3881
3882	switches[n_switches].live_cond = 0;
3883	switches[n_switches].validated = validated;
3884	switches[n_switches].known = known;
3885	switches[n_switches].ordering = 0;
3886	n_switches++;
3887	}
3888
3889	/* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3890	not set already. */
3891
3892	static void
3893	set_source_date_epoch_envvar ()
3894	{
3895	/* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3896	of 64 bit integers. */
3897	char source_date_epoch[21];
3898	time_t tt;
3899
3900	errno = 0;
3901	tt = time (NULL);
3902	if (tt < (time_t) 0 || errno != 0)
3903	tt = (time_t) 0;
3904
3905	snprintf (s: source_date_epoch, maxlen: 21, format: "%llu", (unsigned long long) tt);
3906	/* Using setenv instead of xputenv because we want the variable to remain
3907	after finalizing so that it's still set in the second run when using
3908	-fcompare-debug. */
3909	setenv (name: "SOURCE_DATE_EPOCH", value: source_date_epoch, replace: 0);
3910	}
3911
3912	/* Handle an option DECODED that is unknown to the option-processing
3913	machinery. */
3914
3915	static bool
3916	driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3917	{
3918	const char *opt = decoded->arg;
3919	if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3920	&& !(decoded->errors & CL_ERR_NEGATIVE))
3921	{
3922	/* Leave unknown -Wno-* options for the compiler proper, to be
3923	diagnosed only if there are warnings. */
3924	save_switch (opt: decoded->canonical_option[0],
3925	n_args: decoded->canonical_option_num_elements - 1,
3926	args: &decoded->canonical_option[1], validated: false, known: true);
3927	return false;
3928	}
3929	if (decoded->opt_index == OPT_SPECIAL_unknown)
3930	{
3931	/* Give it a chance to define it a spec file. */
3932	save_switch (opt: decoded->canonical_option[0],
3933	n_args: decoded->canonical_option_num_elements - 1,
3934	args: &decoded->canonical_option[1], validated: false, known: false);
3935	return false;
3936	}
3937	else
3938	return true;
3939	}
3940
3941	/* Handle an option DECODED that is not marked as CL_DRIVER.
3942	LANG_MASK will always be CL_DRIVER. */
3943
3944	static void
3945	driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3946	unsigned int lang_mask ATTRIBUTE_UNUSED)
3947	{
3948	/* At this point, non-driver options are accepted (and expected to
3949	be passed down by specs) unless marked to be rejected by the
3950	driver. Options to be rejected by the driver but accepted by the
3951	compilers proper are treated just like completely unknown
3952	options. */
3953	const struct cl_option *option = &cl_options[decoded->opt_index];
3954
3955	if (option->cl_reject_driver)
3956	error ("unrecognized command-line option %qs",
3957	decoded->orig_option_with_args_text);
3958	else
3959	save_switch (opt: decoded->canonical_option[0],
3960	n_args: decoded->canonical_option_num_elements - 1,
3961	args: &decoded->canonical_option[1], validated: false, known: true);
3962	}
3963
3964	static const char *spec_lang = 0;
3965	static int last_language_n_infiles;
3966
3967
3968	/* Check that GCC is configured to support the offload target. */
3969
3970	static bool
3971	check_offload_target_name (const char *target, ptrdiff_t len)
3972	{
3973	const char *n, *c = OFFLOAD_TARGETS;
3974	while (c)
3975	{
3976	n = strchr (s: c, c: ',');
3977	if (n == NULL)
3978	n = strchr (s: c, c: '\0');
3979	if (len == n - c && strncmp (s1: target, s2: c, n: n - c) == 0)
3980	break;
3981	c = *n ? n + 1 : NULL;
3982	}
3983	if (!c)
3984	{
3985	auto_vec<const char*> candidates;
3986	size_t olen = strlen (OFFLOAD_TARGETS) + 1;
3987	char *cand = XALLOCAVEC (char, olen);
3988	memcpy (dest: cand, OFFLOAD_TARGETS, n: olen);
3989	for (c = strtok (s: cand, delim: ","); c; c = strtok (NULL, delim: ","))
3990	candidates.safe_push (obj: c);
3991	candidates.safe_push (obj: "default");
3992	candidates.safe_push (obj: "disable");
3993
3994	char *target2 = XALLOCAVEC (char, len + 1);
3995	memcpy (dest: target2, src: target, n: len);
3996	target2[len] = '\0';
3997
3998	error ("GCC is not configured to support %qs as %<-foffload=%> argument",
3999	target2);
4000
4001	char *s;
4002	const char *hint = candidates_list_and_hint (arg: target2, str&: s, candidates);
4003	if (hint)
4004	inform (UNKNOWN_LOCATION,
4005	"valid %<-foffload=%> arguments are: %s; "
4006	"did you mean %qs?", s, hint);
4007	else
4008	inform (UNKNOWN_LOCATION, "valid %<-foffload=%> arguments are: %s", s);
4009	XDELETEVEC (s);
4010	return false;
4011	}
4012	return true;
4013	}
4014
4015	/* Sanity check for -foffload-options. */
4016
4017	static void
4018	check_foffload_target_names (const char *arg)
4019	{
4020	const char *cur, *next, *end;
4021	/* If option argument starts with '-' then no target is specified and we
4022	do not need to parse it. */
4023	if (arg[0] == '-')
4024	return;
4025	end = strchr (s: arg, c: '=');
4026	if (end == NULL)
4027	{
4028	error ("%<=%>options missing after %<-foffload-options=%>target");
4029	return;
4030	}
4031
4032	cur = arg;
4033	while (cur < end)
4034	{
4035	next = strchr (s: cur, c: ',');
4036	if (next == NULL)
4037	next = end;
4038	next = (next > end) ? end : next;
4039
4040	/* Retain non-supported targets after printing an error as those will not
4041	be processed; each enabled target only processes its triplet. */
4042	check_offload_target_name (target: cur, len: next - cur);
4043	cur = next + 1;
4044	}
4045	}
4046
4047	/* Parse -foffload option argument. */
4048
4049	static void
4050	handle_foffload_option (const char *arg)
4051	{
4052	const char *c, *cur, *n, *next, *end;
4053	char *target;
4054
4055	/* If option argument starts with '-' then no target is specified and we
4056	do not need to parse it. */
4057	if (arg[0] == '-')
4058	return;
4059
4060	end = strchr (s: arg, c: '=');
4061	if (end == NULL)
4062	end = strchr (s: arg, c: '\0');
4063	cur = arg;
4064
4065	while (cur < end)
4066	{
4067	next = strchr (s: cur, c: ',');
4068	if (next == NULL)
4069	next = end;
4070	next = (next > end) ? end : next;
4071
4072	target = XNEWVEC (char, next - cur + 1);
4073	memcpy (dest: target, src: cur, n: next - cur);
4074	target[next - cur] = '\0';
4075
4076	/* Reset offloading list and continue. */
4077	if (strcmp (s1: target, s2: "default") == 0)
4078	{
4079	free (ptr: offload_targets);
4080	offload_targets = NULL;
4081	goto next_item;
4082	}
4083
4084	/* If 'disable' is passed to the option, clean the list of
4085	offload targets and return, even if more targets follow.
4086	Likewise if GCC is not configured to support that offload target. */
4087	if (strcmp (s1: target, s2: "disable") == 0
4088	|| !check_offload_target_name (target, len: next - cur))
4089	{
4090	free (ptr: offload_targets);
4091	offload_targets = xstrdup ("");
4092	return;
4093	}
4094
4095	if (!offload_targets)
4096	{
4097	offload_targets = target;
4098	target = NULL;
4099	}
4100	else
4101	{
4102	/* Check that the target hasn't already presented in the list. */
4103	c = offload_targets;
4104	do
4105	{
4106	n = strchr (s: c, c: ':');
4107	if (n == NULL)
4108	n = strchr (s: c, c: '\0');
4109
4110	if (next - cur == n - c && strncmp (s1: c, s2: target, n: n - c) == 0)
4111	break;
4112
4113	c = n + 1;
4114	}
4115	while (*n);
4116
4117	/* If duplicate is not found, append the target to the list. */
4118	if (c > n)
4119	{
4120	size_t offload_targets_len = strlen (s: offload_targets);
4121	offload_targets
4122	= XRESIZEVEC (char, offload_targets,
4123	offload_targets_len + 1 + next - cur + 1);
4124	offload_targets[offload_targets_len++] = ':';
4125	memcpy (dest: offload_targets + offload_targets_len, src: target, n: next - cur + 1);
4126	}
4127	}
4128	next_item:
4129	cur = next + 1;
4130	XDELETEVEC (target);
4131	}
4132	}
4133
4134	/* Forward certain options to offloading compilation. */
4135
4136	static void
4137	forward_offload_option (size_t opt_index, const char *arg, bool validated)
4138	{
4139	switch (opt_index)
4140	{
4141	case OPT_l:
4142	/* Use a '_GCC_' prefix and standard name ('-l_GCC_m' irrespective of the
4143	host's 'MATH_LIBRARY', for example), so that the 'mkoffload's can tell
4144	this has been synthesized here, and translate/drop as necessary. */
4145	/* Note that certain libraries ('-lc', '-lgcc', '-lgomp', for example)
4146	are injected by default in offloading compilation, and therefore not
4147	forwarded here. */
4148	/* GCC libraries. */
4149	if (/* '-lgfortran' */ strcmp (s1: arg, s2: "gfortran") == 0 )
4150	save_switch (opt: concat ("-foffload-options=-l_GCC_", arg, NULL),
4151	n_args: 0, NULL, validated, known: true);
4152	/* Other libraries. */
4153	else
4154	{
4155	/* The case will need special consideration where on the host
4156	'!need_math', but for offloading compilation still need
4157	'-foffload-options=-l_GCC_m'. The problem is that we don't get
4158	here anything like '-lm', because it's not synthesized in
4159	'gcc/fortran/gfortranspec.cc:lang_specific_driver', for example.
4160	Generally synthesizing '-foffload-options=-l_GCC_m' etc. in the
4161	language specific drivers is non-trivial, needs very careful
4162	review of their options handling. However, this issue is not
4163	actually relevant for the current set of supported host/offloading
4164	configurations. */
4165	int need_math = (MATH_LIBRARY[0] != '\0');
4166	if (/* '-lm' */ (need_math && strcmp (s1: arg, MATH_LIBRARY) == 0))
4167	save_switch (opt: "-foffload-options=-l_GCC_m",
4168	n_args: 0, NULL, validated, known: true);
4169	}
4170	break;
4171	default:
4172	gcc_unreachable ();
4173	}
4174	}
4175
4176	/* Handle a driver option; arguments and return value as for
4177	handle_option. */
4178
4179	static bool
4180	driver_handle_option (struct gcc_options *opts,
4181	struct gcc_options *opts_set,
4182	const struct cl_decoded_option *decoded,
4183	unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
4184	location_t loc,
4185	const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
4186	diagnostic_context *dc,
4187	void (*) (void))
4188	{
4189	size_t opt_index = decoded->opt_index;
4190	const char *arg = decoded->arg;
4191	const char *compare_debug_replacement_opt;
4192	int value = decoded->value;
4193	bool validated = false;
4194	bool do_save = true;
4195
4196	gcc_assert (opts == &global_options);
4197	gcc_assert (opts_set == &global_options_set);
4198	gcc_assert (kind == DK_UNSPECIFIED);
4199	gcc_assert (loc == UNKNOWN_LOCATION);
4200	gcc_assert (dc == global_dc);
4201
4202	switch (opt_index)
4203	{
4204	case OPT_dumpspecs:
4205	{
4206	struct spec_list *sl;
4207	init_spec ();
4208	for (sl = specs; sl; sl = sl->next)
4209	printf (format: "*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
4210	if (link_command_spec)
4211	printf (format: "*link_command:\n%s\n\n", link_command_spec);
4212	exit (status: 0);
4213	}
4214
4215	case OPT_dumpversion:
4216	printf (format: "%s\n", spec_version);
4217	exit (status: 0);
4218
4219	case OPT_dumpmachine:
4220	printf (format: "%s\n", spec_machine);
4221	exit (status: 0);
4222
4223	case OPT_dumpfullversion:
4224	printf ("%s\n", BASEVER);
4225	exit (status: 0);
4226
4227	case OPT__version:
4228	print_version = 1;
4229
4230	/* CPP driver cannot obtain switch from cc1_options. */
4231	if (is_cpp_driver)
4232	add_preprocessor_option (option: "--version", len: strlen (s: "--version"));
4233	add_assembler_option (option: "--version", len: strlen (s: "--version"));
4234	add_linker_option (option: "--version", len: strlen (s: "--version"));
4235	break;
4236
4237	case OPT__completion_:
4238	validated = true;
4239	completion = decoded->arg;
4240	break;
4241
4242	case OPT__help:
4243	print_help_list = 1;
4244
4245	/* CPP driver cannot obtain switch from cc1_options. */
4246	if (is_cpp_driver)
4247	add_preprocessor_option (option: "--help", len: 6);
4248	add_assembler_option (option: "--help", len: 6);
4249	add_linker_option (option: "--help", len: 6);
4250	break;
4251
4252	case OPT__help_:
4253	print_subprocess_help = 2;
4254	break;
4255
4256	case OPT__target_help:
4257	print_subprocess_help = 1;
4258
4259	/* CPP driver cannot obtain switch from cc1_options. */
4260	if (is_cpp_driver)
4261	add_preprocessor_option (option: "--target-help", len: 13);
4262	add_assembler_option (option: "--target-help", len: 13);
4263	add_linker_option (option: "--target-help", len: 13);
4264	break;
4265
4266	case OPT__no_sysroot_suffix:
4267	case OPT_pass_exit_codes:
4268	case OPT_print_search_dirs:
4269	case OPT_print_file_name_:
4270	case OPT_print_prog_name_:
4271	case OPT_print_multi_lib:
4272	case OPT_print_multi_directory:
4273	case OPT_print_sysroot:
4274	case OPT_print_multi_os_directory:
4275	case OPT_print_multiarch:
4276	case OPT_print_sysroot_headers_suffix:
4277	case OPT_time:
4278	case OPT_wrapper:
4279	/* These options set the variables specified in common.opt
4280	automatically, and do not need to be saved for spec
4281	processing. */
4282	do_save = false;
4283	break;
4284
4285	case OPT_print_libgcc_file_name:
4286	print_file_name = "libgcc.a";
4287	do_save = false;
4288	break;
4289
4290	case OPT_fuse_ld_bfd:
4291	use_ld = ".bfd";
4292	break;
4293
4294	case OPT_fuse_ld_gold:
4295	use_ld = ".gold";
4296	break;
4297
4298	case OPT_fuse_ld_mold:
4299	use_ld = ".mold";
4300	break;
4301
4302	case OPT_fcompare_debug_second:
4303	compare_debug_second = 1;
4304	break;
4305
4306	case OPT_fcompare_debug:
4307	switch (value)
4308	{
4309	case 0:
4310	compare_debug_replacement_opt = "-fcompare-debug=";
4311	arg = "";
4312	goto compare_debug_with_arg;
4313
4314	case 1:
4315	compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
4316	arg = "-gtoggle";
4317	goto compare_debug_with_arg;
4318
4319	default:
4320	gcc_unreachable ();
4321	}
4322	break;
4323
4324	case OPT_fcompare_debug_:
4325	compare_debug_replacement_opt = decoded->canonical_option[0];
4326	compare_debug_with_arg:
4327	gcc_assert (decoded->canonical_option_num_elements == 1);
4328	gcc_assert (arg != NULL);
4329	if (*arg)
4330	compare_debug = 1;
4331	else
4332	compare_debug = -1;
4333	if (compare_debug < 0)
4334	compare_debug_opt = NULL;
4335	else
4336	compare_debug_opt = arg;
4337	save_switch (opt: compare_debug_replacement_opt, n_args: 0, NULL, validated, known: true);
4338	set_source_date_epoch_envvar ();
4339	return true;
4340
4341	case OPT_fdiagnostics_color_:
4342	diagnostic_color_init (context: dc, value);
4343	break;
4344
4345	case OPT_fdiagnostics_urls_:
4346	diagnostic_urls_init (context: dc, value);
4347	break;
4348
4349	case OPT_fdiagnostics_format_:
4350	{
4351	const char *basename = (opts->x_dump_base_name ? opts->x_dump_base_name
4352	: opts->x_main_input_basename);
4353	diagnostic_output_format_init (dc, base_file_name: basename,
4354	(enum diagnostics_output_format)value,
4355	json_formatting: opts->x_flag_diagnostics_json_formatting);
4356	break;
4357	}
4358
4359	case OPT_fdiagnostics_text_art_charset_:
4360	dc->set_text_art_charset ((enum diagnostic_text_art_charset)value);
4361	break;
4362
4363	case OPT_Wa_:
4364	{
4365	int prev, j;
4366	/* Pass the rest of this option to the assembler. */
4367
4368	/* Split the argument at commas. */
4369	prev = 0;
4370	for (j = 0; arg[j]; j++)
4371	if (arg[j] == ',')
4372	{
4373	add_assembler_option (option: arg + prev, len: j - prev);
4374	prev = j + 1;
4375	}
4376
4377	/* Record the part after the last comma. */
4378	add_assembler_option (option: arg + prev, len: j - prev);
4379	}
4380	do_save = false;
4381	break;
4382
4383	case OPT_Wp_:
4384	{
4385	int prev, j;
4386	/* Pass the rest of this option to the preprocessor. */
4387
4388	/* Split the argument at commas. */
4389	prev = 0;
4390	for (j = 0; arg[j]; j++)
4391	if (arg[j] == ',')
4392	{
4393	add_preprocessor_option (option: arg + prev, len: j - prev);
4394	prev = j + 1;
4395	}
4396
4397	/* Record the part after the last comma. */
4398	add_preprocessor_option (option: arg + prev, len: j - prev);
4399	}
4400	do_save = false;
4401	break;
4402
4403	case OPT_Wl_:
4404	{
4405	int prev, j;
4406	/* Split the argument at commas. */
4407	prev = 0;
4408	for (j = 0; arg[j]; j++)
4409	if (arg[j] == ',')
4410	{
4411	add_infile (name: save_string (arg + prev, j - prev), language: "*");
4412	prev = j + 1;
4413	}
4414	/* Record the part after the last comma. */
4415	add_infile (name: arg + prev, language: "*");
4416	}
4417	do_save = false;
4418	break;
4419
4420	case OPT_Xlinker:
4421	add_infile (name: arg, language: "*");
4422	do_save = false;
4423	break;
4424
4425	case OPT_Xpreprocessor:
4426	add_preprocessor_option (option: arg, len: strlen (s: arg));
4427	do_save = false;
4428	break;
4429
4430	case OPT_Xassembler:
4431	add_assembler_option (option: arg, len: strlen (s: arg));
4432	do_save = false;
4433	break;
4434
4435	case OPT_l:
4436	/* POSIX allows separation of -l and the lib arg; canonicalize
4437	by concatenating -l with its arg */
4438	add_infile (name: concat ("-l", arg, NULL), language: "*");
4439
4440	/* Forward to offloading compilation '-l[...]' flags for standard,
4441	well-known libraries. */
4442	/* Doing this processing here means that we don't get to see libraries
4443	injected via specs, such as '-lquadmath' injected via
4444	'[build]/[target]/libgfortran/libgfortran.spec'. However, this issue
4445	is not actually relevant for the current set of host/offloading
4446	configurations. */
4447	if (ENABLE_OFFLOADING)
4448	forward_offload_option (opt_index, arg, validated);
4449
4450	do_save = false;
4451	break;
4452
4453	case OPT_L:
4454	/* Similarly, canonicalize -L for linkers that may not accept
4455	separate arguments. */
4456	save_switch (opt: concat ("-L", arg, NULL), n_args: 0, NULL, validated, known: true);
4457	return true;
4458
4459	case OPT_F:
4460	/* Likewise -F. */
4461	save_switch (opt: concat ("-F", arg, NULL), n_args: 0, NULL, validated, known: true);
4462	return true;
4463
4464	case OPT_save_temps:
4465	if (!save_temps_flag)
4466	save_temps_flag = SAVE_TEMPS_DUMP;
4467	validated = true;
4468	break;
4469
4470	case OPT_save_temps_:
4471	if (strcmp (s1: arg, s2: "cwd") == 0)
4472	save_temps_flag = SAVE_TEMPS_CWD;
4473	else if (strcmp (s1: arg, s2: "obj") == 0
4474	|| strcmp (s1: arg, s2: "object") == 0)
4475	save_temps_flag = SAVE_TEMPS_OBJ;
4476	else
4477	fatal_error (input_location, "%qs is an unknown %<-save-temps%> option",
4478	decoded->orig_option_with_args_text);
4479	save_temps_overrides_dumpdir = true;
4480	break;
4481
4482	case OPT_dumpdir:
4483	free (ptr: dumpdir);
4484	dumpdir = xstrdup (arg);
4485	save_temps_overrides_dumpdir = false;
4486	break;
4487
4488	case OPT_dumpbase:
4489	free (ptr: dumpbase);
4490	dumpbase = xstrdup (arg);
4491	break;
4492
4493	case OPT_dumpbase_ext:
4494	free (ptr: dumpbase_ext);
4495	dumpbase_ext = xstrdup (arg);
4496	break;
4497
4498	case OPT_no_canonical_prefixes:
4499	/* Already handled as a special case, so ignored here. */
4500	do_save = false;
4501	break;
4502
4503	case OPT_pipe:
4504	validated = true;
4505	/* These options set the variables specified in common.opt
4506	automatically, but do need to be saved for spec
4507	processing. */
4508	break;
4509
4510	case OPT_specs_:
4511	{
4512	struct user_specs *user = XNEW (struct user_specs);
4513
4514	user->next = (struct user_specs *) 0;
4515	user->filename = arg;
4516	if (user_specs_tail)
4517	user_specs_tail->next = user;
4518	else
4519	user_specs_head = user;
4520	user_specs_tail = user;
4521	}
4522	validated = true;
4523	break;
4524
4525	case OPT__sysroot_:
4526	target_system_root = arg;
4527	target_system_root_changed = 1;
4528	/* Saving this option is useful to let self-specs decide to
4529	provide a default one. */
4530	do_save = true;
4531	validated = true;
4532	break;
4533
4534	case OPT_time_:
4535	if (report_times_to_file)
4536	fclose (stream: report_times_to_file);
4537	report_times_to_file = fopen (filename: arg, modes: "a");
4538	do_save = false;
4539	break;
4540
4541	case OPT____:
4542	/* "-###"
4543	This is similar to -v except that there is no execution
4544	of the commands and the echoed arguments are quoted. It
4545	is intended for use in shell scripts to capture the
4546	driver-generated command line. */
4547	verbose_only_flag++;
4548	verbose_flag = 1;
4549	do_save = false;
4550	break;
4551
4552	case OPT_B:
4553	{
4554	size_t len = strlen (s: arg);
4555
4556	/* Catch the case where the user has forgotten to append a
4557	directory separator to the path. Note, they may be using
4558	-B to add an executable name prefix, eg "i386-elf-", in
4559	order to distinguish between multiple installations of
4560	GCC in the same directory. Hence we must check to see
4561	if appending a directory separator actually makes a
4562	valid directory name. */
4563	if (!IS_DIR_SEPARATOR (arg[len - 1])
4564	&& is_directory (arg, false))
4565	{
4566	char *tmp = XNEWVEC (char, len + 2);
4567	strcpy (dest: tmp, src: arg);
4568	tmp[len] = DIR_SEPARATOR;
4569	tmp[++len] = 0;
4570	arg = tmp;
4571	}
4572
4573	add_prefix (pprefix: &exec_prefixes, prefix: arg, NULL,
4574	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: 0, os_multilib: 0);
4575	add_prefix (pprefix: &startfile_prefixes, prefix: arg, NULL,
4576	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: 0, os_multilib: 0);
4577	add_prefix (pprefix: &include_prefixes, prefix: arg, NULL,
4578	priority: PREFIX_PRIORITY_B_OPT, require_machine_suffix: 0, os_multilib: 0);
4579	}
4580	validated = true;
4581	break;
4582
4583	case OPT_E:
4584	have_E = true;
4585	break;
4586
4587	case OPT_x:
4588	spec_lang = arg;
4589	if (!strcmp (s1: spec_lang, s2: "none"))
4590	/* Suppress the warning if -xnone comes after the last input
4591	file, because alternate command interfaces like g++ might
4592	find it useful to place -xnone after each input file. */
4593	spec_lang = 0;
4594	else
4595	last_language_n_infiles = n_infiles;
4596	do_save = false;
4597	break;
4598
4599	case OPT_o:
4600	have_o = 1;
4601	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4602	arg = convert_filename (arg, ! have_c, 0);
4603	#endif
4604	output_file = arg;
4605	/* On some systems, ld cannot handle "-o" without a space. So
4606	split the option from its argument. */
4607	save_switch (opt: "-o", n_args: 1, args: &arg, validated, known: true);
4608	return true;
4609
4610	case OPT_pie:
4611	#ifdef ENABLE_DEFAULT_PIE
4612	/* -pie is turned on by default. */
4613	validated = true;
4614	#endif
4615	/* FALLTHROUGH */
4616	case OPT_r:
4617	case OPT_shared:
4618	case OPT_no_pie:
4619	any_link_options_p = true;
4620	break;
4621
4622	case OPT_static:
4623	static_p = true;
4624	break;
4625
4626	case OPT_static_libgcc:
4627	case OPT_shared_libgcc:
4628	case OPT_static_libgfortran:
4629	case OPT_static_libquadmath:
4630	case OPT_static_libphobos:
4631	case OPT_static_libgm2:
4632	case OPT_static_libstdc__:
4633	/* These are always valid; gcc.cc itself understands the first two
4634	gfortranspec.cc understands -static-libgfortran,
4635	libgfortran.spec handles -static-libquadmath,
4636	d-spec.cc understands -static-libphobos,
4637	gm2spec.cc understands -static-libgm2,
4638	and g++spec.cc understands -static-libstdc++. */
4639	validated = true;
4640	break;
4641
4642	case OPT_fwpa:
4643	flag_wpa = "";
4644	break;
4645
4646	case OPT_foffload_options_:
4647	check_foffload_target_names (arg);
4648	break;
4649
4650	case OPT_foffload_:
4651	handle_foffload_option (arg);
4652	if (arg[0] == '-' || NULL != strchr (s: arg, c: '='))
4653	save_switch (opt: concat ("-foffload-options=", arg, NULL),
4654	n_args: 0, NULL, validated, known: true);
4655	do_save = false;
4656	break;
4657
4658	case OPT_gcodeview:
4659	add_infile (name: "--pdb=", language: "*");
4660	break;
4661
4662	default:
4663	/* Various driver options need no special processing at this
4664	point, having been handled in a prescan above or being
4665	handled by specs. */
4666	break;
4667	}
4668
4669	if (do_save)
4670	save_switch (opt: decoded->canonical_option[0],
4671	n_args: decoded->canonical_option_num_elements - 1,
4672	args: &decoded->canonical_option[1], validated, known: true);
4673	return true;
4674	}
4675
4676	/* Return true if F2 is F1 followed by a single suffix, i.e., by a
4677	period and additional characters other than a period. */
4678
4679	static inline bool
4680	adds_single_suffix_p (const char *f2, const char *f1)
4681	{
4682	size_t len = strlen (s: f1);
4683
4684	return (strncmp (s1: f1, s2: f2, n: len) == 0
4685	&& f2[len] == '.'
4686	&& strchr (s: f2 + len + 1, c: '.') == NULL);
4687	}
4688
4689	/* Put the driver's standard set of option handlers in *HANDLERS. */
4690
4691	static void
4692	set_option_handlers (struct cl_option_handlers *handlers)
4693	{
4694	handlers->unknown_option_callback = driver_unknown_option_callback;
4695	handlers->wrong_lang_callback = driver_wrong_lang_callback;
4696	handlers->num_handlers = 3;
4697	handlers->handlers[0].handler = driver_handle_option;
4698	handlers->handlers[0].mask = CL_DRIVER;
4699	handlers->handlers[1].handler = common_handle_option;
4700	handlers->handlers[1].mask = CL_COMMON;
4701	handlers->handlers[2].handler = target_handle_option;
4702	handlers->handlers[2].mask = CL_TARGET;
4703	}
4704
4705
4706	/* Return the index into infiles for the single non-library
4707	non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4708	more than one. */
4709	static inline int
4710	single_input_file_index ()
4711	{
4712	int ret = -1;
4713
4714	for (int i = 0; i < n_infiles; i++)
4715	{
4716	if (infiles[i].language
4717	&& (infiles[i].language[0] == '*'
4718	|| (flag_wpa
4719	&& strcmp (s1: infiles[i].language, s2: "lto") == 0)))
4720	continue;
4721
4722	if (ret != -1)
4723	return -2;
4724
4725	ret = i;
4726	}
4727
4728	return ret;
4729	}
4730
4731	/* Create the vector `switches' and its contents.
4732	Store its length in `n_switches'. */
4733
4734	static void
4735	process_command (unsigned int decoded_options_count,
4736	struct cl_decoded_option *decoded_options)
4737	{
4738	const char *temp;
4739	char *temp1;
4740	char *tooldir_prefix, *tooldir_prefix2;
4741	char *(*get_relative_prefix) (const char *, const char *,
4742	const char *) = NULL;
4743	struct cl_option_handlers handlers;
4744	unsigned int j;
4745
4746	gcc_exec_prefix = env.get (name: "GCC_EXEC_PREFIX");
4747
4748	n_switches = 0;
4749	n_infiles = 0;
4750	added_libraries = 0;
4751
4752	/* Figure compiler version from version string. */
4753
4754	compiler_version = temp1 = xstrdup (version_string);
4755
4756	for (; *temp1; ++temp1)
4757	{
4758	if (*temp1 == ' ')
4759	{
4760	*temp1 = '\0';
4761	break;
4762	}
4763	}
4764
4765	/* Handle any -no-canonical-prefixes flag early, to assign the function
4766	that builds relative prefixes. This function creates default search
4767	paths that are needed later in normal option handling. */
4768
4769	for (j = 1; j < decoded_options_count; j++)
4770	{
4771	if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
4772	{
4773	get_relative_prefix = make_relative_prefix_ignore_links;
4774	break;
4775	}
4776	}
4777	if (! get_relative_prefix)
4778	get_relative_prefix = make_relative_prefix;
4779
4780	/* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4781	see if we can create it from the pathname specified in
4782	decoded_options[0].arg. */
4783
4784	gcc_libexec_prefix = standard_libexec_prefix;
4785	#ifndef VMS
4786	/* FIXME: make_relative_prefix doesn't yet work for VMS. */
4787	if (!gcc_exec_prefix)
4788	{
4789	gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
4790	standard_bindir_prefix,
4791	standard_exec_prefix);
4792	gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
4793	standard_bindir_prefix,
4794	standard_libexec_prefix);
4795	if (gcc_exec_prefix)
4796	xputenv (string: concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
4797	}
4798	else
4799	{
4800	/* make_relative_prefix requires a program name, but
4801	GCC_EXEC_PREFIX is typically a directory name with a trailing
4802	/ (which is ignored by make_relative_prefix), so append a
4803	program name. */
4804	char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
4805	gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
4806	standard_exec_prefix,
4807	standard_libexec_prefix);
4808
4809	/* The path is unrelocated, so fallback to the original setting. */
4810	if (!gcc_libexec_prefix)
4811	gcc_libexec_prefix = standard_libexec_prefix;
4812
4813	free (ptr: tmp_prefix);
4814	}
4815	#else
4816	#endif
4817	/* From this point onward, gcc_exec_prefix is non-null if the toolchain
4818	is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4819	or an automatically created GCC_EXEC_PREFIX from
4820	decoded_options[0].arg. */
4821
4822	/* Do language-specific adjustment/addition of flags. */
4823	lang_specific_driver (&decoded_options, &decoded_options_count,
4824	&added_libraries);
4825
4826	if (gcc_exec_prefix)
4827	{
4828	int len = strlen (s: gcc_exec_prefix);
4829
4830	if (len > (int) sizeof ("/lib/gcc/") - 1
4831	&& (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
4832	{
4833	temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
4834	if (IS_DIR_SEPARATOR (*temp)
4835	&& filename_ncmp (s1: temp + 1, s2: "lib", n: 3) == 0
4836	&& IS_DIR_SEPARATOR (temp[4])
4837	&& filename_ncmp (s1: temp + 5, s2: "gcc", n: 3) == 0)
4838	len -= sizeof ("/lib/gcc/") - 1;
4839	}
4840
4841	set_std_prefix (gcc_exec_prefix, len);
4842	add_prefix (pprefix: &exec_prefixes, prefix: gcc_libexec_prefix, component: "GCC",
4843	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
4844	add_prefix (pprefix: &startfile_prefixes, prefix: gcc_exec_prefix, component: "GCC",
4845	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
4846	}
4847
4848	/* COMPILER_PATH and LIBRARY_PATH have values
4849	that are lists of directory names with colons. */
4850
4851	temp = env.get (name: "COMPILER_PATH");
4852	if (temp)
4853	{
4854	const char *startp, *endp;
4855	char *nstore = (char *) alloca (strlen (temp) + 3);
4856
4857	startp = endp = temp;
4858	while (1)
4859	{
4860	if (*endp == PATH_SEPARATOR || *endp == 0)
4861	{
4862	strncpy (dest: nstore, src: startp, n: endp - startp);
4863	if (endp == startp)
4864	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4865	else if (!IS_DIR_SEPARATOR (endp[-1]))
4866	{
4867	nstore[endp - startp] = DIR_SEPARATOR;
4868	nstore[endp - startp + 1] = 0;
4869	}
4870	else
4871	nstore[endp - startp] = 0;
4872	add_prefix (pprefix: &exec_prefixes, prefix: nstore, component: 0,
4873	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
4874	add_prefix (pprefix: &include_prefixes, prefix: nstore, component: 0,
4875	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
4876	if (*endp == 0)
4877	break;
4878	endp = startp = endp + 1;
4879	}
4880	else
4881	endp++;
4882	}
4883	}
4884
4885	temp = env.get (LIBRARY_PATH_ENV);
4886	if (temp && *cross_compile == '0')
4887	{
4888	const char *startp, *endp;
4889	char *nstore = (char *) alloca (strlen (temp) + 3);
4890
4891	startp = endp = temp;
4892	while (1)
4893	{
4894	if (*endp == PATH_SEPARATOR || *endp == 0)
4895	{
4896	strncpy (dest: nstore, src: startp, n: endp - startp);
4897	if (endp == startp)
4898	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4899	else if (!IS_DIR_SEPARATOR (endp[-1]))
4900	{
4901	nstore[endp - startp] = DIR_SEPARATOR;
4902	nstore[endp - startp + 1] = 0;
4903	}
4904	else
4905	nstore[endp - startp] = 0;
4906	add_prefix (pprefix: &startfile_prefixes, prefix: nstore, NULL,
4907	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
4908	if (*endp == 0)
4909	break;
4910	endp = startp = endp + 1;
4911	}
4912	else
4913	endp++;
4914	}
4915	}
4916
4917	/* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4918	temp = env.get (name: "LPATH");
4919	if (temp && *cross_compile == '0')
4920	{
4921	const char *startp, *endp;
4922	char *nstore = (char *) alloca (strlen (temp) + 3);
4923
4924	startp = endp = temp;
4925	while (1)
4926	{
4927	if (*endp == PATH_SEPARATOR || *endp == 0)
4928	{
4929	strncpy (dest: nstore, src: startp, n: endp - startp);
4930	if (endp == startp)
4931	strcpy (dest: nstore, src: concat (".", dir_separator_str, NULL));
4932	else if (!IS_DIR_SEPARATOR (endp[-1]))
4933	{
4934	nstore[endp - startp] = DIR_SEPARATOR;
4935	nstore[endp - startp + 1] = 0;
4936	}
4937	else
4938	nstore[endp - startp] = 0;
4939	add_prefix (pprefix: &startfile_prefixes, prefix: nstore, NULL,
4940	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
4941	if (*endp == 0)
4942	break;
4943	endp = startp = endp + 1;
4944	}
4945	else
4946	endp++;
4947	}
4948	}
4949
4950	/* Process the options and store input files and switches in their
4951	vectors. */
4952
4953	last_language_n_infiles = -1;
4954
4955	set_option_handlers (&handlers);
4956
4957	for (j = 1; j < decoded_options_count; j++)
4958	{
4959	switch (decoded_options[j].opt_index)
4960	{
4961	case OPT_S:
4962	case OPT_c:
4963	case OPT_E:
4964	have_c = 1;
4965	break;
4966	}
4967	if (have_c)
4968	break;
4969	}
4970
4971	for (j = 1; j < decoded_options_count; j++)
4972	{
4973	if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
4974	{
4975	const char *arg = decoded_options[j].arg;
4976
4977	#ifdef HAVE_TARGET_OBJECT_SUFFIX
4978	arg = convert_filename (arg, 0, access (arg, F_OK));
4979	#endif
4980	add_infile (name: arg, language: spec_lang);
4981
4982	continue;
4983	}
4984
4985	read_cmdline_option (opts: &global_options, opts_set: &global_options_set,
4986	decoded: decoded_options + j, UNKNOWN_LOCATION,
4987	CL_DRIVER, handlers: &handlers, dc: global_dc);
4988	}
4989
4990	/* If the user didn't specify any, default to all configured offload
4991	targets. */
4992	if (ENABLE_OFFLOADING && offload_targets == NULL)
4993	{
4994	handle_foffload_option (OFFLOAD_TARGETS);
4995	#if OFFLOAD_DEFAULTED
4996	offload_targets_default = true;
4997	#endif
4998	}
4999
5000	/* TODO: check if -static -pie works and maybe use it. */
5001	if (flag_hardened)
5002	{
5003	if (!any_link_options_p && !static_p)
5004	{
5005	#if defined HAVE_LD_PIE && defined LD_PIE_SPEC
5006	save_switch (LD_PIE_SPEC, n_args: 0, NULL, /*validated=*/true, /*known=*/false);
5007	#endif
5008	/* These are passed straight down to collect2 so we have to break
5009	it up like this. */
5010	if (HAVE_LD_NOW_SUPPORT)
5011	{
5012	add_infile (name: "-z", language: "*");
5013	add_infile (name: "now", language: "*");
5014	}
5015	if (HAVE_LD_RELRO_SUPPORT)
5016	{
5017	add_infile (name: "-z", language: "*");
5018	add_infile (name: "relro", language: "*");
5019	}
5020	}
5021	/* We can't use OPT_Whardened yet. Sigh. */
5022	else if (warn_hardened)
5023	warning_at (UNKNOWN_LOCATION, 0,
5024	"linker hardening options not enabled by %<-fhardened%> "
5025	"because other link options were specified on the command "
5026	"line");
5027	}
5028
5029	/* Handle -gtoggle as it would later in toplev.cc:process_options to
5030	make the debug-level-gt spec function work as expected. */
5031	if (flag_gtoggle)
5032	{
5033	if (debug_info_level == DINFO_LEVEL_NONE)
5034	debug_info_level = DINFO_LEVEL_NORMAL;
5035	else
5036	debug_info_level = DINFO_LEVEL_NONE;
5037	}
5038
5039	if (output_file
5040	&& strcmp (s1: output_file, s2: "-") != 0
5041	&& strcmp (s1: output_file, HOST_BIT_BUCKET) != 0)
5042	{
5043	int i;
5044	for (i = 0; i < n_infiles; i++)
5045	if ((!infiles[i].language || infiles[i].language[0] != '*')
5046	&& canonical_filename_eq (a: infiles[i].name, b: output_file))
5047	fatal_error (input_location,
5048	"input file %qs is the same as output file",
5049	output_file);
5050	}
5051
5052	if (output_file != NULL && output_file[0] == '\0')
5053	fatal_error (input_location, "output filename may not be empty");
5054
5055	/* -dumpdir and -save-temps=* both specify the location of aux/dump
5056	outputs; the one that appears last prevails. When compiling
5057	multiple sources, an explicit dumpbase (minus -ext) may be
5058	combined with an explicit or implicit dumpdir, whereas when
5059	linking, a specified or implied link output name (minus
5060	extension) may be combined with a prevailing -save-temps=* or an
5061	otherwise implied dumpdir, but not override a prevailing
5062	-dumpdir. Primary outputs (e.g., linker output when linking
5063	without -o, or .i, .s or .o outputs when processing multiple
5064	inputs with -E, -S or -c, respectively) are NOT affected by these
5065	-save-temps=/-dump* options, always landing in the current
5066	directory and with the same basename as the input when an output
5067	name is not given, but when they're intermediate outputs, they
5068	are named like other aux outputs, so the options affect their
5069	location and name.
5070
5071	Here are some examples. There are several more in the
5072	documentation of -o and -dump*, and some quite exhaustive tests
5073	in gcc.misc-tests/outputs.exp.
5074
5075	When compiling any number of sources, no -dump* nor
5076	-save-temps=*, all outputs in cwd without prefix:
5077
5078	# gcc -c b.c -gsplit-dwarf
5079	-> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5080
5081	# gcc -c b.c d.c -gsplit-dwarf
5082	-> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5083	&& cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
5084
5085	When compiling and linking, no -dump* nor -save-temps=*, .o
5086	outputs are temporary, aux outputs land in the dir of the output,
5087	prefixed with the basename of the linker output:
5088
5089	# gcc b.c d.c -o ab -gsplit-dwarf
5090	-> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5091	&& cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5092	&& link ... -o ab
5093
5094	# gcc b.c d.c [-o a.out] -gsplit-dwarf
5095	-> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5096	&& cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5097	&& link ... [-o a.out]
5098
5099	When compiling and linking, a prevailing -dumpdir fully overrides
5100	the prefix of aux outputs given by the output name:
5101
5102	# gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5103	-> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5104	&& cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5105	&& link ... [-o whatever]
5106
5107	When compiling multiple inputs, an explicit -dumpbase is combined
5108	with -dumpdir, affecting aux outputs, but not the .o outputs:
5109
5110	# gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5111	-> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5112	&& cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5113
5114	When compiling and linking with -save-temps, the .o outputs that
5115	would have been temporary become aux outputs, so they get
5116	affected by -dump* flags:
5117
5118	# gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5119	-> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5120	&& cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5121	&& link
5122
5123	If -save-temps=* prevails over -dumpdir, however, the explicit
5124	-dumpdir is discarded, as if it wasn't there. The basename of
5125	the implicit linker output, a.out or a.exe, becomes a- as the aux
5126	output prefix for all compilations:
5127
5128	# gcc [-dumpdir f] -save-temps=cwd b.c d.c
5129	-> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5130	&& cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5131	&& link
5132
5133	A single -dumpbase, applying to multiple inputs, overrides the
5134	linker output name, implied or explicit, as the aux output prefix:
5135
5136	# gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5137	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5138	&& cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5139	&& link
5140
5141	# gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5142	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5143	&& cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5144	&& link -o dir/h.out
5145
5146	Now, if the linker output is NOT overridden as a prefix, but
5147	-save-temps=* overrides implicit or explicit -dumpdir, the
5148	effective dump dir combines the dir selected by the -save-temps=*
5149	option with the basename of the specified or implied link output:
5150
5151	# gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5152	-> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5153	&& cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5154	&& link -o dir/h.out
5155
5156	# gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5157	-> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5158	&& cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5159	&& link -o dir/h.out
5160
5161	But then again, a single -dumpbase applying to multiple inputs
5162	gets used instead of the linker output basename in the combined
5163	dumpdir:
5164
5165	# gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5166	-> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5167	&& cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5168	&& link -o dir/h.out
5169
5170	With a single input being compiled, the output basename does NOT
5171	affect the dumpdir prefix.
5172
5173	# gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5174	-> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5175
5176	but when compiling and linking even a single file, it does:
5177
5178	# gcc -save-temps=obj b.c -o dir/h.out
5179	-> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5180
5181	unless an explicit -dumpdir prevails:
5182
5183	# gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5184	-> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5185
5186	*/
5187
5188	bool explicit_dumpdir = dumpdir;
5189
5190	if ((!save_temps_overrides_dumpdir && explicit_dumpdir)
5191	|| (output_file && not_actual_file_p (output_file)))
5192	{
5193	/* Do nothing. */
5194	}
5195
5196	/* If -save-temps=obj and -o name, create the prefix to use for %b.
5197	Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5198	else if (save_temps_flag != SAVE_TEMPS_CWD && output_file != NULL)
5199	{
5200	free (ptr: dumpdir);
5201	dumpdir = NULL;
5202	temp = lbasename (output_file);
5203	if (temp != output_file)
5204	dumpdir = xstrndup (output_file,
5205	strlen (s: output_file) - strlen (s: temp));
5206	}
5207	else if (dumpdir)
5208	{
5209	free (ptr: dumpdir);
5210	dumpdir = NULL;
5211	}
5212
5213	if (save_temps_flag)
5214	save_temps_flag = SAVE_TEMPS_DUMP;
5215
5216	/* If there is any pathname component in an explicit -dumpbase, it
5217	overrides dumpdir entirely, so discard it right away. Although
5218	the presence of an explicit -dumpdir matters for the driver, it
5219	shouldn't matter for other processes, that get all that's needed
5220	from the -dumpdir and -dumpbase always passed to them. */
5221	if (dumpdir && dumpbase && lbasename (dumpbase) != dumpbase)
5222	{
5223	free (ptr: dumpdir);
5224	dumpdir = NULL;
5225	}
5226
5227	/* Check that dumpbase_ext matches the end of dumpbase, drop it
5228	otherwise. */
5229	if (dumpbase_ext && dumpbase && *dumpbase)
5230	{
5231	int lendb = strlen (s: dumpbase);
5232	int lendbx = strlen (s: dumpbase_ext);
5233
5234	/* -dumpbase-ext must be a suffix proper; discard it if it
5235	matches all of -dumpbase, as that would make for an empty
5236	basename. */
5237	if (lendbx >= lendb
5238	|| strcmp (s1: dumpbase + lendb - lendbx, s2: dumpbase_ext) != 0)
5239	{
5240	free (ptr: dumpbase_ext);
5241	dumpbase_ext = NULL;
5242	}
5243	}
5244
5245	/* -dumpbase with multiple sources goes into dumpdir. With a single
5246	source, it does only if linking and if dumpdir was not explicitly
5247	specified. */
5248	if (dumpbase && *dumpbase
5249	&& (single_input_file_index () == -2
5250	|| (!have_c && !explicit_dumpdir)))
5251	{
5252	char *prefix;
5253
5254	if (dumpbase_ext)
5255	/* We checked that they match above. */
5256	dumpbase[strlen (s: dumpbase) - strlen (s: dumpbase_ext)] = '\0';
5257
5258	if (dumpdir)
5259	prefix = concat (dumpdir, dumpbase, "-", NULL);
5260	else
5261	prefix = concat (dumpbase, "-", NULL);
5262
5263	free (ptr: dumpdir);
5264	free (ptr: dumpbase);
5265	free (ptr: dumpbase_ext);
5266	dumpbase = dumpbase_ext = NULL;
5267	dumpdir = prefix;
5268	dumpdir_trailing_dash_added = true;
5269	}
5270
5271	/* If dumpbase was not brought into dumpdir but we're linking, bring
5272	output_file into dumpdir unless dumpdir was explicitly specified.
5273	The test for !explicit_dumpdir is further below, because we want
5274	to use the obase computation for a ghost outbase, passed to
5275	GCC_COLLECT_OPTIONS. */
5276	else if (!have_c && (!explicit_dumpdir || (dumpbase && !*dumpbase)))
5277	{
5278	/* If we get here, we know dumpbase was not specified, or it was
5279	specified as an empty string. If it was anything else, it
5280	would have combined with dumpdir above, because the condition
5281	for dumpbase to be used when present is broader than the
5282	condition that gets us here. */
5283	gcc_assert (!dumpbase || !*dumpbase);
5284
5285	const char *obase;
5286	char *tofree = NULL;
5287	if (!output_file || not_actual_file_p (output_file))
5288	obase = "a";
5289	else
5290	{
5291	obase = lbasename (output_file);
5292	size_t blen = strlen (s: obase), xlen;
5293	/* Drop the suffix if it's dumpbase_ext, if given,
5294	otherwise .exe or the target executable suffix, or if the
5295	output was explicitly named a.out, but not otherwise. */
5296	if (dumpbase_ext
5297	? (blen > (xlen = strlen (s: dumpbase_ext))
5298	&& strcmp (s1: (temp = (obase + blen - xlen)),
5299	s2: dumpbase_ext) == 0)
5300	: ((temp = strrchr (s: obase + 1, c: '.'))
5301	&& (xlen = strlen (s: temp))
5302	&& (strcmp (s1: temp, s2: ".exe") == 0
5303	#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5304	|| strcmp (temp, TARGET_EXECUTABLE_SUFFIX) == 0
5305	#endif
5306	|| strcmp (s1: obase, s2: "a.out") == 0)))
5307	{
5308	tofree = xstrndup (obase, blen - xlen);
5309	obase = tofree;
5310	}
5311	}
5312
5313	/* We wish to save this basename to the -dumpdir passed through
5314	GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5315	but we do NOT wish to add it to e.g. %b, so we keep
5316	outbase_length as zero. */
5317	gcc_assert (!outbase);
5318	outbase_length = 0;
5319
5320	/* If we're building [dir1/]foo[.exe] out of a single input
5321	[dir2/]foo.c that shares the same basename, dump to
5322	[dir2/]foo.c.* rather than duplicating the basename into
5323	[dir2/]foo-foo.c.*. */
5324	int idxin;
5325	if (dumpbase
5326	|| ((idxin = single_input_file_index ()) >= 0
5327	&& adds_single_suffix_p (f2: lbasename (infiles[idxin].name),
5328	f1: obase)))
5329	{
5330	if (obase == tofree)
5331	outbase = tofree;
5332	else
5333	{
5334	outbase = xstrdup (obase);
5335	free (ptr: tofree);
5336	}
5337	obase = tofree = NULL;
5338	}
5339	else
5340	{
5341	if (dumpdir)
5342	{
5343	char *p = concat (dumpdir, obase, "-", NULL);
5344	free (ptr: dumpdir);
5345	dumpdir = p;
5346	}
5347	else
5348	dumpdir = concat (obase, "-", NULL);
5349
5350	dumpdir_trailing_dash_added = true;
5351
5352	free (ptr: tofree);
5353	obase = tofree = NULL;
5354	}
5355
5356	if (!explicit_dumpdir || dumpbase)
5357	{
5358	/* Absent -dumpbase and present -dumpbase-ext have been applied
5359	to the linker output name, so compute fresh defaults for each
5360	compilation. */
5361	free (ptr: dumpbase_ext);
5362	dumpbase_ext = NULL;
5363	}
5364	}
5365
5366	/* Now, if we're compiling, or if we haven't used the dumpbase
5367	above, then outbase (%B) is derived from dumpbase, if given, or
5368	from the output name, given or implied. We can't precompute
5369	implied output names, but that's ok, since they're derived from
5370	input names. Just make sure we skip this if dumpbase is the
5371	empty string: we want to use input names then, so don't set
5372	outbase. */
5373	if ((dumpbase || have_c)
5374	&& !(dumpbase && !*dumpbase))
5375	{
5376	gcc_assert (!outbase);
5377
5378	if (dumpbase)
5379	{
5380	gcc_assert (single_input_file_index () != -2);
5381	/* We do not want lbasename here; dumpbase with dirnames
5382	overrides dumpdir entirely, even if dumpdir is
5383	specified. */
5384	if (dumpbase_ext)
5385	/* We've already checked above that the suffix matches. */
5386	outbase = xstrndup (dumpbase,
5387	strlen (s: dumpbase) - strlen (s: dumpbase_ext));
5388	else
5389	outbase = xstrdup (dumpbase);
5390	}
5391	else if (output_file && !not_actual_file_p (output_file))
5392	{
5393	outbase = xstrdup (lbasename (output_file));
5394	char *p = strrchr (s: outbase + 1, c: '.');
5395	if (p)
5396	*p = '\0';
5397	}
5398
5399	if (outbase)
5400	outbase_length = strlen (s: outbase);
5401	}
5402
5403	/* If there is any pathname component in an explicit -dumpbase, do
5404	not use dumpdir, but retain it to pass it on to the compiler. */
5405	if (dumpdir)
5406	dumpdir_length = strlen (s: dumpdir);
5407	else
5408	dumpdir_length = 0;
5409
5410	/* Check that dumpbase_ext, if still present, still matches the end
5411	of dumpbase, if present, and drop it otherwise. We only retained
5412	it above when dumpbase was absent to maybe use it to drop the
5413	extension from output_name before combining it with dumpdir. We
5414	won't deal with -dumpbase-ext when -dumpbase is not explicitly
5415	given, even if just to activate backward-compatible dumpbase:
5416	dropping it on the floor is correct, expected and documented
5417	behavior. Attempting to deal with a -dumpbase-ext that might
5418	match the end of some input filename, or of the combination of
5419	the output basename with the suffix of the input filename,
5420	possible with an intermediate .gk extension for -fcompare-debug,
5421	is just calling for trouble. */
5422	if (dumpbase_ext)
5423	{
5424	if (!dumpbase || !*dumpbase)
5425	{
5426	free (ptr: dumpbase_ext);
5427	dumpbase_ext = NULL;
5428	}
5429	else
5430	gcc_assert (strcmp (dumpbase + strlen (dumpbase)
5431	- strlen (dumpbase_ext), dumpbase_ext) == 0);
5432	}
5433
5434	if (save_temps_flag && use_pipes)
5435	{
5436	/* -save-temps overrides -pipe, so that temp files are produced */
5437	if (save_temps_flag)
5438	warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5439	use_pipes = 0;
5440	}
5441
5442	if (!compare_debug)
5443	{
5444	const char *gcd = env.get (name: "GCC_COMPARE_DEBUG");
5445
5446	if (gcd && gcd[0] == '-')
5447	{
5448	compare_debug = 2;
5449	compare_debug_opt = gcd;
5450	}
5451	else if (gcd && *gcd && strcmp (s1: gcd, s2: "0"))
5452	{
5453	compare_debug = 3;
5454	compare_debug_opt = "-gtoggle";
5455	}
5456	}
5457	else if (compare_debug < 0)
5458	{
5459	compare_debug = 0;
5460	gcc_assert (!compare_debug_opt);
5461	}
5462
5463	/* Set up the search paths. We add directories that we expect to
5464	contain GNU Toolchain components before directories specified by
5465	the machine description so that we will find GNU components (like
5466	the GNU assembler) before those of the host system. */
5467
5468	/* If we don't know where the toolchain has been installed, use the
5469	configured-in locations. */
5470	if (!gcc_exec_prefix)
5471	{
5472	#ifndef OS2
5473	add_prefix (pprefix: &exec_prefixes, prefix: standard_libexec_prefix, component: "GCC",
5474	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 1, os_multilib: 0);
5475	add_prefix (pprefix: &exec_prefixes, prefix: standard_libexec_prefix, component: "BINUTILS",
5476	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 2, os_multilib: 0);
5477	add_prefix (pprefix: &exec_prefixes, prefix: standard_exec_prefix, component: "BINUTILS",
5478	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 2, os_multilib: 0);
5479	#endif
5480	add_prefix (pprefix: &startfile_prefixes, prefix: standard_exec_prefix, component: "BINUTILS",
5481	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 1, os_multilib: 0);
5482	}
5483
5484	gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
5485	tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
5486	dir_separator_str, NULL);
5487
5488	/* Look for tools relative to the location from which the driver is
5489	running, or, if that is not available, the configured prefix. */
5490	tooldir_prefix
5491	= concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
5492	spec_host_machine, dir_separator_str, spec_version,
5493	accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
5494	free (ptr: tooldir_prefix2);
5495
5496	add_prefix (pprefix: &exec_prefixes,
5497	prefix: concat (tooldir_prefix, "bin", dir_separator_str, NULL),
5498	component: "BINUTILS", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
5499	add_prefix (pprefix: &startfile_prefixes,
5500	prefix: concat (tooldir_prefix, "lib", dir_separator_str, NULL),
5501	component: "BINUTILS", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
5502	free (ptr: tooldir_prefix);
5503
5504	#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5505	/* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5506	then consider it to relocate with the rest of the GCC installation
5507	if GCC_EXEC_PREFIX is set.
5508	``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5509	if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
5510	{
5511	char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
5512	standard_bindir_prefix,
5513	target_system_root);
5514	if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
5515	{
5516	target_system_root = tmp_prefix;
5517	target_system_root_changed = 1;
5518	}
5519	}
5520	#endif
5521
5522	/* More prefixes are enabled in main, after we read the specs file
5523	and determine whether this is cross-compilation or not. */
5524
5525	if (n_infiles != 0 && n_infiles == last_language_n_infiles && spec_lang != 0)
5526	warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
5527
5528	/* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5529	environment variable. */
5530	if (compare_debug == 2 || compare_debug == 3)
5531	{
5532	const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
5533	save_switch (opt, n_args: 0, NULL, validated: false, known: true);
5534	compare_debug = 1;
5535	}
5536
5537	/* Ensure we only invoke each subprocess once. */
5538	if (n_infiles == 0
5539	&& (print_subprocess_help || print_help_list || print_version))
5540	{
5541	/* Create a dummy input file, so that we can pass
5542	the help option on to the various sub-processes. */
5543	add_infile (name: "help-dummy", language: "c");
5544	}
5545
5546	/* Decide if undefined variable references are allowed in specs. */
5547
5548	/* -v alone is safe. --version and --help alone or together are safe. Note
5549	that -v would make them unsafe, as they'd then be run for subprocesses as
5550	well, the location of which might depend on variables possibly coming
5551	from self-specs. Note also that the command name is counted in
5552	decoded_options_count. */
5553
5554	unsigned help_version_count = 0;
5555
5556	if (print_version)
5557	help_version_count++;
5558
5559	if (print_help_list)
5560	help_version_count++;
5561
5562	spec_undefvar_allowed =
5563	((verbose_flag && decoded_options_count == 2)
5564	|| help_version_count == decoded_options_count - 1);
5565
5566	alloc_switch ();
5567	switches[n_switches].part1 = 0;
5568	alloc_infile ();
5569	infiles[n_infiles].name = 0;
5570	}
5571
5572	/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5573	and place that in the environment. */
5574
5575	static void
5576	set_collect_gcc_options (void)
5577	{
5578	int i;
5579	int first_time;
5580
5581	/* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5582	the compiler. */
5583	obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5584	sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5585
5586	first_time = true;
5587	for (i = 0; (int) i < n_switches; i++)
5588	{
5589	const char *const *args;
5590	const char *p, *q;
5591	if (!first_time)
5592	obstack_grow (&collect_obstack, " ", 1);
5593
5594	first_time = false;
5595
5596	/* Ignore elided switches. */
5597	if ((switches[i].live_cond
5598	& (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
5599	== SWITCH_IGNORE)
5600	continue;
5601
5602	obstack_grow (&collect_obstack, "'-", 2);
5603	q = switches[i].part1;
5604	while ((p = strchr (s: q, c: '\'')))
5605	{
5606	obstack_grow (&collect_obstack, q, p - q);
5607	obstack_grow (&collect_obstack, "'\\''", 4);
5608	q = ++p;
5609	}
5610	obstack_grow (&collect_obstack, q, strlen (q));
5611	obstack_grow (&collect_obstack, "'", 1);
5612
5613	for (args = switches[i].args; args && *args; args++)
5614	{
5615	obstack_grow (&collect_obstack, " '", 2);
5616	q = *args;
5617	while ((p = strchr (s: q, c: '\'')))
5618	{
5619	obstack_grow (&collect_obstack, q, p - q);
5620	obstack_grow (&collect_obstack, "'\\''", 4);
5621	q = ++p;
5622	}
5623	obstack_grow (&collect_obstack, q, strlen (q));
5624	obstack_grow (&collect_obstack, "'", 1);
5625	}
5626	}
5627
5628	if (dumpdir)
5629	{
5630	if (!first_time)
5631	obstack_grow (&collect_obstack, " ", 1);
5632	first_time = false;
5633
5634	obstack_grow (&collect_obstack, "'-dumpdir' '", 12);
5635	const char *p, *q;
5636
5637	q = dumpdir;
5638	while ((p = strchr (s: q, c: '\'')))
5639	{
5640	obstack_grow (&collect_obstack, q, p - q);
5641	obstack_grow (&collect_obstack, "'\\''", 4);
5642	q = ++p;
5643	}
5644	obstack_grow (&collect_obstack, q, strlen (q));
5645
5646	obstack_grow (&collect_obstack, "'", 1);
5647	}
5648
5649	obstack_grow (&collect_obstack, "\0", 1);
5650	xputenv (XOBFINISH (&collect_obstack, char *));
5651	}
5652
5653	/* Process a spec string, accumulating and running commands. */
5654
5655	/* These variables describe the input file name.
5656	input_file_number is the index on outfiles of this file,
5657	so that the output file name can be stored for later use by %o.
5658	input_basename is the start of the part of the input file
5659	sans all directory names, and basename_length is the number
5660	of characters starting there excluding the suffix .c or whatever. */
5661
5662	static const char *gcc_input_filename;
5663	static int input_file_number;
5664	size_t input_filename_length;
5665	static int basename_length;
5666	static int suffixed_basename_length;
5667	static const char *input_basename;
5668	static const char *input_suffix;
5669	#ifndef HOST_LACKS_INODE_NUMBERS
5670	static struct stat input_stat;
5671	#endif
5672	static int input_stat_set;
5673
5674	/* The compiler used to process the current input file. */
5675	static struct compiler *input_file_compiler;
5676
5677	/* These are variables used within do_spec and do_spec_1. */
5678
5679	/* Nonzero if an arg has been started and not yet terminated
5680	(with space, tab or newline). */
5681	static int arg_going;
5682
5683	/* Nonzero means %d or %g has been seen; the next arg to be terminated
5684	is a temporary file name. */
5685	static int delete_this_arg;
5686
5687	/* Nonzero means %w has been seen; the next arg to be terminated
5688	is the output file name of this compilation. */
5689	static int this_is_output_file;
5690
5691	/* Nonzero means %s has been seen; the next arg to be terminated
5692	is the name of a library file and we should try the standard
5693	search dirs for it. */
5694	static int this_is_library_file;
5695
5696	/* Nonzero means %T has been seen; the next arg to be terminated
5697	is the name of a linker script and we should try all of the
5698	standard search dirs for it. If it is found insert a --script
5699	command line switch and then substitute the full path in place,
5700	otherwise generate an error message. */
5701	static int this_is_linker_script;
5702
5703	/* Nonzero means that the input of this command is coming from a pipe. */
5704	static int input_from_pipe;
5705
5706	/* Nonnull means substitute this for any suffix when outputting a switches
5707	arguments. */
5708	static const char *suffix_subst;
5709
5710	/* If there is an argument being accumulated, terminate it and store it. */
5711
5712	static void
5713	end_going_arg (void)
5714	{
5715	if (arg_going)
5716	{
5717	const char *string;
5718
5719	obstack_1grow (&obstack, 0);
5720	string = XOBFINISH (&obstack, const char *);
5721	if (this_is_library_file)
5722	string = find_file (string);
5723	if (this_is_linker_script)
5724	{
5725	char * full_script_path = find_a_file (pprefix: &startfile_prefixes, name: string, R_OK, do_multi: true);
5726
5727	if (full_script_path == NULL)
5728	{
5729	error ("unable to locate default linker script %qs in the library search paths", string);
5730	/* Script was not found on search path. */
5731	return;
5732	}
5733	store_arg (arg: "--script", delete_always: false, delete_failure: false);
5734	string = full_script_path;
5735	}
5736	store_arg (arg: string, delete_always: delete_this_arg, delete_failure: this_is_output_file);
5737	if (this_is_output_file)
5738	outfiles[input_file_number] = string;
5739	arg_going = 0;
5740	}
5741	}
5742
5743
5744	/* Parse the WRAPPER string which is a comma separated list of the command line
5745	and insert them into the beginning of argbuf. */
5746
5747	static void
5748	insert_wrapper (const char *wrapper)
5749	{
5750	int n = 0;
5751	int i;
5752	char *buf = xstrdup (wrapper);
5753	char *p = buf;
5754	unsigned int old_length = argbuf.length ();
5755
5756	do
5757	{
5758	n++;
5759	while (*p == ',')
5760	p++;
5761	}
5762	while ((p = strchr (s: p, c: ',')) != NULL);
5763
5764	argbuf.safe_grow (len: old_length + n, exact: true);
5765	memmove (dest: argbuf.address () + n,
5766	src: argbuf.address (),
5767	n: old_length * sizeof (const_char_p));
5768
5769	i = 0;
5770	p = buf;
5771	do
5772	{
5773	while (*p == ',')
5774	{
5775	*p = 0;
5776	p++;
5777	}
5778	argbuf[i] = p;
5779	i++;
5780	}
5781	while ((p = strchr (s: p, c: ',')) != NULL);
5782	gcc_assert (i == n);
5783	}
5784
5785	/* Process the spec SPEC and run the commands specified therein.
5786	Returns 0 if the spec is successfully processed; -1 if failed. */
5787
5788	int
5789	do_spec (const char *spec)
5790	{
5791	int value;
5792
5793	value = do_spec_2 (spec, NULL);
5794
5795	/* Force out any unfinished command.
5796	If -pipe, this forces out the last command if it ended in `|'. */
5797	if (value == 0)
5798	{
5799	if (argbuf.length () > 0
5800	&& !strcmp (s1: argbuf.last (), s2: "|"))
5801	argbuf.pop ();
5802
5803	set_collect_gcc_options ();
5804
5805	if (argbuf.length () > 0)
5806	value = execute ();
5807	}
5808
5809	return value;
5810	}
5811
5812	/* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5813	of a matched * pattern which may be re-injected by way of %*. */
5814
5815	static int
5816	do_spec_2 (const char *spec, const char *soft_matched_part)
5817	{
5818	int result;
5819
5820	clear_args ();
5821	arg_going = 0;
5822	delete_this_arg = 0;
5823	this_is_output_file = 0;
5824	this_is_library_file = 0;
5825	this_is_linker_script = 0;
5826	input_from_pipe = 0;
5827	suffix_subst = NULL;
5828
5829	result = do_spec_1 (spec, 0, soft_matched_part);
5830
5831	end_going_arg ();
5832
5833	return result;
5834	}
5835
5836	/* Process the given spec string and add any new options to the end
5837	of the switches/n_switches array. */
5838
5839	static void
5840	do_option_spec (const char *name, const char *spec)
5841	{
5842	unsigned int i, value_count, value_len;
5843	const char *p, *q, *value;
5844	char *tmp_spec, *tmp_spec_p;
5845
5846	if (configure_default_options[0].name == NULL)
5847	return;
5848
5849	for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
5850	if (strcmp (s1: configure_default_options[i].name, s2: name) == 0)
5851	break;
5852	if (i == ARRAY_SIZE (configure_default_options))
5853	return;
5854
5855	value = configure_default_options[i].value;
5856	value_len = strlen (s: value);
5857
5858	/* Compute the size of the final spec. */
5859	value_count = 0;
5860	p = spec;
5861	while ((p = strstr (haystack: p, needle: "%(VALUE)")) != NULL)
5862	{
5863	p ++;
5864	value_count ++;
5865	}
5866
5867	/* Replace each %(VALUE) by the specified value. */
5868	tmp_spec = (char *) alloca (strlen (spec) + 1
5869	+ value_count * (value_len - strlen ("%(VALUE)")));
5870	tmp_spec_p = tmp_spec;
5871	q = spec;
5872	while ((p = strstr (haystack: q, needle: "%(VALUE)")) != NULL)
5873	{
5874	memcpy (dest: tmp_spec_p, src: q, n: p - q);
5875	tmp_spec_p = tmp_spec_p + (p - q);
5876	memcpy (dest: tmp_spec_p, src: value, n: value_len);
5877	tmp_spec_p += value_len;
5878	q = p + strlen (s: "%(VALUE)");
5879	}
5880	strcpy (dest: tmp_spec_p, src: q);
5881
5882	do_self_spec (tmp_spec);
5883	}
5884
5885	/* Process the given spec string and add any new options to the end
5886	of the switches/n_switches array. */
5887
5888	static void
5889	do_self_spec (const char *spec)
5890	{
5891	int i;
5892
5893	do_spec_2 (spec, NULL);
5894	do_spec_1 (" ", 0, NULL);
5895
5896	/* Mark %<S switches processed by do_self_spec to be ignored permanently.
5897	do_self_specs adds the replacements to switches array, so it shouldn't
5898	be processed afterwards. */
5899	for (i = 0; i < n_switches; i++)
5900	if ((switches[i].live_cond & SWITCH_IGNORE))
5901	switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
5902
5903	if (argbuf.length () > 0)
5904	{
5905	const char **argbuf_copy;
5906	struct cl_decoded_option *decoded_options;
5907	struct cl_option_handlers handlers;
5908	unsigned int decoded_options_count;
5909	unsigned int j;
5910
5911	/* Create a copy of argbuf with a dummy argv[0] entry for
5912	decode_cmdline_options_to_array. */
5913	argbuf_copy = XNEWVEC (const char *,
5914	argbuf.length () + 1);
5915	argbuf_copy[0] = "";
5916	memcpy (dest: argbuf_copy + 1, src: argbuf.address (),
5917	n: argbuf.length () * sizeof (const char *));
5918
5919	decode_cmdline_options_to_array (argc: argbuf.length () + 1,
5920	argv: argbuf_copy,
5921	CL_DRIVER, decoded_options: &decoded_options,
5922	decoded_options_count: &decoded_options_count);
5923	free (ptr: argbuf_copy);
5924
5925	set_option_handlers (&handlers);
5926
5927	for (j = 1; j < decoded_options_count; j++)
5928	{
5929	switch (decoded_options[j].opt_index)
5930	{
5931	case OPT_SPECIAL_input_file:
5932	/* Specs should only generate options, not input
5933	files. */
5934	if (strcmp (s1: decoded_options[j].arg, s2: "-") != 0)
5935	fatal_error (input_location,
5936	"switch %qs does not start with %<-%>",
5937	decoded_options[j].arg);
5938	else
5939	fatal_error (input_location,
5940	"spec-generated switch is just %<-%>");
5941	break;
5942
5943	case OPT_fcompare_debug_second:
5944	case OPT_fcompare_debug:
5945	case OPT_fcompare_debug_:
5946	case OPT_o:
5947	/* Avoid duplicate processing of some options from
5948	compare-debug specs; just save them here. */
5949	save_switch (opt: decoded_options[j].canonical_option[0],
5950	n_args: (decoded_options[j].canonical_option_num_elements
5951	- 1),
5952	args: &decoded_options[j].canonical_option[1], validated: false, known: true);
5953	break;
5954
5955	default:
5956	read_cmdline_option (opts: &global_options, opts_set: &global_options_set,
5957	decoded: decoded_options + j, UNKNOWN_LOCATION,
5958	CL_DRIVER, handlers: &handlers, dc: global_dc);
5959	break;
5960	}
5961	}
5962
5963	free (ptr: decoded_options);
5964
5965	alloc_switch ();
5966	switches[n_switches].part1 = 0;
5967	}
5968	}
5969
5970	/* Callback for processing %D and %I specs. */
5971
5972	struct spec_path_info {
5973	const char *option;
5974	const char *append;
5975	size_t append_len;
5976	bool omit_relative;
5977	bool separate_options;
5978	bool realpaths;
5979	};
5980
5981	static void *
5982	spec_path (char *path, void *data)
5983	{
5984	struct spec_path_info *info = (struct spec_path_info *) data;
5985	size_t len = 0;
5986	char save = 0;
5987
5988	/* The path must exist; we want to resolve it to the realpath so that this
5989	can be embedded as a runpath. */
5990	if (info->realpaths)
5991	path = lrealpath (path);
5992
5993	/* However, if we failed to resolve it - perhaps because there was a bogus
5994	-B option on the command line, then punt on this entry. */
5995	if (!path)
5996	return NULL;
5997
5998	if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5999	return NULL;
6000
6001	if (info->append_len != 0)
6002	{
6003	len = strlen (s: path);
6004	memcpy (dest: path + len, src: info->append, n: info->append_len + 1);
6005	}
6006
6007	if (!is_directory (path, true))
6008	return NULL;
6009
6010	do_spec_1 (info->option, 1, NULL);
6011	if (info->separate_options)
6012	do_spec_1 (" ", 0, NULL);
6013
6014	if (info->append_len == 0)
6015	{
6016	len = strlen (s: path);
6017	save = path[len - 1];
6018	if (IS_DIR_SEPARATOR (path[len - 1]))
6019	path[len - 1] = '\0';
6020	}
6021
6022	do_spec_1 (path, 1, NULL);
6023	do_spec_1 (" ", 0, NULL);
6024
6025	/* Must not damage the original path. */
6026	if (info->append_len == 0)
6027	path[len - 1] = save;
6028
6029	return NULL;
6030	}
6031
6032	/* True if we should compile INFILE. */
6033
6034	static bool
6035	compile_input_file_p (struct infile *infile)
6036	{
6037	if ((!infile->language) || (infile->language[0] != '*'))
6038	if (infile->incompiler == input_file_compiler)
6039	return true;
6040	return false;
6041	}
6042
6043	/* Process each member of VEC as a spec. */
6044
6045	static void
6046	do_specs_vec (vec<char_p> vec)
6047	{
6048	for (char *opt : vec)
6049	{
6050	do_spec_1 (opt, 1, NULL);
6051	/* Make each accumulated option a separate argument. */
6052	do_spec_1 (" ", 0, NULL);
6053	}
6054	}
6055
6056	/* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
6057
6058	static void
6059	putenv_COLLECT_AS_OPTIONS (vec<char_p> vec)
6060	{
6061	if (vec.is_empty ())
6062	return;
6063
6064	obstack_init (&collect_obstack);
6065	obstack_grow (&collect_obstack, "COLLECT_AS_OPTIONS=",
6066	strlen ("COLLECT_AS_OPTIONS="));
6067
6068	char *opt;
6069	unsigned ix;
6070
6071	FOR_EACH_VEC_ELT (vec, ix, opt)
6072	{
6073	obstack_1grow (&collect_obstack, '\'');
6074	obstack_grow (&collect_obstack, opt, strlen (opt));
6075	obstack_1grow (&collect_obstack, '\'');
6076	if (ix < vec.length () - 1)
6077	obstack_1grow(&collect_obstack, ' ');
6078	}
6079
6080	obstack_1grow (&collect_obstack, '\0');
6081	xputenv (XOBFINISH (&collect_obstack, char *));
6082	}
6083
6084	/* Process the sub-spec SPEC as a portion of a larger spec.
6085	This is like processing a whole spec except that we do
6086	not initialize at the beginning and we do not supply a
6087	newline by default at the end.
6088	INSWITCH nonzero means don't process %-sequences in SPEC;
6089	in this case, % is treated as an ordinary character.
6090	This is used while substituting switches.
6091	INSWITCH nonzero also causes SPC not to terminate an argument.
6092
6093	Value is zero unless a line was finished
6094	and the command on that line reported an error. */
6095
6096	static int
6097	do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
6098	{
6099	const char *p = spec;
6100	int c;
6101	int i;
6102	int value;
6103
6104	/* If it's an empty string argument to a switch, keep it as is. */
6105	if (inswitch && !*p)
6106	arg_going = 1;
6107
6108	while ((c = *p++))
6109	/* If substituting a switch, treat all chars like letters.
6110	Otherwise, NL, SPC, TAB and % are special. */
6111	switch (inswitch ? 'a' : c)
6112	{
6113	case '\n':
6114	end_going_arg ();
6115
6116	if (argbuf.length () > 0
6117	&& !strcmp (s1: argbuf.last (), s2: "|"))
6118	{
6119	/* A `|' before the newline means use a pipe here,
6120	but only if -pipe was specified.
6121	Otherwise, execute now and don't pass the `|' as an arg. */
6122	if (use_pipes)
6123	{
6124	input_from_pipe = 1;
6125	break;
6126	}
6127	else
6128	argbuf.pop ();
6129	}
6130
6131	set_collect_gcc_options ();
6132
6133	if (argbuf.length () > 0)
6134	{
6135	value = execute ();
6136	if (value)
6137	return value;
6138	}
6139	/* Reinitialize for a new command, and for a new argument. */
6140	clear_args ();
6141	arg_going = 0;
6142	delete_this_arg = 0;
6143	this_is_output_file = 0;
6144	this_is_library_file = 0;
6145	this_is_linker_script = 0;
6146	input_from_pipe = 0;
6147	break;
6148
6149	case '|':
6150	end_going_arg ();
6151
6152	/* Use pipe */
6153	obstack_1grow (&obstack, c);
6154	arg_going = 1;
6155	break;
6156
6157	case '\t':
6158	case ' ':
6159	end_going_arg ();
6160
6161	/* Reinitialize for a new argument. */
6162	delete_this_arg = 0;
6163	this_is_output_file = 0;
6164	this_is_library_file = 0;
6165	this_is_linker_script = 0;
6166	break;
6167
6168	case '%':
6169	switch (c = *p++)
6170	{
6171	case 0:
6172	fatal_error (input_location, "spec %qs invalid", spec);
6173
6174	case 'b':
6175	/* Don't use %b in the linker command. */
6176	gcc_assert (suffixed_basename_length);
6177	if (!this_is_output_file && dumpdir_length)
6178	obstack_grow (&obstack, dumpdir, dumpdir_length);
6179	if (this_is_output_file || !outbase_length)
6180	obstack_grow (&obstack, input_basename, basename_length);
6181	else
6182	obstack_grow (&obstack, outbase, outbase_length);
6183	if (compare_debug < 0)
6184	obstack_grow (&obstack, ".gk", 3);
6185	arg_going = 1;
6186	break;
6187
6188	case 'B':
6189	/* Don't use %B in the linker command. */
6190	gcc_assert (suffixed_basename_length);
6191	if (!this_is_output_file && dumpdir_length)
6192	obstack_grow (&obstack, dumpdir, dumpdir_length);
6193	if (this_is_output_file || !outbase_length)
6194	obstack_grow (&obstack, input_basename, basename_length);
6195	else
6196	obstack_grow (&obstack, outbase, outbase_length);
6197	if (compare_debug < 0)
6198	obstack_grow (&obstack, ".gk", 3);
6199	obstack_grow (&obstack, input_basename + basename_length,
6200	suffixed_basename_length - basename_length);
6201
6202	arg_going = 1;
6203	break;
6204
6205	case 'd':
6206	delete_this_arg = 2;
6207	break;
6208
6209	/* Dump out the directories specified with LIBRARY_PATH,
6210	followed by the absolute directories
6211	that we search for startfiles. */
6212	case 'D':
6213	{
6214	struct spec_path_info info;
6215
6216	info.option = "-L";
6217	info.append_len = 0;
6218	#ifdef RELATIVE_PREFIX_NOT_LINKDIR
6219	/* Used on systems which record the specified -L dirs
6220	and use them to search for dynamic linking.
6221	Relative directories always come from -B,
6222	and it is better not to use them for searching
6223	at run time. In particular, stage1 loses. */
6224	info.omit_relative = true;
6225	#else
6226	info.omit_relative = false;
6227	#endif
6228	info.separate_options = false;
6229	info.realpaths = false;
6230
6231	for_each_path (paths: &startfile_prefixes, do_multi: true, extra_space: 0, callback: spec_path, callback_info: &info);
6232	}
6233	break;
6234
6235	case 'P':
6236	{
6237	struct spec_path_info info;
6238
6239	info.option = RUNPATH_OPTION;
6240	info.append_len = 0;
6241	info.omit_relative = false;
6242	info.separate_options = true;
6243	/* We want to embed the actual paths that have the libraries. */
6244	info.realpaths = true;
6245
6246	for_each_path (paths: &startfile_prefixes, do_multi: true, extra_space: 0, callback: spec_path, callback_info: &info);
6247	}
6248	break;
6249
6250	case 'e':
6251	/* %efoo means report an error with `foo' as error message
6252	and don't execute any more commands for this file. */
6253	{
6254	const char *q = p;
6255	char *buf;
6256	while (*p != 0 && *p != '\n')
6257	p++;
6258	buf = (char *) alloca (p - q + 1);
6259	strncpy (dest: buf, src: q, n: p - q);
6260	buf[p - q] = 0;
6261	error ("%s", _(buf));
6262	return -1;
6263	}
6264	break;
6265	case 'n':
6266	/* %nfoo means report a notice with `foo' on stderr. */
6267	{
6268	const char *q = p;
6269	char *buf;
6270	while (*p != 0 && *p != '\n')
6271	p++;
6272	buf = (char *) alloca (p - q + 1);
6273	strncpy (dest: buf, src: q, n: p - q);
6274	buf[p - q] = 0;
6275	inform (UNKNOWN_LOCATION, "%s", _(buf));
6276	if (*p)
6277	p++;
6278	}
6279	break;
6280
6281	case 'j':
6282	{
6283	struct stat st;
6284
6285	/* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6286	defined, and it is not a directory, and it is
6287	writable, use it. Otherwise, treat this like any
6288	other temporary file. */
6289
6290	if ((!save_temps_flag)
6291	&& (stat (HOST_BIT_BUCKET, buf: &st) == 0) && (!S_ISDIR (st.st_mode))
6292	&& (access (HOST_BIT_BUCKET, W_OK) == 0))
6293	{
6294	obstack_grow (&obstack, HOST_BIT_BUCKET,
6295	strlen (HOST_BIT_BUCKET));
6296	delete_this_arg = 0;
6297	arg_going = 1;
6298	break;
6299	}
6300	}
6301	goto create_temp_file;
6302	case '|':
6303	if (use_pipes)
6304	{
6305	obstack_1grow (&obstack, '-');
6306	delete_this_arg = 0;
6307	arg_going = 1;
6308
6309	/* consume suffix */
6310	while (*p == '.' || ISALNUM ((unsigned char) *p))
6311	p++;
6312	if (p[0] == '%' && p[1] == 'O')
6313	p += 2;
6314
6315	break;
6316	}
6317	goto create_temp_file;
6318	case 'm':
6319	if (use_pipes)
6320	{
6321	/* consume suffix */
6322	while (*p == '.' || ISALNUM ((unsigned char) *p))
6323	p++;
6324	if (p[0] == '%' && p[1] == 'O')
6325	p += 2;
6326
6327	break;
6328	}
6329	goto create_temp_file;
6330	case 'g':
6331	case 'u':
6332	case 'U':
6333	create_temp_file:
6334	{
6335	struct temp_name *t;
6336	int suffix_length;
6337	const char *suffix = p;
6338	char *saved_suffix = NULL;
6339
6340	while (*p == '.' || ISALNUM ((unsigned char) *p))
6341	p++;
6342	suffix_length = p - suffix;
6343	if (p[0] == '%' && p[1] == 'O')
6344	{
6345	p += 2;
6346	/* We don't support extra suffix characters after %O. */
6347	if (*p == '.' || ISALNUM ((unsigned char) *p))
6348	fatal_error (input_location,
6349	"spec %qs has invalid %<%%0%c%>", spec, *p);
6350	if (suffix_length == 0)
6351	suffix = TARGET_OBJECT_SUFFIX;
6352	else
6353	{
6354	saved_suffix
6355	= XNEWVEC (char, suffix_length
6356	+ strlen (TARGET_OBJECT_SUFFIX) + 1);
6357	strncpy (dest: saved_suffix, src: suffix, n: suffix_length);
6358	strcpy (dest: saved_suffix + suffix_length,
6359	TARGET_OBJECT_SUFFIX);
6360	}
6361	suffix_length += strlen (TARGET_OBJECT_SUFFIX);
6362	}
6363
6364	if (compare_debug < 0)
6365	{
6366	suffix = concat (".gk", suffix, NULL);
6367	suffix_length += 3;
6368	}
6369
6370	/* If -save-temps was specified, use that for the
6371	temp file. */
6372	if (save_temps_flag)
6373	{
6374	char *tmp;
6375	bool adjusted_suffix = false;
6376	if (suffix_length
6377	&& !outbase_length && !basename_length
6378	&& !dumpdir_trailing_dash_added)
6379	{
6380	adjusted_suffix = true;
6381	suffix++;
6382	suffix_length--;
6383	}
6384	temp_filename_length
6385	= dumpdir_length + suffix_length + 1;
6386	if (outbase_length)
6387	temp_filename_length += outbase_length;
6388	else
6389	temp_filename_length += basename_length;
6390	tmp = (char *) alloca (temp_filename_length);
6391	if (dumpdir_length)
6392	memcpy (dest: tmp, src: dumpdir, n: dumpdir_length);
6393	if (outbase_length)
6394	memcpy (dest: tmp + dumpdir_length, src: outbase,
6395	n: outbase_length);
6396	else if (basename_length)
6397	memcpy (dest: tmp + dumpdir_length, src: input_basename,
6398	n: basename_length);
6399	memcpy (dest: tmp + temp_filename_length - suffix_length - 1,
6400	src: suffix, n: suffix_length);
6401	if (adjusted_suffix)
6402	{
6403	adjusted_suffix = false;
6404	suffix--;
6405	suffix_length++;
6406	}
6407	tmp[temp_filename_length - 1] = '\0';
6408	temp_filename = tmp;
6409
6410	if (filename_cmp (s1: temp_filename, s2: gcc_input_filename) != 0)
6411	{
6412	#ifndef HOST_LACKS_INODE_NUMBERS
6413	struct stat st_temp;
6414
6415	/* Note, set_input() resets input_stat_set to 0. */
6416	if (input_stat_set == 0)
6417	{
6418	input_stat_set = stat (file: gcc_input_filename,
6419	buf: &input_stat);
6420	if (input_stat_set >= 0)
6421	input_stat_set = 1;
6422	}
6423
6424	/* If we have the stat for the gcc_input_filename
6425	and we can do the stat for the temp_filename
6426	then the they could still refer to the same
6427	file if st_dev/st_ino's are the same. */
6428	if (input_stat_set != 1
6429	|| stat (file: temp_filename, buf: &st_temp) < 0
6430	|| input_stat.st_dev != st_temp.st_dev
6431	|| input_stat.st_ino != st_temp.st_ino)
6432	#else
6433	/* Just compare canonical pathnames. */
6434	char* input_realname = lrealpath (gcc_input_filename);
6435	char* temp_realname = lrealpath (temp_filename);
6436	bool files_differ = filename_cmp (input_realname, temp_realname);
6437	free (input_realname);
6438	free (temp_realname);
6439	if (files_differ)
6440	#endif
6441	{
6442	temp_filename
6443	= save_string (temp_filename,
6444	temp_filename_length - 1);
6445	obstack_grow (&obstack, temp_filename,
6446	temp_filename_length);
6447	arg_going = 1;
6448	delete_this_arg = 0;
6449	break;
6450	}
6451	}
6452	}
6453
6454	/* See if we already have an association of %g/%u/%U and
6455	suffix. */
6456	for (t = temp_names; t; t = t->next)
6457	if (t->length == suffix_length
6458	&& strncmp (s1: t->suffix, s2: suffix, n: suffix_length) == 0
6459	&& t->unique == (c == 'u' || c == 'U' || c == 'j'))
6460	break;
6461
6462	/* Make a new association if needed. %u and %j
6463	require one. */
6464	if (t == 0 || c == 'u' || c == 'j')
6465	{
6466	if (t == 0)
6467	{
6468	t = XNEW (struct temp_name);
6469	t->next = temp_names;
6470	temp_names = t;
6471	}
6472	t->length = suffix_length;
6473	if (saved_suffix)
6474	{
6475	t->suffix = saved_suffix;
6476	saved_suffix = NULL;
6477	}
6478	else
6479	t->suffix = save_string (suffix, suffix_length);
6480	t->unique = (c == 'u' || c == 'U' || c == 'j');
6481	temp_filename = make_temp_file (t->suffix);
6482	temp_filename_length = strlen (s: temp_filename);
6483	t->filename = temp_filename;
6484	t->filename_length = temp_filename_length;
6485	}
6486
6487	free (ptr: saved_suffix);
6488
6489	obstack_grow (&obstack, t->filename, t->filename_length);
6490	delete_this_arg = 1;
6491	}
6492	arg_going = 1;
6493	break;
6494
6495	case 'i':
6496	if (combine_inputs)
6497	{
6498	/* We are going to expand `%i' into `@FILE', where FILE
6499	is a newly-created temporary filename. The filenames
6500	that would usually be expanded in place of %o will be
6501	written to the temporary file. */
6502	if (at_file_supplied)
6503	open_at_file ();
6504
6505	for (i = 0; (int) i < n_infiles; i++)
6506	if (compile_input_file_p (infile: &infiles[i]))
6507	{
6508	store_arg (arg: infiles[i].name, delete_always: 0, delete_failure: 0);
6509	infiles[i].compiled = true;
6510	}
6511
6512	if (at_file_supplied)
6513	close_at_file ();
6514	}
6515	else
6516	{
6517	obstack_grow (&obstack, gcc_input_filename,
6518	input_filename_length);
6519	arg_going = 1;
6520	}
6521	break;
6522
6523	case 'I':
6524	{
6525	struct spec_path_info info;
6526
6527	if (multilib_dir)
6528	{
6529	do_spec_1 (spec: "-imultilib", inswitch: 1, NULL);
6530	/* Make this a separate argument. */
6531	do_spec_1 (spec: " ", inswitch: 0, NULL);
6532	do_spec_1 (spec: multilib_dir, inswitch: 1, NULL);
6533	do_spec_1 (spec: " ", inswitch: 0, NULL);
6534	}
6535
6536	if (multiarch_dir)
6537	{
6538	do_spec_1 (spec: "-imultiarch", inswitch: 1, NULL);
6539	/* Make this a separate argument. */
6540	do_spec_1 (spec: " ", inswitch: 0, NULL);
6541	do_spec_1 (spec: multiarch_dir, inswitch: 1, NULL);
6542	do_spec_1 (spec: " ", inswitch: 0, NULL);
6543	}
6544
6545	if (gcc_exec_prefix)
6546	{
6547	do_spec_1 (spec: "-iprefix", inswitch: 1, NULL);
6548	/* Make this a separate argument. */
6549	do_spec_1 (spec: " ", inswitch: 0, NULL);
6550	do_spec_1 (spec: gcc_exec_prefix, inswitch: 1, NULL);
6551	do_spec_1 (spec: " ", inswitch: 0, NULL);
6552	}
6553
6554	if (target_system_root_changed ||
6555	(target_system_root && target_sysroot_hdrs_suffix))
6556	{
6557	do_spec_1 (spec: "-isysroot", inswitch: 1, NULL);
6558	/* Make this a separate argument. */
6559	do_spec_1 (spec: " ", inswitch: 0, NULL);
6560	do_spec_1 (spec: target_system_root, inswitch: 1, NULL);
6561	if (target_sysroot_hdrs_suffix)
6562	do_spec_1 (spec: target_sysroot_hdrs_suffix, inswitch: 1, NULL);
6563	do_spec_1 (spec: " ", inswitch: 0, NULL);
6564	}
6565
6566	info.option = "-isystem";
6567	info.append = "include";
6568	info.append_len = strlen (s: info.append);
6569	info.omit_relative = false;
6570	info.separate_options = true;
6571	info.realpaths = false;
6572
6573	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6574	callback: spec_path, callback_info: &info);
6575
6576	info.append = "include-fixed";
6577	if (*sysroot_hdrs_suffix_spec)
6578	info.append = concat (info.append, dir_separator_str,
6579	multilib_dir, NULL);
6580	else if (multiarch_dir)
6581	{
6582	/* For multiarch, search include-fixed/<multiarch-dir>
6583	before include-fixed. */
6584	info.append = concat (info.append, dir_separator_str,
6585	multiarch_dir, NULL);
6586	info.append_len = strlen (s: info.append);
6587	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6588	callback: spec_path, callback_info: &info);
6589
6590	info.append = "include-fixed";
6591	}
6592	info.append_len = strlen (s: info.append);
6593	for_each_path (paths: &include_prefixes, do_multi: false, extra_space: info.append_len,
6594	callback: spec_path, callback_info: &info);
6595	}
6596	break;
6597
6598	case 'o':
6599	/* We are going to expand `%o' into `@FILE', where FILE
6600	is a newly-created temporary filename. The filenames
6601	that would usually be expanded in place of %o will be
6602	written to the temporary file. */
6603	if (at_file_supplied)
6604	open_at_file ();
6605
6606	for (i = 0; i < n_infiles + lang_specific_extra_outfiles; i++)
6607	if (outfiles[i])
6608	store_arg (arg: outfiles[i], delete_always: 0, delete_failure: 0);
6609
6610	if (at_file_supplied)
6611	close_at_file ();
6612	break;
6613
6614	case 'O':
6615	obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
6616	arg_going = 1;
6617	break;
6618
6619	case 's':
6620	this_is_library_file = 1;
6621	break;
6622
6623	case 'T':
6624	this_is_linker_script = 1;
6625	break;
6626
6627	case 'V':
6628	outfiles[input_file_number] = NULL;
6629	break;
6630
6631	case 'w':
6632	this_is_output_file = 1;
6633	break;
6634
6635	case 'W':
6636	{
6637	unsigned int cur_index = argbuf.length ();
6638	/* Handle the {...} following the %W. */
6639	if (*p != '{')
6640	fatal_error (input_location,
6641	"spec %qs has invalid %<%%W%c%>", spec, *p);
6642	p = handle_braces (p + 1);
6643	if (p == 0)
6644	return -1;
6645	end_going_arg ();
6646	/* If any args were output, mark the last one for deletion
6647	on failure. */
6648	if (argbuf.length () != cur_index)
6649	record_temp_file (filename: argbuf.last (), always_delete: 0, fail_delete: 1);
6650	break;
6651	}
6652
6653	case '@':
6654	/* Handle the {...} following the %@. */
6655	if (*p != '{')
6656	fatal_error (input_location,
6657	"spec %qs has invalid %<%%@%c%>", spec, *p);
6658	if (at_file_supplied)
6659	open_at_file ();
6660	p = handle_braces (p + 1);
6661	if (at_file_supplied)
6662	close_at_file ();
6663	if (p == 0)
6664	return -1;
6665	break;
6666
6667	/* %x{OPTION} records OPTION for %X to output. */
6668	case 'x':
6669	{
6670	const char *p1 = p;
6671	char *string;
6672
6673	/* Skip past the option value and make a copy. */
6674	if (*p != '{')
6675	fatal_error (input_location,
6676	"spec %qs has invalid %<%%x%c%>", spec, *p);
6677	while (*p++ != '}')
6678	;
6679	string = save_string (p1 + 1, p - p1 - 2);
6680
6681	/* See if we already recorded this option. */
6682	for (const char *opt : linker_options)
6683	if (! strcmp (s1: string, s2: opt))
6684	{
6685	free (ptr: string);
6686	return 0;
6687	}
6688
6689	/* This option is new; add it. */
6690	add_linker_option (option: string, len: strlen (s: string));
6691	free (ptr: string);
6692	}
6693	break;
6694
6695	/* Dump out the options accumulated previously using %x. */
6696	case 'X':
6697	do_specs_vec (vec: linker_options);
6698	break;
6699
6700	/* Dump out the options accumulated previously using -Wa,. */
6701	case 'Y':
6702	do_specs_vec (vec: assembler_options);
6703	break;
6704
6705	/* Dump out the options accumulated previously using -Wp,. */
6706	case 'Z':
6707	do_specs_vec (vec: preprocessor_options);
6708	break;
6709
6710	/* Here are digits and numbers that just process
6711	a certain constant string as a spec. */
6712
6713	case '1':
6714	value = do_spec_1 (spec: cc1_spec, inswitch: 0, NULL);
6715	if (value != 0)
6716	return value;
6717	break;
6718
6719	case '2':
6720	value = do_spec_1 (spec: cc1plus_spec, inswitch: 0, NULL);
6721	if (value != 0)
6722	return value;
6723	break;
6724
6725	case 'a':
6726	value = do_spec_1 (spec: asm_spec, inswitch: 0, NULL);
6727	if (value != 0)
6728	return value;
6729	break;
6730
6731	case 'A':
6732	value = do_spec_1 (spec: asm_final_spec, inswitch: 0, NULL);
6733	if (value != 0)
6734	return value;
6735	break;
6736
6737	case 'C':
6738	{
6739	const char *const spec
6740	= (input_file_compiler->cpp_spec
6741	? input_file_compiler->cpp_spec
6742	: cpp_spec);
6743	value = do_spec_1 (spec, inswitch: 0, NULL);
6744	if (value != 0)
6745	return value;
6746	}
6747	break;
6748
6749	case 'E':
6750	value = do_spec_1 (spec: endfile_spec, inswitch: 0, NULL);
6751	if (value != 0)
6752	return value;
6753	break;
6754
6755	case 'l':
6756	value = do_spec_1 (spec: link_spec, inswitch: 0, NULL);
6757	if (value != 0)
6758	return value;
6759	break;
6760
6761	case 'L':
6762	value = do_spec_1 (spec: lib_spec, inswitch: 0, NULL);
6763	if (value != 0)
6764	return value;
6765	break;
6766
6767	case 'M':
6768	if (multilib_os_dir == NULL)
6769	obstack_1grow (&obstack, '.');
6770	else
6771	obstack_grow (&obstack, multilib_os_dir,
6772	strlen (multilib_os_dir));
6773	break;
6774
6775	case 'G':
6776	value = do_spec_1 (spec: libgcc_spec, inswitch: 0, NULL);
6777	if (value != 0)
6778	return value;
6779	break;
6780
6781	case 'R':
6782	/* We assume there is a directory
6783	separator at the end of this string. */
6784	if (target_system_root)
6785	{
6786	obstack_grow (&obstack, target_system_root,
6787	strlen (target_system_root));
6788	if (target_sysroot_suffix)
6789	obstack_grow (&obstack, target_sysroot_suffix,
6790	strlen (target_sysroot_suffix));
6791	}
6792	break;
6793
6794	case 'S':
6795	value = do_spec_1 (spec: startfile_spec, inswitch: 0, NULL);
6796	if (value != 0)
6797	return value;
6798	break;
6799
6800	/* Here we define characters other than letters and digits. */
6801
6802	case '{':
6803	p = handle_braces (p);
6804	if (p == 0)
6805	return -1;
6806	break;
6807
6808	case ':':
6809	p = handle_spec_function (p, NULL, soft_matched_part);
6810	if (p == 0)
6811	return -1;
6812	break;
6813
6814	case '%':
6815	obstack_1grow (&obstack, '%');
6816	break;
6817
6818	case '.':
6819	{
6820	unsigned len = 0;
6821
6822	while (p[len] && p[len] != ' ' && p[len] != '%')
6823	len++;
6824	suffix_subst = save_string (p - 1, len + 1);
6825	p += len;
6826	}
6827	break;
6828
6829	/* Henceforth ignore the option(s) matching the pattern
6830	after the %<. */
6831	case '<':
6832	case '>':
6833	{
6834	unsigned len = 0;
6835	int have_wildcard = 0;
6836	int i;
6837	int switch_option;
6838
6839	if (c == '>')
6840	switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
6841	else
6842	switch_option = SWITCH_IGNORE;
6843
6844	while (p[len] && p[len] != ' ' && p[len] != '\t')
6845	len++;
6846
6847	if (p[len-1] == '*')
6848	have_wildcard = 1;
6849
6850	for (i = 0; i < n_switches; i++)
6851	if (!strncmp (s1: switches[i].part1, s2: p, n: len - have_wildcard)
6852	&& (have_wildcard || switches[i].part1[len] == '\0'))
6853	{
6854	switches[i].live_cond |= switch_option;
6855	/* User switch be validated from validate_all_switches.
6856	when the definition is seen from the spec file.
6857	If not defined anywhere, will be rejected. */
6858	if (switches[i].known)
6859	switches[i].validated = true;
6860	}
6861
6862	p += len;
6863	}
6864	break;
6865
6866	case '*':
6867	if (soft_matched_part)
6868	{
6869	if (soft_matched_part[0])
6870	do_spec_1 (spec: soft_matched_part, inswitch: 1, NULL);
6871	/* Only insert a space after the substitution if it is at the
6872	end of the current sequence. So if:
6873
6874	"%{foo=*:bar%*}%{foo=*:one%*two}"
6875
6876	matches -foo=hello then it will produce:
6877
6878	barhello onehellotwo
6879	*/
6880	if (*p == 0 || *p == '}')
6881	do_spec_1 (spec: " ", inswitch: 0, NULL);
6882	}
6883	else
6884	/* Catch the case where a spec string contains something like
6885	'%{foo:%*}'. i.e. there is no * in the pattern on the left
6886	hand side of the :. */
6887	error ("spec failure: %<%%*%> has not been initialized by pattern match");
6888	break;
6889
6890	/* Process a string found as the value of a spec given by name.
6891	This feature allows individual machine descriptions
6892	to add and use their own specs. */
6893	case '(':
6894	{
6895	const char *name = p;
6896	struct spec_list *sl;
6897	int len;
6898
6899	/* The string after the S/P is the name of a spec that is to be
6900	processed. */
6901	while (*p && *p != ')')
6902	p++;
6903
6904	/* See if it's in the list. */
6905	for (len = p - name, sl = specs; sl; sl = sl->next)
6906	if (sl->name_len == len && !strncmp (s1: sl->name, s2: name, n: len))
6907	{
6908	name = *(sl->ptr_spec);
6909	#ifdef DEBUG_SPECS
6910	fnotice (stderr, "Processing spec (%s), which is '%s'\n",
6911	sl->name, name);
6912	#endif
6913	break;
6914	}
6915
6916	if (sl)
6917	{
6918	value = do_spec_1 (spec: name, inswitch: 0, NULL);
6919	if (value != 0)
6920	return value;
6921	}
6922
6923	/* Discard the closing paren. */
6924	if (*p)
6925	p++;
6926	}
6927	break;
6928
6929	case '"':
6930	/* End a previous argument, if there is one, then issue an
6931	empty argument. */
6932	end_going_arg ();
6933	arg_going = 1;
6934	end_going_arg ();
6935	break;
6936
6937	default:
6938	error ("spec failure: unrecognized spec option %qc", c);
6939	break;
6940	}
6941	break;
6942
6943	case '\\':
6944	/* Backslash: treat next character as ordinary. */
6945	c = *p++;
6946
6947	/* When adding more cases that previously matched default, make
6948	sure to adjust quote_spec_char_p as well. */
6949
6950	/* Fall through. */
6951	default:
6952	/* Ordinary character: put it into the current argument. */
6953	obstack_1grow (&obstack, c);
6954	arg_going = 1;
6955	}
6956
6957	/* End of string. If we are processing a spec function, we need to
6958	end any pending argument. */
6959	if (processing_spec_function)
6960	end_going_arg ();
6961
6962	return 0;
6963	}
6964
6965	/* Look up a spec function. */
6966
6967	static const struct spec_function *
6968	lookup_spec_function (const char *name)
6969	{
6970	const struct spec_function *sf;
6971
6972	for (sf = static_spec_functions; sf->name != NULL; sf++)
6973	if (strcmp (s1: sf->name, s2: name) == 0)
6974	return sf;
6975
6976	return NULL;
6977	}
6978
6979	/* Evaluate a spec function. */
6980
6981	static const char *
6982	eval_spec_function (const char *func, const char *args,
6983	const char *soft_matched_part)
6984	{
6985	const struct spec_function *sf;
6986	const char *funcval;
6987
6988	/* Saved spec processing context. */
6989	vec<const_char_p> save_argbuf;
6990
6991	int save_arg_going;
6992	int save_delete_this_arg;
6993	int save_this_is_output_file;
6994	int save_this_is_library_file;
6995	int save_input_from_pipe;
6996	int save_this_is_linker_script;
6997	const char *save_suffix_subst;
6998
6999	int save_growing_size;
7000	void *save_growing_value = NULL;
7001
7002	sf = lookup_spec_function (name: func);
7003	if (sf == NULL)
7004	fatal_error (input_location, "unknown spec function %qs", func);
7005
7006	/* Push the spec processing context. */
7007	save_argbuf = argbuf;
7008
7009	save_arg_going = arg_going;
7010	save_delete_this_arg = delete_this_arg;
7011	save_this_is_output_file = this_is_output_file;
7012	save_this_is_library_file = this_is_library_file;
7013	save_this_is_linker_script = this_is_linker_script;
7014	save_input_from_pipe = input_from_pipe;
7015	save_suffix_subst = suffix_subst;
7016
7017	/* If we have some object growing now, finalize it so the args and function
7018	eval proceed from a cleared context. This is needed to prevent the first
7019	constructed arg from mistakenly including the growing value. We'll push
7020	this value back on the obstack once the function evaluation is done, to
7021	restore a consistent processing context for our caller. This is fine as
7022	the address of growing objects isn't guaranteed to remain stable until
7023	they are finalized, and we expect this situation to be rare enough for
7024	the extra copy not to be an issue. */
7025	save_growing_size = obstack_object_size (&obstack);
7026	if (save_growing_size > 0)
7027	save_growing_value = obstack_finish (&obstack);
7028
7029	/* Create a new spec processing context, and build the function
7030	arguments. */
7031
7032	alloc_args ();
7033	if (do_spec_2 (spec: args, soft_matched_part) < 0)
7034	fatal_error (input_location, "error in arguments to spec function %qs",
7035	func);
7036
7037	/* argbuf_index is an index for the next argument to be inserted, and
7038	so contains the count of the args already inserted. */
7039
7040	funcval = (*sf->func) (argbuf.length (),
7041	argbuf.address ());
7042
7043	/* Pop the spec processing context. */
7044	argbuf.release ();
7045	argbuf = save_argbuf;
7046
7047	arg_going = save_arg_going;
7048	delete_this_arg = save_delete_this_arg;
7049	this_is_output_file = save_this_is_output_file;
7050	this_is_library_file = save_this_is_library_file;
7051	this_is_linker_script = save_this_is_linker_script;
7052	input_from_pipe = save_input_from_pipe;
7053	suffix_subst = save_suffix_subst;
7054
7055	if (save_growing_size > 0)
7056	obstack_grow (&obstack, save_growing_value, save_growing_size);
7057
7058	return funcval;
7059	}
7060
7061	/* Handle a spec function call of the form:
7062
7063	%:function(args)
7064
7065	ARGS is processed as a spec in a separate context and split into an
7066	argument vector in the normal fashion. The function returns a string
7067	containing a spec which we then process in the caller's context, or
7068	NULL if no processing is required.
7069
7070	If RETVAL_NONNULL is not NULL, then store a bool whether function
7071	returned non-NULL.
7072
7073	SOFT_MATCHED_PART holds the current value of a matched * pattern, which
7074	may be re-expanded with a %* as part of the function arguments. */
7075
7076	static const char *
7077	handle_spec_function (const char *p, bool *retval_nonnull,
7078	const char *soft_matched_part)
7079	{
7080	char *func, *args;
7081	const char *endp, *funcval;
7082	int count;
7083
7084	processing_spec_function++;
7085
7086	/* Get the function name. */
7087	for (endp = p; *endp != '\0'; endp++)
7088	{
7089	if (*endp == '(') /* ) */
7090	break;
7091	/* Only allow [A-Za-z0-9], -, and _ in function names. */
7092	if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
7093	fatal_error (input_location, "malformed spec function name");
7094	}
7095	if (*endp != '(') /* ) */
7096	fatal_error (input_location, "no arguments for spec function");
7097	func = save_string (p, endp - p);
7098	p = ++endp;
7099
7100	/* Get the arguments. */
7101	for (count = 0; *endp != '\0'; endp++)
7102	{
7103	/* ( */
7104	if (*endp == ')')
7105	{
7106	if (count == 0)
7107	break;
7108	count--;
7109	}
7110	else if (*endp == '(') /* ) */
7111	count++;
7112	}
7113	/* ( */
7114	if (*endp != ')')
7115	fatal_error (input_location, "malformed spec function arguments");
7116	args = save_string (p, endp - p);
7117	p = ++endp;
7118
7119	/* p now points to just past the end of the spec function expression. */
7120
7121	funcval = eval_spec_function (func, args, soft_matched_part);
7122	if (funcval != NULL && do_spec_1 (spec: funcval, inswitch: 0, NULL) < 0)
7123	p = NULL;
7124	if (retval_nonnull)
7125	*retval_nonnull = funcval != NULL;
7126
7127	free (ptr: func);
7128	free (ptr: args);
7129
7130	processing_spec_function--;
7131
7132	return p;
7133	}
7134
7135	/* Inline subroutine of handle_braces. Returns true if the current
7136	input suffix matches the atom bracketed by ATOM and END_ATOM. */
7137	static inline bool
7138	input_suffix_matches (const char *atom, const char *end_atom)
7139	{
7140	return (input_suffix
7141	&& !strncmp (s1: input_suffix, s2: atom, n: end_atom - atom)
7142	&& input_suffix[end_atom - atom] == '\0');
7143	}
7144
7145	/* Subroutine of handle_braces. Returns true if the current
7146	input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7147	static bool
7148	input_spec_matches (const char *atom, const char *end_atom)
7149	{
7150	return (input_file_compiler
7151	&& input_file_compiler->suffix
7152	&& input_file_compiler->suffix[0] != '\0'
7153	&& !strncmp (s1: input_file_compiler->suffix + 1, s2: atom,
7154	n: end_atom - atom)
7155	&& input_file_compiler->suffix[end_atom - atom + 1] == '\0');
7156	}
7157
7158	/* Subroutine of handle_braces. Returns true if a switch
7159	matching the atom bracketed by ATOM and END_ATOM appeared on the
7160	command line. */
7161	static bool
7162	switch_matches (const char *atom, const char *end_atom, int starred)
7163	{
7164	int i;
7165	int len = end_atom - atom;
7166	int plen = starred ? len : -1;
7167
7168	for (i = 0; i < n_switches; i++)
7169	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
7170	&& (starred || switches[i].part1[len] == '\0')
7171	&& check_live_switch (i, plen))
7172	return true;
7173
7174	/* Check if a switch with separated form matching the atom.
7175	We check -D and -U switches. */
7176	else if (switches[i].args != 0)
7177	{
7178	if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
7179	&& *switches[i].part1 == atom[0])
7180	{
7181	if (!strncmp (s1: switches[i].args[0], s2: &atom[1], n: len - 1)
7182	&& (starred || (switches[i].part1[1] == '\0'
7183	&& switches[i].args[0][len - 1] == '\0'))
7184	&& check_live_switch (i, (starred ? 1 : -1)))
7185	return true;
7186	}
7187	}
7188
7189	return false;
7190	}
7191
7192	/* Inline subroutine of handle_braces. Mark all of the switches which
7193	match ATOM (extends to END_ATOM; STARRED indicates whether there
7194	was a star after the atom) for later processing. */
7195	static inline void
7196	mark_matching_switches (const char *atom, const char *end_atom, int starred)
7197	{
7198	int i;
7199	int len = end_atom - atom;
7200	int plen = starred ? len : -1;
7201
7202	for (i = 0; i < n_switches; i++)
7203	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
7204	&& (starred || switches[i].part1[len] == '\0')
7205	&& check_live_switch (i, plen))
7206	switches[i].ordering = 1;
7207	}
7208
7209	/* Inline subroutine of handle_braces. Process all the currently
7210	marked switches through give_switch, and clear the marks. */
7211	static inline void
7212	process_marked_switches (void)
7213	{
7214	int i;
7215
7216	for (i = 0; i < n_switches; i++)
7217	if (switches[i].ordering == 1)
7218	{
7219	switches[i].ordering = 0;
7220	give_switch (i, 0);
7221	}
7222	}
7223
7224	/* Handle a %{ ... } construct. P points just inside the leading {.
7225	Returns a pointer one past the end of the brace block, or 0
7226	if we call do_spec_1 and that returns -1. */
7227
7228	static const char *
7229	handle_braces (const char *p)
7230	{
7231	const char *atom, *end_atom;
7232	const char *d_atom = NULL, *d_end_atom = NULL;
7233	char *esc_buf = NULL, *d_esc_buf = NULL;
7234	int esc;
7235	const char *orig = p;
7236
7237	bool a_is_suffix;
7238	bool a_is_spectype;
7239	bool a_is_starred;
7240	bool a_is_negated;
7241	bool a_matched;
7242
7243	bool a_must_be_last = false;
7244	bool ordered_set = false;
7245	bool disjunct_set = false;
7246	bool disj_matched = false;
7247	bool disj_starred = true;
7248	bool n_way_choice = false;
7249	bool n_way_matched = false;
7250
7251	#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7252
7253	do
7254	{
7255	if (a_must_be_last)
7256	goto invalid;
7257
7258	/* Scan one "atom" (S in the description above of %{}, possibly
7259	with '!', '.', '@', ',', or '*' modifiers). */
7260	a_matched = false;
7261	a_is_suffix = false;
7262	a_is_starred = false;
7263	a_is_negated = false;
7264	a_is_spectype = false;
7265
7266	SKIP_WHITE ();
7267	if (*p == '!')
7268	p++, a_is_negated = true;
7269
7270	SKIP_WHITE ();
7271	if (*p == '%' && p[1] == ':')
7272	{
7273	atom = NULL;
7274	end_atom = NULL;
7275	p = handle_spec_function (p: p + 2, retval_nonnull: &a_matched, NULL);
7276	}
7277	else
7278	{
7279	if (*p == '.')
7280	p++, a_is_suffix = true;
7281	else if (*p == ',')
7282	p++, a_is_spectype = true;
7283
7284	atom = p;
7285	esc = 0;
7286	while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7287	|| *p == ',' || *p == '.' || *p == '@' || *p == '\\')
7288	{
7289	if (*p == '\\')
7290	{
7291	p++;
7292	if (!*p)
7293	fatal_error (input_location,
7294	"braced spec %qs ends in escape", orig);
7295	esc++;
7296	}
7297	p++;
7298	}
7299	end_atom = p;
7300
7301	if (esc)
7302	{
7303	const char *ap;
7304	char *ep;
7305
7306	if (esc_buf && esc_buf != d_esc_buf)
7307	free (ptr: esc_buf);
7308	esc_buf = NULL;
7309	ep = esc_buf = (char *) xmalloc (end_atom - atom - esc + 1);
7310	for (ap = atom; ap != end_atom; ap++, ep++)
7311	{
7312	if (*ap == '\\')
7313	ap++;
7314	*ep = *ap;
7315	}
7316	*ep = '\0';
7317	atom = esc_buf;
7318	end_atom = ep;
7319	}
7320
7321	if (*p == '*')
7322	p++, a_is_starred = 1;
7323	}
7324
7325	SKIP_WHITE ();
7326	switch (*p)
7327	{
7328	case '&': case '}':
7329	/* Substitute the switch(es) indicated by the current atom. */
7330	ordered_set = true;
7331	if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
7332	|| a_is_spectype || atom == end_atom)
7333	goto invalid;
7334
7335	mark_matching_switches (atom, end_atom, starred: a_is_starred);
7336
7337	if (*p == '}')
7338	process_marked_switches ();
7339	break;
7340
7341	case '|': case ':':
7342	/* Substitute some text if the current atom appears as a switch
7343	or suffix. */
7344	disjunct_set = true;
7345	if (ordered_set)
7346	goto invalid;
7347
7348	if (atom && atom == end_atom)
7349	{
7350	if (!n_way_choice || disj_matched || *p == '|'
7351	|| a_is_negated || a_is_suffix || a_is_spectype
7352	|| a_is_starred)
7353	goto invalid;
7354
7355	/* An empty term may appear as the last choice of an
7356	N-way choice set; it means "otherwise". */
7357	a_must_be_last = true;
7358	disj_matched = !n_way_matched;
7359	disj_starred = false;
7360	}
7361	else
7362	{
7363	if ((a_is_suffix || a_is_spectype) && a_is_starred)
7364	goto invalid;
7365
7366	if (!a_is_starred)
7367	disj_starred = false;
7368
7369	/* Don't bother testing this atom if we already have a
7370	match. */
7371	if (!disj_matched && !n_way_matched)
7372	{
7373	if (atom == NULL)
7374	/* a_matched is already set by handle_spec_function. */;
7375	else if (a_is_suffix)
7376	a_matched = input_suffix_matches (atom, end_atom);
7377	else if (a_is_spectype)
7378	a_matched = input_spec_matches (atom, end_atom);
7379	else
7380	a_matched = switch_matches (atom, end_atom, starred: a_is_starred);
7381
7382	if (a_matched != a_is_negated)
7383	{
7384	disj_matched = true;
7385	d_atom = atom;
7386	d_end_atom = end_atom;
7387	d_esc_buf = esc_buf;
7388	}
7389	}
7390	}
7391
7392	if (*p == ':')
7393	{
7394	/* Found the body, that is, the text to substitute if the
7395	current disjunction matches. */
7396	p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
7397	disj_matched && !n_way_matched);
7398	if (p == 0)
7399	goto done;
7400
7401	/* If we have an N-way choice, reset state for the next
7402	disjunction. */
7403	if (*p == ';')
7404	{
7405	n_way_choice = true;
7406	n_way_matched |= disj_matched;
7407	disj_matched = false;
7408	disj_starred = true;
7409	d_atom = d_end_atom = NULL;
7410	}
7411	}
7412	break;
7413
7414	default:
7415	goto invalid;
7416	}
7417	}
7418	while (*p++ != '}');
7419
7420	done:
7421	if (d_esc_buf && d_esc_buf != esc_buf)
7422	free (ptr: d_esc_buf);
7423	if (esc_buf)
7424	free (ptr: esc_buf);
7425
7426	return p;
7427
7428	invalid:
7429	fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p);
7430
7431	#undef SKIP_WHITE
7432	}
7433
7434	/* Subroutine of handle_braces. Scan and process a brace substitution body
7435	(X in the description of %{} syntax). P points one past the colon;
7436	ATOM and END_ATOM bracket the first atom which was found to be true
7437	(present) in the current disjunction; STARRED indicates whether all
7438	the atoms in the current disjunction were starred (for syntax validation);
7439	MATCHED indicates whether the disjunction matched or not, and therefore
7440	whether or not the body is to be processed through do_spec_1 or just
7441	skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7442	returns -1. */
7443
7444	static const char *
7445	process_brace_body (const char *p, const char *atom, const char *end_atom,
7446	int starred, int matched)
7447	{
7448	const char *body, *end_body;
7449	unsigned int nesting_level;
7450	bool have_subst = false;
7451
7452	/* Locate the closing } or ;, honoring nested braces.
7453	Trim trailing whitespace. */
7454	body = p;
7455	nesting_level = 1;
7456	for (;;)
7457	{
7458	if (*p == '{')
7459	nesting_level++;
7460	else if (*p == '}')
7461	{
7462	if (!--nesting_level)
7463	break;
7464	}
7465	else if (*p == ';' && nesting_level == 1)
7466	break;
7467	else if (*p == '%' && p[1] == '*' && nesting_level == 1)
7468	have_subst = true;
7469	else if (*p == '\0')
7470	goto invalid;
7471	p++;
7472	}
7473
7474	end_body = p;
7475	while (end_body[-1] == ' ' || end_body[-1] == '\t')
7476	end_body--;
7477
7478	if (have_subst && !starred)
7479	goto invalid;
7480
7481	if (matched)
7482	{
7483	/* Copy the substitution body to permanent storage and execute it.
7484	If have_subst is false, this is a simple matter of running the
7485	body through do_spec_1... */
7486	char *string = save_string (body, end_body - body);
7487	if (!have_subst)
7488	{
7489	if (do_spec_1 (spec: string, inswitch: 0, NULL) < 0)
7490	{
7491	free (ptr: string);
7492	return 0;
7493	}
7494	}
7495	else
7496	{
7497	/* ... but if have_subst is true, we have to process the
7498	body once for each matching switch, with %* set to the
7499	variant part of the switch. */
7500	unsigned int hard_match_len = end_atom - atom;
7501	int i;
7502
7503	for (i = 0; i < n_switches; i++)
7504	if (!strncmp (s1: switches[i].part1, s2: atom, n: hard_match_len)
7505	&& check_live_switch (i, hard_match_len))
7506	{
7507	if (do_spec_1 (spec: string, inswitch: 0,
7508	soft_matched_part: &switches[i].part1[hard_match_len]) < 0)
7509	{
7510	free (ptr: string);
7511	return 0;
7512	}
7513	/* Pass any arguments this switch has. */
7514	give_switch (i, 1);
7515	suffix_subst = NULL;
7516	}
7517	}
7518	free (ptr: string);
7519	}
7520
7521	return p;
7522
7523	invalid:
7524	fatal_error (input_location, "braced spec body %qs is invalid", body);
7525	}
7526
7527	/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7528	on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7529	spec, or -1 if either exact match or %* is used.
7530
7531	A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7532	whose value does not begin with "no-" is obsoleted by the same value
7533	with the "no-", similarly for a switch with the "no-" prefix. */
7534
7535	static int
7536	check_live_switch (int switchnum, int prefix_length)
7537	{
7538	const char *name = switches[switchnum].part1;
7539	int i;
7540
7541	/* If we already processed this switch and determined if it was
7542	live or not, return our past determination. */
7543	if (switches[switchnum].live_cond != 0)
7544	return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
7545	&& (switches[switchnum].live_cond & SWITCH_FALSE) == 0
7546	&& (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
7547	== 0);
7548
7549	/* In the common case of {<at-most-one-letter>*}, a negating
7550	switch would always match, so ignore that case. We will just
7551	send the conflicting switches to the compiler phase. */
7552	if (prefix_length >= 0 && prefix_length <= 1)
7553	return 1;
7554
7555	/* Now search for duplicate in a manner that depends on the name. */
7556	switch (*name)
7557	{
7558	case 'O':
7559	for (i = switchnum + 1; i < n_switches; i++)
7560	if (switches[i].part1[0] == 'O')
7561	{
7562	switches[switchnum].validated = true;
7563	switches[switchnum].live_cond = SWITCH_FALSE;
7564	return 0;
7565	}
7566	break;
7567
7568	case 'W': case 'f': case 'm': case 'g':
7569	if (startswith (str: name + 1, prefix: "no-"))
7570	{
7571	/* We have Xno-YYY, search for XYYY. */
7572	for (i = switchnum + 1; i < n_switches; i++)
7573	if (switches[i].part1[0] == name[0]
7574	&& ! strcmp (s1: &switches[i].part1[1], s2: &name[4]))
7575	{
7576	/* --specs are validated with the validate_switches mechanism. */
7577	if (switches[switchnum].known)
7578	switches[switchnum].validated = true;
7579	switches[switchnum].live_cond = SWITCH_FALSE;
7580	return 0;
7581	}
7582	}
7583	else
7584	{
7585	/* We have XYYY, search for Xno-YYY. */
7586	for (i = switchnum + 1; i < n_switches; i++)
7587	if (switches[i].part1[0] == name[0]
7588	&& switches[i].part1[1] == 'n'
7589	&& switches[i].part1[2] == 'o'
7590	&& switches[i].part1[3] == '-'
7591	&& !strcmp (s1: &switches[i].part1[4], s2: &name[1]))
7592	{
7593	/* --specs are validated with the validate_switches mechanism. */
7594	if (switches[switchnum].known)
7595	switches[switchnum].validated = true;
7596	switches[switchnum].live_cond = SWITCH_FALSE;
7597	return 0;
7598	}
7599	}
7600	break;
7601	}
7602
7603	/* Otherwise the switch is live. */
7604	switches[switchnum].live_cond |= SWITCH_LIVE;
7605	return 1;
7606	}
7607
7608	/* Pass a switch to the current accumulating command
7609	in the same form that we received it.
7610	SWITCHNUM identifies the switch; it is an index into
7611	the vector of switches gcc received, which is `switches'.
7612	This cannot fail since it never finishes a command line.
7613
7614	If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7615
7616	static void
7617	give_switch (int switchnum, int omit_first_word)
7618	{
7619	if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
7620	return;
7621
7622	if (!omit_first_word)
7623	{
7624	do_spec_1 (spec: "-", inswitch: 0, NULL);
7625	do_spec_1 (spec: switches[switchnum].part1, inswitch: 1, NULL);
7626	}
7627
7628	if (switches[switchnum].args != 0)
7629	{
7630	const char **p;
7631	for (p = switches[switchnum].args; *p; p++)
7632	{
7633	const char *arg = *p;
7634
7635	do_spec_1 (spec: " ", inswitch: 0, NULL);
7636	if (suffix_subst)
7637	{
7638	unsigned length = strlen (s: arg);
7639	int dot = 0;
7640
7641	while (length-- && !IS_DIR_SEPARATOR (arg[length]))
7642	if (arg[length] == '.')
7643	{
7644	(CONST_CAST (char *, arg))[length] = 0;
7645	dot = 1;
7646	break;
7647	}
7648	do_spec_1 (spec: arg, inswitch: 1, NULL);
7649	if (dot)
7650	(CONST_CAST (char *, arg))[length] = '.';
7651	do_spec_1 (spec: suffix_subst, inswitch: 1, NULL);
7652	}
7653	else
7654	do_spec_1 (spec: arg, inswitch: 1, NULL);
7655	}
7656	}
7657
7658	do_spec_1 (spec: " ", inswitch: 0, NULL);
7659	switches[switchnum].validated = true;
7660	}
7661
7662	/* Print GCC configuration (e.g. version, thread model, target,
7663	configuration_arguments) to a given FILE. */
7664
7665	static void
7666	print_configuration (FILE *file)
7667	{
7668	int n;
7669	const char *thrmod;
7670
7671	fnotice (file, "Target: %s\n", spec_machine);
7672	fnotice (file, "Configured with: %s\n", configuration_arguments);
7673
7674	#ifdef THREAD_MODEL_SPEC
7675	/* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7676	but there's no point in doing all this processing just to get
7677	thread_model back. */
7678	obstack_init (&obstack);
7679	do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7680	obstack_1grow (&obstack, '\0');
7681	thrmod = XOBFINISH (&obstack, const char *);
7682	#else
7683	thrmod = thread_model;
7684	#endif
7685
7686	fnotice (file, "Thread model: %s\n", thrmod);
7687	fnotice (file, "Supported LTO compression algorithms: zlib");
7688	#ifdef HAVE_ZSTD_H
7689	fnotice (file, " zstd");
7690	#endif
7691	fnotice (file, "\n");
7692
7693	/* compiler_version is truncated at the first space when initialized
7694	from version string, so truncate version_string at the first space
7695	before comparing. */
7696	for (n = 0; version_string[n]; n++)
7697	if (version_string[n] == ' ')
7698	break;
7699
7700	if (! strncmp (version_string, s2: compiler_version, n: n)
7701	&& compiler_version[n] == 0)
7702	fnotice (file, "gcc version %s %s\n", version_string,
7703	pkgversion_string);
7704	else
7705	fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n",
7706	version_string, pkgversion_string, compiler_version);
7707
7708	}
7709
7710	#define RETRY_ICE_ATTEMPTS 3
7711
7712	/* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7713
7714	static bool
7715	files_equal_p (char *file1, char *file2)
7716	{
7717	struct stat st1, st2;
7718	off_t n, len;
7719	int fd1, fd2;
7720	const int bufsize = 8192;
7721	char *buf = XNEWVEC (char, bufsize);
7722
7723	fd1 = open (file: file1, O_RDONLY);
7724	fd2 = open (file: file2, O_RDONLY);
7725
7726	if (fd1 < 0 || fd2 < 0)
7727	goto error;
7728
7729	if (fstat (fd: fd1, buf: &st1) < 0 || fstat (fd: fd2, buf: &st2) < 0)
7730	goto error;
7731
7732	if (st1.st_size != st2.st_size)
7733	goto error;
7734
7735	for (n = st1.st_size; n; n -= len)
7736	{
7737	len = n;
7738	if ((int) len > bufsize / 2)
7739	len = bufsize / 2;
7740
7741	if (read (fd: fd1, buf: buf, nbytes: len) != (int) len
7742	|| read (fd: fd2, buf: buf + bufsize / 2, nbytes: len) != (int) len)
7743	{
7744	goto error;
7745	}
7746
7747	if (memcmp (s1: buf, s2: buf + bufsize / 2, n: len) != 0)
7748	goto error;
7749	}
7750
7751	free (ptr: buf);
7752	close (fd: fd1);
7753	close (fd: fd2);
7754
7755	return 1;
7756
7757	error:
7758	free (ptr: buf);
7759	close (fd: fd1);
7760	close (fd: fd2);
7761	return 0;
7762	}
7763
7764	/* Check that compiler's output doesn't differ across runs.
7765	TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7766	stdout and stderr for each compiler run. Return true if all of
7767	TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7768
7769	static bool
7770	check_repro (char **temp_stdout_files, char **temp_stderr_files)
7771	{
7772	int i;
7773	for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i)
7774	{
7775	if (!files_equal_p (file1: temp_stdout_files[i], file2: temp_stdout_files[i + 1])
7776	|| !files_equal_p (file1: temp_stderr_files[i], file2: temp_stderr_files[i + 1]))
7777	{
7778	fnotice (stderr, "The bug is not reproducible, so it is"
7779	" likely a hardware or OS problem.\n");
7780	break;
7781	}
7782	}
7783	return i == RETRY_ICE_ATTEMPTS - 2;
7784	}
7785
7786	enum attempt_status {
7787	ATTEMPT_STATUS_FAIL_TO_RUN,
7788	ATTEMPT_STATUS_SUCCESS,
7789	ATTEMPT_STATUS_ICE
7790	};
7791
7792
7793	/* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7794	to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7795	and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7796	GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7797	compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7798	ATTEMPT_STATUS_SUCCESS otherwise. */
7799
7800	static enum attempt_status
7801	run_attempt (const char **new_argv, const char *out_temp,
7802	const char *err_temp, int emit_system_info, int append)
7803	{
7804
7805	if (emit_system_info)
7806	{
7807	FILE *file_out = fopen (filename: err_temp, modes: "a");
7808	print_configuration (file: file_out);
7809	fputs (s: "\n", stream: file_out);
7810	fclose (stream: file_out);
7811	}
7812
7813	int exit_status;
7814	const char *errmsg;
7815	struct pex_obj *pex;
7816	int err;
7817	int pex_flags = PEX_USE_PIPES | PEX_LAST;
7818	enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN;
7819
7820	if (append)
7821	pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND;
7822
7823	pex = pex_init (PEX_USE_PIPES, pname: new_argv[0], NULL);
7824	if (!pex)
7825	fatal_error (input_location, "%<pex_init%> failed: %m");
7826
7827	errmsg = pex_run (obj: pex, flags: pex_flags, executable: new_argv[0],
7828	CONST_CAST2 (char *const *, const char **, &new_argv[1]),
7829	outname: out_temp, errname: err_temp, err: &err);
7830	if (errmsg != NULL)
7831	{
7832	errno = err;
7833	fatal_error (input_location,
7834	err ? G_ ("cannot execute %qs: %s: %m")
7835	: G_ ("cannot execute %qs: %s"),
7836	new_argv[0], errmsg);
7837	}
7838
7839	if (!pex_get_status (pex, count: 1, vector: &exit_status))
7840	goto out;
7841
7842	switch (WEXITSTATUS (exit_status))
7843	{
7844	case ICE_EXIT_CODE:
7845	status = ATTEMPT_STATUS_ICE;
7846	break;
7847
7848	case SUCCESS_EXIT_CODE:
7849	status = ATTEMPT_STATUS_SUCCESS;
7850	break;
7851
7852	default:
7853	;
7854	}
7855
7856	out:
7857	pex_free (pex);
7858	return status;
7859	}
7860
7861	/* This routine reads lines from IN file, adds C++ style comments
7862	at the begining of each line and writes result into OUT. */
7863
7864	static void
7865	insert_comments (const char *file_in, const char *file_out)
7866	{
7867	FILE *in = fopen (filename: file_in, modes: "rb");
7868	FILE *out = fopen (filename: file_out, modes: "wb");
7869	char line[256];
7870
7871	bool add_comment = true;
7872	while (fgets (s: line, n: sizeof (line), stream: in))
7873	{
7874	if (add_comment)
7875	fputs (s: "// ", stream: out);
7876	fputs (s: line, stream: out);
7877	add_comment = strchr (s: line, c: '\n') != NULL;
7878	}
7879
7880	fclose (stream: in);
7881	fclose (stream: out);
7882	}
7883
7884	/* This routine adds preprocessed source code into the given ERR_FILE.
7885	To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7886	add information in report file. RUN_ATTEMPT should return
7887	ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7888
7889	static void
7890	do_report_bug (const char **new_argv, const int nargs,
7891	char **out_file, char **err_file)
7892	{
7893	int i, status;
7894	int fd = open (file: *out_file, O_RDWR | O_APPEND);
7895	if (fd < 0)
7896	return;
7897	write (fd: fd, buf: "\n//", n: 3);
7898	for (i = 0; i < nargs; i++)
7899	{
7900	write (fd: fd, buf: " ", n: 1);
7901	write (fd: fd, buf: new_argv[i], n: strlen (s: new_argv[i]));
7902	}
7903	write (fd: fd, buf: "\n\n", n: 2);
7904	close (fd: fd);
7905	new_argv[nargs] = "-E";
7906	new_argv[nargs + 1] = NULL;
7907
7908	status = run_attempt (new_argv, out_temp: *out_file, err_temp: *err_file, emit_system_info: 0, append: 1);
7909
7910	if (status == ATTEMPT_STATUS_SUCCESS)
7911	{
7912	fnotice (stderr, "Preprocessed source stored into %s file,"
7913	" please attach this to your bugreport.\n", *out_file);
7914	/* Make sure it is not deleted. */
7915	free (ptr: *out_file);
7916	*out_file = NULL;
7917	}
7918	}
7919
7920	/* Try to reproduce ICE. If bug is reproducible, generate report .err file
7921	containing GCC configuration, backtrace, compiler's command line options
7922	and preprocessed source code. */
7923
7924	static void
7925	try_generate_repro (const char **argv)
7926	{
7927	int i, nargs, out_arg = -1, quiet = 0, attempt;
7928	const char **new_argv;
7929	char *temp_files[RETRY_ICE_ATTEMPTS * 2];
7930	char **temp_stdout_files = &temp_files[0];
7931	char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS];
7932
7933	if (gcc_input_filename == NULL || ! strcmp (s1: gcc_input_filename, s2: "-"))
7934	return;
7935
7936	for (nargs = 0; argv[nargs] != NULL; ++nargs)
7937	/* Only retry compiler ICEs, not preprocessor ones. */
7938	if (! strcmp (s1: argv[nargs], s2: "-E"))
7939	return;
7940	else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o')
7941	{
7942	if (out_arg == -1)
7943	out_arg = nargs;
7944	else
7945	return;
7946	}
7947	/* If the compiler is going to output any time information,
7948	it might varry between invocations. */
7949	else if (! strcmp (s1: argv[nargs], s2: "-quiet"))
7950	quiet = 1;
7951	else if (! strcmp (s1: argv[nargs], s2: "-ftime-report"))
7952	return;
7953
7954	if (out_arg == -1 || !quiet)
7955	return;
7956
7957	memset (s: temp_files, c: '\0', n: sizeof (temp_files));
7958	new_argv = XALLOCAVEC (const char *, nargs + 4);
7959	memcpy (dest: new_argv, src: argv, n: (nargs + 1) * sizeof (const char *));
7960	new_argv[nargs++] = "-frandom-seed=0";
7961	new_argv[nargs++] = "-fdump-noaddr";
7962	new_argv[nargs] = NULL;
7963	if (new_argv[out_arg][2] == '\0')
7964	new_argv[out_arg + 1] = "-";
7965	else
7966	new_argv[out_arg] = "-o-";
7967
7968	int status;
7969	for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt)
7970	{
7971	int emit_system_info = 0;
7972	int append = 0;
7973	temp_stdout_files[attempt] = make_temp_file (".out");
7974	temp_stderr_files[attempt] = make_temp_file (".err");
7975
7976	if (attempt == RETRY_ICE_ATTEMPTS - 1)
7977	{
7978	append = 1;
7979	emit_system_info = 1;
7980	}
7981
7982	status = run_attempt (new_argv, out_temp: temp_stdout_files[attempt],
7983	err_temp: temp_stderr_files[attempt], emit_system_info,
7984	append);
7985
7986	if (status != ATTEMPT_STATUS_ICE)
7987	{
7988	fnotice (stderr, "The bug is not reproducible, so it is"
7989	" likely a hardware or OS problem.\n");
7990	goto out;
7991	}
7992	}
7993
7994	if (!check_repro (temp_stdout_files, temp_stderr_files))
7995	goto out;
7996
7997	{
7998	/* Insert commented out backtrace into report file. */
7999	char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
8000	insert_comments (file_in: temp_stderr_files[RETRY_ICE_ATTEMPTS - 1],
8001	file_out: *stderr_commented);
8002
8003	/* In final attempt we append compiler options and preprocesssed code to last
8004	generated .out file with configuration and backtrace. */
8005	char **err = &temp_stderr_files[RETRY_ICE_ATTEMPTS - 1];
8006	do_report_bug (new_argv, nargs, out_file: stderr_commented, err_file: err);
8007	}
8008
8009	out:
8010	for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++)
8011	if (temp_files[i])
8012	{
8013	unlink (name: temp_stdout_files[i]);
8014	free (ptr: temp_stdout_files[i]);
8015	}
8016	}
8017
8018	/* Search for a file named NAME trying various prefixes including the
8019	user's -B prefix and some standard ones.
8020	Return the absolute file name found. If nothing is found, return NAME. */
8021
8022	static const char *
8023	find_file (const char *name)
8024	{
8025	char *newname = find_a_file (pprefix: &startfile_prefixes, name, R_OK, do_multi: true);
8026	return newname ? newname : name;
8027	}
8028
8029	/* Determine whether a directory exists. If LINKER, return 0 for
8030	certain fixed names not needed by the linker. */
8031
8032	static int
8033	is_directory (const char *path1, bool linker)
8034	{
8035	int len1;
8036	char *path;
8037	char *cp;
8038	struct stat st;
8039
8040	/* Ensure the string ends with "/.". The resulting path will be a
8041	directory even if the given path is a symbolic link. */
8042	len1 = strlen (s: path1);
8043	path = (char *) alloca (3 + len1);
8044	memcpy (dest: path, src: path1, n: len1);
8045	cp = path + len1;
8046	if (!IS_DIR_SEPARATOR (cp[-1]))
8047	*cp++ = DIR_SEPARATOR;
8048	*cp++ = '.';
8049	*cp = '\0';
8050
8051	/* Exclude directories that the linker is known to search. */
8052	if (linker
8053	&& IS_DIR_SEPARATOR (path[0])
8054	&& ((cp - path == 6
8055	&& filename_ncmp (s1: path + 1, s2: "lib", n: 3) == 0)
8056	|| (cp - path == 10
8057	&& filename_ncmp (s1: path + 1, s2: "usr", n: 3) == 0
8058	&& IS_DIR_SEPARATOR (path[4])
8059	&& filename_ncmp (s1: path + 5, s2: "lib", n: 3) == 0)))
8060	return 0;
8061
8062	return (stat (file: path, buf: &st) >= 0 && S_ISDIR (st.st_mode));
8063	}
8064
8065	/* Set up the various global variables to indicate that we're processing
8066	the input file named FILENAME. */
8067
8068	void
8069	set_input (const char *filename)
8070	{
8071	const char *p;
8072
8073	gcc_input_filename = filename;
8074	input_filename_length = strlen (s: gcc_input_filename);
8075	input_basename = lbasename (gcc_input_filename);
8076
8077	/* Find a suffix starting with the last period,
8078	and set basename_length to exclude that suffix. */
8079	basename_length = strlen (s: input_basename);
8080	suffixed_basename_length = basename_length;
8081	p = input_basename + basename_length;
8082	while (p != input_basename && *p != '.')
8083	--p;
8084	if (*p == '.' && p != input_basename)
8085	{
8086	basename_length = p - input_basename;
8087	input_suffix = p + 1;
8088	}
8089	else
8090	input_suffix = "";
8091
8092	/* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
8093	we will need to do a stat on the gcc_input_filename. The
8094	INPUT_STAT_SET signals that the stat is needed. */
8095	input_stat_set = 0;
8096	}
8097
8098	/* On fatal signals, delete all the temporary files. */
8099
8100	static void
8101	fatal_signal (int signum)
8102	{
8103	signal (sig: signum, SIG_DFL);
8104	delete_failure_queue ();
8105	delete_temp_files ();
8106	/* Get the same signal again, this time not handled,
8107	so its normal effect occurs. */
8108	kill (pid: getpid (), sig: signum);
8109	}
8110
8111	/* Compare the contents of the two files named CMPFILE[0] and
8112	CMPFILE[1]. Return zero if they're identical, nonzero
8113	otherwise. */
8114
8115	static int
8116	compare_files (char *cmpfile[])
8117	{
8118	int ret = 0;
8119	FILE *temp[2] = { NULL, NULL };
8120	int i;
8121
8122	#if HAVE_MMAP_FILE
8123	{
8124	size_t length[2];
8125	void *map[2] = { NULL, NULL };
8126
8127	for (i = 0; i < 2; i++)
8128	{
8129	struct stat st;
8130
8131	if (stat (file: cmpfile[i], buf: &st) < 0 || !S_ISREG (st.st_mode))
8132	{
8133	error ("%s: could not determine length of compare-debug file %s",
8134	gcc_input_filename, cmpfile[i]);
8135	ret = 1;
8136	break;
8137	}
8138
8139	length[i] = st.st_size;
8140	}
8141
8142	if (!ret && length[0] != length[1])
8143	{
8144	error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename);
8145	ret = 1;
8146	}
8147
8148	if (!ret)
8149	for (i = 0; i < 2; i++)
8150	{
8151	int fd = open (file: cmpfile[i], O_RDONLY);
8152	if (fd < 0)
8153	{
8154	error ("%s: could not open compare-debug file %s",
8155	gcc_input_filename, cmpfile[i]);
8156	ret = 1;
8157	break;
8158	}
8159
8160	map[i] = mmap (NULL, len: length[i], PROT_READ, MAP_PRIVATE, fd: fd, offset: 0);
8161	close (fd: fd);
8162
8163	if (map[i] == (void *) MAP_FAILED)
8164	{
8165	ret = -1;
8166	break;
8167	}
8168	}
8169
8170	if (!ret)
8171	{
8172	if (memcmp (s1: map[0], s2: map[1], n: length[0]) != 0)
8173	{
8174	error ("%s: %<-fcompare-debug%> failure", gcc_input_filename);
8175	ret = 1;
8176	}
8177	}
8178
8179	for (i = 0; i < 2; i++)
8180	if (map[i])
8181	munmap (addr: (caddr_t) map[i], len: length[i]);
8182
8183	if (ret >= 0)
8184	return ret;
8185
8186	ret = 0;
8187	}
8188	#endif
8189
8190	for (i = 0; i < 2; i++)
8191	{
8192	temp[i] = fopen (filename: cmpfile[i], modes: "r");
8193	if (!temp[i])
8194	{
8195	error ("%s: could not open compare-debug file %s",
8196	gcc_input_filename, cmpfile[i]);
8197	ret = 1;
8198	break;
8199	}
8200	}
8201
8202	if (!ret && temp[0] && temp[1])
8203	for (;;)
8204	{
8205	int c0, c1;
8206	c0 = fgetc (stream: temp[0]);
8207	c1 = fgetc (stream: temp[1]);
8208
8209	if (c0 != c1)
8210	{
8211	error ("%s: %<-fcompare-debug%> failure",
8212	gcc_input_filename);
8213	ret = 1;
8214	break;
8215	}
8216
8217	if (c0 == EOF)
8218	break;
8219	}
8220
8221	for (i = 1; i >= 0; i--)
8222	{
8223	if (temp[i])
8224	fclose (stream: temp[i]);
8225	}
8226
8227	return ret;
8228	}
8229
8230	driver::driver (bool can_finalize, bool debug) :
8231	explicit_link_files (NULL),
8232	decoded_options (NULL)
8233	{
8234	env.init (can_restore: can_finalize, debug);
8235	}
8236
8237	driver::~driver ()
8238	{
8239	XDELETEVEC (explicit_link_files);
8240	XDELETEVEC (decoded_options);
8241	}
8242
8243	/* driver::main is implemented as a series of driver:: method calls. */
8244
8245	int
8246	driver::main (int argc, char **argv)
8247	{
8248	bool early_exit;
8249
8250	set_progname (argv[0]);
8251	expand_at_files (argc: &argc, argv: &argv);
8252	decode_argv (argc, argv: const_cast <const char **> (argv));
8253	global_initializations ();
8254	build_multilib_strings ();
8255	set_up_specs ();
8256	putenv_COLLECT_AS_OPTIONS (vec: assembler_options);
8257	putenv_COLLECT_GCC (argv0: argv[0]);
8258	maybe_putenv_COLLECT_LTO_WRAPPER ();
8259	maybe_putenv_OFFLOAD_TARGETS ();
8260	handle_unrecognized_options ();
8261
8262	if (completion)
8263	{
8264	m_option_proposer.suggest_completion (option_prefix: completion);
8265	return 0;
8266	}
8267
8268	if (!maybe_print_and_exit ())
8269	return 0;
8270
8271	early_exit = prepare_infiles ();
8272	if (early_exit)
8273	return get_exit_code ();
8274
8275	do_spec_on_infiles ();
8276	maybe_run_linker (argv0: argv[0]);
8277	final_actions ();
8278	return get_exit_code ();
8279	}
8280
8281	/* Locate the final component of argv[0] after any leading path, and set
8282	the program name accordingly. */
8283
8284	void
8285	driver::set_progname (const char *argv0) const
8286	{
8287	const char *p = argv0 + strlen (s: argv0);
8288	while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
8289	--p;
8290	progname = p;
8291
8292	xmalloc_set_program_name (progname);
8293	}
8294
8295	/* Expand any @ files within the command-line args,
8296	setting at_file_supplied if any were expanded. */
8297
8298	void
8299	driver::expand_at_files (int *argc, char ***argv) const
8300	{
8301	char **old_argv = *argv;
8302
8303	expandargv (argc, argv);
8304
8305	/* Determine if any expansions were made. */
8306	if (*argv != old_argv)
8307	at_file_supplied = true;
8308	}
8309
8310	/* Decode the command-line arguments from argc/argv into the
8311	decoded_options array. */
8312
8313	void
8314	driver::decode_argv (int argc, const char **argv)
8315	{
8316	init_opts_obstack ();
8317	init_options_struct (opts: &global_options, opts_set: &global_options_set);
8318
8319	decode_cmdline_options_to_array (argc, argv,
8320	CL_DRIVER,
8321	decoded_options: &decoded_options, decoded_options_count: &decoded_options_count);
8322	}
8323
8324	/* Perform various initializations and setup. */
8325
8326	void
8327	driver::global_initializations ()
8328	{
8329	/* Unlock the stdio streams. */
8330	unlock_std_streams ();
8331
8332	gcc_init_libintl ();
8333
8334	diagnostic_initialize (context: global_dc, n_opts: 0);
8335	diagnostic_color_init (context: global_dc);
8336	diagnostic_urls_init (context: global_dc);
8337	global_dc->set_urlifier (make_gcc_urlifier (lang_mask: 0));
8338
8339	#ifdef GCC_DRIVER_HOST_INITIALIZATION
8340	/* Perform host dependent initialization when needed. */
8341	GCC_DRIVER_HOST_INITIALIZATION;
8342	#endif
8343
8344	if (atexit (func: delete_temp_files) != 0)
8345	fatal_error (input_location, "atexit failed");
8346
8347	if (signal (SIGINT, SIG_IGN) != SIG_IGN)
8348	signal (SIGINT, handler: fatal_signal);
8349	#ifdef SIGHUP
8350	if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
8351	signal (SIGHUP, handler: fatal_signal);
8352	#endif
8353	if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
8354	signal (SIGTERM, handler: fatal_signal);
8355	#ifdef SIGPIPE
8356	if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
8357	signal (SIGPIPE, handler: fatal_signal);
8358	#endif
8359	#ifdef SIGCHLD
8360	/* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8361	receive the signal. A different setting is inheritable */
8362	signal (SIGCHLD, SIG_DFL);
8363	#endif
8364
8365	/* Parsing and gimplification sometimes need quite large stack.
8366	Increase stack size limits if possible. */
8367	stack_limit_increase (64 * 1024 * 1024);
8368
8369	/* Allocate the argument vector. */
8370	alloc_args ();
8371
8372	obstack_init (&obstack);
8373	}
8374
8375	/* Build multilib_select, et. al from the separate lines that make up each
8376	multilib selection. */
8377
8378	void
8379	driver::build_multilib_strings () const
8380	{
8381	{
8382	const char *p;
8383	const char *const *q = multilib_raw;
8384	int need_space;
8385
8386	obstack_init (&multilib_obstack);
8387	while ((p = *q++) != (char *) 0)
8388	obstack_grow (&multilib_obstack, p, strlen (p));
8389
8390	obstack_1grow (&multilib_obstack, 0);
8391	multilib_select = XOBFINISH (&multilib_obstack, const char *);
8392
8393	q = multilib_matches_raw;
8394	while ((p = *q++) != (char *) 0)
8395	obstack_grow (&multilib_obstack, p, strlen (p));
8396
8397	obstack_1grow (&multilib_obstack, 0);
8398	multilib_matches = XOBFINISH (&multilib_obstack, const char *);
8399
8400	q = multilib_exclusions_raw;
8401	while ((p = *q++) != (char *) 0)
8402	obstack_grow (&multilib_obstack, p, strlen (p));
8403
8404	obstack_1grow (&multilib_obstack, 0);
8405	multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
8406
8407	q = multilib_reuse_raw;
8408	while ((p = *q++) != (char *) 0)
8409	obstack_grow (&multilib_obstack, p, strlen (p));
8410
8411	obstack_1grow (&multilib_obstack, 0);
8412	multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
8413
8414	need_space = false;
8415	for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
8416	{
8417	if (need_space)
8418	obstack_1grow (&multilib_obstack, ' ');
8419	obstack_grow (&multilib_obstack,
8420	multilib_defaults_raw[i],
8421	strlen (multilib_defaults_raw[i]));
8422	need_space = true;
8423	}
8424
8425	obstack_1grow (&multilib_obstack, 0);
8426	multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
8427	}
8428	}
8429
8430	/* Set up the spec-handling machinery. */
8431
8432	void
8433	driver::set_up_specs () const
8434	{
8435	const char *spec_machine_suffix;
8436	char *specs_file;
8437	size_t i;
8438
8439	#ifdef INIT_ENVIRONMENT
8440	/* Set up any other necessary machine specific environment variables. */
8441	xputenv (INIT_ENVIRONMENT);
8442	#endif
8443
8444	/* Make a table of what switches there are (switches, n_switches).
8445	Make a table of specified input files (infiles, n_infiles).
8446	Decode switches that are handled locally. */
8447
8448	process_command (decoded_options_count, decoded_options);
8449
8450	/* Initialize the vector of specs to just the default.
8451	This means one element containing 0s, as a terminator. */
8452
8453	compilers = XNEWVAR (struct compiler, sizeof default_compilers);
8454	memcpy (dest: compilers, src: default_compilers, n: sizeof default_compilers);
8455	n_compilers = n_default_compilers;
8456
8457	/* Read specs from a file if there is one. */
8458
8459	machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,
8460	accel_dir_suffix, dir_separator_str, NULL);
8461	just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
8462
8463	specs_file = find_a_file (pprefix: &startfile_prefixes, name: "specs", R_OK, do_multi: true);
8464	/* Read the specs file unless it is a default one. */
8465	if (specs_file != 0 && strcmp (s1: specs_file, s2: "specs"))
8466	read_specs (filename: specs_file, main_p: true, user_p: false);
8467	else
8468	init_spec ();
8469
8470	#ifdef ACCEL_COMPILER
8471	spec_machine_suffix = machine_suffix;
8472	#else
8473	spec_machine_suffix = just_machine_suffix;
8474	#endif
8475
8476	/* We need to check standard_exec_prefix/spec_machine_suffix/specs
8477	for any override of as, ld and libraries. */
8478	specs_file = (char *) alloca (strlen (standard_exec_prefix)
8479	+ strlen (spec_machine_suffix) + sizeof ("specs"));
8480	strcpy (dest: specs_file, src: standard_exec_prefix);
8481	strcat (dest: specs_file, src: spec_machine_suffix);
8482	strcat (dest: specs_file, src: "specs");
8483	if (access (name: specs_file, R_OK) == 0)
8484	read_specs (filename: specs_file, main_p: true, user_p: false);
8485
8486	/* Process any configure-time defaults specified for the command line
8487	options, via OPTION_DEFAULT_SPECS. */
8488	for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
8489	do_option_spec (name: option_default_specs[i].name,
8490	spec: option_default_specs[i].spec);
8491
8492	/* Process DRIVER_SELF_SPECS, adding any new options to the end
8493	of the command line. */
8494
8495	for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
8496	do_self_spec (driver_self_specs[i]);
8497
8498	/* If not cross-compiling, look for executables in the standard
8499	places. */
8500	if (*cross_compile == '0')
8501	{
8502	if (*md_exec_prefix)
8503	{
8504	add_prefix (pprefix: &exec_prefixes, prefix: md_exec_prefix, component: "GCC",
8505	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 0);
8506	}
8507	}
8508
8509	/* Process sysroot_suffix_spec. */
8510	if (*sysroot_suffix_spec != 0
8511	&& !no_sysroot_suffix
8512	&& do_spec_2 (spec: sysroot_suffix_spec, NULL) == 0)
8513	{
8514	if (argbuf.length () > 1)
8515	error ("spec failure: more than one argument to "
8516	"%<SYSROOT_SUFFIX_SPEC%>");
8517	else if (argbuf.length () == 1)
8518	target_sysroot_suffix = xstrdup (argbuf.last ());
8519	}
8520
8521	#ifdef HAVE_LD_SYSROOT
8522	/* Pass the --sysroot option to the linker, if it supports that. If
8523	there is a sysroot_suffix_spec, it has already been processed by
8524	this point, so target_system_root really is the system root we
8525	should be using. */
8526	if (target_system_root)
8527	{
8528	obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8529	obstack_grow0 (&obstack, link_spec, strlen (link_spec));
8530	set_spec (name: "link", XOBFINISH (&obstack, const char *), user_p: false);
8531	}
8532	#endif
8533
8534	/* Process sysroot_hdrs_suffix_spec. */
8535	if (*sysroot_hdrs_suffix_spec != 0
8536	&& !no_sysroot_suffix
8537	&& do_spec_2 (spec: sysroot_hdrs_suffix_spec, NULL) == 0)
8538	{
8539	if (argbuf.length () > 1)
8540	error ("spec failure: more than one argument "
8541	"to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8542	else if (argbuf.length () == 1)
8543	target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
8544	}
8545
8546	/* Look for startfiles in the standard places. */
8547	if (*startfile_prefix_spec != 0
8548	&& do_spec_2 (spec: startfile_prefix_spec, NULL) == 0
8549	&& do_spec_1 (spec: " ", inswitch: 0, NULL) == 0)
8550	{
8551	for (const char *arg : argbuf)
8552	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: arg, component: "BINUTILS",
8553	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8554	}
8555	/* We should eventually get rid of all these and stick to
8556	startfile_prefix_spec exclusively. */
8557	else if (*cross_compile == '0' || target_system_root)
8558	{
8559	if (*md_startfile_prefix)
8560	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: md_startfile_prefix,
8561	component: "GCC", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8562
8563	if (*md_startfile_prefix_1)
8564	add_sysrooted_prefix (pprefix: &startfile_prefixes, prefix: md_startfile_prefix_1,
8565	component: "GCC", priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8566
8567	/* If standard_startfile_prefix is relative, base it on
8568	standard_exec_prefix. This lets us move the installed tree
8569	as a unit. If GCC_EXEC_PREFIX is defined, base
8570	standard_startfile_prefix on that as well.
8571
8572	If the prefix is relative, only search it for native compilers;
8573	otherwise we will search a directory containing host libraries. */
8574	if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
8575	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8576	prefix: standard_startfile_prefix, component: "BINUTILS",
8577	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8578	else if (*cross_compile == '0')
8579	{
8580	add_prefix (pprefix: &startfile_prefixes,
8581	prefix: concat (gcc_exec_prefix
8582	? gcc_exec_prefix : standard_exec_prefix,
8583	machine_suffix,
8584	standard_startfile_prefix, NULL),
8585	NULL, priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8586	}
8587
8588	/* Sysrooted prefixes are relocated because target_system_root is
8589	also relocated by gcc_exec_prefix. */
8590	if (*standard_startfile_prefix_1)
8591	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8592	prefix: standard_startfile_prefix_1, component: "BINUTILS",
8593	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8594	if (*standard_startfile_prefix_2)
8595	add_sysrooted_prefix (pprefix: &startfile_prefixes,
8596	prefix: standard_startfile_prefix_2, component: "BINUTILS",
8597	priority: PREFIX_PRIORITY_LAST, require_machine_suffix: 0, os_multilib: 1);
8598	}
8599
8600	/* Process any user specified specs in the order given on the command
8601	line. */
8602	for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next)
8603	{
8604	char *filename = find_a_file (pprefix: &startfile_prefixes, name: uptr->filename,
8605	R_OK, do_multi: true);
8606	read_specs (filename: filename ? filename : uptr->filename, main_p: false, user_p: true);
8607	}
8608
8609	/* Process any user self specs. */
8610	{
8611	struct spec_list *sl;
8612	for (sl = specs; sl; sl = sl->next)
8613	if (sl->name_len == sizeof "self_spec" - 1
8614	&& !strcmp (s1: sl->name, s2: "self_spec"))
8615	do_self_spec (spec: *sl->ptr_spec);
8616	}
8617
8618	if (compare_debug)
8619	{
8620	enum save_temps save;
8621
8622	if (!compare_debug_second)
8623	{
8624	n_switches_debug_check[1] = n_switches;
8625	n_switches_alloc_debug_check[1] = n_switches_alloc;
8626	switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
8627	n_switches_alloc);
8628
8629	do_self_spec (spec: "%:compare-debug-self-opt()");
8630	n_switches_debug_check[0] = n_switches;
8631	n_switches_alloc_debug_check[0] = n_switches_alloc;
8632	switches_debug_check[0] = switches;
8633
8634	n_switches = n_switches_debug_check[1];
8635	n_switches_alloc = n_switches_alloc_debug_check[1];
8636	switches = switches_debug_check[1];
8637	}
8638
8639	/* Avoid crash when computing %j in this early. */
8640	save = save_temps_flag;
8641	save_temps_flag = SAVE_TEMPS_NONE;
8642
8643	compare_debug = -compare_debug;
8644	do_self_spec (spec: "%:compare-debug-self-opt()");
8645
8646	save_temps_flag = save;
8647
8648	if (!compare_debug_second)
8649	{
8650	n_switches_debug_check[1] = n_switches;
8651	n_switches_alloc_debug_check[1] = n_switches_alloc;
8652	switches_debug_check[1] = switches;
8653	compare_debug = -compare_debug;
8654	n_switches = n_switches_debug_check[0];
8655	n_switches_alloc = n_switches_debug_check[0];
8656	switches = switches_debug_check[0];
8657	}
8658	}
8659
8660
8661	/* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8662	if (gcc_exec_prefix)
8663	gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine,
8664	dir_separator_str, spec_version,
8665	accel_dir_suffix, dir_separator_str, NULL);
8666
8667	/* Now we have the specs.
8668	Set the `valid' bits for switches that match anything in any spec. */
8669
8670	validate_all_switches ();
8671
8672	/* Now that we have the switches and the specs, set
8673	the subdirectory based on the options. */
8674	set_multilib_dir ();
8675	}
8676
8677	/* Set up to remember the pathname of gcc and any options
8678	needed for collect. We use argv[0] instead of progname because
8679	we need the complete pathname. */
8680
8681	void
8682	driver::putenv_COLLECT_GCC (const char *argv0) const
8683	{
8684	obstack_init (&collect_obstack);
8685	obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8686	obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1);
8687	xputenv (XOBFINISH (&collect_obstack, char *));
8688	}
8689
8690	/* Set up to remember the pathname of the lto wrapper. */
8691
8692	void
8693	driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8694	{
8695	char *lto_wrapper_file;
8696
8697	if (have_c)
8698	lto_wrapper_file = NULL;
8699	else
8700	lto_wrapper_file = find_a_program (name: "lto-wrapper");
8701	if (lto_wrapper_file)
8702	{
8703	lto_wrapper_file = convert_white_space (lto_wrapper_file);
8704	set_static_spec_owned (spec: &lto_wrapper_spec, val: lto_wrapper_file);
8705	obstack_init (&collect_obstack);
8706	obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
8707	sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8708	obstack_grow (&collect_obstack, lto_wrapper_spec,
8709	strlen (lto_wrapper_spec) + 1);
8710	xputenv (XOBFINISH (&collect_obstack, char *));
8711	}
8712
8713	}
8714
8715	/* Set up to remember the names of offload targets. */
8716
8717	void
8718	driver::maybe_putenv_OFFLOAD_TARGETS () const
8719	{
8720	if (offload_targets && offload_targets[0] != '\0')
8721	{
8722	obstack_grow (&collect_obstack, "OFFLOAD_TARGET_NAMES=",
8723	sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8724	obstack_grow (&collect_obstack, offload_targets,
8725	strlen (offload_targets) + 1);
8726	xputenv (XOBFINISH (&collect_obstack, char *));
8727	#if OFFLOAD_DEFAULTED
8728	if (offload_targets_default)
8729	xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8730	#endif
8731	}
8732
8733	free (ptr: offload_targets);
8734	offload_targets = NULL;
8735	}
8736
8737	/* Reject switches that no pass was interested in. */
8738
8739	void
8740	driver::handle_unrecognized_options ()
8741	{
8742	for (size_t i = 0; (int) i < n_switches; i++)
8743	if (! switches[i].validated)
8744	{
8745	const char *hint = m_option_proposer.suggest_option (bad_opt: switches[i].part1);
8746	if (hint)
8747	error ("unrecognized command-line option %<-%s%>;"
8748	" did you mean %<-%s%>?",
8749	switches[i].part1, hint);
8750	else
8751	error ("unrecognized command-line option %<-%s%>",
8752	switches[i].part1);
8753	}
8754	}
8755
8756	/* Handle the various -print-* options, returning 0 if the driver
8757	should exit, or nonzero if the driver should continue. */
8758
8759	int
8760	driver::maybe_print_and_exit () const
8761	{
8762	if (print_search_dirs)
8763	{
8764	printf (_("install: %s%s\n"),
8765	gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
8766	gcc_exec_prefix ? "" : machine_suffix);
8767	printf (_("programs: %s\n"),
8768	build_search_list (paths: &exec_prefixes, prefix: "", check_dir: false, do_multi: false));
8769	printf (_("libraries: %s\n"),
8770	build_search_list (paths: &startfile_prefixes, prefix: "", check_dir: false, do_multi: true));
8771	return (0);
8772	}
8773
8774	if (print_file_name)
8775	{
8776	printf (format: "%s\n", find_file (print_file_name));
8777	return (0);
8778	}
8779
8780	if (print_prog_name)
8781	{
8782	if (use_ld != NULL && ! strcmp (print_prog_name, s2: "ld"))
8783	{
8784	/* Append USE_LD to the default linker. */
8785	#ifdef DEFAULT_LINKER
8786	char *ld;
8787	# ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8788	int len = (sizeof (DEFAULT_LINKER)
8789	- sizeof (HOST_EXECUTABLE_SUFFIX));
8790	ld = NULL;
8791	if (len > 0)
8792	{
8793	char *default_linker = xstrdup (DEFAULT_LINKER);
8794	/* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8795	HOST_EXECUTABLE_SUFFIX. */
8796	if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
8797	{
8798	default_linker[len] = '\0';
8799	ld = concat (default_linker, use_ld,
8800	HOST_EXECUTABLE_SUFFIX, NULL);
8801	}
8802	}
8803	if (ld == NULL)
8804	# endif
8805	ld = concat (DEFAULT_LINKER, use_ld, NULL);
8806	if (access (ld, X_OK) == 0)
8807	{
8808	printf ("%s\n", ld);
8809	return (0);
8810	}
8811	#endif
8812	print_prog_name = concat (print_prog_name, use_ld, NULL);
8813	}
8814	char *newname = find_a_program (print_prog_name);
8815	printf (format: "%s\n", (newname ? newname : print_prog_name));
8816	return (0);
8817	}
8818
8819	if (print_multi_lib)
8820	{
8821	print_multilib_info ();
8822	return (0);
8823	}
8824
8825	if (print_multi_directory)
8826	{
8827	if (multilib_dir == NULL)
8828	printf (format: ".\n");
8829	else
8830	printf (format: "%s\n", multilib_dir);
8831	return (0);
8832	}
8833
8834	if (print_multiarch)
8835	{
8836	if (multiarch_dir == NULL)
8837	printf (format: "\n");
8838	else
8839	printf (format: "%s\n", multiarch_dir);
8840	return (0);
8841	}
8842
8843	if (print_sysroot)
8844	{
8845	if (target_system_root)
8846	{
8847	if (target_sysroot_suffix)
8848	printf (format: "%s%s\n", target_system_root, target_sysroot_suffix);
8849	else
8850	printf (format: "%s\n", target_system_root);
8851	}
8852	return (0);
8853	}
8854
8855	if (print_multi_os_directory)
8856	{
8857	if (multilib_os_dir == NULL)
8858	printf (format: ".\n");
8859	else
8860	printf (format: "%s\n", multilib_os_dir);
8861	return (0);
8862	}
8863
8864	if (print_sysroot_headers_suffix)
8865	{
8866	if (*sysroot_hdrs_suffix_spec)
8867	{
8868	printf(format: "%s\n", (target_sysroot_hdrs_suffix
8869	? target_sysroot_hdrs_suffix
8870	: ""));
8871	return (0);
8872	}
8873	else
8874	/* The error status indicates that only one set of fixed
8875	headers should be built. */
8876	fatal_error (input_location,
8877	"not configured with sysroot headers suffix");
8878	}
8879
8880	if (print_help_list)
8881	{
8882	display_help ();
8883
8884	if (! verbose_flag)
8885	{
8886	printf (_("\nFor bug reporting instructions, please see:\n"));
8887	printf (format: "%s.\n", bug_report_url);
8888
8889	return (0);
8890	}
8891
8892	/* We do not exit here. Instead we have created a fake input file
8893	called 'help-dummy' which needs to be compiled, and we pass this
8894	on the various sub-processes, along with the --help switch.
8895	Ensure their output appears after ours. */
8896	fputc (c: '\n', stdout);
8897	fflush (stdout);
8898	}
8899
8900	if (print_version)
8901	{
8902	printf (_("%s %s%s\n"), progname, pkgversion_string,
8903	version_string);
8904	printf (format: "Copyright %s 2024 Free Software Foundation, Inc.\n",
8905	_("(C)"));
8906	fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8907	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8908	stdout);
8909	if (! verbose_flag)
8910	return 0;
8911
8912	/* We do not exit here. We use the same mechanism of --help to print
8913	the version of the sub-processes. */
8914	fputc (c: '\n', stdout);
8915	fflush (stdout);
8916	}
8917
8918	if (verbose_flag)
8919	{
8920	print_configuration (stderr);
8921	if (n_infiles == 0)
8922	return (0);
8923	}
8924
8925	return 1;
8926	}
8927
8928	/* Figure out what to do with each input file.
8929	Return true if we need to exit early from "main", false otherwise. */
8930
8931	bool
8932	driver::prepare_infiles ()
8933	{
8934	size_t i;
8935	int lang_n_infiles = 0;
8936
8937	if (n_infiles == added_libraries)
8938	fatal_error (input_location, "no input files");
8939
8940	if (seen_error ())
8941	/* Early exit needed from main. */
8942	return true;
8943
8944	/* Make a place to record the compiler output file names
8945	that correspond to the input files. */
8946
8947	i = n_infiles;
8948	i += lang_specific_extra_outfiles;
8949	outfiles = XCNEWVEC (const char *, i);
8950
8951	/* Record which files were specified explicitly as link input. */
8952
8953	explicit_link_files = XCNEWVEC (char, n_infiles);
8954
8955	combine_inputs = have_o || flag_wpa;
8956
8957	for (i = 0; (int) i < n_infiles; i++)
8958	{
8959	const char *name = infiles[i].name;
8960	struct compiler *compiler = lookup_compiler (name,
8961	strlen (s: name),
8962	infiles[i].language);
8963
8964	if (compiler && !(compiler->combinable))
8965	combine_inputs = false;
8966
8967	if (lang_n_infiles > 0 && compiler != input_file_compiler
8968	&& infiles[i].language && infiles[i].language[0] != '*')
8969	infiles[i].incompiler = compiler;
8970	else if (compiler)
8971	{
8972	lang_n_infiles++;
8973	input_file_compiler = compiler;
8974	infiles[i].incompiler = compiler;
8975	}
8976	else
8977	{
8978	/* Since there is no compiler for this input file, assume it is a
8979	linker file. */
8980	explicit_link_files[i] = 1;
8981	infiles[i].incompiler = NULL;
8982	}
8983	infiles[i].compiled = false;
8984	infiles[i].preprocessed = false;
8985	}
8986
8987	if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
8988	fatal_error (input_location,
8989	"cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8990	"with multiple files");
8991
8992	/* No early exit needed from main; we can continue. */
8993	return false;
8994	}
8995
8996	/* Run the spec machinery on each input file. */
8997
8998	void
8999	driver::do_spec_on_infiles () const
9000	{
9001	size_t i;
9002
9003	for (i = 0; (int) i < n_infiles; i++)
9004	{
9005	int this_file_error = 0;
9006
9007	/* Tell do_spec what to substitute for %i. */
9008
9009	input_file_number = i;
9010	set_input (infiles[i].name);
9011
9012	if (infiles[i].compiled)
9013	continue;
9014
9015	/* Use the same thing in %o, unless cp->spec says otherwise. */
9016
9017	outfiles[i] = gcc_input_filename;
9018
9019	/* Figure out which compiler from the file's suffix. */
9020
9021	input_file_compiler
9022	= lookup_compiler (infiles[i].name, input_filename_length,
9023	infiles[i].language);
9024
9025	if (input_file_compiler)
9026	{
9027	/* Ok, we found an applicable compiler. Run its spec. */
9028
9029	if (input_file_compiler->spec[0] == '#')
9030	{
9031	error ("%s: %s compiler not installed on this system",
9032	gcc_input_filename, &input_file_compiler->spec[1]);
9033	this_file_error = 1;
9034	}
9035	else
9036	{
9037	int value;
9038
9039	if (compare_debug)
9040	{
9041	free (ptr: debug_check_temp_file[0]);
9042	debug_check_temp_file[0] = NULL;
9043
9044	free (ptr: debug_check_temp_file[1]);
9045	debug_check_temp_file[1] = NULL;
9046	}
9047
9048	value = do_spec (spec: input_file_compiler->spec);
9049	infiles[i].compiled = true;
9050	if (value < 0)
9051	this_file_error = 1;
9052	else if (compare_debug && debug_check_temp_file[0])
9053	{
9054	if (verbose_flag)
9055	inform (UNKNOWN_LOCATION,
9056	"recompiling with %<-fcompare-debug%>");
9057
9058	compare_debug = -compare_debug;
9059	n_switches = n_switches_debug_check[1];
9060	n_switches_alloc = n_switches_alloc_debug_check[1];
9061	switches = switches_debug_check[1];
9062
9063	value = do_spec (spec: input_file_compiler->spec);
9064
9065	compare_debug = -compare_debug;
9066	n_switches = n_switches_debug_check[0];
9067	n_switches_alloc = n_switches_alloc_debug_check[0];
9068	switches = switches_debug_check[0];
9069
9070	if (value < 0)
9071	{
9072	error ("during %<-fcompare-debug%> recompilation");
9073	this_file_error = 1;
9074	}
9075
9076	gcc_assert (debug_check_temp_file[1]
9077	&& filename_cmp (debug_check_temp_file[0],
9078	debug_check_temp_file[1]));
9079
9080	if (verbose_flag)
9081	inform (UNKNOWN_LOCATION, "comparing final insns dumps");
9082
9083	if (compare_files (cmpfile: debug_check_temp_file))
9084	this_file_error = 1;
9085	}
9086
9087	if (compare_debug)
9088	{
9089	free (ptr: debug_check_temp_file[0]);
9090	debug_check_temp_file[0] = NULL;
9091
9092	free (ptr: debug_check_temp_file[1]);
9093	debug_check_temp_file[1] = NULL;
9094	}
9095	}
9096	}
9097
9098	/* If this file's name does not contain a recognized suffix,
9099	record it as explicit linker input. */
9100
9101	else
9102	explicit_link_files[i] = 1;
9103
9104	/* Clear the delete-on-failure queue, deleting the files in it
9105	if this compilation failed. */
9106
9107	if (this_file_error)
9108	{
9109	delete_failure_queue ();
9110	errorcount++;
9111	}
9112	/* If this compilation succeeded, don't delete those files later. */
9113	clear_failure_queue ();
9114	}
9115
9116	/* Reset the input file name to the first compile/object file name, for use
9117	with %b in LINK_SPEC. We use the first input file that we can find
9118	a compiler to compile it instead of using infiles.language since for
9119	languages other than C we use aliases that we then lookup later. */
9120	if (n_infiles > 0)
9121	{
9122	int i;
9123
9124	for (i = 0; i < n_infiles ; i++)
9125	if (infiles[i].incompiler
9126	|| (infiles[i].language && infiles[i].language[0] != '*'))
9127	{
9128	set_input (infiles[i].name);
9129	break;
9130	}
9131	}
9132
9133	if (!seen_error ())
9134	{
9135	/* Make sure INPUT_FILE_NUMBER points to first available open
9136	slot. */
9137	input_file_number = n_infiles;
9138	if (lang_specific_pre_link ())
9139	errorcount++;
9140	}
9141	}
9142
9143	/* If we have to run the linker, do it now. */
9144
9145	void
9146	driver::maybe_run_linker (const char *argv0) const
9147	{
9148	size_t i;
9149	int linker_was_run = 0;
9150	int num_linker_inputs;
9151
9152	/* Determine if there are any linker input files. */
9153	num_linker_inputs = 0;
9154	for (i = 0; (int) i < n_infiles; i++)
9155	if (explicit_link_files[i] || outfiles[i] != NULL)
9156	num_linker_inputs++;
9157
9158	/* Arrange for temporary file names created during linking to take
9159	on names related with the linker output rather than with the
9160	inputs when appropriate. */
9161	if (outbase && *outbase)
9162	{
9163	if (dumpdir)
9164	{
9165	char *tofree = dumpdir;
9166	gcc_checking_assert (strlen (dumpdir) == dumpdir_length);
9167	dumpdir = concat (dumpdir, outbase, ".", NULL);
9168	free (ptr: tofree);
9169	}
9170	else
9171	dumpdir = concat (outbase, ".", NULL);
9172	dumpdir_length += strlen (s: outbase) + 1;
9173	dumpdir_trailing_dash_added = true;
9174	}
9175	else if (dumpdir_trailing_dash_added)
9176	{
9177	gcc_assert (dumpdir[dumpdir_length - 1] == '-');
9178	dumpdir[dumpdir_length - 1] = '.';
9179	}
9180
9181	if (dumpdir_trailing_dash_added)
9182	{
9183	gcc_assert (dumpdir_length > 0);
9184	gcc_assert (dumpdir[dumpdir_length - 1] == '.');
9185	dumpdir_length--;
9186	}
9187
9188	free (ptr: outbase);
9189	input_basename = outbase = NULL;
9190	outbase_length = suffixed_basename_length = basename_length = 0;
9191
9192	/* Run ld to link all the compiler output files. */
9193
9194	if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
9195	{
9196	int tmp = execution_count;
9197
9198	detect_jobserver ();
9199
9200	if (! have_c)
9201	{
9202	#if HAVE_LTO_PLUGIN > 0
9203	#if HAVE_LTO_PLUGIN == 2
9204	const char *fno_use_linker_plugin = "fno-use-linker-plugin";
9205	#else
9206	const char *fuse_linker_plugin = "fuse-linker-plugin";
9207	#endif
9208	#endif
9209
9210	/* We'll use ld if we can't find collect2. */
9211	if (! strcmp (s1: linker_name_spec, s2: "collect2"))
9212	{
9213	char *s = find_a_program (name: "collect2");
9214	if (s == NULL)
9215	set_static_spec_shared (spec: &linker_name_spec, val: "ld");
9216	}
9217
9218	#if HAVE_LTO_PLUGIN > 0
9219	#if HAVE_LTO_PLUGIN == 2
9220	if (!switch_matches (atom: fno_use_linker_plugin,
9221	end_atom: fno_use_linker_plugin
9222	+ strlen (s: fno_use_linker_plugin), starred: 0))
9223	#else
9224	if (switch_matches (fuse_linker_plugin,
9225	fuse_linker_plugin
9226	+ strlen (fuse_linker_plugin), 0))
9227	#endif
9228	{
9229	char *temp_spec = find_a_file (pprefix: &exec_prefixes,
9230	LTOPLUGINSONAME, R_OK,
9231	do_multi: false);
9232	if (!temp_spec)
9233	fatal_error (input_location,
9234	"%<-fuse-linker-plugin%>, but %s not found",
9235	LTOPLUGINSONAME);
9236	linker_plugin_file_spec = convert_white_space (temp_spec);
9237	}
9238	#endif
9239	set_static_spec_shared (spec: &lto_gcc_spec, val: argv0);
9240	}
9241
9242	/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9243	for collect. */
9244	putenv_from_prefixes (paths: &exec_prefixes, env_var: "COMPILER_PATH", do_multi: false);
9245	putenv_from_prefixes (paths: &startfile_prefixes, LIBRARY_PATH_ENV, do_multi: true);
9246
9247	if (print_subprocess_help == 1)
9248	{
9249	printf (_("\nLinker options\n==============\n\n"));
9250	printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9251	" to the linker.\n\n"));
9252	fflush (stdout);
9253	}
9254	int value = do_spec (spec: link_command_spec);
9255	if (value < 0)
9256	errorcount = 1;
9257	linker_was_run = (tmp != execution_count);
9258	}
9259
9260	/* If options said don't run linker,
9261	complain about input files to be given to the linker. */
9262
9263	if (! linker_was_run && !seen_error ())
9264	for (i = 0; (int) i < n_infiles; i++)
9265	if (explicit_link_files[i]
9266	&& !(infiles[i].language && infiles[i].language[0] == '*'))
9267	{
9268	warning (0, "%s: linker input file unused because linking not done",
9269	outfiles[i]);
9270	if (access (name: outfiles[i], F_OK) < 0)
9271	/* This is can be an indication the user specifed an errorneous
9272	separated option value, (or used the wrong prefix for an
9273	option). */
9274	error ("%s: linker input file not found: %m", outfiles[i]);
9275	}
9276	}
9277
9278	/* The end of "main". */
9279
9280	void
9281	driver::final_actions () const
9282	{
9283	/* Delete some or all of the temporary files we made. */
9284
9285	if (seen_error ())
9286	delete_failure_queue ();
9287	delete_temp_files ();
9288
9289	if (print_help_list)
9290	{
9291	printf (format: ("\nFor bug reporting instructions, please see:\n"));
9292	printf (format: "%s\n", bug_report_url);
9293	}
9294	}
9295
9296	/* Detect whether jobserver is active and working. If not drop
9297	--jobserver-auth from MAKEFLAGS. */
9298
9299	void
9300	driver::detect_jobserver () const
9301	{
9302	jobserver_info jinfo;
9303	if (!jinfo.is_active && !jinfo.skipped_makeflags.empty ())
9304	xputenv (string: xstrdup (jinfo.skipped_makeflags.c_str ()));
9305	}
9306
9307	/* Determine what the exit code of the driver should be. */
9308
9309	int
9310	driver::get_exit_code () const
9311	{
9312	return (signal_count != 0 ? 2
9313	: seen_error () ? (pass_exit_codes ? greatest_status : 1)
9314	: 0);
9315	}
9316
9317	/* Find the proper compilation spec for the file name NAME,
9318	whose length is LENGTH. LANGUAGE is the specified language,
9319	or 0 if this file is to be passed to the linker. */
9320
9321	static struct compiler *
9322	lookup_compiler (const char *name, size_t length, const char *language)
9323	{
9324	struct compiler *cp;
9325
9326	/* If this was specified by the user to be a linker input, indicate that. */
9327	if (language != 0 && language[0] == '*')
9328	return 0;
9329
9330	/* Otherwise, look for the language, if one is spec'd. */
9331	if (language != 0)
9332	{
9333	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9334	if (cp->suffix[0] == '@' && !strcmp (s1: cp->suffix + 1, s2: language))
9335	{
9336	if (name != NULL && strcmp (s1: name, s2: "-") == 0
9337	&& (strcmp (s1: cp->suffix, s2: "@c-header") == 0
9338	|| strcmp (s1: cp->suffix, s2: "@c++-header") == 0)
9339	&& !have_E)
9340	fatal_error (input_location,
9341	"cannot use %<-%> as input filename for a "
9342	"precompiled header");
9343
9344	return cp;
9345	}
9346
9347	error ("language %s not recognized", language);
9348	return 0;
9349	}
9350
9351	/* Look for a suffix. */
9352	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9353	{
9354	if (/* The suffix `-' matches only the file name `-'. */
9355	(!strcmp (s1: cp->suffix, s2: "-") && !strcmp (s1: name, s2: "-"))
9356	|| (strlen (s: cp->suffix) < length
9357	/* See if the suffix matches the end of NAME. */
9358	&& !strcmp (s1: cp->suffix,
9359	s2: name + length - strlen (s: cp->suffix))
9360	))
9361	break;
9362	}
9363
9364	#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9365	/* Look again, but case-insensitively this time. */
9366	if (cp < compilers)
9367	for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9368	{
9369	if (/* The suffix `-' matches only the file name `-'. */
9370	(!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
9371	|| (strlen (cp->suffix) < length
9372	/* See if the suffix matches the end of NAME. */
9373	&& ((!strcmp (cp->suffix,
9374	name + length - strlen (cp->suffix))
9375	|| !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9376	&& !strcasecmp (cp->suffix,
9377	name + length - strlen (cp->suffix)))
9378	))
9379	break;
9380	}
9381	#endif
9382
9383	if (cp >= compilers)
9384	{
9385	if (cp->spec[0] != '@')
9386	/* A non-alias entry: return it. */
9387	return cp;
9388
9389	/* An alias entry maps a suffix to a language.
9390	Search for the language; pass 0 for NAME and LENGTH
9391	to avoid infinite recursion if language not found. */
9392	return lookup_compiler (NULL, length: 0, language: cp->spec + 1);
9393	}
9394	return 0;
9395	}
9396
9397	static char *
9398	save_string (const char *s, int len)
9399	{
9400	char *result = XNEWVEC (char, len + 1);
9401
9402	gcc_checking_assert (strlen (s) >= (unsigned int) len);
9403	memcpy (dest: result, src: s, n: len);
9404	result[len] = 0;
9405	return result;
9406	}
9407
9408
9409	static inline void
9410	validate_switches_from_spec (const char *spec, bool user)
9411	{
9412	const char *p = spec;
9413	char c;
9414	while ((c = *p++))
9415	if (c == '%'
9416	&& (*p == '{'
9417	|| *p == '<'
9418	|| (*p == 'W' && *++p == '{')
9419	|| (*p == '@' && *++p == '{')))
9420	/* We have a switch spec. */
9421	p = validate_switches (p + 1, user, *p == '{');
9422	}
9423
9424	static void
9425	validate_all_switches (void)
9426	{
9427	struct compiler *comp;
9428	struct spec_list *spec;
9429
9430	for (comp = compilers; comp->spec; comp++)
9431	validate_switches_from_spec (spec: comp->spec, user: false);
9432
9433	/* Look through the linked list of specs read from the specs file. */
9434	for (spec = specs; spec; spec = spec->next)
9435	validate_switches_from_spec (spec: *spec->ptr_spec, user: spec->user_p);
9436
9437	validate_switches_from_spec (spec: link_command_spec, user: false);
9438	}
9439
9440	/* Look at the switch-name that comes after START and mark as valid
9441	all supplied switches that match it. If BRACED, handle other
9442	switches after '|' and '&', and specs after ':' until ';' or '}',
9443	going back for more switches after ';'. Without BRACED, handle
9444	only one atom. Return a pointer to whatever follows the handled
9445	items, after the closing brace if BRACED. */
9446
9447	static const char *
9448	validate_switches (const char *start, bool user_spec, bool braced)
9449	{
9450	const char *p = start;
9451	const char *atom;
9452	size_t len;
9453	int i;
9454	bool suffix;
9455	bool starred;
9456
9457	#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9458
9459	next_member:
9460	suffix = false;
9461	starred = false;
9462
9463	SKIP_WHITE ();
9464
9465	if (*p == '!')
9466	p++;
9467
9468	SKIP_WHITE ();
9469	if (*p == '.' || *p == ',')
9470	suffix = true, p++;
9471
9472	atom = p;
9473	while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
9474	|| *p == ',' || *p == '.' || *p == '@')
9475	p++;
9476	len = p - atom;
9477
9478	if (*p == '*')
9479	starred = true, p++;
9480
9481	SKIP_WHITE ();
9482
9483	if (!suffix)
9484	{
9485	/* Mark all matching switches as valid. */
9486	for (i = 0; i < n_switches; i++)
9487	if (!strncmp (s1: switches[i].part1, s2: atom, n: len)
9488	&& (starred || switches[i].part1[len] == '\0')
9489	&& (switches[i].known || user_spec))
9490	switches[i].validated = true;
9491	}
9492
9493	if (!braced)
9494	return p;
9495
9496	if (*p) p++;
9497	if (*p && (p[-1] == '|' || p[-1] == '&'))
9498	goto next_member;
9499
9500	if (*p && p[-1] == ':')
9501	{
9502	while (*p && *p != ';' && *p != '}')
9503	{
9504	if (*p == '%')
9505	{
9506	p++;
9507	if (*p == '{' || *p == '<')
9508	p = validate_switches (start: p+1, user_spec, braced: *p == '{');
9509	else if (p[0] == 'W' && p[1] == '{')
9510	p = validate_switches (start: p+2, user_spec, braced: true);
9511	else if (p[0] == '@' && p[1] == '{')
9512	p = validate_switches (start: p+2, user_spec, braced: true);
9513	}
9514	else
9515	p++;
9516	}
9517
9518	if (*p) p++;
9519	if (*p && p[-1] == ';')
9520	goto next_member;
9521	}
9522
9523	return p;
9524	#undef SKIP_WHITE
9525	}
9526
9527	struct mdswitchstr
9528	{
9529	const char *str;
9530	int len;
9531	};
9532
9533	static struct mdswitchstr *mdswitches;
9534	static int n_mdswitches;
9535
9536	/* Check whether a particular argument was used. The first time we
9537	canonicalize the switches to keep only the ones we care about. */
9538
9539	struct used_arg_t
9540	{
9541	public:
9542	int operator () (const char *p, int len);
9543	void finalize ();
9544
9545	private:
9546	struct mswitchstr
9547	{
9548	const char *str;
9549	const char *replace;
9550	int len;
9551	int rep_len;
9552	};
9553
9554	mswitchstr *mswitches;
9555	int n_mswitches;
9556
9557	};
9558
9559	used_arg_t used_arg;
9560
9561	int
9562	used_arg_t::operator () (const char *p, int len)
9563	{
9564	int i, j;
9565
9566	if (!mswitches)
9567	{
9568	struct mswitchstr *matches;
9569	const char *q;
9570	int cnt = 0;
9571
9572	/* Break multilib_matches into the component strings of string
9573	and replacement string. */
9574	for (q = multilib_matches; *q != '\0'; q++)
9575	if (*q == ';')
9576	cnt++;
9577
9578	matches
9579	= (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
9580	i = 0;
9581	q = multilib_matches;
9582	while (*q != '\0')
9583	{
9584	matches[i].str = q;
9585	while (*q != ' ')
9586	{
9587	if (*q == '\0')
9588	{
9589	invalid_matches:
9590	fatal_error (input_location, "multilib spec %qs is invalid",
9591	multilib_matches);
9592	}
9593	q++;
9594	}
9595	matches[i].len = q - matches[i].str;
9596
9597	matches[i].replace = ++q;
9598	while (*q != ';' && *q != '\0')
9599	{
9600	if (*q == ' ')
9601	goto invalid_matches;
9602	q++;
9603	}
9604	matches[i].rep_len = q - matches[i].replace;
9605	i++;
9606	if (*q == ';')
9607	q++;
9608	}
9609
9610	/* Now build a list of the replacement string for switches that we care
9611	about. Make sure we allocate at least one entry. This prevents
9612	xmalloc from calling fatal, and prevents us from re-executing this
9613	block of code. */
9614	mswitches
9615	= XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
9616	for (i = 0; i < n_switches; i++)
9617	if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
9618	{
9619	int xlen = strlen (s: switches[i].part1);
9620	for (j = 0; j < cnt; j++)
9621	if (xlen == matches[j].len
9622	&& ! strncmp (s1: switches[i].part1, s2: matches[j].str, n: xlen))
9623	{
9624	mswitches[n_mswitches].str = matches[j].replace;
9625	mswitches[n_mswitches].len = matches[j].rep_len;
9626	mswitches[n_mswitches].replace = (char *) 0;
9627	mswitches[n_mswitches].rep_len = 0;
9628	n_mswitches++;
9629	break;
9630	}
9631	}
9632
9633	/* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9634	on the command line nor any options mutually incompatible with
9635	them. */
9636	for (i = 0; i < n_mdswitches; i++)
9637	{
9638	const char *r;
9639
9640	for (q = multilib_options; *q != '\0'; *q && q++)
9641	{
9642	while (*q == ' ')
9643	q++;
9644
9645	r = q;
9646	while (strncmp (s1: q, s2: mdswitches[i].str, n: mdswitches[i].len) != 0
9647	|| strchr (s: " /", c: q[mdswitches[i].len]) == NULL)
9648	{
9649	while (*q != ' ' && *q != '/' && *q != '\0')
9650	q++;
9651	if (*q != '/')
9652	break;
9653	q++;
9654	}
9655
9656	if (*q != ' ' && *q != '\0')
9657	{
9658	while (*r != ' ' && *r != '\0')
9659	{
9660	q = r;
9661	while (*q != ' ' && *q != '/' && *q != '\0')
9662	q++;
9663
9664	if (used_arg (r, q - r))
9665	break;
9666
9667	if (*q != '/')
9668	{
9669	mswitches[n_mswitches].str = mdswitches[i].str;
9670	mswitches[n_mswitches].len = mdswitches[i].len;
9671	mswitches[n_mswitches].replace = (char *) 0;
9672	mswitches[n_mswitches].rep_len = 0;
9673	n_mswitches++;
9674	break;
9675	}
9676
9677	r = q + 1;
9678	}
9679	break;
9680	}
9681	}
9682	}
9683	}
9684
9685	for (i = 0; i < n_mswitches; i++)
9686	if (len == mswitches[i].len && ! strncmp (s1: p, s2: mswitches[i].str, n: len))
9687	return 1;
9688
9689	return 0;
9690	}
9691
9692	void used_arg_t::finalize ()
9693	{
9694	XDELETEVEC (mswitches);
9695	mswitches = NULL;
9696	n_mswitches = 0;
9697	}
9698
9699
9700	static int
9701	default_arg (const char *p, int len)
9702	{
9703	int i;
9704
9705	for (i = 0; i < n_mdswitches; i++)
9706	if (len == mdswitches[i].len && ! strncmp (s1: p, s2: mdswitches[i].str, n: len))
9707	return 1;
9708
9709	return 0;
9710	}
9711
9712	/* Work out the subdirectory to use based on the options. The format of
9713	multilib_select is a list of elements. Each element is a subdirectory
9714	name followed by a list of options followed by a semicolon. The format
9715	of multilib_exclusions is the same, but without the preceding
9716	directory. First gcc will check the exclusions, if none of the options
9717	beginning with an exclamation point are present, and all of the other
9718	options are present, then we will ignore this completely. Passing
9719	that, gcc will consider each multilib_select in turn using the same
9720	rules for matching the options. If a match is found, that subdirectory
9721	will be used.
9722	A subdirectory name is optionally followed by a colon and the corresponding
9723	multiarch name. */
9724
9725	static void
9726	set_multilib_dir (void)
9727	{
9728	const char *p;
9729	unsigned int this_path_len;
9730	const char *this_path, *this_arg;
9731	const char *start, *end;
9732	int not_arg;
9733	int ok, ndfltok, first;
9734
9735	n_mdswitches = 0;
9736	start = multilib_defaults;
9737	while (*start == ' ' || *start == '\t')
9738	start++;
9739	while (*start != '\0')
9740	{
9741	n_mdswitches++;
9742	while (*start != ' ' && *start != '\t' && *start != '\0')
9743	start++;
9744	while (*start == ' ' || *start == '\t')
9745	start++;
9746	}
9747
9748	if (n_mdswitches)
9749	{
9750	int i = 0;
9751
9752	mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
9753	for (start = multilib_defaults; *start != '\0'; start = end + 1)
9754	{
9755	while (*start == ' ' || *start == '\t')
9756	start++;
9757
9758	if (*start == '\0')
9759	break;
9760
9761	for (end = start + 1;
9762	*end != ' ' && *end != '\t' && *end != '\0'; end++)
9763	;
9764
9765	obstack_grow (&multilib_obstack, start, end - start);
9766	obstack_1grow (&multilib_obstack, 0);
9767	mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
9768	mdswitches[i++].len = end - start;
9769
9770	if (*end == '\0')
9771	break;
9772	}
9773	}
9774
9775	p = multilib_exclusions;
9776	while (*p != '\0')
9777	{
9778	/* Ignore newlines. */
9779	if (*p == '\n')
9780	{
9781	++p;
9782	continue;
9783	}
9784
9785	/* Check the arguments. */
9786	ok = 1;
9787	while (*p != ';')
9788	{
9789	if (*p == '\0')
9790	{
9791	invalid_exclusions:
9792	fatal_error (input_location, "multilib exclusions %qs is invalid",
9793	multilib_exclusions);
9794	}
9795
9796	if (! ok)
9797	{
9798	++p;
9799	continue;
9800	}
9801
9802	this_arg = p;
9803	while (*p != ' ' && *p != ';')
9804	{
9805	if (*p == '\0')
9806	goto invalid_exclusions;
9807	++p;
9808	}
9809
9810	if (*this_arg != '!')
9811	not_arg = 0;
9812	else
9813	{
9814	not_arg = 1;
9815	++this_arg;
9816	}
9817
9818	ok = used_arg (this_arg, p - this_arg);
9819	if (not_arg)
9820	ok = ! ok;
9821
9822	if (*p == ' ')
9823	++p;
9824	}
9825
9826	if (ok)
9827	return;
9828
9829	++p;
9830	}
9831
9832	first = 1;
9833	p = multilib_select;
9834
9835	/* Append multilib reuse rules if any. With those rules, we can reuse
9836	one multilib for certain different options sets. */
9837	if (strlen (s: multilib_reuse) > 0)
9838	p = concat (p, multilib_reuse, NULL);
9839
9840	while (*p != '\0')
9841	{
9842	/* Ignore newlines. */
9843	if (*p == '\n')
9844	{
9845	++p;
9846	continue;
9847	}
9848
9849	/* Get the initial path. */
9850	this_path = p;
9851	while (*p != ' ')
9852	{
9853	if (*p == '\0')
9854	{
9855	invalid_select:
9856	fatal_error (input_location, "multilib select %qs %qs is invalid",
9857	multilib_select, multilib_reuse);
9858	}
9859	++p;
9860	}
9861	this_path_len = p - this_path;
9862
9863	/* Check the arguments. */
9864	ok = 1;
9865	ndfltok = 1;
9866	++p;
9867	while (*p != ';')
9868	{
9869	if (*p == '\0')
9870	goto invalid_select;
9871
9872	if (! ok)
9873	{
9874	++p;
9875	continue;
9876	}
9877
9878	this_arg = p;
9879	while (*p != ' ' && *p != ';')
9880	{
9881	if (*p == '\0')
9882	goto invalid_select;
9883	++p;
9884	}
9885
9886	if (*this_arg != '!')
9887	not_arg = 0;
9888	else
9889	{
9890	not_arg = 1;
9891	++this_arg;
9892	}
9893
9894	/* If this is a default argument, we can just ignore it.
9895	This is true even if this_arg begins with '!'. Beginning
9896	with '!' does not mean that this argument is necessarily
9897	inappropriate for this library: it merely means that
9898	there is a more specific library which uses this
9899	argument. If this argument is a default, we need not
9900	consider that more specific library. */
9901	ok = used_arg (this_arg, p - this_arg);
9902	if (not_arg)
9903	ok = ! ok;
9904
9905	if (! ok)
9906	ndfltok = 0;
9907
9908	if (default_arg (p: this_arg, len: p - this_arg))
9909	ok = 1;
9910
9911	if (*p == ' ')
9912	++p;
9913	}
9914
9915	if (ok && first)
9916	{
9917	if (this_path_len != 1
9918	|| this_path[0] != '.')
9919	{
9920	char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
9921	char *q;
9922
9923	strncpy (dest: new_multilib_dir, src: this_path, n: this_path_len);
9924	new_multilib_dir[this_path_len] = '\0';
9925	q = strchr (s: new_multilib_dir, c: ':');
9926	if (q != NULL)
9927	*q = '\0';
9928	multilib_dir = new_multilib_dir;
9929	}
9930	first = 0;
9931	}
9932
9933	if (ndfltok)
9934	{
9935	const char *q = this_path, *end = this_path + this_path_len;
9936
9937	while (q < end && *q != ':')
9938	q++;
9939	if (q < end)
9940	{
9941	const char *q2 = q + 1, *ml_end = end;
9942	char *new_multilib_os_dir;
9943
9944	while (q2 < end && *q2 != ':')
9945	q2++;
9946	if (*q2 == ':')
9947	ml_end = q2;
9948	if (ml_end - q == 1)
9949	multilib_os_dir = xstrdup (".");
9950	else
9951	{
9952	new_multilib_os_dir = XNEWVEC (char, ml_end - q);
9953	memcpy (dest: new_multilib_os_dir, src: q + 1, n: ml_end - q - 1);
9954	new_multilib_os_dir[ml_end - q - 1] = '\0';
9955	multilib_os_dir = new_multilib_os_dir;
9956	}
9957
9958	if (q2 < end && *q2 == ':')
9959	{
9960	char *new_multiarch_dir = XNEWVEC (char, end - q2);
9961	memcpy (dest: new_multiarch_dir, src: q2 + 1, n: end - q2 - 1);
9962	new_multiarch_dir[end - q2 - 1] = '\0';
9963	multiarch_dir = new_multiarch_dir;
9964	}
9965	break;
9966	}
9967	}
9968
9969	++p;
9970	}
9971
9972	multilib_dir =
9973	targetm_common.compute_multilib (
9974	switches,
9975	n_switches,
9976	multilib_dir,
9977	multilib_defaults,
9978	multilib_select,
9979	multilib_matches,
9980	multilib_exclusions,
9981	multilib_reuse);
9982
9983	if (multilib_dir == NULL && multilib_os_dir != NULL
9984	&& strcmp (s1: multilib_os_dir, s2: ".") == 0)
9985	{
9986	free (CONST_CAST (char *, multilib_os_dir));
9987	multilib_os_dir = NULL;
9988	}
9989	else if (multilib_dir != NULL && multilib_os_dir == NULL)
9990	multilib_os_dir = multilib_dir;
9991	}
9992
9993	/* Print out the multiple library subdirectory selection
9994	information. This prints out a series of lines. Each line looks
9995	like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9996	required. Only the desired options are printed out, the negative
9997	matches. The options are print without a leading dash. There are
9998	no spaces to make it easy to use the information in the shell.
9999	Each subdirectory is printed only once. This assumes the ordering
10000	generated by the genmultilib script. Also, we leave out ones that match
10001	the exclusions. */
10002
10003	static void
10004	print_multilib_info (void)
10005	{
10006	const char *p = multilib_select;
10007	const char *last_path = 0, *this_path;
10008	int skip;
10009	int not_arg;
10010	unsigned int last_path_len = 0;
10011
10012	while (*p != '\0')
10013	{
10014	skip = 0;
10015	/* Ignore newlines. */
10016	if (*p == '\n')
10017	{
10018	++p;
10019	continue;
10020	}
10021
10022	/* Get the initial path. */
10023	this_path = p;
10024	while (*p != ' ')
10025	{
10026	if (*p == '\0')
10027	{
10028	invalid_select:
10029	fatal_error (input_location,
10030	"multilib select %qs is invalid", multilib_select);
10031	}
10032
10033	++p;
10034	}
10035
10036	/* When --disable-multilib was used but target defines
10037	MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
10038	with .:: for multiarch configurations) are there just to find
10039	multilib_os_dir, so skip them from output. */
10040	if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
10041	skip = 1;
10042
10043	/* Check for matches with the multilib_exclusions. We don't bother
10044	with the '!' in either list. If any of the exclusion rules match
10045	all of its options with the select rule, we skip it. */
10046	{
10047	const char *e = multilib_exclusions;
10048	const char *this_arg;
10049
10050	while (*e != '\0')
10051	{
10052	int m = 1;
10053	/* Ignore newlines. */
10054	if (*e == '\n')
10055	{
10056	++e;
10057	continue;
10058	}
10059
10060	/* Check the arguments. */
10061	while (*e != ';')
10062	{
10063	const char *q;
10064	int mp = 0;
10065
10066	if (*e == '\0')
10067	{
10068	invalid_exclusion:
10069	fatal_error (input_location,
10070	"multilib exclusion %qs is invalid",
10071	multilib_exclusions);
10072	}
10073
10074	if (! m)
10075	{
10076	++e;
10077	continue;
10078	}
10079
10080	this_arg = e;
10081
10082	while (*e != ' ' && *e != ';')
10083	{
10084	if (*e == '\0')
10085	goto invalid_exclusion;
10086	++e;
10087	}
10088
10089	q = p + 1;
10090	while (*q != ';')
10091	{
10092	const char *arg;
10093	int len = e - this_arg;
10094
10095	if (*q == '\0')
10096	goto invalid_select;
10097
10098	arg = q;
10099
10100	while (*q != ' ' && *q != ';')
10101	{
10102	if (*q == '\0')
10103	goto invalid_select;
10104	++q;
10105	}
10106
10107	if (! strncmp (s1: arg, s2: this_arg,
10108	n: (len < q - arg) ? q - arg : len)
10109	|| default_arg (p: this_arg, len: e - this_arg))
10110	{
10111	mp = 1;
10112	break;
10113	}
10114
10115	if (*q == ' ')
10116	++q;
10117	}
10118
10119	if (! mp)
10120	m = 0;
10121
10122	if (*e == ' ')
10123	++e;
10124	}
10125
10126	if (m)
10127	{
10128	skip = 1;
10129	break;
10130	}
10131
10132	if (*e != '\0')
10133	++e;
10134	}
10135	}
10136
10137	if (! skip)
10138	{
10139	/* If this is a duplicate, skip it. */
10140	skip = (last_path != 0
10141	&& (unsigned int) (p - this_path) == last_path_len
10142	&& ! filename_ncmp (s1: last_path, s2: this_path, n: last_path_len));
10143
10144	last_path = this_path;
10145	last_path_len = p - this_path;
10146	}
10147
10148	/* If all required arguments are default arguments, and no default
10149	arguments appear in the ! argument list, then we can skip it.
10150	We will already have printed a directory identical to this one
10151	which does not require that default argument. */
10152	if (! skip)
10153	{
10154	const char *q;
10155	bool default_arg_ok = false;
10156
10157	q = p + 1;
10158	while (*q != ';')
10159	{
10160	const char *arg;
10161
10162	if (*q == '\0')
10163	goto invalid_select;
10164
10165	if (*q == '!')
10166	{
10167	not_arg = 1;
10168	q++;
10169	}
10170	else
10171	not_arg = 0;
10172	arg = q;
10173
10174	while (*q != ' ' && *q != ';')
10175	{
10176	if (*q == '\0')
10177	goto invalid_select;
10178	++q;
10179	}
10180
10181	if (default_arg (p: arg, len: q - arg))
10182	{
10183	/* Stop checking if any default arguments appeared in not
10184	list. */
10185	if (not_arg)
10186	{
10187	default_arg_ok = false;
10188	break;
10189	}
10190
10191	default_arg_ok = true;
10192	}
10193	else if (!not_arg)
10194	{
10195	/* Stop checking if any required argument is not provided by
10196	default arguments. */
10197	default_arg_ok = false;
10198	break;
10199	}
10200
10201	if (*q == ' ')
10202	++q;
10203	}
10204
10205	/* Make sure all default argument is OK for this multi-lib set. */
10206	if (default_arg_ok)
10207	skip = 1;
10208	else
10209	skip = 0;
10210	}
10211
10212	if (! skip)
10213	{
10214	const char *p1;
10215
10216	for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
10217	putchar (c: *p1);
10218	putchar (c: ';');
10219	}
10220
10221	++p;
10222	while (*p != ';')
10223	{
10224	int use_arg;
10225
10226	if (*p == '\0')
10227	goto invalid_select;
10228
10229	if (skip)
10230	{
10231	++p;
10232	continue;
10233	}
10234
10235	use_arg = *p != '!';
10236
10237	if (use_arg)
10238	putchar (c: '@');
10239
10240	while (*p != ' ' && *p != ';')
10241	{
10242	if (*p == '\0')
10243	goto invalid_select;
10244	if (use_arg)
10245	putchar (c: *p);
10246	++p;
10247	}
10248
10249	if (*p == ' ')
10250	++p;
10251	}
10252
10253	if (! skip)
10254	{
10255	/* If there are extra options, print them now. */
10256	if (multilib_extra && *multilib_extra)
10257	{
10258	int print_at = true;
10259	const char *q;
10260
10261	for (q = multilib_extra; *q != '\0'; q++)
10262	{
10263	if (*q == ' ')
10264	print_at = true;
10265	else
10266	{
10267	if (print_at)
10268	putchar (c: '@');
10269	putchar (c: *q);
10270	print_at = false;
10271	}
10272	}
10273	}
10274
10275	putchar (c: '\n');
10276	}
10277
10278	++p;
10279	}
10280	}
10281
10282	/* getenv built-in spec function.
10283
10284	Returns the value of the environment variable given by its first argument,
10285	concatenated with the second argument. If the variable is not defined, a
10286	fatal error is issued unless such undefs are internally allowed, in which
10287	case the variable name prefixed by a '/' is used as the variable value.
10288
10289	The leading '/' allows using the result at a spot where a full path would
10290	normally be expected and when the actual value doesn't really matter since
10291	undef vars are allowed. */
10292
10293	static const char *
10294	getenv_spec_function (int argc, const char **argv)
10295	{
10296	const char *value;
10297	const char *varname;
10298
10299	char *result;
10300	char *ptr;
10301	size_t len;
10302
10303	if (argc != 2)
10304	return NULL;
10305
10306	varname = argv[0];
10307	value = env.get (name: varname);
10308
10309	/* If the variable isn't defined and this is allowed, craft our expected
10310	return value. Assume variable names used in specs strings don't contain
10311	any active spec character so don't need escaping. */
10312	if (!value && spec_undefvar_allowed)
10313	{
10314	result = XNEWVAR (char, strlen(varname) + 2);
10315	sprintf (s: result, format: "/%s", varname);
10316	return result;
10317	}
10318
10319	if (!value)
10320	fatal_error (input_location,
10321	"environment variable %qs not defined", varname);
10322
10323	/* We have to escape every character of the environment variable so
10324	they are not interpreted as active spec characters. A
10325	particularly painful case is when we are reading a variable
10326	holding a windows path complete with \ separators. */
10327	len = strlen (s: value) * 2 + strlen (s: argv[1]) + 1;
10328	result = XNEWVAR (char, len);
10329	for (ptr = result; *value; ptr += 2)
10330	{
10331	ptr[0] = '\\';
10332	ptr[1] = *value++;
10333	}
10334
10335	strcpy (dest: ptr, src: argv[1]);
10336
10337	return result;
10338	}
10339
10340	/* if-exists built-in spec function.
10341
10342	Checks to see if the file specified by the absolute pathname in
10343	ARGS exists. Returns that pathname if found.
10344
10345	The usual use for this function is to check for a library file
10346	(whose name has been expanded with %s). */
10347
10348	static const char *
10349	if_exists_spec_function (int argc, const char **argv)
10350	{
10351	/* Must have only one argument. */
10352	if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10353	return argv[0];
10354
10355	return NULL;
10356	}
10357
10358	/* if-exists-else built-in spec function.
10359
10360	This is like if-exists, but takes an additional argument which
10361	is returned if the first argument does not exist. */
10362
10363	static const char *
10364	if_exists_else_spec_function (int argc, const char **argv)
10365	{
10366	/* Must have exactly two arguments. */
10367	if (argc != 2)
10368	return NULL;
10369
10370	if (IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10371	return argv[0];
10372
10373	return argv[1];
10374	}
10375
10376	/* if-exists-then-else built-in spec function.
10377
10378	Checks to see if the file specified by the absolute pathname in
10379	the first arg exists. Returns the second arg if so, otherwise returns
10380	the third arg if it is present. */
10381
10382	static const char *
10383	if_exists_then_else_spec_function (int argc, const char **argv)
10384	{
10385
10386	/* Must have two or three arguments. */
10387	if (argc != 2 && argc != 3)
10388	return NULL;
10389
10390	if (IS_ABSOLUTE_PATH (argv[0]) && ! access (name: argv[0], R_OK))
10391	return argv[1];
10392
10393	if (argc == 3)
10394	return argv[2];
10395
10396	return NULL;
10397	}
10398
10399	/* sanitize built-in spec function.
10400
10401	This returns non-NULL, if sanitizing address, thread or
10402	any of the undefined behavior sanitizers. */
10403
10404	static const char *
10405	sanitize_spec_function (int argc, const char **argv)
10406	{
10407	if (argc != 1)
10408	return NULL;
10409
10410	if (strcmp (s1: argv[0], s2: "address") == 0)
10411	return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL;
10412	if (strcmp (s1: argv[0], s2: "hwaddress") == 0)
10413	return (flag_sanitize & SANITIZE_USER_HWADDRESS) ? "" : NULL;
10414	if (strcmp (s1: argv[0], s2: "kernel-address") == 0)
10415	return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL;
10416	if (strcmp (s1: argv[0], s2: "kernel-hwaddress") == 0)
10417	return (flag_sanitize & SANITIZE_KERNEL_HWADDRESS) ? "" : NULL;
10418	if (strcmp (s1: argv[0], s2: "thread") == 0)
10419	return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
10420	if (strcmp (s1: argv[0], s2: "undefined") == 0)
10421	return ((flag_sanitize
10422	& ~flag_sanitize_trap
10423	& (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)))
10424	? "" : NULL;
10425	if (strcmp (s1: argv[0], s2: "leak") == 0)
10426	return ((flag_sanitize
10427	& (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
10428	== SANITIZE_LEAK) ? "" : NULL;
10429	return NULL;
10430	}
10431
10432	/* replace-outfile built-in spec function.
10433
10434	This looks for the first argument in the outfiles array's name and
10435	replaces it with the second argument. */
10436
10437	static const char *
10438	replace_outfile_spec_function (int argc, const char **argv)
10439	{
10440	int i;
10441	/* Must have exactly two arguments. */
10442	if (argc != 2)
10443	abort ();
10444
10445	for (i = 0; i < n_infiles; i++)
10446	{
10447	if (outfiles[i] && !filename_cmp (s1: outfiles[i], s2: argv[0]))
10448	outfiles[i] = xstrdup (argv[1]);
10449	}
10450	return NULL;
10451	}
10452
10453	/* remove-outfile built-in spec function.
10454	*
10455	* This looks for the first argument in the outfiles array's name and
10456	* removes it. */
10457
10458	static const char *
10459	remove_outfile_spec_function (int argc, const char **argv)
10460	{
10461	int i;
10462	/* Must have exactly one argument. */
10463	if (argc != 1)
10464	abort ();
10465
10466	for (i = 0; i < n_infiles; i++)
10467	{
10468	if (outfiles[i] && !filename_cmp (s1: outfiles[i], s2: argv[0]))
10469	outfiles[i] = NULL;
10470	}
10471	return NULL;
10472	}
10473
10474	/* Given two version numbers, compares the two numbers.
10475	A version number must match the regular expression
10476	([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10477	*/
10478	static int
10479	compare_version_strings (const char *v1, const char *v2)
10480	{
10481	int rresult;
10482	regex_t r;
10483
10484	if (regcomp (preg: &r, pattern: "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10485	REG_EXTENDED | REG_NOSUB) != 0)
10486	abort ();
10487	rresult = regexec (preg: &r, string: v1, nmatch: 0, NULL, eflags: 0);
10488	if (rresult == REG_NOMATCH)
10489	fatal_error (input_location, "invalid version number %qs", v1);
10490	else if (rresult != 0)
10491	abort ();
10492	rresult = regexec (preg: &r, string: v2, nmatch: 0, NULL, eflags: 0);
10493	if (rresult == REG_NOMATCH)
10494	fatal_error (input_location, "invalid version number %qs", v2);
10495	else if (rresult != 0)
10496	abort ();
10497
10498	return strverscmp (s1: v1, s2: v2);
10499	}
10500
10501
10502	/* version_compare built-in spec function.
10503
10504	This takes an argument of the following form:
10505
10506	<comparison-op> <arg1> [<arg2>] <switch> <result>
10507
10508	and produces "result" if the comparison evaluates to true,
10509	and nothing if it doesn't.
10510
10511	The supported <comparison-op> values are:
10512
10513	>= true if switch is a later (or same) version than arg1
10514	!> opposite of >=
10515	< true if switch is an earlier version than arg1
10516	!< opposite of <
10517	>< true if switch is arg1 or later, and earlier than arg2
10518	<> true if switch is earlier than arg1 or is arg2 or later
10519
10520	If the switch is not present, the condition is false unless
10521	the first character of the <comparison-op> is '!'.
10522
10523	For example,
10524	%:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10525	adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10526
10527	static const char *
10528	version_compare_spec_function (int argc, const char **argv)
10529	{
10530	int comp1, comp2;
10531	size_t switch_len;
10532	const char *switch_value = NULL;
10533	int nargs = 1, i;
10534	bool result;
10535
10536	if (argc < 3)
10537	fatal_error (input_location, "too few arguments to %%:version-compare");
10538	if (argv[0][0] == '\0')
10539	abort ();
10540	if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
10541	nargs = 2;
10542	if (argc != nargs + 3)
10543	fatal_error (input_location, "too many arguments to %%:version-compare");
10544
10545	switch_len = strlen (s: argv[nargs + 1]);
10546	for (i = 0; i < n_switches; i++)
10547	if (!strncmp (s1: switches[i].part1, s2: argv[nargs + 1], n: switch_len)
10548	&& check_live_switch (switchnum: i, prefix_length: switch_len))
10549	switch_value = switches[i].part1 + switch_len;
10550
10551	if (switch_value == NULL)
10552	comp1 = comp2 = -1;
10553	else
10554	{
10555	comp1 = compare_version_strings (v1: switch_value, v2: argv[1]);
10556	if (nargs == 2)
10557	comp2 = compare_version_strings (v1: switch_value, v2: argv[2]);
10558	else
10559	comp2 = -1; /* This value unused. */
10560	}
10561
10562	switch (argv[0][0] << 8 | argv[0][1])
10563	{
10564	case '>' << 8 | '=':
10565	result = comp1 >= 0;
10566	break;
10567	case '!' << 8 | '<':
10568	result = comp1 >= 0 || switch_value == NULL;
10569	break;
10570	case '<' << 8:
10571	result = comp1 < 0;
10572	break;
10573	case '!' << 8 | '>':
10574	result = comp1 < 0 || switch_value == NULL;
10575	break;
10576	case '>' << 8 | '<':
10577	result = comp1 >= 0 && comp2 < 0;
10578	break;
10579	case '<' << 8 | '>':
10580	result = comp1 < 0 || comp2 >= 0;
10581	break;
10582
10583	default:
10584	fatal_error (input_location,
10585	"unknown operator %qs in %%:version-compare", argv[0]);
10586	}
10587	if (! result)
10588	return NULL;
10589
10590	return argv[nargs + 2];
10591	}
10592
10593	/* %:include builtin spec function. This differs from %include in that it
10594	can be nested inside a spec, and thus be conditionalized. It takes
10595	one argument, the filename, and looks for it in the startfile path.
10596	The result is always NULL, i.e. an empty expansion. */
10597
10598	static const char *
10599	include_spec_function (int argc, const char **argv)
10600	{
10601	char *file;
10602
10603	if (argc != 1)
10604	abort ();
10605
10606	file = find_a_file (pprefix: &startfile_prefixes, name: argv[0], R_OK, do_multi: true);
10607	read_specs (filename: file ? file : argv[0], main_p: false, user_p: false);
10608
10609	return NULL;
10610	}
10611
10612	/* %:find-file spec function. This function replaces its argument by
10613	the file found through find_file, that is the -print-file-name gcc
10614	program option. */
10615	static const char *
10616	find_file_spec_function (int argc, const char **argv)
10617	{
10618	const char *file;
10619
10620	if (argc != 1)
10621	abort ();
10622
10623	file = find_file (name: argv[0]);
10624	return file;
10625	}
10626
10627
10628	/* %:find-plugindir spec function. This function replaces its argument
10629	by the -iplugindir=<dir> option. `dir' is found through find_file, that
10630	is the -print-file-name gcc program option. */
10631	static const char *
10632	find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
10633	{
10634	const char *option;
10635
10636	if (argc != 0)
10637	abort ();
10638
10639	option = concat ("-iplugindir=", find_file (name: "plugin"), NULL);
10640	return option;
10641	}
10642
10643
10644	/* %:print-asm-header spec function. Print a banner to say that the
10645	following output is from the assembler. */
10646
10647	static const char *
10648	print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
10649	const char **argv ATTRIBUTE_UNUSED)
10650	{
10651	printf (_("Assembler options\n=================\n\n"));
10652	printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10653	fflush (stdout);
10654	return NULL;
10655	}
10656
10657	/* Get a random number for -frandom-seed */
10658
10659	static unsigned HOST_WIDE_INT
10660	get_random_number (void)
10661	{
10662	unsigned HOST_WIDE_INT ret = 0;
10663	int fd;
10664
10665	fd = open (file: "/dev/urandom", O_RDONLY);
10666	if (fd >= 0)
10667	{
10668	read (fd: fd, buf: &ret, nbytes: sizeof (HOST_WIDE_INT));
10669	close (fd: fd);
10670	if (ret)
10671	return ret;
10672	}
10673
10674	/* Get some more or less random data. */
10675	#ifdef HAVE_GETTIMEOFDAY
10676	{
10677	struct timeval tv;
10678
10679	gettimeofday (tv: &tv, NULL);
10680	ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
10681	}
10682	#else
10683	{
10684	time_t now = time (NULL);
10685
10686	if (now != (time_t)-1)
10687	ret = (unsigned) now;
10688	}
10689	#endif
10690
10691	return ret ^ getpid ();
10692	}
10693
10694	/* %:compare-debug-dump-opt spec function. Save the last argument,
10695	expected to be the last -fdump-final-insns option, or generate a
10696	temporary. */
10697
10698	static const char *
10699	compare_debug_dump_opt_spec_function (int arg,
10700	const char **argv ATTRIBUTE_UNUSED)
10701	{
10702	char *ret;
10703	char *name;
10704	int which;
10705	static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
10706
10707	if (arg != 0)
10708	fatal_error (input_location,
10709	"too many arguments to %%:compare-debug-dump-opt");
10710
10711	do_spec_2 (spec: "%{fdump-final-insns=*:%*}", NULL);
10712	do_spec_1 (spec: " ", inswitch: 0, NULL);
10713
10714	if (argbuf.length () > 0
10715	&& strcmp (s1: argv[argbuf.length () - 1], s2: ".") != 0)
10716	{
10717	if (!compare_debug)
10718	return NULL;
10719
10720	name = xstrdup (argv[argbuf.length () - 1]);
10721	ret = NULL;
10722	}
10723	else
10724	{
10725	if (argbuf.length () > 0)
10726	do_spec_2 (spec: "%B.gkd", NULL);
10727	else if (!compare_debug)
10728	return NULL;
10729	else
10730	do_spec_2 (spec: "%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL);
10731
10732	do_spec_1 (spec: " ", inswitch: 0, NULL);
10733
10734	gcc_assert (argbuf.length () > 0);
10735
10736	name = xstrdup (argbuf.last ());
10737
10738	char *arg = quote_spec (xstrdup (name));
10739	ret = concat ("-fdump-final-insns=", arg, NULL);
10740	free (ptr: arg);
10741	}
10742
10743	which = compare_debug < 0;
10744	debug_check_temp_file[which] = name;
10745
10746	if (!which)
10747	{
10748	unsigned HOST_WIDE_INT value = get_random_number ();
10749
10750	sprintf (s: random_seed, HOST_WIDE_INT_PRINT_HEX, value);
10751	}
10752
10753	if (*random_seed)
10754	{
10755	char *tmp = ret;
10756	ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
10757	ret, NULL);
10758	free (ptr: tmp);
10759	}
10760
10761	if (which)
10762	*random_seed = 0;
10763
10764	return ret;
10765	}
10766
10767	/* %:compare-debug-self-opt spec function. Expands to the options
10768	that are to be passed in the second compilation of
10769	compare-debug. */
10770
10771	static const char *
10772	compare_debug_self_opt_spec_function (int arg,
10773	const char **argv ATTRIBUTE_UNUSED)
10774	{
10775	if (arg != 0)
10776	fatal_error (input_location,
10777	"too many arguments to %%:compare-debug-self-opt");
10778
10779	if (compare_debug >= 0)
10780	return NULL;
10781
10782	return concat ("\
10783	%<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10784	%<fdump-final-insns=* -w -S -o %j \
10785	%{!fcompare-debug-second:-fcompare-debug-second} \
10786	", compare_debug_opt, NULL);
10787	}
10788
10789	/* %:pass-through-libs spec function. Finds all -l options and input
10790	file names in the lib spec passed to it, and makes a list of them
10791	prepended with the plugin option to cause them to be passed through
10792	to the final link after all the new object files have been added. */
10793
10794	const char *
10795	pass_through_libs_spec_func (int argc, const char **argv)
10796	{
10797	char *prepended = xstrdup (" ");
10798	int n;
10799	/* Shlemiel the painter's algorithm. Innately horrible, but at least
10800	we know that there will never be more than a handful of strings to
10801	concat, and it's only once per run, so it's not worth optimising. */
10802	for (n = 0; n < argc; n++)
10803	{
10804	char *old = prepended;
10805	/* Anything that isn't an option is a full path to an output
10806	file; pass it through if it ends in '.a'. Among options,
10807	pass only -l. */
10808	if (argv[n][0] == '-' && argv[n][1] == 'l')
10809	{
10810	const char *lopt = argv[n] + 2;
10811	/* Handle both joined and non-joined -l options. If for any
10812	reason there's a trailing -l with no joined or following
10813	arg just discard it. */
10814	if (!*lopt && ++n >= argc)
10815	break;
10816	else if (!*lopt)
10817	lopt = argv[n];
10818	prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
10819	lopt, " ", NULL);
10820	}
10821	else if (!strcmp (s1: ".a", s2: argv[n] + strlen (s: argv[n]) - 2))
10822	{
10823	prepended = concat (prepended, "-plugin-opt=-pass-through=",
10824	argv[n], " ", NULL);
10825	}
10826	if (prepended != old)
10827	free (ptr: old);
10828	}
10829	return prepended;
10830	}
10831
10832	static bool
10833	not_actual_file_p (const char *name)
10834	{
10835	return (strcmp (s1: name, s2: "-") == 0
10836	|| strcmp (s1: name, HOST_BIT_BUCKET) == 0);
10837	}
10838
10839	/* %:dumps spec function. Take an optional argument that overrides
10840	the default extension for -dumpbase and -dumpbase-ext.
10841	Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10842	const char *
10843	dumps_spec_func (int argc, const char **argv ATTRIBUTE_UNUSED)
10844	{
10845	const char *ext = dumpbase_ext;
10846	char *p;
10847
10848	char *args[3] = { NULL, NULL, NULL };
10849	int nargs = 0;
10850
10851	/* Do not compute a default for -dumpbase-ext when -dumpbase was
10852	given explicitly. */
10853	if (dumpbase && *dumpbase && !ext)
10854	ext = "";
10855
10856	if (argc == 1)
10857	{
10858	/* Do not override the explicitly-specified -dumpbase-ext with
10859	the specs-provided overrider. */
10860	if (!ext)
10861	ext = argv[0];
10862	}
10863	else if (argc != 0)
10864	fatal_error (input_location, "too many arguments for %%:dumps");
10865
10866	if (dumpdir)
10867	{
10868	p = quote_spec_arg (xstrdup (dumpdir));
10869	args[nargs++] = concat (" -dumpdir ", p, NULL);
10870	free (ptr: p);
10871	}
10872
10873	if (!ext)
10874	ext = input_basename + basename_length;
10875
10876	/* Use the precomputed outbase, or compute dumpbase from
10877	input_basename, just like %b would. */
10878	char *base;
10879
10880	if (dumpbase && *dumpbase)
10881	{
10882	base = xstrdup (dumpbase);
10883	p = base + outbase_length;
10884	gcc_checking_assert (strncmp (base, outbase, outbase_length) == 0);
10885	gcc_checking_assert (strcmp (p, ext) == 0);
10886	}
10887	else if (outbase_length)
10888	{
10889	base = xstrndup (outbase, outbase_length);
10890	p = NULL;
10891	}
10892	else
10893	{
10894	base = xstrndup (input_basename, suffixed_basename_length);
10895	p = base + basename_length;
10896	}
10897
10898	if (compare_debug < 0 || !p || strcmp (s1: p, s2: ext) != 0)
10899	{
10900	if (p)
10901	*p = '\0';
10902
10903	const char *gk;
10904	if (compare_debug < 0)
10905	gk = ".gk";
10906	else
10907	gk = "";
10908
10909	p = concat (base, gk, ext, NULL);
10910
10911	free (ptr: base);
10912	base = p;
10913	}
10914
10915	base = quote_spec_arg (base);
10916	args[nargs++] = concat (" -dumpbase ", base, NULL);
10917	free (ptr: base);
10918
10919	if (*ext)
10920	{
10921	p = quote_spec_arg (xstrdup (ext));
10922	args[nargs++] = concat (" -dumpbase-ext ", p, NULL);
10923	free (ptr: p);
10924	}
10925
10926	const char *ret = concat (args[0], args[1], args[2], NULL);
10927	while (nargs > 0)
10928	free (ptr: args[--nargs]);
10929
10930	return ret;
10931	}
10932
10933	/* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10934	Otherwise, return NULL. */
10935
10936	static const char *
10937	greater_than_spec_func (int argc, const char **argv)
10938	{
10939	char *converted;
10940
10941	if (argc == 1)
10942	return NULL;
10943
10944	gcc_assert (argc >= 2);
10945
10946	long arg = strtol (nptr: argv[argc - 2], endptr: &converted, base: 10);
10947	gcc_assert (converted != argv[argc - 2]);
10948
10949	long lim = strtol (nptr: argv[argc - 1], endptr: &converted, base: 10);
10950	gcc_assert (converted != argv[argc - 1]);
10951
10952	if (arg > lim)
10953	return "";
10954
10955	return NULL;
10956	}
10957
10958	/* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10959	Otherwise, return NULL. */
10960
10961	static const char *
10962	debug_level_greater_than_spec_func (int argc, const char **argv)
10963	{
10964	char *converted;
10965
10966	if (argc != 1)
10967	fatal_error (input_location,
10968	"wrong number of arguments to %%:debug-level-gt");
10969
10970	long arg = strtol (nptr: argv[0], endptr: &converted, base: 10);
10971	gcc_assert (converted != argv[0]);
10972
10973	if (debug_info_level > arg)
10974	return "";
10975
10976	return NULL;
10977	}
10978
10979	/* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10980	Otherwise, return NULL. */
10981
10982	static const char *
10983	dwarf_version_greater_than_spec_func (int argc, const char **argv)
10984	{
10985	char *converted;
10986
10987	if (argc != 1)
10988	fatal_error (input_location,
10989	"wrong number of arguments to %%:dwarf-version-gt");
10990
10991	long arg = strtol (nptr: argv[0], endptr: &converted, base: 10);
10992	gcc_assert (converted != argv[0]);
10993
10994	if (dwarf_version > arg)
10995	return "";
10996
10997	return NULL;
10998	}
10999
11000	static void
11001	path_prefix_reset (path_prefix *prefix)
11002	{
11003	struct prefix_list *iter, *next;
11004	iter = prefix->plist;
11005	while (iter)
11006	{
11007	next = iter->next;
11008	free (ptr: const_cast <char *> (iter->prefix));
11009	XDELETE (iter);
11010	iter = next;
11011	}
11012	prefix->plist = 0;
11013	prefix->max_len = 0;
11014	}
11015
11016	/* The function takes 3 arguments: OPTION name, file name and location
11017	where we search for Fortran modules.
11018	When the FILE is found by find_file, return OPTION=path_to_file. */
11019
11020	static const char *
11021	find_fortran_preinclude_file (int argc, const char **argv)
11022	{
11023	char *result = NULL;
11024	if (argc != 3)
11025	return NULL;
11026
11027	struct path_prefix prefixes = { .plist: 0, .max_len: 0, .name: "preinclude" };
11028
11029	/* Search first for 'finclude' folder location for a header file
11030	installed by the compiler (similar to omp_lib.h). */
11031	add_prefix (pprefix: &prefixes, prefix: argv[2], NULL, priority: 0, require_machine_suffix: 0, os_multilib: 0);
11032	#ifdef TOOL_INCLUDE_DIR
11033	/* Then search: <prefix>/<target>/<include>/finclude */
11034	add_prefix (&prefixes, TOOL_INCLUDE_DIR "/finclude/",
11035	NULL, 0, 0, 0);
11036	#endif
11037	#ifdef NATIVE_SYSTEM_HEADER_DIR
11038	/* Then search: <sysroot>/usr/include/finclude/<multilib> */
11039	add_sysrooted_hdrs_prefix (&prefixes, NATIVE_SYSTEM_HEADER_DIR "/finclude/",
11040	NULL, 0, 0, 0);
11041	#endif
11042
11043	const char *path = find_a_file (pprefix: &include_prefixes, name: argv[1], R_OK, do_multi: false);
11044	if (path != NULL)
11045	result = concat (argv[0], path, NULL);
11046	else
11047	{
11048	path = find_a_file (pprefix: &prefixes, name: argv[1], R_OK, do_multi: false);
11049	if (path != NULL)
11050	result = concat (argv[0], path, NULL);
11051	}
11052
11053	path_prefix_reset (prefix: &prefixes);
11054	return result;
11055	}
11056
11057	/* The function takes any number of arguments and joins them together.
11058
11059	This seems to be necessary to build "-fjoined=foo.b" from "-fseparate foo.a"
11060	with a %{fseparate*:-fjoined=%.b$*} rule without adding undesired spaces:
11061	when doing $* replacement we first replace $* with the rest of the switch
11062	(in this case ""), and then add any arguments as arguments after the result,
11063	resulting in "-fjoined= foo.b". Using this function with e.g.
11064	%{fseparate*:-fjoined=%:join(%.b$*)} gets multiple words as separate argv
11065	elements instead of separated by spaces, and we paste them together. */
11066
11067	static const char *
11068	join_spec_func (int argc, const char **argv)
11069	{
11070	if (argc == 1)
11071	return argv[0];
11072	for (int i = 0; i < argc; ++i)
11073	obstack_grow (&obstack, argv[i], strlen (argv[i]));
11074	obstack_1grow (&obstack, '\0');
11075	return XOBFINISH (&obstack, const char *);
11076	}
11077
11078	/* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
11079	so as to precede every one of them with a backslash. Return the
11080	original string or the reallocated one. */
11081
11082	static inline char *
11083	quote_string (char *orig, bool (*quote_p)(char, void *), void *p)
11084	{
11085	int len, number_of_space = 0;
11086
11087	for (len = 0; orig[len]; len++)
11088	if (quote_p (orig[len], p))
11089	number_of_space++;
11090
11091	if (number_of_space)
11092	{
11093	char *new_spec = (char *) xmalloc (len + number_of_space + 1);
11094	int j, k;
11095	for (j = 0, k = 0; j <= len; j++, k++)
11096	{
11097	if (quote_p (orig[j], p))
11098	new_spec[k++] = '\\';
11099	new_spec[k] = orig[j];
11100	}
11101	free (ptr: orig);
11102	return new_spec;
11103	}
11104	else
11105	return orig;
11106	}
11107
11108	/* Return true iff C is any of the characters convert_white_space
11109	should quote. */
11110
11111	static inline bool
11112	whitespace_to_convert_p (char c, void *)
11113	{
11114	return (c == ' ' || c == '\t');
11115	}
11116
11117	/* Insert backslash before spaces in ORIG (usually a file path), to
11118	avoid being broken by spec parser.
11119
11120	This function is needed as do_spec_1 treats white space (' ' and '\t')
11121	as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
11122	the file name should be treated as a single argument rather than being
11123	broken into multiple. Solution is to insert '\\' before the space in a
11124	file name.
11125
11126	This function converts and only converts all occurrence of ' '
11127	to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
11128	"a b" -> "a\\ b"
11129	"a b" -> "a\\ \\ b"
11130	"a\tb" -> "a\\\tb"
11131	"a\\ b" -> "a\\\\ b"
11132
11133	orig: input null-terminating string that was allocated by xalloc. The
11134	memory it points to might be freed in this function. Behavior undefined
11135	if ORIG wasn't xalloced or was freed already at entry.
11136
11137	Return: ORIG if no conversion needed. Otherwise a newly allocated string
11138	that was converted from ORIG. */
11139
11140	static char *
11141	convert_white_space (char *orig)
11142	{
11143	return quote_string (orig, quote_p: whitespace_to_convert_p, NULL);
11144	}
11145
11146	/* Return true iff C matches any of the spec active characters. */
11147	static inline bool
11148	quote_spec_char_p (char c, void *)
11149	{
11150	switch (c)
11151	{
11152	case ' ':
11153	case '\t':
11154	case '\n':
11155	case '|':
11156	case '%':
11157	case '\\':
11158	return true;
11159
11160	default:
11161	return false;
11162	}
11163	}
11164
11165	/* Like convert_white_space, but deactivate all active spec chars by
11166	quoting them. */
11167
11168	static inline char *
11169	quote_spec (char *orig)
11170	{
11171	return quote_string (orig, quote_p: quote_spec_char_p, NULL);
11172	}
11173
11174	/* Like quote_spec, but also turn an empty string into the spec for an
11175	empty argument. */
11176
11177	static inline char *
11178	quote_spec_arg (char *orig)
11179	{
11180	if (!*orig)
11181	{
11182	free (ptr: orig);
11183	return xstrdup ("%\"");
11184	}
11185
11186	return quote_spec (orig);
11187	}
11188
11189	/* Restore all state within gcc.cc to the initial state, so that the driver
11190	code can be safely re-run in-process.
11191
11192	Many const char * variables are referenced by static specs (see
11193	INIT_STATIC_SPEC above). These variables are restored to their default
11194	values by a simple loop over the static specs.
11195
11196	For other variables, we directly restore them all to their initial
11197	values (often implicitly 0).
11198
11199	Free the various obstacks in this file, along with "opts_obstack"
11200	from opts.cc.
11201
11202	This function also restores any environment variables that were changed. */
11203
11204	void
11205	driver::finalize ()
11206	{
11207	env.restore ();
11208	diagnostic_finish (context: global_dc);
11209
11210	is_cpp_driver = 0;
11211	at_file_supplied = 0;
11212	print_help_list = 0;
11213	print_version = 0;
11214	verbose_only_flag = 0;
11215	print_subprocess_help = 0;
11216	use_ld = NULL;
11217	report_times_to_file = NULL;
11218	target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
11219	target_system_root_changed = 0;
11220	target_sysroot_suffix = 0;
11221	target_sysroot_hdrs_suffix = 0;
11222	save_temps_flag = SAVE_TEMPS_NONE;
11223	save_temps_overrides_dumpdir = false;
11224	dumpdir_trailing_dash_added = false;
11225	free (ptr: dumpdir);
11226	free (ptr: dumpbase);
11227	free (ptr: dumpbase_ext);
11228	free (ptr: outbase);
11229	dumpdir = dumpbase = dumpbase_ext = outbase = NULL;
11230	dumpdir_length = outbase_length = 0;
11231	spec_machine = DEFAULT_TARGET_MACHINE;
11232	greatest_status = 1;
11233
11234	obstack_free (&obstack, NULL);
11235	obstack_free (&opts_obstack, NULL); /* in opts.cc */
11236	obstack_free (&collect_obstack, NULL);
11237
11238	link_command_spec = LINK_COMMAND_SPEC;
11239
11240	obstack_free (&multilib_obstack, NULL);
11241
11242	user_specs_head = NULL;
11243	user_specs_tail = NULL;
11244
11245	/* Within the "compilers" vec, the fields "suffix" and "spec" were
11246	statically allocated for the default compilers, but dynamically
11247	allocated for additional compilers. Delete them for the latter. */
11248	for (int i = n_default_compilers; i < n_compilers; i++)
11249	{
11250	free (ptr: const_cast <char *> (compilers[i].suffix));
11251	free (ptr: const_cast <char *> (compilers[i].spec));
11252	}
11253	XDELETEVEC (compilers);
11254	compilers = NULL;
11255	n_compilers = 0;
11256
11257	linker_options.truncate (size: 0);
11258	assembler_options.truncate (size: 0);
11259	preprocessor_options.truncate (size: 0);
11260
11261	path_prefix_reset (prefix: &exec_prefixes);
11262	path_prefix_reset (prefix: &startfile_prefixes);
11263	path_prefix_reset (prefix: &include_prefixes);
11264
11265	machine_suffix = 0;
11266	just_machine_suffix = 0;
11267	gcc_exec_prefix = 0;
11268	gcc_libexec_prefix = 0;
11269	set_static_spec_shared (spec: &md_exec_prefix, MD_EXEC_PREFIX);
11270	set_static_spec_shared (spec: &md_startfile_prefix, MD_STARTFILE_PREFIX);
11271	set_static_spec_shared (spec: &md_startfile_prefix_1, MD_STARTFILE_PREFIX_1);
11272	multilib_dir = 0;
11273	multilib_os_dir = 0;
11274	multiarch_dir = 0;
11275
11276	/* Free any specs dynamically-allocated by set_spec.
11277	These will be at the head of the list, before the
11278	statically-allocated ones. */
11279	if (specs)
11280	{
11281	while (specs != static_specs)
11282	{
11283	spec_list *next = specs->next;
11284	free (ptr: const_cast <char *> (specs->name));
11285	XDELETE (specs);
11286	specs = next;
11287	}
11288	specs = 0;
11289	}
11290	for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
11291	{
11292	spec_list *sl = &static_specs[i];
11293	if (sl->alloc_p)
11294	{
11295	free (ptr: const_cast <char *> (*(sl->ptr_spec)));
11296	sl->alloc_p = false;
11297	}
11298	*(sl->ptr_spec) = sl->default_ptr;
11299	}
11300	#ifdef EXTRA_SPECS
11301	extra_specs = NULL;
11302	#endif
11303
11304	processing_spec_function = 0;
11305
11306	clear_args ();
11307
11308	have_c = 0;
11309	have_o = 0;
11310
11311	temp_names = NULL;
11312	execution_count = 0;
11313	signal_count = 0;
11314
11315	temp_filename = NULL;
11316	temp_filename_length = 0;
11317	always_delete_queue = NULL;
11318	failure_delete_queue = NULL;
11319
11320	XDELETEVEC (switches);
11321	switches = NULL;
11322	n_switches = 0;
11323	n_switches_alloc = 0;
11324
11325	compare_debug = 0;
11326	compare_debug_second = 0;
11327	compare_debug_opt = NULL;
11328	for (int i = 0; i < 2; i++)
11329	{
11330	switches_debug_check[i] = NULL;
11331	n_switches_debug_check[i] = 0;
11332	n_switches_alloc_debug_check[i] = 0;
11333	debug_check_temp_file[i] = NULL;
11334	}
11335
11336	XDELETEVEC (infiles);
11337	infiles = NULL;
11338	n_infiles = 0;
11339	n_infiles_alloc = 0;
11340
11341	combine_inputs = false;
11342	added_libraries = 0;
11343	XDELETEVEC (outfiles);
11344	outfiles = NULL;
11345	spec_lang = 0;
11346	last_language_n_infiles = 0;
11347	gcc_input_filename = NULL;
11348	input_file_number = 0;
11349	input_filename_length = 0;
11350	basename_length = 0;
11351	suffixed_basename_length = 0;
11352	input_basename = NULL;
11353	input_suffix = NULL;
11354	/* We don't need to purge "input_stat", just to unset "input_stat_set". */
11355	input_stat_set = 0;
11356	input_file_compiler = NULL;
11357	arg_going = 0;
11358	delete_this_arg = 0;
11359	this_is_output_file = 0;
11360	this_is_library_file = 0;
11361	this_is_linker_script = 0;
11362	input_from_pipe = 0;
11363	suffix_subst = NULL;
11364
11365	XDELETEVEC (mdswitches);
11366	mdswitches = NULL;
11367	n_mdswitches = 0;
11368
11369	used_arg.finalize ();
11370	}
11371
11372	/* PR jit/64810.
11373	Targets can provide configure-time default options in
11374	OPTION_DEFAULT_SPECS. The jit needs to access these, but
11375	they are expressed in the spec language.
11376
11377	Run just enough of the driver to be able to expand these
11378	specs, and then call the callback CB on each
11379	such option. The options strings are *without* a leading
11380	'-' character e.g. ("march=x86-64"). Finally, clean up. */
11381
11382	void
11383	driver_get_configure_time_options (void (*cb) (const char *option,
11384	void *user_data),
11385	void *user_data)
11386	{
11387	size_t i;
11388
11389	obstack_init (&obstack);
11390	init_opts_obstack ();
11391	n_switches = 0;
11392
11393	for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
11394	do_option_spec (name: option_default_specs[i].name,
11395	spec: option_default_specs[i].spec);
11396
11397	for (i = 0; (int) i < n_switches; i++)
11398	{
11399	gcc_assert (switches[i].part1);
11400	(*cb) (switches[i].part1, user_data);
11401	}
11402
11403	obstack_free (&opts_obstack, NULL);
11404	obstack_free (&obstack, NULL);
11405	n_switches = 0;
11406	}
11407