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