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". */
33 /* A Short Introduction to Adding a Command-Line Option.
35 Before adding a command-line option, consider if it is really
36 necessary. Each additional command-line option adds complexity and
37 is difficult to remove in subsequent versions.
39 In the following, consider adding the command-line argument
42 1. Each command-line option is specified in the specs file. The
43 notation is described below in the comment entitled "The Specs
46 2. In this file, add an entry to "option_map" equating the long
47 `--' argument version and any shorter, single letter version. Read
48 the comments in the declaration of "struct option_map" for an
49 explanation. Do not omit the first `-'.
51 3. Look in the "specs" file to determine which program or option
52 list should be given the argument, e.g., "cc1_options". Add the
53 appropriate syntax for the shorter option version to the
54 corresponding "const char *" entry in this file. Omit the first
55 `-' from the option. For example, use `-bar', rather than `--bar'.
57 4. If the argument takes an argument, e.g., `--baz argument1',
58 modify either DEFAULT_SWITCH_TAKES_ARG or
59 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
62 5. Document the option in this file's display_help(). If the
63 option is passed to a subprogram, modify its corresponding
64 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
67 6. Compile and test. Make sure that your new specs file is being
68 read. For example, use a debugger to investigate the value of
69 "specs_file" in main(). */
73 #include "coretypes.h"
74 #include "multilib.h" /* before tm.h */
77 #if ! defined( SIGCHLD ) && defined( SIGCLD )
78 # define SIGCHLD SIGCLD
85 #include "diagnostic.h"
90 # include <sys/mman.h>
92 /* This is on Solaris. */
93 # include <sys/types.h>
98 # define MAP_FAILED ((void *)-1)
101 /* By default there is no special suffix for target executables. */
102 /* FIXME: when autoconf is fixed, remove the host check - dj */
103 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
104 #define HAVE_TARGET_EXECUTABLE_SUFFIX
107 /* By default there is no special suffix for host executables. */
108 #ifdef HOST_EXECUTABLE_SUFFIX
109 #define HAVE_HOST_EXECUTABLE_SUFFIX
111 #define HOST_EXECUTABLE_SUFFIX ""
114 /* By default, the suffix for target object files is ".o". */
115 #ifdef TARGET_OBJECT_SUFFIX
116 #define HAVE_TARGET_OBJECT_SUFFIX
118 #define TARGET_OBJECT_SUFFIX ".o"
121 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
123 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
124 #ifndef LIBRARY_PATH_ENV
125 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
129 #define kill(p,s) raise(s)
132 /* If a stage of compilation returns an exit status >= 1,
133 compilation of that file ceases. */
135 #define MIN_FATAL_STATUS 1
137 /* Flag set by cppspec.c to 1. */
140 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
141 static bool at_file_supplied;
143 /* Flag saying to pass the greatest exit code returned by a sub-process
144 to the calling program. */
145 static int pass_exit_codes;
147 /* Definition of string containing the arguments given to configure. */
148 #include "configargs.h"
150 /* Flag saying to print the directories gcc will search through looking for
151 programs, libraries, etc. */
153 static int print_search_dirs;
155 /* Flag saying to print the full filename of this file
156 as found through our usual search mechanism. */
158 static const char *print_file_name = NULL;
160 /* As print_file_name, but search for executable file. */
162 static const char *print_prog_name = NULL;
164 /* Flag saying to print the relative path we'd use to
165 find libgcc.a given the current compiler flags. */
167 static int print_multi_directory;
169 static int print_sysroot;
171 /* Flag saying to print the relative path we'd use to
172 find OS libraries given the current compiler flags. */
174 static int print_multi_os_directory;
176 /* Flag saying to print the list of subdirectories and
177 compiler flags used to select them in a standard form. */
179 static int print_multi_lib;
181 /* Flag saying to print the command line options understood by gcc and its
184 static int print_help_list;
186 /* Flag saying to print the version of gcc and its sub-processes. */
188 static int print_version;
190 /* Flag saying to print the sysroot suffix used for searching for
193 static int print_sysroot_headers_suffix;
195 /* Flag indicating whether we should print the command and arguments */
197 static int verbose_flag;
199 /* Flag indicating whether we should ONLY print the command and
200 arguments (like verbose_flag) without executing the command.
201 Displayed arguments are quoted so that the generated command
202 line is suitable for execution. This is intended for use in
203 shell scripts to capture the driver-generated command line. */
204 static int verbose_only_flag;
206 /* Flag indicating how to print command line options of sub-processes. */
208 static int print_subprocess_help;
210 /* Flag indicating whether we should report subprocess execution times
211 (if this is supported by the system - see pexecute.c). */
213 static int report_times;
215 /* Whether we should report subprocess execution times to a file. */
217 FILE *report_times_to_file = NULL;
219 /* Nonzero means place this string before uses of /, so that include
220 and library files can be found in an alternate location. */
222 #ifdef TARGET_SYSTEM_ROOT
223 static const char *target_system_root = TARGET_SYSTEM_ROOT;
225 static const char *target_system_root = 0;
228 /* Nonzero means pass the updated target_system_root to the compiler. */
230 static int target_system_root_changed;
232 /* Nonzero means append this string to target_system_root. */
234 static const char *target_sysroot_suffix = 0;
236 /* Nonzero means append this string to target_system_root for headers. */
238 static const char *target_sysroot_hdrs_suffix = 0;
240 /* Nonzero means write "temp" files in source directory
241 and use the source file's name in them, and don't delete them. */
243 static enum save_temps {
244 SAVE_TEMPS_NONE, /* no -save-temps */
245 SAVE_TEMPS_CWD, /* -save-temps in current directory */
246 SAVE_TEMPS_OBJ /* -save-temps in object directory */
249 /* Output file to use to get the object directory for -save-temps=obj */
250 static char *save_temps_prefix = 0;
251 static size_t save_temps_length = 0;
253 /* Nonzero means pass multiple source files to the compiler at one time. */
255 static int combine_flag = 0;
257 /* Nonzero means use pipes to communicate between subprocesses.
258 Overridden by either of the above two flags. */
260 static int use_pipes;
262 /* The compiler version. */
264 static const char *compiler_version;
266 /* The target version. */
268 static const char *const spec_version = DEFAULT_TARGET_VERSION;
270 /* The target machine. */
272 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
274 /* Nonzero if cross-compiling.
275 When -b is used, the value comes from the `specs' file. */
277 #ifdef CROSS_DIRECTORY_STRUCTURE
278 static const char *cross_compile = "1";
280 static const char *cross_compile = "0";
283 /* Greatest exit code of sub-processes that has been encountered up to
285 static int greatest_status = 1;
287 /* This is the obstack which we use to allocate many strings. */
289 static struct obstack obstack;
291 /* This is the obstack to build an environment variable to pass to
292 collect2 that describes all of the relevant switches of what to
293 pass the compiler in building the list of pointers to constructors
296 static struct obstack collect_obstack;
298 /* This is a list of a wrapper program and its arguments.
299 e.g. wrapper_string of "strace,-c"
300 will cause all programs to run as
301 strace -c program arguments
304 static const char *wrapper_string;
306 /* Forward declaration for prototypes. */
310 static void init_spec (void);
311 static void store_arg (const char *, int, int);
312 static void insert_wrapper (const char *);
313 static char *load_specs (const char *);
314 static void read_specs (const char *, int);
315 static void set_spec (const char *, const char *);
316 static struct compiler *lookup_compiler (const char *, size_t, const char *);
317 static char *build_search_list (const struct path_prefix *, const char *,
319 static void xputenv (const char *);
320 static void putenv_from_prefixes (const struct path_prefix *, const char *,
322 static int access_check (const char *, int);
323 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
324 static void add_prefix (struct path_prefix *, const char *, const char *,
326 static void add_sysrooted_prefix (struct path_prefix *, const char *,
327 const char *, int, int, int);
328 static void translate_options (int *, const char *const **);
329 static char *skip_whitespace (char *);
330 static void delete_if_ordinary (const char *);
331 static void delete_temp_files (void);
332 static void delete_failure_queue (void);
333 static void clear_failure_queue (void);
334 static int check_live_switch (int, int);
335 static const char *handle_braces (const char *);
336 static inline bool input_suffix_matches (const char *, const char *);
337 static inline bool switch_matches (const char *, const char *, int);
338 static inline void mark_matching_switches (const char *, const char *, int);
339 static inline void process_marked_switches (void);
340 static const char *process_brace_body (const char *, const char *, const char *, int, int);
341 static const struct spec_function *lookup_spec_function (const char *);
342 static const char *eval_spec_function (const char *, const char *);
343 static const char *handle_spec_function (const char *);
344 static char *save_string (const char *, int);
345 static void set_collect_gcc_options (void);
346 static int do_spec_1 (const char *, int, const char *);
347 static int do_spec_2 (const char *);
348 static void do_option_spec (const char *, const char *);
349 static void do_self_spec (const char *);
350 static const char *find_file (const char *);
351 static int is_directory (const char *, bool);
352 static const char *validate_switches (const char *);
353 static void validate_all_switches (void);
354 static inline void validate_switches_from_spec (const char *);
355 static void give_switch (int, int);
356 static int used_arg (const char *, int);
357 static int default_arg (const char *, int);
358 static void set_multilib_dir (void);
359 static void print_multilib_info (void);
360 static void perror_with_name (const char *);
361 static void display_help (void);
362 static void add_preprocessor_option (const char *, int);
363 static void add_assembler_option (const char *, int);
364 static void add_linker_option (const char *, int);
365 static void process_command (int, const char **);
366 static int execute (void);
367 static void alloc_args (void);
368 static void clear_args (void);
369 static void fatal_signal (int);
370 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
371 static void init_gcc_specs (struct obstack *, const char *, const char *,
374 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
375 static const char *convert_filename (const char *, int, int);
378 static const char *getenv_spec_function (int, const char **);
379 static const char *if_exists_spec_function (int, const char **);
380 static const char *if_exists_else_spec_function (int, const char **);
381 static const char *replace_outfile_spec_function (int, const char **);
382 static const char *version_compare_spec_function (int, const char **);
383 static const char *include_spec_function (int, const char **);
384 static const char *find_file_spec_function (int, const char **);
385 static const char *find_plugindir_spec_function (int, const char **);
386 static const char *print_asm_header_spec_function (int, const char **);
387 static const char *compare_debug_dump_opt_spec_function (int, const char **);
388 static const char *compare_debug_self_opt_spec_function (int, const char **);
389 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
391 /* The Specs Language
393 Specs are strings containing lines, each of which (if not blank)
394 is made up of a program name, and arguments separated by spaces.
395 The program name must be exact and start from root, since no path
396 is searched and it is unreliable to depend on the current working directory.
397 Redirection of input or output is not supported; the subprograms must
398 accept filenames saying what files to read and write.
400 In addition, the specs can contain %-sequences to substitute variable text
401 or for conditional text. Here is a table of all defined %-sequences.
402 Note that spaces are not generated automatically around the results of
403 expanding these sequences; therefore, you can concatenate them together
404 or with constant text in a single argument.
406 %% substitute one % into the program name or argument.
407 %i substitute the name of the input file being processed.
408 %b substitute the basename of the input file being processed.
409 This is the substring up to (and not including) the last period
410 and not including the directory unless -save-temps was specified
411 to put temporaries in a different location.
412 %B same as %b, but include the file suffix (text after the last period).
414 substitute a file name that has suffix SUFFIX and is chosen
415 once per compilation, and mark the argument a la %d. To reduce
416 exposure to denial-of-service attacks, the file name is now
417 chosen in a way that is hard to predict even when previously
418 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
419 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
420 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
421 had been pre-processed. Previously, %g was simply substituted
422 with a file name chosen once per compilation, without regard
423 to any appended suffix (which was therefore treated just like
424 ordinary text), making such attacks more likely to succeed.
426 like %g, but if -pipe is in effect, expands simply to "-".
428 like %g, but if -pipe is in effect, expands to nothing. (We have both
429 %| and %m to accommodate differences between system assemblers; see
430 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
432 like %g, but generates a new temporary file name even if %uSUFFIX
435 substitutes the last file name generated with %uSUFFIX, generating a
436 new one if there is no such last file name. In the absence of any
437 %uSUFFIX, this is just like %gSUFFIX, except they don't share
438 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
439 would involve the generation of two distinct file names, one
440 for each `%g.s' and another for each `%U.s'. Previously, %U was
441 simply substituted with a file name chosen for the previous %u,
442 without regard to any appended suffix.
444 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
445 writable, and if save-temps is off; otherwise, substitute the name
446 of a temporary file, just like %u. This temporary file is not
447 meant for communication between processes, but rather as a junk
450 substitutes .SUFFIX for the suffixes of a matched switch's args when
451 it is subsequently output with %*. SUFFIX is terminated by the next
453 %d marks the argument containing or following the %d as a
454 temporary file name, so that that file will be deleted if GCC exits
455 successfully. Unlike %g, this contributes no text to the argument.
456 %w marks the argument containing or following the %w as the
457 "output file" of this compilation. This puts the argument
458 into the sequence of arguments that %o will substitute later.
459 %V indicates that this compilation produces no "output file".
461 like %{...} but mark last argument supplied within
462 as a file to be deleted on failure.
463 %o substitutes the names of all the output files, with spaces
464 automatically placed around them. You should write spaces
465 around the %o as well or the results are undefined.
466 %o is for use in the specs for running the linker.
467 Input files whose names have no recognized suffix are not compiled
468 at all, but they are included among the output files, so they will
470 %O substitutes the suffix for object files. Note that this is
471 handled specially when it immediately follows %g, %u, or %U
472 (with or without a suffix argument) because of the need for
473 those to form complete file names. The handling is such that
474 %O is treated exactly as if it had already been substituted,
475 except that %g, %u, and %U do not currently support additional
476 SUFFIX characters following %O as they would following, for
478 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
479 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
480 and -B options) and -imultilib as necessary.
481 %s current argument is the name of a library or startup file of some sort.
482 Search for that file in a standard list of directories
483 and substitute the full name found.
484 %eSTR Print STR as an error message. STR is terminated by a newline.
485 Use this when inconsistent options are detected.
486 %nSTR Print STR as a notice. STR is terminated by a newline.
487 %x{OPTION} Accumulate an option for %X.
488 %X Output the accumulated linker options specified by compilations.
489 %Y Output the accumulated assembler options specified by compilations.
490 %Z Output the accumulated preprocessor options specified by compilations.
491 %a process ASM_SPEC as a spec.
492 This allows config.h to specify part of the spec for running as.
493 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
494 used here. This can be used to run a post-processor after the
495 assembler has done its job.
496 %D Dump out a -L option for each directory in startfile_prefixes.
497 If multilib_dir is set, extra entries are generated with it affixed.
498 %l process LINK_SPEC as a spec.
499 %L process LIB_SPEC as a spec.
500 %G process LIBGCC_SPEC as a spec.
501 %R Output the concatenation of target_system_root and
502 target_sysroot_suffix.
503 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
504 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
505 %C process CPP_SPEC as a spec.
506 %1 process CC1_SPEC as a spec.
507 %2 process CC1PLUS_SPEC as a spec.
508 %* substitute the variable part of a matched option. (See below.)
509 Note that each comma in the substituted string is replaced by
511 %<S remove all occurrences of -S from the command line.
512 Note - this command is position dependent. % commands in the
513 spec string before this one will see -S, % commands in the
514 spec string after this one will not.
515 %<S* remove all occurrences of all switches beginning with -S from the
518 Call the named function FUNCTION, passing it ARGS. ARGS is
519 first processed as a nested spec string, then split into an
520 argument vector in the usual fashion. The function returns
521 a string which is processed as if it had appeared literally
522 as part of the current spec.
523 %{S} substitutes the -S switch, if that switch was given to GCC.
524 If that switch was not specified, this substitutes nothing.
525 Here S is a metasyntactic variable.
526 %{S*} substitutes all the switches specified to GCC whose names start
527 with -S. This is used for -o, -I, etc; switches that take
528 arguments. GCC considers `-o foo' as being one switch whose
529 name starts with `o'. %{o*} would substitute this text,
530 including the space; thus, two arguments would be generated.
531 %{S*&T*} likewise, but preserve order of S and T options (the order
532 of S and T in the spec is not significant). Can be any number
533 of ampersand-separated variables; for each the wild card is
534 optional. Useful for CPP as %{D*&U*&A*}.
536 %{S:X} substitutes X, if the -S switch was given to GCC.
537 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
538 %{S*:X} substitutes X if one or more switches whose names start
539 with -S was given to GCC. Normally X is substituted only
540 once, no matter how many such switches appeared. However,
541 if %* appears somewhere in X, then X will be substituted
542 once for each matching switch, with the %* replaced by the
543 part of that switch that matched the '*'.
544 %{.S:X} substitutes X, if processing a file with suffix S.
545 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
546 %{,S:X} substitutes X, if processing a file which will use spec S.
547 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
549 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
550 combined with '!', '.', ',', and '*' as above binding stronger
552 If %* appears in X, all of the alternatives must be starred, and
553 only the first matching alternative is substituted.
554 %{S:X; if S was given to GCC, substitutes X;
555 T:Y; else if T was given to GCC, substitutes Y;
556 :D} else substitutes D. There can be as many clauses as you need.
557 This may be combined with '.', '!', ',', '|', and '*' as above.
559 %(Spec) processes a specification defined in a specs file as *Spec:
560 %[Spec] as above, but put __ around -D arguments
562 The conditional text X in a %{S:X} or similar construct may contain
563 other nested % constructs or spaces, or even newlines. They are
564 processed as usual, as described above. Trailing white space in X is
565 ignored. White space may also appear anywhere on the left side of the
566 colon in these constructs, except between . or * and the corresponding
569 The -O, -f, -m, and -W switches are handled specifically in these
570 constructs. If another value of -O or the negated form of a -f, -m, or
571 -W switch is found later in the command line, the earlier switch
572 value is ignored, except with {S*} where S is just one letter; this
573 passes all matching options.
575 The character | at the beginning of the predicate text is used to indicate
576 that a command should be piped to the following command, but only if -pipe
579 Note that it is built into GCC which switches take arguments and which
580 do not. You might think it would be useful to generalize this to
581 allow each compiler's spec to say which switches take arguments. But
582 this cannot be done in a consistent fashion. GCC cannot even decide
583 which input files have been specified without knowing which switches
584 take arguments, and it must know which input files to compile in order
585 to tell which compilers to run.
587 GCC also knows implicitly that arguments starting in `-l' are to be
588 treated as compiler output files, and passed to the linker in their
589 proper position among the other output files. */
591 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
593 /* config.h can define ASM_SPEC to provide extra args to the assembler
594 or extra switch-translations. */
599 /* config.h can define ASM_FINAL_SPEC to run a post processor after
600 the assembler has run. */
601 #ifndef ASM_FINAL_SPEC
602 #define ASM_FINAL_SPEC ""
605 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
606 or extra switch-translations. */
611 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
612 or extra switch-translations. */
617 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
618 or extra switch-translations. */
620 #define CC1PLUS_SPEC ""
623 /* config.h can define LINK_SPEC to provide extra args to the linker
624 or extra switch-translations. */
629 /* config.h can define LIB_SPEC to override the default libraries. */
631 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
636 /* XXX: valid only for GNU ld */
637 /* XXX: should exactly match hooks provided by libmudflap.a */
638 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
639 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
640 --wrap=mmap --wrap=munmap --wrap=alloca\
641 } %{fmudflapth: --wrap=pthread_create\
642 }} %{fmudflap|fmudflapth: --wrap=main}"
645 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
648 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
651 #if defined(REAL_LIBGCC_SPEC)
652 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
653 #elif defined(LINK_LIBGCC_SPECIAL_1)
654 /* Have gcc do the search for libgcc.a. */
655 #define LIBGCC_SPEC "libgcc.a%s"
657 #define LIBGCC_SPEC "-lgcc"
661 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
662 #ifndef STARTFILE_SPEC
663 #define STARTFILE_SPEC \
664 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
667 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
669 #define ENDFILE_SPEC ""
673 #define LINKER_NAME "collect2"
676 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
677 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
682 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
684 #ifndef ASM_DEBUG_SPEC
685 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
686 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
687 # define ASM_DEBUG_SPEC \
688 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
689 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
690 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
692 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
693 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
695 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
696 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
700 #ifndef ASM_DEBUG_SPEC
701 # define ASM_DEBUG_SPEC ""
704 /* Here is the spec for running the linker, after compiling all files. */
706 /* This is overridable by the target in case they need to specify the
707 -lgcc and -lc order specially, yet not require them to override all
708 of LINK_COMMAND_SPEC. */
709 #ifndef LINK_GCC_C_SEQUENCE_SPEC
710 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
713 #ifndef LINK_SSP_SPEC
714 #ifdef TARGET_LIBC_PROVIDES_SSP
715 #define LINK_SSP_SPEC "%{fstack-protector:}"
717 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
721 #ifndef LINK_PIE_SPEC
723 #define LINK_PIE_SPEC "%{pie:-pie} "
725 #define LINK_PIE_SPEC "%{pie:} "
729 #ifndef LINK_BUILDID_SPEC
730 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
731 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
736 /* -u* was put back because both BSD and SysV seem to support it. */
737 /* %{static:} simply prevents an error message if the target machine
738 doesn't handle -static. */
739 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
740 scripts which exist in user specified directories, or in standard
742 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
743 to understand them. In practice, this means it had better be collect2. */
744 #ifndef LINK_COMMAND_SPEC
745 #define LINK_COMMAND_SPEC "\
746 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
748 %{fuse-linker-plugin: \
749 -plugin %(linker_plugin_file) \
750 -plugin-opt=%(lto_wrapper) \
751 -plugin-opt=-fresolution=%u.res \
752 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
753 %{static:-plugin-opt=-pass-through=-lc} \
755 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
756 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
757 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
758 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
759 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
760 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
761 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
762 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
765 #ifndef LINK_LIBGCC_SPEC
766 /* Generate -L options for startfile prefix list. */
767 # define LINK_LIBGCC_SPEC "%D"
770 #ifndef STARTFILE_PREFIX_SPEC
771 # define STARTFILE_PREFIX_SPEC ""
775 # define SYSROOT_SPEC "--sysroot=%R"
778 #ifndef SYSROOT_SUFFIX_SPEC
779 # define SYSROOT_SUFFIX_SPEC ""
782 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
783 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
786 static const char *asm_debug;
787 static const char *cpp_spec = CPP_SPEC;
788 static const char *cc1_spec = CC1_SPEC;
789 static const char *cc1plus_spec = CC1PLUS_SPEC;
790 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
791 static const char *link_ssp_spec = LINK_SSP_SPEC;
792 static const char *asm_spec = ASM_SPEC;
793 static const char *asm_final_spec = ASM_FINAL_SPEC;
794 static const char *link_spec = LINK_SPEC;
795 static const char *lib_spec = LIB_SPEC;
796 static const char *mfwrap_spec = MFWRAP_SPEC;
797 static const char *mflib_spec = MFLIB_SPEC;
798 static const char *link_gomp_spec = "";
799 static const char *libgcc_spec = LIBGCC_SPEC;
800 static const char *endfile_spec = ENDFILE_SPEC;
801 static const char *startfile_spec = STARTFILE_SPEC;
802 static const char *linker_name_spec = LINKER_NAME;
803 static const char *linker_plugin_file_spec = "";
804 static const char *lto_wrapper_spec = "";
805 static const char *lto_gcc_spec = "";
806 static const char *lto_libgcc_spec = "";
807 static const char *link_command_spec = LINK_COMMAND_SPEC;
808 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
809 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
810 static const char *sysroot_spec = SYSROOT_SPEC;
811 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
812 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
814 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
815 There should be no need to override these in target dependent files,
816 but we need to copy them to the specs file so that newer versions
817 of the GCC driver can correctly drive older tool chains with the
818 appropriate -B options. */
820 /* When cpplib handles traditional preprocessing, get rid of this, and
821 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
822 that we default the front end language better. */
823 static const char *trad_capable_cpp =
824 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
826 /* We don't wrap .d files in %W{} since a missing .d file, and
827 therefore no dependency entry, confuses make into thinking a .o
828 file that happens to exist is up-to-date. */
829 static const char *cpp_unique_options =
830 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
831 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
832 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
833 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
834 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
835 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
836 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
837 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
838 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
839 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
842 /* This contains cpp options which are common with cc1_options and are passed
843 only when preprocessing only to avoid duplication. We pass the cc1 spec
844 options to the preprocessor so that it the cc1 spec may manipulate
845 options used to set target flags. Those special target flags settings may
846 in turn cause preprocessor symbols to be defined specially. */
847 static const char *cpp_options =
848 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
849 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
850 %{undef} %{save-temps*:-fpch-preprocess}";
852 /* This contains cpp options which are not passed when the preprocessor
853 output will be used by another program. */
854 static const char *cpp_debug_options = "%{d*}";
856 /* NB: This is shared amongst all front-ends, except for Ada. */
857 static const char *cc1_options =
858 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
859 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
860 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{a*}\
861 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
862 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
863 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
864 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
865 %{Qn:-fno-ident} %{--help:--help}\
866 %{--target-help:--target-help}\
867 %{--help=*:--help=%(VALUE)}\
868 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
869 %{fsyntax-only:-o %j} %{-param*}\
870 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
871 %{coverage:-fprofile-arcs -ftest-coverage}";
873 static const char *asm_options =
874 "%{--target-help:%:print-asm-header()} "
876 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
877 to the assembler equivalents. */
878 "%{v} %{w:-W} %{I*} "
880 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
882 static const char *invoke_as =
883 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
885 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
886 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
890 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
891 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
895 /* Some compilers have limits on line lengths, and the multilib_select
896 and/or multilib_matches strings can be very long, so we build them at
898 static struct obstack multilib_obstack;
899 static const char *multilib_select;
900 static const char *multilib_matches;
901 static const char *multilib_defaults;
902 static const char *multilib_exclusions;
904 /* Check whether a particular argument is a default argument. */
906 #ifndef MULTILIB_DEFAULTS
907 #define MULTILIB_DEFAULTS { "" }
910 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
912 #ifndef DRIVER_SELF_SPECS
913 #define DRIVER_SELF_SPECS ""
916 /* Adding -fopenmp should imply pthreads. This is particularly important
917 for targets that use different start files and suchlike. */
918 #ifndef GOMP_SELF_SPECS
919 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
922 static const char *const driver_self_specs[] = {
923 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
924 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
927 #ifndef OPTION_DEFAULT_SPECS
928 #define OPTION_DEFAULT_SPECS { "", "" }
937 static const struct default_spec
938 option_default_specs[] = { OPTION_DEFAULT_SPECS };
942 struct user_specs *next;
943 const char *filename;
946 static struct user_specs *user_specs_head, *user_specs_tail;
948 #ifndef SWITCH_TAKES_ARG
949 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
952 #ifndef WORD_SWITCH_TAKES_ARG
953 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
956 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
957 /* This defines which switches stop a full compilation. */
958 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
959 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
961 #ifndef SWITCH_CURTAILS_COMPILATION
962 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
963 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
967 /* Record the mapping from file suffixes for compilation specs. */
971 const char *suffix; /* Use this compiler for input files
972 whose names end in this suffix. */
974 const char *spec; /* To use this compiler, run this spec. */
976 const char *cpp_spec; /* If non-NULL, substitute this spec
977 for `%C', rather than the usual
979 const int combinable; /* If nonzero, compiler can deal with
980 multiple source files at once (IMA). */
981 const int needs_preprocessing; /* If nonzero, source files need to
982 be run through a preprocessor. */
985 /* Pointer to a vector of `struct compiler' that gives the spec for
986 compiling a file, based on its suffix.
987 A file that does not end in any of these suffixes will be passed
988 unchanged to the loader and nothing else will be done to it.
990 An entry containing two 0s is used to terminate the vector.
992 If multiple entries match a file, the last matching one is used. */
994 static struct compiler *compilers;
996 /* Number of entries in `compilers', not counting the null terminator. */
998 static int n_compilers;
1000 /* The default list of file name suffixes and their compilation specs. */
1002 static const struct compiler default_compilers[] =
1004 /* Add lists of suffixes of known languages here. If those languages
1005 were not present when we built the driver, we will hit these copies
1006 and be given a more meaningful error than "file not used since
1007 linking is not done". */
1008 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1009 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1010 {".mii", "#Objective-C++", 0, 0, 0},
1011 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1012 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1013 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1014 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1015 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1016 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1017 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1018 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1019 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1020 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1021 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1022 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1023 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1024 {".r", "#Ratfor", 0, 0, 0},
1025 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1026 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1027 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1028 /* Next come the entries for C. */
1029 {".c", "@c", 0, 1, 1},
1031 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1032 external preprocessor if -save-temps is given. */
1033 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1035 %{traditional|ftraditional:\
1036 %eGNU C no longer supports -traditional without -E}\
1038 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1039 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1040 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1042 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1043 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1044 %{!fsyntax-only:%(invoke_as)}} \
1046 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1047 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1048 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1049 cc1 %(cpp_unique_options) %(cc1_options)}}\
1050 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1052 "%{!E:%e-E or -x required when input is from standard input}\
1053 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1054 {".h", "@c-header", 0, 0, 0},
1056 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1057 external preprocessor if -save-temps is given. */
1058 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1060 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1061 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1062 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1064 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1065 %W{o*:--output-pch=%*}}%V}\
1066 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1067 cc1 %(cpp_unique_options) %(cc1_options)\
1068 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1069 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1070 {".i", "@cpp-output", 0, 1, 0},
1072 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1073 {".s", "@assembler", 0, 1, 0},
1075 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1076 {".sx", "@assembler-with-cpp", 0, 1, 0},
1077 {".S", "@assembler-with-cpp", 0, 1, 0},
1078 {"@assembler-with-cpp",
1079 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1080 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1081 %{E|M|MM:%(cpp_debug_options)}\
1082 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1083 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1085 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1086 %{E|M|MM:%(cpp_debug_options)}\
1087 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1088 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1093 /* Mark end of table. */
1097 /* Number of elements in default_compilers, not counting the terminator. */
1099 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1101 /* A vector of options to give to the linker.
1102 These options are accumulated by %x,
1103 and substituted into the linker command with %X. */
1104 static int n_linker_options;
1105 static char **linker_options;
1107 /* A vector of options to give to the assembler.
1108 These options are accumulated by -Wa,
1109 and substituted into the assembler command with %Y. */
1110 static int n_assembler_options;
1111 static char **assembler_options;
1113 /* A vector of options to give to the preprocessor.
1114 These options are accumulated by -Wp,
1115 and substituted into the preprocessor command with %Z. */
1116 static int n_preprocessor_options;
1117 static char **preprocessor_options;
1119 /* Define how to map long options into short ones. */
1121 /* This structure describes one mapping. */
1124 /* The long option's name. */
1125 const char *const name;
1126 /* The equivalent short option. */
1127 const char *const equivalent;
1128 /* Argument info. A string of flag chars; NULL equals no options.
1129 a => argument required.
1130 o => argument optional.
1131 j => join argument to equivalent, making one word.
1132 * => require other text after NAME as an argument. */
1133 const char *const arg_info;
1136 /* This is the table of mappings. Mappings are tried sequentially
1137 for each option encountered; the first one that matches, wins. */
1139 static const struct option_map option_map[] =
1141 {"--all-warnings", "-Wall", 0},
1142 {"--ansi", "-ansi", 0},
1143 {"--assemble", "-S", 0},
1144 {"--assert", "-A", "a"},
1145 {"--classpath", "-fclasspath=", "aj"},
1146 {"--bootclasspath", "-fbootclasspath=", "aj"},
1147 {"--CLASSPATH", "-fclasspath=", "aj"},
1148 {"--combine", "-combine", 0},
1149 {"--comments", "-C", 0},
1150 {"--comments-in-macros", "-CC", 0},
1151 {"--compile", "-c", 0},
1152 {"--debug", "-g", "oj"},
1153 {"--define-macro", "-D", "aj"},
1154 {"--dependencies", "-M", 0},
1155 {"--dump", "-d", "a"},
1156 {"--dumpbase", "-dumpbase", "a"},
1157 {"--dumpdir", "-dumpdir", "a"},
1158 {"--encoding", "-fencoding=", "aj"},
1159 {"--entry", "-e", 0},
1160 {"--extra-warnings", "-W", 0},
1161 {"--extdirs", "-fextdirs=", "aj"},
1162 {"--for-assembler", "-Wa", "a"},
1163 {"--for-linker", "-Xlinker", "a"},
1164 {"--force-link", "-u", "a"},
1165 {"--coverage", "-coverage", 0},
1166 {"--imacros", "-imacros", "a"},
1167 {"--include", "-include", "a"},
1168 {"--include-barrier", "-I-", 0},
1169 {"--include-directory", "-I", "aj"},
1170 {"--include-directory-after", "-idirafter", "a"},
1171 {"--include-prefix", "-iprefix", "a"},
1172 {"--include-with-prefix", "-iwithprefix", "a"},
1173 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1174 {"--include-with-prefix-after", "-iwithprefix", "a"},
1175 {"--language", "-x", "a"},
1176 {"--library-directory", "-L", "a"},
1177 {"--machine", "-m", "aj"},
1178 {"--machine-", "-m", "*j"},
1179 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1180 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1181 {"--no-line-commands", "-P", 0},
1182 {"--no-precompiled-includes", "-noprecomp", 0},
1183 {"--no-standard-includes", "-nostdinc", 0},
1184 {"--no-standard-libraries", "-nostdlib", 0},
1185 {"--no-warnings", "-w", 0},
1186 {"--optimize", "-O", "oj"},
1187 {"--output", "-o", "a"},
1188 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1189 {"--param", "--param", "a"},
1190 {"--pass-exit-codes", "-pass-exit-codes", 0},
1191 {"--pedantic", "-pedantic", 0},
1192 {"--pedantic-errors", "-pedantic-errors", 0},
1193 {"--pie", "-pie", 0},
1194 {"--pipe", "-pipe", 0},
1195 {"--prefix", "-B", "a"},
1196 {"--preprocess", "-E", 0},
1197 {"--print-search-dirs", "-print-search-dirs", 0},
1198 {"--print-file-name", "-print-file-name=", "aj"},
1199 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1200 {"--print-missing-file-dependencies", "-MG", 0},
1201 {"--print-multi-lib", "-print-multi-lib", 0},
1202 {"--print-multi-directory", "-print-multi-directory", 0},
1203 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1204 {"--print-prog-name", "-print-prog-name=", "aj"},
1205 {"--print-sysroot", "-print-sysroot", 0},
1206 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1207 {"--profile", "-p", 0},
1208 {"--profile-blocks", "-a", 0},
1209 {"--quiet", "-q", 0},
1210 {"--resource", "-fcompile-resource=", "aj"},
1211 {"--save-temps", "-save-temps", 0},
1212 {"--shared", "-shared", 0},
1213 {"--silent", "-q", 0},
1214 {"--specs", "-specs=", "aj"},
1215 {"--static", "-static", 0},
1216 {"--std", "-std=", "aj"},
1217 {"--symbolic", "-symbolic", 0},
1218 {"--sysroot", "--sysroot=", "aj"},
1219 {"--time", "-time", 0},
1220 {"--trace-includes", "-H", 0},
1221 {"--traditional", "-traditional", 0},
1222 {"--traditional-cpp", "-traditional-cpp", 0},
1223 {"--trigraphs", "-trigraphs", 0},
1224 {"--undefine-macro", "-U", "aj"},
1225 {"--user-dependencies", "-MM", 0},
1226 {"--verbose", "-v", 0},
1227 {"--warn-", "-W", "*j"},
1228 {"--write-dependencies", "-MD", 0},
1229 {"--write-user-dependencies", "-MMD", 0},
1234 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1235 static const struct {
1236 const char *const option_found;
1237 const char *const replacements;
1238 } target_option_translations[] =
1240 TARGET_OPTION_TRANSLATE_TABLE,
1245 /* Translate the options described by *ARGCP and *ARGVP.
1246 Make a new vector and store it back in *ARGVP,
1247 and store its length in *ARGCP. */
1250 translate_options (int *argcp, const char *const **argvp)
1254 const char *const *argv = *argvp;
1255 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1256 const char **newv = XNEWVAR (const char *, newvsize);
1260 newv[newindex++] = argv[i++];
1264 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1268 target_option_translations[tott_idx].option_found;
1271 if (strcmp (target_option_translations[tott_idx].option_found,
1278 for (sp = target_option_translations[tott_idx].replacements;
1285 newvsize += spaces * sizeof (const char *);
1286 newv = XRESIZEVAR (const char *, newv, newvsize);
1288 sp = target_option_translations[tott_idx].replacements;
1297 newv[newindex++] = np;
1298 while (*np != ' ' && *np)
1309 if (target_option_translations[tott_idx].option_found)
1313 /* Translate -- options. */
1314 if (argv[i][0] == '-' && argv[i][1] == '-')
1317 /* Find a mapping that applies to this option. */
1318 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1320 size_t optlen = strlen (option_map[j].name);
1321 size_t arglen = strlen (argv[i]);
1322 size_t complen = arglen > optlen ? optlen : arglen;
1323 const char *arginfo = option_map[j].arg_info;
1328 if (!strncmp (argv[i], option_map[j].name, complen))
1330 const char *arg = 0;
1332 if (arglen < optlen)
1335 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1336 if (strlen (option_map[k].name) >= arglen
1337 && !strncmp (argv[i], option_map[k].name, arglen))
1339 error ("ambiguous abbreviation %s", argv[i]);
1343 if (k != ARRAY_SIZE (option_map))
1347 if (arglen > optlen)
1349 /* If the option has an argument, accept that. */
1350 if (argv[i][optlen] == '=')
1351 arg = argv[i] + optlen + 1;
1353 /* If this mapping requires extra text at end of name,
1354 accept that as "argument". */
1355 else if (strchr (arginfo, '*') != 0)
1356 arg = argv[i] + optlen;
1358 /* Otherwise, extra text at end means mismatch.
1359 Try other mappings. */
1364 else if (strchr (arginfo, '*') != 0)
1366 error ("incomplete %qs option", option_map[j].name);
1370 /* Handle arguments. */
1371 if (strchr (arginfo, 'a') != 0)
1377 error ("missing argument to %qs option",
1378 option_map[j].name);
1385 else if (strchr (arginfo, '*') != 0)
1387 else if (strchr (arginfo, 'o') == 0)
1390 error ("extraneous argument to %qs option",
1391 option_map[j].name);
1395 /* Store the translation as one argv elt or as two. */
1396 if (arg != 0 && strchr (arginfo, 'j') != 0)
1397 newv[newindex++] = concat (option_map[j].equivalent, arg,
1401 newv[newindex++] = option_map[j].equivalent;
1402 newv[newindex++] = arg;
1405 newv[newindex++] = option_map[j].equivalent;
1413 /* Handle old-fashioned options--just copy them through,
1414 with their arguments. */
1415 else if (argv[i][0] == '-')
1417 const char *p = argv[i] + 1;
1421 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1422 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1423 else if (WORD_SWITCH_TAKES_ARG (p))
1424 nskip += WORD_SWITCH_TAKES_ARG (p);
1425 else if ((c == 'B' || c == 'b' || c == 'x')
1428 else if (! strcmp (p, "Xlinker"))
1430 else if (! strcmp (p, "Xpreprocessor"))
1432 else if (! strcmp (p, "Xassembler"))
1435 /* Watch out for an option at the end of the command line that
1436 is missing arguments, and avoid skipping past the end of the
1438 if (nskip + i > argc)
1443 newv[newindex++] = argv[i++];
1448 /* Ordinary operands. */
1449 newv[newindex++] = argv[i++];
1459 skip_whitespace (char *p)
1463 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1464 be considered whitespace. */
1465 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1467 else if (*p == '\n' || *p == ' ' || *p == '\t')
1481 /* Structures to keep track of prefixes to try when looking for files. */
1485 const char *prefix; /* String to prepend to the path. */
1486 struct prefix_list *next; /* Next in linked list. */
1487 int require_machine_suffix; /* Don't use without machine_suffix. */
1488 /* 2 means try both machine_suffix and just_machine_suffix. */
1489 int priority; /* Sort key - priority within list. */
1490 int os_multilib; /* 1 if OS multilib scheme should be used,
1491 0 for GCC multilib scheme. */
1496 struct prefix_list *plist; /* List of prefixes to try */
1497 int max_len; /* Max length of a prefix in PLIST */
1498 const char *name; /* Name of this list (used in config stuff) */
1501 /* List of prefixes to try when looking for executables. */
1503 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1505 /* List of prefixes to try when looking for startup (crt0) files. */
1507 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1509 /* List of prefixes to try when looking for include files. */
1511 static struct path_prefix include_prefixes = { 0, 0, "include" };
1513 /* Suffix to attach to directories searched for commands.
1514 This looks like `MACHINE/VERSION/'. */
1516 static const char *machine_suffix = 0;
1518 /* Suffix to attach to directories searched for commands.
1519 This is just `MACHINE/'. */
1521 static const char *just_machine_suffix = 0;
1523 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1525 static const char *gcc_exec_prefix;
1527 /* Adjusted value of standard_libexec_prefix. */
1529 static const char *gcc_libexec_prefix;
1531 /* Default prefixes to attach to command names. */
1533 #ifndef STANDARD_STARTFILE_PREFIX_1
1534 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1536 #ifndef STANDARD_STARTFILE_PREFIX_2
1537 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1540 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1541 #undef MD_EXEC_PREFIX
1542 #undef MD_STARTFILE_PREFIX
1543 #undef MD_STARTFILE_PREFIX_1
1546 /* If no prefixes defined, use the null string, which will disable them. */
1547 #ifndef MD_EXEC_PREFIX
1548 #define MD_EXEC_PREFIX ""
1550 #ifndef MD_STARTFILE_PREFIX
1551 #define MD_STARTFILE_PREFIX ""
1553 #ifndef MD_STARTFILE_PREFIX_1
1554 #define MD_STARTFILE_PREFIX_1 ""
1557 /* These directories are locations set at configure-time based on the
1558 --prefix option provided to configure. Their initializers are
1559 defined in Makefile.in. These paths are not *directly* used when
1560 gcc_exec_prefix is set because, in that case, we know where the
1561 compiler has been installed, and use paths relative to that
1562 location instead. */
1563 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1564 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1565 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1566 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1568 /* For native compilers, these are well-known paths containing
1569 components that may be provided by the system. For cross
1570 compilers, these paths are not used. */
1571 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1572 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1573 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1574 static const char *const standard_startfile_prefix_1
1575 = STANDARD_STARTFILE_PREFIX_1;
1576 static const char *const standard_startfile_prefix_2
1577 = STANDARD_STARTFILE_PREFIX_2;
1579 /* A relative path to be used in finding the location of tools
1580 relative to the driver. */
1581 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1583 /* Subdirectory to use for locating libraries. Set by
1584 set_multilib_dir based on the compilation options. */
1586 static const char *multilib_dir;
1588 /* Subdirectory to use for locating libraries in OS conventions. Set by
1589 set_multilib_dir based on the compilation options. */
1591 static const char *multilib_os_dir;
1593 /* Structure to keep track of the specs that have been defined so far.
1594 These are accessed using %(specname) or %[specname] in a compiler
1599 /* The following 2 fields must be first */
1600 /* to allow EXTRA_SPECS to be initialized */
1601 const char *name; /* name of the spec. */
1602 const char *ptr; /* available ptr if no static pointer */
1604 /* The following fields are not initialized */
1605 /* by EXTRA_SPECS */
1606 const char **ptr_spec; /* pointer to the spec itself. */
1607 struct spec_list *next; /* Next spec in linked list. */
1608 int name_len; /* length of the name */
1609 int alloc_p; /* whether string was allocated */
1612 #define INIT_STATIC_SPEC(NAME,PTR) \
1613 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1615 /* List of statically defined specs. */
1616 static struct spec_list static_specs[] =
1618 INIT_STATIC_SPEC ("asm", &asm_spec),
1619 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1620 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1621 INIT_STATIC_SPEC ("asm_options", &asm_options),
1622 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1623 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1624 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1625 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1626 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1627 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1628 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1629 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1630 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1631 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1632 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1633 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1634 INIT_STATIC_SPEC ("link", &link_spec),
1635 INIT_STATIC_SPEC ("lib", &lib_spec),
1636 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1637 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1638 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1639 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1640 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1641 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1642 INIT_STATIC_SPEC ("version", &compiler_version),
1643 INIT_STATIC_SPEC ("multilib", &multilib_select),
1644 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1645 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1646 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1647 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1648 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1649 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1650 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1651 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec),
1652 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec),
1653 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec),
1654 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1655 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1656 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1657 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1658 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1659 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1660 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1661 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1664 #ifdef EXTRA_SPECS /* additional specs needed */
1665 /* Structure to keep track of just the first two args of a spec_list.
1666 That is all that the EXTRA_SPECS macro gives us. */
1669 const char *const name;
1670 const char *const ptr;
1673 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1674 static struct spec_list *extra_specs = (struct spec_list *) 0;
1677 /* List of dynamically allocates specs that have been defined so far. */
1679 static struct spec_list *specs = (struct spec_list *) 0;
1681 /* List of static spec functions. */
1683 static const struct spec_function static_spec_functions[] =
1685 { "getenv", getenv_spec_function },
1686 { "if-exists", if_exists_spec_function },
1687 { "if-exists-else", if_exists_else_spec_function },
1688 { "replace-outfile", replace_outfile_spec_function },
1689 { "version-compare", version_compare_spec_function },
1690 { "include", include_spec_function },
1691 { "find-file", find_file_spec_function },
1692 { "find-plugindir", find_plugindir_spec_function },
1693 { "print-asm-header", print_asm_header_spec_function },
1694 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1695 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1696 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1697 #ifdef EXTRA_SPEC_FUNCTIONS
1698 EXTRA_SPEC_FUNCTIONS
1703 static int processing_spec_function;
1705 /* Add appropriate libgcc specs to OBSTACK, taking into account
1706 various permutations of -shared-libgcc, -shared, and such. */
1708 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1710 #ifndef USE_LD_AS_NEEDED
1711 #define USE_LD_AS_NEEDED 0
1715 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1716 const char *static_name, const char *eh_name)
1720 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1721 "%{!static:%{!static-libgcc:"
1722 #if USE_LD_AS_NEEDED
1723 "%{!shared-libgcc:",
1724 static_name, " --as-needed ", shared_name, " --no-as-needed"
1727 shared_name, "%{!shared: ", static_name, "}"
1731 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1732 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1736 "%{shared-libgcc:", shared_name, "}"
1737 "%{!shared-libgcc:", static_name, "}"
1740 "%{shared:", shared_name, "}"
1745 obstack_grow (obstack, buf, strlen (buf));
1748 #endif /* ENABLE_SHARED_LIBGCC */
1750 /* Initialize the specs lookup routines. */
1755 struct spec_list *next = (struct spec_list *) 0;
1756 struct spec_list *sl = (struct spec_list *) 0;
1760 return; /* Already initialized. */
1763 fnotice (stderr, "Using built-in specs.\n");
1766 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1768 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1770 sl = &extra_specs[i];
1771 sl->name = extra_specs_1[i].name;
1772 sl->ptr = extra_specs_1[i].ptr;
1774 sl->name_len = strlen (sl->name);
1775 sl->ptr_spec = &sl->ptr;
1780 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1782 sl = &static_specs[i];
1787 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1788 /* ??? If neither -shared-libgcc nor --static-libgcc was
1789 seen, then we should be making an educated guess. Some proposed
1790 heuristics for ELF include:
1792 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1793 program will be doing dynamic loading, which will likely
1794 need the shared libgcc.
1796 (2) If "-ldl", then it's also a fair bet that we're doing
1799 (3) For each ET_DYN we're linking against (either through -lfoo
1800 or /some/path/foo.so), check to see whether it or one of
1801 its dependencies depends on a shared libgcc.
1805 If the runtime is fixed to look for program headers instead
1806 of calling __register_frame_info at all, for each object,
1807 use the shared libgcc if any EH symbol referenced.
1809 If crtstuff is fixed to not invoke __register_frame_info
1810 automatically, for each object, use the shared libgcc if
1811 any non-empty unwind section found.
1813 Doing any of this probably requires invoking an external program to
1814 do the actual object file scanning. */
1816 const char *p = libgcc_spec;
1819 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1820 when given the proper command line arguments. */
1823 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1825 init_gcc_specs (&obstack,
1827 #ifdef USE_LIBUNWIND_EXCEPTIONS
1833 #ifdef USE_LIBUNWIND_EXCEPTIONS
1834 # ifdef HAVE_LD_STATIC_DYNAMIC
1835 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1845 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1847 /* Ug. We don't know shared library extensions. Hope that
1848 systems that use this form don't do shared libraries. */
1849 init_gcc_specs (&obstack,
1853 #ifdef USE_LIBUNWIND_EXCEPTIONS
1862 obstack_1grow (&obstack, *p);
1863 in_sep = (*p == ' ');
1868 obstack_1grow (&obstack, '\0');
1869 libgcc_spec = XOBFINISH (&obstack, const char *);
1872 #ifdef USE_AS_TRADITIONAL_FORMAT
1873 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1875 static const char tf[] = "--traditional-format ";
1876 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1877 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1878 asm_spec = XOBFINISH (&obstack, const char *);
1882 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1883 # ifdef LINK_BUILDID_SPEC
1884 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1885 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1887 # ifdef LINK_EH_SPEC
1888 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1889 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1891 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1892 link_spec = XOBFINISH (&obstack, const char *);
1898 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1899 removed; If the spec starts with a + then SPEC is added to the end of the
1903 set_spec (const char *name, const char *spec)
1905 struct spec_list *sl;
1906 const char *old_spec;
1907 int name_len = strlen (name);
1910 /* If this is the first call, initialize the statically allocated specs. */
1913 struct spec_list *next = (struct spec_list *) 0;
1914 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1916 sl = &static_specs[i];
1923 /* See if the spec already exists. */
1924 for (sl = specs; sl; sl = sl->next)
1925 if (name_len == sl->name_len && !strcmp (sl->name, name))
1930 /* Not found - make it. */
1931 sl = XNEW (struct spec_list);
1932 sl->name = xstrdup (name);
1933 sl->name_len = name_len;
1934 sl->ptr_spec = &sl->ptr;
1936 *(sl->ptr_spec) = "";
1941 old_spec = *(sl->ptr_spec);
1942 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1943 ? concat (old_spec, spec + 1, NULL)
1948 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1951 /* Free the old spec. */
1952 if (old_spec && sl->alloc_p)
1953 free (CONST_CAST(char *, old_spec));
1958 /* Accumulate a command (program name and args), and run it. */
1960 /* Vector of pointers to arguments in the current line of specifications. */
1962 static const char **argbuf;
1964 /* Number of elements allocated in argbuf. */
1966 static int argbuf_length;
1968 /* Number of elements in argbuf currently in use (containing args). */
1970 static int argbuf_index;
1972 /* Position in the argbuf array containing the name of the output file
1973 (the value associated with the "-o" flag). */
1975 static int have_o_argbuf_index = 0;
1977 /* Were the options -c, -S or -E passed. */
1978 static int have_c = 0;
1980 /* Was the option -o passed. */
1981 static int have_o = 0;
1983 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1984 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1987 static struct temp_name {
1988 const char *suffix; /* suffix associated with the code. */
1989 int length; /* strlen (suffix). */
1990 int unique; /* Indicates whether %g or %u/%U was used. */
1991 const char *filename; /* associated filename. */
1992 int filename_length; /* strlen (filename). */
1993 struct temp_name *next;
1996 /* Number of commands executed so far. */
1998 static int execution_count;
2000 /* Number of commands that exited with a signal. */
2002 static int signal_count;
2004 /* Allocate the argument vector. */
2010 argbuf = XNEWVEC (const char *, argbuf_length);
2013 /* Clear out the vector of arguments (after a command is executed). */
2021 /* Add one argument to the vector at the end.
2022 This is done when a space is seen or at the end of the line.
2023 If DELETE_ALWAYS is nonzero, the arg is a filename
2024 and the file should be deleted eventually.
2025 If DELETE_FAILURE is nonzero, the arg is a filename
2026 and the file should be deleted if this compilation fails. */
2029 store_arg (const char *arg, int delete_always, int delete_failure)
2031 if (argbuf_index + 1 == argbuf_length)
2032 argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
2034 argbuf[argbuf_index++] = arg;
2035 argbuf[argbuf_index] = 0;
2037 if (strcmp (arg, "-o") == 0)
2038 have_o_argbuf_index = argbuf_index;
2039 if (delete_always || delete_failure)
2042 /* If the temporary file we should delete is specified as
2043 part of a joined argument extract the filename. */
2045 && (p = strrchr (arg, '=')))
2047 record_temp_file (arg, delete_always, delete_failure);
2051 /* Load specs from a file name named FILENAME, replacing occurrences of
2052 various different types of line-endings, \r\n, \n\r and just \r, with
2056 load_specs (const char *filename)
2060 struct stat statbuf;
2067 fnotice (stderr, "Reading specs from %s\n", filename);
2069 /* Open and stat the file. */
2070 desc = open (filename, O_RDONLY, 0);
2072 pfatal_with_name (filename);
2073 if (stat (filename, &statbuf) < 0)
2074 pfatal_with_name (filename);
2076 /* Read contents of file into BUFFER. */
2077 buffer = XNEWVEC (char, statbuf.st_size + 1);
2078 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2080 pfatal_with_name (filename);
2081 buffer[readlen] = 0;
2084 specs = XNEWVEC (char, readlen + 1);
2086 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2092 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2094 else if (*(buffer_p + 1) == '\n') /* \r\n */
2108 /* Read compilation specs from a file named FILENAME,
2109 replacing the default ones.
2111 A suffix which starts with `*' is a definition for
2112 one of the machine-specific sub-specs. The "suffix" should be
2113 *asm, *cc1, *cpp, *link, *startfile, etc.
2114 The corresponding spec is stored in asm_spec, etc.,
2115 rather than in the `compilers' vector.
2117 Anything invalid in the file is a fatal error. */
2120 read_specs (const char *filename, int main_p)
2125 buffer = load_specs (filename);
2127 /* Scan BUFFER for specs, putting them in the vector. */
2133 char *in, *out, *p1, *p2, *p3;
2135 /* Advance P in BUFFER to the next nonblank nocomment line. */
2136 p = skip_whitespace (p);
2140 /* Is this a special command that starts with '%'? */
2141 /* Don't allow this for the main specs file, since it would
2142 encourage people to overwrite it. */
2143 if (*p == '%' && !main_p)
2146 while (*p && *p != '\n')
2152 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2153 && (p1[sizeof "%include" - 1] == ' '
2154 || p1[sizeof "%include" - 1] == '\t'))
2158 p1 += sizeof ("%include");
2159 while (*p1 == ' ' || *p1 == '\t')
2162 if (*p1++ != '<' || p[-2] != '>')
2163 fatal_error ("specs %%include syntax malformed after "
2165 (long) (p1 - buffer + 1));
2168 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2169 read_specs (new_filename ? new_filename : p1, FALSE);
2172 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2173 && (p1[sizeof "%include_noerr" - 1] == ' '
2174 || p1[sizeof "%include_noerr" - 1] == '\t'))
2178 p1 += sizeof "%include_noerr";
2179 while (*p1 == ' ' || *p1 == '\t')
2182 if (*p1++ != '<' || p[-2] != '>')
2183 fatal_error ("specs %%include syntax malformed after "
2185 (long) (p1 - buffer + 1));
2188 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2190 read_specs (new_filename, FALSE);
2191 else if (verbose_flag)
2192 fnotice (stderr, "could not find specs file %s\n", p1);
2195 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2196 && (p1[sizeof "%rename" - 1] == ' '
2197 || p1[sizeof "%rename" - 1] == '\t'))
2200 struct spec_list *sl;
2201 struct spec_list *newsl;
2203 /* Get original name. */
2204 p1 += sizeof "%rename";
2205 while (*p1 == ' ' || *p1 == '\t')
2208 if (! ISALPHA ((unsigned char) *p1))
2209 fatal_error ("specs %%rename syntax malformed after "
2211 (long) (p1 - buffer));
2214 while (*p2 && !ISSPACE ((unsigned char) *p2))
2217 if (*p2 != ' ' && *p2 != '\t')
2218 fatal_error ("specs %%rename syntax malformed after "
2220 (long) (p2 - buffer));
2224 while (*p2 == ' ' || *p2 == '\t')
2227 if (! ISALPHA ((unsigned char) *p2))
2228 fatal_error ("specs %%rename syntax malformed after "
2230 (long) (p2 - buffer));
2232 /* Get new spec name. */
2234 while (*p3 && !ISSPACE ((unsigned char) *p3))
2238 fatal_error ("specs %%rename syntax malformed after "
2240 (long) (p3 - buffer));
2243 for (sl = specs; sl; sl = sl->next)
2244 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2248 fatal_error ("specs %s spec was not found to be renamed", p1);
2250 if (strcmp (p1, p2) == 0)
2253 for (newsl = specs; newsl; newsl = newsl->next)
2254 if (strcmp (newsl->name, p2) == 0)
2255 fatal_error ("%s: attempt to rename spec %qs to "
2256 "already defined spec %qs",
2261 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2263 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2267 set_spec (p2, *(sl->ptr_spec));
2269 free (CONST_CAST (char *, *(sl->ptr_spec)));
2271 *(sl->ptr_spec) = "";
2276 fatal_error ("specs unknown %% command after %ld characters",
2277 (long) (p1 - buffer));
2280 /* Find the colon that should end the suffix. */
2282 while (*p1 && *p1 != ':' && *p1 != '\n')
2285 /* The colon shouldn't be missing. */
2287 fatal_error ("specs file malformed after %ld characters",
2288 (long) (p1 - buffer));
2290 /* Skip back over trailing whitespace. */
2292 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2295 /* Copy the suffix to a string. */
2296 suffix = save_string (p, p2 - p);
2297 /* Find the next line. */
2298 p = skip_whitespace (p1 + 1);
2300 fatal_error ("specs file malformed after %ld characters",
2301 (long) (p - buffer));
2304 /* Find next blank line or end of string. */
2305 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2308 /* Specs end at the blank line and do not include the newline. */
2309 spec = save_string (p, p1 - p);
2312 /* Delete backslash-newline sequences from the spec. */
2317 if (in[0] == '\\' && in[1] == '\n')
2319 else if (in[0] == '#')
2320 while (*in && *in != '\n')
2328 if (suffix[0] == '*')
2330 if (! strcmp (suffix, "*link_command"))
2331 link_command_spec = spec;
2333 set_spec (suffix + 1, spec);
2337 /* Add this pair to the vector. */
2339 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2341 compilers[n_compilers].suffix = suffix;
2342 compilers[n_compilers].spec = spec;
2344 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2348 link_command_spec = spec;
2351 if (link_command_spec == 0)
2352 fatal_error ("spec file has no spec for linking");
2355 /* Record the names of temporary files we tell compilers to write,
2356 and delete them at the end of the run. */
2358 /* This is the common prefix we use to make temp file names.
2359 It is chosen once for each run of this program.
2360 It is substituted into a spec by %g or %j.
2361 Thus, all temp file names contain this prefix.
2362 In practice, all temp file names start with this prefix.
2364 This prefix comes from the envvar TMPDIR if it is defined;
2365 otherwise, from the P_tmpdir macro if that is defined;
2366 otherwise, in /usr/tmp or /tmp;
2367 or finally the current directory if all else fails. */
2369 static const char *temp_filename;
2371 /* Length of the prefix. */
2373 static int temp_filename_length;
2375 /* Define the list of temporary files to delete. */
2380 struct temp_file *next;
2383 /* Queue of files to delete on success or failure of compilation. */
2384 static struct temp_file *always_delete_queue;
2385 /* Queue of files to delete on failure of compilation. */
2386 static struct temp_file *failure_delete_queue;
2388 /* Record FILENAME as a file to be deleted automatically.
2389 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2390 otherwise delete it in any case.
2391 FAIL_DELETE nonzero means delete it if a compilation step fails;
2392 otherwise delete it in any case. */
2395 record_temp_file (const char *filename, int always_delete, int fail_delete)
2397 char *const name = xstrdup (filename);
2401 struct temp_file *temp;
2402 for (temp = always_delete_queue; temp; temp = temp->next)
2403 if (! strcmp (name, temp->name))
2406 temp = XNEW (struct temp_file);
2407 temp->next = always_delete_queue;
2409 always_delete_queue = temp;
2416 struct temp_file *temp;
2417 for (temp = failure_delete_queue; temp; temp = temp->next)
2418 if (! strcmp (name, temp->name))
2421 temp = XNEW (struct temp_file);
2422 temp->next = failure_delete_queue;
2424 failure_delete_queue = temp;
2430 /* Delete all the temporary files whose names we previously recorded. */
2432 #ifndef DELETE_IF_ORDINARY
2433 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2436 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2437 if (unlink (NAME) < 0) \
2439 perror_with_name (NAME); \
2444 delete_if_ordinary (const char *name)
2450 printf ("Delete %s? (y or n) ", name);
2454 while ((c = getchar ()) != '\n' && c != EOF)
2457 if (i == 'y' || i == 'Y')
2459 DELETE_IF_ORDINARY (name, st, verbose_flag);
2463 delete_temp_files (void)
2465 struct temp_file *temp;
2467 for (temp = always_delete_queue; temp; temp = temp->next)
2468 delete_if_ordinary (temp->name);
2469 always_delete_queue = 0;
2472 /* Delete all the files to be deleted on error. */
2475 delete_failure_queue (void)
2477 struct temp_file *temp;
2479 for (temp = failure_delete_queue; temp; temp = temp->next)
2480 delete_if_ordinary (temp->name);
2484 clear_failure_queue (void)
2486 failure_delete_queue = 0;
2489 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2491 If DO_MULTI is true iterate over the paths twice, first with multilib
2492 suffix then without, otherwise iterate over the paths once without
2493 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2494 to avoid visiting the same path twice, but we could do better. For
2495 instance, /usr/lib/../lib is considered different from /usr/lib.
2496 At least EXTRA_SPACE chars past the end of the path passed to
2497 CALLBACK are available for use by the callback.
2498 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2500 Returns the value returned by CALLBACK. */
2503 for_each_path (const struct path_prefix *paths,
2506 void *(*callback) (char *, void *),
2507 void *callback_info)
2509 struct prefix_list *pl;
2510 const char *multi_dir = NULL;
2511 const char *multi_os_dir = NULL;
2512 const char *multi_suffix;
2513 const char *just_multi_suffix;
2516 bool skip_multi_dir = false;
2517 bool skip_multi_os_dir = false;
2519 multi_suffix = machine_suffix;
2520 just_multi_suffix = just_machine_suffix;
2521 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2523 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2524 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2525 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2527 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2528 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2532 size_t multi_dir_len = 0;
2533 size_t multi_os_dir_len = 0;
2535 size_t just_suffix_len;
2539 multi_dir_len = strlen (multi_dir);
2541 multi_os_dir_len = strlen (multi_os_dir);
2542 suffix_len = strlen (multi_suffix);
2543 just_suffix_len = strlen (just_multi_suffix);
2547 len = paths->max_len + extra_space + 1;
2548 if (suffix_len > multi_os_dir_len)
2551 len += multi_os_dir_len;
2552 path = XNEWVEC (char, len);
2555 for (pl = paths->plist; pl != 0; pl = pl->next)
2557 len = strlen (pl->prefix);
2558 memcpy (path, pl->prefix, len);
2560 /* Look first in MACHINE/VERSION subdirectory. */
2561 if (!skip_multi_dir)
2563 memcpy (path + len, multi_suffix, suffix_len + 1);
2564 ret = callback (path, callback_info);
2569 /* Some paths are tried with just the machine (ie. target)
2570 subdir. This is used for finding as, ld, etc. */
2572 && pl->require_machine_suffix == 2)
2574 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2575 ret = callback (path, callback_info);
2580 /* Now try the base path. */
2581 if (!pl->require_machine_suffix
2582 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2584 const char *this_multi;
2585 size_t this_multi_len;
2587 if (pl->os_multilib)
2589 this_multi = multi_os_dir;
2590 this_multi_len = multi_os_dir_len;
2594 this_multi = multi_dir;
2595 this_multi_len = multi_dir_len;
2599 memcpy (path + len, this_multi, this_multi_len + 1);
2603 ret = callback (path, callback_info);
2611 if (multi_dir == NULL && multi_os_dir == NULL)
2614 /* Run through the paths again, this time without multilibs.
2615 Don't repeat any we have already seen. */
2618 free (CONST_CAST (char *, multi_dir));
2620 free (CONST_CAST (char *, multi_suffix));
2621 multi_suffix = machine_suffix;
2622 free (CONST_CAST (char *, just_multi_suffix));
2623 just_multi_suffix = just_machine_suffix;
2626 skip_multi_dir = true;
2629 free (CONST_CAST (char *, multi_os_dir));
2630 multi_os_dir = NULL;
2633 skip_multi_os_dir = true;
2638 free (CONST_CAST (char *, multi_dir));
2639 free (CONST_CAST (char *, multi_suffix));
2640 free (CONST_CAST (char *, just_multi_suffix));
2643 free (CONST_CAST (char *, multi_os_dir));
2649 /* Callback for build_search_list. Adds path to obstack being built. */
2651 struct add_to_obstack_info {
2658 add_to_obstack (char *path, void *data)
2660 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2662 if (info->check_dir && !is_directory (path, false))
2665 if (!info->first_time)
2666 obstack_1grow (info->ob, PATH_SEPARATOR);
2668 obstack_grow (info->ob, path, strlen (path));
2670 info->first_time = false;
2674 /* Add or change the value of an environment variable, outputting the
2675 change to standard error if in verbose mode. */
2677 xputenv (const char *string)
2680 fnotice (stderr, "%s\n", string);
2681 putenv (CONST_CAST (char *, string));
2684 /* Build a list of search directories from PATHS.
2685 PREFIX is a string to prepend to the list.
2686 If CHECK_DIR_P is true we ensure the directory exists.
2687 If DO_MULTI is true, multilib paths are output first, then
2689 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2690 It is also used by the --print-search-dirs flag. */
2693 build_search_list (const struct path_prefix *paths, const char *prefix,
2694 bool check_dir, bool do_multi)
2696 struct add_to_obstack_info info;
2698 info.ob = &collect_obstack;
2699 info.check_dir = check_dir;
2700 info.first_time = true;
2702 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2703 obstack_1grow (&collect_obstack, '=');
2705 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2707 obstack_1grow (&collect_obstack, '\0');
2708 return XOBFINISH (&collect_obstack, char *);
2711 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2715 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2718 xputenv (build_search_list (paths, env_var, true, do_multi));
2721 /* Check whether NAME can be accessed in MODE. This is like access,
2722 except that it never considers directories to be executable. */
2725 access_check (const char *name, int mode)
2731 if (stat (name, &st) < 0
2732 || S_ISDIR (st.st_mode))
2736 return access (name, mode);
2739 /* Callback for find_a_file. Appends the file name to the directory
2740 path. If the resulting file exists in the right mode, return the
2741 full pathname to the file. */
2743 struct file_at_path_info {
2752 file_at_path (char *path, void *data)
2754 struct file_at_path_info *info = (struct file_at_path_info *) data;
2755 size_t len = strlen (path);
2757 memcpy (path + len, info->name, info->name_len);
2758 len += info->name_len;
2760 /* Some systems have a suffix for executable files.
2761 So try appending that first. */
2762 if (info->suffix_len)
2764 memcpy (path + len, info->suffix, info->suffix_len + 1);
2765 if (access_check (path, info->mode) == 0)
2770 if (access_check (path, info->mode) == 0)
2776 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2777 access to check permissions. If DO_MULTI is true, search multilib
2778 paths then non-multilib paths, otherwise do not search multilib paths.
2779 Return 0 if not found, otherwise return its name, allocated with malloc. */
2782 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2785 struct file_at_path_info info;
2787 #ifdef DEFAULT_ASSEMBLER
2788 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2789 return xstrdup (DEFAULT_ASSEMBLER);
2792 #ifdef DEFAULT_LINKER
2793 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2794 return xstrdup (DEFAULT_LINKER);
2797 /* Determine the filename to execute (special case for absolute paths). */
2799 if (IS_ABSOLUTE_PATH (name))
2801 if (access (name, mode) == 0)
2802 return xstrdup (name);
2808 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2809 info.name_len = strlen (info.name);
2810 info.suffix_len = strlen (info.suffix);
2813 return (char*) for_each_path (pprefix, do_multi,
2814 info.name_len + info.suffix_len,
2815 file_at_path, &info);
2818 /* Ranking of prefixes in the sort list. -B prefixes are put before
2821 enum path_prefix_priority
2823 PREFIX_PRIORITY_B_OPT,
2824 PREFIX_PRIORITY_LAST
2827 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2828 order according to PRIORITY. Within each PRIORITY, new entries are
2831 If WARN is nonzero, we will warn if no file is found
2832 through this prefix. WARN should point to an int
2833 which will be set to 1 if this entry is used.
2835 COMPONENT is the value to be passed to update_path.
2837 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2838 the complete value of machine_suffix.
2839 2 means try both machine_suffix and just_machine_suffix. */
2842 add_prefix (struct path_prefix *pprefix, const char *prefix,
2843 const char *component, /* enum prefix_priority */ int priority,
2844 int require_machine_suffix, int os_multilib)
2846 struct prefix_list *pl, **prev;
2849 for (prev = &pprefix->plist;
2850 (*prev) != NULL && (*prev)->priority <= priority;
2851 prev = &(*prev)->next)
2854 /* Keep track of the longest prefix. */
2856 prefix = update_path (prefix, component);
2857 len = strlen (prefix);
2858 if (len > pprefix->max_len)
2859 pprefix->max_len = len;
2861 pl = XNEW (struct prefix_list);
2862 pl->prefix = prefix;
2863 pl->require_machine_suffix = require_machine_suffix;
2864 pl->priority = priority;
2865 pl->os_multilib = os_multilib;
2867 /* Insert after PREV. */
2872 /* Same as add_prefix, but prepending target_system_root to prefix. */
2873 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2875 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2876 const char *component,
2877 /* enum prefix_priority */ int priority,
2878 int require_machine_suffix, int os_multilib)
2880 if (!IS_ABSOLUTE_PATH (prefix))
2881 fatal_error ("system path %qs is not absolute", prefix);
2883 if (target_system_root)
2885 if (target_sysroot_suffix)
2886 prefix = concat (target_sysroot_suffix, prefix, NULL);
2887 prefix = concat (target_system_root, prefix, NULL);
2889 /* We have to override this because GCC's notion of sysroot
2890 moves along with GCC. */
2894 add_prefix (pprefix, prefix, component, priority,
2895 require_machine_suffix, os_multilib);
2898 /* Execute the command specified by the arguments on the current line of spec.
2899 When using pipes, this includes several piped-together commands
2900 with `|' between them.
2902 Return 0 if successful, -1 if failed. */
2908 int n_commands; /* # of command. */
2910 struct pex_obj *pex;
2913 const char *prog; /* program name. */
2914 const char **argv; /* vector of args. */
2917 struct command *commands; /* each command buffer with above info. */
2919 gcc_assert (!processing_spec_function);
2923 string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2924 argbuf[0] = (string) ? string : argbuf[0];
2925 insert_wrapper (wrapper_string);
2928 /* Count # of piped commands. */
2929 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2930 if (strcmp (argbuf[i], "|") == 0)
2933 /* Get storage for each command. */
2934 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2936 /* Split argbuf into its separate piped processes,
2937 and record info about each one.
2938 Also search for the programs that are to be run. */
2940 commands[0].prog = argbuf[0]; /* first command. */
2941 commands[0].argv = &argbuf[0];
2943 if (!wrapper_string)
2945 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2946 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2949 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2950 if (strcmp (argbuf[i], "|") == 0)
2951 { /* each command. */
2952 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2953 fatal_error ("-pipe not supported");
2955 argbuf[i] = 0; /* termination of command args. */
2956 commands[n_commands].prog = argbuf[i + 1];
2957 commands[n_commands].argv = &argbuf[i + 1];
2958 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2961 commands[n_commands].argv[0] = string;
2965 argbuf[argbuf_index] = 0;
2967 /* If -v, print what we are about to do, and maybe query. */
2971 /* For help listings, put a blank line between sub-processes. */
2972 if (print_help_list)
2973 fputc ('\n', stderr);
2975 /* Print each piped command as a separate line. */
2976 for (i = 0; i < n_commands; i++)
2978 const char *const *j;
2980 if (verbose_only_flag)
2982 for (j = commands[i].argv; *j; j++)
2985 for (p = *j; *p; ++p)
2986 if (!ISALNUM ((unsigned char) *p)
2987 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2991 fprintf (stderr, " \"");
2992 for (p = *j; *p; ++p)
2994 if (*p == '"' || *p == '\\' || *p == '$')
2995 fputc ('\\', stderr);
2998 fputc ('"', stderr);
3001 fprintf (stderr, " %s", *j);
3005 for (j = commands[i].argv; *j; j++)
3006 fprintf (stderr, " %s", *j);
3008 /* Print a pipe symbol after all but the last command. */
3009 if (i + 1 != n_commands)
3010 fprintf (stderr, " |");
3011 fprintf (stderr, "\n");
3014 if (verbose_only_flag != 0)
3016 /* verbose_only_flag should act as if the spec was
3017 executed, so increment execution_count before
3018 returning. This prevents spurious warnings about
3019 unused linker input files, etc. */
3024 fnotice (stderr, "\nGo ahead? (y or n) ");
3028 while (getchar () != '\n')
3031 if (i != 'y' && i != 'Y')
3036 #ifdef ENABLE_VALGRIND_CHECKING
3037 /* Run the each command through valgrind. To simplify prepending the
3038 path to valgrind and the option "-q" (for quiet operation unless
3039 something triggers), we allocate a separate argv array. */
3041 for (i = 0; i < n_commands; i++)
3047 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3050 argv = XALLOCAVEC (const char *, argc + 3);
3052 argv[0] = VALGRIND_PATH;
3054 for (j = 2; j < argc + 2; j++)
3055 argv[j] = commands[i].argv[j - 2];
3058 commands[i].argv = argv;
3059 commands[i].prog = argv[0];
3063 /* Run each piped subprocess. */
3065 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3066 ? PEX_RECORD_TIMES : 0),
3067 progname, temp_filename);
3069 fatal_error ("pex_init failed: %m");
3071 for (i = 0; i < n_commands; i++)
3075 const char *string = commands[i].argv[0];
3077 errmsg = pex_run (pex,
3078 ((i + 1 == n_commands ? PEX_LAST : 0)
3079 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3080 string, CONST_CAST (char **, commands[i].argv),
3085 fatal_error (errmsg);
3089 pfatal_with_name (errmsg);
3093 if (string != commands[i].prog)
3094 free (CONST_CAST (char *, string));
3099 /* Wait for all the subprocesses to finish. */
3103 struct pex_time *times = NULL;
3106 statuses = (int *) alloca (n_commands * sizeof (int));
3107 if (!pex_get_status (pex, n_commands, statuses))
3108 fatal_error ("failed to get exit status: %m");
3110 if (report_times || report_times_to_file)
3112 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3113 if (!pex_get_times (pex, n_commands, times))
3114 fatal_error ("failed to get process times: %m");
3119 for (i = 0; i < n_commands; ++i)
3121 int status = statuses[i];
3123 if (WIFSIGNALED (status))
3126 /* SIGPIPE is a special case. It happens in -pipe mode
3127 when the compiler dies before the preprocessor is done,
3128 or the assembler dies before the compiler is done.
3129 There's generally been an error already, and this is
3130 just fallout. So don't generate another error unless
3131 we would otherwise have succeeded. */
3132 if (WTERMSIG (status) == SIGPIPE
3133 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3140 internal_error ("%s (program %s)",
3141 strsignal (WTERMSIG (status)), commands[i].prog);
3143 else if (WIFEXITED (status)
3144 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3146 if (WEXITSTATUS (status) > greatest_status)
3147 greatest_status = WEXITSTATUS (status);
3151 if (report_times || report_times_to_file)
3153 struct pex_time *pt = ×[i];
3156 ut = ((double) pt->user_seconds
3157 + (double) pt->user_microseconds / 1.0e6);
3158 st = ((double) pt->system_seconds
3159 + (double) pt->system_microseconds / 1.0e6);
3164 fnotice (stderr, "# %s %.2f %.2f\n",
3165 commands[i].prog, ut, st);
3167 if (report_times_to_file)
3170 const char *const *j;
3172 fprintf (report_times_to_file, "%g %g", ut, st);
3174 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3177 for (p = *j; *p; ++p)
3178 if (*p == '"' || *p == '\\' || *p == '$'
3184 fprintf (report_times_to_file, " \"");
3185 for (p = *j; *p; ++p)
3187 if (*p == '"' || *p == '\\' || *p == '$')
3188 fputc ('\\', report_times_to_file);
3189 fputc (*p, report_times_to_file);
3191 fputc ('"', report_times_to_file);
3194 fprintf (report_times_to_file, " %s", *j);
3197 fputc ('\n', report_times_to_file);
3207 /* Find all the switches given to us
3208 and make a vector describing them.
3209 The elements of the vector are strings, one per switch given.
3210 If a switch uses following arguments, then the `part1' field
3211 is the switch itself and the `args' field
3212 is a null-terminated vector containing the following arguments.
3213 Bits in the `live_cond' field are:
3214 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3215 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3216 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3217 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3218 in all do_spec calls afterwards. Used for %<S from self specs.
3219 The `validated' field is nonzero if any spec has looked at this switch;
3220 if it remains zero at the end of the run, it must be meaningless. */
3222 #define SWITCH_LIVE 0x1
3223 #define SWITCH_FALSE 0x2
3224 #define SWITCH_IGNORE 0x4
3225 #define SWITCH_IGNORE_PERMANENTLY 0x8
3231 unsigned int live_cond;
3232 unsigned char validated;
3233 unsigned char ordering;
3236 static struct switchstr *switches;
3238 static int n_switches;
3240 static int n_switches_alloc;
3242 /* Set to zero if -fcompare-debug is disabled, positive if it's
3243 enabled and we're running the first compilation, negative if it's
3244 enabled and we're running the second compilation. For most of the
3245 time, it's in the range -1..1, but it can be temporarily set to 2
3246 or 3 to indicate that the -fcompare-debug flags didn't come from
3247 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3248 variable, until a synthesized -fcompare-debug flag is added to the
3252 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3253 int compare_debug_second;
3255 /* Set to the flags that should be passed to the second compilation in
3256 a -fcompare-debug compilation. */
3257 const char *compare_debug_opt;
3259 static struct switchstr *switches_debug_check[2];
3261 static int n_switches_debug_check[2];
3263 static char *debug_check_temp_file[2];
3265 /* Language is one of three things:
3267 1) The name of a real programming language.
3268 2) NULL, indicating that no one has figured out
3270 3) '*', indicating that the file should be passed
3275 const char *language;
3276 struct compiler *incompiler;
3281 /* Also a vector of input files specified. */
3283 static struct infile *infiles;
3287 static int n_infiles_alloc;
3289 /* True if multiple input files are being compiled to a single
3292 static bool combine_inputs;
3294 /* This counts the number of libraries added by lang_specific_driver, so that
3295 we can tell if there were any user supplied any files or libraries. */
3297 static int added_libraries;
3299 /* And a vector of corresponding output files is made up later. */
3301 const char **outfiles;
3303 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3305 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3306 is true if we should look for an executable suffix. DO_OBJ
3307 is true if we should look for an object suffix. */
3310 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3311 int do_obj ATTRIBUTE_UNUSED)
3313 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3321 len = strlen (name);
3323 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3324 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3325 if (do_obj && len > 2
3326 && name[len - 2] == '.'
3327 && name[len - 1] == 'o')
3329 obstack_grow (&obstack, name, len - 2);
3330 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3331 name = XOBFINISH (&obstack, const char *);
3335 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3336 /* If there is no filetype, make it the executable suffix (which includes
3337 the "."). But don't get confused if we have just "-o". */
3338 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3341 for (i = len - 1; i >= 0; i--)
3342 if (IS_DIR_SEPARATOR (name[i]))
3345 for (i++; i < len; i++)
3349 obstack_grow (&obstack, name, len);
3350 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3351 strlen (TARGET_EXECUTABLE_SUFFIX));
3352 name = XOBFINISH (&obstack, const char *);
3359 /* Display the command line switches accepted by gcc. */
3363 printf (_("Usage: %s [options] file...\n"), progname);
3364 fputs (_("Options:\n"), stdout);
3366 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3367 fputs (_(" --help Display this information\n"), stdout);
3368 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3369 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3370 fputs (_(" Display specific types of command line options\n"), stdout);
3372 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3373 fputs (_(" --version Display compiler version information\n"), stdout);
3374 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3375 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3376 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3377 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3378 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3379 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3380 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3381 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3383 -print-multi-lib Display the mapping between command line options and\n\
3384 multiple library search directories\n"), stdout);
3385 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3386 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3387 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3388 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3389 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3390 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3391 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3392 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3393 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3394 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3395 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3396 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3398 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3399 prefixes to other gcc components\n"), stdout);
3400 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3401 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3402 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3403 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3405 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3406 and libraries\n"), stdout);
3407 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3408 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3409 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3410 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3411 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3412 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3413 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3415 -x <language> Specify the language of the following input files\n\
3416 Permissible languages include: c c++ assembler none\n\
3417 'none' means revert to the default behavior of\n\
3418 guessing the language based on the file's extension\n\
3422 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3423 passed on to the various sub-processes invoked by %s. In order to pass\n\
3424 other options on to these processes the -W<letter> options must be used.\n\
3427 /* The rest of the options are displayed by invocations of the various
3432 add_preprocessor_option (const char *option, int len)
3434 n_preprocessor_options++;
3436 if (! preprocessor_options)
3437 preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3439 preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3440 n_preprocessor_options);
3442 preprocessor_options [n_preprocessor_options - 1] =
3443 save_string (option, len);
3447 add_assembler_option (const char *option, int len)
3449 n_assembler_options++;
3451 if (! assembler_options)
3452 assembler_options = XNEWVEC (char *, n_assembler_options);
3454 assembler_options = XRESIZEVEC (char *, assembler_options,
3455 n_assembler_options);
3457 assembler_options [n_assembler_options - 1] = save_string (option, len);
3461 add_linker_option (const char *option, int len)
3465 if (! linker_options)
3466 linker_options = XNEWVEC (char *, n_linker_options);
3468 linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3470 linker_options [n_linker_options - 1] = save_string (option, len);
3473 /* Allocate space for an input file in infiles. */
3478 if (n_infiles_alloc == 0)
3480 n_infiles_alloc = 16;
3481 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3483 else if (n_infiles_alloc == n_infiles)
3485 n_infiles_alloc *= 2;
3486 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3490 /* Store an input file with the given NAME and LANGUAGE in
3494 add_infile (const char *name, const char *language)
3497 infiles[n_infiles].name = name;
3498 infiles[n_infiles++].language = language;
3501 /* Allocate space for a switch in switches. */
3506 if (n_switches_alloc == 0)
3508 n_switches_alloc = 16;
3509 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3511 else if (n_switches_alloc == n_switches)
3513 n_switches_alloc *= 2;
3514 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3518 /* Create the vector `switches' and its contents.
3519 Store its length in `n_switches'. */
3522 process_command (int argc, const char **argv)
3527 const char *spec_lang = 0;
3528 int last_language_n_infiles;
3529 const char *tooldir_prefix;
3530 char *(*get_relative_prefix) (const char *, const char *,
3531 const char *) = NULL;
3533 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3537 added_libraries = 0;
3539 /* Figure compiler version from version string. */
3541 compiler_version = temp1 = xstrdup (version_string);
3543 for (; *temp1; ++temp1)
3552 /* Convert new-style -- options to old-style. */
3553 translate_options (&argc,
3554 CONST_CAST2 (const char *const **, const char ***,
3557 /* Handle any -no-canonical-prefixes flag early, to assign the function
3558 that builds relative prefixes. This function creates default search
3559 paths that are needed later in normal option handling. */
3561 for (i = 1; i < argc; i++)
3563 if (! strcmp (argv[i], "-no-canonical-prefixes"))
3565 get_relative_prefix = make_relative_prefix_ignore_links;
3569 if (! get_relative_prefix)
3570 get_relative_prefix = make_relative_prefix;
3572 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3573 see if we can create it from the pathname specified in argv[0]. */
3575 gcc_libexec_prefix = standard_libexec_prefix;
3577 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3578 if (!gcc_exec_prefix)
3580 gcc_exec_prefix = get_relative_prefix (argv[0],
3581 standard_bindir_prefix,
3582 standard_exec_prefix);
3583 gcc_libexec_prefix = get_relative_prefix (argv[0],
3584 standard_bindir_prefix,
3585 standard_libexec_prefix);
3586 if (gcc_exec_prefix)
3587 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3591 /* make_relative_prefix requires a program name, but
3592 GCC_EXEC_PREFIX is typically a directory name with a trailing
3593 / (which is ignored by make_relative_prefix), so append a
3595 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3596 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3597 standard_exec_prefix,
3598 standard_libexec_prefix);
3600 /* The path is unrelocated, so fallback to the original setting. */
3601 if (!gcc_libexec_prefix)
3602 gcc_libexec_prefix = standard_libexec_prefix;
3608 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3609 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3610 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3612 /* Do language-specific adjustment/addition of flags. */
3613 lang_specific_driver (&argc,
3614 CONST_CAST2 (const char *const **, const char ***,
3618 if (gcc_exec_prefix)
3620 int len = strlen (gcc_exec_prefix);
3622 if (len > (int) sizeof ("/lib/gcc/") - 1
3623 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3625 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3626 if (IS_DIR_SEPARATOR (*temp)
3627 && strncmp (temp + 1, "lib", 3) == 0
3628 && IS_DIR_SEPARATOR (temp[4])
3629 && strncmp (temp + 5, "gcc", 3) == 0)
3630 len -= sizeof ("/lib/gcc/") - 1;
3633 set_std_prefix (gcc_exec_prefix, len);
3634 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3635 PREFIX_PRIORITY_LAST, 0, 0);
3636 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3637 PREFIX_PRIORITY_LAST, 0, 0);
3640 /* COMPILER_PATH and LIBRARY_PATH have values
3641 that are lists of directory names with colons. */
3643 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3646 const char *startp, *endp;
3647 char *nstore = (char *) alloca (strlen (temp) + 3);
3649 startp = endp = temp;
3652 if (*endp == PATH_SEPARATOR || *endp == 0)
3654 strncpy (nstore, startp, endp - startp);
3656 strcpy (nstore, concat (".", dir_separator_str, NULL));
3657 else if (!IS_DIR_SEPARATOR (endp[-1]))
3659 nstore[endp - startp] = DIR_SEPARATOR;
3660 nstore[endp - startp + 1] = 0;
3663 nstore[endp - startp] = 0;
3664 add_prefix (&exec_prefixes, nstore, 0,
3665 PREFIX_PRIORITY_LAST, 0, 0);
3666 add_prefix (&include_prefixes, nstore, 0,
3667 PREFIX_PRIORITY_LAST, 0, 0);
3670 endp = startp = endp + 1;
3677 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3678 if (temp && *cross_compile == '0')
3680 const char *startp, *endp;
3681 char *nstore = (char *) alloca (strlen (temp) + 3);
3683 startp = endp = temp;
3686 if (*endp == PATH_SEPARATOR || *endp == 0)
3688 strncpy (nstore, startp, endp - startp);
3690 strcpy (nstore, concat (".", dir_separator_str, NULL));
3691 else if (!IS_DIR_SEPARATOR (endp[-1]))
3693 nstore[endp - startp] = DIR_SEPARATOR;
3694 nstore[endp - startp + 1] = 0;
3697 nstore[endp - startp] = 0;
3698 add_prefix (&startfile_prefixes, nstore, NULL,
3699 PREFIX_PRIORITY_LAST, 0, 1);
3702 endp = startp = endp + 1;
3709 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3710 GET_ENVIRONMENT (temp, "LPATH");
3711 if (temp && *cross_compile == '0')
3713 const char *startp, *endp;
3714 char *nstore = (char *) alloca (strlen (temp) + 3);
3716 startp = endp = temp;
3719 if (*endp == PATH_SEPARATOR || *endp == 0)
3721 strncpy (nstore, startp, endp - startp);
3723 strcpy (nstore, concat (".", dir_separator_str, NULL));
3724 else if (!IS_DIR_SEPARATOR (endp[-1]))
3726 nstore[endp - startp] = DIR_SEPARATOR;
3727 nstore[endp - startp + 1] = 0;
3730 nstore[endp - startp] = 0;
3731 add_prefix (&startfile_prefixes, nstore, NULL,
3732 PREFIX_PRIORITY_LAST, 0, 1);
3735 endp = startp = endp + 1;
3742 /* Process the options and store input files and switches in their
3745 last_language_n_infiles = -1;
3747 for (i = 1; i < argc; i++)
3749 const char *p = NULL;
3752 if (argv[i][0] == '-' && argv[i][1] != 0)
3758 if (! strcmp (argv[i], "-dumpspecs"))
3760 struct spec_list *sl;
3762 for (sl = specs; sl; sl = sl->next)
3763 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3764 if (link_command_spec)
3765 printf ("*link_command:\n%s\n\n", link_command_spec);
3768 else if (! strcmp (argv[i], "-dumpversion"))
3770 printf ("%s\n", spec_version);
3773 else if (! strcmp (argv[i], "-dumpmachine"))
3775 printf ("%s\n", spec_machine);
3778 else if (strcmp (argv[i], "-fversion") == 0)
3780 /* translate_options () has turned --version into -fversion. */
3783 /* CPP driver cannot obtain switch from cc1_options. */
3785 add_preprocessor_option ("--version", strlen ("--version"));
3786 add_assembler_option ("--version", strlen ("--version"));
3787 add_linker_option ("--version", strlen ("--version"));
3791 else if (strcmp (argv[i], "-fhelp") == 0)
3793 /* translate_options () has turned --help into -fhelp. */
3794 print_help_list = 1;
3796 /* CPP driver cannot obtain switch from cc1_options. */
3798 add_preprocessor_option ("--help", 6);
3799 add_assembler_option ("--help", 6);
3800 add_linker_option ("--help", 6);
3804 else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3806 /* translate_options () has turned --help into -fhelp. */
3807 print_subprocess_help = 2;
3811 else if (strcmp (argv[i], "-ftarget-help") == 0)
3813 /* translate_options() has turned --target-help into -ftarget-help. */
3814 print_subprocess_help = 1;
3816 /* CPP driver cannot obtain switch from cc1_options. */
3818 add_preprocessor_option ("--target-help", 13);
3819 add_assembler_option ("--target-help", 13);
3820 add_linker_option ("--target-help", 13);
3824 else if (! strcmp (argv[i], "-pass-exit-codes"))
3826 pass_exit_codes = 1;
3828 else if (! strcmp (argv[i], "-print-search-dirs"))
3829 print_search_dirs = 1;
3830 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3831 print_file_name = "libgcc.a";
3832 else if (! strncmp (argv[i], "-print-file-name=", 17))
3833 print_file_name = argv[i] + 17;
3834 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3835 print_prog_name = argv[i] + 17;
3836 else if (! strcmp (argv[i], "-print-multi-lib"))
3837 print_multi_lib = 1;
3838 else if (! strcmp (argv[i], "-print-multi-directory"))
3839 print_multi_directory = 1;
3840 else if (! strcmp (argv[i], "-print-sysroot"))
3842 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3843 print_multi_os_directory = 1;
3844 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3845 print_sysroot_headers_suffix = 1;
3846 else if (! strcmp (argv[i], "-fcompare-debug-second"))
3848 compare_debug_second = 1;
3851 else if (! strcmp (argv[i], "-fno-compare-debug"))
3853 argv[i] = "-fcompare-debug=";
3855 goto compare_debug_with_arg;
3857 else if (! strcmp (argv[i], "-fcompare-debug"))
3859 argv[i] = "-fcompare-debug=-gtoggle";
3861 goto compare_debug_with_arg;
3863 #define OPT "-fcompare-debug="
3864 else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3867 compare_debug_with_arg:
3868 opt = argv[i] + sizeof (OPT) - 1;
3874 if (compare_debug < 0)
3875 compare_debug_opt = NULL;
3877 compare_debug_opt = opt;
3880 else if (! strncmp (argv[i], "-Wa,", 4))
3883 /* Pass the rest of this option to the assembler. */
3885 /* Split the argument at commas. */
3887 for (j = 4; argv[i][j]; j++)
3888 if (argv[i][j] == ',')
3890 add_assembler_option (argv[i] + prev, j - prev);
3894 /* Record the part after the last comma. */
3895 add_assembler_option (argv[i] + prev, j - prev);
3897 else if (! strncmp (argv[i], "-Wp,", 4))
3900 /* Pass the rest of this option to the preprocessor. */
3902 /* Split the argument at commas. */
3904 for (j = 4; argv[i][j]; j++)
3905 if (argv[i][j] == ',')
3907 add_preprocessor_option (argv[i] + prev, j - prev);
3911 /* Record the part after the last comma. */
3912 add_preprocessor_option (argv[i] + prev, j - prev);
3914 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3917 /* Split the argument at commas. */
3919 for (j = 4; argv[i][j]; j++)
3920 if (argv[i][j] == ',')
3922 add_infile (save_string (argv[i] + prev, j - prev), "*");
3925 /* Record the part after the last comma. */
3926 add_infile (argv[i] + prev, "*");
3928 else if (strcmp (argv[i], "-Xlinker") == 0)
3931 fatal_error ("argument to %<-Xlinker%> is missing");
3933 add_infile (argv[i+1], "*");
3936 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3939 fatal_error ("argument to %<-Xpreprocessor%> is missing");
3941 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3944 else if (strcmp (argv[i], "-Xassembler") == 0)
3947 fatal_error ("argument to %<-Xassembler%> is missing");
3949 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3952 else if (strcmp (argv[i], "-l") == 0)
3955 fatal_error ("argument to %<-l%> is missing");
3957 /* POSIX allows separation of -l and the lib arg;
3958 canonicalize by concatenating -l with its arg */
3959 add_infile (concat ("-l", argv[i + 1], NULL), "*");
3962 else if (strncmp (argv[i], "-l", 2) == 0)
3964 add_infile (argv[i], "*");
3966 else if (strcmp (argv[i], "-save-temps") == 0)
3968 save_temps_flag = SAVE_TEMPS_CWD;
3971 else if (strncmp (argv[i], "-save-temps=", 12) == 0)
3973 if (strcmp (argv[i]+12, "cwd") == 0)
3974 save_temps_flag = SAVE_TEMPS_CWD;
3975 else if (strcmp (argv[i]+12, "obj") == 0
3976 || strcmp (argv[i]+12, "object") == 0)
3977 save_temps_flag = SAVE_TEMPS_OBJ;
3979 fatal_error ("%qs is an unknown -save-temps option", argv[i]);
3982 else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
3983 /* Already handled as a special case, so ignored here. */
3985 else if (strcmp (argv[i], "-combine") == 0)
3990 else if (strcmp (argv[i], "-specs") == 0)
3992 struct user_specs *user = XNEW (struct user_specs);
3994 fatal_error ("argument to %<-specs%> is missing");
3996 user->next = (struct user_specs *) 0;
3997 user->filename = argv[i];
3998 if (user_specs_tail)
3999 user_specs_tail->next = user;
4001 user_specs_head = user;
4002 user_specs_tail = user;
4004 else if (strncmp (argv[i], "-specs=", 7) == 0)
4006 struct user_specs *user = XNEW (struct user_specs);
4007 if (strlen (argv[i]) == 7)
4008 fatal_error ("argument to %<-specs=%> is missing");
4010 user->next = (struct user_specs *) 0;
4011 user->filename = argv[i] + 7;
4012 if (user_specs_tail)
4013 user_specs_tail->next = user;
4015 user_specs_head = user;
4016 user_specs_tail = user;
4018 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4020 target_system_root = argv[i] + strlen ("--sysroot=");
4021 target_system_root_changed = 1;
4023 else if (strcmp (argv[i], "-time") == 0)
4025 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4027 if (report_times_to_file)
4028 fclose (report_times_to_file);
4029 report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
4031 else if (strcmp (argv[i], "-pipe") == 0)
4033 /* -pipe has to go into the switches array as well as
4038 else if (strcmp (argv[i], "-wrapper") == 0)
4041 fatal_error ("argument to %<-wrapper%> is missing");
4043 wrapper_string = argv[i];
4045 else if (strcmp (argv[i], "-###") == 0)
4047 /* This is similar to -v except that there is no execution
4048 of the commands and the echoed arguments are quoted. It
4049 is intended for use in shell scripts to capture the
4050 driver-generated command line. */
4051 verbose_only_flag++;
4054 else if (argv[i][0] == '-' && argv[i][1] != 0)
4063 if (p[1] == 0 && i + 1 == argc)
4064 fatal_error ("argument to %<-B%> is missing");
4066 value = argv[i + 1];
4070 len = strlen (value);
4072 /* Catch the case where the user has forgotten to append a
4073 directory separator to the path. Note, they may be using
4074 -B to add an executable name prefix, eg "i386-elf-", in
4075 order to distinguish between multiple installations of
4076 GCC in the same directory. Hence we must check to see
4077 if appending a directory separator actually makes a
4078 valid directory name. */
4079 if (! IS_DIR_SEPARATOR (value [len - 1])
4080 && is_directory (value, false))
4082 char *tmp = XNEWVEC (char, len + 2);
4083 strcpy (tmp, value);
4084 tmp[len] = DIR_SEPARATOR;
4089 add_prefix (&exec_prefixes, value, NULL,
4090 PREFIX_PRIORITY_B_OPT, 0, 0);
4091 add_prefix (&startfile_prefixes, value, NULL,
4092 PREFIX_PRIORITY_B_OPT, 0, 0);
4093 add_prefix (&include_prefixes, value, NULL,
4094 PREFIX_PRIORITY_B_OPT, 0, 0);
4098 case 'v': /* Print our subcommands and print versions. */
4099 /* If they do anything other than exactly `-v', don't set
4100 verbose_flag; rather, continue on to give the error. */
4107 if (p[1] == 0 && i + 1 == argc)
4108 fatal_error ("argument to %<-x%> is missing");
4110 spec_lang = argv[++i];
4113 if (! strcmp (spec_lang, "none"))
4114 /* Suppress the warning if -xnone comes after the last input
4115 file, because alternate command interfaces like g++ might
4116 find it useful to place -xnone after each input file. */
4119 last_language_n_infiles = n_infiles;
4131 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4136 /* Forward scan, just in case -S, -E or -c is specified
4143 if (argv[j][0] == '-')
4145 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4151 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4152 j += skip - (argv[j][2] != 0);
4153 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4160 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4162 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4165 argv[i] = convert_filename (argv[i], ! have_c, 0);
4169 /* Save the output name in case -save-temps=obj was used. */
4170 if ((p[1] == 0) && argv[i + 1])
4171 save_temps_prefix = xstrdup(argv[i + 1]);
4173 save_temps_prefix = xstrdup(argv[i] + 1);
4180 switches[n_switches].part1 = p;
4181 /* Deal with option arguments in separate argv elements. */
4182 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4183 || WORD_SWITCH_TAKES_ARG (p))
4186 int n_args = WORD_SWITCH_TAKES_ARG (p);
4190 /* Count only the option arguments in separate
4192 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4194 if (i + n_args >= argc)
4195 fatal_error ("argument to %<-%s%> is missing", p);
4196 switches[n_switches].args
4197 = XNEWVEC (const char *, n_args + 1);
4199 switches[n_switches].args[j++] = argv[++i];
4200 /* Null-terminate the vector. */
4201 switches[n_switches].args[j] = 0;
4205 /* On some systems, ld cannot handle "-o" without
4206 a space. So split the option from its argument. */
4207 char *part1 = XNEWVEC (char, 2);
4211 switches[n_switches].part1 = part1;
4212 switches[n_switches].args = XNEWVEC (const char *, 2);
4213 switches[n_switches].args[0] = xstrdup (p+1);
4214 switches[n_switches].args[1] = 0;
4217 switches[n_switches].args = 0;
4219 switches[n_switches].live_cond = 0;
4220 switches[n_switches].validated = 0;
4221 switches[n_switches].ordering = 0;
4222 /* These are always valid, since gcc.c itself understands the
4223 first four, gfortranspec.c understands -static-libgfortran
4224 and g++spec.c understands -static-libstdc++ */
4225 if (!strcmp (p, "save-temps")
4226 || !strcmp (p, "static-libgcc")
4227 || !strcmp (p, "shared-libgcc")
4228 || !strcmp (p, "pipe")
4229 || !strcmp (p, "static-libgfortran")
4230 || !strcmp (p, "static-libstdc++"))
4231 switches[n_switches].validated = 1;
4234 char ch = switches[n_switches].part1[0];
4236 switches[n_switches].validated = 1;
4243 const char *p = strrchr (argv[i], '@');
4247 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4248 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4250 /* For LTO static archive support we handle input file
4251 specifications that are composed of a filename and
4252 an offset like FNAME@OFFSET. */
4255 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4256 && strlen (p) == (unsigned int)consumed)
4258 fname = (char *)xmalloc (p - argv[i] + 1);
4259 memcpy (fname, argv[i], p - argv[i]);
4260 fname[p - argv[i]] = '\0';
4261 /* Only accept non-stdin and existing FNAME parts, otherwise
4262 try with the full name. */
4263 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4266 fname = xstrdup (argv[i]);
4270 fname = xstrdup (argv[i]);
4272 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4273 perror_with_name (fname);
4275 add_infile (argv[i], spec_lang);
4281 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4282 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4283 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4285 save_temps_length = strlen (save_temps_prefix);
4286 temp = strrchr (lbasename (save_temps_prefix), '.');
4289 save_temps_length -= strlen (temp);
4290 save_temps_prefix[save_temps_length] = '\0';
4294 else if (save_temps_prefix != NULL)
4296 free (save_temps_prefix);
4297 save_temps_prefix = NULL;
4300 if (save_temps_flag && use_pipes)
4302 /* -save-temps overrides -pipe, so that temp files are produced */
4303 if (save_temps_flag)
4304 warning (0, "-pipe ignored because -save-temps specified");
4310 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4312 if (gcd && gcd[0] == '-')
4315 compare_debug_opt = gcd;
4317 else if (gcd && *gcd && strcmp (gcd, "0"))
4320 compare_debug_opt = "-gtoggle";
4323 else if (compare_debug < 0)
4326 gcc_assert (!compare_debug_opt);
4329 /* Set up the search paths. We add directories that we expect to
4330 contain GNU Toolchain components before directories specified by
4331 the machine description so that we will find GNU components (like
4332 the GNU assembler) before those of the host system. */
4334 /* If we don't know where the toolchain has been installed, use the
4335 configured-in locations. */
4336 if (!gcc_exec_prefix)
4339 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4340 PREFIX_PRIORITY_LAST, 1, 0);
4341 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4342 PREFIX_PRIORITY_LAST, 2, 0);
4343 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4344 PREFIX_PRIORITY_LAST, 2, 0);
4346 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4347 PREFIX_PRIORITY_LAST, 1, 0);
4350 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4351 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4352 dir_separator_str, NULL);
4354 /* Look for tools relative to the location from which the driver is
4355 running, or, if that is not available, the configured prefix. */
4357 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4358 spec_machine, dir_separator_str,
4359 spec_version, dir_separator_str, tooldir_prefix, NULL);
4361 add_prefix (&exec_prefixes,
4362 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4363 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4364 add_prefix (&startfile_prefixes,
4365 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4366 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4368 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4369 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4370 then consider it to relocate with the rest of the GCC installation
4371 if GCC_EXEC_PREFIX is set.
4372 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4373 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4375 char *tmp_prefix = get_relative_prefix (argv[0],
4376 standard_bindir_prefix,
4377 target_system_root);
4378 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4380 target_system_root = tmp_prefix;
4381 target_system_root_changed = 1;
4386 /* More prefixes are enabled in main, after we read the specs file
4387 and determine whether this is cross-compilation or not. */
4389 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4390 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4392 if (compare_debug == 2 || compare_debug == 3)
4395 switches[n_switches].part1 = concat ("fcompare-debug=",
4398 switches[n_switches].args = 0;
4399 switches[n_switches].live_cond = 0;
4400 switches[n_switches].validated = 0;
4401 switches[n_switches].ordering = 0;
4406 /* Ensure we only invoke each subprocess once. */
4407 if (print_subprocess_help || print_help_list || print_version)
4411 /* Create a dummy input file, so that we can pass
4412 the help option on to the various sub-processes. */
4413 add_infile ("help-dummy", "c");
4417 switches[n_switches].part1 = 0;
4419 infiles[n_infiles].name = 0;
4422 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4423 and place that in the environment. */
4426 set_collect_gcc_options (void)
4431 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4433 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4434 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4437 for (i = 0; (int) i < n_switches; i++)
4439 const char *const *args;
4442 obstack_grow (&collect_obstack, " ", 1);
4446 /* Ignore elided switches. */
4447 if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4450 obstack_grow (&collect_obstack, "'-", 2);
4451 q = switches[i].part1;
4452 while ((p = strchr (q, '\'')))
4454 obstack_grow (&collect_obstack, q, p - q);
4455 obstack_grow (&collect_obstack, "'\\''", 4);
4458 obstack_grow (&collect_obstack, q, strlen (q));
4459 obstack_grow (&collect_obstack, "'", 1);
4461 for (args = switches[i].args; args && *args; args++)
4463 obstack_grow (&collect_obstack, " '", 2);
4465 while ((p = strchr (q, '\'')))
4467 obstack_grow (&collect_obstack, q, p - q);
4468 obstack_grow (&collect_obstack, "'\\''", 4);
4471 obstack_grow (&collect_obstack, q, strlen (q));
4472 obstack_grow (&collect_obstack, "'", 1);
4475 obstack_grow (&collect_obstack, "\0", 1);
4476 xputenv (XOBFINISH (&collect_obstack, char *));
4479 /* Process a spec string, accumulating and running commands. */
4481 /* These variables describe the input file name.
4482 input_file_number is the index on outfiles of this file,
4483 so that the output file name can be stored for later use by %o.
4484 input_basename is the start of the part of the input file
4485 sans all directory names, and basename_length is the number
4486 of characters starting there excluding the suffix .c or whatever. */
4488 static const char *gcc_input_filename;
4489 static int input_file_number;
4490 size_t input_filename_length;
4491 static int basename_length;
4492 static int suffixed_basename_length;
4493 static const char *input_basename;
4494 static const char *input_suffix;
4495 #ifndef HOST_LACKS_INODE_NUMBERS
4496 static struct stat input_stat;
4498 static int input_stat_set;
4500 /* The compiler used to process the current input file. */
4501 static struct compiler *input_file_compiler;
4503 /* These are variables used within do_spec and do_spec_1. */
4505 /* Nonzero if an arg has been started and not yet terminated
4506 (with space, tab or newline). */
4507 static int arg_going;
4509 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4510 is a temporary file name. */
4511 static int delete_this_arg;
4513 /* Nonzero means %w has been seen; the next arg to be terminated
4514 is the output file name of this compilation. */
4515 static int this_is_output_file;
4517 /* Nonzero means %s has been seen; the next arg to be terminated
4518 is the name of a library file and we should try the standard
4519 search dirs for it. */
4520 static int this_is_library_file;
4522 /* Nonzero means %T has been seen; the next arg to be terminated
4523 is the name of a linker script and we should try all of the
4524 standard search dirs for it. If it is found insert a --script
4525 command line switch and then substitute the full path in place,
4526 otherwise generate an error message. */
4527 static int this_is_linker_script;
4529 /* Nonzero means that the input of this command is coming from a pipe. */
4530 static int input_from_pipe;
4532 /* Nonnull means substitute this for any suffix when outputting a switches
4534 static const char *suffix_subst;
4536 /* If there is an argument being accumulated, terminate it and store it. */
4539 end_going_arg (void)
4545 obstack_1grow (&obstack, 0);
4546 string = XOBFINISH (&obstack, const char *);
4547 if (this_is_library_file)
4548 string = find_file (string);
4549 if (this_is_linker_script)
4551 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4553 if (full_script_path == NULL)
4555 error ("unable to locate default linker script %qs in the library search paths", string);
4556 /* Script was not found on search path. */
4559 store_arg ("--script", false, false);
4560 string = full_script_path;
4562 store_arg (string, delete_this_arg, this_is_output_file);
4563 if (this_is_output_file)
4564 outfiles[input_file_number] = string;
4570 /* Parse the WRAPPER string which is a comma separated list of the command line
4571 and insert them into the beginning of argbuf. */
4574 insert_wrapper (const char *wrapper)
4578 char *buf = xstrdup (wrapper);
4587 while ((p = strchr (p, ',')) != NULL);
4589 if (argbuf_index + n >= argbuf_length)
4591 argbuf_length = argbuf_length * 2;
4592 while (argbuf_length < argbuf_index + n)
4594 argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4596 for (i = argbuf_index - 1; i >= 0; i--)
4597 argbuf[i + n] = argbuf[i];
4610 while ((p = strchr (p, ',')) != NULL);
4611 gcc_assert (i == n);
4615 /* Process the spec SPEC and run the commands specified therein.
4616 Returns 0 if the spec is successfully processed; -1 if failed. */
4619 do_spec (const char *spec)
4623 value = do_spec_2 (spec);
4625 /* Force out any unfinished command.
4626 If -pipe, this forces out the last command if it ended in `|'. */
4629 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4632 set_collect_gcc_options ();
4634 if (argbuf_index > 0)
4642 do_spec_2 (const char *spec)
4648 delete_this_arg = 0;
4649 this_is_output_file = 0;
4650 this_is_library_file = 0;
4651 this_is_linker_script = 0;
4652 input_from_pipe = 0;
4653 suffix_subst = NULL;
4655 result = do_spec_1 (spec, 0, NULL);
4663 /* Process the given spec string and add any new options to the end
4664 of the switches/n_switches array. */
4667 do_option_spec (const char *name, const char *spec)
4669 unsigned int i, value_count, value_len;
4670 const char *p, *q, *value;
4671 char *tmp_spec, *tmp_spec_p;
4673 if (configure_default_options[0].name == NULL)
4676 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4677 if (strcmp (configure_default_options[i].name, name) == 0)
4679 if (i == ARRAY_SIZE (configure_default_options))
4682 value = configure_default_options[i].value;
4683 value_len = strlen (value);
4685 /* Compute the size of the final spec. */
4688 while ((p = strstr (p, "%(VALUE)")) != NULL)
4694 /* Replace each %(VALUE) by the specified value. */
4695 tmp_spec = (char *) alloca (strlen (spec) + 1
4696 + value_count * (value_len - strlen ("%(VALUE)")));
4697 tmp_spec_p = tmp_spec;
4699 while ((p = strstr (q, "%(VALUE)")) != NULL)
4701 memcpy (tmp_spec_p, q, p - q);
4702 tmp_spec_p = tmp_spec_p + (p - q);
4703 memcpy (tmp_spec_p, value, value_len);
4704 tmp_spec_p += value_len;
4705 q = p + strlen ("%(VALUE)");
4707 strcpy (tmp_spec_p, q);
4709 do_self_spec (tmp_spec);
4712 /* Process the given spec string and add any new options to the end
4713 of the switches/n_switches array. */
4716 do_self_spec (const char *spec)
4721 do_spec_1 (" ", 0, NULL);
4723 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4724 do_self_specs adds the replacements to switches array, so it shouldn't
4725 be processed afterwards. */
4726 for (i = 0; i < n_switches; i++)
4727 if ((switches[i].live_cond & SWITCH_IGNORE))
4728 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4730 if (argbuf_index > 0)
4732 switches = XRESIZEVEC (struct switchstr, switches,
4733 n_switches + argbuf_index + 1);
4735 for (i = 0; i < argbuf_index; i++)
4737 struct switchstr *sw;
4738 const char *p = argbuf[i];
4741 /* Each switch should start with '-'. */
4743 fatal_error ("switch %qs does not start with %<-%>", argbuf[i]);
4748 sw = &switches[n_switches++];
4754 /* Deal with option arguments in separate argv elements. */
4755 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4756 || WORD_SWITCH_TAKES_ARG (p))
4759 int n_args = WORD_SWITCH_TAKES_ARG (p);
4763 /* Count only the option arguments in separate argv elements. */
4764 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4766 if (i + n_args >= argbuf_index)
4767 fatal_error ("argument to %<-%s%> is missing", p);
4769 = XNEWVEC (const char *, n_args + 1);
4771 sw->args[j++] = argbuf[++i];
4772 /* Null-terminate the vector. */
4777 /* On some systems, ld cannot handle "-o" without
4778 a space. So split the option from its argument. */
4779 char *part1 = XNEWVEC (char, 2);
4784 sw->args = XNEWVEC (const char *, 2);
4785 sw->args[0] = xstrdup (p+1);
4792 switches[n_switches].part1 = 0;
4796 /* Callback for processing %D and %I specs. */
4798 struct spec_path_info {
4803 bool separate_options;
4807 spec_path (char *path, void *data)
4809 struct spec_path_info *info = (struct spec_path_info *) data;
4813 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4816 if (info->append_len != 0)
4818 len = strlen (path);
4819 memcpy (path + len, info->append, info->append_len + 1);
4822 if (!is_directory (path, true))
4825 do_spec_1 (info->option, 1, NULL);
4826 if (info->separate_options)
4827 do_spec_1 (" ", 0, NULL);
4829 if (info->append_len == 0)
4831 len = strlen (path);
4832 save = path[len - 1];
4833 if (IS_DIR_SEPARATOR (path[len - 1]))
4834 path[len - 1] = '\0';
4837 do_spec_1 (path, 1, NULL);
4838 do_spec_1 (" ", 0, NULL);
4840 /* Must not damage the original path. */
4841 if (info->append_len == 0)
4842 path[len - 1] = save;
4847 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4851 create_at_file (char **argv)
4853 char *temp_file = make_temp_file ("");
4854 char *at_argument = concat ("@", temp_file, NULL);
4855 FILE *f = fopen (temp_file, "w");
4859 fatal_error ("could not open temporary response file %s",
4862 status = writeargv (argv, f);
4865 fatal_error ("could not write to temporary response file %s",
4868 status = fclose (f);
4871 fatal_error ("could not close temporary response file %s",
4874 store_arg (at_argument, 0, 0);
4876 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4879 /* True if we should compile INFILE. */
4882 compile_input_file_p (struct infile *infile)
4884 if ((!infile->language) || (infile->language[0] != '*'))
4885 if (infile->incompiler == input_file_compiler)
4890 /* Process the sub-spec SPEC as a portion of a larger spec.
4891 This is like processing a whole spec except that we do
4892 not initialize at the beginning and we do not supply a
4893 newline by default at the end.
4894 INSWITCH nonzero means don't process %-sequences in SPEC;
4895 in this case, % is treated as an ordinary character.
4896 This is used while substituting switches.
4897 INSWITCH nonzero also causes SPC not to terminate an argument.
4899 Value is zero unless a line was finished
4900 and the command on that line reported an error. */
4903 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4905 const char *p = spec;
4911 /* If substituting a switch, treat all chars like letters.
4912 Otherwise, NL, SPC, TAB and % are special. */
4913 switch (inswitch ? 'a' : c)
4918 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4920 /* A `|' before the newline means use a pipe here,
4921 but only if -pipe was specified.
4922 Otherwise, execute now and don't pass the `|' as an arg. */
4925 input_from_pipe = 1;
4932 set_collect_gcc_options ();
4934 if (argbuf_index > 0)
4940 /* Reinitialize for a new command, and for a new argument. */
4943 delete_this_arg = 0;
4944 this_is_output_file = 0;
4945 this_is_library_file = 0;
4946 this_is_linker_script = 0;
4947 input_from_pipe = 0;
4954 obstack_1grow (&obstack, c);
4962 /* Reinitialize for a new argument. */
4963 delete_this_arg = 0;
4964 this_is_output_file = 0;
4965 this_is_library_file = 0;
4966 this_is_linker_script = 0;
4973 fatal_error ("spec %qs invalid", spec);
4976 if (save_temps_length)
4977 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4979 obstack_grow (&obstack, input_basename, basename_length);
4980 if (compare_debug < 0)
4981 obstack_grow (&obstack, ".gk", 3);
4986 if (save_temps_length)
4987 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4989 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4990 if (compare_debug < 0)
4991 obstack_grow (&obstack, ".gk", 3);
4996 delete_this_arg = 2;
4999 /* Dump out the directories specified with LIBRARY_PATH,
5000 followed by the absolute directories
5001 that we search for startfiles. */
5004 struct spec_path_info info;
5007 info.append_len = 0;
5008 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5009 /* Used on systems which record the specified -L dirs
5010 and use them to search for dynamic linking.
5011 Relative directories always come from -B,
5012 and it is better not to use them for searching
5013 at run time. In particular, stage1 loses. */
5014 info.omit_relative = true;
5016 info.omit_relative = false;
5018 info.separate_options = false;
5020 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5025 /* %efoo means report an error with `foo' as error message
5026 and don't execute any more commands for this file. */
5030 while (*p != 0 && *p != '\n')
5032 buf = (char *) alloca (p - q + 1);
5033 strncpy (buf, q, p - q);
5035 error ("%s", _(buf));
5040 /* %nfoo means report a notice with `foo' on stderr. */
5044 while (*p != 0 && *p != '\n')
5046 buf = (char *) alloca (p - q + 1);
5047 strncpy (buf, q, p - q);
5049 inform (0, "%s", _(buf));
5059 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5060 defined, and it is not a directory, and it is
5061 writable, use it. Otherwise, treat this like any
5062 other temporary file. */
5064 if ((!save_temps_flag)
5065 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5066 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5068 obstack_grow (&obstack, HOST_BIT_BUCKET,
5069 strlen (HOST_BIT_BUCKET));
5070 delete_this_arg = 0;
5075 goto create_temp_file;
5079 obstack_1grow (&obstack, '-');
5080 delete_this_arg = 0;
5083 /* consume suffix */
5084 while (*p == '.' || ISALNUM ((unsigned char) *p))
5086 if (p[0] == '%' && p[1] == 'O')
5091 goto create_temp_file;
5095 /* consume suffix */
5096 while (*p == '.' || ISALNUM ((unsigned char) *p))
5098 if (p[0] == '%' && p[1] == 'O')
5103 goto create_temp_file;
5109 struct temp_name *t;
5111 const char *suffix = p;
5112 char *saved_suffix = NULL;
5114 while (*p == '.' || ISALNUM ((unsigned char) *p))
5116 suffix_length = p - suffix;
5117 if (p[0] == '%' && p[1] == 'O')
5120 /* We don't support extra suffix characters after %O. */
5121 if (*p == '.' || ISALNUM ((unsigned char) *p))
5122 fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
5123 if (suffix_length == 0)
5124 suffix = TARGET_OBJECT_SUFFIX;
5128 = XNEWVEC (char, suffix_length
5129 + strlen (TARGET_OBJECT_SUFFIX));
5130 strncpy (saved_suffix, suffix, suffix_length);
5131 strcpy (saved_suffix + suffix_length,
5132 TARGET_OBJECT_SUFFIX);
5134 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5137 if (compare_debug < 0)
5139 suffix = concat (".gk", suffix, NULL);
5143 /* If -save-temps=obj and -o were specified, use that for the
5145 if (save_temps_length)
5148 temp_filename_length
5149 = save_temps_length + suffix_length + 1;
5150 tmp = (char *) alloca (temp_filename_length);
5151 memcpy (tmp, save_temps_prefix, save_temps_length);
5152 memcpy (tmp + save_temps_length, suffix, suffix_length);
5153 tmp[save_temps_length + suffix_length] = '\0';
5154 temp_filename = save_string (tmp,
5155 temp_filename_length + 1);
5156 obstack_grow (&obstack, temp_filename,
5157 temp_filename_length);
5159 delete_this_arg = 0;
5163 /* If the gcc_input_filename has the same suffix specified
5164 for the %g, %u, or %U, and -save-temps is specified,
5165 we could end up using that file as an intermediate
5166 thus clobbering the user's source file (.e.g.,
5167 gcc -save-temps foo.s would clobber foo.s with the
5168 output of cpp0). So check for this condition and
5169 generate a temp file as the intermediate. */
5171 if (save_temps_flag)
5174 temp_filename_length = basename_length + suffix_length + 1;
5175 tmp = (char *) alloca (temp_filename_length);
5176 memcpy (tmp, input_basename, basename_length);
5177 memcpy (tmp + basename_length, suffix, suffix_length);
5178 tmp[basename_length + suffix_length] = '\0';
5179 temp_filename = tmp;
5181 if (strcmp (temp_filename, gcc_input_filename) != 0)
5183 #ifndef HOST_LACKS_INODE_NUMBERS
5184 struct stat st_temp;
5186 /* Note, set_input() resets input_stat_set to 0. */
5187 if (input_stat_set == 0)
5189 input_stat_set = stat (gcc_input_filename,
5191 if (input_stat_set >= 0)
5195 /* If we have the stat for the gcc_input_filename
5196 and we can do the stat for the temp_filename
5197 then the they could still refer to the same
5198 file if st_dev/st_ino's are the same. */
5199 if (input_stat_set != 1
5200 || stat (temp_filename, &st_temp) < 0
5201 || input_stat.st_dev != st_temp.st_dev
5202 || input_stat.st_ino != st_temp.st_ino)
5204 /* Just compare canonical pathnames. */
5205 char* input_realname = lrealpath (gcc_input_filename);
5206 char* temp_realname = lrealpath (temp_filename);
5207 bool files_differ = strcmp (input_realname, temp_realname);
5208 free (input_realname);
5209 free (temp_realname);
5213 temp_filename = save_string (temp_filename,
5214 temp_filename_length + 1);
5215 obstack_grow (&obstack, temp_filename,
5216 temp_filename_length);
5218 delete_this_arg = 0;
5224 /* See if we already have an association of %g/%u/%U and
5226 for (t = temp_names; t; t = t->next)
5227 if (t->length == suffix_length
5228 && strncmp (t->suffix, suffix, suffix_length) == 0
5229 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5232 /* Make a new association if needed. %u and %j
5234 if (t == 0 || c == 'u' || c == 'j')
5238 t = XNEW (struct temp_name);
5239 t->next = temp_names;
5242 t->length = suffix_length;
5245 t->suffix = saved_suffix;
5246 saved_suffix = NULL;
5249 t->suffix = save_string (suffix, suffix_length);
5250 t->unique = (c == 'u' || c == 'U' || c == 'j');
5251 temp_filename = make_temp_file (t->suffix);
5252 temp_filename_length = strlen (temp_filename);
5253 t->filename = temp_filename;
5254 t->filename_length = temp_filename_length;
5258 free (saved_suffix);
5260 obstack_grow (&obstack, t->filename, t->filename_length);
5261 delete_this_arg = 1;
5269 if (at_file_supplied)
5271 /* We are going to expand `%i' to `@FILE', where FILE
5272 is a newly-created temporary filename. The filenames
5273 that would usually be expanded in place of %o will be
5274 written to the temporary file. */
5279 for (i = 0; i < n_infiles; i++)
5280 if (compile_input_file_p (&infiles[i]))
5283 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5285 /* Copy the strings over. */
5286 for (i = 0, j = 0; i < n_infiles; i++)
5287 if (compile_input_file_p (&infiles[i]))
5289 argv[j] = CONST_CAST (char *, infiles[i].name);
5290 infiles[i].compiled = true;
5295 create_at_file (argv);
5298 for (i = 0; (int) i < n_infiles; i++)
5299 if (compile_input_file_p (&infiles[i]))
5301 store_arg (infiles[i].name, 0, 0);
5302 infiles[i].compiled = true;
5307 obstack_grow (&obstack, gcc_input_filename,
5308 input_filename_length);
5315 struct spec_path_info info;
5319 do_spec_1 ("-imultilib", 1, NULL);
5320 /* Make this a separate argument. */
5321 do_spec_1 (" ", 0, NULL);
5322 do_spec_1 (multilib_dir, 1, NULL);
5323 do_spec_1 (" ", 0, NULL);
5326 if (gcc_exec_prefix)
5328 do_spec_1 ("-iprefix", 1, NULL);
5329 /* Make this a separate argument. */
5330 do_spec_1 (" ", 0, NULL);
5331 do_spec_1 (gcc_exec_prefix, 1, NULL);
5332 do_spec_1 (" ", 0, NULL);
5335 if (target_system_root_changed ||
5336 (target_system_root && target_sysroot_hdrs_suffix))
5338 do_spec_1 ("-isysroot", 1, NULL);
5339 /* Make this a separate argument. */
5340 do_spec_1 (" ", 0, NULL);
5341 do_spec_1 (target_system_root, 1, NULL);
5342 if (target_sysroot_hdrs_suffix)
5343 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5344 do_spec_1 (" ", 0, NULL);
5347 info.option = "-isystem";
5348 info.append = "include";
5349 info.append_len = strlen (info.append);
5350 info.omit_relative = false;
5351 info.separate_options = true;
5353 for_each_path (&include_prefixes, false, info.append_len,
5356 info.append = "include-fixed";
5357 if (*sysroot_hdrs_suffix_spec)
5358 info.append = concat (info.append, dir_separator_str,
5359 multilib_dir, NULL);
5360 info.append_len = strlen (info.append);
5361 for_each_path (&include_prefixes, false, info.append_len,
5368 int max = n_infiles;
5369 max += lang_specific_extra_outfiles;
5371 if (HAVE_GNU_LD && at_file_supplied)
5373 /* We are going to expand `%o' to `@FILE', where FILE
5374 is a newly-created temporary filename. The filenames
5375 that would usually be expanded in place of %o will be
5376 written to the temporary file. */
5381 /* Convert OUTFILES into a form suitable for writeargv. */
5383 /* Determine how many are non-NULL. */
5384 for (n_files = 0, i = 0; i < max; i++)
5385 n_files += outfiles[i] != NULL;
5387 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5389 /* Copy the strings over. */
5390 for (i = 0, j = 0; i < max; i++)
5393 argv[j] = CONST_CAST (char *, outfiles[i]);
5398 create_at_file (argv);
5401 for (i = 0; i < max; i++)
5403 store_arg (outfiles[i], 0, 0);
5408 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5413 this_is_library_file = 1;
5417 this_is_linker_script = 1;
5421 outfiles[input_file_number] = NULL;
5425 this_is_output_file = 1;
5430 int cur_index = argbuf_index;
5431 /* Handle the {...} following the %W. */
5433 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5434 p = handle_braces (p + 1);
5438 /* If any args were output, mark the last one for deletion
5440 if (argbuf_index != cur_index)
5441 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5445 /* %x{OPTION} records OPTION for %X to output. */
5451 /* Skip past the option value and make a copy. */
5453 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5456 string = save_string (p1 + 1, p - p1 - 2);
5458 /* See if we already recorded this option. */
5459 for (i = 0; i < n_linker_options; i++)
5460 if (! strcmp (string, linker_options[i]))
5466 /* This option is new; add it. */
5467 add_linker_option (string, strlen (string));
5471 /* Dump out the options accumulated previously using %x. */
5473 for (i = 0; i < n_linker_options; i++)
5475 do_spec_1 (linker_options[i], 1, NULL);
5476 /* Make each accumulated option a separate argument. */
5477 do_spec_1 (" ", 0, NULL);
5481 /* Dump out the options accumulated previously using -Wa,. */
5483 for (i = 0; i < n_assembler_options; i++)
5485 do_spec_1 (assembler_options[i], 1, NULL);
5486 /* Make each accumulated option a separate argument. */
5487 do_spec_1 (" ", 0, NULL);
5491 /* Dump out the options accumulated previously using -Wp,. */
5493 for (i = 0; i < n_preprocessor_options; i++)
5495 do_spec_1 (preprocessor_options[i], 1, NULL);
5496 /* Make each accumulated option a separate argument. */
5497 do_spec_1 (" ", 0, NULL);
5501 /* Here are digits and numbers that just process
5502 a certain constant string as a spec. */
5505 value = do_spec_1 (cc1_spec, 0, NULL);
5511 value = do_spec_1 (cc1plus_spec, 0, NULL);
5517 value = do_spec_1 (asm_spec, 0, NULL);
5523 value = do_spec_1 (asm_final_spec, 0, NULL);
5530 const char *const spec
5531 = (input_file_compiler->cpp_spec
5532 ? input_file_compiler->cpp_spec
5534 value = do_spec_1 (spec, 0, NULL);
5541 value = do_spec_1 (endfile_spec, 0, NULL);
5547 value = do_spec_1 (link_spec, 0, NULL);
5553 value = do_spec_1 (lib_spec, 0, NULL);
5559 value = do_spec_1 (libgcc_spec, 0, NULL);
5565 /* We assume there is a directory
5566 separator at the end of this string. */
5567 if (target_system_root)
5569 obstack_grow (&obstack, target_system_root,
5570 strlen (target_system_root));
5571 if (target_sysroot_suffix)
5572 obstack_grow (&obstack, target_sysroot_suffix,
5573 strlen (target_sysroot_suffix));
5578 value = do_spec_1 (startfile_spec, 0, NULL);
5583 /* Here we define characters other than letters and digits. */
5586 p = handle_braces (p);
5592 p = handle_spec_function (p);
5598 obstack_1grow (&obstack, '%');
5605 while (p[len] && p[len] != ' ' && p[len] != '%')
5607 suffix_subst = save_string (p - 1, len + 1);
5612 /* Henceforth ignore the option(s) matching the pattern
5617 int have_wildcard = 0;
5620 while (p[len] && p[len] != ' ' && p[len] != '\t')
5623 if (p[len-1] == '*')
5626 for (i = 0; i < n_switches; i++)
5627 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5628 && (have_wildcard || switches[i].part1[len] == '\0'))
5630 switches[i].live_cond |= SWITCH_IGNORE;
5631 switches[i].validated = 1;
5639 if (soft_matched_part)
5641 do_spec_1 (soft_matched_part, 1, NULL);
5642 do_spec_1 (" ", 0, NULL);
5645 /* Catch the case where a spec string contains something like
5646 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5647 hand side of the :. */
5648 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5651 /* Process a string found as the value of a spec given by name.
5652 This feature allows individual machine descriptions
5653 to add and use their own specs.
5654 %[...] modifies -D options the way %P does;
5655 %(...) uses the spec unmodified. */
5657 warning (0, "use of obsolete %%[ operator in specs");
5660 const char *name = p;
5661 struct spec_list *sl;
5664 /* The string after the S/P is the name of a spec that is to be
5666 while (*p && *p != ')' && *p != ']')
5669 /* See if it's in the list. */
5670 for (len = p - name, sl = specs; sl; sl = sl->next)
5671 if (sl->name_len == len && !strncmp (sl->name, name, len))
5673 name = *(sl->ptr_spec);
5675 fnotice (stderr, "Processing spec %c%s%c, which is '%s'\n",
5676 c, sl->name, (c == '(') ? ')' : ']', name);
5685 value = do_spec_1 (name, 0, NULL);
5691 char *x = (char *) alloca (strlen (name) * 2 + 1);
5693 const char *y = name;
5696 /* Copy all of NAME into BUF, but put __ after
5697 every -D and at the end of each arg. */
5700 if (! strncmp (y, "-D", 2))
5711 && (*y == ' ' || *y == '\t' || *y == '='
5712 || *y == '}' || *y == 0))
5725 value = do_spec_1 (buf, 0, NULL);
5731 /* Discard the closing paren or bracket. */
5738 error ("spec failure: unrecognized spec option %qc", c);
5744 /* Backslash: treat next character as ordinary. */
5749 /* Ordinary character: put it into the current argument. */
5750 obstack_1grow (&obstack, c);
5754 /* End of string. If we are processing a spec function, we need to
5755 end any pending argument. */
5756 if (processing_spec_function)
5762 /* Look up a spec function. */
5764 static const struct spec_function *
5765 lookup_spec_function (const char *name)
5767 const struct spec_function *sf;
5769 for (sf = static_spec_functions; sf->name != NULL; sf++)
5770 if (strcmp (sf->name, name) == 0)
5776 /* Evaluate a spec function. */
5779 eval_spec_function (const char *func, const char *args)
5781 const struct spec_function *sf;
5782 const char *funcval;
5784 /* Saved spec processing context. */
5785 int save_argbuf_index;
5786 int save_argbuf_length;
5787 const char **save_argbuf;
5790 int save_delete_this_arg;
5791 int save_this_is_output_file;
5792 int save_this_is_library_file;
5793 int save_input_from_pipe;
5794 int save_this_is_linker_script;
5795 const char *save_suffix_subst;
5798 sf = lookup_spec_function (func);
5800 fatal_error ("unknown spec function %qs", func);
5802 /* Push the spec processing context. */
5803 save_argbuf_index = argbuf_index;
5804 save_argbuf_length = argbuf_length;
5805 save_argbuf = argbuf;
5807 save_arg_going = arg_going;
5808 save_delete_this_arg = delete_this_arg;
5809 save_this_is_output_file = this_is_output_file;
5810 save_this_is_library_file = this_is_library_file;
5811 save_this_is_linker_script = this_is_linker_script;
5812 save_input_from_pipe = input_from_pipe;
5813 save_suffix_subst = suffix_subst;
5815 /* Create a new spec processing context, and build the function
5819 if (do_spec_2 (args) < 0)
5820 fatal_error ("error in args to spec function %qs", func);
5822 /* argbuf_index is an index for the next argument to be inserted, and
5823 so contains the count of the args already inserted. */
5825 funcval = (*sf->func) (argbuf_index, argbuf);
5827 /* Pop the spec processing context. */
5828 argbuf_index = save_argbuf_index;
5829 argbuf_length = save_argbuf_length;
5831 argbuf = save_argbuf;
5833 arg_going = save_arg_going;
5834 delete_this_arg = save_delete_this_arg;
5835 this_is_output_file = save_this_is_output_file;
5836 this_is_library_file = save_this_is_library_file;
5837 this_is_linker_script = save_this_is_linker_script;
5838 input_from_pipe = save_input_from_pipe;
5839 suffix_subst = save_suffix_subst;
5844 /* Handle a spec function call of the form:
5848 ARGS is processed as a spec in a separate context and split into an
5849 argument vector in the normal fashion. The function returns a string
5850 containing a spec which we then process in the caller's context, or
5851 NULL if no processing is required. */
5854 handle_spec_function (const char *p)
5857 const char *endp, *funcval;
5860 processing_spec_function++;
5862 /* Get the function name. */
5863 for (endp = p; *endp != '\0'; endp++)
5865 if (*endp == '(') /* ) */
5867 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5868 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5869 fatal_error ("malformed spec function name");
5871 if (*endp != '(') /* ) */
5872 fatal_error ("no arguments for spec function");
5873 func = save_string (p, endp - p);
5876 /* Get the arguments. */
5877 for (count = 0; *endp != '\0'; endp++)
5886 else if (*endp == '(') /* ) */
5891 fatal_error ("malformed spec function arguments");
5892 args = save_string (p, endp - p);
5895 /* p now points to just past the end of the spec function expression. */
5897 funcval = eval_spec_function (func, args);
5898 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5904 processing_spec_function--;
5909 /* Inline subroutine of handle_braces. Returns true if the current
5910 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5912 input_suffix_matches (const char *atom, const char *end_atom)
5914 return (input_suffix
5915 && !strncmp (input_suffix, atom, end_atom - atom)
5916 && input_suffix[end_atom - atom] == '\0');
5919 /* Subroutine of handle_braces. Returns true if the current
5920 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5922 input_spec_matches (const char *atom, const char *end_atom)
5924 return (input_file_compiler
5925 && input_file_compiler->suffix
5926 && input_file_compiler->suffix[0] != '\0'
5927 && !strncmp (input_file_compiler->suffix + 1, atom,
5929 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5932 /* Subroutine of handle_braces. Returns true if a switch
5933 matching the atom bracketed by ATOM and END_ATOM appeared on the
5936 switch_matches (const char *atom, const char *end_atom, int starred)
5939 int len = end_atom - atom;
5940 int plen = starred ? len : -1;
5942 for (i = 0; i < n_switches; i++)
5943 if (!strncmp (switches[i].part1, atom, len)
5944 && (starred || switches[i].part1[len] == '\0')
5945 && check_live_switch (i, plen))
5951 /* Inline subroutine of handle_braces. Mark all of the switches which
5952 match ATOM (extends to END_ATOM; STARRED indicates whether there
5953 was a star after the atom) for later processing. */
5955 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5958 int len = end_atom - atom;
5959 int plen = starred ? len : -1;
5961 for (i = 0; i < n_switches; i++)
5962 if (!strncmp (switches[i].part1, atom, len)
5963 && (starred || switches[i].part1[len] == '\0')
5964 && check_live_switch (i, plen))
5965 switches[i].ordering = 1;
5968 /* Inline subroutine of handle_braces. Process all the currently
5969 marked switches through give_switch, and clear the marks. */
5971 process_marked_switches (void)
5975 for (i = 0; i < n_switches; i++)
5976 if (switches[i].ordering == 1)
5978 switches[i].ordering = 0;
5983 /* Handle a %{ ... } construct. P points just inside the leading {.
5984 Returns a pointer one past the end of the brace block, or 0
5985 if we call do_spec_1 and that returns -1. */
5988 handle_braces (const char *p)
5990 const char *atom, *end_atom;
5991 const char *d_atom = NULL, *d_end_atom = NULL;
5992 const char *orig = p;
6000 bool a_must_be_last = false;
6001 bool ordered_set = false;
6002 bool disjunct_set = false;
6003 bool disj_matched = false;
6004 bool disj_starred = true;
6005 bool n_way_choice = false;
6006 bool n_way_matched = false;
6008 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6015 /* Scan one "atom" (S in the description above of %{}, possibly
6016 with '!', '.', '@', ',', or '*' modifiers). */
6018 a_is_suffix = false;
6019 a_is_starred = false;
6020 a_is_negated = false;
6021 a_is_spectype = false;
6025 p++, a_is_negated = true;
6029 p++, a_is_suffix = true;
6031 p++, a_is_spectype = true;
6034 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6035 || *p == ',' || *p == '.' || *p == '@')
6040 p++, a_is_starred = 1;
6046 /* Substitute the switch(es) indicated by the current atom. */
6048 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6049 || a_is_spectype || atom == end_atom)
6052 mark_matching_switches (atom, end_atom, a_is_starred);
6055 process_marked_switches ();
6059 /* Substitute some text if the current atom appears as a switch
6061 disjunct_set = true;
6065 if (atom == end_atom)
6067 if (!n_way_choice || disj_matched || *p == '|'
6068 || a_is_negated || a_is_suffix || a_is_spectype
6072 /* An empty term may appear as the last choice of an
6073 N-way choice set; it means "otherwise". */
6074 a_must_be_last = true;
6075 disj_matched = !n_way_matched;
6076 disj_starred = false;
6080 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6084 disj_starred = false;
6086 /* Don't bother testing this atom if we already have a
6088 if (!disj_matched && !n_way_matched)
6091 a_matched = input_suffix_matches (atom, end_atom);
6092 else if (a_is_spectype)
6093 a_matched = input_spec_matches (atom, end_atom);
6095 a_matched = switch_matches (atom, end_atom, a_is_starred);
6097 if (a_matched != a_is_negated)
6099 disj_matched = true;
6101 d_end_atom = end_atom;
6108 /* Found the body, that is, the text to substitute if the
6109 current disjunction matches. */
6110 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6111 disj_matched && !n_way_matched);
6115 /* If we have an N-way choice, reset state for the next
6119 n_way_choice = true;
6120 n_way_matched |= disj_matched;
6121 disj_matched = false;
6122 disj_starred = true;
6123 d_atom = d_end_atom = NULL;
6132 while (*p++ != '}');
6137 fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
6142 /* Subroutine of handle_braces. Scan and process a brace substitution body
6143 (X in the description of %{} syntax). P points one past the colon;
6144 ATOM and END_ATOM bracket the first atom which was found to be true
6145 (present) in the current disjunction; STARRED indicates whether all
6146 the atoms in the current disjunction were starred (for syntax validation);
6147 MATCHED indicates whether the disjunction matched or not, and therefore
6148 whether or not the body is to be processed through do_spec_1 or just
6149 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6153 process_brace_body (const char *p, const char *atom, const char *end_atom,
6154 int starred, int matched)
6156 const char *body, *end_body;
6157 unsigned int nesting_level;
6158 bool have_subst = false;
6160 /* Locate the closing } or ;, honoring nested braces.
6161 Trim trailing whitespace. */
6170 if (!--nesting_level)
6173 else if (*p == ';' && nesting_level == 1)
6175 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6177 else if (*p == '\0')
6183 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6186 if (have_subst && !starred)
6191 /* Copy the substitution body to permanent storage and execute it.
6192 If have_subst is false, this is a simple matter of running the
6193 body through do_spec_1... */
6194 char *string = save_string (body, end_body - body);
6197 if (do_spec_1 (string, 0, NULL) < 0)
6202 /* ... but if have_subst is true, we have to process the
6203 body once for each matching switch, with %* set to the
6204 variant part of the switch. */
6205 unsigned int hard_match_len = end_atom - atom;
6208 for (i = 0; i < n_switches; i++)
6209 if (!strncmp (switches[i].part1, atom, hard_match_len)
6210 && check_live_switch (i, hard_match_len))
6212 if (do_spec_1 (string, 0,
6213 &switches[i].part1[hard_match_len]) < 0)
6215 /* Pass any arguments this switch has. */
6217 suffix_subst = NULL;
6225 fatal_error ("braced spec body %qs is invalid", body);
6228 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6229 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6230 spec, or -1 if either exact match or %* is used.
6232 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6233 whose value does not begin with "no-" is obsoleted by the same value
6234 with the "no-", similarly for a switch with the "no-" prefix. */
6237 check_live_switch (int switchnum, int prefix_length)
6239 const char *name = switches[switchnum].part1;
6242 /* If we already processed this switch and determined if it was
6243 live or not, return our past determination. */
6244 if (switches[switchnum].live_cond != 0)
6245 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6246 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6247 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6250 /* In the common case of {<at-most-one-letter>*}, a negating
6251 switch would always match, so ignore that case. We will just
6252 send the conflicting switches to the compiler phase. */
6253 if (prefix_length >= 0 && prefix_length <= 1)
6256 /* Now search for duplicate in a manner that depends on the name. */
6260 for (i = switchnum + 1; i < n_switches; i++)
6261 if (switches[i].part1[0] == 'O')
6263 switches[switchnum].validated = 1;
6264 switches[switchnum].live_cond = SWITCH_FALSE;
6269 case 'W': case 'f': case 'm':
6270 if (! strncmp (name + 1, "no-", 3))
6272 /* We have Xno-YYY, search for XYYY. */
6273 for (i = switchnum + 1; i < n_switches; i++)
6274 if (switches[i].part1[0] == name[0]
6275 && ! strcmp (&switches[i].part1[1], &name[4]))
6277 switches[switchnum].validated = 1;
6278 switches[switchnum].live_cond = SWITCH_FALSE;
6284 /* We have XYYY, search for Xno-YYY. */
6285 for (i = switchnum + 1; i < n_switches; i++)
6286 if (switches[i].part1[0] == name[0]
6287 && switches[i].part1[1] == 'n'
6288 && switches[i].part1[2] == 'o'
6289 && switches[i].part1[3] == '-'
6290 && !strcmp (&switches[i].part1[4], &name[1]))
6292 switches[switchnum].validated = 1;
6293 switches[switchnum].live_cond = SWITCH_FALSE;
6300 /* Otherwise the switch is live. */
6301 switches[switchnum].live_cond |= SWITCH_LIVE;
6305 /* Pass a switch to the current accumulating command
6306 in the same form that we received it.
6307 SWITCHNUM identifies the switch; it is an index into
6308 the vector of switches gcc received, which is `switches'.
6309 This cannot fail since it never finishes a command line.
6311 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6314 give_switch (int switchnum, int omit_first_word)
6316 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6319 if (!omit_first_word)
6321 do_spec_1 ("-", 0, NULL);
6322 do_spec_1 (switches[switchnum].part1, 1, NULL);
6325 if (switches[switchnum].args != 0)
6328 for (p = switches[switchnum].args; *p; p++)
6330 const char *arg = *p;
6332 do_spec_1 (" ", 0, NULL);
6335 unsigned length = strlen (arg);
6338 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6339 if (arg[length] == '.')
6341 (CONST_CAST(char *, arg))[length] = 0;
6345 do_spec_1 (arg, 1, NULL);
6347 (CONST_CAST(char *, arg))[length] = '.';
6348 do_spec_1 (suffix_subst, 1, NULL);
6351 do_spec_1 (arg, 1, NULL);
6355 do_spec_1 (" ", 0, NULL);
6356 switches[switchnum].validated = 1;
6359 /* Search for a file named NAME trying various prefixes including the
6360 user's -B prefix and some standard ones.
6361 Return the absolute file name found. If nothing is found, return NAME. */
6364 find_file (const char *name)
6366 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6367 return newname ? newname : name;
6370 /* Determine whether a directory exists. If LINKER, return 0 for
6371 certain fixed names not needed by the linker. */
6374 is_directory (const char *path1, bool linker)
6381 /* Ensure the string ends with "/.". The resulting path will be a
6382 directory even if the given path is a symbolic link. */
6383 len1 = strlen (path1);
6384 path = (char *) alloca (3 + len1);
6385 memcpy (path, path1, len1);
6387 if (!IS_DIR_SEPARATOR (cp[-1]))
6388 *cp++ = DIR_SEPARATOR;
6392 /* Exclude directories that the linker is known to search. */
6394 && IS_DIR_SEPARATOR (path[0])
6396 && strncmp (path + 1, "lib", 3) == 0)
6398 && strncmp (path + 1, "usr", 3) == 0
6399 && IS_DIR_SEPARATOR (path[4])
6400 && strncmp (path + 5, "lib", 3) == 0)))
6403 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6406 /* Set up the various global variables to indicate that we're processing
6407 the input file named FILENAME. */
6410 set_input (const char *filename)
6414 gcc_input_filename = filename;
6415 input_filename_length = strlen (gcc_input_filename);
6416 input_basename = lbasename (gcc_input_filename);
6418 /* Find a suffix starting with the last period,
6419 and set basename_length to exclude that suffix. */
6420 basename_length = strlen (input_basename);
6421 suffixed_basename_length = basename_length;
6422 p = input_basename + basename_length;
6423 while (p != input_basename && *p != '.')
6425 if (*p == '.' && p != input_basename)
6427 basename_length = p - input_basename;
6428 input_suffix = p + 1;
6433 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6434 we will need to do a stat on the gcc_input_filename. The
6435 INPUT_STAT_SET signals that the stat is needed. */
6439 /* On fatal signals, delete all the temporary files. */
6442 fatal_signal (int signum)
6444 signal (signum, SIG_DFL);
6445 delete_failure_queue ();
6446 delete_temp_files ();
6447 /* Get the same signal again, this time not handled,
6448 so its normal effect occurs. */
6449 kill (getpid (), signum);
6452 /* Compare the contents of the two files named CMPFILE[0] and
6453 CMPFILE[1]. Return zero if they're identical, nonzero
6457 compare_files (char *cmpfile[])
6460 FILE *temp[2] = { NULL, NULL };
6466 void *map[2] = { NULL, NULL };
6468 for (i = 0; i < 2; i++)
6472 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6474 error ("%s: could not determine length of compare-debug file %s",
6475 gcc_input_filename, cmpfile[i]);
6480 length[i] = st.st_size;
6483 if (!ret && length[0] != length[1])
6485 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6490 for (i = 0; i < 2; i++)
6492 int fd = open (cmpfile[i], O_RDONLY);
6495 error ("%s: could not open compare-debug file %s",
6496 gcc_input_filename, cmpfile[i]);
6501 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6504 if (map[i] == (void *) MAP_FAILED)
6513 if (memcmp (map[0], map[1], length[0]) != 0)
6515 error ("%s: -fcompare-debug failure", gcc_input_filename);
6520 for (i = 0; i < 2; i++)
6522 munmap ((caddr_t) map[i], length[i]);
6531 for (i = 0; i < 2; i++)
6533 temp[i] = fopen (cmpfile[i], "r");
6536 error ("%s: could not open compare-debug file %s",
6537 gcc_input_filename, cmpfile[i]);
6543 if (!ret && temp[0] && temp[1])
6547 c0 = fgetc (temp[0]);
6548 c1 = fgetc (temp[1]);
6552 error ("%s: -fcompare-debug failure",
6553 gcc_input_filename);
6562 for (i = 1; i >= 0; i--)
6571 extern int main (int, char **);
6574 main (int argc, char **argv)
6578 int linker_was_run = 0;
6579 int lang_n_infiles = 0;
6580 int num_linker_inputs = 0;
6581 char *explicit_link_files;
6584 struct user_specs *uptr;
6585 char **old_argv = argv;
6587 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6588 on ?: in file-scope variable initializations. */
6589 asm_debug = ASM_DEBUG_SPEC;
6591 p = argv[0] + strlen (argv[0]);
6592 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6596 xmalloc_set_program_name (progname);
6598 expandargv (&argc, &argv);
6600 /* Determine if any expansions were made. */
6601 if (argv != old_argv)
6602 at_file_supplied = true;
6604 prune_options (&argc, &argv);
6606 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6607 /* Perform host dependent initialization when needed. */
6608 GCC_DRIVER_HOST_INITIALIZATION;
6611 /* Unlock the stdio streams. */
6612 unlock_std_streams ();
6614 gcc_init_libintl ();
6616 diagnostic_initialize (global_dc, 0);
6617 if (atexit (delete_temp_files) != 0)
6618 fatal_error ("atexit failed");
6620 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6621 signal (SIGINT, fatal_signal);
6623 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6624 signal (SIGHUP, fatal_signal);
6626 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6627 signal (SIGTERM, fatal_signal);
6629 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6630 signal (SIGPIPE, fatal_signal);
6633 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6634 receive the signal. A different setting is inheritable */
6635 signal (SIGCHLD, SIG_DFL);
6638 /* Allocate the argument vector. */
6641 obstack_init (&obstack);
6643 /* Build multilib_select, et. al from the separate lines that make up each
6644 multilib selection. */
6646 const char *const *q = multilib_raw;
6649 obstack_init (&multilib_obstack);
6650 while ((p = *q++) != (char *) 0)
6651 obstack_grow (&multilib_obstack, p, strlen (p));
6653 obstack_1grow (&multilib_obstack, 0);
6654 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6656 q = multilib_matches_raw;
6657 while ((p = *q++) != (char *) 0)
6658 obstack_grow (&multilib_obstack, p, strlen (p));
6660 obstack_1grow (&multilib_obstack, 0);
6661 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6663 q = multilib_exclusions_raw;
6664 while ((p = *q++) != (char *) 0)
6665 obstack_grow (&multilib_obstack, p, strlen (p));
6667 obstack_1grow (&multilib_obstack, 0);
6668 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6671 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6674 obstack_1grow (&multilib_obstack, ' ');
6675 obstack_grow (&multilib_obstack,
6676 multilib_defaults_raw[i],
6677 strlen (multilib_defaults_raw[i]));
6681 obstack_1grow (&multilib_obstack, 0);
6682 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6685 #ifdef INIT_ENVIRONMENT
6686 /* Set up any other necessary machine specific environment variables. */
6687 xputenv (INIT_ENVIRONMENT);
6690 /* Make a table of what switches there are (switches, n_switches).
6691 Make a table of specified input files (infiles, n_infiles).
6692 Decode switches that are handled locally. */
6694 process_command (argc, CONST_CAST2 (const char **, char **, argv));
6696 /* Initialize the vector of specs to just the default.
6697 This means one element containing 0s, as a terminator. */
6699 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6700 memcpy (compilers, default_compilers, sizeof default_compilers);
6701 n_compilers = n_default_compilers;
6703 /* Read specs from a file if there is one. */
6705 machine_suffix = concat (spec_machine, dir_separator_str,
6706 spec_version, dir_separator_str, NULL);
6707 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6709 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6710 /* Read the specs file unless it is a default one. */
6711 if (specs_file != 0 && strcmp (specs_file, "specs"))
6712 read_specs (specs_file, TRUE);
6716 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6717 for any override of as, ld and libraries. */
6718 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6719 + strlen (just_machine_suffix) + sizeof ("specs"));
6721 strcpy (specs_file, standard_exec_prefix);
6722 strcat (specs_file, just_machine_suffix);
6723 strcat (specs_file, "specs");
6724 if (access (specs_file, R_OK) == 0)
6725 read_specs (specs_file, TRUE);
6727 /* Process any configure-time defaults specified for the command line
6728 options, via OPTION_DEFAULT_SPECS. */
6729 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6730 do_option_spec (option_default_specs[i].name,
6731 option_default_specs[i].spec);
6733 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6734 of the command line. */
6736 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6737 do_self_spec (driver_self_specs[i]);
6741 enum save_temps save;
6743 if (!compare_debug_second)
6745 n_switches_debug_check[1] = n_switches;
6746 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6749 do_self_spec ("%:compare-debug-self-opt()");
6750 n_switches_debug_check[0] = n_switches;
6751 switches_debug_check[0] = switches;
6753 n_switches = n_switches_debug_check[1];
6754 switches = switches_debug_check[1];
6757 /* Avoid crash when computing %j in this early. */
6758 save = save_temps_flag;
6759 save_temps_flag = SAVE_TEMPS_NONE;
6761 compare_debug = -compare_debug;
6762 do_self_spec ("%:compare-debug-self-opt()");
6764 save_temps_flag = save;
6766 if (!compare_debug_second)
6768 n_switches_debug_check[1] = n_switches;
6769 switches_debug_check[1] = switches;
6770 compare_debug = -compare_debug;
6771 n_switches = n_switches_debug_check[0];
6772 switches = switches_debug_check[0];
6776 /* If not cross-compiling, look for executables in the standard
6778 if (*cross_compile == '0')
6780 if (*md_exec_prefix)
6782 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6783 PREFIX_PRIORITY_LAST, 0, 0);
6787 /* Process sysroot_suffix_spec. */
6788 if (*sysroot_suffix_spec != 0
6789 && do_spec_2 (sysroot_suffix_spec) == 0)
6791 if (argbuf_index > 1)
6792 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6793 else if (argbuf_index == 1)
6794 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6797 #ifdef HAVE_LD_SYSROOT
6798 /* Pass the --sysroot option to the linker, if it supports that. If
6799 there is a sysroot_suffix_spec, it has already been processed by
6800 this point, so target_system_root really is the system root we
6802 if (target_system_root)
6804 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6805 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6806 set_spec ("link", XOBFINISH (&obstack, const char *));
6810 /* Process sysroot_hdrs_suffix_spec. */
6811 if (*sysroot_hdrs_suffix_spec != 0
6812 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6814 if (argbuf_index > 1)
6815 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6816 else if (argbuf_index == 1)
6817 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6820 /* Look for startfiles in the standard places. */
6821 if (*startfile_prefix_spec != 0
6822 && do_spec_2 (startfile_prefix_spec) == 0
6823 && do_spec_1 (" ", 0, NULL) == 0)
6826 for (ndx = 0; ndx < argbuf_index; ndx++)
6827 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6828 PREFIX_PRIORITY_LAST, 0, 1);
6830 /* We should eventually get rid of all these and stick to
6831 startfile_prefix_spec exclusively. */
6832 else if (*cross_compile == '0' || target_system_root)
6834 if (*md_startfile_prefix)
6835 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6836 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6838 if (*md_startfile_prefix_1)
6839 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6840 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6842 /* If standard_startfile_prefix is relative, base it on
6843 standard_exec_prefix. This lets us move the installed tree
6844 as a unit. If GCC_EXEC_PREFIX is defined, base
6845 standard_startfile_prefix on that as well.
6847 If the prefix is relative, only search it for native compilers;
6848 otherwise we will search a directory containing host libraries. */
6849 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6850 add_sysrooted_prefix (&startfile_prefixes,
6851 standard_startfile_prefix, "BINUTILS",
6852 PREFIX_PRIORITY_LAST, 0, 1);
6853 else if (*cross_compile == '0')
6855 add_prefix (&startfile_prefixes,
6856 concat (gcc_exec_prefix
6857 ? gcc_exec_prefix : standard_exec_prefix,
6859 standard_startfile_prefix, NULL),
6860 NULL, PREFIX_PRIORITY_LAST, 0, 1);
6863 /* Sysrooted prefixes are relocated because target_system_root is
6864 also relocated by gcc_exec_prefix. */
6865 if (*standard_startfile_prefix_1)
6866 add_sysrooted_prefix (&startfile_prefixes,
6867 standard_startfile_prefix_1, "BINUTILS",
6868 PREFIX_PRIORITY_LAST, 0, 1);
6869 if (*standard_startfile_prefix_2)
6870 add_sysrooted_prefix (&startfile_prefixes,
6871 standard_startfile_prefix_2, "BINUTILS",
6872 PREFIX_PRIORITY_LAST, 0, 1);
6875 /* Process any user specified specs in the order given on the command
6877 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6879 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6881 read_specs (filename ? filename : uptr->filename, FALSE);
6884 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6885 if (gcc_exec_prefix)
6886 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6887 spec_version, dir_separator_str, NULL);
6889 /* Now we have the specs.
6890 Set the `valid' bits for switches that match anything in any spec. */
6892 validate_all_switches ();
6894 /* Now that we have the switches and the specs, set
6895 the subdirectory based on the options. */
6896 set_multilib_dir ();
6898 /* Set up to remember the pathname of gcc and any options
6899 needed for collect. We use argv[0] instead of progname because
6900 we need the complete pathname. */
6901 obstack_init (&collect_obstack);
6902 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6903 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6904 xputenv (XOBFINISH (&collect_obstack, char *));
6906 /* Set up to remember the pathname of the lto wrapper. */
6908 lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
6909 if (lto_wrapper_spec)
6911 obstack_init (&collect_obstack);
6912 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6913 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6914 obstack_grow (&collect_obstack, lto_wrapper_spec,
6915 strlen (lto_wrapper_spec) + 1);
6916 xputenv (XOBFINISH (&collect_obstack, char *));
6919 /* Warn about any switches that no pass was interested in. */
6921 for (i = 0; (int) i < n_switches; i++)
6922 if (! switches[i].validated)
6923 error ("unrecognized option %<-%s%>", switches[i].part1);
6925 /* Obey some of the options. */
6927 if (print_search_dirs)
6929 printf (_("install: %s%s\n"),
6930 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6931 gcc_exec_prefix ? "" : machine_suffix);
6932 printf (_("programs: %s\n"),
6933 build_search_list (&exec_prefixes, "", false, false));
6934 printf (_("libraries: %s\n"),
6935 build_search_list (&startfile_prefixes, "", false, true));
6939 if (print_file_name)
6941 printf ("%s\n", find_file (print_file_name));
6945 if (print_prog_name)
6947 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6948 printf ("%s\n", (newname ? newname : print_prog_name));
6952 if (print_multi_lib)
6954 print_multilib_info ();
6958 if (print_multi_directory)
6960 if (multilib_dir == NULL)
6963 printf ("%s\n", multilib_dir);
6969 if (target_system_root)
6971 if (target_sysroot_suffix)
6972 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6974 printf ("%s\n", target_system_root);
6979 if (print_multi_os_directory)
6981 if (multilib_os_dir == NULL)
6984 printf ("%s\n", multilib_os_dir);
6988 if (print_sysroot_headers_suffix)
6990 if (*sysroot_hdrs_suffix_spec)
6992 printf("%s\n", (target_sysroot_hdrs_suffix
6993 ? target_sysroot_hdrs_suffix
6998 /* The error status indicates that only one set of fixed
6999 headers should be built. */
7000 fatal_error ("not configured with sysroot headers suffix");
7003 if (print_help_list)
7009 printf (_("\nFor bug reporting instructions, please see:\n"));
7010 printf ("%s.\n", bug_report_url);
7015 /* We do not exit here. Instead we have created a fake input file
7016 called 'help-dummy' which needs to be compiled, and we pass this
7017 on the various sub-processes, along with the --help switch.
7018 Ensure their output appears after ours. */
7019 fputc ('\n', stdout);
7025 printf (_("%s %s%s\n"), progname, pkgversion_string,
7027 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7029 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7030 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7035 /* We do not exit here. We use the same mechanism of --help to print
7036 the version of the sub-processes. */
7037 fputc ('\n', stdout);
7046 fnotice (stderr, "Target: %s\n", spec_machine);
7047 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
7049 #ifdef THREAD_MODEL_SPEC
7050 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7051 but there's no point in doing all this processing just to get
7052 thread_model back. */
7053 obstack_init (&obstack);
7054 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7055 obstack_1grow (&obstack, '\0');
7056 thrmod = XOBFINISH (&obstack, const char *);
7058 thrmod = thread_model;
7061 fnotice (stderr, "Thread model: %s\n", thrmod);
7063 /* compiler_version is truncated at the first space when initialized
7064 from version string, so truncate version_string at the first space
7065 before comparing. */
7066 for (n = 0; version_string[n]; n++)
7067 if (version_string[n] == ' ')
7070 if (! strncmp (version_string, compiler_version, n)
7071 && compiler_version[n] == 0)
7072 fnotice (stderr, "gcc version %s %s\n", version_string,
7075 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
7076 version_string, pkgversion_string, compiler_version);
7082 if (n_infiles == added_libraries)
7083 fatal_error ("no input files");
7085 /* Make a place to record the compiler output file names
7086 that correspond to the input files. */
7089 i += lang_specific_extra_outfiles;
7090 outfiles = XCNEWVEC (const char *, i);
7092 /* Record which files were specified explicitly as link input. */
7094 explicit_link_files = XCNEWVEC (char, n_infiles);
7097 combine_inputs = true;
7099 combine_inputs = false;
7101 for (i = 0; (int) i < n_infiles; i++)
7103 const char *name = infiles[i].name;
7104 struct compiler *compiler = lookup_compiler (name,
7106 infiles[i].language);
7108 if (compiler && !(compiler->combinable))
7109 combine_inputs = false;
7111 if (lang_n_infiles > 0 && compiler != input_file_compiler
7112 && infiles[i].language && infiles[i].language[0] != '*')
7113 infiles[i].incompiler = compiler;
7117 input_file_compiler = compiler;
7118 infiles[i].incompiler = compiler;
7122 /* Since there is no compiler for this input file, assume it is a
7124 explicit_link_files[i] = 1;
7125 infiles[i].incompiler = NULL;
7127 infiles[i].compiled = false;
7128 infiles[i].preprocessed = false;
7131 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7132 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7134 if (combine_flag && save_temps_flag)
7136 bool save_combine_inputs = combine_inputs;
7137 /* Must do a separate pre-processing pass for C & Objective-C files, to
7138 obtain individual .i files. */
7140 combine_inputs = false;
7141 for (i = 0; (int) i < n_infiles; i++)
7143 int this_file_error = 0;
7145 input_file_number = i;
7146 set_input (infiles[i].name);
7147 if (infiles[i].incompiler
7148 && (infiles[i].incompiler)->needs_preprocessing)
7149 input_file_compiler = infiles[i].incompiler;
7153 if (input_file_compiler)
7155 if (input_file_compiler->spec[0] == '#')
7157 error ("%s: %s compiler not installed on this system",
7158 gcc_input_filename, &input_file_compiler->spec[1]);
7159 this_file_error = 1;
7163 value = do_spec (input_file_compiler->spec);
7164 infiles[i].preprocessed = true;
7165 if (!have_o_argbuf_index)
7166 fatal_error ("spec %qs is invalid",
7167 input_file_compiler->spec);
7168 infiles[i].name = argbuf[have_o_argbuf_index];
7169 infiles[i].incompiler
7170 = lookup_compiler (infiles[i].name,
7171 strlen (infiles[i].name),
7172 infiles[i].language);
7175 this_file_error = 1;
7179 if (this_file_error)
7181 delete_failure_queue ();
7185 clear_failure_queue ();
7187 combine_inputs = save_combine_inputs;
7190 for (i = 0; (int) i < n_infiles; i++)
7192 int this_file_error = 0;
7194 /* Tell do_spec what to substitute for %i. */
7196 input_file_number = i;
7197 set_input (infiles[i].name);
7199 if (infiles[i].compiled)
7202 /* Use the same thing in %o, unless cp->spec says otherwise. */
7204 outfiles[i] = gcc_input_filename;
7206 /* Figure out which compiler from the file's suffix. */
7208 if (! combine_inputs)
7210 = lookup_compiler (infiles[i].name, input_filename_length,
7211 infiles[i].language);
7213 input_file_compiler = infiles[i].incompiler;
7215 if (input_file_compiler)
7217 /* Ok, we found an applicable compiler. Run its spec. */
7219 if (input_file_compiler->spec[0] == '#')
7221 error ("%s: %s compiler not installed on this system",
7222 gcc_input_filename, &input_file_compiler->spec[1]);
7223 this_file_error = 1;
7229 if (debug_check_temp_file[0])
7230 free (debug_check_temp_file[0]);
7231 debug_check_temp_file[0] = NULL;
7233 if (debug_check_temp_file[1])
7234 free (debug_check_temp_file[1]);
7235 debug_check_temp_file[1] = NULL;
7238 value = do_spec (input_file_compiler->spec);
7239 infiles[i].compiled = true;
7241 this_file_error = 1;
7242 else if (compare_debug && debug_check_temp_file[0])
7245 inform (0, "recompiling with -fcompare-debug");
7247 compare_debug = -compare_debug;
7248 n_switches = n_switches_debug_check[1];
7249 switches = switches_debug_check[1];
7251 value = do_spec (input_file_compiler->spec);
7253 compare_debug = -compare_debug;
7254 n_switches = n_switches_debug_check[0];
7255 switches = switches_debug_check[0];
7259 error ("during -fcompare-debug recompilation");
7260 this_file_error = 1;
7263 gcc_assert (debug_check_temp_file[1]
7264 && strcmp (debug_check_temp_file[0],
7265 debug_check_temp_file[1]));
7268 inform (0, "comparing final insns dumps");
7270 if (compare_files (debug_check_temp_file))
7271 this_file_error = 1;
7276 if (debug_check_temp_file[0])
7277 free (debug_check_temp_file[0]);
7278 debug_check_temp_file[0] = NULL;
7280 if (debug_check_temp_file[1])
7281 free (debug_check_temp_file[1]);
7282 debug_check_temp_file[1] = NULL;
7287 /* If this file's name does not contain a recognized suffix,
7288 record it as explicit linker input. */
7291 explicit_link_files[i] = 1;
7293 /* Clear the delete-on-failure queue, deleting the files in it
7294 if this compilation failed. */
7296 if (this_file_error)
7298 delete_failure_queue ();
7301 /* If this compilation succeeded, don't delete those files later. */
7302 clear_failure_queue ();
7305 /* Reset the input file name to the first compile/object file name, for use
7306 with %b in LINK_SPEC. We use the first input file that we can find
7307 a compiler to compile it instead of using infiles.language since for
7308 languages other than C we use aliases that we then lookup later. */
7313 for (i = 0; i < n_infiles ; i++)
7314 if (infiles[i].language && infiles[i].language[0] != '*')
7316 set_input (infiles[i].name);
7323 /* Make sure INPUT_FILE_NUMBER points to first available open
7325 input_file_number = n_infiles;
7326 if (lang_specific_pre_link ())
7330 /* Determine if there are any linker input files. */
7331 num_linker_inputs = 0;
7332 for (i = 0; (int) i < n_infiles; i++)
7333 if (explicit_link_files[i] || outfiles[i] != NULL)
7334 num_linker_inputs++;
7336 /* Run ld to link all the compiler output files. */
7338 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
7340 int tmp = execution_count;
7341 const char *fuse_linker_plugin = "fuse-linker-plugin";
7343 /* We'll use ld if we can't find collect2. */
7344 if (! strcmp (linker_name_spec, "collect2"))
7346 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7348 linker_name_spec = "ld";
7351 if (switch_matches (fuse_linker_plugin,
7352 fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7354 linker_plugin_file_spec = find_a_file (&exec_prefixes,
7355 "liblto_plugin.so", R_OK,
7357 if (!linker_plugin_file_spec)
7358 fatal_error ("-fuse-linker-plugin, but liblto_plugin.so not found");
7360 lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7362 if (!lto_libgcc_spec)
7363 fatal_error ("could not find libgcc.a");
7365 lto_gcc_spec = argv[0];
7367 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7369 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7370 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7372 if (print_subprocess_help == 1)
7374 printf (_("\nLinker options\n==============\n\n"));
7375 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7376 " to the linker.\n\n"));
7379 value = do_spec (link_command_spec);
7382 linker_was_run = (tmp != execution_count);
7385 /* If options said don't run linker,
7386 complain about input files to be given to the linker. */
7388 if (! linker_was_run && !seen_error ())
7389 for (i = 0; (int) i < n_infiles; i++)
7390 if (explicit_link_files[i]
7391 && !(infiles[i].language && infiles[i].language[0] == '*'))
7392 warning (0, "%s: linker input file unused because linking not done",
7395 /* Delete some or all of the temporary files we made. */
7398 delete_failure_queue ();
7399 delete_temp_files ();
7401 if (print_help_list)
7403 printf (("\nFor bug reporting instructions, please see:\n"));
7404 printf ("%s\n", bug_report_url);
7407 return (signal_count != 0 ? 2
7408 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7412 /* Find the proper compilation spec for the file name NAME,
7413 whose length is LENGTH. LANGUAGE is the specified language,
7414 or 0 if this file is to be passed to the linker. */
7416 static struct compiler *
7417 lookup_compiler (const char *name, size_t length, const char *language)
7419 struct compiler *cp;
7421 /* If this was specified by the user to be a linker input, indicate that. */
7422 if (language != 0 && language[0] == '*')
7425 /* Otherwise, look for the language, if one is spec'd. */
7428 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7429 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7432 error ("language %s not recognized", language);
7436 /* Look for a suffix. */
7437 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7439 if (/* The suffix `-' matches only the file name `-'. */
7440 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7441 || (strlen (cp->suffix) < length
7442 /* See if the suffix matches the end of NAME. */
7443 && !strcmp (cp->suffix,
7444 name + length - strlen (cp->suffix))
7449 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7450 /* Look again, but case-insensitively this time. */
7452 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7454 if (/* The suffix `-' matches only the file name `-'. */
7455 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7456 || (strlen (cp->suffix) < length
7457 /* See if the suffix matches the end of NAME. */
7458 && ((!strcmp (cp->suffix,
7459 name + length - strlen (cp->suffix))
7460 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7461 && !strcasecmp (cp->suffix,
7462 name + length - strlen (cp->suffix)))
7468 if (cp >= compilers)
7470 if (cp->spec[0] != '@')
7471 /* A non-alias entry: return it. */
7474 /* An alias entry maps a suffix to a language.
7475 Search for the language; pass 0 for NAME and LENGTH
7476 to avoid infinite recursion if language not found. */
7477 return lookup_compiler (NULL, 0, cp->spec + 1);
7483 save_string (const char *s, int len)
7485 char *result = XNEWVEC (char, len + 1);
7487 memcpy (result, s, len);
7493 pfatal_with_name (const char *name)
7495 perror_with_name (name);
7496 delete_temp_files ();
7501 perror_with_name (const char *name)
7503 error ("%s: %m", name);
7507 validate_switches_from_spec (const char *spec)
7509 const char *p = spec;
7512 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7513 /* We have a switch spec. */
7514 p = validate_switches (p + 1);
7518 validate_all_switches (void)
7520 struct compiler *comp;
7521 struct spec_list *spec;
7523 for (comp = compilers; comp->spec; comp++)
7524 validate_switches_from_spec (comp->spec);
7526 /* Look through the linked list of specs read from the specs file. */
7527 for (spec = specs; spec; spec = spec->next)
7528 validate_switches_from_spec (*spec->ptr_spec);
7530 validate_switches_from_spec (link_command_spec);
7533 /* Look at the switch-name that comes after START
7534 and mark as valid all supplied switches that match it. */
7537 validate_switches (const char *start)
7539 const char *p = start;
7543 bool suffix = false;
7544 bool starred = false;
7546 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7555 if (*p == '.' || *p == ',')
7559 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7560 || *p == ',' || *p == '.' || *p == '@')
7565 starred = true, p++;
7571 /* Mark all matching switches as valid. */
7572 for (i = 0; i < n_switches; i++)
7573 if (!strncmp (switches[i].part1, atom, len)
7574 && (starred || switches[i].part1[len] == 0))
7575 switches[i].validated = 1;
7579 if (*p && (p[-1] == '|' || p[-1] == '&'))
7582 if (*p && p[-1] == ':')
7584 while (*p && *p != ';' && *p != '}')
7589 if (*p == '{' || *p == '<')
7590 p = validate_switches (p+1);
7591 else if (p[0] == 'W' && p[1] == '{')
7592 p = validate_switches (p+2);
7599 if (*p && p[-1] == ';')
7613 static struct mdswitchstr *mdswitches;
7614 static int n_mdswitches;
7616 /* Check whether a particular argument was used. The first time we
7617 canonicalize the switches to keep only the ones we care about. */
7620 used_arg (const char *p, int len)
7625 const char *replace;
7630 static struct mswitchstr *mswitches;
7631 static int n_mswitches;
7636 struct mswitchstr *matches;
7640 /* Break multilib_matches into the component strings of string
7641 and replacement string. */
7642 for (q = multilib_matches; *q != '\0'; q++)
7647 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7649 q = multilib_matches;
7658 fatal_error ("multilib spec %qs is invalid",
7663 matches[i].len = q - matches[i].str;
7665 matches[i].replace = ++q;
7666 while (*q != ';' && *q != '\0')
7669 goto invalid_matches;
7672 matches[i].rep_len = q - matches[i].replace;
7678 /* Now build a list of the replacement string for switches that we care
7679 about. Make sure we allocate at least one entry. This prevents
7680 xmalloc from calling fatal, and prevents us from re-executing this
7683 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7684 for (i = 0; i < n_switches; i++)
7685 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7687 int xlen = strlen (switches[i].part1);
7688 for (j = 0; j < cnt; j++)
7689 if (xlen == matches[j].len
7690 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7692 mswitches[n_mswitches].str = matches[j].replace;
7693 mswitches[n_mswitches].len = matches[j].rep_len;
7694 mswitches[n_mswitches].replace = (char *) 0;
7695 mswitches[n_mswitches].rep_len = 0;
7701 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7702 on the command line nor any options mutually incompatible with
7704 for (i = 0; i < n_mdswitches; i++)
7708 for (q = multilib_options; *q != '\0'; q++)
7714 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7715 || strchr (" /", q[mdswitches[i].len]) == NULL)
7717 while (*q != ' ' && *q != '/' && *q != '\0')
7724 if (*q != ' ' && *q != '\0')
7726 while (*r != ' ' && *r != '\0')
7729 while (*q != ' ' && *q != '/' && *q != '\0')
7732 if (used_arg (r, q - r))
7737 mswitches[n_mswitches].str = mdswitches[i].str;
7738 mswitches[n_mswitches].len = mdswitches[i].len;
7739 mswitches[n_mswitches].replace = (char *) 0;
7740 mswitches[n_mswitches].rep_len = 0;
7753 for (i = 0; i < n_mswitches; i++)
7754 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7761 default_arg (const char *p, int len)
7765 for (i = 0; i < n_mdswitches; i++)
7766 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7772 /* Work out the subdirectory to use based on the options. The format of
7773 multilib_select is a list of elements. Each element is a subdirectory
7774 name followed by a list of options followed by a semicolon. The format
7775 of multilib_exclusions is the same, but without the preceding
7776 directory. First gcc will check the exclusions, if none of the options
7777 beginning with an exclamation point are present, and all of the other
7778 options are present, then we will ignore this completely. Passing
7779 that, gcc will consider each multilib_select in turn using the same
7780 rules for matching the options. If a match is found, that subdirectory
7784 set_multilib_dir (void)
7787 unsigned int this_path_len;
7788 const char *this_path, *this_arg;
7789 const char *start, *end;
7791 int ok, ndfltok, first;
7794 start = multilib_defaults;
7795 while (*start == ' ' || *start == '\t')
7797 while (*start != '\0')
7800 while (*start != ' ' && *start != '\t' && *start != '\0')
7802 while (*start == ' ' || *start == '\t')
7810 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7811 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7813 while (*start == ' ' || *start == '\t')
7819 for (end = start + 1;
7820 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7823 obstack_grow (&multilib_obstack, start, end - start);
7824 obstack_1grow (&multilib_obstack, 0);
7825 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7826 mdswitches[i++].len = end - start;
7833 p = multilib_exclusions;
7836 /* Ignore newlines. */
7843 /* Check the arguments. */
7850 fatal_error ("multilib exclusions %qs is invalid",
7851 multilib_exclusions);
7861 while (*p != ' ' && *p != ';')
7864 goto invalid_exclusions;
7868 if (*this_arg != '!')
7876 ok = used_arg (this_arg, p - this_arg);
7891 p = multilib_select;
7894 /* Ignore newlines. */
7901 /* Get the initial path. */
7908 fatal_error ("multilib select %qs is invalid",
7913 this_path_len = p - this_path;
7915 /* Check the arguments. */
7922 goto invalid_select;
7931 while (*p != ' ' && *p != ';')
7934 goto invalid_select;
7938 if (*this_arg != '!')
7946 /* If this is a default argument, we can just ignore it.
7947 This is true even if this_arg begins with '!'. Beginning
7948 with '!' does not mean that this argument is necessarily
7949 inappropriate for this library: it merely means that
7950 there is a more specific library which uses this
7951 argument. If this argument is a default, we need not
7952 consider that more specific library. */
7953 ok = used_arg (this_arg, p - this_arg);
7960 if (default_arg (this_arg, p - this_arg))
7969 if (this_path_len != 1
7970 || this_path[0] != '.')
7972 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7975 strncpy (new_multilib_dir, this_path, this_path_len);
7976 new_multilib_dir[this_path_len] = '\0';
7977 q = strchr (new_multilib_dir, ':');
7980 multilib_dir = new_multilib_dir;
7987 const char *q = this_path, *end = this_path + this_path_len;
7989 while (q < end && *q != ':')
7993 char *new_multilib_os_dir = XNEWVEC (char, end - q);
7994 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7995 new_multilib_os_dir[end - q - 1] = '\0';
7996 multilib_os_dir = new_multilib_os_dir;
8004 if (multilib_dir == NULL && multilib_os_dir != NULL
8005 && strcmp (multilib_os_dir, ".") == 0)
8007 free (CONST_CAST (char *, multilib_os_dir));
8008 multilib_os_dir = NULL;
8010 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8011 multilib_os_dir = multilib_dir;
8014 /* Print out the multiple library subdirectory selection
8015 information. This prints out a series of lines. Each line looks
8016 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8017 required. Only the desired options are printed out, the negative
8018 matches. The options are print without a leading dash. There are
8019 no spaces to make it easy to use the information in the shell.
8020 Each subdirectory is printed only once. This assumes the ordering
8021 generated by the genmultilib script. Also, we leave out ones that match
8025 print_multilib_info (void)
8027 const char *p = multilib_select;
8028 const char *last_path = 0, *this_path;
8030 unsigned int last_path_len = 0;
8035 /* Ignore newlines. */
8042 /* Get the initial path. */
8049 fatal_error ("multilib select %qs is invalid", multilib_select);
8055 /* When --disable-multilib was used but target defines
8056 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8057 to find multilib_os_dir, so skip them from output. */
8058 if (this_path[0] == '.' && this_path[1] == ':')
8061 /* Check for matches with the multilib_exclusions. We don't bother
8062 with the '!' in either list. If any of the exclusion rules match
8063 all of its options with the select rule, we skip it. */
8065 const char *e = multilib_exclusions;
8066 const char *this_arg;
8071 /* Ignore newlines. */
8078 /* Check the arguments. */
8087 fatal_error ("multilib exclusion %qs is invalid",
8088 multilib_exclusions);
8099 while (*e != ' ' && *e != ';')
8102 goto invalid_exclusion;
8110 int len = e - this_arg;
8113 goto invalid_select;
8117 while (*q != ' ' && *q != ';')
8120 goto invalid_select;
8124 if (! strncmp (arg, this_arg,
8125 (len < q - arg) ? q - arg : len)
8126 || default_arg (this_arg, e - this_arg))
8156 /* If this is a duplicate, skip it. */
8157 skip = (last_path != 0
8158 && (unsigned int) (p - this_path) == last_path_len
8159 && ! strncmp (last_path, this_path, last_path_len));
8161 last_path = this_path;
8162 last_path_len = p - this_path;
8165 /* If this directory requires any default arguments, we can skip
8166 it. We will already have printed a directory identical to
8167 this one which does not require that default argument. */
8178 goto invalid_select;
8185 while (*q != ' ' && *q != ';')
8188 goto invalid_select;
8193 && default_arg (arg, q - arg))
8208 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8219 goto invalid_select;
8227 use_arg = *p != '!';
8232 while (*p != ' ' && *p != ';')
8235 goto invalid_select;
8247 /* If there are extra options, print them now. */
8248 if (multilib_extra && *multilib_extra)
8250 int print_at = TRUE;
8253 for (q = multilib_extra; *q != '\0'; q++)
8274 /* getenv built-in spec function.
8276 Returns the value of the environment variable given by its first
8277 argument, concatenated with the second argument. If the
8278 environment variable is not defined, a fatal error is issued. */
8281 getenv_spec_function (int argc, const char **argv)
8291 value = getenv (argv[0]);
8293 fatal_error ("environment variable %qs not defined", argv[0]);
8295 /* We have to escape every character of the environment variable so
8296 they are not interpreted as active spec characters. A
8297 particularly painful case is when we are reading a variable
8298 holding a windows path complete with \ separators. */
8299 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8300 result = XNEWVAR (char, len);
8301 for (ptr = result; *value; ptr += 2)
8307 strcpy (ptr, argv[1]);
8312 /* if-exists built-in spec function.
8314 Checks to see if the file specified by the absolute pathname in
8315 ARGS exists. Returns that pathname if found.
8317 The usual use for this function is to check for a library file
8318 (whose name has been expanded with %s). */
8321 if_exists_spec_function (int argc, const char **argv)
8323 /* Must have only one argument. */
8324 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8330 /* if-exists-else built-in spec function.
8332 This is like if-exists, but takes an additional argument which
8333 is returned if the first argument does not exist. */
8336 if_exists_else_spec_function (int argc, const char **argv)
8338 /* Must have exactly two arguments. */
8342 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8348 /* replace-outfile built-in spec function.
8350 This looks for the first argument in the outfiles array's name and
8351 replaces it with the second argument. */
8354 replace_outfile_spec_function (int argc, const char **argv)
8357 /* Must have exactly two arguments. */
8361 for (i = 0; i < n_infiles; i++)
8363 if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8364 outfiles[i] = xstrdup (argv[1]);
8369 /* Given two version numbers, compares the two numbers.
8370 A version number must match the regular expression
8371 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8374 compare_version_strings (const char *v1, const char *v2)
8379 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8380 REG_EXTENDED | REG_NOSUB) != 0)
8382 rresult = regexec (&r, v1, 0, NULL, 0);
8383 if (rresult == REG_NOMATCH)
8384 fatal_error ("invalid version number %qs", v1);
8385 else if (rresult != 0)
8387 rresult = regexec (&r, v2, 0, NULL, 0);
8388 if (rresult == REG_NOMATCH)
8389 fatal_error ("invalid version number %qs", v2);
8390 else if (rresult != 0)
8393 return strverscmp (v1, v2);
8397 /* version_compare built-in spec function.
8399 This takes an argument of the following form:
8401 <comparison-op> <arg1> [<arg2>] <switch> <result>
8403 and produces "result" if the comparison evaluates to true,
8404 and nothing if it doesn't.
8406 The supported <comparison-op> values are:
8408 >= true if switch is a later (or same) version than arg1
8410 < true if switch is an earlier version than arg1
8412 >< true if switch is arg1 or later, and earlier than arg2
8413 <> true if switch is earlier than arg1 or is arg2 or later
8415 If the switch is not present, the condition is false unless
8416 the first character of the <comparison-op> is '!'.
8419 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8420 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8423 version_compare_spec_function (int argc, const char **argv)
8427 const char *switch_value = NULL;
8432 fatal_error ("too few arguments to %%:version-compare");
8433 if (argv[0][0] == '\0')
8435 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8437 if (argc != nargs + 3)
8438 fatal_error ("too many arguments to %%:version-compare");
8440 switch_len = strlen (argv[nargs + 1]);
8441 for (i = 0; i < n_switches; i++)
8442 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8443 && check_live_switch (i, switch_len))
8444 switch_value = switches[i].part1 + switch_len;
8446 if (switch_value == NULL)
8450 comp1 = compare_version_strings (switch_value, argv[1]);
8452 comp2 = compare_version_strings (switch_value, argv[2]);
8454 comp2 = -1; /* This value unused. */
8457 switch (argv[0][0] << 8 | argv[0][1])
8459 case '>' << 8 | '=':
8460 result = comp1 >= 0;
8462 case '!' << 8 | '<':
8463 result = comp1 >= 0 || switch_value == NULL;
8468 case '!' << 8 | '>':
8469 result = comp1 < 0 || switch_value == NULL;
8471 case '>' << 8 | '<':
8472 result = comp1 >= 0 && comp2 < 0;
8474 case '<' << 8 | '>':
8475 result = comp1 < 0 || comp2 >= 0;
8479 fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8484 return argv[nargs + 2];
8487 /* %:include builtin spec function. This differs from %include in that it
8488 can be nested inside a spec, and thus be conditionalized. It takes
8489 one argument, the filename, and looks for it in the startfile path.
8490 The result is always NULL, i.e. an empty expansion. */
8493 include_spec_function (int argc, const char **argv)
8500 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8501 read_specs (file ? file : argv[0], FALSE);
8506 /* %:find-file spec function. This function replaces its argument by
8507 the file found thru find_file, that is the -print-file-name gcc
8510 find_file_spec_function (int argc, const char **argv)
8517 file = find_file (argv[0]);
8522 /* %:find-plugindir spec function. This function replaces its argument
8523 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
8524 is the -print-file-name gcc program option. */
8526 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8533 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8538 /* %:print-asm-header spec function. Print a banner to say that the
8539 following output is from the assembler. */
8542 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8543 const char **argv ATTRIBUTE_UNUSED)
8545 printf (_("Assembler options\n=================\n\n"));
8546 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8551 /* Compute a timestamp to initialize flag_random_seed. */
8554 get_local_tick (void)
8558 /* Get some more or less random data. */
8559 #ifdef HAVE_GETTIMEOFDAY
8563 gettimeofday (&tv, NULL);
8564 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8568 time_t now = time (NULL);
8570 if (now != (time_t)-1)
8571 ret = (unsigned) now;
8578 /* %:compare-debug-dump-opt spec function. Save the last argument,
8579 expected to be the last -fdump-final-insns option, or generate a
8583 compare_debug_dump_opt_spec_function (int arg,
8584 const char **argv ATTRIBUTE_UNUSED)
8589 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8592 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8594 do_spec_2 ("%{fdump-final-insns=*:%*}");
8595 do_spec_1 (" ", 0, NULL);
8597 if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8602 name = xstrdup (argv[argbuf_index - 1]);
8607 const char *ext = NULL;
8609 if (argbuf_index > 0)
8611 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8614 else if (!compare_debug)
8617 do_spec_2 ("%g.gkd");
8619 do_spec_1 (" ", 0, NULL);
8621 gcc_assert (argbuf_index > 0);
8623 name = concat (argbuf[argbuf_index - 1], ext, NULL);
8625 ret = concat ("-fdump-final-insns=", name, NULL);
8628 which = compare_debug < 0;
8629 debug_check_temp_file[which] = name;
8633 unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8635 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8639 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8648 static const char *debug_auxbase_opt;
8650 /* %:compare-debug-self-opt spec function. Expands to the options
8651 that are to be passed in the second compilation of
8655 compare_debug_self_opt_spec_function (int arg,
8656 const char **argv ATTRIBUTE_UNUSED)
8659 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8661 if (compare_debug >= 0)
8664 do_spec_2 ("%{c|S:%{o*:%*}}");
8665 do_spec_1 (" ", 0, NULL);
8667 if (argbuf_index > 0)
8668 debug_auxbase_opt = concat ("-auxbase-strip ",
8669 argbuf[argbuf_index - 1],
8672 debug_auxbase_opt = NULL;
8675 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8676 %<fdump-final-insns=* -w -S -o %j \
8677 %{!fcompare-debug-second:-fcompare-debug-second} \
8678 ", compare_debug_opt, NULL);
8681 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8682 options that are to be passed in the second compilation of
8683 compare-debug. It expects, as an argument, the basename of the
8684 current input file name, with the .gk suffix appended to it. */
8687 compare_debug_auxbase_opt_spec_function (int arg,
8694 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8697 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8699 if (compare_debug >= 0)
8702 len = strlen (argv[0]);
8703 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8704 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8705 "does not end in .gk");
8707 if (debug_auxbase_opt)
8708 return debug_auxbase_opt;
8710 #define OPT "-auxbase "
8713 name = (char*) xmalloc (sizeof (OPT) + len);
8714 memcpy (name, OPT, sizeof (OPT) - 1);
8715 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8716 name[sizeof (OPT) - 1 + len] = '\0';