OSDN Git Service

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