OSDN Git Service

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