OSDN Git Service

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