OSDN Git Service

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