OSDN Git Service

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