OSDN Git Service

d6f0a0812f6685cba2190623253153d204315d82
[pf3gnuchains/gcc-fork.git] / gcc / gcc.c
1 /* Compiler driver program that can handle many languages.
2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4    2010
5    Free Software Foundation, Inc.
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers.  It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
28
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec".  */
32
33 #include "config.h"
34 #include "system.h"
35 #include "coretypes.h"
36 #include "multilib.h" /* before tm.h */
37 #include "tm.h"
38 #include "xregex.h"
39 #include "obstack.h"
40 #include "intl.h"
41 #include "prefix.h"
42 #include "gcc.h"
43 #include "diagnostic.h"
44 #include "flags.h"
45 #include "opts.h"
46 #include "vec.h"
47
48 /* By default there is no special suffix for target executables.  */
49 /* FIXME: when autoconf is fixed, remove the host check - dj */
50 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
51 #define HAVE_TARGET_EXECUTABLE_SUFFIX
52 #endif
53
54 /* By default there is no special suffix for host executables.  */
55 #ifdef HOST_EXECUTABLE_SUFFIX
56 #define HAVE_HOST_EXECUTABLE_SUFFIX
57 #else
58 #define HOST_EXECUTABLE_SUFFIX ""
59 #endif
60
61 /* By default, the suffix for target object files is ".o".  */
62 #ifdef TARGET_OBJECT_SUFFIX
63 #define HAVE_TARGET_OBJECT_SUFFIX
64 #else
65 #define TARGET_OBJECT_SUFFIX ".o"
66 #endif
67
68 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
69
70 /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
71 #ifndef LIBRARY_PATH_ENV
72 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
73 #endif
74
75 /* If a stage of compilation returns an exit status >= 1,
76    compilation of that file ceases.  */
77
78 #define MIN_FATAL_STATUS 1
79
80 /* Flag set by cppspec.c to 1.  */
81 int is_cpp_driver;
82
83 /* Flag set to nonzero if an @file argument has been supplied to gcc.  */
84 static bool at_file_supplied;
85
86 /* Definition of string containing the arguments given to configure.  */
87 #include "configargs.h"
88
89 /* Flag saying to print the command line options understood by gcc and its
90    sub-processes.  */
91
92 static int print_help_list;
93
94 /* Flag saying to print the version of gcc and its sub-processes.  */
95
96 static int print_version;
97
98 /* Flag indicating whether we should ONLY print the command and
99    arguments (like verbose_flag) without executing the command.
100    Displayed arguments are quoted so that the generated command
101    line is suitable for execution.  This is intended for use in
102    shell scripts to capture the driver-generated command line.  */
103 static int verbose_only_flag;
104
105 /* Flag indicating how to print command line options of sub-processes.  */
106
107 static int print_subprocess_help;
108
109 /* Whether we should report subprocess execution times to a file.  */
110
111 FILE *report_times_to_file = NULL;
112
113 /* Nonzero means place this string before uses of /, so that include
114    and library files can be found in an alternate location.  */
115
116 #ifdef TARGET_SYSTEM_ROOT
117 static const char *target_system_root = TARGET_SYSTEM_ROOT;
118 #else
119 static const char *target_system_root = 0;
120 #endif
121
122 /* Nonzero means pass the updated target_system_root to the compiler.  */
123
124 static int target_system_root_changed;
125
126 /* Nonzero means append this string to target_system_root.  */
127
128 static const char *target_sysroot_suffix = 0;
129
130 /* Nonzero means append this string to target_system_root for headers.  */
131
132 static const char *target_sysroot_hdrs_suffix = 0;
133
134 /* Nonzero means write "temp" files in source directory
135    and use the source file's name in them, and don't delete them.  */
136
137 static enum save_temps {
138   SAVE_TEMPS_NONE,              /* no -save-temps */
139   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
140   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
141 } save_temps_flag;
142
143 /* Output file to use to get the object directory for -save-temps=obj  */
144 static char *save_temps_prefix = 0;
145 static size_t save_temps_length = 0;
146
147 /* The compiler version.  */
148
149 static const char *compiler_version;
150
151 /* The target version.  */
152
153 static const char *const spec_version = DEFAULT_TARGET_VERSION;
154
155 /* The target machine.  */
156
157 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
158
159 /* Nonzero if cross-compiling.
160    When -b is used, the value comes from the `specs' file.  */
161
162 #ifdef CROSS_DIRECTORY_STRUCTURE
163 static const char *cross_compile = "1";
164 #else
165 static const char *cross_compile = "0";
166 #endif
167
168 /* Greatest exit code of sub-processes that has been encountered up to
169    now.  */
170 static int greatest_status = 1;
171
172 /* This is the obstack which we use to allocate many strings.  */
173
174 static struct obstack obstack;
175
176 /* This is the obstack to build an environment variable to pass to
177    collect2 that describes all of the relevant switches of what to
178    pass the compiler in building the list of pointers to constructors
179    and destructors.  */
180
181 static struct obstack collect_obstack;
182
183 /* Forward declaration for prototypes.  */
184 struct path_prefix;
185 struct prefix_list;
186
187 static void init_spec (void);
188 static void store_arg (const char *, int, int);
189 static void insert_wrapper (const char *);
190 static char *load_specs (const char *);
191 static void read_specs (const char *, int);
192 static void set_spec (const char *, const char *);
193 static struct compiler *lookup_compiler (const char *, size_t, const char *);
194 static char *build_search_list (const struct path_prefix *, const char *,
195                                 bool, bool);
196 static void xputenv (const char *);
197 static void putenv_from_prefixes (const struct path_prefix *, const char *,
198                                   bool);
199 static int access_check (const char *, int);
200 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
201 static void add_prefix (struct path_prefix *, const char *, const char *,
202                         int, int, int);
203 static void add_sysrooted_prefix (struct path_prefix *, const char *,
204                                   const char *, int, int, int);
205 static char *skip_whitespace (char *);
206 static void delete_if_ordinary (const char *);
207 static void delete_temp_files (void);
208 static void delete_failure_queue (void);
209 static void clear_failure_queue (void);
210 static int check_live_switch (int, int);
211 static const char *handle_braces (const char *);
212 static inline bool input_suffix_matches (const char *, const char *);
213 static inline bool switch_matches (const char *, const char *, int);
214 static inline void mark_matching_switches (const char *, const char *, int);
215 static inline void process_marked_switches (void);
216 static const char *process_brace_body (const char *, const char *, const char *, int, int);
217 static const struct spec_function *lookup_spec_function (const char *);
218 static const char *eval_spec_function (const char *, const char *);
219 static const char *handle_spec_function (const char *);
220 static char *save_string (const char *, int);
221 static void set_collect_gcc_options (void);
222 static int do_spec_1 (const char *, int, const char *);
223 static int do_spec_2 (const char *);
224 static void do_option_spec (const char *, const char *);
225 static void do_self_spec (const char *);
226 static const char *find_file (const char *);
227 static int is_directory (const char *, bool);
228 static const char *validate_switches (const char *);
229 static void validate_all_switches (void);
230 static inline void validate_switches_from_spec (const char *);
231 static void give_switch (int, int);
232 static int used_arg (const char *, int);
233 static int default_arg (const char *, int);
234 static void set_multilib_dir (void);
235 static void print_multilib_info (void);
236 static void perror_with_name (const char *);
237 static void display_help (void);
238 static void add_preprocessor_option (const char *, int);
239 static void add_assembler_option (const char *, int);
240 static void add_linker_option (const char *, int);
241 static void process_command (unsigned int, struct cl_decoded_option *);
242 static int execute (void);
243 static void alloc_args (void);
244 static void clear_args (void);
245 static void fatal_signal (int);
246 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
247 static void init_gcc_specs (struct obstack *, const char *, const char *,
248                             const char *);
249 #endif
250 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
251 static const char *convert_filename (const char *, int, int);
252 #endif
253
254 static const char *getenv_spec_function (int, const char **);
255 static const char *if_exists_spec_function (int, const char **);
256 static const char *if_exists_else_spec_function (int, const char **);
257 static const char *replace_outfile_spec_function (int, const char **);
258 static const char *remove_outfile_spec_function (int, const char **);
259 static const char *version_compare_spec_function (int, const char **);
260 static const char *include_spec_function (int, const char **);
261 static const char *find_file_spec_function (int, const char **);
262 static const char *find_plugindir_spec_function (int, const char **);
263 static const char *print_asm_header_spec_function (int, const char **);
264 static const char *compare_debug_dump_opt_spec_function (int, const char **);
265 static const char *compare_debug_self_opt_spec_function (int, const char **);
266 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
267 static const char *pass_through_libs_spec_func (int, const char **);
268 \f
269 /* The Specs Language
270
271 Specs are strings containing lines, each of which (if not blank)
272 is made up of a program name, and arguments separated by spaces.
273 The program name must be exact and start from root, since no path
274 is searched and it is unreliable to depend on the current working directory.
275 Redirection of input or output is not supported; the subprograms must
276 accept filenames saying what files to read and write.
277
278 In addition, the specs can contain %-sequences to substitute variable text
279 or for conditional text.  Here is a table of all defined %-sequences.
280 Note that spaces are not generated automatically around the results of
281 expanding these sequences; therefore, you can concatenate them together
282 or with constant text in a single argument.
283
284  %%     substitute one % into the program name or argument.
285  %i     substitute the name of the input file being processed.
286  %b     substitute the basename of the input file being processed.
287         This is the substring up to (and not including) the last period
288         and not including the directory unless -save-temps was specified
289         to put temporaries in a different location.
290  %B     same as %b, but include the file suffix (text after the last period).
291  %gSUFFIX
292         substitute a file name that has suffix SUFFIX and is chosen
293         once per compilation, and mark the argument a la %d.  To reduce
294         exposure to denial-of-service attacks, the file name is now
295         chosen in a way that is hard to predict even when previously
296         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
297         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
298         the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
299         had been pre-processed.  Previously, %g was simply substituted
300         with a file name chosen once per compilation, without regard
301         to any appended suffix (which was therefore treated just like
302         ordinary text), making such attacks more likely to succeed.
303  %|SUFFIX
304         like %g, but if -pipe is in effect, expands simply to "-".
305  %mSUFFIX
306         like %g, but if -pipe is in effect, expands to nothing.  (We have both
307         %| and %m to accommodate differences between system assemblers; see
308         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
309  %uSUFFIX
310         like %g, but generates a new temporary file name even if %uSUFFIX
311         was already seen.
312  %USUFFIX
313         substitutes the last file name generated with %uSUFFIX, generating a
314         new one if there is no such last file name.  In the absence of any
315         %uSUFFIX, this is just like %gSUFFIX, except they don't share
316         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
317         would involve the generation of two distinct file names, one
318         for each `%g.s' and another for each `%U.s'.  Previously, %U was
319         simply substituted with a file name chosen for the previous %u,
320         without regard to any appended suffix.
321  %jSUFFIX
322         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
323         writable, and if save-temps is off; otherwise, substitute the name
324         of a temporary file, just like %u.  This temporary file is not
325         meant for communication between processes, but rather as a junk
326         disposal mechanism.
327  %.SUFFIX
328         substitutes .SUFFIX for the suffixes of a matched switch's args when
329         it is subsequently output with %*. SUFFIX is terminated by the next
330         space or %.
331  %d     marks the argument containing or following the %d as a
332         temporary file name, so that that file will be deleted if GCC exits
333         successfully.  Unlike %g, this contributes no text to the argument.
334  %w     marks the argument containing or following the %w as the
335         "output file" of this compilation.  This puts the argument
336         into the sequence of arguments that %o will substitute later.
337  %V     indicates that this compilation produces no "output file".
338  %W{...}
339         like %{...} but mark last argument supplied within
340         as a file to be deleted on failure.
341  %o     substitutes the names of all the output files, with spaces
342         automatically placed around them.  You should write spaces
343         around the %o as well or the results are undefined.
344         %o is for use in the specs for running the linker.
345         Input files whose names have no recognized suffix are not compiled
346         at all, but they are included among the output files, so they will
347         be linked.
348  %O     substitutes the suffix for object files.  Note that this is
349         handled specially when it immediately follows %g, %u, or %U
350         (with or without a suffix argument) because of the need for
351         those to form complete file names.  The handling is such that
352         %O is treated exactly as if it had already been substituted,
353         except that %g, %u, and %U do not currently support additional
354         SUFFIX characters following %O as they would following, for
355         example, `.o'.
356  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
357         (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
358         and -B options) and -imultilib as necessary.
359  %s     current argument is the name of a library or startup file of some sort.
360         Search for that file in a standard list of directories
361         and substitute the full name found.
362  %eSTR  Print STR as an error message.  STR is terminated by a newline.
363         Use this when inconsistent options are detected.
364  %nSTR  Print STR as a notice.  STR is terminated by a newline.
365  %x{OPTION}     Accumulate an option for %X.
366  %X     Output the accumulated linker options specified by compilations.
367  %Y     Output the accumulated assembler options specified by compilations.
368  %Z     Output the accumulated preprocessor options specified by compilations.
369  %a     process ASM_SPEC as a spec.
370         This allows config.h to specify part of the spec for running as.
371  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
372         used here.  This can be used to run a post-processor after the
373         assembler has done its job.
374  %D     Dump out a -L option for each directory in startfile_prefixes.
375         If multilib_dir is set, extra entries are generated with it affixed.
376  %l     process LINK_SPEC as a spec.
377  %L     process LIB_SPEC as a spec.
378  %G     process LIBGCC_SPEC as a spec.
379  %R     Output the concatenation of target_system_root and
380         target_sysroot_suffix.
381  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
382  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
383  %C     process CPP_SPEC as a spec.
384  %1     process CC1_SPEC as a spec.
385  %2     process CC1PLUS_SPEC as a spec.
386  %*     substitute the variable part of a matched option.  (See below.)
387         Note that each comma in the substituted string is replaced by
388         a single space.
389  %<S    remove all occurrences of -S from the command line.
390         Note - this command is position dependent.  % commands in the
391         spec string before this one will see -S, % commands in the
392         spec string after this one will not.
393  %<S*   remove all occurrences of all switches beginning with -S from the
394         command line.
395  %:function(args)
396         Call the named function FUNCTION, passing it ARGS.  ARGS is
397         first processed as a nested spec string, then split into an
398         argument vector in the usual fashion.  The function returns
399         a string which is processed as if it had appeared literally
400         as part of the current spec.
401  %{S}   substitutes the -S switch, if that switch was given to GCC.
402         If that switch was not specified, this substitutes nothing.
403         Here S is a metasyntactic variable.
404  %{S*}  substitutes all the switches specified to GCC whose names start
405         with -S.  This is used for -o, -I, etc; switches that take
406         arguments.  GCC considers `-o foo' as being one switch whose
407         name starts with `o'.  %{o*} would substitute this text,
408         including the space; thus, two arguments would be generated.
409  %{S*&T*} likewise, but preserve order of S and T options (the order
410         of S and T in the spec is not significant).  Can be any number
411         of ampersand-separated variables; for each the wild card is
412         optional.  Useful for CPP as %{D*&U*&A*}.
413
414  %{S:X}   substitutes X, if the -S switch was given to GCC.
415  %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
416  %{S*:X}  substitutes X if one or more switches whose names start
417           with -S was given to GCC.  Normally X is substituted only
418           once, no matter how many such switches appeared.  However,
419           if %* appears somewhere in X, then X will be substituted
420           once for each matching switch, with the %* replaced by the
421           part of that switch that matched the '*'.
422  %{.S:X}  substitutes X, if processing a file with suffix S.
423  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
424  %{,S:X}  substitutes X, if processing a file which will use spec S.
425  %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
426
427  %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
428           combined with '!', '.', ',', and '*' as above binding stronger
429           than the OR.
430           If %* appears in X, all of the alternatives must be starred, and
431           only the first matching alternative is substituted.
432  %{S:X;   if S was given to GCC, substitutes X;
433    T:Y;   else if T was given to GCC, substitutes Y;
434     :D}   else substitutes D.  There can be as many clauses as you need.
435           This may be combined with '.', '!', ',', '|', and '*' as above.
436
437  %(Spec) processes a specification defined in a specs file as *Spec:
438  %[Spec] as above, but put __ around -D arguments
439
440 The conditional text X in a %{S:X} or similar construct may contain
441 other nested % constructs or spaces, or even newlines.  They are
442 processed as usual, as described above.  Trailing white space in X is
443 ignored.  White space may also appear anywhere on the left side of the
444 colon in these constructs, except between . or * and the corresponding
445 word.
446
447 The -O, -f, -m, and -W switches are handled specifically in these
448 constructs.  If another value of -O or the negated form of a -f, -m, or
449 -W switch is found later in the command line, the earlier switch
450 value is ignored, except with {S*} where S is just one letter; this
451 passes all matching options.
452
453 The character | at the beginning of the predicate text is used to indicate
454 that a command should be piped to the following command, but only if -pipe
455 is specified.
456
457 Note that it is built into GCC which switches take arguments and which
458 do not.  You might think it would be useful to generalize this to
459 allow each compiler's spec to say which switches take arguments.  But
460 this cannot be done in a consistent fashion.  GCC cannot even decide
461 which input files have been specified without knowing which switches
462 take arguments, and it must know which input files to compile in order
463 to tell which compilers to run.
464
465 GCC also knows implicitly that arguments starting in `-l' are to be
466 treated as compiler output files, and passed to the linker in their
467 proper position among the other output files.  */
468 \f
469 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
470
471 /* config.h can define ASM_SPEC to provide extra args to the assembler
472    or extra switch-translations.  */
473 #ifndef ASM_SPEC
474 #define ASM_SPEC ""
475 #endif
476
477 /* config.h can define ASM_FINAL_SPEC to run a post processor after
478    the assembler has run.  */
479 #ifndef ASM_FINAL_SPEC
480 #define ASM_FINAL_SPEC ""
481 #endif
482
483 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
484    or extra switch-translations.  */
485 #ifndef CPP_SPEC
486 #define CPP_SPEC ""
487 #endif
488
489 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
490    or extra switch-translations.  */
491 #ifndef CC1_SPEC
492 #define CC1_SPEC ""
493 #endif
494
495 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
496    or extra switch-translations.  */
497 #ifndef CC1PLUS_SPEC
498 #define CC1PLUS_SPEC ""
499 #endif
500
501 /* config.h can define LINK_SPEC to provide extra args to the linker
502    or extra switch-translations.  */
503 #ifndef LINK_SPEC
504 #define LINK_SPEC ""
505 #endif
506
507 /* config.h can define LIB_SPEC to override the default libraries.  */
508 #ifndef LIB_SPEC
509 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
510 #endif
511
512 /* mudflap specs */
513 #ifndef MFWRAP_SPEC
514 /* XXX: valid only for GNU ld */
515 /* XXX: should exactly match hooks provided by libmudflap.a */
516 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
517  --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
518  --wrap=mmap --wrap=munmap --wrap=alloca\
519 } %{fmudflapth: --wrap=pthread_create\
520 }} %{fmudflap|fmudflapth: --wrap=main}"
521 #endif
522 #ifndef MFLIB_SPEC
523 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
524 #endif
525
526 /* When using -fsplit-stack we need to wrap pthread_create, in order
527    to initialize the stack guard.  We always use wrapping, rather than
528    shared library ordering, and we keep the wrapper function in
529    libgcc.  This is not yet a real spec, though it could become one;
530    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
531    only works with GNU ld and gold.  FIXME: This is incompatible with
532    -fmudflap when linking statically, which wants to do its own
533    wrapping.  */
534 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
535
536 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
537    included.  */
538 #ifndef LIBGCC_SPEC
539 #if defined(REAL_LIBGCC_SPEC)
540 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
541 #elif defined(LINK_LIBGCC_SPECIAL_1)
542 /* Have gcc do the search for libgcc.a.  */
543 #define LIBGCC_SPEC "libgcc.a%s"
544 #else
545 #define LIBGCC_SPEC "-lgcc"
546 #endif
547 #endif
548
549 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
550 #ifndef STARTFILE_SPEC
551 #define STARTFILE_SPEC  \
552   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
553 #endif
554
555 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
556 #ifndef ENDFILE_SPEC
557 #define ENDFILE_SPEC ""
558 #endif
559
560 #ifndef LINKER_NAME
561 #define LINKER_NAME "collect2"
562 #endif
563
564 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
565 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
566 #else
567 #define ASM_MAP ""
568 #endif
569
570 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
571    to the assembler.  */
572 #ifndef ASM_DEBUG_SPEC
573 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
574      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
575 #  define ASM_DEBUG_SPEC                                                \
576       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
577        ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \
578        : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
579 # else
580 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
581 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
582 #  endif
583 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
584 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
585 #  endif
586 # endif
587 #endif
588 #ifndef ASM_DEBUG_SPEC
589 # define ASM_DEBUG_SPEC ""
590 #endif
591
592 /* Here is the spec for running the linker, after compiling all files.  */
593
594 /* This is overridable by the target in case they need to specify the
595    -lgcc and -lc order specially, yet not require them to override all
596    of LINK_COMMAND_SPEC.  */
597 #ifndef LINK_GCC_C_SEQUENCE_SPEC
598 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
599 #endif
600
601 #ifndef LINK_SSP_SPEC
602 #ifdef TARGET_LIBC_PROVIDES_SSP
603 #define LINK_SSP_SPEC "%{fstack-protector:}"
604 #else
605 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
606 #endif
607 #endif
608
609 #ifndef LINK_PIE_SPEC
610 #ifdef HAVE_LD_PIE
611 #define LINK_PIE_SPEC "%{pie:-pie} "
612 #else
613 #define LINK_PIE_SPEC "%{pie:} "
614 #endif
615 #endif
616
617 #ifndef LINK_BUILDID_SPEC
618 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
619 #  define LINK_BUILDID_SPEC "%{!r:--build-id} "
620 # endif
621 #endif
622
623
624 /* -u* was put back because both BSD and SysV seem to support it.  */
625 /* %{static:} simply prevents an error message if the target machine
626    doesn't handle -static.  */
627 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
628    scripts which exist in user specified directories, or in standard
629    directories.  */
630 /* We pass any -flto flags on to the linker, which is expected
631    to understand them.  In practice, this means it had better be collect2.  */
632 #ifndef LINK_COMMAND_SPEC
633 #define LINK_COMMAND_SPEC "\
634 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
635     %(linker) \
636     %{fuse-linker-plugin: \
637     -plugin %(linker_plugin_file) \
638     -plugin-opt=%(lto_wrapper) \
639     -plugin-opt=-fresolution=%u.res \
640     %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
641     } \
642     %{flto*:%<fcompare-debug*} \
643     %{flto*} %l " LINK_PIE_SPEC \
644    "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
645     %{s} %{t} %{u*} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
646     %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
647     %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
648     %(mflib) " STACK_SPLIT_SPEC "\
649     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
650     %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
651     %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
652 #endif
653
654 #ifndef LINK_LIBGCC_SPEC
655 /* Generate -L options for startfile prefix list.  */
656 # define LINK_LIBGCC_SPEC "%D"
657 #endif
658
659 #ifndef STARTFILE_PREFIX_SPEC
660 # define STARTFILE_PREFIX_SPEC ""
661 #endif
662
663 #ifndef SYSROOT_SPEC
664 # define SYSROOT_SPEC "--sysroot=%R"
665 #endif
666
667 #ifndef SYSROOT_SUFFIX_SPEC
668 # define SYSROOT_SUFFIX_SPEC ""
669 #endif
670
671 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
672 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
673 #endif
674
675 static const char *asm_debug;
676 static const char *cpp_spec = CPP_SPEC;
677 static const char *cc1_spec = CC1_SPEC;
678 static const char *cc1plus_spec = CC1PLUS_SPEC;
679 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
680 static const char *link_ssp_spec = LINK_SSP_SPEC;
681 static const char *asm_spec = ASM_SPEC;
682 static const char *asm_final_spec = ASM_FINAL_SPEC;
683 static const char *link_spec = LINK_SPEC;
684 static const char *lib_spec = LIB_SPEC;
685 static const char *mfwrap_spec = MFWRAP_SPEC;
686 static const char *mflib_spec = MFLIB_SPEC;
687 static const char *link_gomp_spec = "";
688 static const char *libgcc_spec = LIBGCC_SPEC;
689 static const char *endfile_spec = ENDFILE_SPEC;
690 static const char *startfile_spec = STARTFILE_SPEC;
691 static const char *linker_name_spec = LINKER_NAME;
692 static const char *linker_plugin_file_spec = "";
693 static const char *lto_wrapper_spec = "";
694 static const char *lto_gcc_spec = "";
695 static const char *link_command_spec = LINK_COMMAND_SPEC;
696 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
697 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
698 static const char *sysroot_spec = SYSROOT_SPEC;
699 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
700 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
701
702 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
703    There should be no need to override these in target dependent files,
704    but we need to copy them to the specs file so that newer versions
705    of the GCC driver can correctly drive older tool chains with the
706    appropriate -B options.  */
707
708 /* When cpplib handles traditional preprocessing, get rid of this, and
709    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
710    that we default the front end language better.  */
711 static const char *trad_capable_cpp =
712 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
713
714 /* We don't wrap .d files in %W{} since a missing .d file, and
715    therefore no dependency entry, confuses make into thinking a .o
716    file that happens to exist is up-to-date.  */
717 static const char *cpp_unique_options =
718 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
719  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
720  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
721  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
722  %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
723  %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
724  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
725  %{H} %C %{D*&U*&A*} %{i*} %Z %i\
726  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
727  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
728  %{E|M|MM:%W{o*}}";
729
730 /* This contains cpp options which are common with cc1_options and are passed
731    only when preprocessing only to avoid duplication.  We pass the cc1 spec
732    options to the preprocessor so that it the cc1 spec may manipulate
733    options used to set target flags.  Those special target flags settings may
734    in turn cause preprocessor symbols to be defined specially.  */
735 static const char *cpp_options =
736 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
737  %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
738  %{undef} %{save-temps*:-fpch-preprocess}";
739
740 /* This contains cpp options which are not passed when the preprocessor
741    output will be used by another program.  */
742 static const char *cpp_debug_options = "%{d*}";
743
744 /* NB: This is shared amongst all front-ends, except for Ada.  */
745 static const char *cc1_options =
746 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
747  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
748  %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
749  %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
750  %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
751  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
752  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
753  %{Qn:-fno-ident} %{-help:--help}\
754  %{-target-help:--target-help}\
755  %{-version:--version}\
756  %{-help=*:--help=%*}\
757  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
758  %{fsyntax-only:-o %j} %{-param*}\
759  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
760  %{coverage:-fprofile-arcs -ftest-coverage}";
761
762 static const char *asm_options =
763 "%{--target-help:%:print-asm-header()} "
764 #if HAVE_GNU_AS
765 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
766    to the assembler equivalents.  */
767 "%{v} %{w:-W} %{I*} "
768 #endif
769 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
770
771 static const char *invoke_as =
772 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
773 "%{!fwpa:\
774    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
775    %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
776   }";
777 #else
778 "%{!fwpa:\
779    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
780    %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
781   }";
782 #endif
783
784 /* Some compilers have limits on line lengths, and the multilib_select
785    and/or multilib_matches strings can be very long, so we build them at
786    run time.  */
787 static struct obstack multilib_obstack;
788 static const char *multilib_select;
789 static const char *multilib_matches;
790 static const char *multilib_defaults;
791 static const char *multilib_exclusions;
792
793 /* Check whether a particular argument is a default argument.  */
794
795 #ifndef MULTILIB_DEFAULTS
796 #define MULTILIB_DEFAULTS { "" }
797 #endif
798
799 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
800
801 #ifndef DRIVER_SELF_SPECS
802 #define DRIVER_SELF_SPECS ""
803 #endif
804
805 /* Adding -fopenmp should imply pthreads.  This is particularly important
806    for targets that use different start files and suchlike.  */
807 #ifndef GOMP_SELF_SPECS
808 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
809 #endif
810
811 static const char *const driver_self_specs[] = {
812   "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
813   DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
814 };
815
816 #ifndef OPTION_DEFAULT_SPECS
817 #define OPTION_DEFAULT_SPECS { "", "" }
818 #endif
819
820 struct default_spec
821 {
822   const char *name;
823   const char *spec;
824 };
825
826 static const struct default_spec
827   option_default_specs[] = { OPTION_DEFAULT_SPECS };
828
829 struct user_specs
830 {
831   struct user_specs *next;
832   const char *filename;
833 };
834
835 static struct user_specs *user_specs_head, *user_specs_tail;
836
837 \f
838 /* Record the mapping from file suffixes for compilation specs.  */
839
840 struct compiler
841 {
842   const char *suffix;           /* Use this compiler for input files
843                                    whose names end in this suffix.  */
844
845   const char *spec;             /* To use this compiler, run this spec.  */
846
847   const char *cpp_spec;         /* If non-NULL, substitute this spec
848                                    for `%C', rather than the usual
849                                    cpp_spec.  */
850   const int combinable;          /* If nonzero, compiler can deal with
851                                     multiple source files at once (IMA).  */
852   const int needs_preprocessing; /* If nonzero, source files need to
853                                     be run through a preprocessor.  */
854 };
855
856 /* Pointer to a vector of `struct compiler' that gives the spec for
857    compiling a file, based on its suffix.
858    A file that does not end in any of these suffixes will be passed
859    unchanged to the loader and nothing else will be done to it.
860
861    An entry containing two 0s is used to terminate the vector.
862
863    If multiple entries match a file, the last matching one is used.  */
864
865 static struct compiler *compilers;
866
867 /* Number of entries in `compilers', not counting the null terminator.  */
868
869 static int n_compilers;
870
871 /* The default list of file name suffixes and their compilation specs.  */
872
873 static const struct compiler default_compilers[] =
874 {
875   /* Add lists of suffixes of known languages here.  If those languages
876      were not present when we built the driver, we will hit these copies
877      and be given a more meaningful error than "file not used since
878      linking is not done".  */
879   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
880   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
881   {".mii", "#Objective-C++", 0, 0, 0},
882   {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
883   {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
884   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
885   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
886   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
887   {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
888   {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
889   {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
890   {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
891   {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
892   {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
893   {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
894   {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
895   {".r", "#Ratfor", 0, 0, 0},
896   {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
897   {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
898   {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
899   /* Next come the entries for C.  */
900   {".c", "@c", 0, 0, 1},
901   {"@c",
902    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
903       external preprocessor if -save-temps is given.  */
904      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
905       %{!E:%{!M:%{!MM:\
906           %{traditional|ftraditional:\
907 %eGNU C no longer supports -traditional without -E}\
908       %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
909           %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
910             cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
911           %(cc1_options)}\
912       %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
913           cc1 %(cpp_unique_options) %(cc1_options)}}}\
914       %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
915   {"-",
916    "%{!E:%e-E or -x required when input is from standard input}\
917     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
918   {".h", "@c-header", 0, 0, 0},
919   {"@c-header",
920    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
921       external preprocessor if -save-temps is given.  */
922      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
923       %{!E:%{!M:%{!MM:\
924           %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
925                 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
926                     cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
927                         %(cc1_options)\
928                         %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
929                         %W{o*:--output-pch=%*}}%V}\
930           %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
931                 cc1 %(cpp_unique_options) %(cc1_options)\
932                     %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
933                     %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
934   {".i", "@cpp-output", 0, 0, 0},
935   {"@cpp-output",
936    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
937   {".s", "@assembler", 0, 1, 0},
938   {"@assembler",
939    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
940   {".sx", "@assembler-with-cpp", 0, 1, 0},
941   {".S", "@assembler-with-cpp", 0, 1, 0},
942   {"@assembler-with-cpp",
943 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
944    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
945       %{E|M|MM:%(cpp_debug_options)}\
946       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
947        as %(asm_debug) %(asm_options) %|.s %A }}}}"
948 #else
949    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
950       %{E|M|MM:%(cpp_debug_options)}\
951       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
952        as %(asm_debug) %(asm_options) %m.s %A }}}}"
953 #endif
954    , 0, 1, 0},
955
956 #include "specs.h"
957   /* Mark end of table.  */
958   {0, 0, 0, 0, 0}
959 };
960
961 /* Number of elements in default_compilers, not counting the terminator.  */
962
963 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
964
965 typedef char *char_p; /* For DEF_VEC_P.  */
966 DEF_VEC_P(char_p);
967 DEF_VEC_ALLOC_P(char_p,heap);
968
969 /* A vector of options to give to the linker.
970    These options are accumulated by %x,
971    and substituted into the linker command with %X.  */
972 static VEC(char_p,heap) *linker_options;
973
974 /* A vector of options to give to the assembler.
975    These options are accumulated by -Wa,
976    and substituted into the assembler command with %Y.  */
977 static VEC(char_p,heap) *assembler_options;
978
979 /* A vector of options to give to the preprocessor.
980    These options are accumulated by -Wp,
981    and substituted into the preprocessor command with %Z.  */
982 static VEC(char_p,heap) *preprocessor_options;
983 \f
984 static char *
985 skip_whitespace (char *p)
986 {
987   while (1)
988     {
989       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
990          be considered whitespace.  */
991       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
992         return p + 1;
993       else if (*p == '\n' || *p == ' ' || *p == '\t')
994         p++;
995       else if (*p == '#')
996         {
997           while (*p != '\n')
998             p++;
999           p++;
1000         }
1001       else
1002         break;
1003     }
1004
1005   return p;
1006 }
1007 /* Structures to keep track of prefixes to try when looking for files.  */
1008
1009 struct prefix_list
1010 {
1011   const char *prefix;         /* String to prepend to the path.  */
1012   struct prefix_list *next;   /* Next in linked list.  */
1013   int require_machine_suffix; /* Don't use without machine_suffix.  */
1014   /* 2 means try both machine_suffix and just_machine_suffix.  */
1015   int priority;               /* Sort key - priority within list.  */
1016   int os_multilib;            /* 1 if OS multilib scheme should be used,
1017                                  0 for GCC multilib scheme.  */
1018 };
1019
1020 struct path_prefix
1021 {
1022   struct prefix_list *plist;  /* List of prefixes to try */
1023   int max_len;                /* Max length of a prefix in PLIST */
1024   const char *name;           /* Name of this list (used in config stuff) */
1025 };
1026
1027 /* List of prefixes to try when looking for executables.  */
1028
1029 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1030
1031 /* List of prefixes to try when looking for startup (crt0) files.  */
1032
1033 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1034
1035 /* List of prefixes to try when looking for include files.  */
1036
1037 static struct path_prefix include_prefixes = { 0, 0, "include" };
1038
1039 /* Suffix to attach to directories searched for commands.
1040    This looks like `MACHINE/VERSION/'.  */
1041
1042 static const char *machine_suffix = 0;
1043
1044 /* Suffix to attach to directories searched for commands.
1045    This is just `MACHINE/'.  */
1046
1047 static const char *just_machine_suffix = 0;
1048
1049 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1050
1051 static const char *gcc_exec_prefix;
1052
1053 /* Adjusted value of standard_libexec_prefix.  */
1054
1055 static const char *gcc_libexec_prefix;
1056
1057 /* Default prefixes to attach to command names.  */
1058
1059 #ifndef STANDARD_STARTFILE_PREFIX_1
1060 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1061 #endif
1062 #ifndef STANDARD_STARTFILE_PREFIX_2
1063 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1064 #endif
1065
1066 #ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
1067 #undef MD_EXEC_PREFIX
1068 #undef MD_STARTFILE_PREFIX
1069 #undef MD_STARTFILE_PREFIX_1
1070 #endif
1071
1072 /* If no prefixes defined, use the null string, which will disable them.  */
1073 #ifndef MD_EXEC_PREFIX
1074 #define MD_EXEC_PREFIX ""
1075 #endif
1076 #ifndef MD_STARTFILE_PREFIX
1077 #define MD_STARTFILE_PREFIX ""
1078 #endif
1079 #ifndef MD_STARTFILE_PREFIX_1
1080 #define MD_STARTFILE_PREFIX_1 ""
1081 #endif
1082
1083 /* These directories are locations set at configure-time based on the
1084    --prefix option provided to configure.  Their initializers are
1085    defined in Makefile.in.  These paths are not *directly* used when
1086    gcc_exec_prefix is set because, in that case, we know where the
1087    compiler has been installed, and use paths relative to that
1088    location instead.  */
1089 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1090 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1091 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1092 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1093
1094 /* For native compilers, these are well-known paths containing
1095    components that may be provided by the system.  For cross
1096    compilers, these paths are not used.  */
1097 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1098 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1099 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1100 static const char *const standard_startfile_prefix_1
1101   = STANDARD_STARTFILE_PREFIX_1;
1102 static const char *const standard_startfile_prefix_2
1103   = STANDARD_STARTFILE_PREFIX_2;
1104
1105 /* A relative path to be used in finding the location of tools
1106    relative to the driver.  */
1107 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1108
1109 /* Subdirectory to use for locating libraries.  Set by
1110    set_multilib_dir based on the compilation options.  */
1111
1112 static const char *multilib_dir;
1113
1114 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1115    set_multilib_dir based on the compilation options.  */
1116
1117 static const char *multilib_os_dir;
1118 \f
1119 /* Structure to keep track of the specs that have been defined so far.
1120    These are accessed using %(specname) or %[specname] in a compiler
1121    or link spec.  */
1122
1123 struct spec_list
1124 {
1125                                 /* The following 2 fields must be first */
1126                                 /* to allow EXTRA_SPECS to be initialized */
1127   const char *name;             /* name of the spec.  */
1128   const char *ptr;              /* available ptr if no static pointer */
1129
1130                                 /* The following fields are not initialized */
1131                                 /* by EXTRA_SPECS */
1132   const char **ptr_spec;        /* pointer to the spec itself.  */
1133   struct spec_list *next;       /* Next spec in linked list.  */
1134   int name_len;                 /* length of the name */
1135   int alloc_p;                  /* whether string was allocated */
1136 };
1137
1138 #define INIT_STATIC_SPEC(NAME,PTR) \
1139 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1140
1141 /* List of statically defined specs.  */
1142 static struct spec_list static_specs[] =
1143 {
1144   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1145   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1146   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1147   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1148   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1149   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1150   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1151   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1152   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1153   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1154   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1155   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1156   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1157   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1158   INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1159   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1160   INIT_STATIC_SPEC ("link",                     &link_spec),
1161   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1162   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1163   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1164   INIT_STATIC_SPEC ("link_gomp",                &link_gomp_spec),
1165   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1166   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1167   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1168   INIT_STATIC_SPEC ("version",                  &compiler_version),
1169   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1170   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1171   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1172   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1173   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1174   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1175   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1176   INIT_STATIC_SPEC ("linker_plugin_file",       &linker_plugin_file_spec),
1177   INIT_STATIC_SPEC ("lto_wrapper",              &lto_wrapper_spec),
1178   INIT_STATIC_SPEC ("lto_gcc",                  &lto_gcc_spec),
1179   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1180   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1181   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1182   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1183   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1184   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1185   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1186   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1187 };
1188
1189 #ifdef EXTRA_SPECS              /* additional specs needed */
1190 /* Structure to keep track of just the first two args of a spec_list.
1191    That is all that the EXTRA_SPECS macro gives us.  */
1192 struct spec_list_1
1193 {
1194   const char *const name;
1195   const char *const ptr;
1196 };
1197
1198 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1199 static struct spec_list *extra_specs = (struct spec_list *) 0;
1200 #endif
1201
1202 /* List of dynamically allocates specs that have been defined so far.  */
1203
1204 static struct spec_list *specs = (struct spec_list *) 0;
1205 \f
1206 /* List of static spec functions.  */
1207
1208 static const struct spec_function static_spec_functions[] =
1209 {
1210   { "getenv",                   getenv_spec_function },
1211   { "if-exists",                if_exists_spec_function },
1212   { "if-exists-else",           if_exists_else_spec_function },
1213   { "replace-outfile",          replace_outfile_spec_function },
1214   { "remove-outfile",           remove_outfile_spec_function },
1215   { "version-compare",          version_compare_spec_function },
1216   { "include",                  include_spec_function },
1217   { "find-file",                find_file_spec_function },
1218   { "find-plugindir",           find_plugindir_spec_function },
1219   { "print-asm-header",         print_asm_header_spec_function },
1220   { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1221   { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1222   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1223   { "pass-through-libs",        pass_through_libs_spec_func },
1224 #ifdef EXTRA_SPEC_FUNCTIONS
1225   EXTRA_SPEC_FUNCTIONS
1226 #endif
1227   { 0, 0 }
1228 };
1229
1230 static int processing_spec_function;
1231 \f
1232 /* Add appropriate libgcc specs to OBSTACK, taking into account
1233    various permutations of -shared-libgcc, -shared, and such.  */
1234
1235 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1236
1237 #ifndef USE_LD_AS_NEEDED
1238 #define USE_LD_AS_NEEDED 0
1239 #endif
1240
1241 static void
1242 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1243                 const char *static_name, const char *eh_name)
1244 {
1245   char *buf;
1246
1247   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1248                 "%{!static:%{!static-libgcc:"
1249 #if USE_LD_AS_NEEDED
1250                 "%{!shared-libgcc:",
1251                 static_name, " --as-needed ", shared_name, " --no-as-needed"
1252                 "}"
1253                 "%{shared-libgcc:",
1254                 shared_name, "%{!shared: ", static_name, "}"
1255                 "}"
1256 #else
1257                 "%{!shared:"
1258                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1259                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1260                 "}"
1261 #ifdef LINK_EH_SPEC
1262                 "%{shared:"
1263                 "%{shared-libgcc:", shared_name, "}"
1264                 "%{!shared-libgcc:", static_name, "}"
1265                 "}"
1266 #else
1267                 "%{shared:", shared_name, "}"
1268 #endif
1269 #endif
1270                 "}}", NULL);
1271
1272   obstack_grow (obstack, buf, strlen (buf));
1273   free (buf);
1274 }
1275 #endif /* ENABLE_SHARED_LIBGCC */
1276
1277 /* Initialize the specs lookup routines.  */
1278
1279 static void
1280 init_spec (void)
1281 {
1282   struct spec_list *next = (struct spec_list *) 0;
1283   struct spec_list *sl   = (struct spec_list *) 0;
1284   int i;
1285
1286   if (specs)
1287     return;                     /* Already initialized.  */
1288
1289   if (verbose_flag)
1290     fnotice (stderr, "Using built-in specs.\n");
1291
1292 #ifdef EXTRA_SPECS
1293   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1294
1295   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1296     {
1297       sl = &extra_specs[i];
1298       sl->name = extra_specs_1[i].name;
1299       sl->ptr = extra_specs_1[i].ptr;
1300       sl->next = next;
1301       sl->name_len = strlen (sl->name);
1302       sl->ptr_spec = &sl->ptr;
1303       next = sl;
1304     }
1305 #endif
1306
1307   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1308     {
1309       sl = &static_specs[i];
1310       sl->next = next;
1311       next = sl;
1312     }
1313
1314 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1315   /* ??? If neither -shared-libgcc nor --static-libgcc was
1316      seen, then we should be making an educated guess.  Some proposed
1317      heuristics for ELF include:
1318
1319         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1320             program will be doing dynamic loading, which will likely
1321             need the shared libgcc.
1322
1323         (2) If "-ldl", then it's also a fair bet that we're doing
1324             dynamic loading.
1325
1326         (3) For each ET_DYN we're linking against (either through -lfoo
1327             or /some/path/foo.so), check to see whether it or one of
1328             its dependencies depends on a shared libgcc.
1329
1330         (4) If "-shared"
1331
1332             If the runtime is fixed to look for program headers instead
1333             of calling __register_frame_info at all, for each object,
1334             use the shared libgcc if any EH symbol referenced.
1335
1336             If crtstuff is fixed to not invoke __register_frame_info
1337             automatically, for each object, use the shared libgcc if
1338             any non-empty unwind section found.
1339
1340      Doing any of this probably requires invoking an external program to
1341      do the actual object file scanning.  */
1342   {
1343     const char *p = libgcc_spec;
1344     int in_sep = 1;
1345
1346     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1347        when given the proper command line arguments.  */
1348     while (*p)
1349       {
1350         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1351           {
1352             init_gcc_specs (&obstack,
1353                             "-lgcc_s"
1354 #ifdef USE_LIBUNWIND_EXCEPTIONS
1355                             " -lunwind"
1356 #endif
1357                             ,
1358                             "-lgcc",
1359                             "-lgcc_eh"
1360 #ifdef USE_LIBUNWIND_EXCEPTIONS
1361 # ifdef HAVE_LD_STATIC_DYNAMIC
1362                             " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1363 # else
1364                             " -lunwind"
1365 # endif
1366 #endif
1367                             );
1368
1369             p += 5;
1370             in_sep = 0;
1371           }
1372         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1373           {
1374             /* Ug.  We don't know shared library extensions.  Hope that
1375                systems that use this form don't do shared libraries.  */
1376             init_gcc_specs (&obstack,
1377                             "-lgcc_s",
1378                             "libgcc.a%s",
1379                             "libgcc_eh.a%s"
1380 #ifdef USE_LIBUNWIND_EXCEPTIONS
1381                             " -lunwind"
1382 #endif
1383                             );
1384             p += 10;
1385             in_sep = 0;
1386           }
1387         else
1388           {
1389             obstack_1grow (&obstack, *p);
1390             in_sep = (*p == ' ');
1391             p += 1;
1392           }
1393       }
1394
1395     obstack_1grow (&obstack, '\0');
1396     libgcc_spec = XOBFINISH (&obstack, const char *);
1397   }
1398 #endif
1399 #ifdef USE_AS_TRADITIONAL_FORMAT
1400   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1401   {
1402     static const char tf[] = "--traditional-format ";
1403     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1404     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1405     asm_spec = XOBFINISH (&obstack, const char *);
1406   }
1407 #endif
1408
1409 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1410 # ifdef LINK_BUILDID_SPEC
1411   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1412   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1413 # endif
1414 # ifdef LINK_EH_SPEC
1415   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1416   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1417 # endif
1418   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1419   link_spec = XOBFINISH (&obstack, const char *);
1420 #endif
1421
1422   specs = sl;
1423 }
1424 \f
1425 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1426    removed; If the spec starts with a + then SPEC is added to the end of the
1427    current spec.  */
1428
1429 static void
1430 set_spec (const char *name, const char *spec)
1431 {
1432   struct spec_list *sl;
1433   const char *old_spec;
1434   int name_len = strlen (name);
1435   int i;
1436
1437   /* If this is the first call, initialize the statically allocated specs.  */
1438   if (!specs)
1439     {
1440       struct spec_list *next = (struct spec_list *) 0;
1441       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1442         {
1443           sl = &static_specs[i];
1444           sl->next = next;
1445           next = sl;
1446         }
1447       specs = sl;
1448     }
1449
1450   /* See if the spec already exists.  */
1451   for (sl = specs; sl; sl = sl->next)
1452     if (name_len == sl->name_len && !strcmp (sl->name, name))
1453       break;
1454
1455   if (!sl)
1456     {
1457       /* Not found - make it.  */
1458       sl = XNEW (struct spec_list);
1459       sl->name = xstrdup (name);
1460       sl->name_len = name_len;
1461       sl->ptr_spec = &sl->ptr;
1462       sl->alloc_p = 0;
1463       *(sl->ptr_spec) = "";
1464       sl->next = specs;
1465       specs = sl;
1466     }
1467
1468   old_spec = *(sl->ptr_spec);
1469   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1470                      ? concat (old_spec, spec + 1, NULL)
1471                      : xstrdup (spec));
1472
1473 #ifdef DEBUG_SPECS
1474   if (verbose_flag)
1475     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1476 #endif
1477
1478   /* Free the old spec.  */
1479   if (old_spec && sl->alloc_p)
1480     free (CONST_CAST(char *, old_spec));
1481
1482   sl->alloc_p = 1;
1483 }
1484 \f
1485 /* Accumulate a command (program name and args), and run it.  */
1486
1487 typedef const char *const_char_p; /* For DEF_VEC_P.  */
1488 DEF_VEC_P(const_char_p);
1489 DEF_VEC_ALLOC_P(const_char_p,heap);
1490
1491 /* Vector of pointers to arguments in the current line of specifications.  */
1492
1493 static VEC(const_char_p,heap) *argbuf;
1494
1495 /* Position in the argbuf vector containing the name of the output file
1496    (the value associated with the "-o" flag).  */
1497
1498 static int have_o_argbuf_index = 0;
1499
1500 /* Were the options -c, -S or -E passed.  */
1501 static int have_c = 0;
1502
1503 /* Was the option -o passed.  */
1504 static int have_o = 0;
1505
1506 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1507    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1508    it here.  */
1509
1510 static struct temp_name {
1511   const char *suffix;   /* suffix associated with the code.  */
1512   int length;           /* strlen (suffix).  */
1513   int unique;           /* Indicates whether %g or %u/%U was used.  */
1514   const char *filename; /* associated filename.  */
1515   int filename_length;  /* strlen (filename).  */
1516   struct temp_name *next;
1517 } *temp_names;
1518
1519 /* Number of commands executed so far.  */
1520
1521 static int execution_count;
1522
1523 /* Number of commands that exited with a signal.  */
1524
1525 static int signal_count;
1526 \f
1527 /* Allocate the argument vector.  */
1528
1529 static void
1530 alloc_args (void)
1531 {
1532   argbuf = VEC_alloc (const_char_p, heap, 10);
1533 }
1534
1535 /* Clear out the vector of arguments (after a command is executed).  */
1536
1537 static void
1538 clear_args (void)
1539 {
1540   VEC_truncate (const_char_p, argbuf, 0);
1541 }
1542
1543 /* Add one argument to the vector at the end.
1544    This is done when a space is seen or at the end of the line.
1545    If DELETE_ALWAYS is nonzero, the arg is a filename
1546     and the file should be deleted eventually.
1547    If DELETE_FAILURE is nonzero, the arg is a filename
1548     and the file should be deleted if this compilation fails.  */
1549
1550 static void
1551 store_arg (const char *arg, int delete_always, int delete_failure)
1552 {
1553   VEC_safe_push (const_char_p, heap, argbuf, arg);
1554
1555   if (strcmp (arg, "-o") == 0)
1556     have_o_argbuf_index = VEC_length (const_char_p, argbuf);
1557   if (delete_always || delete_failure)
1558     {
1559       const char *p;
1560       /* If the temporary file we should delete is specified as
1561          part of a joined argument extract the filename.  */
1562       if (arg[0] == '-'
1563           && (p = strrchr (arg, '=')))
1564         arg = p + 1;
1565       record_temp_file (arg, delete_always, delete_failure);
1566     }
1567 }
1568 \f
1569 /* Load specs from a file name named FILENAME, replacing occurrences of
1570    various different types of line-endings, \r\n, \n\r and just \r, with
1571    a single \n.  */
1572
1573 static char *
1574 load_specs (const char *filename)
1575 {
1576   int desc;
1577   int readlen;
1578   struct stat statbuf;
1579   char *buffer;
1580   char *buffer_p;
1581   char *specs;
1582   char *specs_p;
1583
1584   if (verbose_flag)
1585     fnotice (stderr, "Reading specs from %s\n", filename);
1586
1587   /* Open and stat the file.  */
1588   desc = open (filename, O_RDONLY, 0);
1589   if (desc < 0)
1590     pfatal_with_name (filename);
1591   if (stat (filename, &statbuf) < 0)
1592     pfatal_with_name (filename);
1593
1594   /* Read contents of file into BUFFER.  */
1595   buffer = XNEWVEC (char, statbuf.st_size + 1);
1596   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1597   if (readlen < 0)
1598     pfatal_with_name (filename);
1599   buffer[readlen] = 0;
1600   close (desc);
1601
1602   specs = XNEWVEC (char, readlen + 1);
1603   specs_p = specs;
1604   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1605     {
1606       int skip = 0;
1607       char c = *buffer_p;
1608       if (c == '\r')
1609         {
1610           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1611             skip = 1;
1612           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1613             skip = 1;
1614           else                                                  /* \r */
1615             c = '\n';
1616         }
1617       if (! skip)
1618         *specs_p++ = c;
1619     }
1620   *specs_p = '\0';
1621
1622   free (buffer);
1623   return (specs);
1624 }
1625
1626 /* Read compilation specs from a file named FILENAME,
1627    replacing the default ones.
1628
1629    A suffix which starts with `*' is a definition for
1630    one of the machine-specific sub-specs.  The "suffix" should be
1631    *asm, *cc1, *cpp, *link, *startfile, etc.
1632    The corresponding spec is stored in asm_spec, etc.,
1633    rather than in the `compilers' vector.
1634
1635    Anything invalid in the file is a fatal error.  */
1636
1637 static void
1638 read_specs (const char *filename, int main_p)
1639 {
1640   char *buffer;
1641   char *p;
1642
1643   buffer = load_specs (filename);
1644
1645   /* Scan BUFFER for specs, putting them in the vector.  */
1646   p = buffer;
1647   while (1)
1648     {
1649       char *suffix;
1650       char *spec;
1651       char *in, *out, *p1, *p2, *p3;
1652
1653       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1654       p = skip_whitespace (p);
1655       if (*p == 0)
1656         break;
1657
1658       /* Is this a special command that starts with '%'? */
1659       /* Don't allow this for the main specs file, since it would
1660          encourage people to overwrite it.  */
1661       if (*p == '%' && !main_p)
1662         {
1663           p1 = p;
1664           while (*p && *p != '\n')
1665             p++;
1666
1667           /* Skip '\n'.  */
1668           p++;
1669
1670           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1671               && (p1[sizeof "%include" - 1] == ' '
1672                   || p1[sizeof "%include" - 1] == '\t'))
1673             {
1674               char *new_filename;
1675
1676               p1 += sizeof ("%include");
1677               while (*p1 == ' ' || *p1 == '\t')
1678                 p1++;
1679
1680               if (*p1++ != '<' || p[-2] != '>')
1681                 fatal_error ("specs %%include syntax malformed after "
1682                              "%ld characters",
1683                              (long) (p1 - buffer + 1));
1684
1685               p[-2] = '\0';
1686               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1687               read_specs (new_filename ? new_filename : p1, FALSE);
1688               continue;
1689             }
1690           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1691                    && (p1[sizeof "%include_noerr" - 1] == ' '
1692                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1693             {
1694               char *new_filename;
1695
1696               p1 += sizeof "%include_noerr";
1697               while (*p1 == ' ' || *p1 == '\t')
1698                 p1++;
1699
1700               if (*p1++ != '<' || p[-2] != '>')
1701                 fatal_error ("specs %%include syntax malformed after "
1702                              "%ld characters",
1703                              (long) (p1 - buffer + 1));
1704
1705               p[-2] = '\0';
1706               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1707               if (new_filename)
1708                 read_specs (new_filename, FALSE);
1709               else if (verbose_flag)
1710                 fnotice (stderr, "could not find specs file %s\n", p1);
1711               continue;
1712             }
1713           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1714                    && (p1[sizeof "%rename" - 1] == ' '
1715                        || p1[sizeof "%rename" - 1] == '\t'))
1716             {
1717               int name_len;
1718               struct spec_list *sl;
1719               struct spec_list *newsl;
1720
1721               /* Get original name.  */
1722               p1 += sizeof "%rename";
1723               while (*p1 == ' ' || *p1 == '\t')
1724                 p1++;
1725
1726               if (! ISALPHA ((unsigned char) *p1))
1727                 fatal_error ("specs %%rename syntax malformed after "
1728                              "%ld characters",
1729                              (long) (p1 - buffer));
1730
1731               p2 = p1;
1732               while (*p2 && !ISSPACE ((unsigned char) *p2))
1733                 p2++;
1734
1735               if (*p2 != ' ' && *p2 != '\t')
1736                 fatal_error ("specs %%rename syntax malformed after "
1737                              "%ld characters",
1738                              (long) (p2 - buffer));
1739
1740               name_len = p2 - p1;
1741               *p2++ = '\0';
1742               while (*p2 == ' ' || *p2 == '\t')
1743                 p2++;
1744
1745               if (! ISALPHA ((unsigned char) *p2))
1746                 fatal_error ("specs %%rename syntax malformed after "
1747                              "%ld characters",
1748                              (long) (p2 - buffer));
1749
1750               /* Get new spec name.  */
1751               p3 = p2;
1752               while (*p3 && !ISSPACE ((unsigned char) *p3))
1753                 p3++;
1754
1755               if (p3 != p - 1)
1756                 fatal_error ("specs %%rename syntax malformed after "
1757                              "%ld characters",
1758                              (long) (p3 - buffer));
1759               *p3 = '\0';
1760
1761               for (sl = specs; sl; sl = sl->next)
1762                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1763                   break;
1764
1765               if (!sl)
1766                 fatal_error ("specs %s spec was not found to be renamed", p1);
1767
1768               if (strcmp (p1, p2) == 0)
1769                 continue;
1770
1771               for (newsl = specs; newsl; newsl = newsl->next)
1772                 if (strcmp (newsl->name, p2) == 0)
1773                   fatal_error ("%s: attempt to rename spec %qs to "
1774                                "already defined spec %qs",
1775                     filename, p1, p2);
1776
1777               if (verbose_flag)
1778                 {
1779                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1780 #ifdef DEBUG_SPECS
1781                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1782 #endif
1783                 }
1784
1785               set_spec (p2, *(sl->ptr_spec));
1786               if (sl->alloc_p)
1787                 free (CONST_CAST (char *, *(sl->ptr_spec)));
1788
1789               *(sl->ptr_spec) = "";
1790               sl->alloc_p = 0;
1791               continue;
1792             }
1793           else
1794             fatal_error ("specs unknown %% command after %ld characters",
1795                          (long) (p1 - buffer));
1796         }
1797
1798       /* Find the colon that should end the suffix.  */
1799       p1 = p;
1800       while (*p1 && *p1 != ':' && *p1 != '\n')
1801         p1++;
1802
1803       /* The colon shouldn't be missing.  */
1804       if (*p1 != ':')
1805         fatal_error ("specs file malformed after %ld characters",
1806                      (long) (p1 - buffer));
1807
1808       /* Skip back over trailing whitespace.  */
1809       p2 = p1;
1810       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1811         p2--;
1812
1813       /* Copy the suffix to a string.  */
1814       suffix = save_string (p, p2 - p);
1815       /* Find the next line.  */
1816       p = skip_whitespace (p1 + 1);
1817       if (p[1] == 0)
1818         fatal_error ("specs file malformed after %ld characters",
1819                      (long) (p - buffer));
1820
1821       p1 = p;
1822       /* Find next blank line or end of string.  */
1823       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1824         p1++;
1825
1826       /* Specs end at the blank line and do not include the newline.  */
1827       spec = save_string (p, p1 - p);
1828       p = p1;
1829
1830       /* Delete backslash-newline sequences from the spec.  */
1831       in = spec;
1832       out = spec;
1833       while (*in != 0)
1834         {
1835           if (in[0] == '\\' && in[1] == '\n')
1836             in += 2;
1837           else if (in[0] == '#')
1838             while (*in && *in != '\n')
1839               in++;
1840
1841           else
1842             *out++ = *in++;
1843         }
1844       *out = 0;
1845
1846       if (suffix[0] == '*')
1847         {
1848           if (! strcmp (suffix, "*link_command"))
1849             link_command_spec = spec;
1850           else
1851             set_spec (suffix + 1, spec);
1852         }
1853       else
1854         {
1855           /* Add this pair to the vector.  */
1856           compilers
1857             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1858
1859           compilers[n_compilers].suffix = suffix;
1860           compilers[n_compilers].spec = spec;
1861           n_compilers++;
1862           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1863         }
1864
1865       if (*suffix == 0)
1866         link_command_spec = spec;
1867     }
1868
1869   if (link_command_spec == 0)
1870     fatal_error ("spec file has no spec for linking");
1871 }
1872 \f
1873 /* Record the names of temporary files we tell compilers to write,
1874    and delete them at the end of the run.  */
1875
1876 /* This is the common prefix we use to make temp file names.
1877    It is chosen once for each run of this program.
1878    It is substituted into a spec by %g or %j.
1879    Thus, all temp file names contain this prefix.
1880    In practice, all temp file names start with this prefix.
1881
1882    This prefix comes from the envvar TMPDIR if it is defined;
1883    otherwise, from the P_tmpdir macro if that is defined;
1884    otherwise, in /usr/tmp or /tmp;
1885    or finally the current directory if all else fails.  */
1886
1887 static const char *temp_filename;
1888
1889 /* Length of the prefix.  */
1890
1891 static int temp_filename_length;
1892
1893 /* Define the list of temporary files to delete.  */
1894
1895 struct temp_file
1896 {
1897   const char *name;
1898   struct temp_file *next;
1899 };
1900
1901 /* Queue of files to delete on success or failure of compilation.  */
1902 static struct temp_file *always_delete_queue;
1903 /* Queue of files to delete on failure of compilation.  */
1904 static struct temp_file *failure_delete_queue;
1905
1906 /* Record FILENAME as a file to be deleted automatically.
1907    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1908    otherwise delete it in any case.
1909    FAIL_DELETE nonzero means delete it if a compilation step fails;
1910    otherwise delete it in any case.  */
1911
1912 void
1913 record_temp_file (const char *filename, int always_delete, int fail_delete)
1914 {
1915   char *const name = xstrdup (filename);
1916
1917   if (always_delete)
1918     {
1919       struct temp_file *temp;
1920       for (temp = always_delete_queue; temp; temp = temp->next)
1921         if (! strcmp (name, temp->name))
1922           goto already1;
1923
1924       temp = XNEW (struct temp_file);
1925       temp->next = always_delete_queue;
1926       temp->name = name;
1927       always_delete_queue = temp;
1928
1929     already1:;
1930     }
1931
1932   if (fail_delete)
1933     {
1934       struct temp_file *temp;
1935       for (temp = failure_delete_queue; temp; temp = temp->next)
1936         if (! strcmp (name, temp->name))
1937           goto already2;
1938
1939       temp = XNEW (struct temp_file);
1940       temp->next = failure_delete_queue;
1941       temp->name = name;
1942       failure_delete_queue = temp;
1943
1944     already2:;
1945     }
1946 }
1947
1948 /* Delete all the temporary files whose names we previously recorded.  */
1949
1950 #ifndef DELETE_IF_ORDINARY
1951 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
1952 do                                                      \
1953   {                                                     \
1954     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
1955       if (unlink (NAME) < 0)                            \
1956         if (VERBOSE_FLAG)                               \
1957           perror_with_name (NAME);                      \
1958   } while (0)
1959 #endif
1960
1961 static void
1962 delete_if_ordinary (const char *name)
1963 {
1964   struct stat st;
1965 #ifdef DEBUG
1966   int i, c;
1967
1968   printf ("Delete %s? (y or n) ", name);
1969   fflush (stdout);
1970   i = getchar ();
1971   if (i != '\n')
1972     while ((c = getchar ()) != '\n' && c != EOF)
1973       ;
1974
1975   if (i == 'y' || i == 'Y')
1976 #endif /* DEBUG */
1977   DELETE_IF_ORDINARY (name, st, verbose_flag);
1978 }
1979
1980 static void
1981 delete_temp_files (void)
1982 {
1983   struct temp_file *temp;
1984
1985   for (temp = always_delete_queue; temp; temp = temp->next)
1986     delete_if_ordinary (temp->name);
1987   always_delete_queue = 0;
1988 }
1989
1990 /* Delete all the files to be deleted on error.  */
1991
1992 static void
1993 delete_failure_queue (void)
1994 {
1995   struct temp_file *temp;
1996
1997   for (temp = failure_delete_queue; temp; temp = temp->next)
1998     delete_if_ordinary (temp->name);
1999 }
2000
2001 static void
2002 clear_failure_queue (void)
2003 {
2004   failure_delete_queue = 0;
2005 }
2006 \f
2007 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2008    returns non-NULL.
2009    If DO_MULTI is true iterate over the paths twice, first with multilib
2010    suffix then without, otherwise iterate over the paths once without
2011    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2012    to avoid visiting the same path twice, but we could do better.  For
2013    instance, /usr/lib/../lib is considered different from /usr/lib.
2014    At least EXTRA_SPACE chars past the end of the path passed to
2015    CALLBACK are available for use by the callback.
2016    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2017
2018    Returns the value returned by CALLBACK.  */
2019
2020 static void *
2021 for_each_path (const struct path_prefix *paths,
2022                bool do_multi,
2023                size_t extra_space,
2024                void *(*callback) (char *, void *),
2025                void *callback_info)
2026 {
2027   struct prefix_list *pl;
2028   const char *multi_dir = NULL;
2029   const char *multi_os_dir = NULL;
2030   const char *multi_suffix;
2031   const char *just_multi_suffix;
2032   char *path = NULL;
2033   void *ret = NULL;
2034   bool skip_multi_dir = false;
2035   bool skip_multi_os_dir = false;
2036
2037   multi_suffix = machine_suffix;
2038   just_multi_suffix = just_machine_suffix;
2039   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2040     {
2041       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2042       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2043       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2044     }
2045   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2046     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2047
2048   while (1)
2049     {
2050       size_t multi_dir_len = 0;
2051       size_t multi_os_dir_len = 0;
2052       size_t suffix_len;
2053       size_t just_suffix_len;
2054       size_t len;
2055
2056       if (multi_dir)
2057         multi_dir_len = strlen (multi_dir);
2058       if (multi_os_dir)
2059         multi_os_dir_len = strlen (multi_os_dir);
2060       suffix_len = strlen (multi_suffix);
2061       just_suffix_len = strlen (just_multi_suffix);
2062
2063       if (path == NULL)
2064         {
2065           len = paths->max_len + extra_space + 1;
2066           if (suffix_len > multi_os_dir_len)
2067             len += suffix_len;
2068           else
2069             len += multi_os_dir_len;
2070           path = XNEWVEC (char, len);
2071         }
2072
2073       for (pl = paths->plist; pl != 0; pl = pl->next)
2074         {
2075           len = strlen (pl->prefix);
2076           memcpy (path, pl->prefix, len);
2077
2078           /* Look first in MACHINE/VERSION subdirectory.  */
2079           if (!skip_multi_dir)
2080             {
2081               memcpy (path + len, multi_suffix, suffix_len + 1);
2082               ret = callback (path, callback_info);
2083               if (ret)
2084                 break;
2085             }
2086
2087           /* Some paths are tried with just the machine (ie. target)
2088              subdir.  This is used for finding as, ld, etc.  */
2089           if (!skip_multi_dir
2090               && pl->require_machine_suffix == 2)
2091             {
2092               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2093               ret = callback (path, callback_info);
2094               if (ret)
2095                 break;
2096             }
2097
2098           /* Now try the base path.  */
2099           if (!pl->require_machine_suffix
2100               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2101             {
2102               const char *this_multi;
2103               size_t this_multi_len;
2104
2105               if (pl->os_multilib)
2106                 {
2107                   this_multi = multi_os_dir;
2108                   this_multi_len = multi_os_dir_len;
2109                 }
2110               else
2111                 {
2112                   this_multi = multi_dir;
2113                   this_multi_len = multi_dir_len;
2114                 }
2115
2116               if (this_multi_len)
2117                 memcpy (path + len, this_multi, this_multi_len + 1);
2118               else
2119                 path[len] = '\0';
2120
2121               ret = callback (path, callback_info);
2122               if (ret)
2123                 break;
2124             }
2125         }
2126       if (pl)
2127         break;
2128
2129       if (multi_dir == NULL && multi_os_dir == NULL)
2130         break;
2131
2132       /* Run through the paths again, this time without multilibs.
2133          Don't repeat any we have already seen.  */
2134       if (multi_dir)
2135         {
2136           free (CONST_CAST (char *, multi_dir));
2137           multi_dir = NULL;
2138           free (CONST_CAST (char *, multi_suffix));
2139           multi_suffix = machine_suffix;
2140           free (CONST_CAST (char *, just_multi_suffix));
2141           just_multi_suffix = just_machine_suffix;
2142         }
2143       else
2144         skip_multi_dir = true;
2145       if (multi_os_dir)
2146         {
2147           free (CONST_CAST (char *, multi_os_dir));
2148           multi_os_dir = NULL;
2149         }
2150       else
2151         skip_multi_os_dir = true;
2152     }
2153
2154   if (multi_dir)
2155     {
2156       free (CONST_CAST (char *, multi_dir));
2157       free (CONST_CAST (char *, multi_suffix));
2158       free (CONST_CAST (char *, just_multi_suffix));
2159     }
2160   if (multi_os_dir)
2161     free (CONST_CAST (char *, multi_os_dir));
2162   if (ret != path)
2163     free (path);
2164   return ret;
2165 }
2166
2167 /* Callback for build_search_list.  Adds path to obstack being built.  */
2168
2169 struct add_to_obstack_info {
2170   struct obstack *ob;
2171   bool check_dir;
2172   bool first_time;
2173 };
2174
2175 static void *
2176 add_to_obstack (char *path, void *data)
2177 {
2178   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2179
2180   if (info->check_dir && !is_directory (path, false))
2181     return NULL;
2182
2183   if (!info->first_time)
2184     obstack_1grow (info->ob, PATH_SEPARATOR);
2185
2186   obstack_grow (info->ob, path, strlen (path));
2187
2188   info->first_time = false;
2189   return NULL;
2190 }
2191
2192 /* Add or change the value of an environment variable, outputting the
2193    change to standard error if in verbose mode.  */
2194 static void
2195 xputenv (const char *string)
2196 {
2197   if (verbose_flag)
2198     fnotice (stderr, "%s\n", string);
2199   putenv (CONST_CAST (char *, string));
2200 }
2201
2202 /* Build a list of search directories from PATHS.
2203    PREFIX is a string to prepend to the list.
2204    If CHECK_DIR_P is true we ensure the directory exists.
2205    If DO_MULTI is true, multilib paths are output first, then
2206    non-multilib paths.
2207    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2208    It is also used by the --print-search-dirs flag.  */
2209
2210 static char *
2211 build_search_list (const struct path_prefix *paths, const char *prefix,
2212                    bool check_dir, bool do_multi)
2213 {
2214   struct add_to_obstack_info info;
2215
2216   info.ob = &collect_obstack;
2217   info.check_dir = check_dir;
2218   info.first_time = true;
2219
2220   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2221   obstack_1grow (&collect_obstack, '=');
2222
2223   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2224
2225   obstack_1grow (&collect_obstack, '\0');
2226   return XOBFINISH (&collect_obstack, char *);
2227 }
2228
2229 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2230    for collect.  */
2231
2232 static void
2233 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2234                       bool do_multi)
2235 {
2236   xputenv (build_search_list (paths, env_var, true, do_multi));
2237 }
2238 \f
2239 /* Check whether NAME can be accessed in MODE.  This is like access,
2240    except that it never considers directories to be executable.  */
2241
2242 static int
2243 access_check (const char *name, int mode)
2244 {
2245   if (mode == X_OK)
2246     {
2247       struct stat st;
2248
2249       if (stat (name, &st) < 0
2250           || S_ISDIR (st.st_mode))
2251         return -1;
2252     }
2253
2254   return access (name, mode);
2255 }
2256
2257 /* Callback for find_a_file.  Appends the file name to the directory
2258    path.  If the resulting file exists in the right mode, return the
2259    full pathname to the file.  */
2260
2261 struct file_at_path_info {
2262   const char *name;
2263   const char *suffix;
2264   int name_len;
2265   int suffix_len;
2266   int mode;
2267 };
2268
2269 static void *
2270 file_at_path (char *path, void *data)
2271 {
2272   struct file_at_path_info *info = (struct file_at_path_info *) data;
2273   size_t len = strlen (path);
2274
2275   memcpy (path + len, info->name, info->name_len);
2276   len += info->name_len;
2277
2278   /* Some systems have a suffix for executable files.
2279      So try appending that first.  */
2280   if (info->suffix_len)
2281     {
2282       memcpy (path + len, info->suffix, info->suffix_len + 1);
2283       if (access_check (path, info->mode) == 0)
2284         return path;
2285     }
2286
2287   path[len] = '\0';
2288   if (access_check (path, info->mode) == 0)
2289     return path;
2290
2291   return NULL;
2292 }
2293
2294 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2295    access to check permissions.  If DO_MULTI is true, search multilib
2296    paths then non-multilib paths, otherwise do not search multilib paths.
2297    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2298
2299 static char *
2300 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2301              bool do_multi)
2302 {
2303   struct file_at_path_info info;
2304
2305 #ifdef DEFAULT_ASSEMBLER
2306   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2307     return xstrdup (DEFAULT_ASSEMBLER);
2308 #endif
2309
2310 #ifdef DEFAULT_LINKER
2311   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2312     return xstrdup (DEFAULT_LINKER);
2313 #endif
2314
2315   /* Determine the filename to execute (special case for absolute paths).  */
2316
2317   if (IS_ABSOLUTE_PATH (name))
2318     {
2319       if (access (name, mode) == 0)
2320         return xstrdup (name);
2321
2322       return NULL;
2323     }
2324
2325   info.name = name;
2326   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2327   info.name_len = strlen (info.name);
2328   info.suffix_len = strlen (info.suffix);
2329   info.mode = mode;
2330
2331   return (char*) for_each_path (pprefix, do_multi,
2332                                 info.name_len + info.suffix_len,
2333                                 file_at_path, &info);
2334 }
2335
2336 /* Ranking of prefixes in the sort list. -B prefixes are put before
2337    all others.  */
2338
2339 enum path_prefix_priority
2340 {
2341   PREFIX_PRIORITY_B_OPT,
2342   PREFIX_PRIORITY_LAST
2343 };
2344
2345 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2346    order according to PRIORITY.  Within each PRIORITY, new entries are
2347    appended.
2348
2349    If WARN is nonzero, we will warn if no file is found
2350    through this prefix.  WARN should point to an int
2351    which will be set to 1 if this entry is used.
2352
2353    COMPONENT is the value to be passed to update_path.
2354
2355    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2356    the complete value of machine_suffix.
2357    2 means try both machine_suffix and just_machine_suffix.  */
2358
2359 static void
2360 add_prefix (struct path_prefix *pprefix, const char *prefix,
2361             const char *component, /* enum prefix_priority */ int priority,
2362             int require_machine_suffix, int os_multilib)
2363 {
2364   struct prefix_list *pl, **prev;
2365   int len;
2366
2367   for (prev = &pprefix->plist;
2368        (*prev) != NULL && (*prev)->priority <= priority;
2369        prev = &(*prev)->next)
2370     ;
2371
2372   /* Keep track of the longest prefix.  */
2373
2374   prefix = update_path (prefix, component);
2375   len = strlen (prefix);
2376   if (len > pprefix->max_len)
2377     pprefix->max_len = len;
2378
2379   pl = XNEW (struct prefix_list);
2380   pl->prefix = prefix;
2381   pl->require_machine_suffix = require_machine_suffix;
2382   pl->priority = priority;
2383   pl->os_multilib = os_multilib;
2384
2385   /* Insert after PREV.  */
2386   pl->next = (*prev);
2387   (*prev) = pl;
2388 }
2389
2390 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2391 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2392 static void
2393 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2394                       const char *component,
2395                       /* enum prefix_priority */ int priority,
2396                       int require_machine_suffix, int os_multilib)
2397 {
2398   if (!IS_ABSOLUTE_PATH (prefix))
2399     fatal_error ("system path %qs is not absolute", prefix);
2400
2401   if (target_system_root)
2402     {
2403       if (target_sysroot_suffix)
2404           prefix = concat (target_sysroot_suffix, prefix, NULL);
2405       prefix = concat (target_system_root, prefix, NULL);
2406
2407       /* We have to override this because GCC's notion of sysroot
2408          moves along with GCC.  */
2409       component = "GCC";
2410     }
2411
2412   add_prefix (pprefix, prefix, component, priority,
2413               require_machine_suffix, os_multilib);
2414 }
2415 \f
2416 /* Execute the command specified by the arguments on the current line of spec.
2417    When using pipes, this includes several piped-together commands
2418    with `|' between them.
2419
2420    Return 0 if successful, -1 if failed.  */
2421
2422 static int
2423 execute (void)
2424 {
2425   int i;
2426   int n_commands;               /* # of command.  */
2427   char *string;
2428   struct pex_obj *pex;
2429   struct command
2430   {
2431     const char *prog;           /* program name.  */
2432     const char **argv;          /* vector of args.  */
2433   };
2434   const char *arg;
2435
2436   struct command *commands;     /* each command buffer with above info.  */
2437
2438   gcc_assert (!processing_spec_function);
2439
2440   if (wrapper_string)
2441     {
2442       string = find_a_file (&exec_prefixes,
2443                             VEC_index (const_char_p, argbuf, 0), X_OK, false);
2444       if (string)
2445         VEC_replace (const_char_p, argbuf, 0, string);
2446       insert_wrapper (wrapper_string);
2447     }
2448
2449   /* Count # of piped commands.  */
2450   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2451     if (strcmp (arg, "|") == 0)
2452       n_commands++;
2453
2454   /* Get storage for each command.  */
2455   commands = (struct command *) alloca (n_commands * sizeof (struct command));
2456
2457   /* Split argbuf into its separate piped processes,
2458      and record info about each one.
2459      Also search for the programs that are to be run.  */
2460
2461   VEC_safe_push (const_char_p, heap, argbuf, 0);
2462
2463   commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command.  */
2464   commands[0].argv = VEC_address (const_char_p, argbuf);
2465
2466   if (!wrapper_string)
2467     {
2468       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2469       commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2470     }
2471
2472   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2473     if (arg && strcmp (arg, "|") == 0)
2474       {                         /* each command.  */
2475 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2476         fatal_error ("-pipe not supported");
2477 #endif
2478         VEC_replace (const_char_p, argbuf, i, 0); /* Termination of
2479                                                      command args.  */
2480         commands[n_commands].prog = VEC_index (const_char_p, argbuf, i + 1);
2481         commands[n_commands].argv
2482           = &(VEC_address (const_char_p, argbuf))[i + 1];
2483         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2484                               X_OK, false);
2485         if (string)
2486           commands[n_commands].argv[0] = string;
2487         n_commands++;
2488       }
2489
2490   /* If -v, print what we are about to do, and maybe query.  */
2491
2492   if (verbose_flag)
2493     {
2494       /* For help listings, put a blank line between sub-processes.  */
2495       if (print_help_list)
2496         fputc ('\n', stderr);
2497
2498       /* Print each piped command as a separate line.  */
2499       for (i = 0; i < n_commands; i++)
2500         {
2501           const char *const *j;
2502
2503           if (verbose_only_flag)
2504             {
2505               for (j = commands[i].argv; *j; j++)
2506                 {
2507                   const char *p;
2508                   for (p = *j; *p; ++p)
2509                     if (!ISALNUM ((unsigned char) *p)
2510                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2511                       break;
2512                   if (*p || !*j)
2513                     {
2514                       fprintf (stderr, " \"");
2515                       for (p = *j; *p; ++p)
2516                         {
2517                           if (*p == '"' || *p == '\\' || *p == '$')
2518                             fputc ('\\', stderr);
2519                           fputc (*p, stderr);
2520                         }
2521                       fputc ('"', stderr);
2522                     }
2523                   else
2524                     fprintf (stderr, " %s", *j);
2525                 }
2526             }
2527           else
2528             for (j = commands[i].argv; *j; j++)
2529               fprintf (stderr, " %s", *j);
2530
2531           /* Print a pipe symbol after all but the last command.  */
2532           if (i + 1 != n_commands)
2533             fprintf (stderr, " |");
2534           fprintf (stderr, "\n");
2535         }
2536       fflush (stderr);
2537       if (verbose_only_flag != 0)
2538         {
2539           /* verbose_only_flag should act as if the spec was
2540              executed, so increment execution_count before
2541              returning.  This prevents spurious warnings about
2542              unused linker input files, etc.  */
2543           execution_count++;
2544           return 0;
2545         }
2546 #ifdef DEBUG
2547       fnotice (stderr, "\nGo ahead? (y or n) ");
2548       fflush (stderr);
2549       i = getchar ();
2550       if (i != '\n')
2551         while (getchar () != '\n')
2552           ;
2553
2554       if (i != 'y' && i != 'Y')
2555         return 0;
2556 #endif /* DEBUG */
2557     }
2558
2559 #ifdef ENABLE_VALGRIND_CHECKING
2560   /* Run the each command through valgrind.  To simplify prepending the
2561      path to valgrind and the option "-q" (for quiet operation unless
2562      something triggers), we allocate a separate argv array.  */
2563
2564   for (i = 0; i < n_commands; i++)
2565     {
2566       const char **argv;
2567       int argc;
2568       int j;
2569
2570       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2571         ;
2572
2573       argv = XALLOCAVEC (const char *, argc + 3);
2574
2575       argv[0] = VALGRIND_PATH;
2576       argv[1] = "-q";
2577       for (j = 2; j < argc + 2; j++)
2578         argv[j] = commands[i].argv[j - 2];
2579       argv[j] = NULL;
2580
2581       commands[i].argv = argv;
2582       commands[i].prog = argv[0];
2583     }
2584 #endif
2585
2586   /* Run each piped subprocess.  */
2587
2588   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2589                                    ? PEX_RECORD_TIMES : 0),
2590                   progname, temp_filename);
2591   if (pex == NULL)
2592     fatal_error ("pex_init failed: %m");
2593
2594   for (i = 0; i < n_commands; i++)
2595     {
2596       const char *errmsg;
2597       int err;
2598       const char *string = commands[i].argv[0];
2599
2600       errmsg = pex_run (pex,
2601                         ((i + 1 == n_commands ? PEX_LAST : 0)
2602                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2603                         string, CONST_CAST (char **, commands[i].argv),
2604                         NULL, NULL, &err);
2605       if (errmsg != NULL)
2606         {
2607           if (err == 0)
2608             fatal_error (errmsg);
2609           else
2610             {
2611               errno = err;
2612               pfatal_with_name (errmsg);
2613             }
2614         }
2615
2616       if (string != commands[i].prog)
2617         free (CONST_CAST (char *, string));
2618     }
2619
2620   execution_count++;
2621
2622   /* Wait for all the subprocesses to finish.  */
2623
2624   {
2625     int *statuses;
2626     struct pex_time *times = NULL;
2627     int ret_code = 0;
2628
2629     statuses = (int *) alloca (n_commands * sizeof (int));
2630     if (!pex_get_status (pex, n_commands, statuses))
2631       fatal_error ("failed to get exit status: %m");
2632
2633     if (report_times || report_times_to_file)
2634       {
2635         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2636         if (!pex_get_times (pex, n_commands, times))
2637           fatal_error ("failed to get process times: %m");
2638       }
2639
2640     pex_free (pex);
2641
2642     for (i = 0; i < n_commands; ++i)
2643       {
2644         int status = statuses[i];
2645
2646         if (WIFSIGNALED (status))
2647           {
2648 #ifdef SIGPIPE
2649             /* SIGPIPE is a special case.  It happens in -pipe mode
2650                when the compiler dies before the preprocessor is done,
2651                or the assembler dies before the compiler is done.
2652                There's generally been an error already, and this is
2653                just fallout.  So don't generate another error unless
2654                we would otherwise have succeeded.  */
2655             if (WTERMSIG (status) == SIGPIPE
2656                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2657               {
2658                 signal_count++;
2659                 ret_code = -1;
2660               }
2661             else
2662 #endif
2663               internal_error ("%s (program %s)",
2664                               strsignal (WTERMSIG (status)), commands[i].prog);
2665           }
2666         else if (WIFEXITED (status)
2667                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2668           {
2669             if (WEXITSTATUS (status) > greatest_status)
2670               greatest_status = WEXITSTATUS (status);
2671             ret_code = -1;
2672           }
2673
2674         if (report_times || report_times_to_file)
2675           {
2676             struct pex_time *pt = &times[i];
2677             double ut, st;
2678
2679             ut = ((double) pt->user_seconds
2680                   + (double) pt->user_microseconds / 1.0e6);
2681             st = ((double) pt->system_seconds
2682                   + (double) pt->system_microseconds / 1.0e6);
2683
2684             if (ut + st != 0)
2685               {
2686                 if (report_times)
2687                   fnotice (stderr, "# %s %.2f %.2f\n",
2688                            commands[i].prog, ut, st);
2689
2690                 if (report_times_to_file)
2691                   {
2692                     int c = 0;
2693                     const char *const *j;
2694
2695                     fprintf (report_times_to_file, "%g %g", ut, st);
2696
2697                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2698                       {
2699                         const char *p;
2700                         for (p = *j; *p; ++p)
2701                           if (*p == '"' || *p == '\\' || *p == '$'
2702                               || ISSPACE (*p))
2703                             break;
2704
2705                         if (*p)
2706                           {
2707                             fprintf (report_times_to_file, " \"");
2708                             for (p = *j; *p; ++p)
2709                               {
2710                                 if (*p == '"' || *p == '\\' || *p == '$')
2711                                   fputc ('\\', report_times_to_file);
2712                                 fputc (*p, report_times_to_file);
2713                               }
2714                             fputc ('"', report_times_to_file);
2715                           }
2716                         else
2717                           fprintf (report_times_to_file, " %s", *j);
2718                       }
2719
2720                     fputc ('\n', report_times_to_file);
2721                   }
2722               }
2723           }
2724       }
2725
2726     return ret_code;
2727   }
2728 }
2729 \f
2730 /* Find all the switches given to us
2731    and make a vector describing them.
2732    The elements of the vector are strings, one per switch given.
2733    If a switch uses following arguments, then the `part1' field
2734    is the switch itself and the `args' field
2735    is a null-terminated vector containing the following arguments.
2736    Bits in the `live_cond' field are:
2737    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2738    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2739    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2740    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2741    in all do_spec calls afterwards.  Used for %<S from self specs.
2742    The `validated' field is nonzero if any spec has looked at this switch;
2743    if it remains zero at the end of the run, it must be meaningless.  */
2744
2745 #define SWITCH_LIVE                     0x1
2746 #define SWITCH_FALSE                    0x2
2747 #define SWITCH_IGNORE                   0x4
2748 #define SWITCH_IGNORE_PERMANENTLY       0x8
2749
2750 struct switchstr
2751 {
2752   const char *part1;
2753   const char **args;
2754   unsigned int live_cond;
2755   unsigned char validated;
2756   unsigned char ordering;
2757 };
2758
2759 static struct switchstr *switches;
2760
2761 static int n_switches;
2762
2763 static int n_switches_alloc;
2764
2765 /* Set to zero if -fcompare-debug is disabled, positive if it's
2766    enabled and we're running the first compilation, negative if it's
2767    enabled and we're running the second compilation.  For most of the
2768    time, it's in the range -1..1, but it can be temporarily set to 2
2769    or 3 to indicate that the -fcompare-debug flags didn't come from
2770    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2771    variable, until a synthesized -fcompare-debug flag is added to the
2772    command line.  */
2773 int compare_debug;
2774
2775 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2776 int compare_debug_second;
2777
2778 /* Set to the flags that should be passed to the second compilation in
2779    a -fcompare-debug compilation.  */
2780 const char *compare_debug_opt;
2781
2782 static struct switchstr *switches_debug_check[2];
2783
2784 static int n_switches_debug_check[2];
2785
2786 static int n_switches_alloc_debug_check[2];
2787
2788 static char *debug_check_temp_file[2];
2789
2790 /* Language is one of three things:
2791
2792    1) The name of a real programming language.
2793    2) NULL, indicating that no one has figured out
2794    what it is yet.
2795    3) '*', indicating that the file should be passed
2796    to the linker.  */
2797 struct infile
2798 {
2799   const char *name;
2800   const char *language;
2801   struct compiler *incompiler;
2802   bool compiled;
2803   bool preprocessed;
2804 };
2805
2806 /* Also a vector of input files specified.  */
2807
2808 static struct infile *infiles;
2809
2810 int n_infiles;
2811
2812 static int n_infiles_alloc;
2813
2814 /* True if multiple input files are being compiled to a single
2815    assembly file.  */
2816
2817 static bool combine_inputs;
2818
2819 /* This counts the number of libraries added by lang_specific_driver, so that
2820    we can tell if there were any user supplied any files or libraries.  */
2821
2822 static int added_libraries;
2823
2824 /* And a vector of corresponding output files is made up later.  */
2825
2826 const char **outfiles;
2827 \f
2828 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2829
2830 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2831    is true if we should look for an executable suffix.  DO_OBJ
2832    is true if we should look for an object suffix.  */
2833
2834 static const char *
2835 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2836                   int do_obj ATTRIBUTE_UNUSED)
2837 {
2838 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2839   int i;
2840 #endif
2841   int len;
2842
2843   if (name == NULL)
2844     return NULL;
2845
2846   len = strlen (name);
2847
2848 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2849   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2850   if (do_obj && len > 2
2851       && name[len - 2] == '.'
2852       && name[len - 1] == 'o')
2853     {
2854       obstack_grow (&obstack, name, len - 2);
2855       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2856       name = XOBFINISH (&obstack, const char *);
2857     }
2858 #endif
2859
2860 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2861   /* If there is no filetype, make it the executable suffix (which includes
2862      the ".").  But don't get confused if we have just "-o".  */
2863   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2864     return name;
2865
2866   for (i = len - 1; i >= 0; i--)
2867     if (IS_DIR_SEPARATOR (name[i]))
2868       break;
2869
2870   for (i++; i < len; i++)
2871     if (name[i] == '.')
2872       return name;
2873
2874   obstack_grow (&obstack, name, len);
2875   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2876                  strlen (TARGET_EXECUTABLE_SUFFIX));
2877   name = XOBFINISH (&obstack, const char *);
2878 #endif
2879
2880   return name;
2881 }
2882 #endif
2883 \f
2884 /* Display the command line switches accepted by gcc.  */
2885 static void
2886 display_help (void)
2887 {
2888   printf (_("Usage: %s [options] file...\n"), progname);
2889   fputs (_("Options:\n"), stdout);
2890
2891   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2892   fputs (_("  --help                   Display this information\n"), stdout);
2893   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2894   fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2895   fputs (_("                           Display specific types of command line options\n"), stdout);
2896   if (! verbose_flag)
2897     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2898   fputs (_("  --version                Display compiler version information\n"), stdout);
2899   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2900   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2901   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2902   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2903   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2904   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2905   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2906   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2907   fputs (_("\
2908   -print-multi-lib         Display the mapping between command line options and\n\
2909                            multiple library search directories\n"), stdout);
2910   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2911   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
2912   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
2913   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2914   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2915   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2916   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2917   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
2918   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
2919   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
2920   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
2921   fputs (_("\
2922   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
2923                            prefixes to other gcc components\n"), stdout);
2924   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
2925   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
2926   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
2927   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
2928   fputs (_("\
2929   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
2930                            and libraries\n"), stdout);
2931   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
2932   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
2933   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
2934   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
2935   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
2936   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
2937   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
2938   fputs (_("\
2939   -x <language>            Specify the language of the following input files\n\
2940                            Permissible languages include: c c++ assembler none\n\
2941                            'none' means revert to the default behavior of\n\
2942                            guessing the language based on the file's extension\n\
2943 "), stdout);
2944
2945   printf (_("\
2946 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
2947  passed on to the various sub-processes invoked by %s.  In order to pass\n\
2948  other options on to these processes the -W<letter> options must be used.\n\
2949 "), progname);
2950
2951   /* The rest of the options are displayed by invocations of the various
2952      sub-processes.  */
2953 }
2954
2955 static void
2956 add_preprocessor_option (const char *option, int len)
2957 {
2958   VEC_safe_push (char_p, heap, preprocessor_options,
2959                  save_string (option, len));
2960 }
2961
2962 static void
2963 add_assembler_option (const char *option, int len)
2964 {
2965   VEC_safe_push (char_p, heap, assembler_options, save_string (option, len));
2966 }
2967
2968 static void
2969 add_linker_option (const char *option, int len)
2970 {
2971   VEC_safe_push (char_p, heap, linker_options, save_string (option, len));
2972 }
2973 \f
2974 /* Allocate space for an input file in infiles.  */
2975
2976 static void
2977 alloc_infile (void)
2978 {
2979   if (n_infiles_alloc == 0)
2980     {
2981       n_infiles_alloc = 16;
2982       infiles = XNEWVEC (struct infile, n_infiles_alloc);
2983     }
2984   else if (n_infiles_alloc == n_infiles)
2985     {
2986       n_infiles_alloc *= 2;
2987       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
2988     }
2989 }
2990
2991 /* Store an input file with the given NAME and LANGUAGE in
2992    infiles.  */
2993
2994 static void
2995 add_infile (const char *name, const char *language)
2996 {
2997   alloc_infile ();
2998   infiles[n_infiles].name = name;
2999   infiles[n_infiles++].language = language;
3000 }
3001
3002 /* Allocate space for a switch in switches.  */
3003
3004 static void
3005 alloc_switch (void)
3006 {
3007   if (n_switches_alloc == 0)
3008     {
3009       n_switches_alloc = 16;
3010       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3011     }
3012   else if (n_switches_alloc == n_switches)
3013     {
3014       n_switches_alloc *= 2;
3015       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3016     }
3017 }
3018
3019 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3020    as validated if VALIDATED.  */
3021
3022 static void
3023 save_switch (const char *opt, size_t n_args, const char *const *args,
3024              bool validated)
3025 {
3026   alloc_switch ();
3027   switches[n_switches].part1 = opt + 1;
3028   if (n_args == 0)
3029     switches[n_switches].args = 0;
3030   else
3031     {
3032       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3033       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3034       switches[n_switches].args[n_args] = NULL;
3035     }
3036
3037   switches[n_switches].live_cond = 0;
3038   switches[n_switches].validated = validated;
3039   switches[n_switches].ordering = 0;
3040   n_switches++;
3041 }
3042
3043 /* Handle an option DECODED that is unknown to the option-processing
3044    machinery, but may be known to specs.  */
3045
3046 static bool
3047 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3048 {
3049   save_switch (decoded->canonical_option[0],
3050                decoded->canonical_option_num_elements - 1,
3051                &decoded->canonical_option[1], false);
3052
3053   return false;
3054 }
3055
3056 /* Handle an option DECODED that is not marked as CL_DRIVER.
3057    LANG_MASK will always be CL_DRIVER.  */
3058
3059 static void
3060 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3061                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3062 {
3063   /* At this point, non-driver options are accepted (and expected to
3064      be passed down by specs) unless marked to be rejected by the
3065      driver.  Options to be rejected by the driver but accepted by the
3066      compilers proper are treated just like completely unknown
3067      options.  */
3068   const struct cl_option *option = &cl_options[decoded->opt_index];
3069
3070   if (option->flags & CL_REJECT_DRIVER)
3071     error ("unrecognized command line option %qs",
3072            decoded->orig_option_with_args_text);
3073   else
3074     driver_unknown_option_callback (decoded);
3075 }
3076
3077 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3078    has been successfully handled with a handler for mask MASK.  */
3079
3080 static void
3081 driver_post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
3082                                unsigned int mask ATTRIBUTE_UNUSED)
3083 {
3084   /* Nothing to do here.  */
3085 }
3086
3087 static const char *spec_lang = 0;
3088 static int last_language_n_infiles;
3089
3090 /* Handle a driver option; arguments and return value as for
3091    handle_option.  */
3092
3093 static bool
3094 driver_handle_option (struct gcc_options *opts,
3095                       struct gcc_options *opts_set,
3096                       const struct cl_decoded_option *decoded,
3097                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3098                       location_t loc,
3099                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3100                       diagnostic_context *dc)
3101 {
3102   size_t opt_index = decoded->opt_index;
3103   const char *arg = decoded->arg;
3104   const char *compare_debug_replacement_opt;
3105   int value = decoded->value;
3106   bool validated = false;
3107   bool do_save = true;
3108
3109   gcc_assert (opts == &global_options);
3110   gcc_assert (opts_set == &global_options_set);
3111   gcc_assert (kind == DK_UNSPECIFIED);
3112   gcc_assert (loc == UNKNOWN_LOCATION);
3113   gcc_assert (dc == global_dc);
3114
3115   switch (opt_index)
3116     {
3117     case OPT_dumpspecs:
3118       {
3119         struct spec_list *sl;
3120         init_spec ();
3121         for (sl = specs; sl; sl = sl->next)
3122           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3123         if (link_command_spec)
3124           printf ("*link_command:\n%s\n\n", link_command_spec);
3125         exit (0);
3126       }
3127
3128     case OPT_dumpversion:
3129       printf ("%s\n", spec_version);
3130       exit (0);
3131
3132     case OPT_dumpmachine:
3133       printf ("%s\n", spec_machine);
3134       exit (0);
3135
3136     case OPT__version:
3137       print_version = 1;
3138
3139       /* CPP driver cannot obtain switch from cc1_options.  */
3140       if (is_cpp_driver)
3141         add_preprocessor_option ("--version", strlen ("--version"));
3142       add_assembler_option ("--version", strlen ("--version"));
3143       add_linker_option ("--version", strlen ("--version"));
3144       break;
3145
3146     case OPT__help:
3147       print_help_list = 1;
3148
3149       /* CPP driver cannot obtain switch from cc1_options.  */
3150       if (is_cpp_driver)
3151         add_preprocessor_option ("--help", 6);
3152       add_assembler_option ("--help", 6);
3153       add_linker_option ("--help", 6);
3154       break;
3155
3156     case OPT__help_:
3157       print_subprocess_help = 2;
3158       break;
3159
3160     case OPT__target_help:
3161       print_subprocess_help = 1;
3162
3163       /* CPP driver cannot obtain switch from cc1_options.  */
3164       if (is_cpp_driver)
3165         add_preprocessor_option ("--target-help", 13);
3166       add_assembler_option ("--target-help", 13);
3167       add_linker_option ("--target-help", 13);
3168       break;
3169
3170     case OPT_pass_exit_codes:
3171     case OPT_print_search_dirs:
3172     case OPT_print_file_name_:
3173     case OPT_print_prog_name_:
3174     case OPT_print_multi_lib:
3175     case OPT_print_multi_directory:
3176     case OPT_print_sysroot:
3177     case OPT_print_multi_os_directory:
3178     case OPT_print_sysroot_headers_suffix:
3179     case OPT_time:
3180     case OPT_wrapper:
3181       /* These options set the variables specified in common.opt
3182          automatically, and do not need to be saved for spec
3183          processing.  */
3184       do_save = false;
3185       break;
3186
3187     case OPT_print_libgcc_file_name:
3188       print_file_name = "libgcc.a";
3189       do_save = false;
3190       break;
3191
3192     case OPT_fcompare_debug_second:
3193       compare_debug_second = 1;
3194       break;
3195
3196     case OPT_fcompare_debug:
3197       switch (value)
3198         {
3199         case 0:
3200           compare_debug_replacement_opt = "-fcompare-debug=";
3201           arg = "";
3202           goto compare_debug_with_arg;
3203
3204         case 1:
3205           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3206           arg = "-gtoggle";
3207           goto compare_debug_with_arg;
3208
3209         default:
3210           gcc_unreachable ();
3211         }
3212       break;
3213
3214     case OPT_fcompare_debug_:
3215       compare_debug_replacement_opt = decoded->canonical_option[0];
3216     compare_debug_with_arg:
3217       gcc_assert (decoded->canonical_option_num_elements == 1);
3218       gcc_assert (arg != NULL);
3219       if (arg)
3220         compare_debug = 1;
3221       else
3222         compare_debug = -1;
3223       if (compare_debug < 0)
3224         compare_debug_opt = NULL;
3225       else
3226         compare_debug_opt = arg;
3227       save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3228       return true;
3229
3230     case OPT_Wa_:
3231       {
3232         int prev, j;
3233         /* Pass the rest of this option to the assembler.  */
3234
3235         /* Split the argument at commas.  */
3236         prev = 0;
3237         for (j = 0; arg[j]; j++)
3238           if (arg[j] == ',')
3239             {
3240               add_assembler_option (arg + prev, j - prev);
3241               prev = j + 1;
3242             }
3243
3244         /* Record the part after the last comma.  */
3245         add_assembler_option (arg + prev, j - prev);
3246       }
3247       do_save = false;
3248       break;
3249
3250     case OPT_Wp_:
3251       {
3252         int prev, j;
3253         /* Pass the rest of this option to the preprocessor.  */
3254
3255         /* Split the argument at commas.  */
3256         prev = 0;
3257         for (j = 0; arg[j]; j++)
3258           if (arg[j] == ',')
3259             {
3260               add_preprocessor_option (arg + prev, j - prev);
3261               prev = j + 1;
3262             }
3263
3264         /* Record the part after the last comma.  */
3265         add_preprocessor_option (arg + prev, j - prev);
3266       }
3267       do_save = false;
3268       break;
3269
3270     case OPT_Wl_:
3271       {
3272         int prev, j;
3273         /* Split the argument at commas.  */
3274         prev = 0;
3275         for (j = 0; arg[j]; j++)
3276           if (arg[j] == ',')
3277             {
3278               add_infile (save_string (arg + prev, j - prev), "*");
3279               prev = j + 1;
3280             }
3281         /* Record the part after the last comma.  */
3282         add_infile (arg + prev, "*");
3283       }
3284       do_save = false;
3285       break;
3286
3287     case OPT_Xlinker:
3288       add_infile (arg, "*");
3289       do_save = false;
3290       break;
3291
3292     case OPT_Xpreprocessor:
3293       add_preprocessor_option (arg, strlen (arg));
3294       do_save = false;
3295       break;
3296
3297     case OPT_Xassembler:
3298       add_assembler_option (arg, strlen (arg));
3299       do_save = false;
3300       break;
3301
3302     case OPT_l:
3303       /* POSIX allows separation of -l and the lib arg; canonicalize
3304          by concatenating -l with its arg */
3305       add_infile (concat ("-l", arg, NULL), "*");
3306       do_save = false;
3307       break;
3308
3309     case OPT_L:
3310       /* Similarly, canonicalize -L for linkers that may not accept
3311          separate arguments.  */
3312       save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3313       return true;
3314
3315     case OPT_save_temps:
3316       save_temps_flag = SAVE_TEMPS_CWD;
3317       validated = true;
3318       break;
3319
3320     case OPT_save_temps_:
3321       if (strcmp (arg, "cwd") == 0)
3322         save_temps_flag = SAVE_TEMPS_CWD;
3323       else if (strcmp (arg, "obj") == 0
3324                || strcmp (arg, "object") == 0)
3325         save_temps_flag = SAVE_TEMPS_OBJ;
3326       else
3327         fatal_error ("%qs is an unknown -save-temps option",
3328                      decoded->orig_option_with_args_text);
3329       break;
3330
3331     case OPT_no_canonical_prefixes:
3332       /* Already handled as a special case, so ignored here.  */
3333       do_save = false;
3334       break;
3335
3336     case OPT_pipe:
3337       validated = true;
3338       /* These options set the variables specified in common.opt
3339          automatically, but do need to be saved for spec
3340          processing.  */
3341       break;
3342
3343     case OPT_specs_:
3344       {
3345         struct user_specs *user = XNEW (struct user_specs);
3346
3347         user->next = (struct user_specs *) 0;
3348         user->filename = arg;
3349         if (user_specs_tail)
3350           user_specs_tail->next = user;
3351         else
3352           user_specs_head = user;
3353         user_specs_tail = user;
3354       }
3355       do_save = false;
3356       break;
3357
3358     case OPT__sysroot_:
3359       target_system_root = arg;
3360       target_system_root_changed = 1;
3361       do_save = false;
3362       break;
3363
3364     case OPT_time_:
3365       if (report_times_to_file)
3366         fclose (report_times_to_file);
3367       report_times_to_file = fopen (arg, "a");
3368       do_save = false;
3369       break;
3370
3371     case OPT____:
3372       /* "-###"
3373          This is similar to -v except that there is no execution
3374          of the commands and the echoed arguments are quoted.  It
3375          is intended for use in shell scripts to capture the
3376          driver-generated command line.  */
3377       verbose_only_flag++;
3378       verbose_flag = 1;
3379       do_save = false;
3380       break;
3381
3382     case OPT_B:
3383       {
3384         size_t len = strlen (arg);
3385
3386         /* Catch the case where the user has forgotten to append a
3387            directory separator to the path.  Note, they may be using
3388            -B to add an executable name prefix, eg "i386-elf-", in
3389            order to distinguish between multiple installations of
3390            GCC in the same directory.  Hence we must check to see
3391            if appending a directory separator actually makes a
3392            valid directory name.  */
3393         if (!IS_DIR_SEPARATOR (arg[len - 1])
3394             && is_directory (arg, false))
3395           {
3396             char *tmp = XNEWVEC (char, len + 2);
3397             strcpy (tmp, arg);
3398             tmp[len] = DIR_SEPARATOR;
3399             tmp[++len] = 0;
3400             arg = tmp;
3401           }
3402
3403         add_prefix (&exec_prefixes, arg, NULL,
3404                     PREFIX_PRIORITY_B_OPT, 0, 0);
3405         add_prefix (&startfile_prefixes, arg, NULL,
3406                     PREFIX_PRIORITY_B_OPT, 0, 0);
3407         add_prefix (&include_prefixes, arg, NULL,
3408                     PREFIX_PRIORITY_B_OPT, 0, 0);
3409       }
3410       validated = true;
3411       break;
3412
3413     case OPT_x:
3414       spec_lang = arg;
3415       if (!strcmp (spec_lang, "none"))
3416         /* Suppress the warning if -xnone comes after the last input
3417            file, because alternate command interfaces like g++ might
3418            find it useful to place -xnone after each input file.  */
3419         spec_lang = 0;
3420       else
3421         last_language_n_infiles = n_infiles;
3422       do_save = false;
3423       break;
3424
3425     case OPT_o:
3426       have_o = 1;
3427 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3428       arg = convert_filename (arg, ! have_c, 0);
3429 #endif
3430       /* Save the output name in case -save-temps=obj was used.  */
3431       save_temps_prefix = xstrdup (arg);
3432       /* On some systems, ld cannot handle "-o" without a space.  So
3433          split the option from its argument.  */
3434       save_switch ("-o", 1, &arg, validated);
3435       return true;
3436
3437     case OPT_static_libgcc:
3438     case OPT_shared_libgcc:
3439     case OPT_static_libgfortran:
3440     case OPT_static_libstdc__:
3441       /* These are always valid, since gcc.c itself understands the
3442          first two, gfortranspec.c understands -static-libgfortran and
3443          g++spec.c understands -static-libstdc++ */
3444       validated = true;
3445       break;
3446
3447     default:
3448       /* Various driver options need no special processing at this
3449          point, having been handled in a prescan above or being
3450          handled by specs.  */
3451       break;
3452     }
3453
3454   if (do_save)
3455     save_switch (decoded->canonical_option[0],
3456                  decoded->canonical_option_num_elements - 1,
3457                  &decoded->canonical_option[1], validated);
3458   return true;
3459 }
3460
3461 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3462
3463 static void
3464 set_option_handlers (struct cl_option_handlers *handlers)
3465 {
3466   handlers->unknown_option_callback = driver_unknown_option_callback;
3467   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3468   handlers->post_handling_callback = driver_post_handling_callback;
3469   handlers->num_handlers = 1;
3470   handlers->handlers[0].handler = driver_handle_option;
3471   handlers->handlers[0].mask = CL_DRIVER;
3472 }
3473
3474 /* Create the vector `switches' and its contents.
3475    Store its length in `n_switches'.  */
3476
3477 static void
3478 process_command (unsigned int decoded_options_count,
3479                  struct cl_decoded_option *decoded_options)
3480 {
3481   const char *temp;
3482   char *temp1;
3483   const char *tooldir_prefix;
3484   char *(*get_relative_prefix) (const char *, const char *,
3485                                 const char *) = NULL;
3486   struct cl_option_handlers handlers;
3487   unsigned int j;
3488
3489   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3490
3491   n_switches = 0;
3492   n_infiles = 0;
3493   added_libraries = 0;
3494
3495   /* Figure compiler version from version string.  */
3496
3497   compiler_version = temp1 = xstrdup (version_string);
3498
3499   for (; *temp1; ++temp1)
3500     {
3501       if (*temp1 == ' ')
3502         {
3503           *temp1 = '\0';
3504           break;
3505         }
3506     }
3507
3508   /* Handle any -no-canonical-prefixes flag early, to assign the function
3509      that builds relative prefixes.  This function creates default search
3510      paths that are needed later in normal option handling.  */
3511
3512   for (j = 1; j < decoded_options_count; j++)
3513     {
3514       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3515         {
3516           get_relative_prefix = make_relative_prefix_ignore_links;
3517           break;
3518         }
3519     }
3520   if (! get_relative_prefix)
3521     get_relative_prefix = make_relative_prefix;
3522
3523   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3524      see if we can create it from the pathname specified in
3525      decoded_options[0].arg.  */
3526
3527   gcc_libexec_prefix = standard_libexec_prefix;
3528 #ifndef VMS
3529   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3530   if (!gcc_exec_prefix)
3531     {
3532       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3533                                              standard_bindir_prefix,
3534                                              standard_exec_prefix);
3535       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3536                                              standard_bindir_prefix,
3537                                              standard_libexec_prefix);
3538       if (gcc_exec_prefix)
3539         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3540     }
3541   else
3542     {
3543       /* make_relative_prefix requires a program name, but
3544          GCC_EXEC_PREFIX is typically a directory name with a trailing
3545          / (which is ignored by make_relative_prefix), so append a
3546          program name.  */
3547       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3548       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3549                                                 standard_exec_prefix,
3550                                                 standard_libexec_prefix);
3551
3552       /* The path is unrelocated, so fallback to the original setting.  */
3553       if (!gcc_libexec_prefix)
3554         gcc_libexec_prefix = standard_libexec_prefix;
3555
3556       free (tmp_prefix);
3557     }
3558 #else
3559 #endif
3560   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3561      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3562      or an automatically created GCC_EXEC_PREFIX from
3563      decoded_options[0].arg.  */
3564
3565   /* Do language-specific adjustment/addition of flags.  */
3566   lang_specific_driver (&decoded_options, &decoded_options_count,
3567                         &added_libraries);
3568
3569   if (gcc_exec_prefix)
3570     {
3571       int len = strlen (gcc_exec_prefix);
3572
3573       if (len > (int) sizeof ("/lib/gcc/") - 1
3574           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3575         {
3576           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3577           if (IS_DIR_SEPARATOR (*temp)
3578               && strncmp (temp + 1, "lib", 3) == 0
3579               && IS_DIR_SEPARATOR (temp[4])
3580               && strncmp (temp + 5, "gcc", 3) == 0)
3581             len -= sizeof ("/lib/gcc/") - 1;
3582         }
3583
3584       set_std_prefix (gcc_exec_prefix, len);
3585       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3586                   PREFIX_PRIORITY_LAST, 0, 0);
3587       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3588                   PREFIX_PRIORITY_LAST, 0, 0);
3589     }
3590
3591   /* COMPILER_PATH and LIBRARY_PATH have values
3592      that are lists of directory names with colons.  */
3593
3594   temp = getenv ("COMPILER_PATH");
3595   if (temp)
3596     {
3597       const char *startp, *endp;
3598       char *nstore = (char *) alloca (strlen (temp) + 3);
3599
3600       startp = endp = temp;
3601       while (1)
3602         {
3603           if (*endp == PATH_SEPARATOR || *endp == 0)
3604             {
3605               strncpy (nstore, startp, endp - startp);
3606               if (endp == startp)
3607                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3608               else if (!IS_DIR_SEPARATOR (endp[-1]))
3609                 {
3610                   nstore[endp - startp] = DIR_SEPARATOR;
3611                   nstore[endp - startp + 1] = 0;
3612                 }
3613               else
3614                 nstore[endp - startp] = 0;
3615               add_prefix (&exec_prefixes, nstore, 0,
3616                           PREFIX_PRIORITY_LAST, 0, 0);
3617               add_prefix (&include_prefixes, nstore, 0,
3618                           PREFIX_PRIORITY_LAST, 0, 0);
3619               if (*endp == 0)
3620                 break;
3621               endp = startp = endp + 1;
3622             }
3623           else
3624             endp++;
3625         }
3626     }
3627
3628   temp = getenv (LIBRARY_PATH_ENV);
3629   if (temp && *cross_compile == '0')
3630     {
3631       const char *startp, *endp;
3632       char *nstore = (char *) alloca (strlen (temp) + 3);
3633
3634       startp = endp = temp;
3635       while (1)
3636         {
3637           if (*endp == PATH_SEPARATOR || *endp == 0)
3638             {
3639               strncpy (nstore, startp, endp - startp);
3640               if (endp == startp)
3641                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3642               else if (!IS_DIR_SEPARATOR (endp[-1]))
3643                 {
3644                   nstore[endp - startp] = DIR_SEPARATOR;
3645                   nstore[endp - startp + 1] = 0;
3646                 }
3647               else
3648                 nstore[endp - startp] = 0;
3649               add_prefix (&startfile_prefixes, nstore, NULL,
3650                           PREFIX_PRIORITY_LAST, 0, 1);
3651               if (*endp == 0)
3652                 break;
3653               endp = startp = endp + 1;
3654             }
3655           else
3656             endp++;
3657         }
3658     }
3659
3660   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3661   temp = getenv ("LPATH");
3662   if (temp && *cross_compile == '0')
3663     {
3664       const char *startp, *endp;
3665       char *nstore = (char *) alloca (strlen (temp) + 3);
3666
3667       startp = endp = temp;
3668       while (1)
3669         {
3670           if (*endp == PATH_SEPARATOR || *endp == 0)
3671             {
3672               strncpy (nstore, startp, endp - startp);
3673               if (endp == startp)
3674                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3675               else if (!IS_DIR_SEPARATOR (endp[-1]))
3676                 {
3677                   nstore[endp - startp] = DIR_SEPARATOR;
3678                   nstore[endp - startp + 1] = 0;
3679                 }
3680               else
3681                 nstore[endp - startp] = 0;
3682               add_prefix (&startfile_prefixes, nstore, NULL,
3683                           PREFIX_PRIORITY_LAST, 0, 1);
3684               if (*endp == 0)
3685                 break;
3686               endp = startp = endp + 1;
3687             }
3688           else
3689             endp++;
3690         }
3691     }
3692
3693   /* Process the options and store input files and switches in their
3694      vectors.  */
3695
3696   last_language_n_infiles = -1;
3697
3698   set_option_handlers (&handlers);
3699
3700   for (j = 1; j < decoded_options_count; j++)
3701     {
3702       switch (decoded_options[j].opt_index)
3703         {
3704         case OPT_S:
3705         case OPT_c:
3706         case OPT_E:
3707           have_c = 1;
3708           break;
3709         }
3710       if (have_c)
3711         break;
3712     }
3713
3714   for (j = 1; j < decoded_options_count; j++)
3715     {
3716       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3717         {
3718           const char *arg = decoded_options[j].arg;
3719           const char *p = strrchr (arg, '@');
3720           char *fname;
3721           long offset;
3722           int consumed;
3723 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3724           arg = convert_filename (arg, 0, access (arg, F_OK));
3725 #endif
3726           /* For LTO static archive support we handle input file
3727              specifications that are composed of a filename and
3728              an offset like FNAME@OFFSET.  */
3729           if (p
3730               && p != arg
3731               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3732               && strlen (p) == (unsigned int)consumed)
3733             {
3734               fname = (char *)xmalloc (p - arg + 1);
3735               memcpy (fname, arg, p - arg);
3736               fname[p - arg] = '\0';
3737               /* Only accept non-stdin and existing FNAME parts, otherwise
3738                  try with the full name.  */
3739               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3740                 {
3741                   free (fname);
3742                   fname = xstrdup (arg);
3743                 }
3744             }
3745           else
3746             fname = xstrdup (arg);
3747  
3748           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3749             perror_with_name (fname);
3750           else
3751             add_infile (arg, spec_lang);
3752
3753           free (fname);
3754           continue;
3755         }
3756
3757       read_cmdline_option (&global_options, &global_options_set,
3758                            decoded_options + j, UNKNOWN_LOCATION,
3759                            CL_DRIVER, &handlers, global_dc);
3760     }
3761
3762   /* If -save-temps=obj and -o name, create the prefix to use for %b.
3763      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
3764   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3765     {
3766       save_temps_length = strlen (save_temps_prefix);
3767       temp = strrchr (lbasename (save_temps_prefix), '.');
3768       if (temp)
3769         {
3770           save_temps_length -= strlen (temp);
3771           save_temps_prefix[save_temps_length] = '\0';
3772         }
3773
3774     }
3775   else if (save_temps_prefix != NULL)
3776     {
3777       free (save_temps_prefix);
3778       save_temps_prefix = NULL;
3779     }
3780
3781   if (save_temps_flag && use_pipes)
3782     {
3783       /* -save-temps overrides -pipe, so that temp files are produced */
3784       if (save_temps_flag)
3785         warning (0, "-pipe ignored because -save-temps specified");
3786       use_pipes = 0;
3787     }
3788
3789   if (!compare_debug)
3790     {
3791       const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3792
3793       if (gcd && gcd[0] == '-')
3794         {
3795           compare_debug = 2;
3796           compare_debug_opt = gcd;
3797         }
3798       else if (gcd && *gcd && strcmp (gcd, "0"))
3799         {
3800           compare_debug = 3;
3801           compare_debug_opt = "-gtoggle";
3802         }
3803     }
3804   else if (compare_debug < 0)
3805     {
3806       compare_debug = 0;
3807       gcc_assert (!compare_debug_opt);
3808     }
3809
3810   /* Set up the search paths.  We add directories that we expect to
3811      contain GNU Toolchain components before directories specified by
3812      the machine description so that we will find GNU components (like
3813      the GNU assembler) before those of the host system.  */
3814
3815   /* If we don't know where the toolchain has been installed, use the
3816      configured-in locations.  */
3817   if (!gcc_exec_prefix)
3818     {
3819 #ifndef OS2
3820       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3821                   PREFIX_PRIORITY_LAST, 1, 0);
3822       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3823                   PREFIX_PRIORITY_LAST, 2, 0);
3824       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3825                   PREFIX_PRIORITY_LAST, 2, 0);
3826 #endif
3827       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3828                   PREFIX_PRIORITY_LAST, 1, 0);
3829     }
3830
3831   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
3832   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3833                            dir_separator_str, NULL);
3834
3835   /* Look for tools relative to the location from which the driver is
3836      running, or, if that is not available, the configured prefix.  */
3837   tooldir_prefix
3838     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
3839               spec_machine, dir_separator_str,
3840               spec_version, dir_separator_str, tooldir_prefix, NULL);
3841
3842   add_prefix (&exec_prefixes,
3843               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3844               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3845   add_prefix (&startfile_prefixes,
3846               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3847               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3848
3849 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3850   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3851      then consider it to relocate with the rest of the GCC installation
3852      if GCC_EXEC_PREFIX is set.
3853      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3854   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
3855     {
3856       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
3857                                               standard_bindir_prefix,
3858                                               target_system_root);
3859       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3860         {
3861           target_system_root = tmp_prefix;
3862           target_system_root_changed = 1;
3863         }
3864     }
3865 #endif
3866
3867   /* More prefixes are enabled in main, after we read the specs file
3868      and determine whether this is cross-compilation or not.  */
3869
3870   if (n_infiles == last_language_n_infiles && spec_lang != 0)
3871     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
3872
3873   if (compare_debug == 2 || compare_debug == 3)
3874     {
3875       alloc_switch ();
3876       switches[n_switches].part1 = concat ("fcompare-debug=",
3877                                            compare_debug_opt,
3878                                            NULL);
3879       switches[n_switches].args = 0;
3880       switches[n_switches].live_cond = 0;
3881       switches[n_switches].validated = 0;
3882       switches[n_switches].ordering = 0;
3883       n_switches++;
3884       compare_debug = 1;
3885     }
3886
3887   /* Ensure we only invoke each subprocess once.  */
3888   if (print_subprocess_help || print_help_list || print_version)
3889     {
3890       n_infiles = 0;
3891
3892       /* Create a dummy input file, so that we can pass
3893          the help option on to the various sub-processes.  */
3894       add_infile ("help-dummy", "c");
3895     }
3896
3897   alloc_switch ();
3898   switches[n_switches].part1 = 0;
3899   alloc_infile ();
3900   infiles[n_infiles].name = 0;
3901 }
3902
3903 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
3904    and place that in the environment.  */
3905
3906 static void
3907 set_collect_gcc_options (void)
3908 {
3909   int i;
3910   int first_time;
3911
3912   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3913      the compiler.  */
3914   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
3915                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
3916
3917   first_time = TRUE;
3918   for (i = 0; (int) i < n_switches; i++)
3919     {
3920       const char *const *args;
3921       const char *p, *q;
3922       if (!first_time)
3923         obstack_grow (&collect_obstack, " ", 1);
3924
3925       first_time = FALSE;
3926
3927       /* Ignore elided switches.  */
3928       if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
3929         continue;
3930
3931       obstack_grow (&collect_obstack, "'-", 2);
3932       q = switches[i].part1;
3933       while ((p = strchr (q, '\'')))
3934         {
3935           obstack_grow (&collect_obstack, q, p - q);
3936           obstack_grow (&collect_obstack, "'\\''", 4);
3937           q = ++p;
3938         }
3939       obstack_grow (&collect_obstack, q, strlen (q));
3940       obstack_grow (&collect_obstack, "'", 1);
3941
3942       for (args = switches[i].args; args && *args; args++)
3943         {
3944           obstack_grow (&collect_obstack, " '", 2);
3945           q = *args;
3946           while ((p = strchr (q, '\'')))
3947             {
3948               obstack_grow (&collect_obstack, q, p - q);
3949               obstack_grow (&collect_obstack, "'\\''", 4);
3950               q = ++p;
3951             }
3952           obstack_grow (&collect_obstack, q, strlen (q));
3953           obstack_grow (&collect_obstack, "'", 1);
3954         }
3955     }
3956   obstack_grow (&collect_obstack, "\0", 1);
3957   xputenv (XOBFINISH (&collect_obstack, char *));
3958 }
3959 \f
3960 /* Process a spec string, accumulating and running commands.  */
3961
3962 /* These variables describe the input file name.
3963    input_file_number is the index on outfiles of this file,
3964    so that the output file name can be stored for later use by %o.
3965    input_basename is the start of the part of the input file
3966    sans all directory names, and basename_length is the number
3967    of characters starting there excluding the suffix .c or whatever.  */
3968
3969 static const char *gcc_input_filename;
3970 static int input_file_number;
3971 size_t input_filename_length;
3972 static int basename_length;
3973 static int suffixed_basename_length;
3974 static const char *input_basename;
3975 static const char *input_suffix;
3976 #ifndef HOST_LACKS_INODE_NUMBERS
3977 static struct stat input_stat;
3978 #endif
3979 static int input_stat_set;
3980
3981 /* The compiler used to process the current input file.  */
3982 static struct compiler *input_file_compiler;
3983
3984 /* These are variables used within do_spec and do_spec_1.  */
3985
3986 /* Nonzero if an arg has been started and not yet terminated
3987    (with space, tab or newline).  */
3988 static int arg_going;
3989
3990 /* Nonzero means %d or %g has been seen; the next arg to be terminated
3991    is a temporary file name.  */
3992 static int delete_this_arg;
3993
3994 /* Nonzero means %w has been seen; the next arg to be terminated
3995    is the output file name of this compilation.  */
3996 static int this_is_output_file;
3997
3998 /* Nonzero means %s has been seen; the next arg to be terminated
3999    is the name of a library file and we should try the standard
4000    search dirs for it.  */
4001 static int this_is_library_file;
4002
4003 /* Nonzero means %T has been seen; the next arg to be terminated
4004    is the name of a linker script and we should try all of the
4005    standard search dirs for it.  If it is found insert a --script
4006    command line switch and then substitute the full path in place,
4007    otherwise generate an error message.  */
4008 static int this_is_linker_script;
4009
4010 /* Nonzero means that the input of this command is coming from a pipe.  */
4011 static int input_from_pipe;
4012
4013 /* Nonnull means substitute this for any suffix when outputting a switches
4014    arguments.  */
4015 static const char *suffix_subst;
4016
4017 /* If there is an argument being accumulated, terminate it and store it.  */
4018
4019 static void
4020 end_going_arg (void)
4021 {
4022   if (arg_going)
4023     {
4024       const char *string;
4025
4026       obstack_1grow (&obstack, 0);
4027       string = XOBFINISH (&obstack, const char *);
4028       if (this_is_library_file)
4029         string = find_file (string);
4030       if (this_is_linker_script)
4031         {
4032           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4033
4034           if (full_script_path == NULL)
4035             {
4036               error ("unable to locate default linker script %qs in the library search paths", string);
4037               /* Script was not found on search path.  */
4038               return;
4039             }
4040           store_arg ("--script", false, false);
4041           string = full_script_path;
4042         }
4043       store_arg (string, delete_this_arg, this_is_output_file);
4044       if (this_is_output_file)
4045         outfiles[input_file_number] = string;
4046       arg_going = 0;
4047     }
4048 }
4049
4050
4051 /* Parse the WRAPPER string which is a comma separated list of the command line
4052    and insert them into the beginning of argbuf.  */
4053
4054 static void
4055 insert_wrapper (const char *wrapper)
4056 {
4057   int n = 0;
4058   int i;
4059   char *buf = xstrdup (wrapper);
4060   char *p = buf;
4061   unsigned int old_length = VEC_length (const_char_p, argbuf);
4062
4063   do
4064     {
4065       n++;
4066       while (*p == ',')
4067         p++;
4068     }
4069   while ((p = strchr (p, ',')) != NULL);
4070
4071   VEC_safe_grow (const_char_p, heap, argbuf, old_length + n);
4072   memmove (VEC_address (const_char_p, argbuf) + n,
4073            VEC_address (const_char_p, argbuf),
4074            old_length * sizeof (const_char_p));
4075
4076   i = 0;
4077   p = buf;
4078   do
4079     {
4080       while (*p == ',')
4081         {
4082           *p = 0;
4083           p++;
4084         }
4085       VEC_replace (const_char_p, argbuf, i, p);
4086       i++;
4087     }
4088   while ((p = strchr (p, ',')) != NULL);
4089   gcc_assert (i == n);
4090 }
4091
4092 /* Process the spec SPEC and run the commands specified therein.
4093    Returns 0 if the spec is successfully processed; -1 if failed.  */
4094
4095 int
4096 do_spec (const char *spec)
4097 {
4098   int value;
4099
4100   value = do_spec_2 (spec);
4101
4102   /* Force out any unfinished command.
4103      If -pipe, this forces out the last command if it ended in `|'.  */
4104   if (value == 0)
4105     {
4106       if (VEC_length (const_char_p, argbuf) > 0
4107           && !strcmp (VEC_last (const_char_p, argbuf), "|"))
4108         VEC_pop (const_char_p, argbuf);
4109
4110       set_collect_gcc_options ();
4111
4112       if (VEC_length (const_char_p, argbuf) > 0)
4113         value = execute ();
4114     }
4115
4116   return value;
4117 }
4118
4119 static int
4120 do_spec_2 (const char *spec)
4121 {
4122   int result;
4123
4124   clear_args ();
4125   arg_going = 0;
4126   delete_this_arg = 0;
4127   this_is_output_file = 0;
4128   this_is_library_file = 0;
4129   this_is_linker_script = 0;
4130   input_from_pipe = 0;
4131   suffix_subst = NULL;
4132
4133   result = do_spec_1 (spec, 0, NULL);
4134
4135   end_going_arg ();
4136
4137   return result;
4138 }
4139
4140
4141 /* Process the given spec string and add any new options to the end
4142    of the switches/n_switches array.  */
4143
4144 static void
4145 do_option_spec (const char *name, const char *spec)
4146 {
4147   unsigned int i, value_count, value_len;
4148   const char *p, *q, *value;
4149   char *tmp_spec, *tmp_spec_p;
4150
4151   if (configure_default_options[0].name == NULL)
4152     return;
4153
4154   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4155     if (strcmp (configure_default_options[i].name, name) == 0)
4156       break;
4157   if (i == ARRAY_SIZE (configure_default_options))
4158     return;
4159
4160   value = configure_default_options[i].value;
4161   value_len = strlen (value);
4162
4163   /* Compute the size of the final spec.  */
4164   value_count = 0;
4165   p = spec;
4166   while ((p = strstr (p, "%(VALUE)")) != NULL)
4167     {
4168       p ++;
4169       value_count ++;
4170     }
4171
4172   /* Replace each %(VALUE) by the specified value.  */
4173   tmp_spec = (char *) alloca (strlen (spec) + 1
4174                      + value_count * (value_len - strlen ("%(VALUE)")));
4175   tmp_spec_p = tmp_spec;
4176   q = spec;
4177   while ((p = strstr (q, "%(VALUE)")) != NULL)
4178     {
4179       memcpy (tmp_spec_p, q, p - q);
4180       tmp_spec_p = tmp_spec_p + (p - q);
4181       memcpy (tmp_spec_p, value, value_len);
4182       tmp_spec_p += value_len;
4183       q = p + strlen ("%(VALUE)");
4184     }
4185   strcpy (tmp_spec_p, q);
4186
4187   do_self_spec (tmp_spec);
4188 }
4189
4190 /* Process the given spec string and add any new options to the end
4191    of the switches/n_switches array.  */
4192
4193 static void
4194 do_self_spec (const char *spec)
4195 {
4196   int i;
4197
4198   do_spec_2 (spec);
4199   do_spec_1 (" ", 0, NULL);
4200
4201   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4202      do_self_specs adds the replacements to switches array, so it shouldn't
4203      be processed afterwards.  */
4204   for (i = 0; i < n_switches; i++)
4205     if ((switches[i].live_cond & SWITCH_IGNORE))
4206       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4207
4208   if (VEC_length (const_char_p, argbuf) > 0)
4209     {
4210       const char **argbuf_copy;
4211       struct cl_decoded_option *decoded_options;
4212       struct cl_option_handlers handlers;
4213       unsigned int decoded_options_count;
4214       unsigned int j;
4215
4216       /* Create a copy of argbuf with a dummy argv[0] entry for
4217          decode_cmdline_options_to_array.  */
4218       argbuf_copy = XNEWVEC (const char *,
4219                              VEC_length (const_char_p, argbuf) + 1);