OSDN Git Service

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