OSDN Git Service

* gcc.c (LINK_COMMAND_SPEC): Don't handle -A, -d or -m.
[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*} %{e*} %{N} %{n} %{r}\
645     %{s} %{t} %{u*} %{z} %{Z} %{!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     %{!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|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   {".go", "#Go", 0, 1, 0},
900   /* Next come the entries for C.  */
901   {".c", "@c", 0, 0, 1},
902   {"@c",
903    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
904       external preprocessor if -save-temps is given.  */
905      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
906       %{!E:%{!M:%{!MM:\
907           %{traditional:\
908 %eGNU C no longer supports -traditional without -E}\
909       %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
910           %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
911             cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
912           %(cc1_options)}\
913       %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
914           cc1 %(cpp_unique_options) %(cc1_options)}}}\
915       %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
916   {"-",
917    "%{!E:%e-E or -x required when input is from standard input}\
918     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
919   {".h", "@c-header", 0, 0, 0},
920   {"@c-header",
921    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
922       external preprocessor if -save-temps is given.  */
923      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
924       %{!E:%{!M:%{!MM:\
925           %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
926                 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
927                     cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
928                         %(cc1_options)\
929                         %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
930                         %W{o*:--output-pch=%*}}%V}\
931           %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
932                 cc1 %(cpp_unique_options) %(cc1_options)\
933                     %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
934                     %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
935   {".i", "@cpp-output", 0, 0, 0},
936   {"@cpp-output",
937    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
938   {".s", "@assembler", 0, 1, 0},
939   {"@assembler",
940    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
941   {".sx", "@assembler-with-cpp", 0, 1, 0},
942   {".S", "@assembler-with-cpp", 0, 1, 0},
943   {"@assembler-with-cpp",
944 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
945    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
946       %{E|M|MM:%(cpp_debug_options)}\
947       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
948        as %(asm_debug) %(asm_options) %|.s %A }}}}"
949 #else
950    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
951       %{E|M|MM:%(cpp_debug_options)}\
952       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
953        as %(asm_debug) %(asm_options) %m.s %A }}}}"
954 #endif
955    , 0, 1, 0},
956
957 #include "specs.h"
958   /* Mark end of table.  */
959   {0, 0, 0, 0, 0}
960 };
961
962 /* Number of elements in default_compilers, not counting the terminator.  */
963
964 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
965
966 typedef char *char_p; /* For DEF_VEC_P.  */
967 DEF_VEC_P(char_p);
968 DEF_VEC_ALLOC_P(char_p,heap);
969
970 /* A vector of options to give to the linker.
971    These options are accumulated by %x,
972    and substituted into the linker command with %X.  */
973 static VEC(char_p,heap) *linker_options;
974
975 /* A vector of options to give to the assembler.
976    These options are accumulated by -Wa,
977    and substituted into the assembler command with %Y.  */
978 static VEC(char_p,heap) *assembler_options;
979
980 /* A vector of options to give to the preprocessor.
981    These options are accumulated by -Wp,
982    and substituted into the preprocessor command with %Z.  */
983 static VEC(char_p,heap) *preprocessor_options;
984 \f
985 static char *
986 skip_whitespace (char *p)
987 {
988   while (1)
989     {
990       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
991          be considered whitespace.  */
992       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
993         return p + 1;
994       else if (*p == '\n' || *p == ' ' || *p == '\t')
995         p++;
996       else if (*p == '#')
997         {
998           while (*p != '\n')
999             p++;
1000           p++;
1001         }
1002       else
1003         break;
1004     }
1005
1006   return p;
1007 }
1008 /* Structures to keep track of prefixes to try when looking for files.  */
1009
1010 struct prefix_list
1011 {
1012   const char *prefix;         /* String to prepend to the path.  */
1013   struct prefix_list *next;   /* Next in linked list.  */
1014   int require_machine_suffix; /* Don't use without machine_suffix.  */
1015   /* 2 means try both machine_suffix and just_machine_suffix.  */
1016   int priority;               /* Sort key - priority within list.  */
1017   int os_multilib;            /* 1 if OS multilib scheme should be used,
1018                                  0 for GCC multilib scheme.  */
1019 };
1020
1021 struct path_prefix
1022 {
1023   struct prefix_list *plist;  /* List of prefixes to try */
1024   int max_len;                /* Max length of a prefix in PLIST */
1025   const char *name;           /* Name of this list (used in config stuff) */
1026 };
1027
1028 /* List of prefixes to try when looking for executables.  */
1029
1030 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1031
1032 /* List of prefixes to try when looking for startup (crt0) files.  */
1033
1034 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1035
1036 /* List of prefixes to try when looking for include files.  */
1037
1038 static struct path_prefix include_prefixes = { 0, 0, "include" };
1039
1040 /* Suffix to attach to directories searched for commands.
1041    This looks like `MACHINE/VERSION/'.  */
1042
1043 static const char *machine_suffix = 0;
1044
1045 /* Suffix to attach to directories searched for commands.
1046    This is just `MACHINE/'.  */
1047
1048 static const char *just_machine_suffix = 0;
1049
1050 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1051
1052 static const char *gcc_exec_prefix;
1053
1054 /* Adjusted value of standard_libexec_prefix.  */
1055
1056 static const char *gcc_libexec_prefix;
1057
1058 /* Default prefixes to attach to command names.  */
1059
1060 #ifndef STANDARD_STARTFILE_PREFIX_1
1061 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1062 #endif
1063 #ifndef STANDARD_STARTFILE_PREFIX_2
1064 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1065 #endif
1066
1067 #ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
1068 #undef MD_EXEC_PREFIX
1069 #undef MD_STARTFILE_PREFIX
1070 #undef MD_STARTFILE_PREFIX_1
1071 #endif
1072
1073 /* If no prefixes defined, use the null string, which will disable them.  */
1074 #ifndef MD_EXEC_PREFIX
1075 #define MD_EXEC_PREFIX ""
1076 #endif
1077 #ifndef MD_STARTFILE_PREFIX
1078 #define MD_STARTFILE_PREFIX ""
1079 #endif
1080 #ifndef MD_STARTFILE_PREFIX_1
1081 #define MD_STARTFILE_PREFIX_1 ""
1082 #endif
1083
1084 /* These directories are locations set at configure-time based on the
1085    --prefix option provided to configure.  Their initializers are
1086    defined in Makefile.in.  These paths are not *directly* used when
1087    gcc_exec_prefix is set because, in that case, we know where the
1088    compiler has been installed, and use paths relative to that
1089    location instead.  */
1090 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1091 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1092 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1093 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1094
1095 /* For native compilers, these are well-known paths containing
1096    components that may be provided by the system.  For cross
1097    compilers, these paths are not used.  */
1098 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1099 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1100 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1101 static const char *const standard_startfile_prefix_1
1102   = STANDARD_STARTFILE_PREFIX_1;
1103 static const char *const standard_startfile_prefix_2
1104   = STANDARD_STARTFILE_PREFIX_2;
1105
1106 /* A relative path to be used in finding the location of tools
1107    relative to the driver.  */
1108 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1109
1110 /* Subdirectory to use for locating libraries.  Set by
1111    set_multilib_dir based on the compilation options.  */
1112
1113 static const char *multilib_dir;
1114
1115 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1116    set_multilib_dir based on the compilation options.  */
1117
1118 static const char *multilib_os_dir;
1119 \f
1120 /* Structure to keep track of the specs that have been defined so far.
1121    These are accessed using %(specname) or %[specname] in a compiler
1122    or link spec.  */
1123
1124 struct spec_list
1125 {
1126                                 /* The following 2 fields must be first */
1127                                 /* to allow EXTRA_SPECS to be initialized */
1128   const char *name;             /* name of the spec.  */
1129   const char *ptr;              /* available ptr if no static pointer */
1130
1131                                 /* The following fields are not initialized */
1132                                 /* by EXTRA_SPECS */
1133   const char **ptr_spec;        /* pointer to the spec itself.  */
1134   struct spec_list *next;       /* Next spec in linked list.  */
1135   int name_len;                 /* length of the name */
1136   int alloc_p;                  /* whether string was allocated */
1137 };
1138
1139 #define INIT_STATIC_SPEC(NAME,PTR) \
1140 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1141
1142 /* List of statically defined specs.  */
1143 static struct spec_list static_specs[] =
1144 {
1145   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1146   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1147   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1148   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1149   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1150   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1151   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1152   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1153   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1154   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1155   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1156   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1157   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1158   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1159   INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1160   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1161   INIT_STATIC_SPEC ("link",                     &link_spec),
1162   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1163   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1164   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1165   INIT_STATIC_SPEC ("link_gomp",                &link_gomp_spec),
1166   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1167   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1168   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1169   INIT_STATIC_SPEC ("version",                  &compiler_version),
1170   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1171   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1172   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1173   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1174   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1175   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1176   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1177   INIT_STATIC_SPEC ("linker_plugin_file",       &linker_plugin_file_spec),
1178   INIT_STATIC_SPEC ("lto_wrapper",              &lto_wrapper_spec),
1179   INIT_STATIC_SPEC ("lto_gcc",                  &lto_gcc_spec),
1180   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1181   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1182   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1183   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1184   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1185   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1186   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1187   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1188 };
1189
1190 #ifdef EXTRA_SPECS              /* additional specs needed */
1191 /* Structure to keep track of just the first two args of a spec_list.
1192    That is all that the EXTRA_SPECS macro gives us.  */
1193 struct spec_list_1
1194 {
1195   const char *const name;
1196   const char *const ptr;
1197 };
1198
1199 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1200 static struct spec_list *extra_specs = (struct spec_list *) 0;
1201 #endif
1202
1203 /* List of dynamically allocates specs that have been defined so far.  */
1204
1205 static struct spec_list *specs = (struct spec_list *) 0;
1206 \f
1207 /* List of static spec functions.  */
1208
1209 static const struct spec_function static_spec_functions[] =
1210 {
1211   { "getenv",                   getenv_spec_function },
1212   { "if-exists",                if_exists_spec_function },
1213   { "if-exists-else",           if_exists_else_spec_function },
1214   { "replace-outfile",          replace_outfile_spec_function },
1215   { "remove-outfile",           remove_outfile_spec_function },
1216   { "version-compare",          version_compare_spec_function },
1217   { "include",                  include_spec_function },
1218   { "find-file",                find_file_spec_function },
1219   { "find-plugindir",           find_plugindir_spec_function },
1220   { "print-asm-header",         print_asm_header_spec_function },
1221   { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1222   { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1223   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1224   { "pass-through-libs",        pass_through_libs_spec_func },
1225 #ifdef EXTRA_SPEC_FUNCTIONS
1226   EXTRA_SPEC_FUNCTIONS
1227 #endif
1228   { 0, 0 }
1229 };
1230
1231 static int processing_spec_function;
1232 \f
1233 /* Add appropriate libgcc specs to OBSTACK, taking into account
1234    various permutations of -shared-libgcc, -shared, and such.  */
1235
1236 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1237
1238 #ifndef USE_LD_AS_NEEDED
1239 #define USE_LD_AS_NEEDED 0
1240 #endif
1241
1242 static void
1243 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1244                 const char *static_name, const char *eh_name)
1245 {
1246   char *buf;
1247
1248   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1249                 "%{!static:%{!static-libgcc:"
1250 #if USE_LD_AS_NEEDED
1251                 "%{!shared-libgcc:",
1252                 static_name, " --as-needed ", shared_name, " --no-as-needed"
1253                 "}"
1254                 "%{shared-libgcc:",
1255                 shared_name, "%{!shared: ", static_name, "}"
1256                 "}"
1257 #else
1258                 "%{!shared:"
1259                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1260                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1261                 "}"
1262 #ifdef LINK_EH_SPEC
1263                 "%{shared:"
1264                 "%{shared-libgcc:", shared_name, "}"
1265                 "%{!shared-libgcc:", static_name, "}"
1266                 "}"
1267 #else
1268                 "%{shared:", shared_name, "}"
1269 #endif
1270 #endif
1271                 "}}", NULL);
1272
1273   obstack_grow (obstack, buf, strlen (buf));
1274   free (buf);
1275 }
1276 #endif /* ENABLE_SHARED_LIBGCC */
1277
1278 /* Initialize the specs lookup routines.  */
1279
1280 static void
1281 init_spec (void)
1282 {
1283   struct spec_list *next = (struct spec_list *) 0;
1284   struct spec_list *sl   = (struct spec_list *) 0;
1285   int i;
1286
1287   if (specs)
1288     return;                     /* Already initialized.  */
1289
1290   if (verbose_flag)
1291     fnotice (stderr, "Using built-in specs.\n");
1292
1293 #ifdef EXTRA_SPECS
1294   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1295
1296   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1297     {
1298       sl = &extra_specs[i];
1299       sl->name = extra_specs_1[i].name;
1300       sl->ptr = extra_specs_1[i].ptr;
1301       sl->next = next;
1302       sl->name_len = strlen (sl->name);
1303       sl->ptr_spec = &sl->ptr;
1304       next = sl;
1305     }
1306 #endif
1307
1308   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1309     {
1310       sl = &static_specs[i];
1311       sl->next = next;
1312       next = sl;
1313     }
1314
1315 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1316   /* ??? If neither -shared-libgcc nor --static-libgcc was
1317      seen, then we should be making an educated guess.  Some proposed
1318      heuristics for ELF include:
1319
1320         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1321             program will be doing dynamic loading, which will likely
1322             need the shared libgcc.
1323
1324         (2) If "-ldl", then it's also a fair bet that we're doing
1325             dynamic loading.
1326
1327         (3) For each ET_DYN we're linking against (either through -lfoo
1328             or /some/path/foo.so), check to see whether it or one of
1329             its dependencies depends on a shared libgcc.
1330
1331         (4) If "-shared"
1332
1333             If the runtime is fixed to look for program headers instead
1334             of calling __register_frame_info at all, for each object,
1335             use the shared libgcc if any EH symbol referenced.
1336
1337             If crtstuff is fixed to not invoke __register_frame_info
1338             automatically, for each object, use the shared libgcc if
1339             any non-empty unwind section found.
1340
1341      Doing any of this probably requires invoking an external program to
1342      do the actual object file scanning.  */
1343   {
1344     const char *p = libgcc_spec;
1345     int in_sep = 1;
1346
1347     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1348        when given the proper command line arguments.  */
1349     while (*p)
1350       {
1351         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1352           {
1353             init_gcc_specs (&obstack,
1354                             "-lgcc_s"
1355 #ifdef USE_LIBUNWIND_EXCEPTIONS
1356                             " -lunwind"
1357 #endif
1358                             ,
1359                             "-lgcc",
1360                             "-lgcc_eh"
1361 #ifdef USE_LIBUNWIND_EXCEPTIONS
1362 # ifdef HAVE_LD_STATIC_DYNAMIC
1363                             " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1364 # else
1365                             " -lunwind"
1366 # endif
1367 #endif
1368                             );
1369
1370             p += 5;
1371             in_sep = 0;
1372           }
1373         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1374           {
1375             /* Ug.  We don't know shared library extensions.  Hope that
1376                systems that use this form don't do shared libraries.  */
1377             init_gcc_specs (&obstack,
1378                             "-lgcc_s",
1379                             "libgcc.a%s",
1380                             "libgcc_eh.a%s"
1381 #ifdef USE_LIBUNWIND_EXCEPTIONS
1382                             " -lunwind"
1383 #endif
1384                             );
1385             p += 10;
1386             in_sep = 0;
1387           }
1388         else
1389           {
1390             obstack_1grow (&obstack, *p);
1391             in_sep = (*p == ' ');
1392             p += 1;
1393           }
1394       }
1395
1396     obstack_1grow (&obstack, '\0');
1397     libgcc_spec = XOBFINISH (&obstack, const char *);
1398   }
1399 #endif
1400 #ifdef USE_AS_TRADITIONAL_FORMAT
1401   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1402   {
1403     static const char tf[] = "--traditional-format ";
1404     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1405     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1406     asm_spec = XOBFINISH (&obstack, const char *);
1407   }
1408 #endif
1409
1410 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1411 # ifdef LINK_BUILDID_SPEC
1412   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1413   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1414 # endif
1415 # ifdef LINK_EH_SPEC
1416   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1417   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1418 # endif
1419   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1420   link_spec = XOBFINISH (&obstack, const char *);
1421 #endif
1422
1423   specs = sl;
1424 }
1425 \f
1426 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1427    removed; If the spec starts with a + then SPEC is added to the end of the
1428    current spec.  */
1429
1430 static void
1431 set_spec (const char *name, const char *spec)
1432 {
1433   struct spec_list *sl;
1434   const char *old_spec;
1435   int name_len = strlen (name);
1436   int i;
1437
1438   /* If this is the first call, initialize the statically allocated specs.  */
1439   if (!specs)
1440     {
1441       struct spec_list *next = (struct spec_list *) 0;
1442       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1443         {
1444           sl = &static_specs[i];
1445           sl->next = next;
1446           next = sl;
1447         }
1448       specs = sl;
1449     }
1450
1451   /* See if the spec already exists.  */
1452   for (sl = specs; sl; sl = sl->next)
1453     if (name_len == sl->name_len && !strcmp (sl->name, name))
1454       break;
1455
1456   if (!sl)
1457     {
1458       /* Not found - make it.  */
1459       sl = XNEW (struct spec_list);
1460       sl->name = xstrdup (name);
1461       sl->name_len = name_len;
1462       sl->ptr_spec = &sl->ptr;
1463       sl->alloc_p = 0;
1464       *(sl->ptr_spec) = "";
1465       sl->next = specs;
1466       specs = sl;
1467     }
1468
1469   old_spec = *(sl->ptr_spec);
1470   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1471                      ? concat (old_spec, spec + 1, NULL)
1472                      : xstrdup (spec));
1473
1474 #ifdef DEBUG_SPECS
1475   if (verbose_flag)
1476     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1477 #endif
1478
1479   /* Free the old spec.  */
1480   if (old_spec && sl->alloc_p)
1481     free (CONST_CAST(char *, old_spec));
1482
1483   sl->alloc_p = 1;
1484 }
1485 \f
1486 /* Accumulate a command (program name and args), and run it.  */
1487
1488 typedef const char *const_char_p; /* For DEF_VEC_P.  */
1489 DEF_VEC_P(const_char_p);
1490 DEF_VEC_ALLOC_P(const_char_p,heap);
1491
1492 /* Vector of pointers to arguments in the current line of specifications.  */
1493
1494 static VEC(const_char_p,heap) *argbuf;
1495
1496 /* Position in the argbuf vector containing the name of the output file
1497    (the value associated with the "-o" flag).  */
1498
1499 static int have_o_argbuf_index = 0;
1500
1501 /* Were the options -c, -S or -E passed.  */
1502 static int have_c = 0;
1503
1504 /* Was the option -o passed.  */
1505 static int have_o = 0;
1506
1507 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1508    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1509    it here.  */
1510
1511 static struct temp_name {
1512   const char *suffix;   /* suffix associated with the code.  */
1513   int length;           /* strlen (suffix).  */
1514   int unique;           /* Indicates whether %g or %u/%U was used.  */
1515   const char *filename; /* associated filename.  */
1516   int filename_length;  /* strlen (filename).  */
1517   struct temp_name *next;
1518 } *temp_names;
1519
1520 /* Number of commands executed so far.  */
1521
1522 static int execution_count;
1523
1524 /* Number of commands that exited with a signal.  */
1525
1526 static int signal_count;
1527 \f
1528 /* Allocate the argument vector.  */
1529
1530 static void
1531 alloc_args (void)
1532 {
1533   argbuf = VEC_alloc (const_char_p, heap, 10);
1534 }
1535
1536 /* Clear out the vector of arguments (after a command is executed).  */
1537
1538 static void
1539 clear_args (void)
1540 {
1541   VEC_truncate (const_char_p, argbuf, 0);
1542 }
1543
1544 /* Add one argument to the vector at the end.
1545    This is done when a space is seen or at the end of the line.
1546    If DELETE_ALWAYS is nonzero, the arg is a filename
1547     and the file should be deleted eventually.
1548    If DELETE_FAILURE is nonzero, the arg is a filename
1549     and the file should be deleted if this compilation fails.  */
1550
1551 static void
1552 store_arg (const char *arg, int delete_always, int delete_failure)
1553 {
1554   VEC_safe_push (const_char_p, heap, argbuf, arg);
1555
1556   if (strcmp (arg, "-o") == 0)
1557     have_o_argbuf_index = VEC_length (const_char_p, argbuf);
1558   if (delete_always || delete_failure)
1559     {
1560       const char *p;
1561       /* If the temporary file we should delete is specified as
1562          part of a joined argument extract the filename.  */
1563       if (arg[0] == '-'
1564           && (p = strrchr (arg, '=')))
1565         arg = p + 1;
1566       record_temp_file (arg, delete_always, delete_failure);
1567     }
1568 }
1569 \f
1570 /* Load specs from a file name named FILENAME, replacing occurrences of
1571    various different types of line-endings, \r\n, \n\r and just \r, with
1572    a single \n.  */
1573
1574 static char *
1575 load_specs (const char *filename)
1576 {
1577   int desc;
1578   int readlen;
1579   struct stat statbuf;
1580   char *buffer;
1581   char *buffer_p;
1582   char *specs;
1583   char *specs_p;
1584
1585   if (verbose_flag)
1586     fnotice (stderr, "Reading specs from %s\n", filename);
1587
1588   /* Open and stat the file.  */
1589   desc = open (filename, O_RDONLY, 0);
1590   if (desc < 0)
1591     pfatal_with_name (filename);
1592   if (stat (filename, &statbuf) < 0)
1593     pfatal_with_name (filename);
1594
1595   /* Read contents of file into BUFFER.  */
1596   buffer = XNEWVEC (char, statbuf.st_size + 1);
1597   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1598   if (readlen < 0)
1599     pfatal_with_name (filename);
1600   buffer[readlen] = 0;
1601   close (desc);
1602
1603   specs = XNEWVEC (char, readlen + 1);
1604   specs_p = specs;
1605   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1606     {
1607       int skip = 0;
1608       char c = *buffer_p;
1609       if (c == '\r')
1610         {
1611           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1612             skip = 1;
1613           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1614             skip = 1;
1615           else                                                  /* \r */
1616             c = '\n';
1617         }
1618       if (! skip)
1619         *specs_p++ = c;
1620     }
1621   *specs_p = '\0';
1622
1623   free (buffer);
1624   return (specs);
1625 }
1626
1627 /* Read compilation specs from a file named FILENAME,
1628    replacing the default ones.
1629
1630    A suffix which starts with `*' is a definition for
1631    one of the machine-specific sub-specs.  The "suffix" should be
1632    *asm, *cc1, *cpp, *link, *startfile, etc.
1633    The corresponding spec is stored in asm_spec, etc.,
1634    rather than in the `compilers' vector.
1635
1636    Anything invalid in the file is a fatal error.  */
1637
1638 static void
1639 read_specs (const char *filename, int main_p)
1640 {
1641   char *buffer;
1642   char *p;
1643
1644   buffer = load_specs (filename);
1645
1646   /* Scan BUFFER for specs, putting them in the vector.  */
1647   p = buffer;
1648   while (1)
1649     {
1650       char *suffix;
1651       char *spec;
1652       char *in, *out, *p1, *p2, *p3;
1653
1654       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1655       p = skip_whitespace (p);
1656       if (*p == 0)
1657         break;
1658
1659       /* Is this a special command that starts with '%'? */
1660       /* Don't allow this for the main specs file, since it would
1661          encourage people to overwrite it.  */
1662       if (*p == '%' && !main_p)
1663         {
1664           p1 = p;
1665           while (*p && *p != '\n')
1666             p++;
1667
1668           /* Skip '\n'.  */
1669           p++;
1670
1671           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1672               && (p1[sizeof "%include" - 1] == ' '
1673                   || p1[sizeof "%include" - 1] == '\t'))
1674             {
1675               char *new_filename;
1676
1677               p1 += sizeof ("%include");
1678               while (*p1 == ' ' || *p1 == '\t')
1679                 p1++;
1680
1681               if (*p1++ != '<' || p[-2] != '>')
1682                 fatal_error ("specs %%include syntax malformed after "
1683                              "%ld characters",
1684                              (long) (p1 - buffer + 1));
1685
1686               p[-2] = '\0';
1687               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1688               read_specs (new_filename ? new_filename : p1, FALSE);
1689               continue;
1690             }
1691           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1692                    && (p1[sizeof "%include_noerr" - 1] == ' '
1693                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1694             {
1695               char *new_filename;
1696
1697               p1 += sizeof "%include_noerr";
1698               while (*p1 == ' ' || *p1 == '\t')
1699                 p1++;
1700
1701               if (*p1++ != '<' || p[-2] != '>')
1702                 fatal_error ("specs %%include syntax malformed after "
1703                              "%ld characters",
1704                              (long) (p1 - buffer + 1));
1705
1706               p[-2] = '\0';
1707               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1708               if (new_filename)
1709                 read_specs (new_filename, FALSE);
1710               else if (verbose_flag)
1711                 fnotice (stderr, "could not find specs file %s\n", p1);
1712               continue;
1713             }
1714           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1715                    && (p1[sizeof "%rename" - 1] == ' '
1716                        || p1[sizeof "%rename" - 1] == '\t'))
1717             {
1718               int name_len;
1719               struct spec_list *sl;
1720               struct spec_list *newsl;
1721
1722               /* Get original name.  */
1723               p1 += sizeof "%rename";
1724               while (*p1 == ' ' || *p1 == '\t')
1725                 p1++;
1726
1727               if (! ISALPHA ((unsigned char) *p1))
1728                 fatal_error ("specs %%rename syntax malformed after "
1729                              "%ld characters",
1730                              (long) (p1 - buffer));
1731
1732               p2 = p1;
1733               while (*p2 && !ISSPACE ((unsigned char) *p2))
1734                 p2++;
1735
1736               if (*p2 != ' ' && *p2 != '\t')
1737                 fatal_error ("specs %%rename syntax malformed after "
1738                              "%ld characters",
1739                              (long) (p2 - buffer));
1740
1741               name_len = p2 - p1;
1742               *p2++ = '\0';
1743               while (*p2 == ' ' || *p2 == '\t')
1744                 p2++;
1745
1746               if (! ISALPHA ((unsigned char) *p2))
1747                 fatal_error ("specs %%rename syntax malformed after "
1748                              "%ld characters",
1749                              (long) (p2 - buffer));
1750
1751               /* Get new spec name.  */
1752               p3 = p2;
1753               while (*p3 && !ISSPACE ((unsigned char) *p3))
1754                 p3++;
1755
1756               if (p3 != p - 1)
1757                 fatal_error ("specs %%rename syntax malformed after "
1758                              "%ld characters",
1759                              (long) (p3 - buffer));
1760               *p3 = '\0';
1761
1762               for (sl = specs; sl; sl = sl->next)
1763                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1764                   break;
1765
1766               if (!sl)
1767                 fatal_error ("specs %s spec was not found to be renamed", p1);
1768
1769               if (strcmp (p1, p2) == 0)
1770                 continue;
1771
1772               for (newsl = specs; newsl; newsl = newsl->next)
1773                 if (strcmp (newsl->name, p2) == 0)
1774                   fatal_error ("%s: attempt to rename spec %qs to "
1775                                "already defined spec %qs",
1776                     filename, p1, p2);
1777
1778               if (verbose_flag)
1779                 {
1780                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1781 #ifdef DEBUG_SPECS
1782                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1783 #endif
1784                 }
1785
1786               set_spec (p2, *(sl->ptr_spec));
1787               if (sl->alloc_p)
1788                 free (CONST_CAST (char *, *(sl->ptr_spec)));
1789
1790               *(sl->ptr_spec) = "";
1791               sl->alloc_p = 0;
1792               continue;
1793             }
1794           else
1795             fatal_error ("specs unknown %% command after %ld characters",
1796                          (long) (p1 - buffer));
1797         }
1798
1799       /* Find the colon that should end the suffix.  */
1800       p1 = p;
1801       while (*p1 && *p1 != ':' && *p1 != '\n')
1802         p1++;
1803
1804       /* The colon shouldn't be missing.  */
1805       if (*p1 != ':')
1806         fatal_error ("specs file malformed after %ld characters",
1807                      (long) (p1 - buffer));
1808
1809       /* Skip back over trailing whitespace.  */
1810       p2 = p1;
1811       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1812         p2--;
1813
1814       /* Copy the suffix to a string.  */
1815       suffix = save_string (p, p2 - p);
1816       /* Find the next line.  */
1817       p = skip_whitespace (p1 + 1);
1818       if (p[1] == 0)
1819         fatal_error ("specs file malformed after %ld characters",
1820                      (long) (p - buffer));
1821
1822       p1 = p;
1823       /* Find next blank line or end of string.  */
1824       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1825         p1++;
1826
1827       /* Specs end at the blank line and do not include the newline.  */
1828       spec = save_string (p, p1 - p);
1829       p = p1;
1830
1831       /* Delete backslash-newline sequences from the spec.  */
1832       in = spec;
1833       out = spec;
1834       while (*in != 0)
1835         {
1836           if (in[0] == '\\' && in[1] == '\n')
1837             in += 2;
1838           else if (in[0] == '#')
1839             while (*in && *in != '\n')
1840               in++;
1841
1842           else
1843             *out++ = *in++;
1844         }
1845       *out = 0;
1846
1847       if (suffix[0] == '*')
1848         {
1849           if (! strcmp (suffix, "*link_command"))
1850             link_command_spec = spec;
1851           else
1852             set_spec (suffix + 1, spec);
1853         }
1854       else
1855         {
1856           /* Add this pair to the vector.  */
1857           compilers
1858             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1859
1860           compilers[n_compilers].suffix = suffix;
1861           compilers[n_compilers].spec = spec;
1862           n_compilers++;
1863           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1864         }
1865
1866       if (*suffix == 0)
1867         link_command_spec = spec;
1868     }
1869
1870   if (link_command_spec == 0)
1871     fatal_error ("spec file has no spec for linking");
1872 }
1873 \f
1874 /* Record the names of temporary files we tell compilers to write,
1875    and delete them at the end of the run.  */
1876
1877 /* This is the common prefix we use to make temp file names.
1878    It is chosen once for each run of this program.
1879    It is substituted into a spec by %g or %j.
1880    Thus, all temp file names contain this prefix.
1881    In practice, all temp file names start with this prefix.
1882
1883    This prefix comes from the envvar TMPDIR if it is defined;
1884    otherwise, from the P_tmpdir macro if that is defined;
1885    otherwise, in /usr/tmp or /tmp;
1886    or finally the current directory if all else fails.  */
1887
1888 static const char *temp_filename;
1889
1890 /* Length of the prefix.  */
1891
1892 static int temp_filename_length;
1893
1894 /* Define the list of temporary files to delete.  */
1895
1896 struct temp_file
1897 {
1898   const char *name;
1899   struct temp_file *next;
1900 };
1901
1902 /* Queue of files to delete on success or failure of compilation.  */
1903 static struct temp_file *always_delete_queue;
1904 /* Queue of files to delete on failure of compilation.  */
1905 static struct temp_file *failure_delete_queue;
1906
1907 /* Record FILENAME as a file to be deleted automatically.
1908    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1909    otherwise delete it in any case.
1910    FAIL_DELETE nonzero means delete it if a compilation step fails;
1911    otherwise delete it in any case.  */
1912
1913 void
1914 record_temp_file (const char *filename, int always_delete, int fail_delete)
1915 {
1916   char *const name = xstrdup (filename);
1917
1918   if (always_delete)
1919     {
1920       struct temp_file *temp;
1921       for (temp = always_delete_queue; temp; temp = temp->next)
1922         if (! strcmp (name, temp->name))
1923           goto already1;
1924
1925       temp = XNEW (struct temp_file);
1926       temp->next = always_delete_queue;
1927       temp->name = name;
1928       always_delete_queue = temp;
1929
1930     already1:;
1931     }
1932
1933   if (fail_delete)
1934     {
1935       struct temp_file *temp;
1936       for (temp = failure_delete_queue; temp; temp = temp->next)
1937         if (! strcmp (name, temp->name))
1938           goto already2;
1939
1940       temp = XNEW (struct temp_file);
1941       temp->next = failure_delete_queue;
1942       temp->name = name;
1943       failure_delete_queue = temp;
1944
1945     already2:;
1946     }
1947 }
1948
1949 /* Delete all the temporary files whose names we previously recorded.  */
1950
1951 #ifndef DELETE_IF_ORDINARY
1952 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
1953 do                                                      \
1954   {                                                     \
1955     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
1956       if (unlink (NAME) < 0)                            \
1957         if (VERBOSE_FLAG)                               \
1958           perror_with_name (NAME);                      \
1959   } while (0)
1960 #endif
1961
1962 static void
1963 delete_if_ordinary (const char *name)
1964 {
1965   struct stat st;
1966 #ifdef DEBUG
1967   int i, c;
1968
1969   printf ("Delete %s? (y or n) ", name);
1970   fflush (stdout);
1971   i = getchar ();
1972   if (i != '\n')
1973     while ((c = getchar ()) != '\n' && c != EOF)
1974       ;
1975
1976   if (i == 'y' || i == 'Y')
1977 #endif /* DEBUG */
1978   DELETE_IF_ORDINARY (name, st, verbose_flag);
1979 }
1980
1981 static void
1982 delete_temp_files (void)
1983 {
1984   struct temp_file *temp;
1985
1986   for (temp = always_delete_queue; temp; temp = temp->next)
1987     delete_if_ordinary (temp->name);
1988   always_delete_queue = 0;
1989 }
1990
1991 /* Delete all the files to be deleted on error.  */
1992
1993 static void
1994 delete_failure_queue (void)
1995 {
1996   struct temp_file *temp;
1997
1998   for (temp = failure_delete_queue; temp; temp = temp->next)
1999     delete_if_ordinary (temp->name);
2000 }
2001
2002 static void
2003 clear_failure_queue (void)
2004 {
2005   failure_delete_queue = 0;
2006 }
2007 \f
2008 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2009    returns non-NULL.
2010    If DO_MULTI is true iterate over the paths twice, first with multilib
2011    suffix then without, otherwise iterate over the paths once without
2012    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2013    to avoid visiting the same path twice, but we could do better.  For
2014    instance, /usr/lib/../lib is considered different from /usr/lib.
2015    At least EXTRA_SPACE chars past the end of the path passed to
2016    CALLBACK are available for use by the callback.
2017    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2018
2019    Returns the value returned by CALLBACK.  */
2020
2021 static void *
2022 for_each_path (const struct path_prefix *paths,
2023                bool do_multi,
2024                size_t extra_space,
2025                void *(*callback) (char *, void *),
2026                void *callback_info)
2027 {
2028   struct prefix_list *pl;
2029   const char *multi_dir = NULL;
2030   const char *multi_os_dir = NULL;
2031   const char *multi_suffix;
2032   const char *just_multi_suffix;
2033   char *path = NULL;
2034   void *ret = NULL;
2035   bool skip_multi_dir = false;
2036   bool skip_multi_os_dir = false;
2037
2038   multi_suffix = machine_suffix;
2039   just_multi_suffix = just_machine_suffix;
2040   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2041     {
2042       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2043       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2044       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2045     }
2046   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2047     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2048
2049   while (1)
2050     {
2051       size_t multi_dir_len = 0;
2052       size_t multi_os_dir_len = 0;
2053       size_t suffix_len;
2054       size_t just_suffix_len;
2055       size_t len;
2056
2057       if (multi_dir)
2058         multi_dir_len = strlen (multi_dir);
2059       if (multi_os_dir)
2060         multi_os_dir_len = strlen (multi_os_dir);
2061       suffix_len = strlen (multi_suffix);
2062       just_suffix_len = strlen (just_multi_suffix);
2063
2064       if (path == NULL)
2065         {
2066           len = paths->max_len + extra_space + 1;
2067           if (suffix_len > multi_os_dir_len)
2068             len += suffix_len;
2069           else
2070             len += multi_os_dir_len;
2071           path = XNEWVEC (char, len);
2072         }
2073
2074       for (pl = paths->plist; pl != 0; pl = pl->next)
2075         {
2076           len = strlen (pl->prefix);
2077           memcpy (path, pl->prefix, len);
2078
2079           /* Look first in MACHINE/VERSION subdirectory.  */
2080           if (!skip_multi_dir)
2081             {
2082               memcpy (path + len, multi_suffix, suffix_len + 1);
2083               ret = callback (path, callback_info);
2084               if (ret)
2085                 break;
2086             }
2087
2088           /* Some paths are tried with just the machine (ie. target)
2089              subdir.  This is used for finding as, ld, etc.  */
2090           if (!skip_multi_dir
2091               && pl->require_machine_suffix == 2)
2092             {
2093               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2094               ret = callback (path, callback_info);
2095               if (ret)
2096                 break;
2097             }
2098
2099           /* Now try the base path.  */
2100           if (!pl->require_machine_suffix
2101               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2102             {
2103               const char *this_multi;
2104               size_t this_multi_len;
2105
2106               if (pl->os_multilib)
2107                 {
2108                   this_multi = multi_os_dir;
2109                   this_multi_len = multi_os_dir_len;
2110                 }
2111               else
2112                 {
2113                   this_multi = multi_dir;
2114                   this_multi_len = multi_dir_len;
2115                 }
2116
2117               if (this_multi_len)
2118                 memcpy (path + len, this_multi, this_multi_len + 1);
2119               else
2120                 path[len] = '\0';
2121
2122               ret = callback (path, callback_info);
2123               if (ret)
2124                 break;
2125             }
2126         }
2127       if (pl)
2128         break;
2129
2130       if (multi_dir == NULL && multi_os_dir == NULL)
2131         break;
2132
2133       /* Run through the paths again, this time without multilibs.
2134          Don't repeat any we have already seen.  */
2135       if (multi_dir)
2136         {
2137           free (CONST_CAST (char *, multi_dir));
2138           multi_dir = NULL;
2139           free (CONST_CAST (char *, multi_suffix));
2140           multi_suffix = machine_suffix;
2141           free (CONST_CAST (char *, just_multi_suffix));
2142           just_multi_suffix = just_machine_suffix;
2143         }
2144       else
2145         skip_multi_dir = true;
2146       if (multi_os_dir)
2147         {
2148           free (CONST_CAST (char *, multi_os_dir));
2149           multi_os_dir = NULL;
2150         }
2151       else
2152         skip_multi_os_dir = true;
2153     }
2154
2155   if (multi_dir)
2156     {
2157       free (CONST_CAST (char *, multi_dir));
2158       free (CONST_CAST (char *, multi_suffix));
2159       free (CONST_CAST (char *, just_multi_suffix));
2160     }
2161   if (multi_os_dir)
2162     free (CONST_CAST (char *, multi_os_dir));
2163   if (ret != path)
2164     free (path);
2165   return ret;
2166 }
2167
2168 /* Callback for build_search_list.  Adds path to obstack being built.  */
2169
2170 struct add_to_obstack_info {
2171   struct obstack *ob;
2172   bool check_dir;
2173   bool first_time;
2174 };
2175
2176 static void *
2177 add_to_obstack (char *path, void *data)
2178 {
2179   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2180
2181   if (info->check_dir && !is_directory (path, false))
2182     return NULL;
2183
2184   if (!info->first_time)
2185     obstack_1grow (info->ob, PATH_SEPARATOR);
2186
2187   obstack_grow (info->ob, path, strlen (path));
2188
2189   info->first_time = false;
2190   return NULL;
2191 }
2192
2193 /* Add or change the value of an environment variable, outputting the
2194    change to standard error if in verbose mode.  */
2195 static void
2196 xputenv (const char *string)
2197 {
2198   if (verbose_flag)
2199     fnotice (stderr, "%s\n", string);
2200   putenv (CONST_CAST (char *, string));
2201 }
2202
2203 /* Build a list of search directories from PATHS.
2204    PREFIX is a string to prepend to the list.
2205    If CHECK_DIR_P is true we ensure the directory exists.
2206    If DO_MULTI is true, multilib paths are output first, then
2207    non-multilib paths.
2208    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2209    It is also used by the --print-search-dirs flag.  */
2210
2211 static char *
2212 build_search_list (const struct path_prefix *paths, const char *prefix,
2213                    bool check_dir, bool do_multi)
2214 {
2215   struct add_to_obstack_info info;
2216
2217   info.ob = &collect_obstack;
2218   info.check_dir = check_dir;
2219   info.first_time = true;
2220
2221   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2222   obstack_1grow (&collect_obstack, '=');
2223
2224   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2225
2226   obstack_1grow (&collect_obstack, '\0');
2227   return XOBFINISH (&collect_obstack, char *);
2228 }
2229
2230 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2231    for collect.  */
2232
2233 static void
2234 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2235                       bool do_multi)
2236 {
2237   xputenv (build_search_list (paths, env_var, true, do_multi));
2238 }
2239 \f
2240 /* Check whether NAME can be accessed in MODE.  This is like access,
2241    except that it never considers directories to be executable.  */
2242
2243 static int
2244 access_check (const char *name, int mode)
2245 {
2246   if (mode == X_OK)
2247     {
2248       struct stat st;
2249
2250       if (stat (name, &st) < 0
2251           || S_ISDIR (st.st_mode))
2252         return -1;
2253     }
2254
2255   return access (name, mode);
2256 }
2257
2258 /* Callback for find_a_file.  Appends the file name to the directory
2259    path.  If the resulting file exists in the right mode, return the
2260    full pathname to the file.  */
2261
2262 struct file_at_path_info {
2263   const char *name;
2264   const char *suffix;
2265   int name_len;
2266   int suffix_len;
2267   int mode;
2268 };
2269
2270 static void *
2271 file_at_path (char *path, void *data)
2272 {
2273   struct file_at_path_info *info = (struct file_at_path_info *) data;
2274   size_t len = strlen (path);
2275
2276   memcpy (path + len, info->name, info->name_len);
2277   len += info->name_len;
2278
2279   /* Some systems have a suffix for executable files.
2280      So try appending that first.  */
2281   if (info->suffix_len)
2282     {
2283       memcpy (path + len, info->suffix, info->suffix_len + 1);
2284       if (access_check (path, info->mode) == 0)
2285         return path;
2286     }
2287
2288   path[len] = '\0';
2289   if (access_check (path, info->mode) == 0)
2290     return path;
2291
2292   return NULL;
2293 }
2294
2295 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2296    access to check permissions.  If DO_MULTI is true, search multilib
2297    paths then non-multilib paths, otherwise do not search multilib paths.
2298    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2299
2300 static char *
2301 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2302              bool do_multi)
2303 {
2304   struct file_at_path_info info;
2305
2306 #ifdef DEFAULT_ASSEMBLER
2307   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2308     return xstrdup (DEFAULT_ASSEMBLER);
2309 #endif
2310
2311 #ifdef DEFAULT_LINKER
2312   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2313     return xstrdup (DEFAULT_LINKER);
2314 #endif
2315
2316   /* Determine the filename to execute (special case for absolute paths).  */
2317
2318   if (IS_ABSOLUTE_PATH (name))
2319     {
2320       if (access (name, mode) == 0)
2321         return xstrdup (name);
2322
2323       return NULL;
2324     }
2325
2326   info.name = name;
2327   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2328   info.name_len = strlen (info.name);
2329   info.suffix_len = strlen (info.suffix);
2330   info.mode = mode;
2331
2332   return (char*) for_each_path (pprefix, do_multi,
2333                                 info.name_len + info.suffix_len,
2334                                 file_at_path, &info);
2335 }
2336
2337 /* Ranking of prefixes in the sort list. -B prefixes are put before
2338    all others.  */
2339
2340 enum path_prefix_priority
2341 {
2342   PREFIX_PRIORITY_B_OPT,
2343   PREFIX_PRIORITY_LAST
2344 };
2345
2346 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2347    order according to PRIORITY.  Within each PRIORITY, new entries are
2348    appended.
2349
2350    If WARN is nonzero, we will warn if no file is found
2351    through this prefix.  WARN should point to an int
2352    which will be set to 1 if this entry is used.
2353
2354    COMPONENT is the value to be passed to update_path.
2355
2356    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2357    the complete value of machine_suffix.
2358    2 means try both machine_suffix and just_machine_suffix.  */
2359
2360 static void
2361 add_prefix (struct path_prefix *pprefix, const char *prefix,
2362             const char *component, /* enum prefix_priority */ int priority,
2363             int require_machine_suffix, int os_multilib)
2364 {
2365   struct prefix_list *pl, **prev;
2366   int len;
2367
2368   for (prev = &pprefix->plist;
2369        (*prev) != NULL && (*prev)->priority <= priority;
2370        prev = &(*prev)->next)
2371     ;
2372
2373   /* Keep track of the longest prefix.  */
2374
2375   prefix = update_path (prefix, component);
2376   len = strlen (prefix);
2377   if (len > pprefix->max_len)
2378     pprefix->max_len = len;
2379
2380   pl = XNEW (struct prefix_list);
2381   pl->prefix = prefix;
2382   pl->require_machine_suffix = require_machine_suffix;
2383   pl->priority = priority;
2384   pl->os_multilib = os_multilib;
2385
2386   /* Insert after PREV.  */
2387   pl->next = (*prev);
2388   (*prev) = pl;
2389 }
2390
2391 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2392 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2393 static void
2394 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2395                       const char *component,
2396                       /* enum prefix_priority */ int priority,
2397                       int require_machine_suffix, int os_multilib)
2398 {
2399   if (!IS_ABSOLUTE_PATH (prefix))
2400     fatal_error ("system path %qs is not absolute", prefix);
2401
2402   if (target_system_root)
2403     {
2404       if (target_sysroot_suffix)
2405           prefix = concat (target_sysroot_suffix, prefix, NULL);
2406       prefix = concat (target_system_root, prefix, NULL);
2407
2408       /* We have to override this because GCC's notion of sysroot
2409          moves along with GCC.  */
2410       component = "GCC";
2411     }
2412
2413   add_prefix (pprefix, prefix, component, priority,
2414               require_machine_suffix, os_multilib);
2415 }
2416 \f
2417 /* Execute the command specified by the arguments on the current line of spec.
2418    When using pipes, this includes several piped-together commands
2419    with `|' between them.
2420
2421    Return 0 if successful, -1 if failed.  */
2422
2423 static int
2424 execute (void)
2425 {
2426   int i;
2427   int n_commands;               /* # of command.  */
2428   char *string;
2429   struct pex_obj *pex;
2430   struct command
2431   {
2432     const char *prog;           /* program name.  */
2433     const char **argv;          /* vector of args.  */
2434   };
2435   const char *arg;
2436
2437   struct command *commands;     /* each command buffer with above info.  */
2438
2439   gcc_assert (!processing_spec_function);
2440
2441   if (wrapper_string)
2442     {
2443       string = find_a_file (&exec_prefixes,
2444                             VEC_index (const_char_p, argbuf, 0), X_OK, false);
2445       if (string)
2446         VEC_replace (const_char_p, argbuf, 0, string);
2447       insert_wrapper (wrapper_string);
2448     }
2449
2450   /* Count # of piped commands.  */
2451   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2452     if (strcmp (arg, "|") == 0)
2453       n_commands++;
2454
2455   /* Get storage for each command.  */
2456   commands = (struct command *) alloca (n_commands * sizeof (struct command));
2457
2458   /* Split argbuf into its separate piped processes,
2459      and record info about each one.
2460      Also search for the programs that are to be run.  */
2461
2462   VEC_safe_push (const_char_p, heap, argbuf, 0);
2463
2464   commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command.  */
2465   commands[0].argv = VEC_address (const_char_p, argbuf);
2466
2467   if (!wrapper_string)
2468     {
2469       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2470       commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2471     }
2472
2473   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2474     if (arg && strcmp (arg, "|") == 0)
2475       {                         /* each command.  */
2476 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2477         fatal_error ("-pipe not supported");
2478 #endif
2479         VEC_replace (const_char_p, argbuf, i, 0); /* Termination of
2480                                                      command args.  */
2481         commands[n_commands].prog = VEC_index (const_char_p, argbuf, i + 1);
2482         commands[n_commands].argv
2483           = &(VEC_address (const_char_p, argbuf))[i + 1];
2484         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2485                               X_OK, false);
2486         if (string)
2487           commands[n_commands].argv[0] = string;
2488         n_commands++;
2489       }
2490
2491   /* If -v, print what we are about to do, and maybe query.  */
2492
2493   if (verbose_flag)
2494     {
2495       /* For help listings, put a blank line between sub-processes.  */
2496       if (print_help_list)
2497         fputc ('\n', stderr);
2498
2499       /* Print each piped command as a separate line.  */
2500       for (i = 0; i < n_commands; i++)
2501         {
2502           const char *const *j;
2503
2504           if (verbose_only_flag)
2505             {
2506               for (j = commands[i].argv; *j; j++)
2507                 {
2508                   const char *p;
2509                   for (p = *j; *p; ++p)
2510                     if (!ISALNUM ((unsigned char) *p)
2511                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2512                       break;
2513                   if (*p || !*j)
2514                     {
2515                       fprintf (stderr, " \"");
2516                       for (p = *j; *p; ++p)
2517                         {
2518                           if (*p == '"' || *p == '\\' || *p == '$')
2519                             fputc ('\\', stderr);
2520                           fputc (*p, stderr);
2521                         }
2522                       fputc ('"', stderr);
2523                     }
2524                   else
2525                     fprintf (stderr, " %s", *j);
2526                 }
2527             }
2528           else
2529             for (j = commands[i].argv; *j; j++)
2530               fprintf (stderr, " %s", *j);
2531
2532           /* Print a pipe symbol after all but the last command.  */
2533           if (i + 1 != n_commands)
2534             fprintf (stderr, " |");
2535           fprintf (stderr, "\n");
2536         }
2537       fflush (stderr);
2538       if (verbose_only_flag != 0)
2539         {
2540           /* verbose_only_flag should act as if the spec was
2541              executed, so increment execution_count before
2542              returning.  This prevents spurious warnings about
2543              unused linker input files, etc.  */
2544           execution_count++;
2545           return 0;
2546         }
2547 #ifdef DEBUG
2548       fnotice (stderr, "\nGo ahead? (y or n) ");
2549       fflush (stderr);
2550       i = getchar ();
2551       if (i != '\n')
2552         while (getchar () != '\n')
2553           ;
2554
2555       if (i != 'y' && i != 'Y')
2556         return 0;
2557 #endif /* DEBUG */
2558     }
2559
2560 #ifdef ENABLE_VALGRIND_CHECKING
2561   /* Run the each command through valgrind.  To simplify prepending the
2562      path to valgrind and the option "-q" (for quiet operation unless
2563      something triggers), we allocate a separate argv array.  */
2564
2565   for (i = 0; i < n_commands; i++)
2566     {
2567       const char **argv;
2568       int argc;
2569       int j;
2570
2571       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2572         ;
2573
2574       argv = XALLOCAVEC (const char *, argc + 3);
2575
2576       argv[0] = VALGRIND_PATH;
2577       argv[1] = "-q";
2578       for (j = 2; j < argc + 2; j++)
2579         argv[j] = commands[i].argv[j - 2];
2580       argv[j] = NULL;
2581
2582       commands[i].argv = argv;
2583       commands[i].prog = argv[0];
2584     }
2585 #endif
2586
2587   /* Run each piped subprocess.  */
2588
2589   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2590                                    ? PEX_RECORD_TIMES : 0),
2591                   progname, temp_filename);
2592   if (pex == NULL)
2593     fatal_error ("pex_init failed: %m");
2594
2595   for (i = 0; i < n_commands; i++)
2596     {
2597       const char *errmsg;
2598       int err;
2599       const char *string = commands[i].argv[0];
2600
2601       errmsg = pex_run (pex,
2602                         ((i + 1 == n_commands ? PEX_LAST : 0)
2603                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2604                         string, CONST_CAST (char **, commands[i].argv),
2605                         NULL, NULL, &err);
2606       if (errmsg != NULL)
2607         {
2608           if (err == 0)
2609             fatal_error (errmsg);
2610           else
2611             {
2612               errno = err;
2613               pfatal_with_name (errmsg);
2614             }
2615         }
2616
2617       if (string != commands[i].prog)
2618         free (CONST_CAST (char *, string));
2619     }
2620
2621   execution_count++;
2622
2623   /* Wait for all the subprocesses to finish.  */
2624
2625   {
2626     int *statuses;
2627     struct pex_time *times = NULL;
2628     int ret_code = 0;
2629
2630     statuses = (int *) alloca (n_commands * sizeof (int));
2631     if (!pex_get_status (pex, n_commands, statuses))
2632       fatal_error ("failed to get exit status: %m");
2633
2634     if (report_times || report_times_to_file)
2635       {
2636         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2637         if (!pex_get_times (pex, n_commands, times))
2638           fatal_error ("failed to get process times: %m");
2639       }
2640
2641     pex_free (pex);
2642
2643     for (i = 0; i < n_commands; ++i)
2644       {
2645         int status = statuses[i];
2646
2647         if (WIFSIGNALED (status))
2648           {
2649 #ifdef SIGPIPE
2650             /* SIGPIPE is a special case.  It happens in -pipe mode
2651                when the compiler dies before the preprocessor is done,
2652                or the assembler dies before the compiler is done.
2653                There's generally been an error already, and this is
2654                just fallout.  So don't generate another error unless
2655                we would otherwise have succeeded.  */
2656             if (WTERMSIG (status) == SIGPIPE
2657                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2658               {
2659                 signal_count++;
2660                 ret_code = -1;
2661               }
2662             else
2663 #endif
2664               internal_error ("%s (program %s)",
2665                               strsignal (WTERMSIG (status)), commands[i].prog);
2666           }
2667         else if (WIFEXITED (status)
2668                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2669           {
2670             if (WEXITSTATUS (status) > greatest_status)
2671               greatest_status = WEXITSTATUS (status);
2672             ret_code = -1;
2673           }
2674
2675         if (report_times || report_times_to_file)
2676           {
2677             struct pex_time *pt = &times[i];
2678             double ut, st;
2679
2680             ut = ((double) pt->user_seconds
2681                   + (double) pt->user_microseconds / 1.0e6);
2682             st = ((double) pt->system_seconds
2683                   + (double) pt->system_microseconds / 1.0e6);
2684
2685             if (ut + st != 0)
2686               {
2687                 if (report_times)
2688                   fnotice (stderr, "# %s %.2f %.2f\n",
2689                            commands[i].prog, ut, st);
2690
2691                 if (report_times_to_file)
2692                   {
2693                     int c = 0;
2694                     const char *const *j;
2695
2696                     fprintf (report_times_to_file, "%g %g", ut, st);
2697
2698                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2699                       {
2700                         const char *p;
2701                         for (p = *j; *p; ++p)
2702                           if (*p == '"' || *p == '\\' || *p == '$'
2703                               || ISSPACE (*p))
2704                             break;
2705
2706                         if (*p)
2707                           {
2708                             fprintf (report_times_to_file, " \"");
2709                             for (p = *j; *p; ++p)
2710                               {
2711                                 if (*p == '"' || *p == '\\' || *p == '$')
2712                                   fputc ('\\', report_times_to_file);
2713                                 fputc (*p, report_times_to_file);
2714                               }
2715                             fputc ('"', report_times_to_file);
2716                           }
2717                         else
2718                           fprintf (report_times_to_file, " %s", *j);
2719                       }
2720
2721                     fputc ('\n', report_times_to_file);
2722                   }
2723               }
2724           }
2725       }
2726
2727     return ret_code;
2728   }
2729 }
2730 \f
2731 /* Find all the switches given to us
2732    and make a vector describing them.
2733    The elements of the vector are strings, one per switch given.
2734    If a switch uses following arguments, then the `part1' field
2735    is the switch itself and the `args' field
2736    is a null-terminated vector containing the following arguments.
2737    Bits in the `live_cond' field are:
2738    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2739    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2740    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2741    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2742    in all do_spec calls afterwards.  Used for %<S from self specs.
2743    The `validated' field is nonzero if any spec has looked at this switch;
2744    if it remains zero at the end of the run, it must be meaningless.  */
2745
2746 #define SWITCH_LIVE                     0x1
2747 #define SWITCH_FALSE                    0x2
2748 #define SWITCH_IGNORE                   0x4
2749 #define SWITCH_IGNORE_PERMANENTLY       0x8
2750
2751 struct switchstr
2752 {
2753   const char *part1;
2754   const char **args;
2755   unsigned int live_cond;
2756   unsigned char validated;
2757   unsigned char ordering;
2758 };
2759
2760 static struct switchstr *switches;
2761
2762 static int n_switches;
2763
2764 static int n_switches_alloc;
2765
2766 /* Set to zero if -fcompare-debug is disabled, positive if it's
2767    enabled and we're running the first compilation, negative if it's
2768    enabled and we're running the second compilation.  For most of the
2769    time, it's in the range -1..1, but it can be temporarily set to 2
2770    or 3 to indicate that the -fcompare-debug flags didn't come from
2771    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2772    variable, until a synthesized -fcompare-debug flag is added to the
2773    command line.  */
2774 int compare_debug;
2775
2776 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2777 int compare_debug_second;
2778
2779 /* Set to the flags that should be passed to the second compilation in
2780    a -fcompare-debug compilation.  */
2781 const char *compare_debug_opt;
2782
2783 static struct switchstr *switches_debug_check[2];
2784
2785 static int n_switches_debug_check[2];
2786
2787 static int n_switches_alloc_debug_check[2];
2788
2789 static char *debug_check_temp_file[2];
2790
2791 /* Language is one of three things:
2792
2793    1) The name of a real programming language.
2794    2) NULL, indicating that no one has figured out
2795    what it is yet.
2796    3) '*', indicating that the file should be passed
2797    to the linker.  */
2798 struct infile
2799 {
2800   const char *name;
2801   const char *language;
2802   struct compiler *incompiler;
2803   bool compiled;
2804   bool preprocessed;
2805 };
2806
2807 /* Also a vector of input files specified.  */
2808
2809 static struct infile *infiles;
2810
2811 int n_infiles;
2812
2813 static int n_infiles_alloc;
2814
2815 /* True if multiple input files are being compiled to a single
2816    assembly file.  */
2817
2818 static bool combine_inputs;
2819
2820 /* This counts the number of libraries added by lang_specific_driver, so that
2821    we can tell if there were any user supplied any files or libraries.  */
2822
2823 static int added_libraries;
2824
2825 /* And a vector of corresponding output files is made up later.  */
2826
2827 const char **outfiles;
2828 \f
2829 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2830
2831 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2832    is true if we should look for an executable suffix.  DO_OBJ
2833    is true if we should look for an object suffix.  */
2834
2835 static const char *
2836 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2837                   int do_obj ATTRIBUTE_UNUSED)
2838 {
2839 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2840   int i;
2841 #endif
2842   int len;
2843
2844   if (name == NULL)
2845     return NULL;
2846
2847   len = strlen (name);
2848
2849 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2850   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2851   if (do_obj && len > 2
2852       && name[len - 2] == '.'
2853       && name[len - 1] == 'o')
2854     {
2855       obstack_grow (&obstack, name, len - 2);
2856       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2857       name = XOBFINISH (&obstack, const char *);
2858     }
2859 #endif
2860
2861 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2862   /* If there is no filetype, make it the executable suffix (which includes
2863      the ".").  But don't get confused if we have just "-o".  */
2864   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2865     return name;
2866
2867   for (i = len - 1; i >= 0; i--)
2868     if (IS_DIR_SEPARATOR (name[i]))
2869       break;
2870
2871   for (i++; i < len; i++)
2872     if (name[i] == '.')
2873       return name;
2874
2875   obstack_grow (&obstack, name, len);
2876   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2877                  strlen (TARGET_EXECUTABLE_SUFFIX));
2878   name = XOBFINISH (&obstack, const char *);
2879 #endif
2880
2881   return name;
2882 }
2883 #endif
2884 \f
2885 /* Display the command line switches accepted by gcc.  */
2886 static void
2887 display_help (void)
2888 {
2889   printf (_("Usage: %s [options] file...\n"), progname);
2890   fputs (_("Options:\n"), stdout);
2891
2892   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2893   fputs (_("  --help                   Display this information\n"), stdout);
2894   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2895   fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2896   fputs (_("                           Display specific types of command line options\n"), stdout);
2897   if (! verbose_flag)
2898     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2899   fputs (_("  --version                Display compiler version information\n"), stdout);
2900   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2901   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2902   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2903   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2904   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2905   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2906   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2907   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2908   fputs (_("\
2909   -print-multi-lib         Display the mapping between command line options and\n\
2910                            multiple library search directories\n"), stdout);
2911   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2912   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
2913   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
2914   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2915   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2916   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2917   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2918   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
2919   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
2920   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
2921   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
2922   fputs (_("\
2923   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
2924                            prefixes to other gcc components\n"), stdout);
2925   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
2926   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
2927   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
2928   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
2929   fputs (_("\
2930   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
2931                            and libraries\n"), stdout);
2932   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
2933   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
2934   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
2935   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
2936   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
2937   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
2938   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
2939   fputs (_("\
2940   -x <language>            Specify the language of the following input files\n\
2941                            Permissible languages include: c c++ assembler none\n\
2942                            'none' means revert to the default behavior of\n\
2943                            guessing the language based on the file's extension\n\
2944 "), stdout);
2945
2946   printf (_("\
2947 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
2948  passed on to the various sub-processes invoked by %s.  In order to pass\n\
2949  other options on to these processes the -W<letter> options must be used.\n\
2950 "), progname);
2951
2952   /* The rest of the options are displayed by invocations of the various
2953      sub-processes.  */
2954 }
2955
2956 static void
2957 add_preprocessor_option (const char *option, int len)
2958 {
2959   VEC_safe_push (char_p, heap, preprocessor_options,
2960                  save_string (option, len));
2961 }
2962
2963 static void
2964 add_assembler_option (const char *option, int len)
2965 {
2966   VEC_safe_push (char_p, heap, assembler_options, save_string (option, len));
2967 }
2968
2969 static void
2970 add_linker_option (const char *option, int len)
2971 {
2972   VEC_safe_push (char_p, heap, linker_options, save_string (option, len));
2973 }
2974 \f
2975 /* Allocate space for an input file in infiles.  */
2976
2977 static void
2978 alloc_infile (void)
2979 {
2980   if (n_infiles_alloc == 0)
2981     {
2982       n_infiles_alloc = 16;
2983       infiles = XNEWVEC (struct infile, n_infiles_alloc);
2984     }
2985   else if (n_infiles_alloc == n_infiles)
2986     {
2987       n_infiles_alloc *= 2;
2988       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
2989     }
2990 }
2991
2992 /* Store an input file with the given NAME and LANGUAGE in
2993    infiles.  */
2994
2995 static void
2996 add_infile (const char *name, const char *language)
2997 {
2998   alloc_infile ();
2999   infiles[n_infiles].name = name;
3000   infiles[n_infiles++].language = language;
3001 }
3002
3003 /* Allocate space for a switch in switches.  */
3004
3005 static void
3006 alloc_switch (void)
3007 {
3008   if (n_switches_alloc == 0)
3009     {
3010       n_switches_alloc = 16;
3011       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3012     }
3013   else if (n_switches_alloc == n_switches)
3014     {
3015       n_switches_alloc *= 2;
3016       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3017     }
3018 }
3019
3020 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3021    as validated if VALIDATED.  */
3022
3023 static void
3024 save_switch (const char *opt, size_t n_args, const char *const *args,
3025              bool validated)
3026 {
3027   alloc_switch ();
3028   switches[n_switches].part1 = opt + 1;
3029   if (n_args == 0)
3030     switches[n_switches].args = 0;
3031   else
3032     {
3033       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3034       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3035       switches[n_switches].args[n_args] = NULL;
3036     }
3037
3038   switches[n_switches].live_cond = 0;
3039   switches[n_switches].validated = validated;
3040   switches[n_switches].ordering = 0;
3041   n_switches++;
3042 }
3043
3044 /* Handle an option DECODED that is unknown to the option-processing
3045    machinery, but may be known to specs.  */
3046
3047 static bool
3048 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3049 {
3050   save_switch (decoded->canonical_option[0],
3051                decoded->canonical_option_num_elements - 1,
3052                &decoded->canonical_option[1], false);
3053
3054   return false;
3055 }
3056
3057 /* Handle an option DECODED that is not marked as CL_DRIVER.
3058    LANG_MASK will always be CL_DRIVER.  */
3059
3060 static void
3061 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3062                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3063 {
3064   /* At this point, non-driver options are accepted (and expected to
3065      be passed down by specs) unless marked to be rejected by the
3066      driver.  Options to be rejected by the driver but accepted by the
3067      compilers proper are treated just like completely unknown
3068      options.  */
3069   const struct cl_option *option = &cl_options[decoded->opt_index];
3070
3071   if (option->flags & CL_REJECT_DRIVER)
3072     error ("unrecognized command line option %qs",
3073            decoded->orig_option_with_args_text);
3074   else
3075     driver_unknown_option_callback (decoded);
3076 }
3077
3078 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3079    has been successfully handled with a handler for mask MASK.  */
3080
3081 static void
3082 driver_post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
3083                                unsigned int mask ATTRIBUTE_UNUSED)
3084 {
3085   /* Nothing to do here.  */
3086 }
3087
3088 static const char *spec_lang = 0;
3089 static int last_language_n_infiles;
3090
3091 /* Handle a driver option; arguments and return value as for
3092    handle_option.  */
3093
3094 static bool
3095 driver_handle_option (struct gcc_options *opts,
3096                       struct gcc_options *opts_set,
3097                       const struct cl_decoded_option *decoded,
3098                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3099                       location_t loc,
3100                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3101                       diagnostic_context *dc)
3102 {
3103   size_t opt_index = decoded->opt_index;
3104   const char *arg = decoded->arg;
3105   const char *compare_debug_replacement_opt;
3106   int value = decoded->value;
3107   bool validated = false;
3108   bool do_save = true;
3109
3110   gcc_assert (opts == &global_options);
3111   gcc_assert (opts_set == &global_options_set);
3112   gcc_assert (kind == DK_UNSPECIFIED);
3113   gcc_assert (loc == UNKNOWN_LOCATION);
3114   gcc_assert (dc == global_dc);
3115
3116   switch (opt_index)
3117     {
3118     case OPT_dumpspecs:
3119       {
3120         struct spec_list *sl;
3121         init_spec ();
3122         for (sl = specs; sl; sl = sl->next)
3123           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3124         if (link_command_spec)
3125           printf ("*link_command:\n%s\n\n", link_command_spec);
3126         exit (0);
3127       }
3128
3129     case OPT_dumpversion:
3130       printf ("%s\n", spec_version);
3131       exit (0);
3132
3133     case OPT_dumpmachine:
3134       printf ("%s\n", spec_machine);
3135       exit (0);
3136
3137     case OPT__version:
3138       print_version = 1;
3139
3140       /* CPP driver cannot obtain switch from cc1_options.  */
3141       if (is_cpp_driver)
3142         add_preprocessor_option ("--version", strlen ("--version"));
3143       add_assembler_option ("--version", strlen ("--version"));
3144       add_linker_option ("--version", strlen ("--version"));
3145       break;
3146
3147     case OPT__help:
3148       print_help_list = 1;
3149
3150       /* CPP driver cannot obtain switch from cc1_options.  */
3151       if (is_cpp_driver)
3152         add_preprocessor_option ("--help", 6);
3153       add_assembler_option ("--help", 6);
3154       add_linker_option ("--help", 6);
3155       break;
3156
3157     case OPT__help_:
3158       print_subprocess_help = 2;
3159       break;
3160
3161     case OPT__target_help:
3162       print_subprocess_help = 1;
3163
3164       /* CPP driver cannot obtain switch from cc1_options.  */
3165       if (is_cpp_driver)
3166         add_preprocessor_option ("--target-help", 13);
3167       add_assembler_option ("--target-help", 13);
3168       add_linker_option ("--target-help", 13);
3169       break;
3170
3171     case OPT_pass_exit_codes:
3172     case OPT_print_search_dirs:
3173     case OPT_print_file_name_:
3174     case OPT_print_prog_name_:
3175     case OPT_print_multi_lib:
3176     case OPT_print_multi_directory:
3177     case OPT_print_sysroot:
3178     case OPT_print_multi_os_directory:
3179     case OPT_print_sysroot_headers_suffix:
3180     case OPT_time:
3181     case OPT_wrapper:
3182       /* These options set the variables specified in common.opt
3183          automatically, and do not need to be saved for spec
3184          processing.  */
3185       do_save = false;
3186       break;
3187
3188     case OPT_print_libgcc_file_name:
3189       print_file_name = "libgcc.a";
3190       do_save = false;
3191       break;
3192
3193     case OPT_fcompare_debug_second:
3194       compare_debug_second = 1;
3195       break;
3196
3197     case OPT_fcompare_debug:
3198       switch (value)
3199         {
3200         case 0:
3201           compare_debug_replacement_opt = "-fcompare-debug=";
3202           arg = "";
3203           goto compare_debug_with_arg;
3204
3205         case 1:
3206           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3207           arg = "-gtoggle";
3208           goto compare_debug_with_arg;
3209
3210         default:
3211           gcc_unreachable ();
3212         }
3213       break;
3214
3215     case OPT_fcompare_debug_:
3216       compare_debug_replacement_opt = decoded->canonical_option[0];
3217     compare_debug_with_arg:
3218       gcc_assert (decoded->canonical_option_num_elements == 1);
3219       gcc_assert (arg != NULL);
3220       if (arg)
3221         compare_debug = 1;
3222       else
3223         compare_debug = -1;
3224       if (compare_debug < 0)
3225         compare_debug_opt = NULL;
3226       else
3227         compare_debug_opt = arg;
3228       save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3229       return true;
3230
3231     case OPT_Wa_:
3232       {
3233         int prev, j;
3234         /* Pass the rest of this option to the assembler.  */
3235
3236         /* Split the argument at commas.  */
3237         prev = 0;
3238         for (j = 0; arg[j]; j++)
3239           if (arg[j] == ',')
3240             {
3241               add_assembler_option (arg + prev, j - prev);
3242               prev = j + 1;
3243             }
3244
3245         /* Record the part after the last comma.  */
3246         add_assembler_option (arg + prev, j - prev);
3247       }
3248       do_save = false;
3249       break;
3250
3251     case OPT_Wp_:
3252       {
3253         int prev, j;
3254         /* Pass the rest of this option to the preprocessor.  */
3255
3256         /* Split the argument at commas.  */
3257         prev = 0;
3258         for (j = 0; arg[j]; j++)
3259           if (arg[j] == ',')
3260             {
3261               add_preprocessor_option (arg + prev, j - prev);
3262               prev = j + 1;
3263             }
3264
3265         /* Record the part after the last comma.  */
3266         add_preprocessor_option (arg + prev, j - prev);
3267       }
3268       do_save = false;
3269       break;
3270
3271     case OPT_Wl_:
3272       {
3273         int prev, j;
3274         /* Split the argument at commas.  */
3275         prev = 0;
3276         for (j = 0; arg[j]; j++)
3277           if (arg[j] == ',')
3278             {
3279               add_infile (save_string (arg + prev, j - prev), "*");
3280               prev = j + 1;
3281             }
3282         /* Record the part after the last comma.  */
3283         add_infile (arg + prev, "*");
3284       }
3285       do_save = false;
3286       break;
3287
3288     case OPT_Xlinker:
3289       add_infile (arg, "*");
3290       do_save = false;
3291       break;
3292
3293     case OPT_Xpreprocessor:
3294       add_preprocessor_option (arg, strlen (arg));
3295       do_save = false;
3296       break;
3297
3298     case OPT_Xassembler:
3299       add_assembler_option (arg, strlen (arg));
3300       do_save = false;
3301       break;
3302
3303     case OPT_l:
3304       /* POSIX allows separation of -l and the lib arg; canonicalize
3305          by concatenating -l with its arg */
3306       add_infile (concat ("-l", arg, NULL), "*");
3307       do_save = false;
3308       break;
3309
3310     case OPT_L:
3311       /* Similarly, canonicalize -L for linkers that may not accept
3312          separate arguments.  */
3313       save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3314       return true;
3315
3316     case OPT_save_temps:
3317       save_temps_flag = SAVE_TEMPS_CWD;
3318       validated = true;
3319       break;
3320
3321     case OPT_save_temps_:
3322       if (strcmp (arg, "cwd") == 0)
3323         save_temps_flag = SAVE_TEMPS_CWD;
3324       else if (strcmp (arg, "obj") == 0
3325                || strcmp (arg, "object") == 0)
3326         save_temps_flag = SAVE_TEMPS_OBJ;
3327       else
3328         fatal_error ("%qs is an unknown -save-temps option",
3329                      decoded->orig_option_with_args_text);
3330       break;
3331
3332     case OPT_no_canonical_prefixes:
3333       /* Already handled as a special case, so ignored here.  */
3334       do_save = false;
3335       break;
3336
3337     case OPT_pipe:
3338       validated = true;
3339       /* These options set the variables specified in common.opt
3340          automatically, but do need to be saved for spec
3341          processing.  */
3342       break;
3343
3344     case OPT_specs_:
3345       {
3346         struct user_specs *user = XNEW (struct user_specs);
3347
3348         user->next = (struct user_specs *) 0;
3349         user->filename = arg;
3350         if (user_specs_tail)
3351           user_specs_tail->next = user;
3352         else
3353           user_specs_head = user;
3354         user_specs_tail = user;
3355       }
3356       do_save = false;
3357       break;
3358
3359     case OPT__sysroot_:
3360       target_system_root = arg;
3361       target_system_root_changed = 1;
3362       do_save = false;
3363       break;
3364
3365     case OPT_time_:
3366       if (report_times_to_file)
3367         fclose (report_times_to_file);
3368       report_times_to_file = fopen (arg, "a");
3369       do_save = false;
3370       break;
3371
3372     case OPT____:
3373       /* "-###"
3374          This is similar to -v except that there is no execution
3375          of the commands and the echoed arguments are quoted.  It
3376          is intended for use in shell scripts to capture the
3377          driver-generated command line.  */
3378       verbose_only_flag++;
3379       verbose_flag = 1;
3380       do_save = false;
3381       break;
3382
3383     case OPT_B:
3384       {
3385         size_t len = strlen (arg);
3386
3387         /* Catch the case where the user has forgotten to append a
3388            directory separator to the path.  Note, they may be using
3389            -B to add an executable name prefix, eg "i386-elf-", in
3390            order to distinguish between multiple installations of
3391            GCC in the same directory.  Hence we must check to see
3392            if appending a directory separator actually makes a
3393            valid directory name.  */
3394         if (!IS_DIR_SEPARATOR (arg[len - 1])
3395             && is_directory (arg, false))
3396           {
3397             char *tmp = XNEWVEC (char, len + 2);
3398             strcpy (tmp, arg);
3399             tmp[len] = DIR_SEPARATOR;
3400             tmp[++len] = 0;
3401             arg = tmp;
3402           }
3403
3404         add_prefix (&exec_prefixes, arg, NULL,
3405                     PREFIX_PRIORITY_B_OPT, 0, 0);
3406         add_prefix (&startfile_prefixes, arg, NULL,
3407                     PREFIX_PRIORITY_B_OPT, 0, 0);
3408         add_prefix (&include_prefixes, arg, NULL,
3409                     PREFIX_PRIORITY_B_OPT, 0, 0);
3410       }
3411       validated = true;
3412       break;
3413
3414     case OPT_x:
3415       spec_lang = arg;
3416       if (!strcmp (spec_lang, "none"))
3417         /* Suppress the warning if -xnone comes after the last input
3418            file, because alternate command interfaces like g++ might
3419            find it useful to place -xnone after each input file.  */
3420         spec_lang = 0;
3421       else
3422         last_language_n_infiles = n_infiles;
3423       do_save = false;
3424       break;
3425
3426     case OPT_o:
3427       have_o = 1;
3428 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3429       arg = convert_filename (arg, ! have_c, 0);
3430 #endif
3431       /* Save the output name in case -save-temps=obj was used.  */
3432       save_temps_prefix = xstrdup (arg);
3433       /* On some systems, ld cannot handle "-o" without a space.  So
3434          split the option from its argument.  */
3435       save_switch ("-o", 1, &arg, validated);
3436       return true;
3437
3438     case OPT_static_libgcc:
3439     case OPT_shared_libgcc:
3440     case OPT_static_libgfortran:
3441     case OPT_static_libstdc__:
3442       /* These are always valid, since gcc.c itself understands the
3443          first two, gfortranspec.c understands -static-libgfortran and
3444          g++spec.c understands -static-libstdc++ */
3445       validated = true;
3446       break;
3447
3448     default:
3449       /* Various driver options need no special processing at this
3450          point, having been handled in a prescan above or being
3451          handled by specs.  */
3452       break;
3453     }
3454
3455   if (do_save)
3456     save_switch (decoded->canonical_option[0],
3457                  decoded->canonical_option_num_elements - 1,
3458                  &decoded->canonical_option[1], validated);
3459   return true;
3460 }
3461
3462 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3463
3464 static void
3465 set_option_handlers (struct cl_option_handlers *handlers)
3466 {
3467   handlers->unknown_option_callback = driver_unknown_option_callback;
3468   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3469   handlers->post_handling_callback = driver_post_handling_callback;
3470   handlers->num_handlers = 1;
3471   handlers->handlers[0].handler = driver_handle_option;
3472   handlers->handlers[0].mask = CL_DRIVER;
3473 }
3474
3475 /* Create the vector `switches' and its contents.
3476    Store its length in `n_switches'.  */
3477
3478 static void
3479 process_command (unsigned int decoded_options_count,
3480                  struct cl_decoded_option *decoded_options)
3481 {
3482   const char *temp;
3483   char *temp1;
3484   const char *tooldir_prefix;
3485   char *(*get_relative_prefix) (const char *, const char *,
3486                                 const char *) = NULL;
3487   struct cl_option_handlers handlers;
3488   unsigned int j;
3489
3490   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3491
3492   n_switches = 0;
3493   n_infiles = 0;
3494   added_libraries = 0;
3495
3496   /* Figure compiler version from version string.  */
3497
3498   compiler_version = temp1 = xstrdup (version_string);
3499
3500   for (; *temp1; ++temp1)
3501     {
3502       if (*temp1 == ' ')
3503         {
3504           *temp1 = '\0';
3505           break;
3506         }
3507     }
3508
3509   /* Handle any -no-canonical-prefixes flag early, to assign the function
3510      that builds relative prefixes.  This function creates default search
3511      paths that are needed later in normal option handling.  */
3512
3513   for (j = 1; j < decoded_options_count; j++)
3514     {
3515       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3516         {
3517           get_relative_prefix = make_relative_prefix_ignore_links;
3518           break;
3519         }
3520     }
3521   if (! get_relative_prefix)
3522     get_relative_prefix = make_relative_prefix;
3523
3524   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3525      see if we can create it from the pathname specified in
3526      decoded_options[0].arg.  */
3527
3528   gcc_libexec_prefix = standard_libexec_prefix;
3529 #ifndef VMS
3530   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3531   if (!gcc_exec_prefix)
3532     {
3533       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3534                                              standard_bindir_prefix,
3535                                              standard_exec_prefix);
3536       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3537                                              standard_bindir_prefix,
3538                                              standard_libexec_prefix);
3539       if (gcc_exec_prefix)
3540         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3541     }
3542   else
3543     {
3544       /* make_relative_prefix requires a program name, but
3545          GCC_EXEC_PREFIX is typically a directory name with a trailing
3546          / (which is ignored by make_relative_prefix), so append a
3547          program name.  */
3548       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3549       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3550                                                 standard_exec_prefix,
3551                                                 standard_libexec_prefix);
3552
3553       /* The path is unrelocated, so fallback to the original setting.  */
3554       if (!gcc_libexec_prefix)
3555         gcc_libexec_prefix = standard_libexec_prefix;
3556
3557       free (tmp_prefix);
3558     }
3559 #else
3560 #endif
3561   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3562      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3563      or an automatically created GCC_EXEC_PREFIX from
3564      decoded_options[0].arg.  */
3565
3566   /* Do language-specific adjustment/addition of flags.  */
3567   lang_specific_driver (&decoded_options, &decoded_options_count,
3568                         &added_libraries);
3569
3570   if (gcc_exec_prefix)
3571     {
3572       int len = strlen (gcc_exec_prefix);
3573
3574       if (len > (int) sizeof ("/lib/gcc/") - 1