OSDN Git Service

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