OSDN Git Service

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