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