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