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