OSDN Git Service

db0cd0e1596e1cf11fc237de8f8e66b05c237e05
[pf3gnuchains/gcc-fork.git] / gcc / gcc.c
1 /* Compiler driver program that can handle many languages.
2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 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 *lib_spec = LIB_SPEC;
737 static const char *mfwrap_spec = MFWRAP_SPEC;
738 static const char *mflib_spec = MFLIB_SPEC;
739 static const char *libgcc_spec = LIBGCC_SPEC;
740 static const char *endfile_spec = ENDFILE_SPEC;
741 static const char *startfile_spec = STARTFILE_SPEC;
742 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
743 static const char *linker_name_spec = LINKER_NAME;
744 static const char *link_command_spec = LINK_COMMAND_SPEC;
745 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
746 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
747 static const char *sysroot_spec = SYSROOT_SPEC;
748 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
749 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
750
751 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
752    There should be no need to override these in target dependent files,
753    but we need to copy them to the specs file so that newer versions
754    of the GCC driver can correctly drive older tool chains with the
755    appropriate -B options.  */
756
757 /* When cpplib handles traditional preprocessing, get rid of this, and
758    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
759    that we default the front end language better.  */
760 static const char *trad_capable_cpp =
761 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
762
763 /* We don't wrap .d files in %W{} since a missing .d file, and
764    therefore no dependency entry, confuses make into thinking a .o
765    file that happens to exist is up-to-date.  */
766 static const char *cpp_unique_options =
767 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
768  %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
769  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
770  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
771  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
772  %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
773  %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
774  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
775  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
776  %{E|M|MM:%W{o*}}";
777
778 /* This contains cpp options which are common with cc1_options and are passed
779    only when preprocessing only to avoid duplication.  We pass the cc1 spec
780    options to the preprocessor so that it the cc1 spec may manipulate
781    options used to set target flags.  Those special target flags settings may
782    in turn cause preprocessor symbols to be defined specially.  */
783 static const char *cpp_options =
784 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
785  %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
786  %{undef} %{save-temps:-fpch-preprocess}";
787
788 /* This contains cpp options which are not passed when the preprocessor
789    output will be used by another program.  */
790 static const char *cpp_debug_options = "%{d*}";
791
792 /* NB: This is shared amongst all front-ends.  */
793 static const char *cc1_options =
794 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
795  %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
796  %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
797  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
798  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
799  %{Qn:-fno-ident} %{--help:--help}\
800  %{--target-help:--target-help}\
801  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
802  %{fsyntax-only:-o %j} %{-param*}\
803  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
804  %{coverage:-fprofile-arcs -ftest-coverage}";
805
806 static const char *asm_options =
807 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
808
809 static const char *invoke_as =
810 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
811 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
812 #else
813 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
814 #endif
815
816 /* Some compilers have limits on line lengths, and the multilib_select
817    and/or multilib_matches strings can be very long, so we build them at
818    run time.  */
819 static struct obstack multilib_obstack;
820 static const char *multilib_select;
821 static const char *multilib_matches;
822 static const char *multilib_defaults;
823 static const char *multilib_exclusions;
824
825 /* Check whether a particular argument is a default argument.  */
826
827 #ifndef MULTILIB_DEFAULTS
828 #define MULTILIB_DEFAULTS { "" }
829 #endif
830
831 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
832
833 #ifndef DRIVER_SELF_SPECS
834 #define DRIVER_SELF_SPECS ""
835 #endif
836
837 static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
838
839 #ifndef OPTION_DEFAULT_SPECS
840 #define OPTION_DEFAULT_SPECS { "", "" }
841 #endif
842
843 struct default_spec
844 {
845   const char *name;
846   const char *spec;
847 };
848
849 static const struct default_spec
850   option_default_specs[] = { OPTION_DEFAULT_SPECS };
851
852 struct user_specs
853 {
854   struct user_specs *next;
855   const char *filename;
856 };
857
858 static struct user_specs *user_specs_head, *user_specs_tail;
859
860 #ifndef SWITCH_TAKES_ARG
861 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
862 #endif
863
864 #ifndef WORD_SWITCH_TAKES_ARG
865 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
866 #endif
867 \f
868 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
869 /* This defines which switches stop a full compilation.  */
870 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
871   ((CHAR) == 'c' || (CHAR) == 'S')
872
873 #ifndef SWITCH_CURTAILS_COMPILATION
874 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
875   DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
876 #endif
877 #endif
878
879 /* Record the mapping from file suffixes for compilation specs.  */
880
881 struct compiler
882 {
883   const char *suffix;           /* Use this compiler for input files
884                                    whose names end in this suffix.  */
885
886   const char *spec;             /* To use this compiler, run this spec.  */
887
888   const char *cpp_spec;         /* If non-NULL, substitute this spec
889                                    for `%C', rather than the usual
890                                    cpp_spec.  */
891   const int combinable;          /* If nonzero, compiler can deal with
892                                     multiple source files at once (IMA).  */
893   const int needs_preprocessing; /* If nonzero, source files need to
894                                     be run through a preprocessor.  */
895 };
896
897 /* Pointer to a vector of `struct compiler' that gives the spec for
898    compiling a file, based on its suffix.
899    A file that does not end in any of these suffixes will be passed
900    unchanged to the loader and nothing else will be done to it.
901
902    An entry containing two 0s is used to terminate the vector.
903
904    If multiple entries match a file, the last matching one is used.  */
905
906 static struct compiler *compilers;
907
908 /* Number of entries in `compilers', not counting the null terminator.  */
909
910 static int n_compilers;
911
912 /* The default list of file name suffixes and their compilation specs.  */
913
914 static const struct compiler default_compilers[] =
915 {
916   /* Add lists of suffixes of known languages here.  If those languages
917      were not present when we built the driver, we will hit these copies
918      and be given a more meaningful error than "file not used since
919      linking is not done".  */
920   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
921   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
922   {".mii", "#Objective-C++", 0, 0, 0},
923   {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
924   {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
925   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
926   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
927   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
928   {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0},
929   {".F", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
930   {".FPP", "#Fortran", 0, 0, 0},
931   {".f90", "#Fortran 95", 0, 0, 0}, {".f95", "#Fortran 95", 0, 0, 0},
932   {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
933   {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#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 #ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
1446 #undef MD_EXEC_PREFIX
1447 #undef MD_STARTFILE_PREFIX
1448 #undef MD_STARTFILE_PREFIX_1
1449 #endif
1450
1451 /* If no prefixes defined, use the null string, which will disable them.  */
1452 #ifndef MD_EXEC_PREFIX
1453 #define MD_EXEC_PREFIX ""
1454 #endif
1455 #ifndef MD_STARTFILE_PREFIX
1456 #define MD_STARTFILE_PREFIX ""
1457 #endif
1458 #ifndef MD_STARTFILE_PREFIX_1
1459 #define MD_STARTFILE_PREFIX_1 ""
1460 #endif
1461
1462 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1463 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1464 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
1465 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1466
1467 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1468 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1469 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1470 static const char *const standard_startfile_prefix_1
1471   = STANDARD_STARTFILE_PREFIX_1;
1472 static const char *const standard_startfile_prefix_2
1473   = STANDARD_STARTFILE_PREFIX_2;
1474
1475 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1476 static const char *tooldir_prefix;
1477
1478 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1479
1480 static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1481
1482 /* Subdirectory to use for locating libraries.  Set by
1483    set_multilib_dir based on the compilation options.  */
1484
1485 static const char *multilib_dir;
1486
1487 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1488    set_multilib_dir based on the compilation options.  */
1489
1490 static const char *multilib_os_dir;
1491 \f
1492 /* Structure to keep track of the specs that have been defined so far.
1493    These are accessed using %(specname) or %[specname] in a compiler
1494    or link spec.  */
1495
1496 struct spec_list
1497 {
1498                                 /* The following 2 fields must be first */
1499                                 /* to allow EXTRA_SPECS to be initialized */
1500   const char *name;             /* name of the spec.  */
1501   const char *ptr;              /* available ptr if no static pointer */
1502
1503                                 /* The following fields are not initialized */
1504                                 /* by EXTRA_SPECS */
1505   const char **ptr_spec;        /* pointer to the spec itself.  */
1506   struct spec_list *next;       /* Next spec in linked list.  */
1507   int name_len;                 /* length of the name */
1508   int alloc_p;                  /* whether string was allocated */
1509 };
1510
1511 #define INIT_STATIC_SPEC(NAME,PTR) \
1512 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1513
1514 /* List of statically defined specs.  */
1515 static struct spec_list static_specs[] =
1516 {
1517   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1518   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1519   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1520   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1521   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1522   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1523   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1524   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1525   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1526   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1527   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1528   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1529   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1530   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1531   INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1532   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1533   INIT_STATIC_SPEC ("link",                     &link_spec),
1534   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1535   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1536   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1537   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1538   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1539   INIT_STATIC_SPEC ("switches_need_spaces",     &switches_need_spaces),
1540   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1541   INIT_STATIC_SPEC ("version",                  &compiler_version),
1542   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1543   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1544   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1545   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1546   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1547   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1548   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1549   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1550   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1551   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1552   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1553   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1554   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1555   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1556   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1557 };
1558
1559 #ifdef EXTRA_SPECS              /* additional specs needed */
1560 /* Structure to keep track of just the first two args of a spec_list.
1561    That is all that the EXTRA_SPECS macro gives us.  */
1562 struct spec_list_1
1563 {
1564   const char *const name;
1565   const char *const ptr;
1566 };
1567
1568 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1569 static struct spec_list *extra_specs = (struct spec_list *) 0;
1570 #endif
1571
1572 /* List of dynamically allocates specs that have been defined so far.  */
1573
1574 static struct spec_list *specs = (struct spec_list *) 0;
1575 \f
1576 /* List of static spec functions.  */
1577
1578 static const struct spec_function static_spec_functions[] =
1579 {
1580   { "if-exists",                if_exists_spec_function },
1581   { "if-exists-else",           if_exists_else_spec_function },
1582   { "replace-outfile",          replace_outfile_spec_function },
1583   { "version-compare",          version_compare_spec_function },
1584   { 0, 0 }
1585 };
1586
1587 static int processing_spec_function;
1588 \f
1589 /* Add appropriate libgcc specs to OBSTACK, taking into account
1590    various permutations of -shared-libgcc, -shared, and such.  */
1591
1592 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1593
1594 #ifndef USE_LD_AS_NEEDED
1595 #define USE_LD_AS_NEEDED 0
1596 #endif
1597
1598 static void
1599 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1600                 const char *static_name, const char *eh_name)
1601 {
1602   char *buf;
1603
1604   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1605                 "}%{!static:%{!static-libgcc:",
1606 #if USE_LD_AS_NEEDED
1607                 "%{!shared-libgcc:", static_name,
1608                 " --as-needed ", shared_name, " --no-as-needed}"
1609                 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
1610                 "}",
1611 #else
1612                 "%{!shared:%{!shared-libgcc:", static_name, " ",
1613                 eh_name, "}%{shared-libgcc:", shared_name, " ",
1614                 static_name, "}}%{shared:",
1615 #ifdef LINK_EH_SPEC
1616                 "%{shared-libgcc:", shared_name,
1617                 "}%{!shared-libgcc:", static_name, "}",
1618 #else
1619                 shared_name,
1620 #endif
1621 #endif
1622                 "}}}", NULL);
1623
1624   obstack_grow (obstack, buf, strlen (buf));
1625   free (buf);
1626 }
1627 #endif /* ENABLE_SHARED_LIBGCC */
1628
1629 /* Initialize the specs lookup routines.  */
1630
1631 static void
1632 init_spec (void)
1633 {
1634   struct spec_list *next = (struct spec_list *) 0;
1635   struct spec_list *sl   = (struct spec_list *) 0;
1636   int i;
1637
1638   if (specs)
1639     return;                     /* Already initialized.  */
1640
1641   if (verbose_flag)
1642     notice ("Using built-in specs.\n");
1643
1644 #ifdef EXTRA_SPECS
1645   extra_specs = xcalloc (sizeof (struct spec_list),
1646                          ARRAY_SIZE (extra_specs_1));
1647
1648   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1649     {
1650       sl = &extra_specs[i];
1651       sl->name = extra_specs_1[i].name;
1652       sl->ptr = extra_specs_1[i].ptr;
1653       sl->next = next;
1654       sl->name_len = strlen (sl->name);
1655       sl->ptr_spec = &sl->ptr;
1656       next = sl;
1657     }
1658 #endif
1659
1660   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
1661      on ?: in file-scope variable initializations.  */
1662   asm_debug = ASM_DEBUG_SPEC;
1663
1664   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1665     {
1666       sl = &static_specs[i];
1667       sl->next = next;
1668       next = sl;
1669     }
1670
1671 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1672   /* ??? If neither -shared-libgcc nor --static-libgcc was
1673      seen, then we should be making an educated guess.  Some proposed
1674      heuristics for ELF include:
1675
1676         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1677             program will be doing dynamic loading, which will likely
1678             need the shared libgcc.
1679
1680         (2) If "-ldl", then it's also a fair bet that we're doing
1681             dynamic loading.
1682
1683         (3) For each ET_DYN we're linking against (either through -lfoo
1684             or /some/path/foo.so), check to see whether it or one of
1685             its dependencies depends on a shared libgcc.
1686
1687         (4) If "-shared"
1688
1689             If the runtime is fixed to look for program headers instead
1690             of calling __register_frame_info at all, for each object,
1691             use the shared libgcc if any EH symbol referenced.
1692
1693             If crtstuff is fixed to not invoke __register_frame_info
1694             automatically, for each object, use the shared libgcc if
1695             any non-empty unwind section found.
1696
1697      Doing any of this probably requires invoking an external program to
1698      do the actual object file scanning.  */
1699   {
1700     const char *p = libgcc_spec;
1701     int in_sep = 1;
1702
1703     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1704        when given the proper command line arguments.  */
1705     while (*p)
1706       {
1707         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1708           {
1709             init_gcc_specs (&obstack,
1710                             "-lgcc_s"
1711 #ifdef USE_LIBUNWIND_EXCEPTIONS
1712                             " -lunwind"
1713 #endif
1714                             ,
1715                             "-lgcc",
1716                             "-lgcc_eh"
1717 #ifdef USE_LIBUNWIND_EXCEPTIONS
1718 # ifdef HAVE_LD_STATIC_DYNAMIC
1719                             " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1720 # else
1721                             " -lunwind"
1722 # endif
1723 #endif
1724                             );
1725
1726             p += 5;
1727             in_sep = 0;
1728           }
1729         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1730           {
1731             /* Ug.  We don't know shared library extensions.  Hope that
1732                systems that use this form don't do shared libraries.  */
1733             init_gcc_specs (&obstack,
1734                             "-lgcc_s",
1735                             "libgcc.a%s",
1736                             "libgcc_eh.a%s"
1737 #ifdef USE_LIBUNWIND_EXCEPTIONS
1738                             " -lunwind"
1739 #endif
1740                             );
1741             p += 10;
1742             in_sep = 0;
1743           }
1744         else
1745           {
1746             obstack_1grow (&obstack, *p);
1747             in_sep = (*p == ' ');
1748             p += 1;
1749           }
1750       }
1751
1752     obstack_1grow (&obstack, '\0');
1753     libgcc_spec = XOBFINISH (&obstack, const char *);
1754   }
1755 #endif
1756 #ifdef USE_AS_TRADITIONAL_FORMAT
1757   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1758   {
1759     static const char tf[] = "--traditional-format ";
1760     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1761     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1762     asm_spec = XOBFINISH (&obstack, const char *);
1763   }
1764 #endif
1765 #ifdef LINK_EH_SPEC
1766   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1767   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1768   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1769   link_spec = XOBFINISH (&obstack, const char *);
1770 #endif
1771
1772   specs = sl;
1773 }
1774 \f
1775 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1776    removed; If the spec starts with a + then SPEC is added to the end of the
1777    current spec.  */
1778
1779 static void
1780 set_spec (const char *name, const char *spec)
1781 {
1782   struct spec_list *sl;
1783   const char *old_spec;
1784   int name_len = strlen (name);
1785   int i;
1786
1787   /* If this is the first call, initialize the statically allocated specs.  */
1788   if (!specs)
1789     {
1790       struct spec_list *next = (struct spec_list *) 0;
1791       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1792         {
1793           sl = &static_specs[i];
1794           sl->next = next;
1795           next = sl;
1796         }
1797       specs = sl;
1798     }
1799
1800   /* See if the spec already exists.  */
1801   for (sl = specs; sl; sl = sl->next)
1802     if (name_len == sl->name_len && !strcmp (sl->name, name))
1803       break;
1804
1805   if (!sl)
1806     {
1807       /* Not found - make it.  */
1808       sl = xmalloc (sizeof (struct spec_list));
1809       sl->name = xstrdup (name);
1810       sl->name_len = name_len;
1811       sl->ptr_spec = &sl->ptr;
1812       sl->alloc_p = 0;
1813       *(sl->ptr_spec) = "";
1814       sl->next = specs;
1815       specs = sl;
1816     }
1817
1818   old_spec = *(sl->ptr_spec);
1819   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1820                      ? concat (old_spec, spec + 1, NULL)
1821                      : xstrdup (spec));
1822
1823 #ifdef DEBUG_SPECS
1824   if (verbose_flag)
1825     notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1826 #endif
1827
1828   /* Free the old spec.  */
1829   if (old_spec && sl->alloc_p)
1830     free ((void *) old_spec);
1831
1832   sl->alloc_p = 1;
1833 }
1834 \f
1835 /* Accumulate a command (program name and args), and run it.  */
1836
1837 /* Vector of pointers to arguments in the current line of specifications.  */
1838
1839 static const char **argbuf;
1840
1841 /* Number of elements allocated in argbuf.  */
1842
1843 static int argbuf_length;
1844
1845 /* Number of elements in argbuf currently in use (containing args).  */
1846
1847 static int argbuf_index;
1848
1849 /* Position in the argbuf array containing the name of the output file
1850    (the value associated with the "-o" flag).  */
1851
1852 static int have_o_argbuf_index = 0;
1853
1854 /* Were the options -c or -S passed.  */
1855 static int have_c = 0;
1856
1857 /* Was the option -o passed.  */
1858 static int have_o = 0;
1859
1860 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1861    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1862    it here.  */
1863
1864 static struct temp_name {
1865   const char *suffix;   /* suffix associated with the code.  */
1866   int length;           /* strlen (suffix).  */
1867   int unique;           /* Indicates whether %g or %u/%U was used.  */
1868   const char *filename; /* associated filename.  */
1869   int filename_length;  /* strlen (filename).  */
1870   struct temp_name *next;
1871 } *temp_names;
1872
1873 /* Number of commands executed so far.  */
1874
1875 static int execution_count;
1876
1877 /* Number of commands that exited with a signal.  */
1878
1879 static int signal_count;
1880
1881 /* Name with which this program was invoked.  */
1882
1883 static const char *programname;
1884 \f
1885 /* Allocate the argument vector.  */
1886
1887 static void
1888 alloc_args (void)
1889 {
1890   argbuf_length = 10;
1891   argbuf = xmalloc (argbuf_length * sizeof (const char *));
1892 }
1893
1894 /* Clear out the vector of arguments (after a command is executed).  */
1895
1896 static void
1897 clear_args (void)
1898 {
1899   argbuf_index = 0;
1900 }
1901
1902 /* Add one argument to the vector at the end.
1903    This is done when a space is seen or at the end of the line.
1904    If DELETE_ALWAYS is nonzero, the arg is a filename
1905     and the file should be deleted eventually.
1906    If DELETE_FAILURE is nonzero, the arg is a filename
1907     and the file should be deleted if this compilation fails.  */
1908
1909 static void
1910 store_arg (const char *arg, int delete_always, int delete_failure)
1911 {
1912   if (argbuf_index + 1 == argbuf_length)
1913     argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1914
1915   argbuf[argbuf_index++] = arg;
1916   argbuf[argbuf_index] = 0;
1917
1918   if (strcmp (arg, "-o") == 0)
1919     have_o_argbuf_index = argbuf_index;
1920   if (delete_always || delete_failure)
1921     record_temp_file (arg, delete_always, delete_failure);
1922 }
1923 \f
1924 /* Load specs from a file name named FILENAME, replacing occurrences of
1925    various different types of line-endings, \r\n, \n\r and just \r, with
1926    a single \n.  */
1927
1928 static char *
1929 load_specs (const char *filename)
1930 {
1931   int desc;
1932   int readlen;
1933   struct stat statbuf;
1934   char *buffer;
1935   char *buffer_p;
1936   char *specs;
1937   char *specs_p;
1938
1939   if (verbose_flag)
1940     notice ("Reading specs from %s\n", filename);
1941
1942   /* Open and stat the file.  */
1943   desc = open (filename, O_RDONLY, 0);
1944   if (desc < 0)
1945     pfatal_with_name (filename);
1946   if (stat (filename, &statbuf) < 0)
1947     pfatal_with_name (filename);
1948
1949   /* Read contents of file into BUFFER.  */
1950   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1951   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1952   if (readlen < 0)
1953     pfatal_with_name (filename);
1954   buffer[readlen] = 0;
1955   close (desc);
1956
1957   specs = xmalloc (readlen + 1);
1958   specs_p = specs;
1959   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1960     {
1961       int skip = 0;
1962       char c = *buffer_p;
1963       if (c == '\r')
1964         {
1965           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1966             skip = 1;
1967           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1968             skip = 1;
1969           else                                                  /* \r */
1970             c = '\n';
1971         }
1972       if (! skip)
1973         *specs_p++ = c;
1974     }
1975   *specs_p = '\0';
1976
1977   free (buffer);
1978   return (specs);
1979 }
1980
1981 /* Read compilation specs from a file named FILENAME,
1982    replacing the default ones.
1983
1984    A suffix which starts with `*' is a definition for
1985    one of the machine-specific sub-specs.  The "suffix" should be
1986    *asm, *cc1, *cpp, *link, *startfile, etc.
1987    The corresponding spec is stored in asm_spec, etc.,
1988    rather than in the `compilers' vector.
1989
1990    Anything invalid in the file is a fatal error.  */
1991
1992 static void
1993 read_specs (const char *filename, int main_p)
1994 {
1995   char *buffer;
1996   char *p;
1997
1998   buffer = load_specs (filename);
1999
2000   /* Scan BUFFER for specs, putting them in the vector.  */
2001   p = buffer;
2002   while (1)
2003     {
2004       char *suffix;
2005       char *spec;
2006       char *in, *out, *p1, *p2, *p3;
2007
2008       /* Advance P in BUFFER to the next nonblank nocomment line.  */
2009       p = skip_whitespace (p);
2010       if (*p == 0)
2011         break;
2012
2013       /* Is this a special command that starts with '%'? */
2014       /* Don't allow this for the main specs file, since it would
2015          encourage people to overwrite it.  */
2016       if (*p == '%' && !main_p)
2017         {
2018           p1 = p;
2019           while (*p && *p != '\n')
2020             p++;
2021
2022           /* Skip '\n'.  */
2023           p++;
2024
2025           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2026               && (p1[sizeof "%include" - 1] == ' '
2027                   || p1[sizeof "%include" - 1] == '\t'))
2028             {
2029               char *new_filename;
2030
2031               p1 += sizeof ("%include");
2032               while (*p1 == ' ' || *p1 == '\t')
2033                 p1++;
2034
2035               if (*p1++ != '<' || p[-2] != '>')
2036                 fatal ("specs %%include syntax malformed after %ld characters",
2037                        (long) (p1 - buffer + 1));
2038
2039               p[-2] = '\0';
2040               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2041               read_specs (new_filename ? new_filename : p1, FALSE);
2042               continue;
2043             }
2044           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2045                    && (p1[sizeof "%include_noerr" - 1] == ' '
2046                        || p1[sizeof "%include_noerr" - 1] == '\t'))
2047             {
2048               char *new_filename;
2049
2050               p1 += sizeof "%include_noerr";
2051               while (*p1 == ' ' || *p1 == '\t')
2052                 p1++;
2053
2054               if (*p1++ != '<' || p[-2] != '>')
2055                 fatal ("specs %%include syntax malformed after %ld characters",
2056                        (long) (p1 - buffer + 1));
2057
2058               p[-2] = '\0';
2059               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2060               if (new_filename)
2061                 read_specs (new_filename, FALSE);
2062               else if (verbose_flag)
2063                 notice ("could not find specs file %s\n", p1);
2064               continue;
2065             }
2066           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2067                    && (p1[sizeof "%rename" - 1] == ' '
2068                        || p1[sizeof "%rename" - 1] == '\t'))
2069             {
2070               int name_len;
2071               struct spec_list *sl;
2072               struct spec_list *newsl;
2073
2074               /* Get original name.  */
2075               p1 += sizeof "%rename";
2076               while (*p1 == ' ' || *p1 == '\t')
2077                 p1++;
2078
2079               if (! ISALPHA ((unsigned char) *p1))
2080                 fatal ("specs %%rename syntax malformed after %ld characters",
2081                        (long) (p1 - buffer));
2082
2083               p2 = p1;
2084               while (*p2 && !ISSPACE ((unsigned char) *p2))
2085                 p2++;
2086
2087               if (*p2 != ' ' && *p2 != '\t')
2088                 fatal ("specs %%rename syntax malformed after %ld characters",
2089                        (long) (p2 - buffer));
2090
2091               name_len = p2 - p1;
2092               *p2++ = '\0';
2093               while (*p2 == ' ' || *p2 == '\t')
2094                 p2++;
2095
2096               if (! ISALPHA ((unsigned char) *p2))
2097                 fatal ("specs %%rename syntax malformed after %ld characters",
2098                        (long) (p2 - buffer));
2099
2100               /* Get new spec name.  */
2101               p3 = p2;
2102               while (*p3 && !ISSPACE ((unsigned char) *p3))
2103                 p3++;
2104
2105               if (p3 != p - 1)
2106                 fatal ("specs %%rename syntax malformed after %ld characters",
2107                        (long) (p3 - buffer));
2108               *p3 = '\0';
2109
2110               for (sl = specs; sl; sl = sl->next)
2111                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2112                   break;
2113
2114               if (!sl)
2115                 fatal ("specs %s spec was not found to be renamed", p1);
2116
2117               if (strcmp (p1, p2) == 0)
2118                 continue;
2119
2120               for (newsl = specs; newsl; newsl = newsl->next)
2121                 if (strcmp (newsl->name, p2) == 0)
2122                   fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2123                     filename, p1, p2);
2124
2125               if (verbose_flag)
2126                 {
2127                   notice ("rename spec %s to %s\n", p1, p2);
2128 #ifdef DEBUG_SPECS
2129                   notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2130 #endif
2131                 }
2132
2133               set_spec (p2, *(sl->ptr_spec));
2134               if (sl->alloc_p)
2135                 free ((void *) *(sl->ptr_spec));
2136
2137               *(sl->ptr_spec) = "";
2138               sl->alloc_p = 0;
2139               continue;
2140             }
2141           else
2142             fatal ("specs unknown %% command after %ld characters",
2143                    (long) (p1 - buffer));
2144         }
2145
2146       /* Find the colon that should end the suffix.  */
2147       p1 = p;
2148       while (*p1 && *p1 != ':' && *p1 != '\n')
2149         p1++;
2150
2151       /* The colon shouldn't be missing.  */
2152       if (*p1 != ':')
2153         fatal ("specs file malformed after %ld characters",
2154                (long) (p1 - buffer));
2155
2156       /* Skip back over trailing whitespace.  */
2157       p2 = p1;
2158       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2159         p2--;
2160
2161       /* Copy the suffix to a string.  */
2162       suffix = save_string (p, p2 - p);
2163       /* Find the next line.  */
2164       p = skip_whitespace (p1 + 1);
2165       if (p[1] == 0)
2166         fatal ("specs file malformed after %ld characters",
2167                (long) (p - buffer));
2168
2169       p1 = p;
2170       /* Find next blank line or end of string.  */
2171       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2172         p1++;
2173
2174       /* Specs end at the blank line and do not include the newline.  */
2175       spec = save_string (p, p1 - p);
2176       p = p1;
2177
2178       /* Delete backslash-newline sequences from the spec.  */
2179       in = spec;
2180       out = spec;
2181       while (*in != 0)
2182         {
2183           if (in[0] == '\\' && in[1] == '\n')
2184             in += 2;
2185           else if (in[0] == '#')
2186             while (*in && *in != '\n')
2187               in++;
2188
2189           else
2190             *out++ = *in++;
2191         }
2192       *out = 0;
2193
2194       if (suffix[0] == '*')
2195         {
2196           if (! strcmp (suffix, "*link_command"))
2197             link_command_spec = spec;
2198           else
2199             set_spec (suffix + 1, spec);
2200         }
2201       else
2202         {
2203           /* Add this pair to the vector.  */
2204           compilers
2205             = xrealloc (compilers,
2206                         (n_compilers + 2) * sizeof (struct compiler));
2207
2208           compilers[n_compilers].suffix = suffix;
2209           compilers[n_compilers].spec = spec;
2210           n_compilers++;
2211           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2212         }
2213
2214       if (*suffix == 0)
2215         link_command_spec = spec;
2216     }
2217
2218   if (link_command_spec == 0)
2219     fatal ("spec file has no spec for linking");
2220 }
2221 \f
2222 /* Record the names of temporary files we tell compilers to write,
2223    and delete them at the end of the run.  */
2224
2225 /* This is the common prefix we use to make temp file names.
2226    It is chosen once for each run of this program.
2227    It is substituted into a spec by %g or %j.
2228    Thus, all temp file names contain this prefix.
2229    In practice, all temp file names start with this prefix.
2230
2231    This prefix comes from the envvar TMPDIR if it is defined;
2232    otherwise, from the P_tmpdir macro if that is defined;
2233    otherwise, in /usr/tmp or /tmp;
2234    or finally the current directory if all else fails.  */
2235
2236 static const char *temp_filename;
2237
2238 /* Length of the prefix.  */
2239
2240 static int temp_filename_length;
2241
2242 /* Define the list of temporary files to delete.  */
2243
2244 struct temp_file
2245 {
2246   const char *name;
2247   struct temp_file *next;
2248 };
2249
2250 /* Queue of files to delete on success or failure of compilation.  */
2251 static struct temp_file *always_delete_queue;
2252 /* Queue of files to delete on failure of compilation.  */
2253 static struct temp_file *failure_delete_queue;
2254
2255 /* Record FILENAME as a file to be deleted automatically.
2256    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2257    otherwise delete it in any case.
2258    FAIL_DELETE nonzero means delete it if a compilation step fails;
2259    otherwise delete it in any case.  */
2260
2261 void
2262 record_temp_file (const char *filename, int always_delete, int fail_delete)
2263 {
2264   char *const name = xstrdup (filename);
2265
2266   if (always_delete)
2267     {
2268       struct temp_file *temp;
2269       for (temp = always_delete_queue; temp; temp = temp->next)
2270         if (! strcmp (name, temp->name))
2271           goto already1;
2272
2273       temp = xmalloc (sizeof (struct temp_file));
2274       temp->next = always_delete_queue;
2275       temp->name = name;
2276       always_delete_queue = temp;
2277
2278     already1:;
2279     }
2280
2281   if (fail_delete)
2282     {
2283       struct temp_file *temp;
2284       for (temp = failure_delete_queue; temp; temp = temp->next)
2285         if (! strcmp (name, temp->name))
2286           goto already2;
2287
2288       temp = xmalloc (sizeof (struct temp_file));
2289       temp->next = failure_delete_queue;
2290       temp->name = name;
2291       failure_delete_queue = temp;
2292
2293     already2:;
2294     }
2295 }
2296
2297 /* Delete all the temporary files whose names we previously recorded.  */
2298
2299 #ifndef DELETE_IF_ORDINARY
2300 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2301 do                                                      \
2302   {                                                     \
2303     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2304       if (unlink (NAME) < 0)                            \
2305         if (VERBOSE_FLAG)                               \
2306           perror_with_name (NAME);                      \
2307   } while (0)
2308 #endif
2309
2310 static void
2311 delete_if_ordinary (const char *name)
2312 {
2313   struct stat st;
2314 #ifdef DEBUG
2315   int i, c;
2316
2317   printf ("Delete %s? (y or n) ", name);
2318   fflush (stdout);
2319   i = getchar ();
2320   if (i != '\n')
2321     while ((c = getchar ()) != '\n' && c != EOF)
2322       ;
2323
2324   if (i == 'y' || i == 'Y')
2325 #endif /* DEBUG */
2326   DELETE_IF_ORDINARY (name, st, verbose_flag);
2327 }
2328
2329 static void
2330 delete_temp_files (void)
2331 {
2332   struct temp_file *temp;
2333
2334   for (temp = always_delete_queue; temp; temp = temp->next)
2335     delete_if_ordinary (temp->name);
2336   always_delete_queue = 0;
2337 }
2338
2339 /* Delete all the files to be deleted on error.  */
2340
2341 static void
2342 delete_failure_queue (void)
2343 {
2344   struct temp_file *temp;
2345
2346   for (temp = failure_delete_queue; temp; temp = temp->next)
2347     delete_if_ordinary (temp->name);
2348 }
2349
2350 static void
2351 clear_failure_queue (void)
2352 {
2353   failure_delete_queue = 0;
2354 }
2355 \f
2356 /* Build a list of search directories from PATHS.
2357    PREFIX is a string to prepend to the list.
2358    If CHECK_DIR_P is nonzero we ensure the directory exists.
2359    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2360    It is also used by the --print-search-dirs flag.  */
2361
2362 static char *
2363 build_search_list (struct path_prefix *paths, const char *prefix,
2364                    int check_dir_p)
2365 {
2366   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2367   int just_suffix_len
2368     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2369   int first_time = TRUE;
2370   struct prefix_list *pprefix;
2371
2372   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2373   obstack_1grow (&collect_obstack, '=');
2374
2375   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2376     {
2377       int len = strlen (pprefix->prefix);
2378
2379       if (machine_suffix
2380           && (! check_dir_p
2381               || is_directory (pprefix->prefix, machine_suffix, 0)))
2382         {
2383           if (!first_time)
2384             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2385
2386           first_time = FALSE;
2387           obstack_grow (&collect_obstack, pprefix->prefix, len);
2388           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2389         }
2390
2391       if (just_machine_suffix
2392           && pprefix->require_machine_suffix == 2
2393           && (! check_dir_p
2394               || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2395         {
2396           if (! first_time)
2397             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2398
2399           first_time = FALSE;
2400           obstack_grow (&collect_obstack, pprefix->prefix, len);
2401           obstack_grow (&collect_obstack, just_machine_suffix,
2402                         just_suffix_len);
2403         }
2404
2405       if (! pprefix->require_machine_suffix)
2406         {
2407           if (! first_time)
2408             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2409
2410           first_time = FALSE;
2411           obstack_grow (&collect_obstack, pprefix->prefix, len);
2412         }
2413     }
2414
2415   obstack_1grow (&collect_obstack, '\0');
2416   return XOBFINISH (&collect_obstack, char *);
2417 }
2418
2419 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2420    for collect.  */
2421
2422 static void
2423 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2424 {
2425   putenv (build_search_list (paths, env_var, 1));
2426 }
2427 \f
2428 /* Check whether NAME can be accessed in MODE.  This is like access,
2429    except that it never considers directories to be executable.  */
2430
2431 static int
2432 access_check (const char *name, int mode)
2433 {
2434   if (mode == X_OK)
2435     {
2436       struct stat st;
2437
2438       if (stat (name, &st) < 0
2439           || S_ISDIR (st.st_mode))
2440         return -1;
2441     }
2442
2443   return access (name, mode);
2444 }
2445
2446 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2447    access to check permissions.
2448    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2449
2450 static char *
2451 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2452              int multilib)
2453 {
2454   char *temp;
2455   const char *const file_suffix =
2456     ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2457   struct prefix_list *pl;
2458   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2459   const char *multilib_name, *multilib_os_name;
2460
2461 #ifdef DEFAULT_ASSEMBLER
2462   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2463     return xstrdup (DEFAULT_ASSEMBLER);
2464 #endif
2465
2466 #ifdef DEFAULT_LINKER
2467   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2468     return xstrdup (DEFAULT_LINKER);
2469 #endif
2470
2471   if (machine_suffix)
2472     len += strlen (machine_suffix);
2473
2474   multilib_name = name;
2475   multilib_os_name = name;
2476   if (multilib && multilib_os_dir)
2477     {
2478       int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2479       int len2 = strlen (multilib_os_dir) + 1;
2480
2481       len += len1 > len2 ? len1 : len2;
2482       if (multilib_dir)
2483         multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2484                                   NULL));
2485       if (strcmp (multilib_os_dir, ".") != 0)
2486         multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2487                                     NULL));
2488     }
2489
2490   temp = xmalloc (len);
2491
2492   /* Determine the filename to execute (special case for absolute paths).  */
2493
2494   if (IS_ABSOLUTE_PATH (name))
2495     {
2496       if (access (name, mode) == 0)
2497         {
2498           strcpy (temp, name);
2499           return temp;
2500         }
2501     }
2502   else
2503     for (pl = pprefix->plist; pl; pl = pl->next)
2504       {
2505         const char *this_name
2506           = pl->os_multilib ? multilib_os_name : multilib_name;
2507
2508         if (machine_suffix)
2509           {
2510             /* Some systems have a suffix for executable files.
2511                So try appending that first.  */
2512             if (file_suffix[0] != 0)
2513               {
2514                 strcpy (temp, pl->prefix);
2515                 strcat (temp, machine_suffix);
2516                 strcat (temp, multilib_name);
2517                 strcat (temp, file_suffix);
2518                 if (access_check (temp, mode) == 0)
2519                   return temp;
2520               }
2521
2522             /* Now try just the multilib_name.  */
2523             strcpy (temp, pl->prefix);
2524             strcat (temp, machine_suffix);
2525             strcat (temp, multilib_name);
2526             if (access_check (temp, mode) == 0)
2527               return temp;
2528           }
2529
2530         /* Certain prefixes are tried with just the machine type,
2531            not the version.  This is used for finding as, ld, etc.  */
2532         if (just_machine_suffix && pl->require_machine_suffix == 2)
2533           {
2534             /* Some systems have a suffix for executable files.
2535                So try appending that first.  */
2536             if (file_suffix[0] != 0)
2537               {
2538                 strcpy (temp, pl->prefix);
2539                 strcat (temp, just_machine_suffix);
2540                 strcat (temp, multilib_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, just_machine_suffix);
2548             strcat (temp, multilib_name);
2549             if (access_check (temp, mode) == 0)
2550               return temp;
2551           }
2552
2553         /* Certain prefixes can't be used without the machine suffix
2554            when the machine or version is explicitly specified.  */
2555         if (! pl->require_machine_suffix)
2556           {
2557             /* Some systems have a suffix for executable files.
2558                So try appending that first.  */
2559             if (file_suffix[0] != 0)
2560               {
2561                 strcpy (temp, pl->prefix);
2562                 strcat (temp, this_name);
2563                 strcat (temp, file_suffix);
2564                 if (access_check (temp, mode) == 0)
2565                   return temp;
2566               }
2567
2568             strcpy (temp, pl->prefix);
2569             strcat (temp, this_name);
2570             if (access_check (temp, mode) == 0)
2571               return temp;
2572           }
2573       }
2574
2575   free (temp);
2576   return 0;
2577 }
2578
2579 /* Ranking of prefixes in the sort list. -B prefixes are put before
2580    all others.  */
2581
2582 enum path_prefix_priority
2583 {
2584   PREFIX_PRIORITY_B_OPT,
2585   PREFIX_PRIORITY_LAST
2586 };
2587
2588 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2589    order according to PRIORITY.  Within each PRIORITY, new entries are
2590    appended.
2591
2592    If WARN is nonzero, we will warn if no file is found
2593    through this prefix.  WARN should point to an int
2594    which will be set to 1 if this entry is used.
2595
2596    COMPONENT is the value to be passed to update_path.
2597
2598    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2599    the complete value of machine_suffix.
2600    2 means try both machine_suffix and just_machine_suffix.  */
2601
2602 static void
2603 add_prefix (struct path_prefix *pprefix, const char *prefix,
2604             const char *component, /* enum prefix_priority */ int priority,
2605             int require_machine_suffix, int os_multilib)
2606 {
2607   struct prefix_list *pl, **prev;
2608   int len;
2609
2610   for (prev = &pprefix->plist;
2611        (*prev) != NULL && (*prev)->priority <= priority;
2612        prev = &(*prev)->next)
2613     ;
2614
2615   /* Keep track of the longest prefix.  */
2616
2617   prefix = update_path (prefix, component);
2618   len = strlen (prefix);
2619   if (len > pprefix->max_len)
2620     pprefix->max_len = len;
2621
2622   pl = xmalloc (sizeof (struct prefix_list));
2623   pl->prefix = prefix;
2624   pl->require_machine_suffix = require_machine_suffix;
2625   pl->priority = priority;
2626   pl->os_multilib = os_multilib;
2627
2628   /* Insert after PREV.  */
2629   pl->next = (*prev);
2630   (*prev) = pl;
2631 }
2632
2633 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2634 static void
2635 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2636                       const char *component,
2637                       /* enum prefix_priority */ int priority,
2638                       int require_machine_suffix, int os_multilib)
2639 {
2640   if (!IS_ABSOLUTE_PATH (prefix))
2641     fatal ("system path '%s' is not absolute", prefix);
2642
2643   if (target_system_root)
2644     {
2645       if (target_sysroot_suffix)
2646           prefix = concat (target_sysroot_suffix, prefix, NULL);
2647       prefix = concat (target_system_root, prefix, NULL);
2648
2649       /* We have to override this because GCC's notion of sysroot
2650          moves along with GCC.  */
2651       component = "GCC";
2652     }
2653
2654   add_prefix (pprefix, prefix, component, priority,
2655               require_machine_suffix, os_multilib);
2656 }
2657 \f
2658 /* Execute the command specified by the arguments on the current line of spec.
2659    When using pipes, this includes several piped-together commands
2660    with `|' between them.
2661
2662    Return 0 if successful, -1 if failed.  */
2663
2664 static int
2665 execute (void)
2666 {
2667   int i;
2668   int n_commands;               /* # of command.  */
2669   char *string;
2670   struct pex_obj *pex;
2671   struct command
2672   {
2673     const char *prog;           /* program name.  */
2674     const char **argv;          /* vector of args.  */
2675   };
2676
2677   struct command *commands;     /* each command buffer with above info.  */
2678
2679   gcc_assert (!processing_spec_function);
2680
2681   /* Count # of piped commands.  */
2682   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2683     if (strcmp (argbuf[i], "|") == 0)
2684       n_commands++;
2685
2686   /* Get storage for each command.  */
2687   commands = alloca (n_commands * sizeof (struct command));
2688
2689   /* Split argbuf into its separate piped processes,
2690      and record info about each one.
2691      Also search for the programs that are to be run.  */
2692
2693   commands[0].prog = argbuf[0]; /* first command.  */
2694   commands[0].argv = &argbuf[0];
2695   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2696
2697   if (string)
2698     commands[0].argv[0] = string;
2699
2700   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2701     if (strcmp (argbuf[i], "|") == 0)
2702       {                         /* each command.  */
2703 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2704         fatal ("-pipe not supported");
2705 #endif
2706         argbuf[i] = 0;  /* termination of command args.  */
2707         commands[n_commands].prog = argbuf[i + 1];
2708         commands[n_commands].argv = &argbuf[i + 1];
2709         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2710                               X_OK, 0);
2711         if (string)
2712           commands[n_commands].argv[0] = string;
2713         n_commands++;
2714       }
2715
2716   argbuf[argbuf_index] = 0;
2717
2718   /* If -v, print what we are about to do, and maybe query.  */
2719
2720   if (verbose_flag)
2721     {
2722       /* For help listings, put a blank line between sub-processes.  */
2723       if (print_help_list)
2724         fputc ('\n', stderr);
2725
2726       /* Print each piped command as a separate line.  */
2727       for (i = 0; i < n_commands; i++)
2728         {
2729           const char *const *j;
2730
2731           if (verbose_only_flag)
2732             {
2733               for (j = commands[i].argv; *j; j++)
2734                 {
2735                   const char *p;
2736                   fprintf (stderr, " \"");
2737                   for (p = *j; *p; ++p)
2738                     {
2739                       if (*p == '"' || *p == '\\' || *p == '$')
2740                         fputc ('\\', stderr);
2741                       fputc (*p, stderr);
2742                     }
2743                   fputc ('"', stderr);
2744                 }
2745             }
2746           else
2747             for (j = commands[i].argv; *j; j++)
2748               fprintf (stderr, " %s", *j);
2749
2750           /* Print a pipe symbol after all but the last command.  */
2751           if (i + 1 != n_commands)
2752             fprintf (stderr, " |");
2753           fprintf (stderr, "\n");
2754         }
2755       fflush (stderr);
2756       if (verbose_only_flag != 0)
2757         {
2758           /* verbose_only_flag should act as if the spec was
2759              executed, so increment execution_count before
2760              returning.  This prevents spurious warnings about
2761              unused linker input files, etc.  */
2762           execution_count++;
2763           return 0;
2764         }
2765 #ifdef DEBUG
2766       notice ("\nGo ahead? (y or n) ");
2767       fflush (stderr);
2768       i = getchar ();
2769       if (i != '\n')
2770         while (getchar () != '\n')
2771           ;
2772
2773       if (i != 'y' && i != 'Y')
2774         return 0;
2775 #endif /* DEBUG */
2776     }
2777
2778 #ifdef ENABLE_VALGRIND_CHECKING
2779   /* Run the each command through valgrind.  To simplify prepending the
2780      path to valgrind and the option "-q" (for quiet operation unless
2781      something triggers), we allocate a separate argv array.  */
2782
2783   for (i = 0; i < n_commands; i++)
2784     {
2785       const char **argv;
2786       int argc;
2787       int j;
2788
2789       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2790         ;
2791
2792       argv = alloca ((argc + 3) * sizeof (char *));
2793
2794       argv[0] = VALGRIND_PATH;
2795       argv[1] = "-q";
2796       for (j = 2; j < argc + 2; j++)
2797         argv[j] = commands[i].argv[j - 2];
2798       argv[j] = NULL;
2799
2800       commands[i].argv = argv;
2801       commands[i].prog = argv[0];
2802     }
2803 #endif
2804
2805   /* Run each piped subprocess.  */
2806
2807   pex = pex_init (PEX_USE_PIPES | (report_times ? PEX_RECORD_TIMES : 0),
2808                   programname, temp_filename);
2809   if (pex == NULL)
2810     pfatal_with_name (_("pex_init failed"));
2811
2812   for (i = 0; i < n_commands; i++)
2813     {
2814       const char *errmsg;
2815       int err;
2816       const char *string = commands[i].argv[0];
2817
2818       errmsg = pex_run (pex,
2819                         ((i + 1 == n_commands ? PEX_LAST : 0)
2820                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2821                         string, (char * const *) commands[i].argv,
2822                         NULL, NULL, &err);
2823       if (errmsg != NULL)
2824         {
2825           if (err == 0)
2826             fatal (errmsg);
2827           else
2828             {
2829               errno = err;
2830               pfatal_with_name (errmsg);
2831             }
2832         }
2833
2834       if (string != commands[i].prog)
2835         free ((void *) string);
2836     }
2837
2838   execution_count++;
2839
2840   /* Wait for all the subprocesses to finish.  */
2841
2842   {
2843     int *statuses;
2844     struct pex_time *times = NULL;
2845     int ret_code = 0;
2846
2847     statuses = alloca (n_commands * sizeof (int));
2848     if (!pex_get_status (pex, n_commands, statuses))
2849       pfatal_with_name (_("failed to get exit status"));
2850
2851     if (report_times)
2852       {
2853         times = alloca (n_commands * sizeof (struct pex_time));
2854         if (!pex_get_times (pex, n_commands, times))
2855           pfatal_with_name (_("failed to get process times"));
2856       }
2857
2858     pex_free (pex);
2859
2860     for (i = 0; i < n_commands; ++i)
2861       {
2862         int status = statuses[i];
2863
2864         if (WIFSIGNALED (status))
2865           {
2866 #ifdef SIGPIPE
2867             /* SIGPIPE is a special case.  It happens in -pipe mode
2868                when the compiler dies before the preprocessor is done,
2869                or the assembler dies before the compiler is done.
2870                There's generally been an error already, and this is
2871                just fallout.  So don't generate another error unless
2872                we would otherwise have succeeded.  */
2873             if (WTERMSIG (status) == SIGPIPE
2874                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2875               ;
2876             else
2877 #endif
2878               fatal ("\
2879 Internal error: %s (program %s)\n\
2880 Please submit a full bug report.\n\
2881 See %s for instructions.",
2882                      strsignal (WTERMSIG (status)), commands[i].prog,
2883                      bug_report_url);
2884             signal_count++;
2885             ret_code = -1;
2886           }
2887         else if (WIFEXITED (status)
2888                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2889           {
2890             if (WEXITSTATUS (status) > greatest_status)
2891               greatest_status = WEXITSTATUS (status);
2892             ret_code = -1;
2893           }
2894
2895         if (report_times)
2896           {
2897             struct pex_time *pt = &times[i];
2898             double ut, st;
2899
2900             ut = ((double) pt->user_seconds
2901                   + (double) pt->user_microseconds / 1.0e6);
2902             st = ((double) pt->system_seconds
2903                   + (double) pt->system_microseconds / 1.0e6);
2904
2905             if (ut + st != 0)
2906               notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
2907           }
2908       }
2909
2910     return ret_code;
2911   }
2912 }
2913 \f
2914 /* Find all the switches given to us
2915    and make a vector describing them.
2916    The elements of the vector are strings, one per switch given.
2917    If a switch uses following arguments, then the `part1' field
2918    is the switch itself and the `args' field
2919    is a null-terminated vector containing the following arguments.
2920    The `live_cond' field is:
2921    0 when initialized
2922    1 if the switch is true in a conditional spec,
2923    -1 if false (overridden by a later switch)
2924    -2 if this switch should be ignored (used in %<S)
2925    The `validated' field is nonzero if any spec has looked at this switch;
2926    if it remains zero at the end of the run, it must be meaningless.  */
2927
2928 #define SWITCH_OK       0
2929 #define SWITCH_FALSE   -1
2930 #define SWITCH_IGNORE  -2
2931 #define SWITCH_LIVE     1
2932
2933 struct switchstr
2934 {
2935   const char *part1;
2936   const char **args;
2937   int live_cond;
2938   unsigned char validated;
2939   unsigned char ordering;
2940 };
2941
2942 static struct switchstr *switches;
2943
2944 static int n_switches;
2945
2946 /* Language is one of three things:
2947
2948    1) The name of a real programming language.
2949    2) NULL, indicating that no one has figured out
2950    what it is yet.
2951    3) '*', indicating that the file should be passed
2952    to the linker.  */
2953 struct infile
2954 {
2955   const char *name;
2956   const char *language;
2957   struct compiler *incompiler;
2958   bool compiled;
2959   bool preprocessed;
2960 };
2961
2962 /* Also a vector of input files specified.  */
2963
2964 static struct infile *infiles;
2965
2966 int n_infiles;
2967
2968 /* True if multiple input files are being compiled to a single
2969    assembly file.  */
2970
2971 static bool combine_inputs;
2972
2973 /* This counts the number of libraries added by lang_specific_driver, so that
2974    we can tell if there were any user supplied any files or libraries.  */
2975
2976 static int added_libraries;
2977
2978 /* And a vector of corresponding output files is made up later.  */
2979
2980 const char **outfiles;
2981 \f
2982 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2983
2984 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2985    is true if we should look for an executable suffix.  DO_OBJ
2986    is true if we should look for an object suffix.  */
2987
2988 static const char *
2989 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2990                   int do_obj ATTRIBUTE_UNUSED)
2991 {
2992 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2993   int i;
2994 #endif
2995   int len;
2996
2997   if (name == NULL)
2998     return NULL;
2999
3000   len = strlen (name);
3001
3002 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3003   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
3004   if (do_obj && len > 2
3005       && name[len - 2] == '.'
3006       && name[len - 1] == 'o')
3007     {
3008       obstack_grow (&obstack, name, len - 2);
3009       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3010       name = XOBFINISH (&obstack, const char *);
3011     }
3012 #endif
3013
3014 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3015   /* If there is no filetype, make it the executable suffix (which includes
3016      the ".").  But don't get confused if we have just "-o".  */
3017   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3018     return name;
3019
3020   for (i = len - 1; i >= 0; i--)
3021     if (IS_DIR_SEPARATOR (name[i]))
3022       break;
3023
3024   for (i++; i < len; i++)
3025     if (name[i] == '.')
3026       return name;
3027
3028   obstack_grow (&obstack, name, len);
3029   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3030                  strlen (TARGET_EXECUTABLE_SUFFIX));
3031   name = XOBFINISH (&obstack, const char *);
3032 #endif
3033
3034   return name;
3035 }
3036 #endif
3037 \f
3038 /* Display the command line switches accepted by gcc.  */
3039 static void
3040 display_help (void)
3041 {
3042   printf (_("Usage: %s [options] file...\n"), programname);
3043   fputs (_("Options:\n"), stdout);
3044
3045   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3046   fputs (_("  --help                   Display this information\n"), stdout);
3047   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3048   if (! verbose_flag)
3049     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3050   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3051   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3052   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3053   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3054   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3055   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3056   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3057   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3058   fputs (_("\
3059   -print-multi-lib         Display the mapping between command line options and\n\
3060                            multiple library search directories\n"), stdout);
3061   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3062   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3063   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3064   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3065   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3066   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3067   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3068   fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3069   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3070   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3071   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3072   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3073   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3074   fputs (_("\
3075   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3076                            for headers and libraries\n"), stdout);
3077   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3078   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3079   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3080   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3081   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3082   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3083   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3084   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3085   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3086   fputs (_("\
3087   -x <language>            Specify the language of the following input files\n\
3088                            Permissible languages include: c c++ assembler none\n\
3089                            'none' means revert to the default behavior of\n\
3090                            guessing the language based on the file's extension\n\
3091 "), stdout);
3092
3093   printf (_("\
3094 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3095  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3096  other options on to these processes the -W<letter> options must be used.\n\
3097 "), programname);
3098
3099   /* The rest of the options are displayed by invocations of the various
3100      sub-processes.  */
3101 }
3102
3103 static void
3104 add_preprocessor_option (const char *option, int len)
3105 {
3106   n_preprocessor_options++;
3107
3108   if (! preprocessor_options)
3109     preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3110   else
3111     preprocessor_options = xrealloc (preprocessor_options,
3112                                      n_preprocessor_options * sizeof (char *));
3113
3114   preprocessor_options [n_preprocessor_options - 1] =
3115     save_string (option, len);
3116 }
3117
3118 static void
3119 add_assembler_option (const char *option, int len)
3120 {
3121   n_assembler_options++;
3122
3123   if (! assembler_options)
3124     assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3125   else
3126     assembler_options = xrealloc (assembler_options,
3127                                   n_assembler_options * sizeof (char *));
3128
3129   assembler_options [n_assembler_options - 1] = save_string (option, len);
3130 }
3131
3132 static void
3133 add_linker_option (const char *option, int len)
3134 {
3135   n_linker_options++;
3136
3137   if (! linker_options)
3138     linker_options = xmalloc (n_linker_options * sizeof (char *));
3139   else
3140     linker_options = xrealloc (linker_options,
3141                                n_linker_options * sizeof (char *));
3142
3143   linker_options [n_linker_options - 1] = save_string (option, len);
3144 }
3145 \f
3146 /* Create the vector `switches' and its contents.
3147    Store its length in `n_switches'.  */
3148
3149 static void
3150 process_command (int argc, const char **argv)
3151 {
3152   int i;
3153   const char *temp;
3154   char *temp1;
3155   const char *spec_lang = 0;
3156   int last_language_n_infiles;
3157   int lang_n_infiles = 0;
3158 #ifdef MODIFY_TARGET_NAME
3159   int is_modify_target_name;
3160   int j;
3161 #endif
3162
3163   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3164
3165   n_switches = 0;
3166   n_infiles = 0;
3167   added_libraries = 0;
3168
3169   /* Figure compiler version from version string.  */
3170
3171   compiler_version = temp1 = xstrdup (version_string);
3172
3173   for (; *temp1; ++temp1)
3174     {
3175       if (*temp1 == ' ')
3176         {
3177           *temp1 = '\0';
3178           break;
3179         }
3180     }
3181
3182   /* If there is a -V or -b option (or both), process it now, before
3183      trying to interpret the rest of the command line. 
3184      Use heuristic that all configuration names must have at least
3185      one dash '-'. This allows us to pass options starting with -b.  */
3186   if (argc > 1 && argv[1][0] == '-'
3187       && (argv[1][1] == 'V' || 
3188          ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
3189     {
3190       const char *new_version = DEFAULT_TARGET_VERSION;
3191       const char *new_machine = DEFAULT_TARGET_MACHINE;
3192       const char *progname = argv[0];
3193       char **new_argv;
3194       char *new_argv0;
3195       int baselen;
3196
3197       while (argc > 1 && argv[1][0] == '-'
3198              && (argv[1][1] == 'V' ||
3199                 ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
3200         {
3201           char opt = argv[1][1];
3202           const char *arg;
3203           if (argv[1][2] != '\0')
3204             {
3205               arg = argv[1] + 2;
3206               argc -= 1;
3207               argv += 1;
3208             }
3209           else if (argc > 2)
3210             {
3211               arg = argv[2];
3212               argc -= 2;
3213               argv += 2;
3214             }
3215           else
3216             fatal ("'-%c' option must have argument", opt);
3217           if (opt == 'V')
3218             new_version = arg;
3219           else
3220             new_machine = arg;
3221         }
3222
3223       for (baselen = strlen (progname); baselen > 0; baselen--)
3224         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3225           break;
3226       new_argv0 = xmemdup (progname, baselen,
3227                            baselen + concat_length (new_version, new_machine,
3228                                                     "-gcc-", NULL) + 1);
3229       strcpy (new_argv0 + baselen, new_machine);
3230       strcat (new_argv0, "-gcc-");
3231       strcat (new_argv0, new_version);
3232
3233       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3234                           (argc + 1) * sizeof (argv[0]));
3235       new_argv[0] = new_argv0;
3236
3237       execvp (new_argv0, new_argv);
3238       fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3239     }
3240
3241   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3242      see if we can create it from the pathname specified in argv[0].  */
3243
3244   gcc_libexec_prefix = standard_libexec_prefix;
3245 #ifndef VMS
3246   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3247   if (!gcc_exec_prefix)
3248     {
3249       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3250                                               standard_exec_prefix);
3251       gcc_libexec_prefix = make_relative_prefix (argv[0],
3252                                                  standard_bindir_prefix,
3253                                                  standard_libexec_prefix);
3254       if (gcc_exec_prefix)
3255         putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3256     }
3257   else
3258     gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3259                                                standard_exec_prefix,
3260                                                standard_libexec_prefix);
3261 #else
3262 #endif
3263
3264   if (gcc_exec_prefix)
3265     {
3266       int len = strlen (gcc_exec_prefix);
3267
3268       if (len > (int) sizeof ("/lib/gcc/") - 1
3269           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3270         {
3271           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3272           if (IS_DIR_SEPARATOR (*temp)
3273               && strncmp (temp + 1, "lib", 3) == 0
3274               && IS_DIR_SEPARATOR (temp[4])
3275               && strncmp (temp + 5, "gcc", 3) == 0)
3276             len -= sizeof ("/lib/gcc/") - 1;
3277         }
3278
3279       set_std_prefix (gcc_exec_prefix, len);
3280       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3281                   PREFIX_PRIORITY_LAST, 0, 0);
3282       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3283                   PREFIX_PRIORITY_LAST, 0, 0);
3284     }
3285
3286   /* COMPILER_PATH and LIBRARY_PATH have values
3287      that are lists of directory names with colons.  */
3288
3289   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3290   if (temp)
3291     {
3292       const char *startp, *endp;
3293       char *nstore = alloca (strlen (temp) + 3);
3294
3295       startp = endp = temp;
3296       while (1)
3297         {
3298           if (*endp == PATH_SEPARATOR || *endp == 0)
3299             {
3300               strncpy (nstore, startp, endp - startp);
3301               if (endp == startp)
3302                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3303               else if (!IS_DIR_SEPARATOR (endp[-1]))
3304                 {
3305                   nstore[endp - startp] = DIR_SEPARATOR;
3306                   nstore[endp - startp + 1] = 0;
3307                 }
3308               else
3309                 nstore[endp - startp] = 0;
3310               add_prefix (&exec_prefixes, nstore, 0,
3311                           PREFIX_PRIORITY_LAST, 0, 0);
3312               add_prefix (&include_prefixes, nstore, 0,
3313                           PREFIX_PRIORITY_LAST, 0, 0);
3314               if (*endp == 0)
3315                 break;
3316               endp = startp = endp + 1;
3317             }
3318           else
3319             endp++;
3320         }
3321     }
3322
3323   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3324   if (temp && *cross_compile == '0')
3325     {
3326       const char *startp, *endp;
3327       char *nstore = alloca (strlen (temp) + 3);
3328
3329       startp = endp = temp;
3330       while (1)
3331         {
3332           if (*endp == PATH_SEPARATOR || *endp == 0)
3333             {
3334               strncpy (nstore, startp, endp - startp);
3335               if (endp == startp)
3336                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3337               else if (!IS_DIR_SEPARATOR (endp[-1]))
3338                 {
3339                   nstore[endp - startp] = DIR_SEPARATOR;
3340                   nstore[endp - startp + 1] = 0;
3341                 }
3342               else
3343                 nstore[endp - startp] = 0;
3344               add_prefix (&startfile_prefixes, nstore, NULL,
3345                           PREFIX_PRIORITY_LAST, 0, 1);
3346               if (*endp == 0)
3347                 break;
3348               endp = startp = endp + 1;
3349             }
3350           else
3351             endp++;
3352         }
3353     }
3354
3355   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3356   GET_ENVIRONMENT (temp, "LPATH");
3357   if (temp && *cross_compile == '0')
3358     {
3359       const char *startp, *endp;
3360       char *nstore = alloca (strlen (temp) + 3);
3361
3362       startp = endp = temp;
3363       while (1)
3364         {
3365           if (*endp == PATH_SEPARATOR || *endp == 0)
3366             {
3367               strncpy (nstore, startp, endp - startp);
3368               if (endp == startp)
3369                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3370               else if (!IS_DIR_SEPARATOR (endp[-1]))
3371                 {
3372                   nstore[endp - startp] = DIR_SEPARATOR;
3373                   nstore[endp - startp + 1] = 0;
3374                 }
3375               else
3376                 nstore[endp - startp] = 0;
3377               add_prefix (&startfile_prefixes, nstore, NULL,
3378                           PREFIX_PRIORITY_LAST, 0, 1);
3379               if (*endp == 0)
3380                 break;
3381               endp = startp = endp + 1;
3382             }
3383           else
3384             endp++;
3385         }
3386     }
3387
3388   /* Convert new-style -- options to old-style.  */
3389   translate_options (&argc, (const char *const **) &argv);
3390
3391   /* Do language-specific adjustment/addition of flags.  */
3392   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3393
3394   /* Scan argv twice.  Here, the first time, just count how many switches
3395      there will be in their vector, and how many input files in theirs.
3396      Here we also parse the switches that cc itself uses (e.g. -v).  */
3397
3398   for (i = 1; i < argc; i++)
3399     {
3400       if (! strcmp (argv[i], "-dumpspecs"))
3401         {
3402           struct spec_list *sl;
3403           init_spec ();
3404           for (sl = specs; sl; sl = sl->next)
3405             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3406           if (link_command_spec)
3407             printf ("*link_command:\n%s\n\n", link_command_spec);
3408           exit (0);
3409         }
3410       else if (! strcmp (argv[i], "-dumpversion"))
3411         {
3412           printf ("%s\n", spec_version);
3413           exit (0);
3414         }
3415       else if (! strcmp (argv[i], "-dumpmachine"))
3416         {
3417           printf ("%s\n", spec_machine);
3418           exit (0);
3419         }
3420       else if (strcmp (argv[i], "-fversion") == 0)
3421         {
3422           /* translate_options () has turned --version into -fversion.  */
3423           printf (_("%s (GCC) %s\n"), programname, version_string);
3424           printf ("Copyright %s 2005 Free Software Foundation, Inc.\n",
3425                   _("(C)"));
3426           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3427 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3428                  stdout);
3429           exit (0);
3430         }
3431       else if (strcmp (argv[i], "-fhelp") == 0)
3432         {
3433           /* translate_options () has turned --help into -fhelp.  */
3434           print_help_list = 1;
3435
3436           /* We will be passing a dummy file on to the sub-processes.  */
3437           n_infiles++;
3438           n_switches++;
3439
3440           /* CPP driver cannot obtain switch from cc1_options.  */
3441           if (is_cpp_driver)
3442             add_preprocessor_option ("--help", 6);
3443           add_assembler_option ("--help", 6);
3444           add_linker_option ("--help", 6);
3445         }
3446       else if (strcmp (argv[i], "-ftarget-help") == 0)
3447         {
3448           /* translate_options() has turned --target-help into -ftarget-help.  */
3449           target_help_flag = 1;
3450
3451           /* We will be passing a dummy file on to the sub-processes.  */
3452           n_infiles++;
3453           n_switches++;
3454
3455           /* CPP driver cannot obtain switch from cc1_options.  */
3456           if (is_cpp_driver)
3457             add_preprocessor_option ("--target-help", 13);
3458           add_assembler_option ("--target-help", 13);
3459           add_linker_option ("--target-help", 13);
3460         }
3461       else if (! strcmp (argv[i], "-pass-exit-codes"))
3462         {
3463           pass_exit_codes = 1;
3464           n_switches++;
3465         }
3466       else if (! strcmp (argv[i], "-print-search-dirs"))
3467         print_search_dirs = 1;
3468       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3469         print_file_name = "libgcc.a";
3470       else if (! strncmp (argv[i], "-print-file-name=", 17))
3471         print_file_name = argv[i] + 17;
3472       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3473         print_prog_name = argv[i] + 17;
3474       else if (! strcmp (argv[i], "-print-multi-lib"))
3475         print_multi_lib = 1;
3476       else if (! strcmp (argv[i], "-print-multi-directory"))
3477         print_multi_directory = 1;
3478       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3479         print_multi_os_directory = 1;
3480       else if (! strncmp (argv[i], "-Wa,", 4))
3481         {
3482           int prev, j;
3483           /* Pass the rest of this option to the assembler.  */
3484
3485           /* Split the argument at commas.  */
3486           prev = 4;
3487           for (j = 4; argv[i][j]; j++)
3488             if (argv[i][j] == ',')
3489               {
3490                 add_assembler_option (argv[i] + prev, j - prev);
3491                 prev = j + 1;
3492               }
3493
3494           /* Record the part after the last comma.  */
3495           add_assembler_option (argv[i] + prev, j - prev);
3496         }
3497       else if (! strncmp (argv[i], "-Wp,", 4))
3498         {
3499           int prev, j;
3500           /* Pass the rest of this option to the preprocessor.  */
3501
3502           /* Split the argument at commas.  */
3503           prev = 4;
3504           for (j = 4; argv[i][j]; j++)
3505             if (argv[i][j] == ',')
3506               {
3507                 add_preprocessor_option (argv[i] + prev, j - prev);
3508                 prev = j + 1;
3509               }
3510
3511           /* Record the part after the last comma.  */
3512           add_preprocessor_option (argv[i] + prev, j - prev);
3513         }
3514       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3515         /* The +e options to the C++ front-end.  */
3516         n_switches++;
3517       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3518         {
3519           int j;
3520           /* Split the argument at commas.  */
3521           for (j = 3; argv[i][j]; j++)
3522             n_infiles += (argv[i][j] == ',');
3523         }
3524       else if (strcmp (argv[i], "-Xlinker") == 0)
3525         {
3526           if (i + 1 == argc)
3527             fatal ("argument to '-Xlinker' is missing");
3528
3529           n_infiles++;
3530           i++;
3531         }
3532       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3533         {
3534           if (i + 1 == argc)
3535             fatal ("argument to '-Xpreprocessor' is missing");
3536
3537           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3538         }
3539       else if (strcmp (argv[i], "-Xassembler") == 0)
3540         {
3541           if (i + 1 == argc)
3542             fatal ("argument to '-Xassembler' is missing");
3543
3544           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3545         }
3546       else if (strcmp (argv[i], "-l") == 0)
3547         {
3548           if (i + 1 == argc)
3549             fatal ("argument to '-l' is missing");
3550
3551           n_infiles++;
3552           i++;
3553         }
3554       else if (strncmp (argv[i], "-l", 2) == 0)
3555         n_infiles++;
3556       else if (strcmp (argv[i], "-save-temps") == 0)
3557         {
3558           save_temps_flag = 1;
3559           n_switches++;
3560         }
3561       else if (strcmp (argv[i], "-combine") == 0)
3562         {
3563           combine_flag = 1;
3564           n_switches++;
3565         }
3566       else if (strcmp (argv[i], "-specs") == 0)
3567         {
3568           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3569           if (++i >= argc)
3570             fatal ("argument to '-specs' is missing");
3571
3572           user->next = (struct user_specs *) 0;
3573           user->filename = argv[i];
3574           if (user_specs_tail)
3575             user_specs_tail->next = user;
3576           else
3577             user_specs_head = user;
3578           user_specs_tail = user;
3579         }
3580       else if (strncmp (argv[i], "-specs=", 7) == 0)
3581         {
3582           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3583           if (strlen (argv[i]) == 7)
3584             fatal ("argument to '-specs=' is missing");
3585
3586           user->next = (struct user_specs *) 0;
3587           user->filename = argv[i] + 7;
3588           if (user_specs_tail)
3589             user_specs_tail->next = user;
3590           else
3591             user_specs_head = user;
3592           user_specs_tail = user;
3593         }
3594       else if (strcmp (argv[i], "-time") == 0)
3595         report_times = 1;
3596       else if (strcmp (argv[i], "-pipe") == 0)
3597         {
3598           /* -pipe has to go into the switches array as well as
3599              setting a flag.  */
3600           use_pipes = 1;
3601           n_switches++;
3602         }
3603       else if (strcmp (argv[i], "-###") == 0)
3604         {
3605           /* This is similar to -v except that there is no execution
3606              of the commands and the echoed arguments are quoted.  It
3607              is intended for use in shell scripts to capture the
3608              driver-generated command line.  */
3609           verbose_only_flag++;
3610           verbose_flag++;
3611         }
3612       else if (argv[i][0] == '-' && argv[i][1] != 0)
3613         {
3614           const char *p = &argv[i][1];
3615           int c = *p;
3616
3617           switch (c)
3618             {
3619             case 'b':
3620               if (NULL == strchr(argv[i] + 2, '-')) break;
3621             case 'V':
3622               fatal ("'-%c' must come at the start of the command line", c);
3623               break;
3624
3625             case 'B':
3626               {
3627                 const char *value;
3628                 int len;
3629
3630                 if (p[1] == 0 && i + 1 == argc)
3631                   fatal ("argument to '-B' is missing");
3632                 if (p[1] == 0)
3633                   value = argv[++i];
3634                 else
3635                   value = p + 1;
3636
3637                 len = strlen (value);
3638
3639                 /* Catch the case where the user has forgotten to append a
3640                    directory separator to the path.  Note, they may be using
3641                    -B to add an executable name prefix, eg "i386-elf-", in
3642                    order to distinguish between multiple installations of
3643                    GCC in the same directory.  Hence we must check to see
3644                    if appending a directory separator actually makes a
3645                    valid directory name.  */
3646                 if (! IS_DIR_SEPARATOR (value [len - 1])
3647                     && is_directory (value, "", 0))
3648                   {
3649                     char *tmp = xmalloc (len + 2);
3650                     strcpy (tmp, value);
3651                     tmp[len] = DIR_SEPARATOR;
3652                     tmp[++ len] = 0;
3653                     value = tmp;
3654                   }
3655
3656                 /* As a kludge, if the arg is "[foo/]stageN/", just
3657                    add "[foo/]include" to the include prefix.  */
3658                 if ((len == 7
3659                      || (len > 7
3660                          && (IS_DIR_SEPARATOR (value[len - 8]))))
3661                     && strncmp (value + len - 7, "stage", 5) == 0
3662                     && ISDIGIT (value[len - 2])
3663                     && (IS_DIR_SEPARATOR (value[len - 1])))
3664                   {
3665                     if (len == 7)
3666                       add_prefix (&include_prefixes, "./", NULL,
3667                                   PREFIX_PRIORITY_B_OPT, 0, 0);
3668                     else
3669                       {
3670                         char *string = xmalloc (len - 6);
3671                         memcpy (string, value, len - 7);
3672                         string[len - 7] = 0;
3673                         add_prefix (&include_prefixes, string, NULL,
3674                                     PREFIX_PRIORITY_B_OPT, 0, 0);
3675                       }
3676                   }
3677
3678                 add_prefix (&exec_prefixes, value, NULL,
3679                             PREFIX_PRIORITY_B_OPT, 0, 0);
3680                 add_prefix (&startfile_prefixes, value, NULL,
3681                             PREFIX_PRIORITY_B_OPT, 0, 0);
3682                 add_prefix (&include_prefixes, value, NULL,
3683                             PREFIX_PRIORITY_B_OPT, 0, 0);
3684                 n_switches++;
3685               }
3686               break;
3687
3688             case 'v':   /* Print our subcommands and print versions.  */
3689               n_switches++;
3690               /* If they do anything other than exactly `-v', don't set
3691                  verbose_flag; rather, continue on to give the error.  */
3692               if (p[1] != 0)
3693                 break;
3694               verbose_flag++;
3695               break;
3696
3697             case 'S':
3698             case 'c':
3699               if (p[1] == 0)
3700                 {
3701                   have_c = 1;
3702                   n_switches++;
3703                   break;
3704                 }
3705               goto normal_switch;
3706
3707             case 'o':
3708               have_o = 1;
3709 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3710               if (! have_c)
3711                 {
3712                   int skip;
3713
3714                   /* Forward scan, just in case -S or -c is specified
3715                      after -o.  */
3716                   int j = i + 1;
3717                   if (p[1] == 0)
3718                     ++j;
3719                   while (j < argc)
3720                     {
3721                       if (argv[j][0] == '-')
3722                         {
3723                           if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3724                               && argv[j][2] == 0)
3725                             {
3726                               have_c = 1;
3727                               break;
3728                             }
3729                           else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3730                             j += skip - (argv[j][2] != 0);
3731                           else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3732                             j += skip;
3733                         }
3734                       j++;
3735                     }
3736                 }
3737 #endif
3738 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3739               if (p[1] == 0)
3740                 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3741               else
3742                 argv[i] = convert_filename (argv[i], ! have_c, 0);
3743 #endif
3744               goto normal_switch;
3745
3746             default:
3747             normal_switch:
3748
3749 #ifdef MODIFY_TARGET_NAME
3750               is_modify_target_name = 0;
3751
3752               for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3753                 if (! strcmp (argv[i], modify_target[j].sw))
3754                   {
3755                     char *new_name = xmalloc (strlen (modify_target[j].str)
3756                                               + strlen (spec_machine));
3757                     const char *p, *r;
3758                     char *q;
3759                     int made_addition = 0;
3760
3761                     is_modify_target_name = 1;
3762                     for (p = spec_machine, q = new_name; *p != 0; )
3763                       {
3764                         if (modify_target[j].add_del == DELETE
3765                             && (! strncmp (q, modify_target[j].str,
3766                                            strlen (modify_target[j].str))))
3767                           p += strlen (modify_target[j].str);
3768                         else if (modify_target[j].add_del == ADD
3769                                  && ! made_addition && *p == '-')
3770                           {
3771                             for (r = modify_target[j].str; *r != 0; )
3772                               *q++ = *r++;
3773                             made_addition = 1;
3774                           }
3775
3776                         *q++ = *p++;
3777                       }
3778
3779                     spec_machine = new_name;
3780                   }
3781
3782               if (is_modify_target_name)
3783                 break;
3784 #endif
3785
3786               n_switches++;
3787
3788               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3789                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3790               else if (WORD_SWITCH_TAKES_ARG (p))
3791                 i += WORD_SWITCH_TAKES_ARG (p);
3792             }
3793         }
3794       else
3795         {
3796           n_infiles++;
3797           lang_n_infiles++;
3798         }
3799     }
3800
3801   if (save_temps_flag && use_pipes)
3802     {
3803       /* -save-temps overrides -pipe, so that temp files are produced */
3804       if (save_temps_flag)
3805         error ("warning: -pipe ignored because -save-temps specified");
3806       use_pipes = 0;
3807     }
3808
3809   /* Set up the search paths before we go looking for config files.  */
3810
3811   /* These come before the md prefixes so that we will find gcc's subcommands
3812      (such as cpp) rather than those of the host system.  */
3813   /* Use 2 as fourth arg meaning try just the machine as a suffix,
3814      as well as trying the machine and the version.  */
3815 #ifndef OS2
3816   add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3817               PREFIX_PRIORITY_LAST, 1, 0);
3818   add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3819               PREFIX_PRIORITY_LAST, 2, 0);
3820   add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3821               PREFIX_PRIORITY_LAST, 2, 0);
3822   add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3823               PREFIX_PRIORITY_LAST, 2, 0);
3824   add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3825               PREFIX_PRIORITY_LAST, 2, 0);
3826 #endif
3827
3828   add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3829               PREFIX_PRIORITY_LAST, 1, 0);
3830   add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
3831               PREFIX_PRIORITY_LAST, 1, 0);
3832
3833   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3834                            dir_separator_str, NULL);
3835
3836   /* If tooldir is relative, base it on exec_prefixes.  A relative
3837      tooldir lets us move the installed tree as a unit.
3838
3839      If GCC_EXEC_PREFIX is defined, then we want to add two relative
3840      directories, so that we can search both the user specified directory
3841      and the standard place.  */
3842
3843   if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3844     {
3845       if (gcc_exec_prefix)
3846         {
3847           char *gcc_exec_tooldir_prefix
3848             = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3849                       spec_version, dir_separator_str, tooldir_prefix, NULL);
3850
3851           add_prefix (&exec_prefixes,
3852                       concat (gcc_exec_tooldir_prefix, "bin",
3853                               dir_separator_str, NULL),
3854                       NULL, PREFIX_PRIORITY_LAST, 0, 0);
3855           add_prefix (&startfile_prefixes,
3856                       concat (gcc_exec_tooldir_prefix, "lib",
3857                               dir_separator_str, NULL),
3858                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
3859         }
3860
3861       tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3862                                dir_separator_str, spec_version,
3863                                dir_separator_str, tooldir_prefix, NULL);
3864     }
3865
3866   add_prefix (&exec_prefixes,
3867               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3868               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3869   add_prefix (&startfile_prefixes,
3870               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3871               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3872
3873 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3874   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3875      then consider it to relocate with the rest of the GCC installation
3876      if GCC_EXEC_PREFIX is set.
3877      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3878   if (target_system_root && gcc_exec_prefix)
3879     {
3880       char *tmp_prefix = make_relative_prefix (argv[0],
3881                                                standard_bindir_prefix,
3882                                                target_system_root);
3883       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3884         {
3885           target_system_root = tmp_prefix;
3886           target_system_root_changed = 1;
3887         }
3888     }
3889 #endif
3890
3891   /* More prefixes are enabled in main, after we read the specs file
3892      and determine whether this is cross-compilation or not.  */
3893
3894   /* Then create the space for the vectors and scan again.  */
3895
3896   switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3897   infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3898   n_switches = 0;
3899   n_infiles = 0;
3900   last_language_n_infiles = -1;
3901
3902   /* This, time, copy the text of each switch and store a pointer
3903      to the copy in the vector of switches.
3904      Store all the infiles in their vector.  */
3905
3906   for (i = 1; i < argc; i++)
3907     {
3908       /* Just skip the switches that were handled by the preceding loop.  */
3909 #ifdef MODIFY_TARGET_NAME
3910       is_modify_target_name = 0;
3911
3912       for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3913         if (! strcmp (argv[i], modify_target[j].sw))
3914           is_modify_target_name = 1;
3915
3916       if (is_modify_target_name)
3917         ;
3918       else
3919 #endif
3920       if (! strncmp (argv[i], "-Wa,", 4))
3921         ;
3922       else if (! strncmp (argv[i], "-Wp,", 4))
3923         ;
3924       else if (! strcmp (argv[i], "-pass-exit-codes"))
3925         ;
3926       else if (! strcmp (argv[i], "-print-search-dirs"))
3927         ;
3928       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3929         ;
3930       else if (! strncmp (argv[i], "-print-file-name=", 17))
3931         ;
3932       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3933         ;
3934       else if (! strcmp (argv[i], "-print-multi-lib"))
3935         ;
3936       else if (! strcmp (argv[i], "-print-multi-directory"))
3937         ;
3938       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3939         ;
3940       else if (! strcmp (argv[i], "-ftarget-help"))
3941         ;
3942       else if (! strcmp (argv[i], "-fhelp"))
3943         ;
3944       else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
3945         {
3946           target_system_root = argv[i] + strlen ("--sysroot=");
3947           target_system_root_changed = 1;
3948         }
3949       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3950         {
3951           /* Compensate for the +e options to the C++ front-end;
3952              they're there simply for cfront call-compatibility.  We do
3953              some magic in default_compilers to pass them down properly.
3954              Note we deliberately start at the `+' here, to avoid passing
3955              -e0 or -e1 down into the linker.  */
3956           switches[n_switches].part1 = &argv[i][0];
3957           switches[n_switches].args = 0;
3958           switches[n_switches].live_cond = SWITCH_OK;
3959           switches[n_switches].validated = 0;
3960           n_switches++;
3961         }
3962       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3963         {
3964           int prev, j;
3965           /* Split the argument at commas.  */
3966           prev = 4;
3967           for (j = 4; argv[i][j]; j++)
3968             if (argv[i][j] == ',')
3969               {
3970                 infiles[n_infiles].language = "*";
3971                 infiles[n_infiles++].name
3972                   = save_string (argv[i] + prev, j - prev);
3973                 prev = j + 1;
3974               }
3975           /* Record the part after the last comma.  */
3976           infiles[n_infiles].language = "*";
3977           infiles[n_infiles++].name = argv[i] + prev;
3978         }
3979       else if (strcmp (argv[i], "-Xlinker") == 0)
3980         {
3981           infiles[n_infiles].language = "*";
3982           infiles[n_infiles++].name = argv[++i];
3983         }
3984       /* Xassembler and Xpreprocessor were already handled in the first argv
3985          scan, so all we need to do here is ignore them and their argument.  */
3986       else if (strcmp (argv[i], "-Xassembler") == 0)
3987         i++;
3988       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3989         i++;
3990       else if (strcmp (argv[i], "-l") == 0)
3991         { /* POSIX allows separation of -l and the lib arg;
3992              canonicalize by concatenating -l with its arg */
3993           infiles[n_infiles].language = "*";
3994           infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3995         }
3996       else if (strncmp (argv[i], "-l", 2) == 0)
3997         {
3998           infiles[n_infiles].language = "*";
3999           infiles[n_infiles++].name = argv[i];
4000         }
4001       else if (strcmp (argv[i], "-specs") == 0)
4002         i++;
4003       else if (strncmp (argv[i], "-specs=", 7) == 0)
4004         ;
4005       else if (strcmp (argv[i], "-time") == 0)
4006         ;
4007       else if (strcmp (argv[i], "-###") == 0)
4008         ;
4009       else if (argv[i][0] == '-' && argv[i][1] != 0)
4010         {
4011           const char *p = &argv[i][1];
4012           int c = *p;
4013
4014           if (c == 'x')
4015             {
4016               if (p[1] == 0 && i + 1 == argc)
4017                 fatal ("argument to '-x' is missing");
4018               if (p[1] == 0)
4019                 spec_lang = argv[++i];
4020               else
4021                 spec_lang = p + 1;
4022               if (! strcmp (spec_lang, "none"))
4023                 /* Suppress the warning if -xnone comes after the last input
4024                    file, because alternate command interfaces like g++ might
4025                    find it useful to place -xnone after each input file.  */
4026                 spec_lang = 0;
4027               else
4028                 last_language_n_infiles = n_infiles;
4029               continue;
4030             }
4031           switches[n_switches].part1 = p;
4032           /* Deal with option arguments in separate argv elements.  */
4033           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4034               || WORD_SWITCH_TAKES_ARG (p))
4035             {
4036               int j = 0;
4037               int n_args = WORD_SWITCH_TAKES_ARG (p);
4038
4039               if (n_args == 0)
4040                 {
4041                   /* Count only the option arguments in separate argv elements.  */
4042                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4043                 }
4044               if (i + n_args >= argc)
4045                 fatal ("argument to '-%s' is missing", p);
4046               switches[n_switches].args
4047                 = xmalloc ((n_args + 1) * sizeof(const char *));
4048               while (j < n_args)
4049                 switches[n_switches].args[j++] = argv[++i];
4050               /* Null-terminate the vector.  */
4051               switches[n_switches].args[j] = 0;
4052             }
4053           else if (strchr (switches_need_spaces, c))
4054             {
4055               /* On some systems, ld cannot handle some options without
4056                  a space.  So split the option from its argument.  */
4057               char *part1 = xmalloc (2);
4058               part1[0] = c;
4059               part1[1] = '\0';
4060
4061               switches[n_switches].part1 = part1;
4062               switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4063               switches[n_switches].args[0] = xstrdup (p+1);
4064               switches[n_switches].args[1] = 0;
4065             }
4066           else
4067             switches[n_switches].args = 0;
4068
4069           switches[n_switches].live_cond = SWITCH_OK;
4070           switches[n_switches].validated = 0;
4071           switches[n_switches].ordering = 0;
4072           /* These are always valid, since gcc.c itself understands them.  */
4073           if (!strcmp (p, "save-temps")
4074               || !strcmp (p, "static-libgcc")
4075               || !strcmp (p, "shared-libgcc")
4076               || !strcmp (p, "pipe"))
4077             switches[n_switches].validated = 1;
4078           else
4079             {
4080               char ch = switches[n_switches].part1[0];
4081               if (ch == 'B')
4082                 switches[n_switches].validated = 1;
4083             }
4084           n_switches++;
4085         }
4086       else
4087         {
4088 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4089           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4090 #endif
4091
4092           if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4093             {
4094               perror_with_name (argv[i]);
4095               error_count++;
4096             }
4097           else
4098    &nbs