OSDN Git Service

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