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,
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers. It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec". */
35 #include "coretypes.h"
36 #include "multilib.h" /* before tm.h */
43 #include "diagnostic.h"
48 #include "filenames.h"
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
56 /* By default there is no special suffix for host executables. */
57 #ifdef HOST_EXECUTABLE_SUFFIX
58 #define HAVE_HOST_EXECUTABLE_SUFFIX
60 #define HOST_EXECUTABLE_SUFFIX ""
63 /* By default, the suffix for target object files is ".o". */
64 #ifdef TARGET_OBJECT_SUFFIX
65 #define HAVE_TARGET_OBJECT_SUFFIX
67 #define TARGET_OBJECT_SUFFIX ".o"
70 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
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"
77 /* If a stage of compilation returns an exit status >= 1,
78 compilation of that file ceases. */
80 #define MIN_FATAL_STATUS 1
82 /* Flag set by cppspec.c to 1. */
85 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
86 static bool at_file_supplied;
88 /* Definition of string containing the arguments given to configure. */
89 #include "configargs.h"
91 /* Flag saying to print the command line options understood by gcc and its
94 static int print_help_list;
96 /* Flag saying to print the version of gcc and its sub-processes. */
98 static int print_version;
100 /* Flag indicating whether we should ONLY print the command and
101 arguments (like verbose_flag) without executing the command.
102 Displayed arguments are quoted so that the generated command
103 line is suitable for execution. This is intended for use in
104 shell scripts to capture the driver-generated command line. */
105 static int verbose_only_flag;
107 /* Flag indicating how to print command line options of sub-processes. */
109 static int print_subprocess_help;
111 /* Whether we should report subprocess execution times to a file. */
113 FILE *report_times_to_file = NULL;
115 /* Nonzero means place this string before uses of /, so that include
116 and library files can be found in an alternate location. */
118 #ifdef TARGET_SYSTEM_ROOT
119 static const char *target_system_root = TARGET_SYSTEM_ROOT;
121 static const char *target_system_root = 0;
124 /* Nonzero means pass the updated target_system_root to the compiler. */
126 static int target_system_root_changed;
128 /* Nonzero means append this string to target_system_root. */
130 static const char *target_sysroot_suffix = 0;
132 /* Nonzero means append this string to target_system_root for headers. */
134 static const char *target_sysroot_hdrs_suffix = 0;
136 /* Nonzero means write "temp" files in source directory
137 and use the source file's name in them, and don't delete them. */
139 static enum save_temps {
140 SAVE_TEMPS_NONE, /* no -save-temps */
141 SAVE_TEMPS_CWD, /* -save-temps in current directory */
142 SAVE_TEMPS_OBJ, /* -save-temps in object directory */
143 SAVE_TEMPS_OBJZ /* -save-temps in object directory with mangling */
146 /* Output file to use to get the object directory for -save-temps=obj */
147 static char *save_temps_prefix = 0;
148 static size_t save_temps_length = 0;
150 /* The compiler version. */
152 static const char *compiler_version;
154 /* The target version. */
156 static const char *const spec_version = DEFAULT_TARGET_VERSION;
158 /* The target machine. */
160 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
162 /* Nonzero if cross-compiling.
163 When -b is used, the value comes from the `specs' file. */
165 #ifdef CROSS_DIRECTORY_STRUCTURE
166 static const char *cross_compile = "1";
168 static const char *cross_compile = "0";
171 /* Greatest exit code of sub-processes that has been encountered up to
173 static int greatest_status = 1;
175 /* This is the obstack which we use to allocate many strings. */
177 static struct obstack obstack;
179 /* This is the obstack to build an environment variable to pass to
180 collect2 that describes all of the relevant switches of what to
181 pass the compiler in building the list of pointers to constructors
184 static struct obstack collect_obstack;
186 /* Forward declaration for prototypes. */
190 static void init_spec (void);
191 static void store_arg (const char *, int, int);
192 static void insert_wrapper (const char *);
193 static char *load_specs (const char *);
194 static void read_specs (const char *, int);
195 static void set_spec (const char *, const char *);
196 static struct compiler *lookup_compiler (const char *, size_t, const char *);
197 static char *build_search_list (const struct path_prefix *, const char *,
199 static void xputenv (const char *);
200 static void putenv_from_prefixes (const struct path_prefix *, const char *,
202 static int access_check (const char *, int);
203 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
204 static void add_prefix (struct path_prefix *, const char *, const char *,
206 static void add_sysrooted_prefix (struct path_prefix *, const char *,
207 const char *, int, int, int);
208 static char *skip_whitespace (char *);
209 static void delete_if_ordinary (const char *);
210 static void delete_temp_files (void);
211 static void delete_failure_queue (void);
212 static void clear_failure_queue (void);
213 static int check_live_switch (int, int);
214 static const char *handle_braces (const char *);
215 static inline bool input_suffix_matches (const char *, const char *);
216 static inline bool switch_matches (const char *, const char *, int);
217 static inline void mark_matching_switches (const char *, const char *, int);
218 static inline void process_marked_switches (void);
219 static const char *process_brace_body (const char *, const char *, const char *, int, int);
220 static const struct spec_function *lookup_spec_function (const char *);
221 static const char *eval_spec_function (const char *, const char *);
222 static const char *handle_spec_function (const char *);
223 static char *save_string (const char *, int);
224 static void set_collect_gcc_options (void);
225 static int do_spec_1 (const char *, int, const char *);
226 static int do_spec_2 (const char *);
227 static void do_option_spec (const char *, const char *);
228 static void do_self_spec (const char *);
229 static const char *find_file (const char *);
230 static int is_directory (const char *, bool);
231 static const char *validate_switches (const char *);
232 static void validate_all_switches (void);
233 static inline void validate_switches_from_spec (const char *);
234 static void give_switch (int, int);
235 static int used_arg (const char *, int);
236 static int default_arg (const char *, int);
237 static void set_multilib_dir (void);
238 static void print_multilib_info (void);
239 static void perror_with_name (const char *);
240 static void display_help (void);
241 static void add_preprocessor_option (const char *, int);
242 static void add_assembler_option (const char *, int);
243 static void add_linker_option (const char *, int);
244 static void process_command (unsigned int, struct cl_decoded_option *);
245 static int execute (void);
246 static void alloc_args (void);
247 static void clear_args (void);
248 static void fatal_signal (int);
249 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
250 static void init_gcc_specs (struct obstack *, const char *, const char *,
253 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
254 static const char *convert_filename (const char *, int, int);
257 static const char *getenv_spec_function (int, const char **);
258 static const char *if_exists_spec_function (int, const char **);
259 static const char *if_exists_else_spec_function (int, const char **);
260 static const char *replace_outfile_spec_function (int, const char **);
261 static const char *remove_outfile_spec_function (int, const char **);
262 static const char *version_compare_spec_function (int, const char **);
263 static const char *include_spec_function (int, const char **);
264 static const char *find_file_spec_function (int, const char **);
265 static const char *find_plugindir_spec_function (int, const char **);
266 static const char *print_asm_header_spec_function (int, const char **);
267 static const char *compare_debug_dump_opt_spec_function (int, const char **);
268 static const char *compare_debug_self_opt_spec_function (int, const char **);
269 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
270 static const char *pass_through_libs_spec_func (int, const char **);
271 static char *convert_white_space (char *);
273 /* The Specs Language
275 Specs are strings containing lines, each of which (if not blank)
276 is made up of a program name, and arguments separated by spaces.
277 The program name must be exact and start from root, since no path
278 is searched and it is unreliable to depend on the current working directory.
279 Redirection of input or output is not supported; the subprograms must
280 accept filenames saying what files to read and write.
282 In addition, the specs can contain %-sequences to substitute variable text
283 or for conditional text. Here is a table of all defined %-sequences.
284 Note that spaces are not generated automatically around the results of
285 expanding these sequences; therefore, you can concatenate them together
286 or with constant text in a single argument.
288 %% substitute one % into the program name or argument.
289 %i substitute the name of the input file being processed.
290 %b substitute the basename of the input file being processed.
291 This is the substring up to (and not including) the last period
292 and not including the directory unless -save-temps was specified
293 to put temporaries in a different location.
294 %B same as %b, but include the file suffix (text after the last period).
296 substitute a file name that has suffix SUFFIX and is chosen
297 once per compilation, and mark the argument a la %d. To reduce
298 exposure to denial-of-service attacks, the file name is now
299 chosen in a way that is hard to predict even when previously
300 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
301 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
302 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
303 had been pre-processed. Previously, %g was simply substituted
304 with a file name chosen once per compilation, without regard
305 to any appended suffix (which was therefore treated just like
306 ordinary text), making such attacks more likely to succeed.
308 like %g, but if -pipe is in effect, expands simply to "-".
310 like %g, but if -pipe is in effect, expands to nothing. (We have both
311 %| and %m to accommodate differences between system assemblers; see
312 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
314 like %g, but generates a new temporary file name even if %uSUFFIX
317 substitutes the last file name generated with %uSUFFIX, generating a
318 new one if there is no such last file name. In the absence of any
319 %uSUFFIX, this is just like %gSUFFIX, except they don't share
320 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
321 would involve the generation of two distinct file names, one
322 for each `%g.s' and another for each `%U.s'. Previously, %U was
323 simply substituted with a file name chosen for the previous %u,
324 without regard to any appended suffix.
326 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
327 writable, and if save-temps is off; otherwise, substitute the name
328 of a temporary file, just like %u. This temporary file is not
329 meant for communication between processes, but rather as a junk
332 substitutes .SUFFIX for the suffixes of a matched switch's args when
333 it is subsequently output with %*. SUFFIX is terminated by the next
335 %d marks the argument containing or following the %d as a
336 temporary file name, so that that file will be deleted if GCC exits
337 successfully. Unlike %g, this contributes no text to the argument.
338 %w marks the argument containing or following the %w as the
339 "output file" of this compilation. This puts the argument
340 into the sequence of arguments that %o will substitute later.
341 %V indicates that this compilation produces no "output file".
343 like %{...} but mark last argument supplied within
344 as a file to be deleted on failure.
345 %o substitutes the names of all the output files, with spaces
346 automatically placed around them. You should write spaces
347 around the %o as well or the results are undefined.
348 %o is for use in the specs for running the linker.
349 Input files whose names have no recognized suffix are not compiled
350 at all, but they are included among the output files, so they will
352 %O substitutes the suffix for object files. Note that this is
353 handled specially when it immediately follows %g, %u, or %U
354 (with or without a suffix argument) because of the need for
355 those to form complete file names. The handling is such that
356 %O is treated exactly as if it had already been substituted,
357 except that %g, %u, and %U do not currently support additional
358 SUFFIX characters following %O as they would following, for
360 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
361 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
362 and -B options) and -imultilib as necessary.
363 %s current argument is the name of a library or startup file of some sort.
364 Search for that file in a standard list of directories
365 and substitute the full name found.
366 %eSTR Print STR as an error message. STR is terminated by a newline.
367 Use this when inconsistent options are detected.
368 %nSTR Print STR as a notice. STR is terminated by a newline.
369 %x{OPTION} Accumulate an option for %X.
370 %X Output the accumulated linker options specified by compilations.
371 %Y Output the accumulated assembler options specified by compilations.
372 %Z Output the accumulated preprocessor options specified by compilations.
373 %a process ASM_SPEC as a spec.
374 This allows config.h to specify part of the spec for running as.
375 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
376 used here. This can be used to run a post-processor after the
377 assembler has done its job.
378 %D Dump out a -L option for each directory in startfile_prefixes.
379 If multilib_dir is set, extra entries are generated with it affixed.
380 %l process LINK_SPEC as a spec.
381 %L process LIB_SPEC as a spec.
382 %G process LIBGCC_SPEC as a spec.
383 %R Output the concatenation of target_system_root and
384 target_sysroot_suffix.
385 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
386 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
387 %C process CPP_SPEC as a spec.
388 %1 process CC1_SPEC as a spec.
389 %2 process CC1PLUS_SPEC as a spec.
390 %* substitute the variable part of a matched option. (See below.)
391 Note that each comma in the substituted string is replaced by
393 %<S remove all occurrences of -S from the command line.
394 Note - this command is position dependent. % commands in the
395 spec string before this one will see -S, % commands in the
396 spec string after this one will not.
397 %>S Similar to "%<S", but keep it in the GCC command line.
398 %<S* remove all occurrences of all switches beginning with -S from the
401 Call the named function FUNCTION, passing it ARGS. ARGS is
402 first processed as a nested spec string, then split into an
403 argument vector in the usual fashion. The function returns
404 a string which is processed as if it had appeared literally
405 as part of the current spec.
406 %{S} substitutes the -S switch, if that switch was given to GCC.
407 If that switch was not specified, this substitutes nothing.
408 Here S is a metasyntactic variable.
409 %{S*} substitutes all the switches specified to GCC whose names start
410 with -S. This is used for -o, -I, etc; switches that take
411 arguments. GCC considers `-o foo' as being one switch whose
412 name starts with `o'. %{o*} would substitute this text,
413 including the space; thus, two arguments would be generated.
414 %{S*&T*} likewise, but preserve order of S and T options (the order
415 of S and T in the spec is not significant). Can be any number
416 of ampersand-separated variables; for each the wild card is
417 optional. Useful for CPP as %{D*&U*&A*}.
419 %{S:X} substitutes X, if the -S switch was given to GCC.
420 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
421 %{S*:X} substitutes X if one or more switches whose names start
422 with -S was given to GCC. Normally X is substituted only
423 once, no matter how many such switches appeared. However,
424 if %* appears somewhere in X, then X will be substituted
425 once for each matching switch, with the %* replaced by the
426 part of that switch that matched the '*'.
427 %{.S:X} substitutes X, if processing a file with suffix S.
428 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
429 %{,S:X} substitutes X, if processing a file which will use spec S.
430 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
432 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
433 combined with '!', '.', ',', and '*' as above binding stronger
435 If %* appears in X, all of the alternatives must be starred, and
436 only the first matching alternative is substituted.
437 %{S:X; if S was given to GCC, substitutes X;
438 T:Y; else if T was given to GCC, substitutes Y;
439 :D} else substitutes D. There can be as many clauses as you need.
440 This may be combined with '.', '!', ',', '|', and '*' as above.
442 %(Spec) processes a specification defined in a specs file as *Spec:
444 The conditional text X in a %{S:X} or similar construct may contain
445 other nested % constructs or spaces, or even newlines. They are
446 processed as usual, as described above. Trailing white space in X is
447 ignored. White space may also appear anywhere on the left side of the
448 colon in these constructs, except between . or * and the corresponding
451 The -O, -f, -m, and -W switches are handled specifically in these
452 constructs. If another value of -O or the negated form of a -f, -m, or
453 -W switch is found later in the command line, the earlier switch
454 value is ignored, except with {S*} where S is just one letter; this
455 passes all matching options.
457 The character | at the beginning of the predicate text is used to indicate
458 that a command should be piped to the following command, but only if -pipe
461 Note that it is built into GCC which switches take arguments and which
462 do not. You might think it would be useful to generalize this to
463 allow each compiler's spec to say which switches take arguments. But
464 this cannot be done in a consistent fashion. GCC cannot even decide
465 which input files have been specified without knowing which switches
466 take arguments, and it must know which input files to compile in order
467 to tell which compilers to run.
469 GCC also knows implicitly that arguments starting in `-l' are to be
470 treated as compiler output files, and passed to the linker in their
471 proper position among the other output files. */
473 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
475 /* config.h can define ASM_SPEC to provide extra args to the assembler
476 or extra switch-translations. */
481 /* config.h can define ASM_FINAL_SPEC to run a post processor after
482 the assembler has run. */
483 #ifndef ASM_FINAL_SPEC
484 #define ASM_FINAL_SPEC ""
487 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
488 or extra switch-translations. */
493 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
494 or extra switch-translations. */
499 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
500 or extra switch-translations. */
502 #define CC1PLUS_SPEC ""
505 /* config.h can define LINK_SPEC to provide extra args to the linker
506 or extra switch-translations. */
511 /* config.h can define LIB_SPEC to override the default libraries. */
513 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
518 /* XXX: valid only for GNU ld */
519 /* XXX: should exactly match hooks provided by libmudflap.a */
520 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
521 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
522 --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
523 } %{fmudflapth: --wrap=pthread_create\
524 }} %{fmudflap|fmudflapth: --wrap=main}"
527 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
530 /* When using -fsplit-stack we need to wrap pthread_create, in order
531 to initialize the stack guard. We always use wrapping, rather than
532 shared library ordering, and we keep the wrapper function in
533 libgcc. This is not yet a real spec, though it could become one;
534 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
535 only works with GNU ld and gold. FIXME: This is incompatible with
536 -fmudflap when linking statically, which wants to do its own
538 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
540 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
543 #if defined(REAL_LIBGCC_SPEC)
544 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
545 #elif defined(LINK_LIBGCC_SPECIAL_1)
546 /* Have gcc do the search for libgcc.a. */
547 #define LIBGCC_SPEC "libgcc.a%s"
549 #define LIBGCC_SPEC "-lgcc"
553 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
554 #ifndef STARTFILE_SPEC
555 #define STARTFILE_SPEC \
556 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
559 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
561 #define ENDFILE_SPEC ""
565 #define LINKER_NAME "collect2"
568 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
569 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
574 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
576 #ifndef ASM_DEBUG_SPEC
577 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
578 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
579 # define ASM_DEBUG_SPEC \
580 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
581 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
582 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
584 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
585 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
587 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
588 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
592 #ifndef ASM_DEBUG_SPEC
593 # define ASM_DEBUG_SPEC ""
596 /* Here is the spec for running the linker, after compiling all files. */
598 /* This is overridable by the target in case they need to specify the
599 -lgcc and -lc order specially, yet not require them to override all
600 of LINK_COMMAND_SPEC. */
601 #ifndef LINK_GCC_C_SEQUENCE_SPEC
602 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
605 #ifndef LINK_SSP_SPEC
606 #ifdef TARGET_LIBC_PROVIDES_SSP
607 #define LINK_SSP_SPEC "%{fstack-protector:}"
609 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
613 #ifndef LINK_PIE_SPEC
615 #define LINK_PIE_SPEC "%{pie:-pie} "
617 #define LINK_PIE_SPEC "%{pie:} "
621 #ifndef LINK_BUILDID_SPEC
622 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
623 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
627 /* Conditional to test whether the LTO plugin is used or not.
628 FIXME: For slim LTO we will need to enable plugin unconditionally. This
629 still cause problems with PLUGIN_LD != LD and when plugin is built but
630 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
631 plugin only when LTO is enabled. We still honor explicit
632 -fuse-linker-plugin if the linker used understands -plugin. */
634 /* The linker has some plugin support. */
635 #if HAVE_LTO_PLUGIN > 0
636 /* The linker used has full plugin support, use LTO plugin by default. */
637 #if HAVE_LTO_PLUGIN == 2
638 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
639 #define PLUGIN_COND_CLOSE "}"
641 /* The linker used has limited plugin support, use LTO plugin with explicit
642 -fuse-linker-plugin. */
643 #define PLUGIN_COND "fuse-linker-plugin"
644 #define PLUGIN_COND_CLOSE ""
646 #define LINK_PLUGIN_SPEC \
648 -plugin %(linker_plugin_file) \
649 -plugin-opt=%(lto_wrapper) \
650 -plugin-opt=-fresolution=%u.res \
651 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
654 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
655 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
656 %e-fuse-linker-plugin is not supported in this configuration}"
660 /* -u* was put back because both BSD and SysV seem to support it. */
661 /* %{static:} simply prevents an error message if the target machine
662 doesn't handle -static. */
663 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
664 scripts which exist in user specified directories, or in standard
666 /* We pass any -flto flags on to the linker, which is expected
667 to understand them. In practice, this means it had better be collect2. */
668 /* %{e*} includes -export-dynamic; see comment in common.opt. */
669 #ifndef LINK_COMMAND_SPEC
670 #define LINK_COMMAND_SPEC "\
671 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
674 "%{flto|flto=*:%<fcompare-debug*} \
675 %{flto} %{flto=*} %l " LINK_PIE_SPEC \
676 "%X %{o*} %{e*} %{N} %{n} %{r}\
677 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
678 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
679 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
680 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
681 %(mflib) " STACK_SPLIT_SPEC "\
682 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
683 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
684 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
687 #ifndef LINK_LIBGCC_SPEC
688 /* Generate -L options for startfile prefix list. */
689 # define LINK_LIBGCC_SPEC "%D"
692 #ifndef STARTFILE_PREFIX_SPEC
693 # define STARTFILE_PREFIX_SPEC ""
697 # define SYSROOT_SPEC "--sysroot=%R"
700 #ifndef SYSROOT_SUFFIX_SPEC
701 # define SYSROOT_SUFFIX_SPEC ""
704 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
705 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
708 static const char *asm_debug;
709 static const char *cpp_spec = CPP_SPEC;
710 static const char *cc1_spec = CC1_SPEC;
711 static const char *cc1plus_spec = CC1PLUS_SPEC;
712 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
713 static const char *link_ssp_spec = LINK_SSP_SPEC;
714 static const char *asm_spec = ASM_SPEC;
715 static const char *asm_final_spec = ASM_FINAL_SPEC;
716 static const char *link_spec = LINK_SPEC;
717 static const char *lib_spec = LIB_SPEC;
718 static const char *mfwrap_spec = MFWRAP_SPEC;
719 static const char *mflib_spec = MFLIB_SPEC;
720 static const char *link_gomp_spec = "";
721 static const char *libgcc_spec = LIBGCC_SPEC;
722 static const char *endfile_spec = ENDFILE_SPEC;
723 static const char *startfile_spec = STARTFILE_SPEC;
724 static const char *linker_name_spec = LINKER_NAME;
725 static const char *linker_plugin_file_spec = "";
726 static const char *lto_wrapper_spec = "";
727 static const char *lto_gcc_spec = "";
728 static const char *link_command_spec = LINK_COMMAND_SPEC;
729 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
730 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
731 static const char *sysroot_spec = SYSROOT_SPEC;
732 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
733 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
734 static const char *self_spec = "";
736 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
737 There should be no need to override these in target dependent files,
738 but we need to copy them to the specs file so that newer versions
739 of the GCC driver can correctly drive older tool chains with the
740 appropriate -B options. */
742 /* When cpplib handles traditional preprocessing, get rid of this, and
743 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
744 that we default the front end language better. */
745 static const char *trad_capable_cpp =
746 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
748 /* We don't wrap .d files in %W{} since a missing .d file, and
749 therefore no dependency entry, confuses make into thinking a .o
750 file that happens to exist is up-to-date. */
751 static const char *cpp_unique_options =
752 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
753 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
754 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
755 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
756 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
757 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
758 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
759 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
760 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
761 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
764 /* This contains cpp options which are common with cc1_options and are passed
765 only when preprocessing only to avoid duplication. We pass the cc1 spec
766 options to the preprocessor so that it the cc1 spec may manipulate
767 options used to set target flags. Those special target flags settings may
768 in turn cause preprocessor symbols to be defined specially. */
769 static const char *cpp_options =
770 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
771 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
772 %{undef} %{save-temps*:-fpch-preprocess}";
774 /* This contains cpp options which are not passed when the preprocessor
775 output will be used by another program. */
776 static const char *cpp_debug_options = "%{d*}";
778 /* NB: This is shared amongst all front-ends, except for Ada. */
779 static const char *cc1_options =
780 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
781 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
782 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
783 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
784 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
785 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
786 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
787 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
788 %{-target-help:--target-help}\
789 %{-version:--version}\
790 %{-help=*:--help=%*}\
791 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
792 %{fsyntax-only:-o %j} %{-param*}\
793 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
794 %{coverage:-fprofile-arcs -ftest-coverage}";
796 static const char *asm_options =
797 "%{-target-help:%:print-asm-header()} "
799 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
800 to the assembler equivalents. */
801 "%{v} %{w:-W} %{I*} "
803 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
805 static const char *invoke_as =
806 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
808 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
809 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
813 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
814 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
818 /* Some compilers have limits on line lengths, and the multilib_select
819 and/or multilib_matches strings can be very long, so we build them at
821 static struct obstack multilib_obstack;
822 static const char *multilib_select;
823 static const char *multilib_matches;
824 static const char *multilib_defaults;
825 static const char *multilib_exclusions;
827 /* Check whether a particular argument is a default argument. */
829 #ifndef MULTILIB_DEFAULTS
830 #define MULTILIB_DEFAULTS { "" }
833 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
835 #ifndef DRIVER_SELF_SPECS
836 #define DRIVER_SELF_SPECS ""
839 /* Adding -fopenmp should imply pthreads. This is particularly important
840 for targets that use different start files and suchlike. */
841 #ifndef GOMP_SELF_SPECS
842 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
845 /* Likewise for -fgnu-tm. */
846 #ifndef GTM_SELF_SPECS
847 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
850 static const char *const driver_self_specs[] = {
851 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
852 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
855 #ifndef OPTION_DEFAULT_SPECS
856 #define OPTION_DEFAULT_SPECS { "", "" }
865 static const struct default_spec
866 option_default_specs[] = { OPTION_DEFAULT_SPECS };
870 struct user_specs *next;
871 const char *filename;
874 static struct user_specs *user_specs_head, *user_specs_tail;
877 /* Record the mapping from file suffixes for compilation specs. */
881 const char *suffix; /* Use this compiler for input files
882 whose names end in this suffix. */
884 const char *spec; /* To use this compiler, run this spec. */
886 const char *cpp_spec; /* If non-NULL, substitute this spec
887 for `%C', rather than the usual
889 const int combinable; /* If nonzero, compiler can deal with
890 multiple source files at once (IMA). */
891 const int needs_preprocessing; /* If nonzero, source files need to
892 be run through a preprocessor. */
895 /* Pointer to a vector of `struct compiler' that gives the spec for
896 compiling a file, based on its suffix.
897 A file that does not end in any of these suffixes will be passed
898 unchanged to the loader and nothing else will be done to it.
900 An entry containing two 0s is used to terminate the vector.
902 If multiple entries match a file, the last matching one is used. */
904 static struct compiler *compilers;
906 /* Number of entries in `compilers', not counting the null terminator. */
908 static int n_compilers;
910 /* The default list of file name suffixes and their compilation specs. */
912 static const struct compiler default_compilers[] =
914 /* Add lists of suffixes of known languages here. If those languages
915 were not present when we built the driver, we will hit these copies
916 and be given a more meaningful error than "file not used since
917 linking is not done". */
918 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
919 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
920 {".mii", "#Objective-C++", 0, 0, 0},
921 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
922 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
923 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
924 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
925 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
926 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
927 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
928 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
929 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
930 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
931 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
932 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
933 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
934 {".r", "#Ratfor", 0, 0, 0},
935 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
936 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
937 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
938 {".go", "#Go", 0, 1, 0},
939 /* Next come the entries for C. */
940 {".c", "@c", 0, 0, 1},
942 /* cc1 has an integrated ISO C preprocessor. We should invoke the
943 external preprocessor if -save-temps is given. */
944 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
947 %eGNU C no longer supports -traditional without -E}\
948 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
949 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
950 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
952 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
953 cc1 %(cpp_unique_options) %(cc1_options)}}}\
954 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
956 "%{!E:%e-E or -x required when input is from standard input}\
957 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
958 {".h", "@c-header", 0, 0, 0},
960 /* cc1 has an integrated ISO C preprocessor. We should invoke the
961 external preprocessor if -save-temps is given. */
962 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
964 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
965 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
966 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
968 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
969 %W{o*:--output-pch=%*}}%V}\
970 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
971 cc1 %(cpp_unique_options) %(cc1_options)\
972 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
973 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
974 {".i", "@cpp-output", 0, 0, 0},
976 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
977 {".s", "@assembler", 0, 0, 0},
979 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
980 {".sx", "@assembler-with-cpp", 0, 0, 0},
981 {".S", "@assembler-with-cpp", 0, 0, 0},
982 {"@assembler-with-cpp",
983 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
984 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
985 %{E|M|MM:%(cpp_debug_options)}\
986 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
987 as %(asm_debug) %(asm_options) %|.s %A }}}}"
989 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
990 %{E|M|MM:%(cpp_debug_options)}\
991 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
992 as %(asm_debug) %(asm_options) %m.s %A }}}}"
997 /* Mark end of table. */
1001 /* Number of elements in default_compilers, not counting the terminator. */
1003 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1005 typedef char *char_p; /* For DEF_VEC_P. */
1007 DEF_VEC_ALLOC_P(char_p,heap);
1009 /* A vector of options to give to the linker.
1010 These options are accumulated by %x,
1011 and substituted into the linker command with %X. */
1012 static VEC(char_p,heap) *linker_options;
1014 /* A vector of options to give to the assembler.
1015 These options are accumulated by -Wa,
1016 and substituted into the assembler command with %Y. */
1017 static VEC(char_p,heap) *assembler_options;
1019 /* A vector of options to give to the preprocessor.
1020 These options are accumulated by -Wp,
1021 and substituted into the preprocessor command with %Z. */
1022 static VEC(char_p,heap) *preprocessor_options;
1025 skip_whitespace (char *p)
1029 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1030 be considered whitespace. */
1031 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1033 else if (*p == '\n' || *p == ' ' || *p == '\t')
1047 /* Structures to keep track of prefixes to try when looking for files. */
1051 const char *prefix; /* String to prepend to the path. */
1052 struct prefix_list *next; /* Next in linked list. */
1053 int require_machine_suffix; /* Don't use without machine_suffix. */
1054 /* 2 means try both machine_suffix and just_machine_suffix. */
1055 int priority; /* Sort key - priority within list. */
1056 int os_multilib; /* 1 if OS multilib scheme should be used,
1057 0 for GCC multilib scheme. */
1062 struct prefix_list *plist; /* List of prefixes to try */
1063 int max_len; /* Max length of a prefix in PLIST */
1064 const char *name; /* Name of this list (used in config stuff) */
1067 /* List of prefixes to try when looking for executables. */
1069 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1071 /* List of prefixes to try when looking for startup (crt0) files. */
1073 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1075 /* List of prefixes to try when looking for include files. */
1077 static struct path_prefix include_prefixes = { 0, 0, "include" };
1079 /* Suffix to attach to directories searched for commands.
1080 This looks like `MACHINE/VERSION/'. */
1082 static const char *machine_suffix = 0;
1084 /* Suffix to attach to directories searched for commands.
1085 This is just `MACHINE/'. */
1087 static const char *just_machine_suffix = 0;
1089 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1091 static const char *gcc_exec_prefix;
1093 /* Adjusted value of standard_libexec_prefix. */
1095 static const char *gcc_libexec_prefix;
1097 /* Default prefixes to attach to command names. */
1099 #ifndef STANDARD_STARTFILE_PREFIX_1
1100 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1102 #ifndef STANDARD_STARTFILE_PREFIX_2
1103 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1106 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1107 #undef MD_EXEC_PREFIX
1108 #undef MD_STARTFILE_PREFIX
1109 #undef MD_STARTFILE_PREFIX_1
1112 /* If no prefixes defined, use the null string, which will disable them. */
1113 #ifndef MD_EXEC_PREFIX
1114 #define MD_EXEC_PREFIX ""
1116 #ifndef MD_STARTFILE_PREFIX
1117 #define MD_STARTFILE_PREFIX ""
1119 #ifndef MD_STARTFILE_PREFIX_1
1120 #define MD_STARTFILE_PREFIX_1 ""
1123 /* These directories are locations set at configure-time based on the
1124 --prefix option provided to configure. Their initializers are
1125 defined in Makefile.in. These paths are not *directly* used when
1126 gcc_exec_prefix is set because, in that case, we know where the
1127 compiler has been installed, and use paths relative to that
1128 location instead. */
1129 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1130 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1131 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1132 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1134 /* For native compilers, these are well-known paths containing
1135 components that may be provided by the system. For cross
1136 compilers, these paths are not used. */
1137 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1138 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1139 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1140 static const char *const standard_startfile_prefix_1
1141 = STANDARD_STARTFILE_PREFIX_1;
1142 static const char *const standard_startfile_prefix_2
1143 = STANDARD_STARTFILE_PREFIX_2;
1145 /* A relative path to be used in finding the location of tools
1146 relative to the driver. */
1147 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1149 /* Subdirectory to use for locating libraries. Set by
1150 set_multilib_dir based on the compilation options. */
1152 static const char *multilib_dir;
1154 /* Subdirectory to use for locating libraries in OS conventions. Set by
1155 set_multilib_dir based on the compilation options. */
1157 static const char *multilib_os_dir;
1159 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1160 set_multilib_dir based on the compilation options. */
1162 static const char *multiarch_dir;
1164 /* Structure to keep track of the specs that have been defined so far.
1165 These are accessed using %(specname) in a compiler or link
1170 /* The following 2 fields must be first */
1171 /* to allow EXTRA_SPECS to be initialized */
1172 const char *name; /* name of the spec. */
1173 const char *ptr; /* available ptr if no static pointer */
1175 /* The following fields are not initialized */
1176 /* by EXTRA_SPECS */
1177 const char **ptr_spec; /* pointer to the spec itself. */
1178 struct spec_list *next; /* Next spec in linked list. */
1179 int name_len; /* length of the name */
1180 int alloc_p; /* whether string was allocated */
1183 #define INIT_STATIC_SPEC(NAME,PTR) \
1184 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1186 /* List of statically defined specs. */
1187 static struct spec_list static_specs[] =
1189 INIT_STATIC_SPEC ("asm", &asm_spec),
1190 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1191 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1192 INIT_STATIC_SPEC ("asm_options", &asm_options),
1193 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1194 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1195 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1196 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1197 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1198 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1199 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1200 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1201 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1202 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1203 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1204 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1205 INIT_STATIC_SPEC ("link", &link_spec),
1206 INIT_STATIC_SPEC ("lib", &lib_spec),
1207 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1208 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1209 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1210 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1211 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1212 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1213 INIT_STATIC_SPEC ("version", &compiler_version),
1214 INIT_STATIC_SPEC ("multilib", &multilib_select),
1215 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1216 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1217 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1218 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1219 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1220 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1221 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1222 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec),
1223 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec),
1224 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1225 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1226 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1227 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1228 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1229 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1230 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1231 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1232 INIT_STATIC_SPEC ("self_spec", &self_spec),
1235 #ifdef EXTRA_SPECS /* additional specs needed */
1236 /* Structure to keep track of just the first two args of a spec_list.
1237 That is all that the EXTRA_SPECS macro gives us. */
1240 const char *const name;
1241 const char *const ptr;
1244 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1245 static struct spec_list *extra_specs = (struct spec_list *) 0;
1248 /* List of dynamically allocates specs that have been defined so far. */
1250 static struct spec_list *specs = (struct spec_list *) 0;
1252 /* List of static spec functions. */
1254 static const struct spec_function static_spec_functions[] =
1256 { "getenv", getenv_spec_function },
1257 { "if-exists", if_exists_spec_function },
1258 { "if-exists-else", if_exists_else_spec_function },
1259 { "replace-outfile", replace_outfile_spec_function },
1260 { "remove-outfile", remove_outfile_spec_function },
1261 { "version-compare", version_compare_spec_function },
1262 { "include", include_spec_function },
1263 { "find-file", find_file_spec_function },
1264 { "find-plugindir", find_plugindir_spec_function },
1265 { "print-asm-header", print_asm_header_spec_function },
1266 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1267 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1268 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1269 { "pass-through-libs", pass_through_libs_spec_func },
1270 #ifdef EXTRA_SPEC_FUNCTIONS
1271 EXTRA_SPEC_FUNCTIONS
1276 static int processing_spec_function;
1278 /* Add appropriate libgcc specs to OBSTACK, taking into account
1279 various permutations of -shared-libgcc, -shared, and such. */
1281 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1283 #ifndef USE_LD_AS_NEEDED
1284 #define USE_LD_AS_NEEDED 0
1288 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1289 const char *static_name, const char *eh_name)
1293 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1294 "%{!static:%{!static-libgcc:"
1295 #if USE_LD_AS_NEEDED
1296 "%{!shared-libgcc:",
1297 static_name, " --as-needed ", shared_name, " --no-as-needed"
1300 shared_name, "%{!shared: ", static_name, "}"
1304 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1305 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1309 "%{shared-libgcc:", shared_name, "}"
1310 "%{!shared-libgcc:", static_name, "}"
1313 "%{shared:", shared_name, "}"
1318 obstack_grow (obstack, buf, strlen (buf));
1321 #endif /* ENABLE_SHARED_LIBGCC */
1323 /* Initialize the specs lookup routines. */
1328 struct spec_list *next = (struct spec_list *) 0;
1329 struct spec_list *sl = (struct spec_list *) 0;
1333 return; /* Already initialized. */
1336 fnotice (stderr, "Using built-in specs.\n");
1339 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1341 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1343 sl = &extra_specs[i];
1344 sl->name = extra_specs_1[i].name;
1345 sl->ptr = extra_specs_1[i].ptr;
1347 sl->name_len = strlen (sl->name);
1348 sl->ptr_spec = &sl->ptr;
1353 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1355 sl = &static_specs[i];
1360 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1361 /* ??? If neither -shared-libgcc nor --static-libgcc was
1362 seen, then we should be making an educated guess. Some proposed
1363 heuristics for ELF include:
1365 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1366 program will be doing dynamic loading, which will likely
1367 need the shared libgcc.
1369 (2) If "-ldl", then it's also a fair bet that we're doing
1372 (3) For each ET_DYN we're linking against (either through -lfoo
1373 or /some/path/foo.so), check to see whether it or one of
1374 its dependencies depends on a shared libgcc.
1378 If the runtime is fixed to look for program headers instead
1379 of calling __register_frame_info at all, for each object,
1380 use the shared libgcc if any EH symbol referenced.
1382 If crtstuff is fixed to not invoke __register_frame_info
1383 automatically, for each object, use the shared libgcc if
1384 any non-empty unwind section found.
1386 Doing any of this probably requires invoking an external program to
1387 do the actual object file scanning. */
1389 const char *p = libgcc_spec;
1392 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1393 when given the proper command line arguments. */
1396 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1398 init_gcc_specs (&obstack,
1400 #ifdef USE_LIBUNWIND_EXCEPTIONS
1406 #ifdef USE_LIBUNWIND_EXCEPTIONS
1407 # ifdef HAVE_LD_STATIC_DYNAMIC
1408 " %{!static:" LD_STATIC_OPTION "} -lunwind"
1409 " %{!static:" LD_DYNAMIC_OPTION "}"
1419 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1421 /* Ug. We don't know shared library extensions. Hope that
1422 systems that use this form don't do shared libraries. */
1423 init_gcc_specs (&obstack,
1427 #ifdef USE_LIBUNWIND_EXCEPTIONS
1436 obstack_1grow (&obstack, *p);
1437 in_sep = (*p == ' ');
1442 obstack_1grow (&obstack, '\0');
1443 libgcc_spec = XOBFINISH (&obstack, const char *);
1446 #ifdef USE_AS_TRADITIONAL_FORMAT
1447 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1449 static const char tf[] = "--traditional-format ";
1450 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1451 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1452 asm_spec = XOBFINISH (&obstack, const char *);
1456 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1457 defined LINKER_HASH_STYLE
1458 # ifdef LINK_BUILDID_SPEC
1459 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1460 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1462 # ifdef LINK_EH_SPEC
1463 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1464 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1466 # ifdef LINKER_HASH_STYLE
1467 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1470 static const char hash_style[] = "--hash-style=";
1471 obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1);
1472 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1);
1473 obstack_1grow (&obstack, ' ');
1476 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1477 link_spec = XOBFINISH (&obstack, const char *);
1483 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1484 removed; If the spec starts with a + then SPEC is added to the end of the
1488 set_spec (const char *name, const char *spec)
1490 struct spec_list *sl;
1491 const char *old_spec;
1492 int name_len = strlen (name);
1495 /* If this is the first call, initialize the statically allocated specs. */
1498 struct spec_list *next = (struct spec_list *) 0;
1499 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1501 sl = &static_specs[i];
1508 /* See if the spec already exists. */
1509 for (sl = specs; sl; sl = sl->next)
1510 if (name_len == sl->name_len && !strcmp (sl->name, name))
1515 /* Not found - make it. */
1516 sl = XNEW (struct spec_list);
1517 sl->name = xstrdup (name);
1518 sl->name_len = name_len;
1519 sl->ptr_spec = &sl->ptr;
1521 *(sl->ptr_spec) = "";
1526 old_spec = *(sl->ptr_spec);
1527 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1528 ? concat (old_spec, spec + 1, NULL)
1533 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1536 /* Free the old spec. */
1537 if (old_spec && sl->alloc_p)
1538 free (CONST_CAST(char *, old_spec));
1543 /* Accumulate a command (program name and args), and run it. */
1545 typedef const char *const_char_p; /* For DEF_VEC_P. */
1546 DEF_VEC_P(const_char_p);
1547 DEF_VEC_ALLOC_P(const_char_p,heap);
1549 /* Vector of pointers to arguments in the current line of specifications. */
1551 static VEC(const_char_p,heap) *argbuf;
1553 /* Position in the argbuf vector containing the name of the output file
1554 (the value associated with the "-o" flag). */
1556 static int have_o_argbuf_index = 0;
1558 /* Were the options -c, -S or -E passed. */
1559 static int have_c = 0;
1561 /* Was the option -o passed. */
1562 static int have_o = 0;
1564 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1565 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1568 static struct temp_name {
1569 const char *suffix; /* suffix associated with the code. */
1570 int length; /* strlen (suffix). */
1571 int unique; /* Indicates whether %g or %u/%U was used. */
1572 const char *filename; /* associated filename. */
1573 int filename_length; /* strlen (filename). */
1574 struct temp_name *next;
1577 /* Number of commands executed so far. */
1579 static int execution_count;
1581 /* Number of commands that exited with a signal. */
1583 static int signal_count;
1585 /* Allocate the argument vector. */
1590 argbuf = VEC_alloc (const_char_p, heap, 10);
1593 /* Clear out the vector of arguments (after a command is executed). */
1598 VEC_truncate (const_char_p, argbuf, 0);
1601 /* Add one argument to the vector at the end.
1602 This is done when a space is seen or at the end of the line.
1603 If DELETE_ALWAYS is nonzero, the arg is a filename
1604 and the file should be deleted eventually.
1605 If DELETE_FAILURE is nonzero, the arg is a filename
1606 and the file should be deleted if this compilation fails. */
1609 store_arg (const char *arg, int delete_always, int delete_failure)
1611 VEC_safe_push (const_char_p, heap, argbuf, arg);
1613 if (strcmp (arg, "-o") == 0)
1614 have_o_argbuf_index = VEC_length (const_char_p, argbuf);
1615 if (delete_always || delete_failure)
1618 /* If the temporary file we should delete is specified as
1619 part of a joined argument extract the filename. */
1621 && (p = strrchr (arg, '=')))
1623 record_temp_file (arg, delete_always, delete_failure);
1627 /* Load specs from a file name named FILENAME, replacing occurrences of
1628 various different types of line-endings, \r\n, \n\r and just \r, with
1632 load_specs (const char *filename)
1636 struct stat statbuf;
1643 fnotice (stderr, "Reading specs from %s\n", filename);
1645 /* Open and stat the file. */
1646 desc = open (filename, O_RDONLY, 0);
1648 pfatal_with_name (filename);
1649 if (stat (filename, &statbuf) < 0)
1650 pfatal_with_name (filename);
1652 /* Read contents of file into BUFFER. */
1653 buffer = XNEWVEC (char, statbuf.st_size + 1);
1654 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1656 pfatal_with_name (filename);
1657 buffer[readlen] = 0;
1660 specs = XNEWVEC (char, readlen + 1);
1662 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1668 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1670 else if (*(buffer_p + 1) == '\n') /* \r\n */
1684 /* Read compilation specs from a file named FILENAME,
1685 replacing the default ones.
1687 A suffix which starts with `*' is a definition for
1688 one of the machine-specific sub-specs. The "suffix" should be
1689 *asm, *cc1, *cpp, *link, *startfile, etc.
1690 The corresponding spec is stored in asm_spec, etc.,
1691 rather than in the `compilers' vector.
1693 Anything invalid in the file is a fatal error. */
1696 read_specs (const char *filename, int main_p)
1701 buffer = load_specs (filename);
1703 /* Scan BUFFER for specs, putting them in the vector. */
1709 char *in, *out, *p1, *p2, *p3;
1711 /* Advance P in BUFFER to the next nonblank nocomment line. */
1712 p = skip_whitespace (p);
1716 /* Is this a special command that starts with '%'? */
1717 /* Don't allow this for the main specs file, since it would
1718 encourage people to overwrite it. */
1719 if (*p == '%' && !main_p)
1722 while (*p && *p != '\n')
1728 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1729 && (p1[sizeof "%include" - 1] == ' '
1730 || p1[sizeof "%include" - 1] == '\t'))
1734 p1 += sizeof ("%include");
1735 while (*p1 == ' ' || *p1 == '\t')
1738 if (*p1++ != '<' || p[-2] != '>')
1739 fatal_error ("specs %%include syntax malformed after "
1741 (long) (p1 - buffer + 1));
1744 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1745 read_specs (new_filename ? new_filename : p1, FALSE);
1748 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1749 && (p1[sizeof "%include_noerr" - 1] == ' '
1750 || p1[sizeof "%include_noerr" - 1] == '\t'))
1754 p1 += sizeof "%include_noerr";
1755 while (*p1 == ' ' || *p1 == '\t')
1758 if (*p1++ != '<' || p[-2] != '>')
1759 fatal_error ("specs %%include syntax malformed after "
1761 (long) (p1 - buffer + 1));
1764 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1766 read_specs (new_filename, FALSE);
1767 else if (verbose_flag)
1768 fnotice (stderr, "could not find specs file %s\n", p1);
1771 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1772 && (p1[sizeof "%rename" - 1] == ' '
1773 || p1[sizeof "%rename" - 1] == '\t'))
1776 struct spec_list *sl;
1777 struct spec_list *newsl;
1779 /* Get original name. */
1780 p1 += sizeof "%rename";
1781 while (*p1 == ' ' || *p1 == '\t')
1784 if (! ISALPHA ((unsigned char) *p1))
1785 fatal_error ("specs %%rename syntax malformed after "
1787 (long) (p1 - buffer));
1790 while (*p2 && !ISSPACE ((unsigned char) *p2))
1793 if (*p2 != ' ' && *p2 != '\t')
1794 fatal_error ("specs %%rename syntax malformed after "
1796 (long) (p2 - buffer));
1800 while (*p2 == ' ' || *p2 == '\t')
1803 if (! ISALPHA ((unsigned char) *p2))
1804 fatal_error ("specs %%rename syntax malformed after "
1806 (long) (p2 - buffer));
1808 /* Get new spec name. */
1810 while (*p3 && !ISSPACE ((unsigned char) *p3))
1814 fatal_error ("specs %%rename syntax malformed after "
1816 (long) (p3 - buffer));
1819 for (sl = specs; sl; sl = sl->next)
1820 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1824 fatal_error ("specs %s spec was not found to be renamed", p1);
1826 if (strcmp (p1, p2) == 0)
1829 for (newsl = specs; newsl; newsl = newsl->next)
1830 if (strcmp (newsl->name, p2) == 0)
1831 fatal_error ("%s: attempt to rename spec %qs to "
1832 "already defined spec %qs",
1837 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1839 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1843 set_spec (p2, *(sl->ptr_spec));
1845 free (CONST_CAST (char *, *(sl->ptr_spec)));
1847 *(sl->ptr_spec) = "";
1852 fatal_error ("specs unknown %% command after %ld characters",
1853 (long) (p1 - buffer));
1856 /* Find the colon that should end the suffix. */
1858 while (*p1 && *p1 != ':' && *p1 != '\n')
1861 /* The colon shouldn't be missing. */
1863 fatal_error ("specs file malformed after %ld characters",
1864 (long) (p1 - buffer));
1866 /* Skip back over trailing whitespace. */
1868 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1871 /* Copy the suffix to a string. */
1872 suffix = save_string (p, p2 - p);
1873 /* Find the next line. */
1874 p = skip_whitespace (p1 + 1);
1876 fatal_error ("specs file malformed after %ld characters",
1877 (long) (p - buffer));
1880 /* Find next blank line or end of string. */
1881 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1884 /* Specs end at the blank line and do not include the newline. */
1885 spec = save_string (p, p1 - p);
1888 /* Delete backslash-newline sequences from the spec. */
1893 if (in[0] == '\\' && in[1] == '\n')
1895 else if (in[0] == '#')
1896 while (*in && *in != '\n')
1904 if (suffix[0] == '*')
1906 if (! strcmp (suffix, "*link_command"))
1907 link_command_spec = spec;
1909 set_spec (suffix + 1, spec);
1913 /* Add this pair to the vector. */
1915 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1917 compilers[n_compilers].suffix = suffix;
1918 compilers[n_compilers].spec = spec;
1920 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1924 link_command_spec = spec;
1927 if (link_command_spec == 0)
1928 fatal_error ("spec file has no spec for linking");
1931 /* Record the names of temporary files we tell compilers to write,
1932 and delete them at the end of the run. */
1934 /* This is the common prefix we use to make temp file names.
1935 It is chosen once for each run of this program.
1936 It is substituted into a spec by %g or %j.
1937 Thus, all temp file names contain this prefix.
1938 In practice, all temp file names start with this prefix.
1940 This prefix comes from the envvar TMPDIR if it is defined;
1941 otherwise, from the P_tmpdir macro if that is defined;
1942 otherwise, in /usr/tmp or /tmp;
1943 or finally the current directory if all else fails. */
1945 static const char *temp_filename;
1947 /* Length of the prefix. */
1949 static int temp_filename_length;
1951 /* Define the list of temporary files to delete. */
1956 struct temp_file *next;
1959 /* Queue of files to delete on success or failure of compilation. */
1960 static struct temp_file *always_delete_queue;
1961 /* Queue of files to delete on failure of compilation. */
1962 static struct temp_file *failure_delete_queue;
1964 /* Record FILENAME as a file to be deleted automatically.
1965 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1966 otherwise delete it in any case.
1967 FAIL_DELETE nonzero means delete it if a compilation step fails;
1968 otherwise delete it in any case. */
1971 record_temp_file (const char *filename, int always_delete, int fail_delete)
1973 char *const name = xstrdup (filename);
1977 struct temp_file *temp;
1978 for (temp = always_delete_queue; temp; temp = temp->next)
1979 if (! filename_cmp (name, temp->name))
1982 temp = XNEW (struct temp_file);
1983 temp->next = always_delete_queue;
1985 always_delete_queue = temp;
1992 struct temp_file *temp;
1993 for (temp = failure_delete_queue; temp; temp = temp->next)
1994 if (! filename_cmp (name, temp->name))
1997 temp = XNEW (struct temp_file);
1998 temp->next = failure_delete_queue;
2000 failure_delete_queue = temp;
2006 /* Delete all the temporary files whose names we previously recorded. */
2008 #ifndef DELETE_IF_ORDINARY
2009 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2012 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2013 if (unlink (NAME) < 0) \
2015 perror_with_name (NAME); \
2020 delete_if_ordinary (const char *name)
2026 printf ("Delete %s? (y or n) ", name);
2030 while ((c = getchar ()) != '\n' && c != EOF)
2033 if (i == 'y' || i == 'Y')
2035 DELETE_IF_ORDINARY (name, st, verbose_flag);
2039 delete_temp_files (void)
2041 struct temp_file *temp;
2043 for (temp = always_delete_queue; temp; temp = temp->next)
2044 delete_if_ordinary (temp->name);
2045 always_delete_queue = 0;
2048 /* Delete all the files to be deleted on error. */
2051 delete_failure_queue (void)
2053 struct temp_file *temp;
2055 for (temp = failure_delete_queue; temp; temp = temp->next)
2056 delete_if_ordinary (temp->name);
2060 clear_failure_queue (void)
2062 failure_delete_queue = 0;
2065 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2067 If DO_MULTI is true iterate over the paths twice, first with multilib
2068 suffix then without, otherwise iterate over the paths once without
2069 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2070 to avoid visiting the same path twice, but we could do better. For
2071 instance, /usr/lib/../lib is considered different from /usr/lib.
2072 At least EXTRA_SPACE chars past the end of the path passed to
2073 CALLBACK are available for use by the callback.
2074 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2076 Returns the value returned by CALLBACK. */
2079 for_each_path (const struct path_prefix *paths,
2082 void *(*callback) (char *, void *),
2083 void *callback_info)
2085 struct prefix_list *pl;
2086 const char *multi_dir = NULL;
2087 const char *multi_os_dir = NULL;
2088 const char *multiarch_suffix = NULL;
2089 const char *multi_suffix;
2090 const char *just_multi_suffix;
2093 bool skip_multi_dir = false;
2094 bool skip_multi_os_dir = false;
2096 multi_suffix = machine_suffix;
2097 just_multi_suffix = just_machine_suffix;
2098 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2100 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2101 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2102 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2104 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2105 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2107 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2111 size_t multi_dir_len = 0;
2112 size_t multi_os_dir_len = 0;
2113 size_t multiarch_len = 0;
2115 size_t just_suffix_len;
2119 multi_dir_len = strlen (multi_dir);
2121 multi_os_dir_len = strlen (multi_os_dir);
2122 if (multiarch_suffix)
2123 multiarch_len = strlen (multiarch_suffix);
2124 suffix_len = strlen (multi_suffix);
2125 just_suffix_len = strlen (just_multi_suffix);
2129 len = paths->max_len + extra_space + 1;
2130 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2131 path = XNEWVEC (char, len);
2134 for (pl = paths->plist; pl != 0; pl = pl->next)
2136 len = strlen (pl->prefix);
2137 memcpy (path, pl->prefix, len);
2139 #if 0 /* MACHINE/VERSION isn't used anywhere DragonFly */
2140 /* Look first in MACHINE/VERSION subdirectory. */
2141 if (!skip_multi_dir)
2143 memcpy (path + len, multi_suffix, suffix_len + 1);
2144 ret = callback (path, callback_info);
2150 /* Some paths are tried with just the machine (ie. target)
2151 subdir. This is used for finding as, ld, etc. */
2153 && pl->require_machine_suffix == 2)
2155 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2156 ret = callback (path, callback_info);
2161 /* Now try the multiarch path. */
2163 && !pl->require_machine_suffix && multiarch_dir)
2165 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2166 ret = callback (path, callback_info);
2171 /* Now try the base path. */
2172 if (!pl->require_machine_suffix
2173 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2175 const char *this_multi;
2176 size_t this_multi_len;
2178 if (pl->os_multilib)
2180 this_multi = multi_os_dir;
2181 this_multi_len = multi_os_dir_len;
2185 this_multi = multi_dir;
2186 this_multi_len = multi_dir_len;
2190 memcpy (path + len, this_multi, this_multi_len + 1);
2194 ret = callback (path, callback_info);
2202 if (multi_dir == NULL && multi_os_dir == NULL)
2205 /* Run through the paths again, this time without multilibs.
2206 Don't repeat any we have already seen. */
2209 free (CONST_CAST (char *, multi_dir));
2211 free (CONST_CAST (char *, multi_suffix));
2212 multi_suffix = machine_suffix;
2213 free (CONST_CAST (char *, just_multi_suffix));
2214 just_multi_suffix = just_machine_suffix;
2217 skip_multi_dir = true;
2220 free (CONST_CAST (char *, multi_os_dir));
2221 multi_os_dir = NULL;
2224 skip_multi_os_dir = true;
2229 free (CONST_CAST (char *, multi_dir));
2230 free (CONST_CAST (char *, multi_suffix));
2231 free (CONST_CAST (char *, just_multi_suffix));
2234 free (CONST_CAST (char *, multi_os_dir));
2240 /* Callback for build_search_list. Adds path to obstack being built. */
2242 struct add_to_obstack_info {
2249 add_to_obstack (char *path, void *data)
2251 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2253 if (info->check_dir && !is_directory (path, false))
2256 if (!info->first_time)
2257 obstack_1grow (info->ob, PATH_SEPARATOR);
2259 obstack_grow (info->ob, path, strlen (path));
2261 info->first_time = false;
2265 /* Add or change the value of an environment variable, outputting the
2266 change to standard error if in verbose mode. */
2268 xputenv (const char *string)
2271 fnotice (stderr, "%s\n", string);
2272 putenv (CONST_CAST (char *, string));
2275 /* Build a list of search directories from PATHS.
2276 PREFIX is a string to prepend to the list.
2277 If CHECK_DIR_P is true we ensure the directory exists.
2278 If DO_MULTI is true, multilib paths are output first, then
2280 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2281 It is also used by the --print-search-dirs flag. */
2284 build_search_list (const struct path_prefix *paths, const char *prefix,
2285 bool check_dir, bool do_multi)
2287 struct add_to_obstack_info info;
2289 info.ob = &collect_obstack;
2290 info.check_dir = check_dir;
2291 info.first_time = true;
2293 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2294 obstack_1grow (&collect_obstack, '=');
2296 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2298 obstack_1grow (&collect_obstack, '\0');
2299 return XOBFINISH (&collect_obstack, char *);
2302 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2306 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2309 xputenv (build_search_list (paths, env_var, true, do_multi));
2312 /* Check whether NAME can be accessed in MODE. This is like access,
2313 except that it never considers directories to be executable. */
2316 access_check (const char *name, int mode)
2322 if (stat (name, &st) < 0
2323 || S_ISDIR (st.st_mode))
2327 return access (name, mode);
2330 /* Callback for find_a_file. Appends the file name to the directory
2331 path. If the resulting file exists in the right mode, return the
2332 full pathname to the file. */
2334 struct file_at_path_info {
2343 file_at_path (char *path, void *data)
2345 struct file_at_path_info *info = (struct file_at_path_info *) data;
2346 size_t len = strlen (path);
2348 memcpy (path + len, info->name, info->name_len);
2349 len += info->name_len;
2351 /* Some systems have a suffix for executable files.
2352 So try appending that first. */
2353 if (info->suffix_len)
2355 memcpy (path + len, info->suffix, info->suffix_len + 1);
2356 if (access_check (path, info->mode) == 0)
2361 if (access_check (path, info->mode) == 0)
2367 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2368 access to check permissions. If DO_MULTI is true, search multilib
2369 paths then non-multilib paths, otherwise do not search multilib paths.
2370 Return 0 if not found, otherwise return its name, allocated with malloc. */
2373 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2376 struct file_at_path_info info;
2378 #ifdef DEFAULT_ASSEMBLER
2379 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2380 return xstrdup (DEFAULT_ASSEMBLER);
2383 #ifdef DEFAULT_LINKER
2384 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2385 return xstrdup (DEFAULT_LINKER);
2388 /* Determine the filename to execute (special case for absolute paths). */
2390 if (IS_ABSOLUTE_PATH (name))
2392 if (access (name, mode) == 0)
2393 return xstrdup (name);
2399 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2400 info.name_len = strlen (info.name);
2401 info.suffix_len = strlen (info.suffix);
2404 return (char*) for_each_path (pprefix, do_multi,
2405 info.name_len + info.suffix_len,
2406 file_at_path, &info);
2409 /* Ranking of prefixes in the sort list. -B prefixes are put before
2412 enum path_prefix_priority
2414 PREFIX_PRIORITY_B_OPT,
2415 PREFIX_PRIORITY_LAST
2418 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2419 order according to PRIORITY. Within each PRIORITY, new entries are
2422 If WARN is nonzero, we will warn if no file is found
2423 through this prefix. WARN should point to an int
2424 which will be set to 1 if this entry is used.
2426 COMPONENT is the value to be passed to update_path.
2428 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2429 the complete value of machine_suffix.
2430 2 means try both machine_suffix and just_machine_suffix. */
2433 add_prefix (struct path_prefix *pprefix, const char *prefix,
2434 const char *component, /* enum prefix_priority */ int priority,
2435 int require_machine_suffix, int os_multilib)
2437 struct prefix_list *pl, **prev;
2440 for (prev = &pprefix->plist;
2441 (*prev) != NULL && (*prev)->priority <= priority;
2442 prev = &(*prev)->next)
2445 /* Keep track of the longest prefix. */
2447 prefix = update_path (prefix, component);
2448 len = strlen (prefix);
2449 if (len > pprefix->max_len)
2450 pprefix->max_len = len;
2452 pl = XNEW (struct prefix_list);
2453 pl->prefix = prefix;
2454 pl->require_machine_suffix = require_machine_suffix;
2455 pl->priority = priority;
2456 pl->os_multilib = os_multilib;
2458 /* Insert after PREV. */
2463 /* Same as add_prefix, but prepending target_system_root to prefix. */
2464 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2466 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2467 const char *component,
2468 /* enum prefix_priority */ int priority,
2469 int require_machine_suffix, int os_multilib)
2471 if (!IS_ABSOLUTE_PATH (prefix))
2472 fatal_error ("system path %qs is not absolute", prefix);
2474 if (target_system_root)
2476 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2477 size_t sysroot_len = strlen (target_system_root);
2480 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2481 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2483 if (target_sysroot_suffix)
2484 prefix = concat (target_sysroot_suffix, prefix, NULL);
2485 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2486 free (sysroot_no_trailing_dir_separator);
2488 /* We have to override this because GCC's notion of sysroot
2489 moves along with GCC. */
2493 add_prefix (pprefix, prefix, component, priority,
2494 require_machine_suffix, os_multilib);
2497 /* Execute the command specified by the arguments on the current line of spec.
2498 When using pipes, this includes several piped-together commands
2499 with `|' between them.
2501 Return 0 if successful, -1 if failed. */
2507 int n_commands; /* # of command. */
2509 struct pex_obj *pex;
2512 const char *prog; /* program name. */
2513 const char **argv; /* vector of args. */
2517 struct command *commands; /* each command buffer with above info. */
2519 gcc_assert (!processing_spec_function);
2523 string = find_a_file (&exec_prefixes,
2524 VEC_index (const_char_p, argbuf, 0), X_OK, false);
2526 VEC_replace (const_char_p, argbuf, 0, string);
2527 insert_wrapper (wrapper_string);
2530 /* Count # of piped commands. */
2531 for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2532 if (strcmp (arg, "|") == 0)
2535 /* Get storage for each command. */
2536 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2538 /* Split argbuf into its separate piped processes,
2539 and record info about each one.
2540 Also search for the programs that are to be run. */
2542 VEC_safe_push (const_char_p, heap, argbuf, 0);
2544 commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command. */
2545 commands[0].argv = VEC_address (const_char_p, argbuf);
2547 if (!wrapper_string)
2549 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2550 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2553 for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2554 if (arg && strcmp (arg, "|") == 0)
2555 { /* each command. */
2556 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2557 fatal_error ("-pipe not supported");
2559 VEC_replace (const_char_p, argbuf, i, 0); /* Termination of
2561 commands[n_commands].prog = VEC_index (const_char_p, argbuf, i + 1);
2562 commands[n_commands].argv
2563 = &(VEC_address (const_char_p, argbuf))[i + 1];
2564 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2567 commands[n_commands].argv[0] = string;
2571 /* If -v, print what we are about to do, and maybe query. */
2575 /* For help listings, put a blank line between sub-processes. */
2576 if (print_help_list)
2577 fputc ('\n', stderr);
2579 /* Print each piped command as a separate line. */
2580 for (i = 0; i < n_commands; i++)
2582 const char *const *j;
2584 if (verbose_only_flag)
2586 for (j = commands[i].argv; *j; j++)
2589 for (p = *j; *p; ++p)
2590 if (!ISALNUM ((unsigned char) *p)
2591 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2595 fprintf (stderr, " \"");
2596 for (p = *j; *p; ++p)
2598 if (*p == '"' || *p == '\\' || *p == '$')
2599 fputc ('\\', stderr);
2602 fputc ('"', stderr);
2604 /* If it's empty, print "". */
2606 fprintf (stderr, " \"\"");
2608 fprintf (stderr, " %s", *j);
2612 for (j = commands[i].argv; *j; j++)
2613 /* If it's empty, print "". */
2615 fprintf (stderr, " \"\"");
2617 fprintf (stderr, " %s", *j);
2619 /* Print a pipe symbol after all but the last command. */
2620 if (i + 1 != n_commands)
2621 fprintf (stderr, " |");
2622 fprintf (stderr, "\n");
2625 if (verbose_only_flag != 0)
2627 /* verbose_only_flag should act as if the spec was
2628 executed, so increment execution_count before
2629 returning. This prevents spurious warnings about
2630 unused linker input files, etc. */
2635 fnotice (stderr, "\nGo ahead? (y or n) ");
2639 while (getchar () != '\n')
2642 if (i != 'y' && i != 'Y')
2647 #ifdef ENABLE_VALGRIND_CHECKING
2648 /* Run the each command through valgrind. To simplify prepending the
2649 path to valgrind and the option "-q" (for quiet operation unless
2650 something triggers), we allocate a separate argv array. */
2652 for (i = 0; i < n_commands; i++)
2658 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2661 argv = XALLOCAVEC (const char *, argc + 3);
2663 argv[0] = VALGRIND_PATH;
2665 for (j = 2; j < argc + 2; j++)
2666 argv[j] = commands[i].argv[j - 2];
2669 commands[i].argv = argv;
2670 commands[i].prog = argv[0];
2674 /* Run each piped subprocess. */
2676 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2677 ? PEX_RECORD_TIMES : 0),
2678 progname, temp_filename);
2680 fatal_error ("pex_init failed: %m");
2682 for (i = 0; i < n_commands; i++)
2686 const char *string = commands[i].argv[0];
2688 errmsg = pex_run (pex,
2689 ((i + 1 == n_commands ? PEX_LAST : 0)
2690 | (string == commands[i].prog ? PEX_SEARCH : 0)),
2691 string, CONST_CAST (char **, commands[i].argv),
2696 fatal_error (errmsg);
2700 pfatal_with_name (errmsg);
2704 if (string != commands[i].prog)
2705 free (CONST_CAST (char *, string));
2710 /* Wait for all the subprocesses to finish. */
2714 struct pex_time *times = NULL;
2717 statuses = (int *) alloca (n_commands * sizeof (int));
2718 if (!pex_get_status (pex, n_commands, statuses))
2719 fatal_error ("failed to get exit status: %m");
2721 if (report_times || report_times_to_file)
2723 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2724 if (!pex_get_times (pex, n_commands, times))
2725 fatal_error ("failed to get process times: %m");
2730 for (i = 0; i < n_commands; ++i)
2732 int status = statuses[i];
2734 if (WIFSIGNALED (status))
2737 /* SIGPIPE is a special case. It happens in -pipe mode
2738 when the compiler dies before the preprocessor is done,
2739 or the assembler dies before the compiler is done.
2740 There's generally been an error already, and this is
2741 just fallout. So don't generate another error unless
2742 we would otherwise have succeeded. */
2743 if (WTERMSIG (status) == SIGPIPE
2744 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2751 internal_error ("%s (program %s)",
2752 strsignal (WTERMSIG (status)), commands[i].prog);
2754 else if (WIFEXITED (status)
2755 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2757 if (WEXITSTATUS (status) > greatest_status)
2758 greatest_status = WEXITSTATUS (status);
2762 if (report_times || report_times_to_file)
2764 struct pex_time *pt = ×[i];
2767 ut = ((double) pt->user_seconds
2768 + (double) pt->user_microseconds / 1.0e6);
2769 st = ((double) pt->system_seconds
2770 + (double) pt->system_microseconds / 1.0e6);
2775 fnotice (stderr, "# %s %.2f %.2f\n",
2776 commands[i].prog, ut, st);
2778 if (report_times_to_file)
2781 const char *const *j;
2783 fprintf (report_times_to_file, "%g %g", ut, st);
2785 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2788 for (p = *j; *p; ++p)
2789 if (*p == '"' || *p == '\\' || *p == '$'
2795 fprintf (report_times_to_file, " \"");
2796 for (p = *j; *p; ++p)
2798 if (*p == '"' || *p == '\\' || *p == '$')
2799 fputc ('\\', report_times_to_file);
2800 fputc (*p, report_times_to_file);
2802 fputc ('"', report_times_to_file);
2805 fprintf (report_times_to_file, " %s", *j);
2808 fputc ('\n', report_times_to_file);
2818 /* Find all the switches given to us
2819 and make a vector describing them.
2820 The elements of the vector are strings, one per switch given.
2821 If a switch uses following arguments, then the `part1' field
2822 is the switch itself and the `args' field
2823 is a null-terminated vector containing the following arguments.
2824 Bits in the `live_cond' field are:
2825 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2826 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2827 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2828 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2829 in all do_spec calls afterwards. Used for %<S from self specs.
2830 The `validated' field is nonzero if any spec has looked at this switch;
2831 if it remains zero at the end of the run, it must be meaningless. */
2833 #define SWITCH_LIVE (1 << 0)
2834 #define SWITCH_FALSE (1 << 1)
2835 #define SWITCH_IGNORE (1 << 2)
2836 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2837 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2843 unsigned int live_cond;
2844 unsigned char validated;
2845 unsigned char ordering;
2848 static struct switchstr *switches;
2850 static int n_switches;
2852 static int n_switches_alloc;
2854 /* Set to zero if -fcompare-debug is disabled, positive if it's
2855 enabled and we're running the first compilation, negative if it's
2856 enabled and we're running the second compilation. For most of the
2857 time, it's in the range -1..1, but it can be temporarily set to 2
2858 or 3 to indicate that the -fcompare-debug flags didn't come from
2859 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2860 variable, until a synthesized -fcompare-debug flag is added to the
2864 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2865 int compare_debug_second;
2867 /* Set to the flags that should be passed to the second compilation in
2868 a -fcompare-debug compilation. */
2869 const char *compare_debug_opt;
2871 static struct switchstr *switches_debug_check[2];
2873 static int n_switches_debug_check[2];
2875 static int n_switches_alloc_debug_check[2];
2877 static char *debug_check_temp_file[2];
2879 /* Language is one of three things:
2881 1) The name of a real programming language.
2882 2) NULL, indicating that no one has figured out
2884 3) '*', indicating that the file should be passed
2889 const char *language;
2890 struct compiler *incompiler;
2895 /* Also a vector of input files specified. */
2897 static struct infile *infiles;
2901 static int n_infiles_alloc;
2903 /* True if multiple input files are being compiled to a single
2906 static bool combine_inputs;
2908 /* This counts the number of libraries added by lang_specific_driver, so that
2909 we can tell if there were any user supplied any files or libraries. */
2911 static int added_libraries;
2913 /* And a vector of corresponding output files is made up later. */
2915 const char **outfiles;
2917 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2919 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2920 is true if we should look for an executable suffix. DO_OBJ
2921 is true if we should look for an object suffix. */
2924 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2925 int do_obj ATTRIBUTE_UNUSED)
2927 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2935 len = strlen (name);
2937 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2938 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2939 if (do_obj && len > 2
2940 && name[len - 2] == '.'
2941 && name[len - 1] == 'o')
2943 obstack_grow (&obstack, name, len - 2);
2944 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2945 name = XOBFINISH (&obstack, const char *);
2949 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2950 /* If there is no filetype, make it the executable suffix (which includes
2951 the "."). But don't get confused if we have just "-o". */
2952 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2955 for (i = len - 1; i >= 0; i--)
2956 if (IS_DIR_SEPARATOR (name[i]))
2959 for (i++; i < len; i++)
2963 obstack_grow (&obstack, name, len);
2964 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2965 strlen (TARGET_EXECUTABLE_SUFFIX));
2966 name = XOBFINISH (&obstack, const char *);
2973 /* Display the command line switches accepted by gcc. */
2977 printf (_("Usage: %s [options] file...\n"), progname);
2978 fputs (_("Options:\n"), stdout);
2980 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
2981 fputs (_(" --help Display this information\n"), stdout);
2982 fputs (_(" --target-help Display target specific command line options\n"), stdout);
2983 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2984 fputs (_(" Display specific types of command line options\n"), stdout);
2986 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2987 fputs (_(" --version Display compiler version information\n"), stdout);
2988 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
2989 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
2990 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
2991 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
2992 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
2993 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
2994 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
2996 -print-multiarch Display the target's normalized GNU triplet, used as\n\
2997 a component in the library path\n"), stdout);
2998 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3000 -print-multi-lib Display the mapping between command line options and\n\
3001 multiple library search directories\n"), stdout);
3002 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3003 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3004 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3005 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3006 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3007 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3008 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3009 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3010 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3011 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3012 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3014 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3015 prefixes to other gcc components\n"), stdout);
3016 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3017 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3018 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3019 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3021 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3022 and libraries\n"), stdout);
3023 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3024 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3025 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3026 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3027 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3028 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3029 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3030 fputs (_(" -pie Create a position independent executable\n"), stdout);
3031 fputs (_(" -shared Create a shared library\n"), stdout);
3033 -x <language> Specify the language of the following input files\n\
3034 Permissible languages include: c c++ assembler none\n\
3035 'none' means revert to the default behavior of\n\
3036 guessing the language based on the file's extension\n\
3040 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3041 passed on to the various sub-processes invoked by %s. In order to pass\n\
3042 other options on to these processes the -W<letter> options must be used.\n\
3045 /* The rest of the options are displayed by invocations of the various
3050 add_preprocessor_option (const char *option, int len)
3052 VEC_safe_push (char_p, heap, preprocessor_options,
3053 save_string (option, len));
3057 add_assembler_option (const char *option, int len)
3059 VEC_safe_push (char_p, heap, assembler_options, save_string (option, len));
3063 add_linker_option (const char *option, int len)
3065 VEC_safe_push (char_p, heap, linker_options, save_string (option, len));
3068 /* Allocate space for an input file in infiles. */
3073 if (n_infiles_alloc == 0)
3075 n_infiles_alloc = 16;
3076 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3078 else if (n_infiles_alloc == n_infiles)
3080 n_infiles_alloc *= 2;
3081 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3085 /* Store an input file with the given NAME and LANGUAGE in
3089 add_infile (const char *name, const char *language)
3092 infiles[n_infiles].name = name;
3093 infiles[n_infiles++].language = language;
3096 /* Allocate space for a switch in switches. */
3101 if (n_switches_alloc == 0)
3103 n_switches_alloc = 16;
3104 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3106 else if (n_switches_alloc == n_switches)
3108 n_switches_alloc *= 2;
3109 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3113 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3114 as validated if VALIDATED. */
3117 save_switch (const char *opt, size_t n_args, const char *const *args,
3121 switches[n_switches].part1 = opt + 1;
3123 switches[n_switches].args = 0;
3126 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3127 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3128 switches[n_switches].args[n_args] = NULL;
3131 switches[n_switches].live_cond = 0;
3132 switches[n_switches].validated = validated;
3133 switches[n_switches].ordering = 0;
3137 /* Handle an option DECODED that is unknown to the option-processing
3141 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3143 const char *opt = decoded->arg;
3144 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3145 && !(decoded->errors & CL_ERR_NEGATIVE))
3147 /* Leave unknown -Wno-* options for the compiler proper, to be
3148 diagnosed only if there are warnings. */
3149 save_switch (decoded->canonical_option[0],
3150 decoded->canonical_option_num_elements - 1,
3151 &decoded->canonical_option[1], false);
3158 /* Handle an option DECODED that is not marked as CL_DRIVER.
3159 LANG_MASK will always be CL_DRIVER. */
3162 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3163 unsigned int lang_mask ATTRIBUTE_UNUSED)
3165 /* At this point, non-driver options are accepted (and expected to
3166 be passed down by specs) unless marked to be rejected by the
3167 driver. Options to be rejected by the driver but accepted by the
3168 compilers proper are treated just like completely unknown
3170 const struct cl_option *option = &cl_options[decoded->opt_index];
3172 if (option->cl_reject_driver)
3173 error ("unrecognized command line option %qs",
3174 decoded->orig_option_with_args_text);
3176 save_switch (decoded->canonical_option[0],
3177 decoded->canonical_option_num_elements - 1,
3178 &decoded->canonical_option[1], false);
3181 static const char *spec_lang = 0;
3182 static int last_language_n_infiles;
3184 /* Handle a driver option; arguments and return value as for
3188 driver_handle_option (struct gcc_options *opts,
3189 struct gcc_options *opts_set,
3190 const struct cl_decoded_option *decoded,
3191 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3193 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3194 diagnostic_context *dc)
3196 size_t opt_index = decoded->opt_index;
3197 const char *arg = decoded->arg;
3198 const char *compare_debug_replacement_opt;
3199 int value = decoded->value;
3200 bool validated = false;
3201 bool do_save = true;
3203 gcc_assert (opts == &global_options);
3204 gcc_assert (opts_set == &global_options_set);
3205 gcc_assert (kind == DK_UNSPECIFIED);
3206 gcc_assert (loc == UNKNOWN_LOCATION);
3207 gcc_assert (dc == global_dc);
3213 struct spec_list *sl;
3215 for (sl = specs; sl; sl = sl->next)
3216 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3217 if (link_command_spec)
3218 printf ("*link_command:\n%s\n\n", link_command_spec);
3222 case OPT_dumpversion:
3223 printf ("%s\n", spec_version);
3226 case OPT_dumpmachine:
3227 printf ("%s\n", spec_machine);
3233 /* CPP driver cannot obtain switch from cc1_options. */
3235 add_preprocessor_option ("--version", strlen ("--version"));
3236 add_assembler_option ("--version", strlen ("--version"));
3237 add_linker_option ("--version", strlen ("--version"));
3241 print_help_list = 1;
3243 /* CPP driver cannot obtain switch from cc1_options. */
3245 add_preprocessor_option ("--help", 6);
3246 add_assembler_option ("--help", 6);
3247 add_linker_option ("--help", 6);
3251 print_subprocess_help = 2;
3254 case OPT__target_help:
3255 print_subprocess_help = 1;
3257 /* CPP driver cannot obtain switch from cc1_options. */
3259 add_preprocessor_option ("--target-help", 13);
3260 add_assembler_option ("--target-help", 13);
3261 add_linker_option ("--target-help", 13);
3264 case OPT_pass_exit_codes:
3265 case OPT_print_search_dirs:
3266 case OPT_print_file_name_:
3267 case OPT_print_prog_name_:
3268 case OPT_print_multi_lib:
3269 case OPT_print_multi_directory:
3270 case OPT_print_sysroot:
3271 case OPT_print_multi_os_directory:
3272 case OPT_print_multiarch:
3273 case OPT_print_sysroot_headers_suffix:
3276 /* These options set the variables specified in common.opt
3277 automatically, and do not need to be saved for spec
3282 case OPT_print_libgcc_file_name:
3283 print_file_name = "libgcc.a";
3287 case OPT_fcompare_debug_second:
3288 compare_debug_second = 1;
3291 case OPT_fcompare_debug:
3295 compare_debug_replacement_opt = "-fcompare-debug=";
3297 goto compare_debug_with_arg;
3300 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3302 goto compare_debug_with_arg;
3309 case OPT_fcompare_debug_:
3310 compare_debug_replacement_opt = decoded->canonical_option[0];
3311 compare_debug_with_arg:
3312 gcc_assert (decoded->canonical_option_num_elements == 1);
3313 gcc_assert (arg != NULL);
3318 if (compare_debug < 0)
3319 compare_debug_opt = NULL;
3321 compare_debug_opt = arg;
3322 save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3328 /* Pass the rest of this option to the assembler. */
3330 /* Split the argument at commas. */
3332 for (j = 0; arg[j]; j++)
3335 add_assembler_option (arg + prev, j - prev);
3339 /* Record the part after the last comma. */
3340 add_assembler_option (arg + prev, j - prev);
3348 /* Pass the rest of this option to the preprocessor. */
3350 /* Split the argument at commas. */
3352 for (j = 0; arg[j]; j++)
3355 add_preprocessor_option (arg + prev, j - prev);
3359 /* Record the part after the last comma. */
3360 add_preprocessor_option (arg + prev, j - prev);
3368 /* Split the argument at commas. */
3370 for (j = 0; arg[j]; j++)
3373 add_infile (save_string (arg + prev, j - prev), "*");
3376 /* Record the part after the last comma. */
3377 add_infile (arg + prev, "*");
3383 add_infile (arg, "*");
3387 case OPT_Xpreprocessor:
3388 add_preprocessor_option (arg, strlen (arg));
3392 case OPT_Xassembler:
3393 add_assembler_option (arg, strlen (arg));
3398 /* POSIX allows separation of -l and the lib arg; canonicalize
3399 by concatenating -l with its arg */
3400 add_infile (concat ("-l", arg, NULL), "*");
3405 /* Similarly, canonicalize -L for linkers that may not accept
3406 separate arguments. */
3407 save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3412 save_switch (concat ("-F", arg, NULL), 0, NULL, validated);
3415 case OPT_save_temps:
3416 save_temps_flag = SAVE_TEMPS_CWD;
3420 case OPT_save_temps_:
3421 if (strcmp (arg, "cwd") == 0)
3422 save_temps_flag = SAVE_TEMPS_CWD;
3423 else if (strcmp (arg, "obj") == 0
3424 || strcmp (arg, "object") == 0)
3425 save_temps_flag = SAVE_TEMPS_OBJ;
3426 else if (strcmp (arg, "objects") == 0)
3427 save_temps_flag = SAVE_TEMPS_OBJZ;
3429 fatal_error ("%qs is an unknown -save-temps option",
3430 decoded->orig_option_with_args_text);
3433 case OPT_no_canonical_prefixes:
3434 /* Already handled as a special case, so ignored here. */
3440 /* These options set the variables specified in common.opt
3441 automatically, but do need to be saved for spec
3447 struct user_specs *user = XNEW (struct user_specs);
3449 user->next = (struct user_specs *) 0;
3450 user->filename = arg;
3451 if (user_specs_tail)
3452 user_specs_tail->next = user;
3454 user_specs_head = user;
3455 user_specs_tail = user;
3461 target_system_root = arg;
3462 target_system_root_changed = 1;
3467 if (report_times_to_file)
3468 fclose (report_times_to_file);
3469 report_times_to_file = fopen (arg, "a");
3475 This is similar to -v except that there is no execution
3476 of the commands and the echoed arguments are quoted. It
3477 is intended for use in shell scripts to capture the
3478 driver-generated command line. */
3479 verbose_only_flag++;
3486 size_t len = strlen (arg);
3488 /* Catch the case where the user has forgotten to append a
3489 directory separator to the path. Note, they may be using
3490 -B to add an executable name prefix, eg "i386-elf-", in
3491 order to distinguish between multiple installations of
3492 GCC in the same directory. Hence we must check to see
3493 if appending a directory separator actually makes a
3494 valid directory name. */
3495 if (!IS_DIR_SEPARATOR (arg[len - 1])
3496 && is_directory (arg, false))
3498 char *tmp = XNEWVEC (char, len + 2);
3500 tmp[len] = DIR_SEPARATOR;
3505 add_prefix (&exec_prefixes, arg, NULL,
3506 PREFIX_PRIORITY_B_OPT, 0, 0);
3507 add_prefix (&startfile_prefixes, arg, NULL,
3508 PREFIX_PRIORITY_B_OPT, 0, 0);
3509 add_prefix (&include_prefixes, arg, NULL,
3510 PREFIX_PRIORITY_B_OPT, 0, 0);
3517 if (!strcmp (spec_lang, "none"))
3518 /* Suppress the warning if -xnone comes after the last input
3519 file, because alternate command interfaces like g++ might
3520 find it useful to place -xnone after each input file. */
3523 last_language_n_infiles = n_infiles;
3529 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3530 arg = convert_filename (arg, ! have_c, 0);
3532 /* Save the output name in case -save-temps=obj was used. */
3533 save_temps_prefix = xstrdup (arg);
3534 /* On some systems, ld cannot handle "-o" without a space. So
3535 split the option from its argument. */
3536 save_switch ("-o", 1, &arg, validated);
3539 case OPT_static_libgcc:
3540 case OPT_shared_libgcc:
3541 case OPT_static_libgfortran:
3542 case OPT_static_libstdc__:
3543 /* These are always valid, since gcc.c itself understands the
3544 first two, gfortranspec.c understands -static-libgfortran and
3545 g++spec.c understands -static-libstdc++ */
3550 /* Various driver options need no special processing at this
3551 point, having been handled in a prescan above or being
3552 handled by specs. */
3557 save_switch (decoded->canonical_option[0],
3558 decoded->canonical_option_num_elements - 1,
3559 &decoded->canonical_option[1], validated);
3563 /* Put the driver's standard set of option handlers in *HANDLERS. */
3566 set_option_handlers (struct cl_option_handlers *handlers)
3568 handlers->unknown_option_callback = driver_unknown_option_callback;
3569 handlers->wrong_lang_callback = driver_wrong_lang_callback;
3570 handlers->num_handlers = 3;
3571 handlers->handlers[0].handler = driver_handle_option;
3572 handlers->handlers[0].mask = CL_DRIVER;
3573 handlers->handlers[1].handler = common_handle_option;
3574 handlers->handlers[1].mask = CL_COMMON;
3575 handlers->handlers[2].handler = target_handle_option;
3576 handlers->handlers[2].mask = CL_TARGET;
3579 /* Create the vector `switches' and its contents.
3580 Store its length in `n_switches'. */
3583 process_command (unsigned int decoded_options_count,
3584 struct cl_decoded_option *decoded_options)
3588 const char *tooldir_prefix;
3589 char *(*get_relative_prefix) (const char *, const char *,
3590 const char *) = NULL;
3591 struct cl_option_handlers handlers;
3594 gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3598 added_libraries = 0;
3600 /* Figure compiler version from version string. */
3602 compiler_version = temp1 = xstrdup (version_string);
3604 for (; *temp1; ++temp1)
3613 /* Handle any -no-canonical-prefixes flag early, to assign the function
3614 that builds relative prefixes. This function creates default search
3615 paths that are needed later in normal option handling. */
3617 for (j = 1; j < decoded_options_count; j++)
3619 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3621 get_relative_prefix = make_relative_prefix_ignore_links;
3625 if (! get_relative_prefix)
3626 get_relative_prefix = make_relative_prefix;
3628 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3629 see if we can create it from the pathname specified in
3630 decoded_options[0].arg. */
3632 gcc_libexec_prefix = standard_libexec_prefix;
3634 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3635 if (!gcc_exec_prefix)
3637 #if 0 /* Never use relative prefix (not bootstrapped) */
3638 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3639 standard_bindir_prefix,
3640 standard_exec_prefix);
3641 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3642 standard_bindir_prefix,
3643 standard_libexec_prefix);
3644 if (gcc_exec_prefix)
3645 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3650 /* make_relative_prefix requires a program name, but
3651 GCC_EXEC_PREFIX is typically a directory name with a trailing
3652 / (which is ignored by make_relative_prefix), so append a
3654 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3655 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3656 standard_exec_prefix,
3657 standard_libexec_prefix);
3659 /* The path is unrelocated, so fallback to the original setting. */
3660 if (!gcc_libexec_prefix)
3661 gcc_libexec_prefix = standard_libexec_prefix;
3667 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3668 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3669 or an automatically created GCC_EXEC_PREFIX from
3670 decoded_options[0].arg. */
3672 /* Do language-specific adjustment/addition of flags. */
3673 lang_specific_driver (&decoded_options, &decoded_options_count,
3676 if (gcc_exec_prefix)
3678 int len = strlen (gcc_exec_prefix);
3680 if (len > (int) sizeof ("/lib/gcc/") - 1
3681 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3683 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3684 if (IS_DIR_SEPARATOR (*temp)
3685 && filename_ncmp (temp + 1, "lib", 3) == 0
3686 && IS_DIR_SEPARATOR (temp[4])
3687 && filename_ncmp (temp + 5, "gcc", 3) == 0)
3688 len -= sizeof ("/lib/gcc/") - 1;
3691 #if 0 /* Bad Paths */
3692 set_std_prefix (gcc_exec_prefix, len);
3693 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3694 PREFIX_PRIORITY_LAST, 0, 0);
3695 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3696 PREFIX_PRIORITY_LAST, 0, 0);
3700 /* COMPILER_PATH and LIBRARY_PATH have values
3701 that are lists of directory names with colons. */
3703 temp = getenv ("COMPILER_PATH");
3706 const char *startp, *endp;
3707 char *nstore = (char *) alloca (strlen (temp) + 3);
3709 startp = endp = temp;
3712 if (*endp == PATH_SEPARATOR || *endp == 0)
3714 strncpy (nstore, startp, endp - startp);
3716 strcpy (nstore, concat (".", dir_separator_str, NULL));
3717 else if (!IS_DIR_SEPARATOR (endp[-1]))
3719 nstore[endp - startp] = DIR_SEPARATOR;
3720 nstore[endp - startp + 1] = 0;
3723 nstore[endp - startp] = 0;
3724 add_prefix (&exec_prefixes, nstore, 0,
3725 PREFIX_PRIORITY_LAST, 0, 0);
3726 add_prefix (&include_prefixes, nstore, 0,
3727 PREFIX_PRIORITY_LAST, 0, 0);
3730 endp = startp = endp + 1;
3737 temp = getenv (LIBRARY_PATH_ENV);
3738 if (temp && *cross_compile == '0')
3740 const char *startp, *endp;
3741 char *nstore = (char *) alloca (strlen (temp) + 3);
3743 startp = endp = temp;
3746 if (*endp == PATH_SEPARATOR || *endp == 0)
3748 strncpy (nstore, startp, endp - startp);
3750 strcpy (nstore, concat (".", dir_separator_str, NULL));
3751 else if (!IS_DIR_SEPARATOR (endp[-1]))
3753 nstore[endp - startp] = DIR_SEPARATOR;
3754 nstore[endp - startp + 1] = 0;
3757 nstore[endp - startp] = 0;
3758 add_prefix (&startfile_prefixes, nstore, NULL,
3759 PREFIX_PRIORITY_LAST, 0, 1);
3762 endp = startp = endp + 1;
3769 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3770 temp = getenv ("LPATH");
3771 if (temp && *cross_compile == '0')
3773 const char *startp, *endp;
3774 char *nstore = (char *) alloca (strlen (temp) + 3);
3776 startp = endp = temp;
3779 if (*endp == PATH_SEPARATOR || *endp == 0)
3781 strncpy (nstore, startp, endp - startp);
3783 strcpy (nstore, concat (".", dir_separator_str, NULL));
3784 else if (!IS_DIR_SEPARATOR (endp[-1]))
3786 nstore[endp - startp] = DIR_SEPARATOR;
3787 nstore[endp - startp + 1] = 0;
3790 nstore[endp - startp] = 0;
3791 add_prefix (&startfile_prefixes, nstore, NULL,
3792 PREFIX_PRIORITY_LAST, 0, 1);
3795 endp = startp = endp + 1;
3802 /* Process the options and store input files and switches in their
3805 last_language_n_infiles = -1;
3807 set_option_handlers (&handlers);
3809 for (j = 1; j < decoded_options_count; j++)
3811 switch (decoded_options[j].opt_index)
3823 for (j = 1; j < decoded_options_count; j++)
3825 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3827 const char *arg = decoded_options[j].arg;
3828 const char *p = strrchr (arg, '@');
3832 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3833 arg = convert_filename (arg, 0, access (arg, F_OK));
3835 /* For LTO static archive support we handle input file
3836 specifications that are composed of a filename and
3837 an offset like FNAME@OFFSET. */
3840 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3841 && strlen (p) == (unsigned int)consumed)
3843 fname = (char *)xmalloc (p - arg + 1);
3844 memcpy (fname, arg, p - arg);
3845 fname[p - arg] = '\0';
3846 /* Only accept non-stdin and existing FNAME parts, otherwise
3847 try with the full name. */
3848 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3851 fname = xstrdup (arg);
3855 fname = xstrdup (arg);
3857 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3858 perror_with_name (fname);
3860 add_infile (arg, spec_lang);
3866 read_cmdline_option (&global_options, &global_options_set,
3867 decoded_options + j, UNKNOWN_LOCATION,
3868 CL_DRIVER, &handlers, global_dc);
3871 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3872 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3873 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3875 save_temps_length = strlen (save_temps_prefix);
3876 temp = strrchr (lbasename (save_temps_prefix), '.');
3879 save_temps_length -= strlen (temp);
3880 save_temps_prefix[save_temps_length] = '\0';
3884 else if (save_temps_flag == SAVE_TEMPS_OBJZ && save_temps_prefix != NULL)
3886 save_temps_length = strlen (save_temps_prefix);
3888 else if (save_temps_prefix != NULL)
3890 free (save_temps_prefix);
3891 save_temps_prefix = NULL;
3894 if (save_temps_flag && use_pipes)
3896 /* -save-temps overrides -pipe, so that temp files are produced */
3897 if (save_temps_flag)
3898 warning (0, "-pipe ignored because -save-temps specified");
3904 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3906 if (gcd && gcd[0] == '-')
3909 compare_debug_opt = gcd;
3911 else if (gcd && *gcd && strcmp (gcd, "0"))
3914 compare_debug_opt = "-gtoggle";
3917 else if (compare_debug < 0)
3920 gcc_assert (!compare_debug_opt);
3923 /* Set up the search paths. We add directories that we expect to
3924 contain GNU Toolchain components before directories specified by
3925 the machine description so that we will find GNU components (like
3926 the GNU assembler) before those of the host system. */
3928 /* If we don't know where the toolchain has been installed, use the
3929 configured-in locations. */
3930 if (!gcc_exec_prefix)
3933 add_prefix (&exec_prefixes, standard_libexec_prefix, NULL,
3934 PREFIX_PRIORITY_LAST, 0, 0);
3935 #if 0 /* Bad paths */
3936 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3937 PREFIX_PRIORITY_LAST, 1, 0);
3938 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3939 PREFIX_PRIORITY_LAST, 2, 0);
3940 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3941 PREFIX_PRIORITY_LAST, 2, 0);
3944 #if 0 /* Bad paths */
3945 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3946 PREFIX_PRIORITY_LAST, 1, 0);
3950 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
3951 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3952 dir_separator_str, NULL);
3954 /* Look for tools relative to the location from which the driver is
3955 running, or, if that is not available, the configured prefix. */
3957 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
3958 spec_machine, dir_separator_str,
3959 spec_version, dir_separator_str, tooldir_prefix, NULL);
3961 #if 0 /* Bad paths */
3962 add_prefix (&exec_prefixes,
3963 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3964 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3965 add_prefix (&startfile_prefixes,
3966 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3967 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3970 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3971 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3972 then consider it to relocate with the rest of the GCC installation
3973 if GCC_EXEC_PREFIX is set.
3974 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3975 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
3977 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
3978 standard_bindir_prefix,
3979 target_system_root);
3980 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3982 target_system_root = tmp_prefix;
3983 target_system_root_changed = 1;
3988 /* More prefixes are enabled in main, after we read the specs file
3989 and determine whether this is cross-compilation or not. */
3991 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3992 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
3994 if (compare_debug == 2 || compare_debug == 3)
3997 switches[n_switches].part1 = concat ("fcompare-debug=",
4000 switches[n_switches].args = 0;
4001 switches[n_switches].live_cond = 0;
4002 switches[n_switches].validated = 0;
4003 switches[n_switches].ordering = 0;
4008 /* Ensure we only invoke each subprocess once. */
4009 if (print_subprocess_help || print_help_list || print_version)
4013 /* Create a dummy input file, so that we can pass
4014 the help option on to the various sub-processes. */
4015 add_infile ("help-dummy", "c");
4019 switches[n_switches].part1 = 0;
4021 infiles[n_infiles].name = 0;
4024 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4025 and place that in the environment. */
4028 set_collect_gcc_options (void)
4033 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4035 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4036 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4039 for (i = 0; (int) i < n_switches; i++)
4041 const char *const *args;
4044 obstack_grow (&collect_obstack, " ", 1);
4048 /* Ignore elided switches. */
4049 if ((switches[i].live_cond
4050 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4054 obstack_grow (&collect_obstack, "'-", 2);
4055 q = switches[i].part1;
4056 while ((p = strchr (q, '\'')))
4058 obstack_grow (&collect_obstack, q, p - q);
4059 obstack_grow (&collect_obstack, "'\\''", 4);
4062 obstack_grow (&collect_obstack, q, strlen (q));
4063 obstack_grow (&collect_obstack, "'", 1);
4065 for (args = switches[i].args; args && *args; args++)
4067 obstack_grow (&collect_obstack, " '", 2);
4069 while ((p = strchr (q, '\'')))
4071 obstack_grow (&collect_obstack, q, p - q);
4072 obstack_grow (&collect_obstack, "'\\''", 4);
4075 obstack_grow (&collect_obstack, q, strlen (q));
4076 obstack_grow (&collect_obstack, "'", 1);
4079 obstack_grow (&collect_obstack, "\0", 1);
4080 xputenv (XOBFINISH (&collect_obstack, char *));
4083 /* Process a spec string, accumulating and running commands. */
4085 /* These variables describe the input file name.
4086 input_file_number is the index on outfiles of this file,
4087 so that the output file name can be stored for later use by %o.
4088 input_basename is the start of the part of the input file
4089 sans all directory names, and basename_length is the number
4090 of characters starting there excluding the suffix .c or whatever. */
4092 static const char *gcc_input_filename;
4093 static int input_file_number;
4094 size_t input_filename_length;
4095 static int basename_length;
4096 static int suffixed_basename_length;
4097 static const char *input_basename;
4098 static const char *input_suffix;
4099 #ifndef HOST_LACKS_INODE_NUMBERS
4100 static struct stat input_stat;
4102 static int input_stat_set;
4104 /* The compiler used to process the current input file. */
4105 static struct compiler *input_file_compiler;
4107 /* These are variables used within do_spec and do_spec_1. */
4109 /* Nonzero if an arg has been started and not yet terminated
4110 (with space, tab or newline). */
4111 static int arg_going;
4113 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4114 is a temporary file name. */
4115 static int delete_this_arg;
4117 /* Nonzero means %w has been seen; the next arg to be terminated
4118 is the output file name of this compilation. */
4119 static int this_is_output_file;
4121 /* Nonzero means %s has been seen; the next arg to be terminated
4122 is the name of a library file and we should try the standard
4123 search dirs for it. */
4124 static int this_is_library_file;
4126 /* Nonzero means %T has been seen; the next arg to be terminated
4127 is the name of a linker script and we should try all of the
4128 standard search dirs for it. If it is found insert a --script
4129 command line switch and then substitute the full path in place,
4130 otherwise generate an error message. */
4131 static int this_is_linker_script;
4133 /* Nonzero means that the input of this command is coming from a pipe. */
4134 static int input_from_pipe;
4136 /* Nonnull means substitute this for any suffix when outputting a switches
4138 static const char *suffix_subst;
4140 /* If there is an argument being accumulated, terminate it and store it. */
4143 end_going_arg (void)
4149 obstack_1grow (&obstack, 0);
4150 string = XOBFINISH (&obstack, const char *);
4151 if (this_is_library_file)
4152 string = find_file (string);
4153 if (this_is_linker_script)
4155 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4157 if (full_script_path == NULL)
4159 error ("unable to locate default linker script %qs in the library search paths", string);
4160 /* Script was not found on search path. */
4163 store_arg ("--script", false, false);
4164 string = full_script_path;
4166 store_arg (string, delete_this_arg, this_is_output_file);
4167 if (this_is_output_file)
4168 outfiles[input_file_number] = string;
4174 /* Parse the WRAPPER string which is a comma separated list of the command line
4175 and insert them into the beginning of argbuf. */
4178 insert_wrapper (const char *wrapper)
4182 char *buf = xstrdup (wrapper);
4184 unsigned int old_length = VEC_length (const_char_p, argbuf);
4192 while ((p = strchr (p, ',')) != NULL);
4194 VEC_safe_grow (const_char_p, heap, argbuf, old_length + n);
4195 memmove (VEC_address (const_char_p, argbuf) + n,
4196 VEC_address (const_char_p, argbuf),
4197 old_length * sizeof (const_char_p));
4208 VEC_replace (const_char_p, argbuf, i, p);
4211 while ((p = strchr (p, ',')) != NULL);
4212 gcc_assert (i == n);
4215 /* Process the spec SPEC and run the commands specified therein.
4216 Returns 0 if the spec is successfully processed; -1 if failed. */
4219 do_spec (const char *spec)
4223 value = do_spec_2 (spec);
4225 /* Force out any unfinished command.
4226 If -pipe, this forces out the last command if it ended in `|'. */
4229 if (VEC_length (const_char_p, argbuf) > 0
4230 && !strcmp (VEC_last (const_char_p, argbuf), "|"))
4231 VEC_pop (const_char_p, argbuf);
4233 set_collect_gcc_options ();
4235 if (VEC_length (const_char_p, argbuf) > 0)
4243 do_spec_2 (const char *spec)
4249 delete_this_arg = 0;
4250 this_is_output_file = 0;
4251 this_is_library_file = 0;
4252 this_is_linker_script = 0;
4253 input_from_pipe = 0;
4254 suffix_subst = NULL;
4256 result = do_spec_1 (spec, 0, NULL);
4264 /* Process the given spec string and add any new options to the end
4265 of the switches/n_switches array. */
4268 do_option_spec (const char *name, const char *spec)
4270 unsigned int i, value_count, value_len;
4271 const char *p, *q, *value;
4272 char *tmp_spec, *tmp_spec_p;
4274 if (configure_default_options[0].name == NULL)
4277 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4278 if (strcmp (configure_default_options[i].name, name) == 0)
4280 if (i == ARRAY_SIZE (configure_default_options))
4283 value = configure_default_options[i].value;
4284 value_len = strlen (value);
4286 /* Compute the size of the final spec. */
4289 while ((p = strstr (p, "%(VALUE)")) != NULL)
4295 /* Replace each %(VALUE) by the specified value. */
4296 tmp_spec = (char *) alloca (strlen (spec) + 1
4297 + value_count * (value_len - strlen ("%(VALUE)")));
4298 tmp_spec_p = tmp_spec;
4300 while ((p = strstr (q, "%(VALUE)")) != NULL)
4302 memcpy (tmp_spec_p, q, p - q);
4303 tmp_spec_p = tmp_spec_p + (p - q);
4304 memcpy (tmp_spec_p, value, value_len);
4305 tmp_spec_p += value_len;
4306 q = p + strlen ("%(VALUE)");
4308 strcpy (tmp_spec_p, q);
4310 do_self_spec (tmp_spec);
4313 /* Process the given spec string and add any new options to the end
4314 of the switches/n_switches array. */
4317 do_self_spec (const char *spec)
4322 do_spec_1 (" ", 0, NULL);
4324 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4325 do_self_specs adds the replacements to switches array, so it shouldn't
4326 be processed afterwards. */
4327 for (i = 0; i < n_switches; i++)
4328 if ((switches[i].live_cond & SWITCH_IGNORE))
4329 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4331 if (VEC_length (const_char_p, argbuf) > 0)
4333 const char **argbuf_copy;
4334 struct cl_decoded_option *decoded_options;
4335 struct cl_option_handlers handlers;
4336 unsigned int decoded_options_count;
4339 /* Create a copy of argbuf with a dummy argv[0] entry for
4340 decode_cmdline_options_to_array. */
4341 argbuf_copy = XNEWVEC (const char *,
4342 VEC_length (const_char_p, argbuf) + 1);
4343 argbuf_copy[0] = "";
4344 memcpy (argbuf_copy + 1, VEC_address (const_char_p, argbuf),
4345 VEC_length (const_char_p, argbuf) * sizeof (const char *));
4347 decode_cmdline_options_to_array (VEC_length (const_char_p, argbuf) + 1,
4349 CL_DRIVER, &decoded_options,
4350 &decoded_options_count);
4352 set_option_handlers (&handlers);
4354 for (j = 1; j < decoded_options_count; j++)
4356 switch (decoded_options[j].opt_index)
4358 case OPT_SPECIAL_input_file:
4359 /* Specs should only generate options, not input
4361 if (strcmp (decoded_options[j].arg, "-") != 0)
4362 fatal_error ("switch %qs does not start with %<-%>",
4363 decoded_options[j].arg);
4365 fatal_error ("spec-generated switch is just %<-%>");
4368 case OPT_fcompare_debug_second:
4369 case OPT_fcompare_debug:
4370 case OPT_fcompare_debug_:
4372 /* Avoid duplicate processing of some options from
4373 compare-debug specs; just save them here. */
4374 save_switch (decoded_options[j].canonical_option[0],
4375 (decoded_options[j].canonical_option_num_elements
4377 &decoded_options[j].canonical_option[1], false);
4381 read_cmdline_option (&global_options, &global_options_set,
4382 decoded_options + j, UNKNOWN_LOCATION,
4383 CL_DRIVER, &handlers, global_dc);
4389 switches[n_switches].part1 = 0;
4393 /* Callback for processing %D and %I specs. */
4395 struct spec_path_info {
4400 bool separate_options;
4404 spec_path (char *path, void *data)
4406 struct spec_path_info *info = (struct spec_path_info *) data;
4410 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4413 if (info->append_len != 0)
4415 len = strlen (path);
4416 memcpy (path + len, info->append, info->append_len + 1);
4419 if (!is_directory (path, true))
4422 do_spec_1 (info->option, 1, NULL);
4423 if (info->separate_options)
4424 do_spec_1 (" ", 0, NULL);
4426 if (info->append_len == 0)
4428 len = strlen (path);
4429 save = path[len - 1];
4430 if (IS_DIR_SEPARATOR (path[len - 1]))
4431 path[len - 1] = '\0';
4434 do_spec_1 (path, 1, NULL);
4435 do_spec_1 (" ", 0, NULL);
4437 /* Must not damage the original path. */
4438 if (info->append_len == 0)
4439 path[len - 1] = save;
4444 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4448 create_at_file (char **argv)
4450 char *temp_file = make_temp_file ("");
4451 char *at_argument = concat ("@", temp_file, NULL);
4452 FILE *f = fopen (temp_file, "w");
4456 fatal_error ("could not open temporary response file %s",
4459 status = writeargv (argv, f);
4462 fatal_error ("could not write to temporary response file %s",
4465 status = fclose (f);
4468 fatal_error ("could not close temporary response file %s",
4471 store_arg (at_argument, 0, 0);
4473 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4476 /* True if we should compile INFILE. */
4479 compile_input_file_p (struct infile *infile)
4481 if ((!infile->language) || (infile->language[0] != '*'))
4482 if (infile->incompiler == input_file_compiler)
4487 /* Process each member of VEC as a spec. */
4490 do_specs_vec (VEC(char_p,heap) *vec)
4495 FOR_EACH_VEC_ELT (char_p, vec, ix, opt)
4497 do_spec_1 (opt, 1, NULL);
4498 /* Make each accumulated option a separate argument. */
4499 do_spec_1 (" ", 0, NULL);
4503 /* Process the sub-spec SPEC as a portion of a larger spec.
4504 This is like processing a whole spec except that we do
4505 not initialize at the beginning and we do not supply a
4506 newline by default at the end.
4507 INSWITCH nonzero means don't process %-sequences in SPEC;
4508 in this case, % is treated as an ordinary character.
4509 This is used while substituting switches.
4510 INSWITCH nonzero also causes SPC not to terminate an argument.
4512 Value is zero unless a line was finished
4513 and the command on that line reported an error. */
4516 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4518 const char *p = spec;
4523 /* If it's an empty string argument to a switch, keep it as is. */
4524 if (inswitch && !*p)
4528 /* If substituting a switch, treat all chars like letters.
4529 Otherwise, NL, SPC, TAB and % are special. */
4530 switch (inswitch ? 'a' : c)
4535 if (VEC_length (const_char_p, argbuf) > 0
4536 && !strcmp (VEC_last (const_char_p, argbuf), "|"))
4538 /* A `|' before the newline means use a pipe here,
4539 but only if -pipe was specified.
4540 Otherwise, execute now and don't pass the `|' as an arg. */
4543 input_from_pipe = 1;
4547 VEC_pop (const_char_p, argbuf);
4550 set_collect_gcc_options ();
4552 if (VEC_length (const_char_p, argbuf) > 0)
4558 /* Reinitialize for a new command, and for a new argument. */
4561 delete_this_arg = 0;
4562 this_is_output_file = 0;
4563 this_is_library_file = 0;
4564 this_is_linker_script = 0;
4565 input_from_pipe = 0;
4572 obstack_1grow (&obstack, c);
4580 /* Reinitialize for a new argument. */
4581 delete_this_arg = 0;
4582 this_is_output_file = 0;
4583 this_is_library_file = 0;
4584 this_is_linker_script = 0;
4591 fatal_error ("spec %qs invalid", spec);
4594 if (save_temps_length)
4595 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4597 obstack_grow (&obstack, input_basename, basename_length);
4598 if (compare_debug < 0)
4599 obstack_grow (&obstack, ".gk", 3);
4604 if (save_temps_length)
4605 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4607 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4608 if (compare_debug < 0)
4609 obstack_grow (&obstack, ".gk", 3);
4614 delete_this_arg = 2;
4617 /* Dump out the directories specified with LIBRARY_PATH,
4618 followed by the absolute directories
4619 that we search for startfiles. */
4622 struct spec_path_info info;
4625 info.append_len = 0;
4626 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4627 /* Used on systems which record the specified -L dirs
4628 and use them to search for dynamic linking.
4629 Relative directories always come from -B,
4630 and it is better not to use them for searching
4631 at run time. In particular, stage1 loses. */
4632 info.omit_relative = true;
4634 info.omit_relative = false;
4636 info.separate_options = false;
4638 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4643 /* %efoo means report an error with `foo' as error message
4644 and don't execute any more commands for this file. */
4648 while (*p != 0 && *p != '\n')
4650 buf = (char *) alloca (p - q + 1);
4651 strncpy (buf, q, p - q);
4653 error ("%s", _(buf));
4658 /* %nfoo means report a notice with `foo' on stderr. */
4662 while (*p != 0 && *p != '\n')
4664 buf = (char *) alloca (p - q + 1);
4665 strncpy (buf, q, p - q);
4667 inform (0, "%s", _(buf));
4677 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4678 defined, and it is not a directory, and it is
4679 writable, use it. Otherwise, treat this like any
4680 other temporary file. */
4682 if ((!save_temps_flag)
4683 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4684 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4686 obstack_grow (&obstack, HOST_BIT_BUCKET,
4687 strlen (HOST_BIT_BUCKET));
4688 delete_this_arg = 0;
4693 goto create_temp_file;
4697 obstack_1grow (&obstack, '-');
4698 delete_this_arg = 0;
4701 /* consume suffix */
4702 while (*p == '.' || ISALNUM ((unsigned char) *p))
4704 if (p[0] == '%' && p[1] == 'O')
4709 goto create_temp_file;
4713 /* consume suffix */
4714 while (*p == '.' || ISALNUM ((unsigned char) *p))
4716 if (p[0] == '%' && p[1] == 'O')
4721 goto create_temp_file;
4727 struct temp_name *t;
4729 const char *suffix = p;
4730 char *saved_suffix = NULL;
4732 while (*p == '.' || ISALNUM ((unsigned char) *p))
4734 suffix_length = p - suffix;
4735 if (p[0] == '%' && p[1] == 'O')
4738 /* We don't support extra suffix characters after %O. */
4739 if (*p == '.' || ISALNUM ((unsigned char) *p))
4740 fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4741 if (suffix_length == 0)
4742 suffix = TARGET_OBJECT_SUFFIX;
4746 = XNEWVEC (char, suffix_length
4747 + strlen (TARGET_OBJECT_SUFFIX));
4748 strncpy (saved_suffix, suffix, suffix_length);
4749 strcpy (saved_suffix + suffix_length,
4750 TARGET_OBJECT_SUFFIX);
4752 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4755 if (compare_debug < 0)
4757 suffix = concat (".gk", suffix, NULL);
4761 /* If -save-temps=obj and -o were specified, use that for the
4763 if (save_temps_length)
4766 temp_filename_length
4767 = save_temps_length + suffix_length + 1;
4768 tmp = (char *) alloca (temp_filename_length);
4769 memcpy (tmp, save_temps_prefix, save_temps_length);
4770 memcpy (tmp + save_temps_length, suffix, suffix_length);
4771 tmp[save_temps_length + suffix_length] = '\0';
4772 temp_filename = save_string (tmp,
4773 temp_filename_length + 1);
4774 obstack_grow (&obstack, temp_filename,
4775 temp_filename_length);
4777 delete_this_arg = 0;
4781 /* If the gcc_input_filename has the same suffix specified
4782 for the %g, %u, or %U, and -save-temps is specified,
4783 we could end up using that file as an intermediate
4784 thus clobbering the user's source file (.e.g.,
4785 gcc -save-temps foo.s would clobber foo.s with the
4786 output of cpp0). So check for this condition and
4787 generate a temp file as the intermediate. */
4789 if (save_temps_flag)
4792 temp_filename_length = basename_length + suffix_length + 1;
4793 tmp = (char *) alloca (temp_filename_length);
4794 memcpy (tmp, input_basename, basename_length);
4795 memcpy (tmp + basename_length, suffix, suffix_length);
4796 tmp[basename_length + suffix_length] = '\0';
4797 temp_filename = tmp;
4799 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4801 #ifndef HOST_LACKS_INODE_NUMBERS
4802 struct stat st_temp;
4804 /* Note, set_input() resets input_stat_set to 0. */
4805 if (input_stat_set == 0)
4807 input_stat_set = stat (gcc_input_filename,
4809 if (input_stat_set >= 0)
4813 /* If we have the stat for the gcc_input_filename
4814 and we can do the stat for the temp_filename
4815 then the they could still refer to the same
4816 file if st_dev/st_ino's are the same. */
4817 if (input_stat_set != 1
4818 || stat (temp_filename, &st_temp) < 0
4819 || input_stat.st_dev != st_temp.st_dev
4820 || input_stat.st_ino != st_temp.st_ino)
4822 /* Just compare canonical pathnames. */
4823 char* input_realname = lrealpath (gcc_input_filename);
4824 char* temp_realname = lrealpath (temp_filename);
4825 bool files_differ = filename_cmp (input_realname, temp_realname);
4826 free (input_realname);
4827 free (temp_realname);
4831 temp_filename = save_string (temp_filename,
4832 temp_filename_length + 1);
4833 obstack_grow (&obstack, temp_filename,
4834 temp_filename_length);
4836 delete_this_arg = 0;
4842 /* See if we already have an association of %g/%u/%U and
4844 for (t = temp_names; t; t = t->next)
4845 if (t->length == suffix_length
4846 && strncmp (t->suffix, suffix, suffix_length) == 0
4847 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4850 /* Make a new association if needed. %u and %j
4852 if (t == 0 || c == 'u' || c == 'j')
4856 t = XNEW (struct temp_name);
4857 t->next = temp_names;
4860 t->length = suffix_length;
4863 t->suffix = saved_suffix;
4864 saved_suffix = NULL;
4867 t->suffix = save_string (suffix, suffix_length);
4868 t->unique = (c == 'u' || c == 'U' || c == 'j');
4869 temp_filename = make_temp_file (t->suffix);
4870 temp_filename_length = strlen (temp_filename);
4871 t->filename = temp_filename;
4872 t->filename_length = temp_filename_length;
4875 free (saved_suffix);
4877 obstack_grow (&obstack, t->filename, t->filename_length);
4878 delete_this_arg = 1;
4886 if (at_file_supplied)
4888 /* We are going to expand `%i' to `@FILE', where FILE
4889 is a newly-created temporary filename. The filenames
4890 that would usually be expanded in place of %o will be
4891 written to the temporary file. */
4896 for (i = 0; i < n_infiles; i++)
4897 if (compile_input_file_p (&infiles[i]))
4900 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4902 /* Copy the strings over. */
4903 for (i = 0, j = 0; i < n_infiles; i++)
4904 if (compile_input_file_p (&infiles[i]))
4906 argv[j] = CONST_CAST (char *, infiles[i].name);
4907 infiles[i].compiled = true;
4912 create_at_file (argv);
4915 for (i = 0; (int) i < n_infiles; i++)
4916 if (compile_input_file_p (&infiles[i]))
4918 store_arg (infiles[i].name, 0, 0);
4919 infiles[i].compiled = true;
4924 obstack_grow (&obstack, gcc_input_filename,
4925 input_filename_length);
4932 struct spec_path_info info;
4936 do_spec_1 ("-imultilib", 1, NULL);
4937 /* Make this a separate argument. */
4938 do_spec_1 (" ", 0, NULL);
4939 do_spec_1 (multilib_dir, 1, NULL);
4940 do_spec_1 (" ", 0, NULL);
4945 do_spec_1 ("-imultiarch", 1, NULL);
4946 /* Make this a separate argument. */
4947 do_spec_1 (" ", 0, NULL);
4948 do_spec_1 (multiarch_dir, 1, NULL);
4949 do_spec_1 (" ", 0, NULL);
4952 if (gcc_exec_prefix)
4954 do_spec_1 ("-iprefix", 1, NULL);
4955 /* Make this a separate argument. */
4956 do_spec_1 (" ", 0, NULL);
4957 do_spec_1 (gcc_exec_prefix, 1, NULL);
4958 do_spec_1 (" ", 0, NULL);
4961 if (target_system_root_changed ||
4962 (target_system_root && target_sysroot_hdrs_suffix))
4964 do_spec_1 ("-isysroot", 1, NULL);
4965 /* Make this a separate argument. */
4966 do_spec_1 (" ", 0, NULL);
4967 do_spec_1 (target_system_root, 1, NULL);
4968 if (target_sysroot_hdrs_suffix)
4969 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4970 do_spec_1 (" ", 0, NULL);
4973 info.option = "-isystem";
4974 info.append = "include";
4975 info.append_len = strlen (info.append);
4976 info.omit_relative = false;
4977 info.separate_options = true;
4979 for_each_path (&include_prefixes, false, info.append_len,
4982 info.append = "include-fixed";
4983 if (*sysroot_hdrs_suffix_spec)
4984 info.append = concat (info.append, dir_separator_str,
4985 multilib_dir, NULL);
4986 info.append_len = strlen (info.append);
4987 for_each_path (&include_prefixes, false, info.append_len,
4994 int max = n_infiles;
4995 max += lang_specific_extra_outfiles;
4997 if (HAVE_GNU_LD && at_file_supplied)
4999 /* We are going to expand `%o' to `@FILE', where FILE
5000 is a newly-created temporary filename. The filenames
5001 that would usually be expanded in place of %o will be
5002 written to the temporary file. */
5007 /* Convert OUTFILES into a form suitable for writeargv. */
5009 /* Determine how many are non-NULL. */
5010 for (n_files = 0, i = 0; i < max; i++)
5011 n_files += outfiles[i] != NULL;
5013 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5015 /* Copy the strings over. */
5016 for (i = 0, j = 0; i < max; i++)
5019 argv[j] = CONST_CAST (char *, outfiles[i]);
5024 create_at_file (argv);
5027 for (i = 0; i < max; i++)
5029 store_arg (outfiles[i], 0, 0);
5034 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5039 this_is_library_file = 1;
5043 this_is_linker_script = 1;
5047 outfiles[input_file_number] = NULL;
5051 this_is_output_file = 1;
5056 unsigned int cur_index = VEC_length (const_char_p, argbuf);
5057 /* Handle the {...} following the %W. */
5059 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5060 p = handle_braces (p + 1);
5064 /* If any args were output, mark the last one for deletion
5066 if (VEC_length (const_char_p, argbuf) != cur_index)
5067 record_temp_file (VEC_last (const_char_p, argbuf), 0, 1);
5071 /* %x{OPTION} records OPTION for %X to output. */
5079 /* Skip past the option value and make a copy. */
5081 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5084 string = save_string (p1 + 1, p - p1 - 2);
5086 /* See if we already recorded this option. */
5087 FOR_EACH_VEC_ELT (char_p, linker_options, ix, opt)
5088 if (! strcmp (string, opt))
5094 /* This option is new; add it. */
5095 add_linker_option (string, strlen (string));
5099 /* Dump out the options accumulated previously using %x. */
5101 do_specs_vec (linker_options);
5104 /* Dump out the options accumulated previously using -Wa,. */
5106 do_specs_vec (assembler_options);
5109 /* Dump out the options accumulated previously using -Wp,. */
5111 do_specs_vec (preprocessor_options);
5114 /* Here are digits and numbers that just process
5115 a certain constant string as a spec. */
5118 value = do_spec_1 (cc1_spec, 0, NULL);
5124 value = do_spec_1 (cc1plus_spec, 0, NULL);
5130 value = do_spec_1 (asm_spec, 0, NULL);
5136 value = do_spec_1 (asm_final_spec, 0, NULL);
5143 const char *const spec
5144 = (input_file_compiler->cpp_spec
5145 ? input_file_compiler->cpp_spec
5147 value = do_spec_1 (spec, 0, NULL);
5154 value = do_spec_1 (endfile_spec, 0, NULL);
5160 value = do_spec_1 (link_spec, 0, NULL);
5166 value = do_spec_1 (lib_spec, 0, NULL);
5172 value = do_spec_1 (libgcc_spec, 0, NULL);
5178 /* We assume there is a directory
5179 separator at the end of this string. */
5180 if (target_system_root)
5182 obstack_grow (&obstack, target_system_root,
5183 strlen (target_system_root));
5184 if (target_sysroot_suffix)
5185 obstack_grow (&obstack, target_sysroot_suffix,
5186 strlen (target_sysroot_suffix));
5191 value = do_spec_1 (startfile_spec, 0, NULL);
5196 /* Here we define characters other than letters and digits. */
5199 p = handle_braces (p);
5205 p = handle_spec_function (p);
5211 obstack_1grow (&obstack, '%');
5218 while (p[len] && p[len] != ' ' && p[len] != '%')
5220 suffix_subst = save_string (p - 1, len + 1);
5225 /* Henceforth ignore the option(s) matching the pattern
5231 int have_wildcard = 0;
5236 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5238 switch_option = SWITCH_IGNORE;
5240 while (p[len] && p[len] != ' ' && p[len] != '\t')
5243 if (p[len-1] == '*')
5246 for (i = 0; i < n_switches; i++)
5247 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5248 && (have_wildcard || switches[i].part1[len] == '\0'))
5250 switches[i].live_cond |= switch_option;
5251 switches[i].validated = 1;
5259 if (soft_matched_part)
5261 if (soft_matched_part[0])
5262 do_spec_1 (soft_matched_part, 1, NULL);
5263 do_spec_1 (" ", 0, NULL);
5266 /* Catch the case where a spec string contains something like
5267 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5268 hand side of the :. */
5269 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5272 /* Process a string found as the value of a spec given by name.
5273 This feature allows individual machine descriptions
5274 to add and use their own specs. */
5277 const char *name = p;
5278 struct spec_list *sl;
5281 /* The string after the S/P is the name of a spec that is to be
5283 while (*p && *p != ')')
5286 /* See if it's in the list. */
5287 for (len = p - name, sl = specs; sl; sl = sl->next)
5288 if (sl->name_len == len && !strncmp (sl->name, name, len))
5290 name = *(sl->ptr_spec);
5292 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5300 value = do_spec_1 (name, 0, NULL);
5305 /* Discard the closing paren. */
5312 error ("spec failure: unrecognized spec option %qc", c);
5318 /* Backslash: treat next character as ordinary. */
5323 /* Ordinary character: put it into the current argument. */
5324 obstack_1grow (&obstack, c);
5328 /* End of string. If we are processing a spec function, we need to
5329 end any pending argument. */
5330 if (processing_spec_function)
5336 /* Look up a spec function. */
5338 static const struct spec_function *
5339 lookup_spec_function (const char *name)
5341 const struct spec_function *sf;
5343 for (sf = static_spec_functions; sf->name != NULL; sf++)
5344 if (strcmp (sf->name, name) == 0)
5350 /* Evaluate a spec function. */
5353 eval_spec_function (const char *func, const char *args)
5355 const struct spec_function *sf;
5356 const char *funcval;
5358 /* Saved spec processing context. */
5359 VEC(const_char_p,heap) *save_argbuf;
5362 int save_delete_this_arg;
5363 int save_this_is_output_file;
5364 int save_this_is_library_file;
5365 int save_input_from_pipe;
5366 int save_this_is_linker_script;
5367 const char *save_suffix_subst;
5370 sf = lookup_spec_function (func);
5372 fatal_error ("unknown spec function %qs", func);
5374 /* Push the spec processing context. */
5375 save_argbuf = argbuf;
5377 save_arg_going = arg_going;
5378 save_delete_this_arg = delete_this_arg;
5379 save_this_is_output_file = this_is_output_file;
5380 save_this_is_library_file = this_is_library_file;
5381 save_this_is_linker_script = this_is_linker_script;
5382 save_input_from_pipe = input_from_pipe;
5383 save_suffix_subst = suffix_subst;
5385 /* Create a new spec processing context, and build the function
5389 if (do_spec_2 (args) < 0)
5390 fatal_error ("error in args to spec function %qs", func);
5392 /* argbuf_index is an index for the next argument to be inserted, and
5393 so contains the count of the args already inserted. */
5395 funcval = (*sf->func) (VEC_length (const_char_p, argbuf),
5396 VEC_address (const_char_p, argbuf));
5398 /* Pop the spec processing context. */
5399 VEC_free (const_char_p, heap, argbuf);
5400 argbuf = save_argbuf;
5402 arg_going = save_arg_going;
5403 delete_this_arg = save_delete_this_arg;
5404 this_is_output_file = save_this_is_output_file;
5405 this_is_library_file = save_this_is_library_file;
5406 this_is_linker_script = save_this_is_linker_script;
5407 input_from_pipe = save_input_from_pipe;
5408 suffix_subst = save_suffix_subst;
5413 /* Handle a spec function call of the form:
5417 ARGS is processed as a spec in a separate context and split into an
5418 argument vector in the normal fashion. The function returns a string
5419 containing a spec which we then process in the caller's context, or
5420 NULL if no processing is required. */
5423 handle_spec_function (const char *p)
5426 const char *endp, *funcval;
5429 processing_spec_function++;
5431 /* Get the function name. */
5432 for (endp = p; *endp != '\0'; endp++)
5434 if (*endp == '(') /* ) */
5436 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5437 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5438 fatal_error ("malformed spec function name");
5440 if (*endp != '(') /* ) */
5441 fatal_error ("no arguments for spec function");
5442 func = save_string (p, endp - p);
5445 /* Get the arguments. */
5446 for (count = 0; *endp != '\0'; endp++)
5455 else if (*endp == '(') /* ) */
5460 fatal_error ("malformed spec function arguments");
5461 args = save_string (p, endp - p);
5464 /* p now points to just past the end of the spec function expression. */
5466 funcval = eval_spec_function (func, args);
5467 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5473 processing_spec_function--;
5478 /* Inline subroutine of handle_braces. Returns true if the current
5479 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5481 input_suffix_matches (const char *atom, const char *end_atom)
5483 return (input_suffix
5484 && !strncmp (input_suffix, atom, end_atom - atom)
5485 && input_suffix[end_atom - atom] == '\0');
5488 /* Subroutine of handle_braces. Returns true if the current
5489 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5491 input_spec_matches (const char *atom, const char *end_atom)
5493 return (input_file_compiler
5494 && input_file_compiler->suffix
5495 && input_file_compiler->suffix[0] != '\0'
5496 && !strncmp (input_file_compiler->suffix + 1, atom,
5498 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5501 /* Subroutine of handle_braces. Returns true if a switch
5502 matching the atom bracketed by ATOM and END_ATOM appeared on the
5505 switch_matches (const char *atom, const char *end_atom, int starred)
5508 int len = end_atom - atom;
5509 int plen = starred ? len : -1;
5511 for (i = 0; i < n_switches; i++)
5512 if (!strncmp (switches[i].part1, atom, len)
5513 && (starred || switches[i].part1[len] == '\0')
5514 && check_live_switch (i, plen))
5517 /* Check if a switch with separated form matching the atom.
5518 We check -D and -U switches. */
5519 else if (switches[i].args != 0)
5521 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5522 && *switches[i].part1 == atom[0])
5524 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5525 && (starred || (switches[i].part1[1] == '\0'
5526 && switches[i].args[0][len - 1] == '\0'))
5527 && check_live_switch (i, (starred ? 1 : -1)))
5535 /* Inline subroutine of handle_braces. Mark all of the switches which
5536 match ATOM (extends to END_ATOM; STARRED indicates whether there
5537 was a star after the atom) for later processing. */
5539 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5542 int len = end_atom - atom;
5543 int plen = starred ? len : -1;
5545 for (i = 0; i < n_switches; i++)
5546 if (!strncmp (switches[i].part1, atom, len)
5547 && (starred || switches[i].part1[len] == '\0')
5548 && check_live_switch (i, plen))
5549 switches[i].ordering = 1;
5552 /* Inline subroutine of handle_braces. Process all the currently
5553 marked switches through give_switch, and clear the marks. */
5555 process_marked_switches (void)
5559 for (i = 0; i < n_switches; i++)
5560 if (switches[i].ordering == 1)
5562 switches[i].ordering = 0;
5567 /* Handle a %{ ... } construct. P points just inside the leading {.
5568 Returns a pointer one past the end of the brace block, or 0
5569 if we call do_spec_1 and that returns -1. */
5572 handle_braces (const char *p)
5574 const char *atom, *end_atom;
5575 const char *d_atom = NULL, *d_end_atom = NULL;
5576 const char *orig = p;
5584 bool a_must_be_last = false;
5585 bool ordered_set = false;
5586 bool disjunct_set = false;
5587 bool disj_matched = false;
5588 bool disj_starred = true;
5589 bool n_way_choice = false;
5590 bool n_way_matched = false;
5592 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5599 /* Scan one "atom" (S in the description above of %{}, possibly
5600 with '!', '.', '@', ',', or '*' modifiers). */
5602 a_is_suffix = false;
5603 a_is_starred = false;
5604 a_is_negated = false;
5605 a_is_spectype = false;
5609 p++, a_is_negated = true;
5613 p++, a_is_suffix = true;
5615 p++, a_is_spectype = true;
5618 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5619 || *p == ',' || *p == '.' || *p == '@')
5624 p++, a_is_starred = 1;
5630 /* Substitute the switch(es) indicated by the current atom. */
5632 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5633 || a_is_spectype || atom == end_atom)
5636 mark_matching_switches (atom, end_atom, a_is_starred);
5639 process_marked_switches ();
5643 /* Substitute some text if the current atom appears as a switch
5645 disjunct_set = true;
5649 if (atom == end_atom)
5651 if (!n_way_choice || disj_matched || *p == '|'
5652 || a_is_negated || a_is_suffix || a_is_spectype
5656 /* An empty term may appear as the last choice of an
5657 N-way choice set; it means "otherwise". */
5658 a_must_be_last = true;
5659 disj_matched = !n_way_matched;
5660 disj_starred = false;
5664 if ((a_is_suffix || a_is_spectype) && a_is_starred)
5668 disj_starred = false;
5670 /* Don't bother testing this atom if we already have a
5672 if (!disj_matched && !n_way_matched)
5675 a_matched = input_suffix_matches (atom, end_atom);
5676 else if (a_is_spectype)
5677 a_matched = input_spec_matches (atom, end_atom);
5679 a_matched = switch_matches (atom, end_atom, a_is_starred);
5681 if (a_matched != a_is_negated)
5683 disj_matched = true;
5685 d_end_atom = end_atom;
5692 /* Found the body, that is, the text to substitute if the
5693 current disjunction matches. */
5694 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5695 disj_matched && !n_way_matched);
5699 /* If we have an N-way choice, reset state for the next
5703 n_way_choice = true;
5704 n_way_matched |= disj_matched;
5705 disj_matched = false;
5706 disj_starred = true;
5707 d_atom = d_end_atom = NULL;
5716 while (*p++ != '}');
5721 fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5726 /* Subroutine of handle_braces. Scan and process a brace substitution body
5727 (X in the description of %{} syntax). P points one past the colon;
5728 ATOM and END_ATOM bracket the first atom which was found to be true
5729 (present) in the current disjunction; STARRED indicates whether all
5730 the atoms in the current disjunction were starred (for syntax validation);
5731 MATCHED indicates whether the disjunction matched or not, and therefore
5732 whether or not the body is to be processed through do_spec_1 or just
5733 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5737 process_brace_body (const char *p, const char *atom, const char *end_atom,
5738 int starred, int matched)
5740 const char *body, *end_body;
5741 unsigned int nesting_level;
5742 bool have_subst = false;
5744 /* Locate the closing } or ;, honoring nested braces.
5745 Trim trailing whitespace. */
5754 if (!--nesting_level)
5757 else if (*p == ';' && nesting_level == 1)
5759 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5761 else if (*p == '\0')
5767 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5770 if (have_subst && !starred)
5775 /* Copy the substitution body to permanent storage and execute it.
5776 If have_subst is false, this is a simple matter of running the
5777 body through do_spec_1... */
5778 char *string = save_string (body, end_body - body);
5781 if (do_spec_1 (string, 0, NULL) < 0)
5786 /* ... but if have_subst is true, we have to process the
5787 body once for each matching switch, with %* set to the
5788 variant part of the switch. */
5789 unsigned int hard_match_len = end_atom - atom;
5792 for (i = 0; i < n_switches; i++)
5793 if (!strncmp (switches[i].part1, atom, hard_match_len)
5794 && check_live_switch (i, hard_match_len))
5796 if (do_spec_1 (string, 0,
5797 &switches[i].part1[hard_match_len]) < 0)
5799 /* Pass any arguments this switch has. */
5801 suffix_subst = NULL;
5809 fatal_error ("braced spec body %qs is invalid", body);
5812 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5813 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5814 spec, or -1 if either exact match or %* is used.
5816 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5817 whose value does not begin with "no-" is obsoleted by the same value
5818 with the "no-", similarly for a switch with the "no-" prefix. */
5821 check_live_switch (int switchnum, int prefix_length)
5823 const char *name = switches[switchnum].part1;
5826 /* If we already processed this switch and determined if it was
5827 live or not, return our past determination. */
5828 if (switches[switchnum].live_cond != 0)
5829 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5830 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5831 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5834 /* In the common case of {<at-most-one-letter>*}, a negating
5835 switch would always match, so ignore that case. We will just
5836 send the conflicting switches to the compiler phase. */
5837 if (prefix_length >= 0 && prefix_length <= 1)
5840 /* Now search for duplicate in a manner that depends on the name. */
5844 for (i = switchnum + 1; i < n_switches; i++)
5845 if (switches[i].part1[0] == 'O')
5847 switches[switchnum].validated = 1;
5848 switches[switchnum].live_cond = SWITCH_FALSE;
5853 case 'W': case 'f': case 'm':
5854 if (! strncmp (name + 1, "no-", 3))
5856 /* We have Xno-YYY, search for XYYY. */
5857 for (i = switchnum + 1; i < n_switches; i++)
5858 if (switches[i].part1[0] == name[0]
5859 && ! strcmp (&switches[i].part1[1], &name[4]))
5861 switches[switchnum].validated = 1;
5862 switches[switchnum].live_cond = SWITCH_FALSE;
5868 /* We have XYYY, search for Xno-YYY. */
5869 for (i = switchnum + 1; i < n_switches; i++)
5870 if (switches[i].part1[0] == name[0]
5871 && switches[i].part1[1] == 'n'
5872 && switches[i].part1[2] == 'o'
5873 && switches[i].part1[3] == '-'
5874 && !strcmp (&switches[i].part1[4], &name[1]))
5876 switches[switchnum].validated = 1;
5877 switches[switchnum].live_cond = SWITCH_FALSE;
5884 /* Otherwise the switch is live. */
5885 switches[switchnum].live_cond |= SWITCH_LIVE;
5889 /* Pass a switch to the current accumulating command
5890 in the same form that we received it.
5891 SWITCHNUM identifies the switch; it is an index into
5892 the vector of switches gcc received, which is `switches'.
5893 This cannot fail since it never finishes a command line.
5895 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5898 give_switch (int switchnum, int omit_first_word)
5900 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
5903 if (!omit_first_word)
5905 do_spec_1 ("-", 0, NULL);
5906 do_spec_1 (switches[switchnum].part1, 1, NULL);
5909 if (switches[switchnum].args != 0)
5912 for (p = switches[switchnum].args; *p; p++)
5914 const char *arg = *p;
5916 do_spec_1 (" ", 0, NULL);
5919 unsigned length = strlen (arg);
5922 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5923 if (arg[length] == '.')
5925 (CONST_CAST(char *, arg))[length] = 0;
5929 do_spec_1 (arg, 1, NULL);
5931 (CONST_CAST(char *, arg))[length] = '.';
5932 do_spec_1 (suffix_subst, 1, NULL);
5935 do_spec_1 (arg, 1, NULL);
5939 do_spec_1 (" ", 0, NULL);
5940 switches[switchnum].validated = 1;
5943 /* Search for a file named NAME trying various prefixes including the
5944 user's -B prefix and some standard ones.
5945 Return the absolute file name found. If nothing is found, return NAME. */
5948 find_file (const char *name)
5950 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
5951 return newname ? newname : name;
5954 /* Determine whether a directory exists. If LINKER, return 0 for
5955 certain fixed names not needed by the linker. */
5958 is_directory (const char *path1, bool linker)
5965 /* Ensure the string ends with "/.". The resulting path will be a
5966 directory even if the given path is a symbolic link. */
5967 len1 = strlen (path1);
5968 path = (char *) alloca (3 + len1);
5969 memcpy (path, path1, len1);
5971 if (!IS_DIR_SEPARATOR (cp[-1]))
5972 *cp++ = DIR_SEPARATOR;
5976 /* Exclude directories that the linker is known to search. */
5978 && IS_DIR_SEPARATOR (path[0])
5980 && filename_ncmp (path + 1, "lib", 3) == 0)
5982 && filename_ncmp (path + 1, "usr", 3) == 0
5983 && IS_DIR_SEPARATOR (path[4])
5984 && filename_ncmp (path + 5, "lib", 3) == 0)))
5987 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5990 /* Set up the various global variables to indicate that we're processing
5991 the input file named FILENAME. */
5994 set_input (const char *filename)
5998 gcc_input_filename = filename;
5999 input_filename_length = strlen (gcc_input_filename);
6000 input_basename = lbasename (gcc_input_filename);
6002 /* Find a suffix starting with the last period,
6003 and set basename_length to exclude that suffix. */
6004 basename_length = strlen (input_basename);
6005 suffixed_basename_length = basename_length;
6006 p = input_basename + basename_length;
6007 while (p != input_basename && *p != '.')
6009 if (*p == '.' && p != input_basename)
6011 basename_length = p - input_basename;
6012 input_suffix = p + 1;
6017 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6018 we will need to do a stat on the gcc_input_filename. The
6019 INPUT_STAT_SET signals that the stat is needed. */
6023 /* On fatal signals, delete all the temporary files. */
6026 fatal_signal (int signum)
6028 signal (signum, SIG_DFL);
6029 delete_failure_queue ();
6030 delete_temp_files ();
6031 /* Get the same signal again, this time not handled,
6032 so its normal effect occurs. */
6033 kill (getpid (), signum);
6036 /* Compare the contents of the two files named CMPFILE[0] and
6037 CMPFILE[1]. Return zero if they're identical, nonzero
6041 compare_files (char *cmpfile[])
6044 FILE *temp[2] = { NULL, NULL };
6050 void *map[2] = { NULL, NULL };
6052 for (i = 0; i < 2; i++)
6056 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6058 error ("%s: could not determine length of compare-debug file %s",
6059 gcc_input_filename, cmpfile[i]);
6064 length[i] = st.st_size;
6067 if (!ret && length[0] != length[1])
6069 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6074 for (i = 0; i < 2; i++)
6076 int fd = open (cmpfile[i], O_RDONLY);
6079 error ("%s: could not open compare-debug file %s",
6080 gcc_input_filename, cmpfile[i]);
6085 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6088 if (map[i] == (void *) MAP_FAILED)
6097 if (memcmp (map[0], map[1], length[0]) != 0)
6099 error ("%s: -fcompare-debug failure", gcc_input_filename);
6104 for (i = 0; i < 2; i++)
6106 munmap ((caddr_t) map[i], length[i]);
6115 for (i = 0; i < 2; i++)
6117 temp[i] = fopen (cmpfile[i], "r");
6120 error ("%s: could not open compare-debug file %s",
6121 gcc_input_filename, cmpfile[i]);
6127 if (!ret && temp[0] && temp[1])
6131 c0 = fgetc (temp[0]);
6132 c1 = fgetc (temp[1]);
6136 error ("%s: -fcompare-debug failure",
6137 gcc_input_filename);
6146 for (i = 1; i >= 0; i--)
6155 extern int main (int, char **);
6158 main (int argc, char **argv)
6162 int linker_was_run = 0;
6163 int lang_n_infiles = 0;
6164 int num_linker_inputs = 0;
6165 char *explicit_link_files;
6167 char *lto_wrapper_file;
6169 struct user_specs *uptr;
6170 char **old_argv = argv;
6171 struct cl_decoded_option *decoded_options;
6172 unsigned int decoded_options_count;
6174 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6175 on ?: in file-scope variable initializations. */
6176 asm_debug = ASM_DEBUG_SPEC;
6178 p = argv[0] + strlen (argv[0]);
6179 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6183 xmalloc_set_program_name (progname);
6185 expandargv (&argc, &argv);
6187 /* Determine if any expansions were made. */
6188 if (argv != old_argv)
6189 at_file_supplied = true;
6191 /* Register the language-independent parameters. */
6192 global_init_params ();
6195 init_options_struct (&global_options, &global_options_set);
6197 decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6200 &decoded_options, &decoded_options_count);
6202 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6203 /* Perform host dependent initialization when needed. */
6204 GCC_DRIVER_HOST_INITIALIZATION;
6207 /* Unlock the stdio streams. */
6208 unlock_std_streams ();
6210 gcc_init_libintl ();
6212 diagnostic_initialize (global_dc, 0);
6213 if (atexit (delete_temp_files) != 0)
6214 fatal_error ("atexit failed");
6216 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6217 signal (SIGINT, fatal_signal);
6219 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6220 signal (SIGHUP, fatal_signal);
6222 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6223 signal (SIGTERM, fatal_signal);
6225 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6226 signal (SIGPIPE, fatal_signal);
6229 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6230 receive the signal. A different setting is inheritable */
6231 signal (SIGCHLD, SIG_DFL);
6234 /* Parsing and gimplification sometimes need quite large stack.
6235 Increase stack size limits if possible. */
6236 stack_limit_increase (64 * 1024 * 1024);
6238 /* Allocate the argument vector. */
6241 obstack_init (&obstack);
6243 /* Build multilib_select, et. al from the separate lines that make up each
6244 multilib selection. */
6246 const char *const *q = multilib_raw;
6249 obstack_init (&multilib_obstack);
6250 while ((p = *q++) != (char *) 0)
6251 obstack_grow (&multilib_obstack, p, strlen (p));
6253 obstack_1grow (&multilib_obstack, 0);
6254 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6256 q = multilib_matches_raw;
6257 while ((p = *q++) != (char *) 0)
6258 obstack_grow (&multilib_obstack, p, strlen (p));
6260 obstack_1grow (&multilib_obstack, 0);
6261 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6263 q = multilib_exclusions_raw;
6264 while ((p = *q++) != (char *) 0)
6265 obstack_grow (&multilib_obstack, p, strlen (p));
6267 obstack_1grow (&multilib_obstack, 0);
6268 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6271 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6274 obstack_1grow (&multilib_obstack, ' ');
6275 obstack_grow (&multilib_obstack,
6276 multilib_defaults_raw[i],
6277 strlen (multilib_defaults_raw[i]));
6281 obstack_1grow (&multilib_obstack, 0);
6282 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6285 #ifdef INIT_ENVIRONMENT
6286 /* Set up any other necessary machine specific environment variables. */
6287 xputenv (INIT_ENVIRONMENT);
6290 /* Make a table of what switches there are (switches, n_switches).
6291 Make a table of specified input files (infiles, n_infiles).
6292 Decode switches that are handled locally. */
6294 process_command (decoded_options_count, decoded_options);
6296 /* Initialize the vector of specs to just the default.
6297 This means one element containing 0s, as a terminator. */
6299 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6300 memcpy (compilers, default_compilers, sizeof default_compilers);
6301 n_compilers = n_default_compilers;
6303 /* Read specs from a file if there is one. */
6305 machine_suffix = concat (spec_machine, dir_separator_str,
6306 spec_version, dir_separator_str, NULL);
6307 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6309 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6310 /* Read the specs file unless it is a default one. */
6311 if (specs_file != 0 && strcmp (specs_file, "specs"))
6312 read_specs (specs_file, TRUE);
6316 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6317 for any override of as, ld and libraries. */
6318 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6319 + strlen (just_machine_suffix) + sizeof ("specs"));
6321 strcpy (specs_file, standard_exec_prefix);
6322 strcat (specs_file, just_machine_suffix);
6323 strcat (specs_file, "specs");
6324 if (access (specs_file, R_OK) == 0)
6325 read_specs (specs_file, TRUE);
6327 /* Process any configure-time defaults specified for the command line
6328 options, via OPTION_DEFAULT_SPECS. */
6329 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6330 do_option_spec (option_default_specs[i].name,
6331 option_default_specs[i].spec);
6333 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6334 of the command line. */
6336 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6337 do_self_spec (driver_self_specs[i]);
6339 /* If not cross-compiling, look for executables in the standard
6341 if (*cross_compile == '0')
6343 if (*md_exec_prefix)
6345 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6346 PREFIX_PRIORITY_LAST, 0, 0);
6350 /* Process sysroot_suffix_spec. */
6351 if (*sysroot_suffix_spec != 0
6352 && do_spec_2 (sysroot_suffix_spec) == 0)
6354 if (VEC_length (const_char_p, argbuf) > 1)
6355 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6356 else if (VEC_length (const_char_p, argbuf) == 1)
6357 target_sysroot_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6360 #ifdef HAVE_LD_SYSROOT
6361 /* Pass the --sysroot option to the linker, if it supports that. If
6362 there is a sysroot_suffix_spec, it has already been processed by
6363 this point, so target_system_root really is the system root we
6365 if (target_system_root)
6367 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6368 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6369 set_spec ("link", XOBFINISH (&obstack, const char *));
6373 /* Process sysroot_hdrs_suffix_spec. */
6374 if (*sysroot_hdrs_suffix_spec != 0
6375 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6377 if (VEC_length (const_char_p, argbuf) > 1)
6378 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6379 else if (VEC_length (const_char_p, argbuf) == 1)
6380 target_sysroot_hdrs_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6383 /* Look for startfiles in the standard places. */
6384 if (*startfile_prefix_spec != 0
6385 && do_spec_2 (startfile_prefix_spec) == 0
6386 && do_spec_1 (" ", 0, NULL) == 0)
6390 FOR_EACH_VEC_ELT (const_char_p, argbuf, ndx, arg)
6391 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6392 PREFIX_PRIORITY_LAST, 0, 1);
6394 /* We should eventually get rid of all these and stick to
6395 startfile_prefix_spec exclusively. */
6396 else if (*cross_compile == '0' || target_system_root)
6398 if (*md_startfile_prefix)
6399 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6400 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6402 if (*md_startfile_prefix_1)
6403 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6404 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6406 /* If standard_startfile_prefix is relative, base it on
6407 standard_exec_prefix. This lets us move the installed tree
6408 as a unit. If GCC_EXEC_PREFIX is defined, base
6409 standard_startfile_prefix on that as well.
6411 If the prefix is relative, only search it for native compilers;
6412 otherwise we will search a directory containing host libraries. */
6413 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6414 add_sysrooted_prefix (&startfile_prefixes,
6415 standard_startfile_prefix, "BINUTILS",
6416 PREFIX_PRIORITY_LAST, 0, 1);
6417 else if (*cross_compile == '0')
6419 add_prefix (&startfile_prefixes,
6420 concat (gcc_exec_prefix
6421 ? gcc_exec_prefix : standard_exec_prefix,
6423 standard_startfile_prefix, NULL),
6424 NULL, PREFIX_PRIORITY_LAST, 0, 1);
6427 /* Sysrooted prefixes are relocated because target_system_root is
6428 also relocated by gcc_exec_prefix. */
6429 if (*standard_startfile_prefix_1)
6430 add_sysrooted_prefix (&startfile_prefixes,
6431 standard_startfile_prefix_1, "BINUTILS",
6432 PREFIX_PRIORITY_LAST, 0, 1);
6433 if (*standard_startfile_prefix_2)
6434 add_sysrooted_prefix (&startfile_prefixes,
6435 standard_startfile_prefix_2, "BINUTILS",
6436 PREFIX_PRIORITY_LAST, 0, 1);
6439 /* Process any user specified specs in the order given on the command
6441 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6443 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6445 read_specs (filename ? filename : uptr->filename, FALSE);
6448 /* Process any user self specs. */
6450 struct spec_list *sl;
6451 for (sl = specs; sl; sl = sl->next)
6452 if (sl->name_len == sizeof "self_spec" - 1
6453 && !strcmp (sl->name, "self_spec"))
6454 do_self_spec (*sl->ptr_spec);
6459 enum save_temps save;
6461 if (!compare_debug_second)
6463 n_switches_debug_check[1] = n_switches;
6464 n_switches_alloc_debug_check[1] = n_switches_alloc;
6465 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6468 do_self_spec ("%:compare-debug-self-opt()");
6469 n_switches_debug_check[0] = n_switches;
6470 n_switches_alloc_debug_check[0] = n_switches_alloc;
6471 switches_debug_check[0] = switches;
6473 n_switches = n_switches_debug_check[1];
6474 n_switches_alloc = n_switches_alloc_debug_check[1];
6475 switches = switches_debug_check[1];
6478 /* Avoid crash when computing %j in this early. */
6479 save = save_temps_flag;
6480 save_temps_flag = SAVE_TEMPS_NONE;
6482 compare_debug = -compare_debug;
6483 do_self_spec ("%:compare-debug-self-opt()");
6485 save_temps_flag = save;
6487 if (!compare_debug_second)
6489 n_switches_debug_check[1] = n_switches;
6490 n_switches_alloc_debug_check[1] = n_switches_alloc;
6491 switches_debug_check[1] = switches;
6492 compare_debug = -compare_debug;
6493 n_switches = n_switches_debug_check[0];
6494 n_switches_alloc = n_switches_debug_check[0];
6495 switches = switches_debug_check[0];
6500 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6501 if (gcc_exec_prefix)
6502 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6503 spec_version, dir_separator_str, NULL);
6505 /* Now we have the specs.
6506 Set the `valid' bits for switches that match anything in any spec. */
6508 validate_all_switches ();
6510 /* Now that we have the switches and the specs, set
6511 the subdirectory based on the options. */
6512 set_multilib_dir ();
6514 /* Set up to remember the pathname of gcc and any options
6515 needed for collect. We use argv[0] instead of progname because
6516 we need the complete pathname. */
6517 obstack_init (&collect_obstack);
6518 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6519 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6520 xputenv (XOBFINISH (&collect_obstack, char *));
6522 /* Set up to remember the pathname of the lto wrapper. */
6525 lto_wrapper_file = NULL;
6527 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6529 if (lto_wrapper_file)
6531 lto_wrapper_file = convert_white_space (lto_wrapper_file);
6532 lto_wrapper_spec = lto_wrapper_file;
6533 obstack_init (&collect_obstack);
6534 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6535 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6536 obstack_grow (&collect_obstack, lto_wrapper_spec,
6537 strlen (lto_wrapper_spec) + 1);
6538 xputenv (XOBFINISH (&collect_obstack, char *));
6541 /* Warn about any switches that no pass was interested in. */
6543 for (i = 0; (int) i < n_switches; i++)
6544 if (! switches[i].validated)
6545 error ("unrecognized option %<-%s%>", switches[i].part1);
6547 /* Obey some of the options. */
6549 if (print_search_dirs)
6551 printf (_("install: %s\n"), STD_EXEC_PATH);
6552 printf (_("programs: %s\n"),
6553 build_search_list (&exec_prefixes, "", false, false));
6554 printf (_("libraries: %s\n"),
6555 build_search_list (&startfile_prefixes, "", false, true));
6559 if (print_file_name)
6561 printf ("%s\n", find_file (print_file_name));
6565 if (print_prog_name)
6567 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6568 printf ("%s\n", (newname ? newname : print_prog_name));
6572 if (print_multi_lib)
6574 print_multilib_info ();
6578 if (print_multi_directory)
6580 if (multilib_dir == NULL)
6583 printf ("%s\n", multilib_dir);
6587 if (print_multiarch)
6589 if (multiarch_dir == NULL)
6592 printf ("%s\n", multiarch_dir);
6598 if (target_system_root)
6600 if (target_sysroot_suffix)
6601 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6603 printf ("%s\n", target_system_root);
6608 if (print_multi_os_directory)
6610 if (multilib_os_dir == NULL)
6613 printf ("%s\n", multilib_os_dir);
6617 if (print_sysroot_headers_suffix)
6619 if (*sysroot_hdrs_suffix_spec)
6621 printf("%s\n", (target_sysroot_hdrs_suffix
6622 ? target_sysroot_hdrs_suffix
6627 /* The error status indicates that only one set of fixed
6628 headers should be built. */
6629 fatal_error ("not configured with sysroot headers suffix");
6632 if (print_help_list)
6638 printf (_("\nFor bug reporting instructions, please see:\n"));
6639 printf ("%s.\n", bug_report_url);
6644 /* We do not exit here. Instead we have created a fake input file
6645 called 'help-dummy' which needs to be compiled, and we pass this
6646 on the various sub-processes, along with the --help switch.
6647 Ensure their output appears after ours. */
6648 fputc ('\n', stdout);
6654 printf (_("%s %s%s\n"), progname, pkgversion_string,
6656 printf ("Copyright %s 2012 Free Software Foundation, Inc.\n",
6658 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6659 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6664 /* We do not exit here. We use the same mechanism of --help to print
6665 the version of the sub-processes. */
6666 fputc ('\n', stdout);
6675 fnotice (stderr, "Target: %s\n", spec_machine);
6676 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6678 #ifdef THREAD_MODEL_SPEC
6679 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6680 but there's no point in doing all this processing just to get
6681 thread_model back. */
6682 obstack_init (&obstack);
6683 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6684 obstack_1grow (&obstack, '\0');
6685 thrmod = XOBFINISH (&obstack, const char *);
6687 thrmod = thread_model;
6690 fnotice (stderr, "Thread model: %s\n", thrmod);
6692 /* compiler_version is truncated at the first space when initialized
6693 from version string, so truncate version_string at the first space
6694 before comparing. */
6695 for (n = 0; version_string[n]; n++)
6696 if (version_string[n] == ' ')
6699 if (! strncmp (version_string, compiler_version, n)
6700 && compiler_version[n] == 0)
6701 fnotice (stderr, "gcc version %s %s\n", version_string,
6704 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6705 version_string, pkgversion_string, compiler_version);
6711 if (n_infiles == added_libraries)
6712 fatal_error ("no input files");
6717 /* Make a place to record the compiler output file names
6718 that correspond to the input files. */
6721 i += lang_specific_extra_outfiles;
6722 outfiles = XCNEWVEC (const char *, i);
6724 /* Record which files were specified explicitly as link input. */
6726 explicit_link_files = XCNEWVEC (char, n_infiles);
6728 combine_inputs = have_o || flag_wpa;
6730 for (i = 0; (int) i < n_infiles; i++)
6732 const char *name = infiles[i].name;
6733 struct compiler *compiler = lookup_compiler (name,
6735 infiles[i].language);
6737 if (compiler && !(compiler->combinable))
6738 combine_inputs = false;
6740 if (lang_n_infiles > 0 && compiler != input_file_compiler
6741 && infiles[i].language && infiles[i].language[0] != '*')
6742 infiles[i].incompiler = compiler;
6746 input_file_compiler = compiler;
6747 infiles[i].incompiler = compiler;
6751 /* Since there is no compiler for this input file, assume it is a
6753 explicit_link_files[i] = 1;
6754 infiles[i].incompiler = NULL;
6756 infiles[i].compiled = false;
6757 infiles[i].preprocessed = false;
6760 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6761 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6763 for (i = 0; (int) i < n_infiles; i++)
6765 int this_file_error = 0;
6767 /* Tell do_spec what to substitute for %i. */
6769 input_file_number = i;
6770 set_input (infiles[i].name);
6772 if (infiles[i].compiled)
6775 /* Use the same thing in %o, unless cp->spec says otherwise. */
6777 outfiles[i] = gcc_input_filename;
6779 /* Figure out which compiler from the file's suffix. */
6782 = lookup_compiler (infiles[i].name, input_filename_length,
6783 infiles[i].language);
6785 if (input_file_compiler)
6787 /* Ok, we found an applicable compiler. Run its spec. */
6789 if (input_file_compiler->spec[0] == '#')
6791 error ("%s: %s compiler not installed on this system",
6792 gcc_input_filename, &input_file_compiler->spec[1]);
6793 this_file_error = 1;
6799 free (debug_check_temp_file[0]);
6800 debug_check_temp_file[0] = NULL;
6802 free (debug_check_temp_file[1]);
6803 debug_check_temp_file[1] = NULL;
6806 value = do_spec (input_file_compiler->spec);
6807 infiles[i].compiled = true;
6809 this_file_error = 1;
6810 else if (compare_debug && debug_check_temp_file[0])
6813 inform (0, "recompiling with -fcompare-debug");
6815 compare_debug = -compare_debug;
6816 n_switches = n_switches_debug_check[1];
6817 n_switches_alloc = n_switches_alloc_debug_check[1];
6818 switches = switches_debug_check[1];
6820 value = do_spec (input_file_compiler->spec);
6822 compare_debug = -compare_debug;
6823 n_switches = n_switches_debug_check[0];
6824 n_switches_alloc = n_switches_alloc_debug_check[0];
6825 switches = switches_debug_check[0];
6829 error ("during -fcompare-debug recompilation");
6830 this_file_error = 1;
6833 gcc_assert (debug_check_temp_file[1]
6834 && filename_cmp (debug_check_temp_file[0],
6835 debug_check_temp_file[1]));
6838 inform (0, "comparing final insns dumps");
6840 if (compare_files (debug_check_temp_file))
6841 this_file_error = 1;
6846 free (debug_check_temp_file[0]);
6847 debug_check_temp_file[0] = NULL;
6849 free (debug_check_temp_file[1]);
6850 debug_check_temp_file[1] = NULL;
6855 /* If this file's name does not contain a recognized suffix,
6856 record it as explicit linker input. */
6859 explicit_link_files[i] = 1;
6861 /* Clear the delete-on-failure queue, deleting the files in it
6862 if this compilation failed. */
6864 if (this_file_error)
6866 delete_failure_queue ();
6869 /* If this compilation succeeded, don't delete those files later. */
6870 clear_failure_queue ();
6873 /* Reset the input file name to the first compile/object file name, for use
6874 with %b in LINK_SPEC. We use the first input file that we can find
6875 a compiler to compile it instead of using infiles.language since for
6876 languages other than C we use aliases that we then lookup later. */
6881 for (i = 0; i < n_infiles ; i++)
6882 if (infiles[i].incompiler
6883 || (infiles[i].language && infiles[i].language[0] != '*'))
6885 set_input (infiles[i].name);
6892 /* Make sure INPUT_FILE_NUMBER points to first available open
6894 input_file_number = n_infiles;
6895 if (lang_specific_pre_link ())
6899 /* Determine if there are any linker input files. */
6900 num_linker_inputs = 0;
6901 for (i = 0; (int) i < n_infiles; i++)
6902 if (explicit_link_files[i] || outfiles[i] != NULL)
6903 num_linker_inputs++;
6905 /* Run ld to link all the compiler output files. */
6907 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
6909 int tmp = execution_count;
6913 #if HAVE_LTO_PLUGIN > 0
6914 #if HAVE_LTO_PLUGIN == 2
6915 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
6917 const char *fuse_linker_plugin = "fuse-linker-plugin";
6921 /* We'll use ld if we can't find collect2. */
6922 if (! strcmp (linker_name_spec, "collect2"))
6924 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
6926 linker_name_spec = "ld";
6929 #if HAVE_LTO_PLUGIN > 0
6930 #if HAVE_LTO_PLUGIN == 2
6931 if (!switch_matches (fno_use_linker_plugin,
6932 fno_use_linker_plugin
6933 + strlen (fno_use_linker_plugin), 0))
6935 if (switch_matches (fuse_linker_plugin,
6937 + strlen (fuse_linker_plugin), 0))
6940 char *temp_spec = find_a_file (&exec_prefixes,
6941 LTOPLUGINSONAME, R_OK,
6944 fatal_error ("-fuse-linker-plugin, but %s not found",
6946 linker_plugin_file_spec = convert_white_space (temp_spec);
6949 lto_gcc_spec = argv[0];
6952 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6954 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
6955 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
6957 if (print_subprocess_help == 1)
6959 printf (_("\nLinker options\n==============\n\n"));
6960 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6961 " to the linker.\n\n"));
6964 value = do_spec (link_command_spec);
6967 linker_was_run = (tmp != execution_count);
6970 /* If options said don't run linker,
6971 complain about input files to be given to the linker. */
6973 if (! linker_was_run && !seen_error ())
6974 for (i = 0; (int) i < n_infiles; i++)
6975 if (explicit_link_files[i]
6976 && !(infiles[i].language && infiles[i].language[0] == '*'))
6977 warning (0, "%s: linker input file unused because linking not done",
6980 /* Delete some or all of the temporary files we made. */
6983 delete_failure_queue ();
6984 delete_temp_files ();
6986 if (print_help_list)
6988 printf (("\nFor bug reporting instructions, please see:\n"));
6989 printf ("%s\n", bug_report_url);
6993 return (signal_count != 0 ? 2
6994 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
6998 /* Find the proper compilation spec for the file name NAME,
6999 whose length is LENGTH. LANGUAGE is the specified language,
7000 or 0 if this file is to be passed to the linker. */
7002 static struct compiler *
7003 lookup_compiler (const char *name, size_t length, const char *language)
7005 struct compiler *cp;
7007 /* If this was specified by the user to be a linker input, indicate that. */
7008 if (language != 0 && language[0] == '*')
7011 /* Otherwise, look for the language, if one is spec'd. */
7014 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7015 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7018 error ("language %s not recognized", language);
7022 /* Look for a suffix. */
7023 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7025 if (/* The suffix `-' matches only the file name `-'. */
7026 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7027 || (strlen (cp->suffix) < length
7028 /* See if the suffix matches the end of NAME. */
7029 && !strcmp (cp->suffix,
7030 name + length - strlen (cp->suffix))
7035 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7036 /* Look again, but case-insensitively this time. */
7038 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7040 if (/* The suffix `-' matches only the file name `-'. */
7041 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7042 || (strlen (cp->suffix) < length
7043 /* See if the suffix matches the end of NAME. */
7044 && ((!strcmp (cp->suffix,
7045 name + length - strlen (cp->suffix))
7046 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7047 && !strcasecmp (cp->suffix,
7048 name + length - strlen (cp->suffix)))
7054 if (cp >= compilers)
7056 if (cp->spec[0] != '@')
7057 /* A non-alias entry: return it. */
7060 /* An alias entry maps a suffix to a language.
7061 Search for the language; pass 0 for NAME and LENGTH
7062 to avoid infinite recursion if language not found. */
7063 return lookup_compiler (NULL, 0, cp->spec + 1);
7069 save_string (const char *s, int len)
7071 char *result = XNEWVEC (char, len + 1);
7073 memcpy (result, s, len);
7079 pfatal_with_name (const char *name)
7081 perror_with_name (name);
7082 delete_temp_files ();
7087 perror_with_name (const char *name)
7089 error ("%s: %m", name);
7093 validate_switches_from_spec (const char *spec)
7095 const char *p = spec;
7098 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7099 /* We have a switch spec. */
7100 p = validate_switches (p + 1);
7104 validate_all_switches (void)
7106 struct compiler *comp;
7107 struct spec_list *spec;
7109 for (comp = compilers; comp->spec; comp++)
7110 validate_switches_from_spec (comp->spec);
7112 /* Look through the linked list of specs read from the specs file. */
7113 for (spec = specs; spec; spec = spec->next)
7114 validate_switches_from_spec (*spec->ptr_spec);
7116 validate_switches_from_spec (link_command_spec);
7119 /* Look at the switch-name that comes after START
7120 and mark as valid all supplied switches that match it. */
7123 validate_switches (const char *start)
7125 const char *p = start;
7129 bool suffix = false;
7130 bool starred = false;
7132 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7141 if (*p == '.' || *p == ',')
7145 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7146 || *p == ',' || *p == '.' || *p == '@')
7151 starred = true, p++;
7157 /* Mark all matching switches as valid. */
7158 for (i = 0; i < n_switches; i++)
7159 if (!strncmp (switches[i].part1, atom, len)
7160 && (starred || switches[i].part1[len] == 0))
7161 switches[i].validated = 1;
7165 if (*p && (p[-1] == '|' || p[-1] == '&'))
7168 if (*p && p[-1] == ':')
7170 while (*p && *p != ';' && *p != '}')
7175 if (*p == '{' || *p == '<')
7176 p = validate_switches (p+1);
7177 else if (p[0] == 'W' && p[1] == '{')
7178 p = validate_switches (p+2);
7185 if (*p && p[-1] == ';')
7199 static struct mdswitchstr *mdswitches;
7200 static int n_mdswitches;
7202 /* Check whether a particular argument was used. The first time we
7203 canonicalize the switches to keep only the ones we care about. */
7206 used_arg (const char *p, int len)
7211 const char *replace;
7216 static struct mswitchstr *mswitches;
7217 static int n_mswitches;
7222 struct mswitchstr *matches;
7226 /* Break multilib_matches into the component strings of string
7227 and replacement string. */
7228 for (q = multilib_matches; *q != '\0'; q++)
7233 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7235 q = multilib_matches;
7244 fatal_error ("multilib spec %qs is invalid",
7249 matches[i].len = q - matches[i].str;
7251 matches[i].replace = ++q;
7252 while (*q != ';' && *q != '\0')
7255 goto invalid_matches;
7258 matches[i].rep_len = q - matches[i].replace;
7264 /* Now build a list of the replacement string for switches that we care
7265 about. Make sure we allocate at least one entry. This prevents
7266 xmalloc from calling fatal, and prevents us from re-executing this
7269 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7270 for (i = 0; i < n_switches; i++)
7271 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7273 int xlen = strlen (switches[i].part1);
7274 for (j = 0; j < cnt; j++)
7275 if (xlen == matches[j].len
7276 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7278 mswitches[n_mswitches].str = matches[j].replace;
7279 mswitches[n_mswitches].len = matches[j].rep_len;
7280 mswitches[n_mswitches].replace = (char *) 0;
7281 mswitches[n_mswitches].rep_len = 0;
7287 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7288 on the command line nor any options mutually incompatible with
7290 for (i = 0; i < n_mdswitches; i++)
7294 for (q = multilib_options; *q != '\0'; q++)
7300 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7301 || strchr (" /", q[mdswitches[i].len]) == NULL)
7303 while (*q != ' ' && *q != '/' && *q != '\0')
7310 if (*q != ' ' && *q != '\0')
7312 while (*r != ' ' && *r != '\0')
7315 while (*q != ' ' && *q != '/' && *q != '\0')
7318 if (used_arg (r, q - r))
7323 mswitches[n_mswitches].str = mdswitches[i].str;
7324 mswitches[n_mswitches].len = mdswitches[i].len;
7325 mswitches[n_mswitches].replace = (char *) 0;
7326 mswitches[n_mswitches].rep_len = 0;
7339 for (i = 0; i < n_mswitches; i++)
7340 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7347 default_arg (const char *p, int len)
7351 for (i = 0; i < n_mdswitches; i++)
7352 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7358 /* Work out the subdirectory to use based on the options. The format of
7359 multilib_select is a list of elements. Each element is a subdirectory
7360 name followed by a list of options followed by a semicolon. The format
7361 of multilib_exclusions is the same, but without the preceding
7362 directory. First gcc will check the exclusions, if none of the options
7363 beginning with an exclamation point are present, and all of the other
7364 options are present, then we will ignore this completely. Passing
7365 that, gcc will consider each multilib_select in turn using the same
7366 rules for matching the options. If a match is found, that subdirectory
7368 A subdirectory name is optionally followed by a colon and the corresponding
7372 set_multilib_dir (void)
7375 unsigned int this_path_len;
7376 const char *this_path, *this_arg;
7377 const char *start, *end;
7379 int ok, ndfltok, first;
7382 start = multilib_defaults;
7383 while (*start == ' ' || *start == '\t')
7385 while (*start != '\0')
7388 while (*start != ' ' && *start != '\t' && *start != '\0')
7390 while (*start == ' ' || *start == '\t')
7398 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7399 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7401 while (*start == ' ' || *start == '\t')
7407 for (end = start + 1;
7408 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7411 obstack_grow (&multilib_obstack, start, end - start);
7412 obstack_1grow (&multilib_obstack, 0);
7413 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7414 mdswitches[i++].len = end - start;
7421 p = multilib_exclusions;
7424 /* Ignore newlines. */
7431 /* Check the arguments. */
7438 fatal_error ("multilib exclusions %qs is invalid",
7439 multilib_exclusions);
7449 while (*p != ' ' && *p != ';')
7452 goto invalid_exclusions;
7456 if (*this_arg != '!')
7464 ok = used_arg (this_arg, p - this_arg);
7479 p = multilib_select;
7482 /* Ignore newlines. */
7489 /* Get the initial path. */
7496 fatal_error ("multilib select %qs is invalid",
7501 this_path_len = p - this_path;
7503 /* Check the arguments. */
7510 goto invalid_select;
7519 while (*p != ' ' && *p != ';')
7522 goto invalid_select;
7526 if (*this_arg != '!')
7534 /* If this is a default argument, we can just ignore it.
7535 This is true even if this_arg begins with '!'. Beginning
7536 with '!' does not mean that this argument is necessarily
7537 inappropriate for this library: it merely means that
7538 there is a more specific library which uses this
7539 argument. If this argument is a default, we need not
7540 consider that more specific library. */
7541 ok = used_arg (this_arg, p - this_arg);
7548 if (default_arg (this_arg, p - this_arg))
7557 if (this_path_len != 1
7558 || this_path[0] != '.')
7560 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7563 strncpy (new_multilib_dir, this_path, this_path_len);
7564 new_multilib_dir[this_path_len] = '\0';
7565 q = strchr (new_multilib_dir, ':');
7568 multilib_dir = new_multilib_dir;
7575 const char *q = this_path, *end = this_path + this_path_len;
7577 while (q < end && *q != ':')
7581 const char *q2 = q + 1, *ml_end = end;
7582 char *new_multilib_os_dir;
7584 while (q2 < end && *q2 != ':')
7588 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7589 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7590 new_multilib_os_dir[ml_end - q - 1] = '\0';
7591 multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7593 if (q2 < end && *q2 == ':')
7595 char *new_multiarch_dir = XNEWVEC (char, end - q2);
7596 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7597 new_multiarch_dir[end - q2 - 1] = '\0';
7598 multiarch_dir = new_multiarch_dir;
7607 if (multilib_dir == NULL && multilib_os_dir != NULL
7608 && strcmp (multilib_os_dir, ".") == 0)
7610 free (CONST_CAST (char *, multilib_os_dir));
7611 multilib_os_dir = NULL;
7613 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7614 multilib_os_dir = multilib_dir;
7617 /* Print out the multiple library subdirectory selection
7618 information. This prints out a series of lines. Each line looks
7619 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7620 required. Only the desired options are printed out, the negative
7621 matches. The options are print without a leading dash. There are
7622 no spaces to make it easy to use the information in the shell.
7623 Each subdirectory is printed only once. This assumes the ordering
7624 generated by the genmultilib script. Also, we leave out ones that match
7628 print_multilib_info (void)
7630 const char *p = multilib_select;
7631 const char *last_path = 0, *this_path;
7633 unsigned int last_path_len = 0;
7638 /* Ignore newlines. */
7645 /* Get the initial path. */
7652 fatal_error ("multilib select %qs is invalid", multilib_select);
7658 /* When --disable-multilib was used but target defines
7659 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7660 with .:: for multiarch configurations) are there just to find
7661 multilib_os_dir, so skip them from output. */
7662 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7665 /* Check for matches with the multilib_exclusions. We don't bother
7666 with the '!' in either list. If any of the exclusion rules match
7667 all of its options with the select rule, we skip it. */
7669 const char *e = multilib_exclusions;
7670 const char *this_arg;
7675 /* Ignore newlines. */
7682 /* Check the arguments. */
7691 fatal_error ("multilib exclusion %qs is invalid",
7692 multilib_exclusions);
7703 while (*e != ' ' && *e != ';')
7706 goto invalid_exclusion;
7714 int len = e - this_arg;
7717 goto invalid_select;
7721 while (*q != ' ' && *q != ';')
7724 goto invalid_select;
7728 if (! strncmp (arg, this_arg,
7729 (len < q - arg) ? q - arg : len)
7730 || default_arg (this_arg, e - this_arg))
7760 /* If this is a duplicate, skip it. */
7761 skip = (last_path != 0
7762 && (unsigned int) (p - this_path) == last_path_len
7763 && ! filename_ncmp (last_path, this_path, last_path_len));
7765 last_path = this_path;
7766 last_path_len = p - this_path;
7769 /* If this directory requires any default arguments, we can skip
7770 it. We will already have printed a directory identical to
7771 this one which does not require that default argument. */
7782 goto invalid_select;
7789 while (*q != ' ' && *q != ';')
7792 goto invalid_select;
7797 && default_arg (arg, q - arg))
7812 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7823 goto invalid_select;
7831 use_arg = *p != '!';
7836 while (*p != ' ' && *p != ';')
7839 goto invalid_select;
7851 /* If there are extra options, print them now. */
7852 if (multilib_extra && *multilib_extra)
7854 int print_at = TRUE;
7857 for (q = multilib_extra; *q != '\0'; q++)
7878 /* getenv built-in spec function.
7880 Returns the value of the environment variable given by its first
7881 argument, concatenated with the second argument. If the
7882 environment variable is not defined, a fatal error is issued. */
7885 getenv_spec_function (int argc, const char **argv)
7895 value = getenv (argv[0]);
7897 fatal_error ("environment variable %qs not defined", argv[0]);
7899 /* We have to escape every character of the environment variable so
7900 they are not interpreted as active spec characters. A
7901 particularly painful case is when we are reading a variable
7902 holding a windows path complete with \ separators. */
7903 len = strlen (value) * 2 + strlen (argv[1]) + 1;
7904 result = XNEWVAR (char, len);
7905 for (ptr = result; *value; ptr += 2)
7911 strcpy (ptr, argv[1]);
7916 /* if-exists built-in spec function.
7918 Checks to see if the file specified by the absolute pathname in
7919 ARGS exists. Returns that pathname if found.
7921 The usual use for this function is to check for a library file
7922 (whose name has been expanded with %s). */
7925 if_exists_spec_function (int argc, const char **argv)
7927 /* Must have only one argument. */
7928 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7934 /* if-exists-else built-in spec function.
7936 This is like if-exists, but takes an additional argument which
7937 is returned if the first argument does not exist. */
7940 if_exists_else_spec_function (int argc, const char **argv)
7942 /* Must have exactly two arguments. */
7946 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7952 /* replace-outfile built-in spec function.
7954 This looks for the first argument in the outfiles array's name and
7955 replaces it with the second argument. */
7958 replace_outfile_spec_function (int argc, const char **argv)
7961 /* Must have exactly two arguments. */
7965 for (i = 0; i < n_infiles; i++)
7967 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
7968 outfiles[i] = xstrdup (argv[1]);
7973 /* remove-outfile built-in spec function.
7975 * This looks for the first argument in the outfiles array's name and
7979 remove_outfile_spec_function (int argc, const char **argv)
7982 /* Must have exactly one argument. */
7986 for (i = 0; i < n_infiles; i++)
7988 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
7994 /* Given two version numbers, compares the two numbers.
7995 A version number must match the regular expression
7996 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7999 compare_version_strings (const char *v1, const char *v2)
8004 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8005 REG_EXTENDED | REG_NOSUB) != 0)
8007 rresult = regexec (&r, v1, 0, NULL, 0);
8008 if (rresult == REG_NOMATCH)
8009 fatal_error ("invalid version number %qs", v1);
8010 else if (rresult != 0)
8012 rresult = regexec (&r, v2, 0, NULL, 0);
8013 if (rresult == REG_NOMATCH)
8014 fatal_error ("invalid version number %qs", v2);
8015 else if (rresult != 0)
8018 return strverscmp (v1, v2);
8022 /* version_compare built-in spec function.
8024 This takes an argument of the following form:
8026 <comparison-op> <arg1> [<arg2>] <switch> <result>
8028 and produces "result" if the comparison evaluates to true,
8029 and nothing if it doesn't.
8031 The supported <comparison-op> values are:
8033 >= true if switch is a later (or same) version than arg1
8035 < true if switch is an earlier version than arg1
8037 >< true if switch is arg1 or later, and earlier than arg2
8038 <> true if switch is earlier than arg1 or is arg2 or later
8040 If the switch is not present, the condition is false unless
8041 the first character of the <comparison-op> is '!'.
8044 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8045 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8048 version_compare_spec_function (int argc, const char **argv)
8052 const char *switch_value = NULL;
8057 fatal_error ("too few arguments to %%:version-compare");
8058 if (argv[0][0] == '\0')
8060 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8062 if (argc != nargs + 3)
8063 fatal_error ("too many arguments to %%:version-compare");
8065 switch_len = strlen (argv[nargs + 1]);
8066 for (i = 0; i < n_switches; i++)
8067 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8068 && check_live_switch (i, switch_len))
8069 switch_value = switches[i].part1 + switch_len;
8071 if (switch_value == NULL)
8075 comp1 = compare_version_strings (switch_value, argv[1]);
8077 comp2 = compare_version_strings (switch_value, argv[2]);
8079 comp2 = -1; /* This value unused. */
8082 switch (argv[0][0] << 8 | argv[0][1])
8084 case '>' << 8 | '=':
8085 result = comp1 >= 0;
8087 case '!' << 8 | '<':
8088 result = comp1 >= 0 || switch_value == NULL;
8093 case '!' << 8 | '>':
8094 result = comp1 < 0 || switch_value == NULL;
8096 case '>' << 8 | '<':
8097 result = comp1 >= 0 && comp2 < 0;
8099 case '<' << 8 | '>':
8100 result = comp1 < 0 || comp2 >= 0;
8104 fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8109 return argv[nargs + 2];
8112 /* %:include builtin spec function. This differs from %include in that it
8113 can be nested inside a spec, and thus be conditionalized. It takes
8114 one argument, the filename, and looks for it in the startfile path.
8115 The result is always NULL, i.e. an empty expansion. */
8118 include_spec_function (int argc, const char **argv)
8125 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8126 read_specs (file ? file : argv[0], FALSE);
8131 /* %:find-file spec function. This function replaces its argument by
8132 the file found thru find_file, that is the -print-file-name gcc
8135 find_file_spec_function (int argc, const char **argv)
8142 file = find_file (argv[0]);
8147 /* %:find-plugindir spec function. This function replaces its argument
8148 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
8149 is the -print-file-name gcc program option. */
8151 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8158 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8163 /* %:print-asm-header spec function. Print a banner to say that the
8164 following output is from the assembler. */
8167 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8168 const char **argv ATTRIBUTE_UNUSED)
8170 printf (_("Assembler options\n=================\n\n"));
8171 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8176 /* Get a random number for -frandom-seed */
8178 static unsigned HOST_WIDE_INT
8179 get_random_number (void)
8181 unsigned HOST_WIDE_INT ret = 0;
8184 fd = open ("/dev/urandom", O_RDONLY);
8187 read (fd, &ret, sizeof (HOST_WIDE_INT));
8193 /* Get some more or less random data. */
8194 #ifdef HAVE_GETTIMEOFDAY
8198 gettimeofday (&tv, NULL);
8199 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8203 time_t now = time (NULL);
8205 if (now != (time_t)-1)
8206 ret = (unsigned) now;
8210 return ret ^ getpid();
8213 /* %:compare-debug-dump-opt spec function. Save the last argument,
8214 expected to be the last -fdump-final-insns option, or generate a
8218 compare_debug_dump_opt_spec_function (int arg,
8219 const char **argv ATTRIBUTE_UNUSED)
8224 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8227 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8229 do_spec_2 ("%{fdump-final-insns=*:%*}");
8230 do_spec_1 (" ", 0, NULL);
8232 if (VEC_length (const_char_p, argbuf) > 0
8233 && strcmp (argv[VEC_length (const_char_p, argbuf) - 1], "."))
8238 name = xstrdup (argv[VEC_length (const_char_p, argbuf) - 1]);
8243 const char *ext = NULL;
8245 if (VEC_length (const_char_p, argbuf) > 0)
8247 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8250 else if (!compare_debug)
8253 do_spec_2 ("%g.gkd");
8255 do_spec_1 (" ", 0, NULL);
8257 gcc_assert (VEC_length (const_char_p, argbuf) > 0);
8259 name = concat (VEC_last (const_char_p, argbuf), ext, NULL);
8261 ret = concat ("-fdump-final-insns=", name, NULL);
8264 which = compare_debug < 0;
8265 debug_check_temp_file[which] = name;
8269 unsigned HOST_WIDE_INT value = get_random_number ();
8271 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8275 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8284 static const char *debug_auxbase_opt;
8286 /* %:compare-debug-self-opt spec function. Expands to the options
8287 that are to be passed in the second compilation of
8291 compare_debug_self_opt_spec_function (int arg,
8292 const char **argv ATTRIBUTE_UNUSED)
8295 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8297 if (compare_debug >= 0)
8300 do_spec_2 ("%{c|S:%{o*:%*}}");
8301 do_spec_1 (" ", 0, NULL);
8303 if (VEC_length (const_char_p, argbuf) > 0)
8304 debug_auxbase_opt = concat ("-auxbase-strip ",
8305 VEC_last (const_char_p, argbuf),
8308 debug_auxbase_opt = NULL;
8311 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8312 %<fdump-final-insns=* -w -S -o %j \
8313 %{!fcompare-debug-second:-fcompare-debug-second} \
8314 ", compare_debug_opt, NULL);
8317 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8318 options that are to be passed in the second compilation of
8319 compare-debug. It expects, as an argument, the basename of the
8320 current input file name, with the .gk suffix appended to it. */
8323 compare_debug_auxbase_opt_spec_function (int arg,
8330 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8333 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8335 if (compare_debug >= 0)
8338 len = strlen (argv[0]);
8339 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8340 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8341 "does not end in .gk");
8343 if (debug_auxbase_opt)
8344 return debug_auxbase_opt;
8346 #define OPT "-auxbase "
8349 name = (char*) xmalloc (sizeof (OPT) + len);
8350 memcpy (name, OPT, sizeof (OPT) - 1);
8351 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8352 name[sizeof (OPT) - 1 + len] = '\0';
8359 /* %:pass-through-libs spec function. Finds all -l options and input
8360 file names in the lib spec passed to it, and makes a list of them
8361 prepended with the plugin option to cause them to be passed through
8362 to the final link after all the new object files have been added. */
8365 pass_through_libs_spec_func (int argc, const char **argv)
8367 char *prepended = xstrdup (" ");
8369 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8370 we know that there will never be more than a handful of strings to
8371 concat, and it's only once per run, so it's not worth optimising. */
8372 for (n = 0; n < argc; n++)
8374 char *old = prepended;
8375 /* Anything that isn't an option is a full path to an output
8376 file; pass it through if it ends in '.a'. Among options,
8378 if (argv[n][0] == '-' && argv[n][1] == 'l')
8380 const char *lopt = argv[n] + 2;
8381 /* Handle both joined and non-joined -l options. If for any
8382 reason there's a trailing -l with no joined or following
8383 arg just discard it. */
8384 if (!*lopt && ++n >= argc)
8388 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8391 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8393 prepended = concat (prepended, "-plugin-opt=-pass-through=",
8394 argv[n], " ", NULL);
8396 if (prepended != old)
8402 /* Insert backslash before spaces in ORIG (usually a file path), to
8403 avoid being broken by spec parser.
8405 This function is needed as do_spec_1 treats white space (' ' and '\t')
8406 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8407 the file name should be treated as a single argument rather than being
8408 broken into multiple. Solution is to insert '\\' before the space in a
8411 This function converts and only converts all occurrence of ' '
8412 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
8416 "a\\ b" -> "a\\\\ b"
8418 orig: input null-terminating string that was allocated by xalloc. The
8419 memory it points to might be freed in this function. Behavior undefined
8420 if ORIG wasn't xalloced or was freed already at entry.
8422 Return: ORIG if no conversion needed. Otherwise a newly allocated string
8423 that was converted from ORIG. */
8426 convert_white_space (char *orig)
8428 int len, number_of_space = 0;
8430 for (len = 0; orig[len]; len++)
8431 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
8433 if (number_of_space)
8435 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
8437 for (j = 0, k = 0; j <= len; j++, k++)
8439 if (orig[j] == ' ' || orig[j] == '\t')
8440 new_spec[k++] = '\\';
8441 new_spec[k] = orig[j];