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