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

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of gcc/gcc.cc