OSDN Git Service

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