OSDN Git Service

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