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