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