OSDN Git Service

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