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
89 # include <sys/mman.h>
91 /* This is on Solaris. */
92 # include <sys/types.h>
97 # define MAP_FAILED ((void *)-1)
100 /* By default there is no special suffix for target executables. */
101 /* FIXME: when autoconf is fixed, remove the host check - dj */
102 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
103 #define HAVE_TARGET_EXECUTABLE_SUFFIX
106 /* By default there is no special suffix for host executables. */
107 #ifdef HOST_EXECUTABLE_SUFFIX
108 #define HAVE_HOST_EXECUTABLE_SUFFIX
110 #define HOST_EXECUTABLE_SUFFIX ""
113 /* By default, the suffix for target object files is ".o". */
114 #ifdef TARGET_OBJECT_SUFFIX
115 #define HAVE_TARGET_OBJECT_SUFFIX
117 #define TARGET_OBJECT_SUFFIX ".o"
120 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
122 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
123 #ifndef LIBRARY_PATH_ENV
124 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
128 #define kill(p,s) raise(s)
131 /* If a stage of compilation returns an exit status >= 1,
132 compilation of that file ceases. */
134 #define MIN_FATAL_STATUS 1
136 /* Flag set by cppspec.c to 1. */
139 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
140 static bool at_file_supplied;
142 /* Flag saying to pass the greatest exit code returned by a sub-process
143 to the calling program. */
144 static int pass_exit_codes;
146 /* Definition of string containing the arguments given to configure. */
147 #include "configargs.h"
149 /* Flag saying to print the directories gcc will search through looking for
150 programs, libraries, etc. */
152 static int print_search_dirs;
154 /* Flag saying to print the full filename of this file
155 as found through our usual search mechanism. */
157 static const char *print_file_name = NULL;
159 /* As print_file_name, but search for executable file. */
161 static const char *print_prog_name = NULL;
163 /* Flag saying to print the relative path we'd use to
164 find libgcc.a given the current compiler flags. */
166 static int print_multi_directory;
168 static int print_sysroot;
170 /* Flag saying to print the relative path we'd use to
171 find OS libraries given the current compiler flags. */
173 static int print_multi_os_directory;
175 /* Flag saying to print the list of subdirectories and
176 compiler flags used to select them in a standard form. */
178 static int print_multi_lib;
180 /* Flag saying to print the command line options understood by gcc and its
183 static int print_help_list;
185 /* Flag saying to print the version of gcc and its sub-processes. */
187 static int print_version;
189 /* Flag saying to print the sysroot suffix used for searching for
192 static int print_sysroot_headers_suffix;
194 /* Flag indicating whether we should print the command and arguments */
196 static int verbose_flag;
198 /* Flag indicating whether we should ONLY print the command and
199 arguments (like verbose_flag) without executing the command.
200 Displayed arguments are quoted so that the generated command
201 line is suitable for execution. This is intended for use in
202 shell scripts to capture the driver-generated command line. */
203 static int verbose_only_flag;
205 /* Flag indicating how to print command line options of sub-processes. */
207 static int print_subprocess_help;
209 /* Flag indicating whether we should report subprocess execution times
210 (if this is supported by the system - see pexecute.c). */
212 static int report_times;
214 /* Whether we should report subprocess execution times to a file. */
216 FILE *report_times_to_file = NULL;
218 /* Nonzero means place this string before uses of /, so that include
219 and library files can be found in an alternate location. */
221 #ifdef TARGET_SYSTEM_ROOT
222 static const char *target_system_root = TARGET_SYSTEM_ROOT;
224 static const char *target_system_root = 0;
227 /* Nonzero means pass the updated target_system_root to the compiler. */
229 static int target_system_root_changed;
231 /* Nonzero means append this string to target_system_root. */
233 static const char *target_sysroot_suffix = 0;
235 /* Nonzero means append this string to target_system_root for headers. */
237 static const char *target_sysroot_hdrs_suffix = 0;
239 /* Nonzero means write "temp" files in source directory
240 and use the source file's name in them, and don't delete them. */
242 static enum save_temps {
243 SAVE_TEMPS_NONE, /* no -save-temps */
244 SAVE_TEMPS_CWD, /* -save-temps in current directory */
245 SAVE_TEMPS_OBJ /* -save-temps in object directory */
248 /* Output file to use to get the object directory for -save-temps=obj */
249 static char *save_temps_prefix = 0;
250 static size_t save_temps_length = 0;
252 /* Nonzero means pass multiple source files to the compiler at one time. */
254 static int combine_flag = 0;
256 /* Nonzero means use pipes to communicate between subprocesses.
257 Overridden by either of the above two flags. */
259 static int use_pipes;
261 /* The compiler version. */
263 static const char *compiler_version;
265 /* The target version. */
267 static const char *const spec_version = DEFAULT_TARGET_VERSION;
269 /* The target machine. */
271 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
273 /* Nonzero if cross-compiling.
274 When -b is used, the value comes from the `specs' file. */
276 #ifdef CROSS_DIRECTORY_STRUCTURE
277 static const char *cross_compile = "1";
279 static const char *cross_compile = "0";
282 #ifdef MODIFY_TARGET_NAME
284 /* Information on how to alter the target name based on a command-line
285 switch. The only case we support now is simply appending or deleting a
286 string to or from the end of the first part of the configuration name. */
288 enum add_del {ADD, DELETE};
290 static const struct modify_target
292 const char *const sw;
293 const enum add_del add_del;
294 const char *const str;
296 modify_target[] = MODIFY_TARGET_NAME;
299 /* The number of errors that have occurred; the link phase will not be
300 run if this is nonzero. */
301 static int error_count = 0;
303 /* Greatest exit code of sub-processes that has been encountered up to
305 static int greatest_status = 1;
307 /* This is the obstack which we use to allocate many strings. */
309 static struct obstack obstack;
311 /* This is the obstack to build an environment variable to pass to
312 collect2 that describes all of the relevant switches of what to
313 pass the compiler in building the list of pointers to constructors
316 static struct obstack collect_obstack;
318 /* This is a list of a wrapper program and its arguments.
319 e.g. wrapper_string of "strace,-c"
320 will cause all programs to run as
321 strace -c program arguments
324 static const char *wrapper_string;
326 /* Forward declaration for prototypes. */
330 static void init_spec (void);
331 static void store_arg (const char *, int, int);
332 static void insert_wrapper (const char *);
333 static char *load_specs (const char *);
334 static void read_specs (const char *, int);
335 static void set_spec (const char *, const char *);
336 static struct compiler *lookup_compiler (const char *, size_t, const char *);
337 static char *build_search_list (const struct path_prefix *, const char *,
339 static void xputenv (const char *);
340 static void putenv_from_prefixes (const struct path_prefix *, const char *,
342 static int access_check (const char *, int);
343 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
344 static void add_prefix (struct path_prefix *, const char *, const char *,
346 static void add_sysrooted_prefix (struct path_prefix *, const char *,
347 const char *, int, int, int);
348 static void translate_options (int *, const char *const **);
349 static char *skip_whitespace (char *);
350 static void delete_if_ordinary (const char *);
351 static void delete_temp_files (void);
352 static void delete_failure_queue (void);
353 static void clear_failure_queue (void);
354 static int check_live_switch (int, int);
355 static const char *handle_braces (const char *);
356 static inline bool input_suffix_matches (const char *, const char *);
357 static inline bool switch_matches (const char *, const char *, int);
358 static inline void mark_matching_switches (const char *, const char *, int);
359 static inline void process_marked_switches (void);
360 static const char *process_brace_body (const char *, const char *, const char *, int, int);
361 static const struct spec_function *lookup_spec_function (const char *);
362 static const char *eval_spec_function (const char *, const char *);
363 static const char *handle_spec_function (const char *);
364 static char *save_string (const char *, int);
365 static void set_collect_gcc_options (void);
366 static int do_spec_1 (const char *, int, const char *);
367 static int do_spec_2 (const char *);
368 static void do_option_spec (const char *, const char *);
369 static void do_self_spec (const char *);
370 static const char *find_file (const char *);
371 static int is_directory (const char *, bool);
372 static const char *validate_switches (const char *);
373 static void validate_all_switches (void);
374 static inline void validate_switches_from_spec (const char *);
375 static void give_switch (int, int);
376 static int used_arg (const char *, int);
377 static int default_arg (const char *, int);
378 static void set_multilib_dir (void);
379 static void print_multilib_info (void);
380 static void perror_with_name (const char *);
381 static void fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
382 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
383 static void display_help (void);
384 static void add_preprocessor_option (const char *, int);
385 static void add_assembler_option (const char *, int);
386 static void add_linker_option (const char *, int);
387 static void process_command (int, const char **);
388 static int execute (void);
389 static void alloc_args (void);
390 static void clear_args (void);
391 static void fatal_error (int);
392 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
393 static void init_gcc_specs (struct obstack *, const char *, const char *,
396 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
397 static const char *convert_filename (const char *, int, int);
400 static const char *getenv_spec_function (int, const char **);
401 static const char *if_exists_spec_function (int, const char **);
402 static const char *if_exists_else_spec_function (int, const char **);
403 static const char *replace_outfile_spec_function (int, const char **);
404 static const char *version_compare_spec_function (int, const char **);
405 static const char *include_spec_function (int, const char **);
406 static const char *find_file_spec_function (int, const char **);
407 static const char *print_asm_header_spec_function (int, const char **);
408 static const char *compare_debug_dump_opt_spec_function (int, const char **);
409 static const char *compare_debug_self_opt_spec_function (int, const char **);
410 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
412 /* The Specs Language
414 Specs are strings containing lines, each of which (if not blank)
415 is made up of a program name, and arguments separated by spaces.
416 The program name must be exact and start from root, since no path
417 is searched and it is unreliable to depend on the current working directory.
418 Redirection of input or output is not supported; the subprograms must
419 accept filenames saying what files to read and write.
421 In addition, the specs can contain %-sequences to substitute variable text
422 or for conditional text. Here is a table of all defined %-sequences.
423 Note that spaces are not generated automatically around the results of
424 expanding these sequences; therefore, you can concatenate them together
425 or with constant text in a single argument.
427 %% substitute one % into the program name or argument.
428 %i substitute the name of the input file being processed.
429 %b substitute the basename of the input file being processed.
430 This is the substring up to (and not including) the last period
431 and not including the directory unless -save-temps was specified
432 to put temporaries in a different location.
433 %B same as %b, but include the file suffix (text after the last period).
435 substitute a file name that has suffix SUFFIX and is chosen
436 once per compilation, and mark the argument a la %d. To reduce
437 exposure to denial-of-service attacks, the file name is now
438 chosen in a way that is hard to predict even when previously
439 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
440 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
441 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
442 had been pre-processed. Previously, %g was simply substituted
443 with a file name chosen once per compilation, without regard
444 to any appended suffix (which was therefore treated just like
445 ordinary text), making such attacks more likely to succeed.
447 like %g, but if -pipe is in effect, expands simply to "-".
449 like %g, but if -pipe is in effect, expands to nothing. (We have both
450 %| and %m to accommodate differences between system assemblers; see
451 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
453 like %g, but generates a new temporary file name even if %uSUFFIX
456 substitutes the last file name generated with %uSUFFIX, generating a
457 new one if there is no such last file name. In the absence of any
458 %uSUFFIX, this is just like %gSUFFIX, except they don't share
459 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
460 would involve the generation of two distinct file names, one
461 for each `%g.s' and another for each `%U.s'. Previously, %U was
462 simply substituted with a file name chosen for the previous %u,
463 without regard to any appended suffix.
465 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
466 writable, and if save-temps is off; otherwise, substitute the name
467 of a temporary file, just like %u. This temporary file is not
468 meant for communication between processes, but rather as a junk
471 substitutes .SUFFIX for the suffixes of a matched switch's args when
472 it is subsequently output with %*. SUFFIX is terminated by the next
474 %d marks the argument containing or following the %d as a
475 temporary file name, so that that file will be deleted if GCC exits
476 successfully. Unlike %g, this contributes no text to the argument.
477 %w marks the argument containing or following the %w as the
478 "output file" of this compilation. This puts the argument
479 into the sequence of arguments that %o will substitute later.
480 %V indicates that this compilation produces no "output file".
482 like %{...} but mark last argument supplied within
483 as a file to be deleted on failure.
484 %o substitutes the names of all the output files, with spaces
485 automatically placed around them. You should write spaces
486 around the %o as well or the results are undefined.
487 %o is for use in the specs for running the linker.
488 Input files whose names have no recognized suffix are not compiled
489 at all, but they are included among the output files, so they will
491 %O substitutes the suffix for object files. Note that this is
492 handled specially when it immediately follows %g, %u, or %U
493 (with or without a suffix argument) because of the need for
494 those to form complete file names. The handling is such that
495 %O is treated exactly as if it had already been substituted,
496 except that %g, %u, and %U do not currently support additional
497 SUFFIX characters following %O as they would following, for
499 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
500 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
501 and -B options) and -imultilib as necessary.
502 %s current argument is the name of a library or startup file of some sort.
503 Search for that file in a standard list of directories
504 and substitute the full name found.
505 %eSTR Print STR as an error message. STR is terminated by a newline.
506 Use this when inconsistent options are detected.
507 %nSTR Print STR as a notice. STR is terminated by a newline.
508 %x{OPTION} Accumulate an option for %X.
509 %X Output the accumulated linker options specified by compilations.
510 %Y Output the accumulated assembler options specified by compilations.
511 %Z Output the accumulated preprocessor options specified by compilations.
512 %a process ASM_SPEC as a spec.
513 This allows config.h to specify part of the spec for running as.
514 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
515 used here. This can be used to run a post-processor after the
516 assembler has done its job.
517 %D Dump out a -L option for each directory in startfile_prefixes.
518 If multilib_dir is set, extra entries are generated with it affixed.
519 %l process LINK_SPEC as a spec.
520 %L process LIB_SPEC as a spec.
521 %G process LIBGCC_SPEC as a spec.
522 %R Output the concatenation of target_system_root and
523 target_sysroot_suffix.
524 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
525 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
526 %C process CPP_SPEC as a spec.
527 %1 process CC1_SPEC as a spec.
528 %2 process CC1PLUS_SPEC as a spec.
529 %* substitute the variable part of a matched option. (See below.)
530 Note that each comma in the substituted string is replaced by
532 %<S remove all occurrences of -S from the command line.
533 Note - this command is position dependent. % commands in the
534 spec string before this one will see -S, % commands in the
535 spec string after this one will not.
536 %<S* remove all occurrences of all switches beginning with -S from the
539 Call the named function FUNCTION, passing it ARGS. ARGS is
540 first processed as a nested spec string, then split into an
541 argument vector in the usual fashion. The function returns
542 a string which is processed as if it had appeared literally
543 as part of the current spec.
544 %{S} substitutes the -S switch, if that switch was given to GCC.
545 If that switch was not specified, this substitutes nothing.
546 Here S is a metasyntactic variable.
547 %{S*} substitutes all the switches specified to GCC whose names start
548 with -S. This is used for -o, -I, etc; switches that take
549 arguments. GCC considers `-o foo' as being one switch whose
550 name starts with `o'. %{o*} would substitute this text,
551 including the space; thus, two arguments would be generated.
552 %{S*&T*} likewise, but preserve order of S and T options (the order
553 of S and T in the spec is not significant). Can be any number
554 of ampersand-separated variables; for each the wild card is
555 optional. Useful for CPP as %{D*&U*&A*}.
557 %{S:X} substitutes X, if the -S switch was given to GCC.
558 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
559 %{S*:X} substitutes X if one or more switches whose names start
560 with -S was given to GCC. Normally X is substituted only
561 once, no matter how many such switches appeared. However,
562 if %* appears somewhere in X, then X will be substituted
563 once for each matching switch, with the %* replaced by the
564 part of that switch that matched the '*'.
565 %{.S:X} substitutes X, if processing a file with suffix S.
566 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
567 %{,S:X} substitutes X, if processing a file which will use spec S.
568 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
570 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
571 combined with '!', '.', ',', and '*' as above binding stronger
573 If %* appears in X, all of the alternatives must be starred, and
574 only the first matching alternative is substituted.
575 %{S:X; if S was given to GCC, substitutes X;
576 T:Y; else if T was given to GCC, substitutes Y;
577 :D} else substitutes D. There can be as many clauses as you need.
578 This may be combined with '.', '!', ',', '|', and '*' as above.
580 %(Spec) processes a specification defined in a specs file as *Spec:
581 %[Spec] as above, but put __ around -D arguments
583 The conditional text X in a %{S:X} or similar construct may contain
584 other nested % constructs or spaces, or even newlines. They are
585 processed as usual, as described above. Trailing white space in X is
586 ignored. White space may also appear anywhere on the left side of the
587 colon in these constructs, except between . or * and the corresponding
590 The -O, -f, -m, and -W switches are handled specifically in these
591 constructs. If another value of -O or the negated form of a -f, -m, or
592 -W switch is found later in the command line, the earlier switch
593 value is ignored, except with {S*} where S is just one letter; this
594 passes all matching options.
596 The character | at the beginning of the predicate text is used to indicate
597 that a command should be piped to the following command, but only if -pipe
600 Note that it is built into GCC which switches take arguments and which
601 do not. You might think it would be useful to generalize this to
602 allow each compiler's spec to say which switches take arguments. But
603 this cannot be done in a consistent fashion. GCC cannot even decide
604 which input files have been specified without knowing which switches
605 take arguments, and it must know which input files to compile in order
606 to tell which compilers to run.
608 GCC also knows implicitly that arguments starting in `-l' are to be
609 treated as compiler output files, and passed to the linker in their
610 proper position among the other output files. */
612 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
614 /* config.h can define ASM_SPEC to provide extra args to the assembler
615 or extra switch-translations. */
620 /* config.h can define ASM_FINAL_SPEC to run a post processor after
621 the assembler has run. */
622 #ifndef ASM_FINAL_SPEC
623 #define ASM_FINAL_SPEC ""
626 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
627 or extra switch-translations. */
632 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
633 or extra switch-translations. */
638 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
639 or extra switch-translations. */
641 #define CC1PLUS_SPEC ""
644 /* config.h can define LINK_SPEC to provide extra args to the linker
645 or extra switch-translations. */
650 /* config.h can define LIB_SPEC to override the default libraries. */
652 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
657 /* XXX: valid only for GNU ld */
658 /* XXX: should exactly match hooks provided by libmudflap.a */
659 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
660 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
661 --wrap=mmap --wrap=munmap --wrap=alloca\
662 } %{fmudflapth: --wrap=pthread_create\
663 }} %{fmudflap|fmudflapth: --wrap=main}"
666 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
669 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
672 #if defined(REAL_LIBGCC_SPEC)
673 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
674 #elif defined(LINK_LIBGCC_SPECIAL_1)
675 /* Have gcc do the search for libgcc.a. */
676 #define LIBGCC_SPEC "libgcc.a%s"
678 #define LIBGCC_SPEC "-lgcc"
682 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
683 #ifndef STARTFILE_SPEC
684 #define STARTFILE_SPEC \
685 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
688 /* config.h can define SWITCHES_NEED_SPACES to control which options
689 require spaces between the option and the argument.
691 We define SWITCHES_NEED_SPACES to include "o" by default. This
692 causes "-ofoo.o" to be split into "-o foo.o" during the initial
693 processing of the command-line, before being seen by the specs
694 machinery. This makes sure we record "foo.o" as the temporary file
695 to be deleted in the case of error, rather than "-ofoo.o". */
696 #ifndef SWITCHES_NEED_SPACES
697 #define SWITCHES_NEED_SPACES "o"
700 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
702 #define ENDFILE_SPEC ""
706 #define LINKER_NAME "collect2"
709 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
710 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
715 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
717 #ifndef ASM_DEBUG_SPEC
718 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
719 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
720 # define ASM_DEBUG_SPEC \
721 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
722 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
723 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
725 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
726 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
728 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
729 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
733 #ifndef ASM_DEBUG_SPEC
734 # define ASM_DEBUG_SPEC ""
737 /* Here is the spec for running the linker, after compiling all files. */
739 /* This is overridable by the target in case they need to specify the
740 -lgcc and -lc order specially, yet not require them to override all
741 of LINK_COMMAND_SPEC. */
742 #ifndef LINK_GCC_C_SEQUENCE_SPEC
743 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
746 #ifndef LINK_SSP_SPEC
747 #ifdef TARGET_LIBC_PROVIDES_SSP
748 #define LINK_SSP_SPEC "%{fstack-protector:}"
750 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
754 #ifndef LINK_PIE_SPEC
756 #define LINK_PIE_SPEC "%{pie:-pie} "
758 #define LINK_PIE_SPEC "%{pie:} "
762 #ifndef LINK_BUILDID_SPEC
763 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
764 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
769 /* -u* was put back because both BSD and SysV seem to support it. */
770 /* %{static:} simply prevents an error message if the target machine
771 doesn't handle -static. */
772 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
773 scripts which exist in user specified directories, or in standard
775 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
776 to understand them. In practice, this means it had better be collect2. */
777 #ifndef LINK_COMMAND_SPEC
778 #define LINK_COMMAND_SPEC "\
779 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
781 %{fuse-linker-plugin: \
782 -plugin %(linker_plugin_file) \
783 -plugin-opt=%(lto_wrapper) \
784 -plugin-opt=%(lto_gcc) \
785 -plugin-opt=-fresolution=%u.res \
786 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
787 %{static:-plugin-opt=-pass-through=-lc} \
788 %{O*:-plugin-opt=-O%*} \
789 %{w:-plugin-opt=-w} \
790 %{f*:-plugin-opt=-f%*} \
791 %{m*:-plugin-opt=-m%*} \
792 %{v:-plugin-opt=-v} \
794 %{flto} %{fwhopr} %l " LINK_PIE_SPEC \
795 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
796 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
797 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
798 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
799 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
800 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
801 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
804 #ifndef LINK_LIBGCC_SPEC
805 /* Generate -L options for startfile prefix list. */
806 # define LINK_LIBGCC_SPEC "%D"
809 #ifndef STARTFILE_PREFIX_SPEC
810 # define STARTFILE_PREFIX_SPEC ""
814 # define SYSROOT_SPEC "--sysroot=%R"
817 #ifndef SYSROOT_SUFFIX_SPEC
818 # define SYSROOT_SUFFIX_SPEC ""
821 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
822 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
825 static const char *asm_debug;
826 static const char *cpp_spec = CPP_SPEC;
827 static const char *cc1_spec = CC1_SPEC;
828 static const char *cc1plus_spec = CC1PLUS_SPEC;
829 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
830 static const char *link_ssp_spec = LINK_SSP_SPEC;
831 static const char *asm_spec = ASM_SPEC;
832 static const char *asm_final_spec = ASM_FINAL_SPEC;
833 static const char *link_spec = LINK_SPEC;
834 static const char *lib_spec = LIB_SPEC;
835 static const char *mfwrap_spec = MFWRAP_SPEC;
836 static const char *mflib_spec = MFLIB_SPEC;
837 static const char *link_gomp_spec = "";
838 static const char *libgcc_spec = LIBGCC_SPEC;
839 static const char *endfile_spec = ENDFILE_SPEC;
840 static const char *startfile_spec = STARTFILE_SPEC;
841 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
842 static const char *linker_name_spec = LINKER_NAME;
843 static const char *linker_plugin_file_spec = "";
844 static const char *lto_wrapper_spec = "";
845 static const char *lto_gcc_spec = "";
846 static const char *lto_libgcc_spec = "";
847 static const char *link_command_spec = LINK_COMMAND_SPEC;
848 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
849 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
850 static const char *sysroot_spec = SYSROOT_SPEC;
851 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
852 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
854 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
855 There should be no need to override these in target dependent files,
856 but we need to copy them to the specs file so that newer versions
857 of the GCC driver can correctly drive older tool chains with the
858 appropriate -B options. */
860 /* When cpplib handles traditional preprocessing, get rid of this, and
861 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
862 that we default the front end language better. */
863 static const char *trad_capable_cpp =
864 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
866 /* We don't wrap .d files in %W{} since a missing .d file, and
867 therefore no dependency entry, confuses make into thinking a .o
868 file that happens to exist is up-to-date. */
869 static const char *cpp_unique_options =
870 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
871 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
872 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
873 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
874 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
875 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
876 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
877 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
878 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
879 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
880 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
883 /* This contains cpp options which are common with cc1_options and are passed
884 only when preprocessing only to avoid duplication. We pass the cc1 spec
885 options to the preprocessor so that it the cc1 spec may manipulate
886 options used to set target flags. Those special target flags settings may
887 in turn cause preprocessor symbols to be defined specially. */
888 static const char *cpp_options =
889 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
890 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
891 %{undef} %{save-temps*:-fpch-preprocess}";
893 /* This contains cpp options which are not passed when the preprocessor
894 output will be used by another program. */
895 static const char *cpp_debug_options = "%{d*}";
897 /* NB: This is shared amongst all front-ends, except for Ada. */
898 static const char *cc1_options =
899 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
900 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
901 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{a*}\
902 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
903 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
904 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
905 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
906 %{Qn:-fno-ident} %{--help:--help}\
907 %{--target-help:--target-help}\
908 %{--help=*:--help=%(VALUE)}\
909 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
910 %{fsyntax-only:-o %j} %{-param*}\
911 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
912 %{coverage:-fprofile-arcs -ftest-coverage}";
914 static const char *asm_options =
915 "%{--target-help:%:print-asm-header()} "
917 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
918 to the assembler equivalents. */
919 "%{v} %{w:-W} %{I*} "
921 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
923 static const char *invoke_as =
924 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
926 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
927 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
931 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
932 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
936 /* Some compilers have limits on line lengths, and the multilib_select
937 and/or multilib_matches strings can be very long, so we build them at
939 static struct obstack multilib_obstack;
940 static const char *multilib_select;
941 static const char *multilib_matches;
942 static const char *multilib_defaults;
943 static const char *multilib_exclusions;
945 /* Check whether a particular argument is a default argument. */
947 #ifndef MULTILIB_DEFAULTS
948 #define MULTILIB_DEFAULTS { "" }
951 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
953 #ifndef DRIVER_SELF_SPECS
954 #define DRIVER_SELF_SPECS ""
957 /* Adding -fopenmp should imply pthreads. This is particularly important
958 for targets that use different start files and suchlike. */
959 #ifndef GOMP_SELF_SPECS
960 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
963 static const char *const driver_self_specs[] = {
964 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
965 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
968 #ifndef OPTION_DEFAULT_SPECS
969 #define OPTION_DEFAULT_SPECS { "", "" }
978 static const struct default_spec
979 option_default_specs[] = { OPTION_DEFAULT_SPECS };
983 struct user_specs *next;
984 const char *filename;
987 static struct user_specs *user_specs_head, *user_specs_tail;
989 #ifndef SWITCH_TAKES_ARG
990 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
993 #ifndef WORD_SWITCH_TAKES_ARG
994 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
997 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
998 /* This defines which switches stop a full compilation. */
999 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
1000 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
1002 #ifndef SWITCH_CURTAILS_COMPILATION
1003 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
1004 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
1008 /* Record the mapping from file suffixes for compilation specs. */
1012 const char *suffix; /* Use this compiler for input files
1013 whose names end in this suffix. */
1015 const char *spec; /* To use this compiler, run this spec. */
1017 const char *cpp_spec; /* If non-NULL, substitute this spec
1018 for `%C', rather than the usual
1020 const int combinable; /* If nonzero, compiler can deal with
1021 multiple source files at once (IMA). */
1022 const int needs_preprocessing; /* If nonzero, source files need to
1023 be run through a preprocessor. */
1026 /* Pointer to a vector of `struct compiler' that gives the spec for
1027 compiling a file, based on its suffix.
1028 A file that does not end in any of these suffixes will be passed
1029 unchanged to the loader and nothing else will be done to it.
1031 An entry containing two 0s is used to terminate the vector.
1033 If multiple entries match a file, the last matching one is used. */
1035 static struct compiler *compilers;
1037 /* Number of entries in `compilers', not counting the null terminator. */
1039 static int n_compilers;
1041 /* The default list of file name suffixes and their compilation specs. */
1043 static const struct compiler default_compilers[] =
1045 /* Add lists of suffixes of known languages here. If those languages
1046 were not present when we built the driver, we will hit these copies
1047 and be given a more meaningful error than "file not used since
1048 linking is not done". */
1049 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1050 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1051 {".mii", "#Objective-C++", 0, 0, 0},
1052 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1053 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1054 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1055 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1056 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1057 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1058 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1059 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1060 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1061 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1062 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1063 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1064 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1065 {".r", "#Ratfor", 0, 0, 0},
1066 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1067 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1068 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1069 /* Next come the entries for C. */
1070 {".c", "@c", 0, 1, 1},
1072 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1073 external preprocessor if -save-temps is given. */
1074 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1076 %{traditional|ftraditional:\
1077 %eGNU C no longer supports -traditional without -E}\
1079 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1080 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1081 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1083 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1084 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1085 %{!fsyntax-only:%(invoke_as)}} \
1087 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1088 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1089 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1090 cc1 %(cpp_unique_options) %(cc1_options)}}\
1091 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1093 "%{!E:%e-E or -x required when input is from standard input}\
1094 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1095 {".h", "@c-header", 0, 0, 0},
1097 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1098 external preprocessor if -save-temps is given. */
1099 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1101 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1102 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1103 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1105 -o %g.s %{!o*:--output-pch=%i.gch}\
1106 %W{o*:--output-pch=%*}%V}\
1107 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1108 cc1 %(cpp_unique_options) %(cc1_options)\
1109 -o %g.s %{!o*:--output-pch=%i.gch}\
1110 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1111 {".i", "@cpp-output", 0, 1, 0},
1113 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1114 {".s", "@assembler", 0, 1, 0},
1116 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1117 {".sx", "@assembler-with-cpp", 0, 1, 0},
1118 {".S", "@assembler-with-cpp", 0, 1, 0},
1119 {"@assembler-with-cpp",
1120 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1121 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1122 %{E|M|MM:%(cpp_debug_options)}\
1123 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1124 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1126 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1127 %{E|M|MM:%(cpp_debug_options)}\
1128 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1129 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1134 /* Mark end of table. */
1138 /* Number of elements in default_compilers, not counting the terminator. */
1140 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1142 /* A vector of options to give to the linker.
1143 These options are accumulated by %x,
1144 and substituted into the linker command with %X. */
1145 static int n_linker_options;
1146 static char **linker_options;
1148 /* A vector of options to give to the assembler.
1149 These options are accumulated by -Wa,
1150 and substituted into the assembler command with %Y. */
1151 static int n_assembler_options;
1152 static char **assembler_options;
1154 /* A vector of options to give to the preprocessor.
1155 These options are accumulated by -Wp,
1156 and substituted into the preprocessor command with %Z. */
1157 static int n_preprocessor_options;
1158 static char **preprocessor_options;
1160 /* Define how to map long options into short ones. */
1162 /* This structure describes one mapping. */
1165 /* The long option's name. */
1166 const char *const name;
1167 /* The equivalent short option. */
1168 const char *const equivalent;
1169 /* Argument info. A string of flag chars; NULL equals no options.
1170 a => argument required.
1171 o => argument optional.
1172 j => join argument to equivalent, making one word.
1173 * => require other text after NAME as an argument. */
1174 const char *const arg_info;
1177 /* This is the table of mappings. Mappings are tried sequentially
1178 for each option encountered; the first one that matches, wins. */
1180 static const struct option_map option_map[] =
1182 {"--all-warnings", "-Wall", 0},
1183 {"--ansi", "-ansi", 0},
1184 {"--assemble", "-S", 0},
1185 {"--assert", "-A", "a"},
1186 {"--classpath", "-fclasspath=", "aj"},
1187 {"--bootclasspath", "-fbootclasspath=", "aj"},
1188 {"--CLASSPATH", "-fclasspath=", "aj"},
1189 {"--combine", "-combine", 0},
1190 {"--comments", "-C", 0},
1191 {"--comments-in-macros", "-CC", 0},
1192 {"--compile", "-c", 0},
1193 {"--debug", "-g", "oj"},
1194 {"--define-macro", "-D", "aj"},
1195 {"--dependencies", "-M", 0},
1196 {"--dump", "-d", "a"},
1197 {"--dumpbase", "-dumpbase", "a"},
1198 {"--dumpdir", "-dumpdir", "a"},
1199 {"--encoding", "-fencoding=", "aj"},
1200 {"--entry", "-e", 0},
1201 {"--extra-warnings", "-W", 0},
1202 {"--extdirs", "-fextdirs=", "aj"},
1203 {"--for-assembler", "-Wa", "a"},
1204 {"--for-linker", "-Xlinker", "a"},
1205 {"--force-link", "-u", "a"},
1206 {"--coverage", "-coverage", 0},
1207 {"--imacros", "-imacros", "a"},
1208 {"--include", "-include", "a"},
1209 {"--include-barrier", "-I-", 0},
1210 {"--include-directory", "-I", "aj"},
1211 {"--include-directory-after", "-idirafter", "a"},
1212 {"--include-prefix", "-iprefix", "a"},
1213 {"--include-with-prefix", "-iwithprefix", "a"},
1214 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1215 {"--include-with-prefix-after", "-iwithprefix", "a"},
1216 {"--language", "-x", "a"},
1217 {"--library-directory", "-L", "a"},
1218 {"--machine", "-m", "aj"},
1219 {"--machine-", "-m", "*j"},
1220 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1221 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1222 {"--no-line-commands", "-P", 0},
1223 {"--no-precompiled-includes", "-noprecomp", 0},
1224 {"--no-standard-includes", "-nostdinc", 0},
1225 {"--no-standard-libraries", "-nostdlib", 0},
1226 {"--no-warnings", "-w", 0},
1227 {"--optimize", "-O", "oj"},
1228 {"--output", "-o", "a"},
1229 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1230 {"--param", "--param", "a"},
1231 {"--pass-exit-codes", "-pass-exit-codes", 0},
1232 {"--pedantic", "-pedantic", 0},
1233 {"--pedantic-errors", "-pedantic-errors", 0},
1234 {"--pie", "-pie", 0},
1235 {"--pipe", "-pipe", 0},
1236 {"--prefix", "-B", "a"},
1237 {"--preprocess", "-E", 0},
1238 {"--print-search-dirs", "-print-search-dirs", 0},
1239 {"--print-file-name", "-print-file-name=", "aj"},
1240 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1241 {"--print-missing-file-dependencies", "-MG", 0},
1242 {"--print-multi-lib", "-print-multi-lib", 0},
1243 {"--print-multi-directory", "-print-multi-directory", 0},
1244 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1245 {"--print-prog-name", "-print-prog-name=", "aj"},
1246 {"--print-sysroot", "-print-sysroot", 0},
1247 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1248 {"--profile", "-p", 0},
1249 {"--profile-blocks", "-a", 0},
1250 {"--quiet", "-q", 0},
1251 {"--resource", "-fcompile-resource=", "aj"},
1252 {"--save-temps", "-save-temps", 0},
1253 {"--shared", "-shared", 0},
1254 {"--silent", "-q", 0},
1255 {"--specs", "-specs=", "aj"},
1256 {"--static", "-static", 0},
1257 {"--std", "-std=", "aj"},
1258 {"--symbolic", "-symbolic", 0},
1259 {"--sysroot", "--sysroot=", "aj"},
1260 {"--time", "-time", 0},
1261 {"--trace-includes", "-H", 0},
1262 {"--traditional", "-traditional", 0},
1263 {"--traditional-cpp", "-traditional-cpp", 0},
1264 {"--trigraphs", "-trigraphs", 0},
1265 {"--undefine-macro", "-U", "aj"},
1266 {"--user-dependencies", "-MM", 0},
1267 {"--verbose", "-v", 0},
1268 {"--warn-", "-W", "*j"},
1269 {"--write-dependencies", "-MD", 0},
1270 {"--write-user-dependencies", "-MMD", 0},
1275 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1276 static const struct {
1277 const char *const option_found;
1278 const char *const replacements;
1279 } target_option_translations[] =
1281 TARGET_OPTION_TRANSLATE_TABLE,
1286 /* Translate the options described by *ARGCP and *ARGVP.
1287 Make a new vector and store it back in *ARGVP,
1288 and store its length in *ARGCP. */
1291 translate_options (int *argcp, const char *const **argvp)
1295 const char *const *argv = *argvp;
1296 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1297 const char **newv = XNEWVAR (const char *, newvsize);
1301 newv[newindex++] = argv[i++];
1305 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1309 target_option_translations[tott_idx].option_found;
1312 if (strcmp (target_option_translations[tott_idx].option_found,
1319 for (sp = target_option_translations[tott_idx].replacements;
1326 newvsize += spaces * sizeof (const char *);
1327 newv = XRESIZEVAR (const char *, newv, newvsize);
1329 sp = target_option_translations[tott_idx].replacements;
1338 newv[newindex++] = np;
1339 while (*np != ' ' && *np)
1350 if (target_option_translations[tott_idx].option_found)
1354 /* Translate -- options. */
1355 if (argv[i][0] == '-' && argv[i][1] == '-')
1358 /* Find a mapping that applies to this option. */
1359 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1361 size_t optlen = strlen (option_map[j].name);
1362 size_t arglen = strlen (argv[i]);
1363 size_t complen = arglen > optlen ? optlen : arglen;
1364 const char *arginfo = option_map[j].arg_info;
1369 if (!strncmp (argv[i], option_map[j].name, complen))
1371 const char *arg = 0;
1373 if (arglen < optlen)
1376 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1377 if (strlen (option_map[k].name) >= arglen
1378 && !strncmp (argv[i], option_map[k].name, arglen))
1380 error ("ambiguous abbreviation %s", argv[i]);
1384 if (k != ARRAY_SIZE (option_map))
1388 if (arglen > optlen)
1390 /* If the option has an argument, accept that. */
1391 if (argv[i][optlen] == '=')
1392 arg = argv[i] + optlen + 1;
1394 /* If this mapping requires extra text at end of name,
1395 accept that as "argument". */
1396 else if (strchr (arginfo, '*') != 0)
1397 arg = argv[i] + optlen;
1399 /* Otherwise, extra text at end means mismatch.
1400 Try other mappings. */
1405 else if (strchr (arginfo, '*') != 0)
1407 error ("incomplete '%s' option", option_map[j].name);
1411 /* Handle arguments. */
1412 if (strchr (arginfo, 'a') != 0)
1418 error ("missing argument to '%s' option",
1419 option_map[j].name);
1426 else if (strchr (arginfo, '*') != 0)
1428 else if (strchr (arginfo, 'o') == 0)
1431 error ("extraneous argument to '%s' option",
1432 option_map[j].name);
1436 /* Store the translation as one argv elt or as two. */
1437 if (arg != 0 && strchr (arginfo, 'j') != 0)
1438 newv[newindex++] = concat (option_map[j].equivalent, arg,
1442 newv[newindex++] = option_map[j].equivalent;
1443 newv[newindex++] = arg;
1446 newv[newindex++] = option_map[j].equivalent;
1454 /* Handle old-fashioned options--just copy them through,
1455 with their arguments. */
1456 else if (argv[i][0] == '-')
1458 const char *p = argv[i] + 1;
1462 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1463 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1464 else if (WORD_SWITCH_TAKES_ARG (p))
1465 nskip += WORD_SWITCH_TAKES_ARG (p);
1466 else if ((c == 'B' || c == 'b' || c == 'x')
1469 else if (! strcmp (p, "Xlinker"))
1471 else if (! strcmp (p, "Xpreprocessor"))
1473 else if (! strcmp (p, "Xassembler"))
1476 /* Watch out for an option at the end of the command line that
1477 is missing arguments, and avoid skipping past the end of the
1479 if (nskip + i > argc)
1484 newv[newindex++] = argv[i++];
1489 /* Ordinary operands, or +e options. */
1490 newv[newindex++] = argv[i++];
1500 skip_whitespace (char *p)
1504 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1505 be considered whitespace. */
1506 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1508 else if (*p == '\n' || *p == ' ' || *p == '\t')
1522 /* Structures to keep track of prefixes to try when looking for files. */
1526 const char *prefix; /* String to prepend to the path. */
1527 struct prefix_list *next; /* Next in linked list. */
1528 int require_machine_suffix; /* Don't use without machine_suffix. */
1529 /* 2 means try both machine_suffix and just_machine_suffix. */
1530 int priority; /* Sort key - priority within list. */
1531 int os_multilib; /* 1 if OS multilib scheme should be used,
1532 0 for GCC multilib scheme. */
1537 struct prefix_list *plist; /* List of prefixes to try */
1538 int max_len; /* Max length of a prefix in PLIST */
1539 const char *name; /* Name of this list (used in config stuff) */
1542 /* List of prefixes to try when looking for executables. */
1544 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1546 /* List of prefixes to try when looking for startup (crt0) files. */
1548 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1550 /* List of prefixes to try when looking for include files. */
1552 static struct path_prefix include_prefixes = { 0, 0, "include" };
1554 /* Suffix to attach to directories searched for commands.
1555 This looks like `MACHINE/VERSION/'. */
1557 static const char *machine_suffix = 0;
1559 /* Suffix to attach to directories searched for commands.
1560 This is just `MACHINE/'. */
1562 static const char *just_machine_suffix = 0;
1564 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1566 static const char *gcc_exec_prefix;
1568 /* Adjusted value of standard_libexec_prefix. */
1570 static const char *gcc_libexec_prefix;
1572 /* Default prefixes to attach to command names. */
1574 #ifndef STANDARD_STARTFILE_PREFIX_1
1575 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1577 #ifndef STANDARD_STARTFILE_PREFIX_2
1578 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1581 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1582 #undef MD_EXEC_PREFIX
1583 #undef MD_STARTFILE_PREFIX
1584 #undef MD_STARTFILE_PREFIX_1
1587 /* If no prefixes defined, use the null string, which will disable them. */
1588 #ifndef MD_EXEC_PREFIX
1589 #define MD_EXEC_PREFIX ""
1591 #ifndef MD_STARTFILE_PREFIX
1592 #define MD_STARTFILE_PREFIX ""
1594 #ifndef MD_STARTFILE_PREFIX_1
1595 #define MD_STARTFILE_PREFIX_1 ""
1598 /* These directories are locations set at configure-time based on the
1599 --prefix option provided to configure. Their initializers are
1600 defined in Makefile.in. These paths are not *directly* used when
1601 gcc_exec_prefix is set because, in that case, we know where the
1602 compiler has been installed, and use paths relative to that
1603 location instead. */
1604 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1605 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1606 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1607 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1609 /* For native compilers, these are well-known paths containing
1610 components that may be provided by the system. For cross
1611 compilers, these paths are not used. */
1612 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1613 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1614 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1615 static const char *const standard_startfile_prefix_1
1616 = STANDARD_STARTFILE_PREFIX_1;
1617 static const char *const standard_startfile_prefix_2
1618 = STANDARD_STARTFILE_PREFIX_2;
1620 /* A relative path to be used in finding the location of tools
1621 relative to the driver. */
1622 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1624 /* Subdirectory to use for locating libraries. Set by
1625 set_multilib_dir based on the compilation options. */
1627 static const char *multilib_dir;
1629 /* Subdirectory to use for locating libraries in OS conventions. Set by
1630 set_multilib_dir based on the compilation options. */
1632 static const char *multilib_os_dir;
1634 /* Structure to keep track of the specs that have been defined so far.
1635 These are accessed using %(specname) or %[specname] in a compiler
1640 /* The following 2 fields must be first */
1641 /* to allow EXTRA_SPECS to be initialized */
1642 const char *name; /* name of the spec. */
1643 const char *ptr; /* available ptr if no static pointer */
1645 /* The following fields are not initialized */
1646 /* by EXTRA_SPECS */
1647 const char **ptr_spec; /* pointer to the spec itself. */
1648 struct spec_list *next; /* Next spec in linked list. */
1649 int name_len; /* length of the name */
1650 int alloc_p; /* whether string was allocated */
1653 #define INIT_STATIC_SPEC(NAME,PTR) \
1654 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1656 /* List of statically defined specs. */
1657 static struct spec_list static_specs[] =
1659 INIT_STATIC_SPEC ("asm", &asm_spec),
1660 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1661 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1662 INIT_STATIC_SPEC ("asm_options", &asm_options),
1663 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1664 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1665 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1666 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1667 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1668 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1669 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1670 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1671 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1672 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1673 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1674 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1675 INIT_STATIC_SPEC ("link", &link_spec),
1676 INIT_STATIC_SPEC ("lib", &lib_spec),
1677 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1678 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1679 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1680 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1681 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1682 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1683 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1684 INIT_STATIC_SPEC ("version", &compiler_version),
1685 INIT_STATIC_SPEC ("multilib", &multilib_select),
1686 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1687 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1688 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1689 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1690 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1691 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1692 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1693 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec),
1694 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec),
1695 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec),
1696 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1697 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1698 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1699 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1700 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1701 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1702 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1703 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1706 #ifdef EXTRA_SPECS /* additional specs needed */
1707 /* Structure to keep track of just the first two args of a spec_list.
1708 That is all that the EXTRA_SPECS macro gives us. */
1711 const char *const name;
1712 const char *const ptr;
1715 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1716 static struct spec_list *extra_specs = (struct spec_list *) 0;
1719 /* List of dynamically allocates specs that have been defined so far. */
1721 static struct spec_list *specs = (struct spec_list *) 0;
1723 /* List of static spec functions. */
1725 static const struct spec_function static_spec_functions[] =
1727 { "getenv", getenv_spec_function },
1728 { "if-exists", if_exists_spec_function },
1729 { "if-exists-else", if_exists_else_spec_function },
1730 { "replace-outfile", replace_outfile_spec_function },
1731 { "version-compare", version_compare_spec_function },
1732 { "include", include_spec_function },
1733 { "find-file", find_file_spec_function },
1734 { "print-asm-header", print_asm_header_spec_function },
1735 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1736 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1737 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1738 #ifdef EXTRA_SPEC_FUNCTIONS
1739 EXTRA_SPEC_FUNCTIONS
1744 static int processing_spec_function;
1746 /* Add appropriate libgcc specs to OBSTACK, taking into account
1747 various permutations of -shared-libgcc, -shared, and such. */
1749 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1751 #ifndef USE_LD_AS_NEEDED
1752 #define USE_LD_AS_NEEDED 0
1756 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1757 const char *static_name, const char *eh_name)
1761 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1762 "%{!static:%{!static-libgcc:"
1763 #if USE_LD_AS_NEEDED
1764 "%{!shared-libgcc:",
1765 static_name, " --as-needed ", shared_name, " --no-as-needed"
1768 shared_name, "%{!shared: ", static_name, "}"
1772 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1773 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1777 "%{shared-libgcc:", shared_name, "}"
1778 "%{!shared-libgcc:", static_name, "}"
1781 "%{shared:", shared_name, "}"
1786 obstack_grow (obstack, buf, strlen (buf));
1789 #endif /* ENABLE_SHARED_LIBGCC */
1791 /* Initialize the specs lookup routines. */
1796 struct spec_list *next = (struct spec_list *) 0;
1797 struct spec_list *sl = (struct spec_list *) 0;
1801 return; /* Already initialized. */
1804 notice ("Using built-in specs.\n");
1807 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1809 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1811 sl = &extra_specs[i];
1812 sl->name = extra_specs_1[i].name;
1813 sl->ptr = extra_specs_1[i].ptr;
1815 sl->name_len = strlen (sl->name);
1816 sl->ptr_spec = &sl->ptr;
1821 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1823 sl = &static_specs[i];
1828 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1829 /* ??? If neither -shared-libgcc nor --static-libgcc was
1830 seen, then we should be making an educated guess. Some proposed
1831 heuristics for ELF include:
1833 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1834 program will be doing dynamic loading, which will likely
1835 need the shared libgcc.
1837 (2) If "-ldl", then it's also a fair bet that we're doing
1840 (3) For each ET_DYN we're linking against (either through -lfoo
1841 or /some/path/foo.so), check to see whether it or one of
1842 its dependencies depends on a shared libgcc.
1846 If the runtime is fixed to look for program headers instead
1847 of calling __register_frame_info at all, for each object,
1848 use the shared libgcc if any EH symbol referenced.
1850 If crtstuff is fixed to not invoke __register_frame_info
1851 automatically, for each object, use the shared libgcc if
1852 any non-empty unwind section found.
1854 Doing any of this probably requires invoking an external program to
1855 do the actual object file scanning. */
1857 const char *p = libgcc_spec;
1860 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1861 when given the proper command line arguments. */
1864 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1866 init_gcc_specs (&obstack,
1868 #ifdef USE_LIBUNWIND_EXCEPTIONS
1874 #ifdef USE_LIBUNWIND_EXCEPTIONS
1875 # ifdef HAVE_LD_STATIC_DYNAMIC
1876 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1886 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1888 /* Ug. We don't know shared library extensions. Hope that
1889 systems that use this form don't do shared libraries. */
1890 init_gcc_specs (&obstack,
1894 #ifdef USE_LIBUNWIND_EXCEPTIONS
1903 obstack_1grow (&obstack, *p);
1904 in_sep = (*p == ' ');
1909 obstack_1grow (&obstack, '\0');
1910 libgcc_spec = XOBFINISH (&obstack, const char *);
1913 #ifdef USE_AS_TRADITIONAL_FORMAT
1914 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1916 static const char tf[] = "--traditional-format ";
1917 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1918 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1919 asm_spec = XOBFINISH (&obstack, const char *);
1923 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1924 # ifdef LINK_BUILDID_SPEC
1925 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1926 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1928 # ifdef LINK_EH_SPEC
1929 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1930 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1932 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1933 link_spec = XOBFINISH (&obstack, const char *);
1939 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1940 removed; If the spec starts with a + then SPEC is added to the end of the
1944 set_spec (const char *name, const char *spec)
1946 struct spec_list *sl;
1947 const char *old_spec;
1948 int name_len = strlen (name);
1951 /* If this is the first call, initialize the statically allocated specs. */
1954 struct spec_list *next = (struct spec_list *) 0;
1955 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1957 sl = &static_specs[i];
1964 /* See if the spec already exists. */
1965 for (sl = specs; sl; sl = sl->next)
1966 if (name_len == sl->name_len && !strcmp (sl->name, name))
1971 /* Not found - make it. */
1972 sl = XNEW (struct spec_list);
1973 sl->name = xstrdup (name);
1974 sl->name_len = name_len;
1975 sl->ptr_spec = &sl->ptr;
1977 *(sl->ptr_spec) = "";
1982 old_spec = *(sl->ptr_spec);
1983 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1984 ? concat (old_spec, spec + 1, NULL)
1989 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1992 /* Free the old spec. */
1993 if (old_spec && sl->alloc_p)
1994 free (CONST_CAST(char *, old_spec));
1999 /* Accumulate a command (program name and args), and run it. */
2001 /* Vector of pointers to arguments in the current line of specifications. */
2003 static const char **argbuf;
2005 /* Number of elements allocated in argbuf. */
2007 static int argbuf_length;
2009 /* Number of elements in argbuf currently in use (containing args). */
2011 static int argbuf_index;
2013 /* Position in the argbuf array containing the name of the output file
2014 (the value associated with the "-o" flag). */
2016 static int have_o_argbuf_index = 0;
2018 /* Were the options -c, -S or -E passed. */
2019 static int have_c = 0;
2021 /* Was the option -o passed. */
2022 static int have_o = 0;
2024 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2025 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2028 static struct temp_name {
2029 const char *suffix; /* suffix associated with the code. */
2030 int length; /* strlen (suffix). */
2031 int unique; /* Indicates whether %g or %u/%U was used. */
2032 const char *filename; /* associated filename. */
2033 int filename_length; /* strlen (filename). */
2034 struct temp_name *next;
2037 /* Number of commands executed so far. */
2039 static int execution_count;
2041 /* Number of commands that exited with a signal. */
2043 static int signal_count;
2045 /* Name with which this program was invoked. */
2047 static const char *programname;
2049 /* Allocate the argument vector. */
2055 argbuf = XNEWVEC (const char *, argbuf_length);
2058 /* Clear out the vector of arguments (after a command is executed). */
2066 /* Add one argument to the vector at the end.
2067 This is done when a space is seen or at the end of the line.
2068 If DELETE_ALWAYS is nonzero, the arg is a filename
2069 and the file should be deleted eventually.
2070 If DELETE_FAILURE is nonzero, the arg is a filename
2071 and the file should be deleted if this compilation fails. */
2074 store_arg (const char *arg, int delete_always, int delete_failure)
2076 if (argbuf_index + 1 == argbuf_length)
2077 argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
2079 argbuf[argbuf_index++] = arg;
2080 argbuf[argbuf_index] = 0;
2082 if (strcmp (arg, "-o") == 0)
2083 have_o_argbuf_index = argbuf_index;
2084 if (delete_always || delete_failure)
2085 record_temp_file (arg, delete_always, delete_failure);
2088 /* Load specs from a file name named FILENAME, replacing occurrences of
2089 various different types of line-endings, \r\n, \n\r and just \r, with
2093 load_specs (const char *filename)
2097 struct stat statbuf;
2104 notice ("Reading specs from %s\n", filename);
2106 /* Open and stat the file. */
2107 desc = open (filename, O_RDONLY, 0);
2109 pfatal_with_name (filename);
2110 if (stat (filename, &statbuf) < 0)
2111 pfatal_with_name (filename);
2113 /* Read contents of file into BUFFER. */
2114 buffer = XNEWVEC (char, statbuf.st_size + 1);
2115 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2117 pfatal_with_name (filename);
2118 buffer[readlen] = 0;
2121 specs = XNEWVEC (char, readlen + 1);
2123 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2129 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2131 else if (*(buffer_p + 1) == '\n') /* \r\n */
2145 /* Read compilation specs from a file named FILENAME,
2146 replacing the default ones.
2148 A suffix which starts with `*' is a definition for
2149 one of the machine-specific sub-specs. The "suffix" should be
2150 *asm, *cc1, *cpp, *link, *startfile, etc.
2151 The corresponding spec is stored in asm_spec, etc.,
2152 rather than in the `compilers' vector.
2154 Anything invalid in the file is a fatal error. */
2157 read_specs (const char *filename, int main_p)
2162 buffer = load_specs (filename);
2164 /* Scan BUFFER for specs, putting them in the vector. */
2170 char *in, *out, *p1, *p2, *p3;
2172 /* Advance P in BUFFER to the next nonblank nocomment line. */
2173 p = skip_whitespace (p);
2177 /* Is this a special command that starts with '%'? */
2178 /* Don't allow this for the main specs file, since it would
2179 encourage people to overwrite it. */
2180 if (*p == '%' && !main_p)
2183 while (*p && *p != '\n')
2189 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2190 && (p1[sizeof "%include" - 1] == ' '
2191 || p1[sizeof "%include" - 1] == '\t'))
2195 p1 += sizeof ("%include");
2196 while (*p1 == ' ' || *p1 == '\t')
2199 if (*p1++ != '<' || p[-2] != '>')
2200 fatal ("specs %%include syntax malformed after %ld characters",
2201 (long) (p1 - buffer + 1));
2204 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2205 read_specs (new_filename ? new_filename : p1, FALSE);
2208 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2209 && (p1[sizeof "%include_noerr" - 1] == ' '
2210 || p1[sizeof "%include_noerr" - 1] == '\t'))
2214 p1 += sizeof "%include_noerr";
2215 while (*p1 == ' ' || *p1 == '\t')
2218 if (*p1++ != '<' || p[-2] != '>')
2219 fatal ("specs %%include syntax malformed after %ld characters",
2220 (long) (p1 - buffer + 1));
2223 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2225 read_specs (new_filename, FALSE);
2226 else if (verbose_flag)
2227 notice ("could not find specs file %s\n", p1);
2230 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2231 && (p1[sizeof "%rename" - 1] == ' '
2232 || p1[sizeof "%rename" - 1] == '\t'))
2235 struct spec_list *sl;
2236 struct spec_list *newsl;
2238 /* Get original name. */
2239 p1 += sizeof "%rename";
2240 while (*p1 == ' ' || *p1 == '\t')
2243 if (! ISALPHA ((unsigned char) *p1))
2244 fatal ("specs %%rename syntax malformed after %ld characters",
2245 (long) (p1 - buffer));
2248 while (*p2 && !ISSPACE ((unsigned char) *p2))
2251 if (*p2 != ' ' && *p2 != '\t')
2252 fatal ("specs %%rename syntax malformed after %ld characters",
2253 (long) (p2 - buffer));
2257 while (*p2 == ' ' || *p2 == '\t')
2260 if (! ISALPHA ((unsigned char) *p2))
2261 fatal ("specs %%rename syntax malformed after %ld characters",
2262 (long) (p2 - buffer));
2264 /* Get new spec name. */
2266 while (*p3 && !ISSPACE ((unsigned char) *p3))
2270 fatal ("specs %%rename syntax malformed after %ld characters",
2271 (long) (p3 - buffer));
2274 for (sl = specs; sl; sl = sl->next)
2275 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2279 fatal ("specs %s spec was not found to be renamed", p1);
2281 if (strcmp (p1, p2) == 0)
2284 for (newsl = specs; newsl; newsl = newsl->next)
2285 if (strcmp (newsl->name, p2) == 0)
2286 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2291 notice ("rename spec %s to %s\n", p1, p2);
2293 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2297 set_spec (p2, *(sl->ptr_spec));
2299 free (CONST_CAST (char *, *(sl->ptr_spec)));
2301 *(sl->ptr_spec) = "";
2306 fatal ("specs unknown %% command after %ld characters",
2307 (long) (p1 - buffer));
2310 /* Find the colon that should end the suffix. */
2312 while (*p1 && *p1 != ':' && *p1 != '\n')
2315 /* The colon shouldn't be missing. */
2317 fatal ("specs file malformed after %ld characters",
2318 (long) (p1 - buffer));
2320 /* Skip back over trailing whitespace. */
2322 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2325 /* Copy the suffix to a string. */
2326 suffix = save_string (p, p2 - p);
2327 /* Find the next line. */
2328 p = skip_whitespace (p1 + 1);
2330 fatal ("specs file malformed after %ld characters",
2331 (long) (p - buffer));
2334 /* Find next blank line or end of string. */
2335 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2338 /* Specs end at the blank line and do not include the newline. */
2339 spec = save_string (p, p1 - p);
2342 /* Delete backslash-newline sequences from the spec. */
2347 if (in[0] == '\\' && in[1] == '\n')
2349 else if (in[0] == '#')
2350 while (*in && *in != '\n')
2358 if (suffix[0] == '*')
2360 if (! strcmp (suffix, "*link_command"))
2361 link_command_spec = spec;
2363 set_spec (suffix + 1, spec);
2367 /* Add this pair to the vector. */
2369 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2371 compilers[n_compilers].suffix = suffix;
2372 compilers[n_compilers].spec = spec;
2374 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2378 link_command_spec = spec;
2381 if (link_command_spec == 0)
2382 fatal ("spec file has no spec for linking");
2385 /* Record the names of temporary files we tell compilers to write,
2386 and delete them at the end of the run. */
2388 /* This is the common prefix we use to make temp file names.
2389 It is chosen once for each run of this program.
2390 It is substituted into a spec by %g or %j.
2391 Thus, all temp file names contain this prefix.
2392 In practice, all temp file names start with this prefix.
2394 This prefix comes from the envvar TMPDIR if it is defined;
2395 otherwise, from the P_tmpdir macro if that is defined;
2396 otherwise, in /usr/tmp or /tmp;
2397 or finally the current directory if all else fails. */
2399 static const char *temp_filename;
2401 /* Length of the prefix. */
2403 static int temp_filename_length;
2405 /* Define the list of temporary files to delete. */
2410 struct temp_file *next;
2413 /* Queue of files to delete on success or failure of compilation. */
2414 static struct temp_file *always_delete_queue;
2415 /* Queue of files to delete on failure of compilation. */
2416 static struct temp_file *failure_delete_queue;
2418 /* Record FILENAME as a file to be deleted automatically.
2419 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2420 otherwise delete it in any case.
2421 FAIL_DELETE nonzero means delete it if a compilation step fails;
2422 otherwise delete it in any case. */
2425 record_temp_file (const char *filename, int always_delete, int fail_delete)
2427 char *const name = xstrdup (filename);
2431 struct temp_file *temp;
2432 for (temp = always_delete_queue; temp; temp = temp->next)
2433 if (! strcmp (name, temp->name))
2436 temp = XNEW (struct temp_file);
2437 temp->next = always_delete_queue;
2439 always_delete_queue = temp;
2446 struct temp_file *temp;
2447 for (temp = failure_delete_queue; temp; temp = temp->next)
2448 if (! strcmp (name, temp->name))
2451 temp = XNEW (struct temp_file);
2452 temp->next = failure_delete_queue;
2454 failure_delete_queue = temp;
2460 /* Delete all the temporary files whose names we previously recorded. */
2462 #ifndef DELETE_IF_ORDINARY
2463 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2466 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2467 if (unlink (NAME) < 0) \
2469 perror_with_name (NAME); \
2474 delete_if_ordinary (const char *name)
2480 printf ("Delete %s? (y or n) ", name);
2484 while ((c = getchar ()) != '\n' && c != EOF)
2487 if (i == 'y' || i == 'Y')
2489 DELETE_IF_ORDINARY (name, st, verbose_flag);
2493 delete_temp_files (void)
2495 struct temp_file *temp;
2497 for (temp = always_delete_queue; temp; temp = temp->next)
2498 delete_if_ordinary (temp->name);
2499 always_delete_queue = 0;
2502 /* Delete all the files to be deleted on error. */
2505 delete_failure_queue (void)
2507 struct temp_file *temp;
2509 for (temp = failure_delete_queue; temp; temp = temp->next)
2510 delete_if_ordinary (temp->name);
2514 clear_failure_queue (void)
2516 failure_delete_queue = 0;
2519 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2521 If DO_MULTI is true iterate over the paths twice, first with multilib
2522 suffix then without, otherwise iterate over the paths once without
2523 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2524 to avoid visiting the same path twice, but we could do better. For
2525 instance, /usr/lib/../lib is considered different from /usr/lib.
2526 At least EXTRA_SPACE chars past the end of the path passed to
2527 CALLBACK are available for use by the callback.
2528 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2530 Returns the value returned by CALLBACK. */
2533 for_each_path (const struct path_prefix *paths,
2536 void *(*callback) (char *, void *),
2537 void *callback_info)
2539 struct prefix_list *pl;
2540 const char *multi_dir = NULL;
2541 const char *multi_os_dir = NULL;
2542 const char *multi_suffix;
2543 const char *just_multi_suffix;
2546 bool skip_multi_dir = false;
2547 bool skip_multi_os_dir = false;
2549 multi_suffix = machine_suffix;
2550 just_multi_suffix = just_machine_suffix;
2551 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2553 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2554 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2555 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2557 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2558 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2562 size_t multi_dir_len = 0;
2563 size_t multi_os_dir_len = 0;
2565 size_t just_suffix_len;
2569 multi_dir_len = strlen (multi_dir);
2571 multi_os_dir_len = strlen (multi_os_dir);
2572 suffix_len = strlen (multi_suffix);
2573 just_suffix_len = strlen (just_multi_suffix);
2577 len = paths->max_len + extra_space + 1;
2578 if (suffix_len > multi_os_dir_len)
2581 len += multi_os_dir_len;
2582 path = XNEWVEC (char, len);
2585 for (pl = paths->plist; pl != 0; pl = pl->next)
2587 len = strlen (pl->prefix);
2588 memcpy (path, pl->prefix, len);
2590 /* Look first in MACHINE/VERSION subdirectory. */
2591 if (!skip_multi_dir)
2593 memcpy (path + len, multi_suffix, suffix_len + 1);
2594 ret = callback (path, callback_info);
2599 /* Some paths are tried with just the machine (ie. target)
2600 subdir. This is used for finding as, ld, etc. */
2602 && pl->require_machine_suffix == 2)
2604 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2605 ret = callback (path, callback_info);
2610 /* Now try the base path. */
2611 if (!pl->require_machine_suffix
2612 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2614 const char *this_multi;
2615 size_t this_multi_len;
2617 if (pl->os_multilib)
2619 this_multi = multi_os_dir;
2620 this_multi_len = multi_os_dir_len;
2624 this_multi = multi_dir;
2625 this_multi_len = multi_dir_len;
2629 memcpy (path + len, this_multi, this_multi_len + 1);
2633 ret = callback (path, callback_info);
2641 if (multi_dir == NULL && multi_os_dir == NULL)
2644 /* Run through the paths again, this time without multilibs.
2645 Don't repeat any we have already seen. */
2648 free (CONST_CAST (char *, multi_dir));
2650 free (CONST_CAST (char *, multi_suffix));
2651 multi_suffix = machine_suffix;
2652 free (CONST_CAST (char *, just_multi_suffix));
2653 just_multi_suffix = just_machine_suffix;
2656 skip_multi_dir = true;
2659 free (CONST_CAST (char *, multi_os_dir));
2660 multi_os_dir = NULL;
2663 skip_multi_os_dir = true;
2668 free (CONST_CAST (char *, multi_dir));
2669 free (CONST_CAST (char *, multi_suffix));
2670 free (CONST_CAST (char *, just_multi_suffix));
2673 free (CONST_CAST (char *, multi_os_dir));
2679 /* Callback for build_search_list. Adds path to obstack being built. */
2681 struct add_to_obstack_info {
2688 add_to_obstack (char *path, void *data)
2690 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2692 if (info->check_dir && !is_directory (path, false))
2695 if (!info->first_time)
2696 obstack_1grow (info->ob, PATH_SEPARATOR);
2698 obstack_grow (info->ob, path, strlen (path));
2700 info->first_time = false;
2704 /* Add or change the value of an environment variable, outputting the
2705 change to standard error if in verbose mode. */
2707 xputenv (const char *string)
2710 notice ("%s\n", string);
2711 putenv (CONST_CAST (char *, string));
2714 /* Build a list of search directories from PATHS.
2715 PREFIX is a string to prepend to the list.
2716 If CHECK_DIR_P is true we ensure the directory exists.
2717 If DO_MULTI is true, multilib paths are output first, then
2719 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2720 It is also used by the --print-search-dirs flag. */
2723 build_search_list (const struct path_prefix *paths, const char *prefix,
2724 bool check_dir, bool do_multi)
2726 struct add_to_obstack_info info;
2728 info.ob = &collect_obstack;
2729 info.check_dir = check_dir;
2730 info.first_time = true;
2732 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2733 obstack_1grow (&collect_obstack, '=');
2735 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2737 obstack_1grow (&collect_obstack, '\0');
2738 return XOBFINISH (&collect_obstack, char *);
2741 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2745 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2748 xputenv (build_search_list (paths, env_var, true, do_multi));
2751 /* Check whether NAME can be accessed in MODE. This is like access,
2752 except that it never considers directories to be executable. */
2755 access_check (const char *name, int mode)
2761 if (stat (name, &st) < 0
2762 || S_ISDIR (st.st_mode))
2766 return access (name, mode);
2769 /* Callback for find_a_file. Appends the file name to the directory
2770 path. If the resulting file exists in the right mode, return the
2771 full pathname to the file. */
2773 struct file_at_path_info {
2782 file_at_path (char *path, void *data)
2784 struct file_at_path_info *info = (struct file_at_path_info *) data;
2785 size_t len = strlen (path);
2787 memcpy (path + len, info->name, info->name_len);
2788 len += info->name_len;
2790 /* Some systems have a suffix for executable files.
2791 So try appending that first. */
2792 if (info->suffix_len)
2794 memcpy (path + len, info->suffix, info->suffix_len + 1);
2795 if (access_check (path, info->mode) == 0)
2800 if (access_check (path, info->mode) == 0)
2806 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2807 access to check permissions. If DO_MULTI is true, search multilib
2808 paths then non-multilib paths, otherwise do not search multilib paths.
2809 Return 0 if not found, otherwise return its name, allocated with malloc. */
2812 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2815 struct file_at_path_info info;
2817 #ifdef DEFAULT_ASSEMBLER
2818 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2819 return xstrdup (DEFAULT_ASSEMBLER);
2822 #ifdef DEFAULT_LINKER
2823 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2824 return xstrdup (DEFAULT_LINKER);
2827 /* Determine the filename to execute (special case for absolute paths). */
2829 if (IS_ABSOLUTE_PATH (name))
2831 if (access (name, mode) == 0)
2832 return xstrdup (name);
2838 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2839 info.name_len = strlen (info.name);
2840 info.suffix_len = strlen (info.suffix);
2843 return (char*) for_each_path (pprefix, do_multi,
2844 info.name_len + info.suffix_len,
2845 file_at_path, &info);
2848 /* Ranking of prefixes in the sort list. -B prefixes are put before
2851 enum path_prefix_priority
2853 PREFIX_PRIORITY_B_OPT,
2854 PREFIX_PRIORITY_LAST
2857 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2858 order according to PRIORITY. Within each PRIORITY, new entries are
2861 If WARN is nonzero, we will warn if no file is found
2862 through this prefix. WARN should point to an int
2863 which will be set to 1 if this entry is used.
2865 COMPONENT is the value to be passed to update_path.
2867 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2868 the complete value of machine_suffix.
2869 2 means try both machine_suffix and just_machine_suffix. */
2872 add_prefix (struct path_prefix *pprefix, const char *prefix,
2873 const char *component, /* enum prefix_priority */ int priority,
2874 int require_machine_suffix, int os_multilib)
2876 struct prefix_list *pl, **prev;
2879 for (prev = &pprefix->plist;
2880 (*prev) != NULL && (*prev)->priority <= priority;
2881 prev = &(*prev)->next)
2884 /* Keep track of the longest prefix. */
2886 prefix = update_path (prefix, component);
2887 len = strlen (prefix);
2888 if (len > pprefix->max_len)
2889 pprefix->max_len = len;
2891 pl = XNEW (struct prefix_list);
2892 pl->prefix = prefix;
2893 pl->require_machine_suffix = require_machine_suffix;
2894 pl->priority = priority;
2895 pl->os_multilib = os_multilib;
2897 /* Insert after PREV. */
2902 /* Same as add_prefix, but prepending target_system_root to prefix. */
2903 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2905 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2906 const char *component,
2907 /* enum prefix_priority */ int priority,
2908 int require_machine_suffix, int os_multilib)
2910 if (!IS_ABSOLUTE_PATH (prefix))
2911 fatal ("system path '%s' is not absolute", prefix);
2913 if (target_system_root)
2915 if (target_sysroot_suffix)
2916 prefix = concat (target_sysroot_suffix, prefix, NULL);
2917 prefix = concat (target_system_root, prefix, NULL);
2919 /* We have to override this because GCC's notion of sysroot
2920 moves along with GCC. */
2924 add_prefix (pprefix, prefix, component, priority,
2925 require_machine_suffix, os_multilib);
2928 /* Execute the command specified by the arguments on the current line of spec.
2929 When using pipes, this includes several piped-together commands
2930 with `|' between them.
2932 Return 0 if successful, -1 if failed. */
2938 int n_commands; /* # of command. */
2940 struct pex_obj *pex;
2943 const char *prog; /* program name. */
2944 const char **argv; /* vector of args. */
2947 struct command *commands; /* each command buffer with above info. */
2949 gcc_assert (!processing_spec_function);
2953 string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2954 argbuf[0] = (string) ? string : argbuf[0];
2955 insert_wrapper (wrapper_string);
2958 /* Count # of piped commands. */
2959 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2960 if (strcmp (argbuf[i], "|") == 0)
2963 /* Get storage for each command. */
2964 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2966 /* Split argbuf into its separate piped processes,
2967 and record info about each one.
2968 Also search for the programs that are to be run. */
2970 commands[0].prog = argbuf[0]; /* first command. */
2971 commands[0].argv = &argbuf[0];
2973 if (!wrapper_string)
2975 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2976 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2979 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2980 if (strcmp (argbuf[i], "|") == 0)
2981 { /* each command. */
2982 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2983 fatal ("-pipe not supported");
2985 argbuf[i] = 0; /* termination of command args. */
2986 commands[n_commands].prog = argbuf[i + 1];
2987 commands[n_commands].argv = &argbuf[i + 1];
2988 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2991 commands[n_commands].argv[0] = string;
2995 argbuf[argbuf_index] = 0;
2997 /* If -v, print what we are about to do, and maybe query. */
3001 /* For help listings, put a blank line between sub-processes. */
3002 if (print_help_list)
3003 fputc ('\n', stderr);
3005 /* Print each piped command as a separate line. */
3006 for (i = 0; i < n_commands; i++)
3008 const char *const *j;
3010 if (verbose_only_flag)
3012 for (j = commands[i].argv; *j; j++)
3015 fprintf (stderr, " \"");
3016 for (p = *j; *p; ++p)
3018 if (*p == '"' || *p == '\\' || *p == '$')
3019 fputc ('\\', stderr);
3022 fputc ('"', stderr);
3026 for (j = commands[i].argv; *j; j++)
3027 fprintf (stderr, " %s", *j);
3029 /* Print a pipe symbol after all but the last command. */
3030 if (i + 1 != n_commands)
3031 fprintf (stderr, " |");
3032 fprintf (stderr, "\n");
3035 if (verbose_only_flag != 0)
3037 /* verbose_only_flag should act as if the spec was
3038 executed, so increment execution_count before
3039 returning. This prevents spurious warnings about
3040 unused linker input files, etc. */
3045 notice ("\nGo ahead? (y or n) ");
3049 while (getchar () != '\n')
3052 if (i != 'y' && i != 'Y')
3057 #ifdef ENABLE_VALGRIND_CHECKING
3058 /* Run the each command through valgrind. To simplify prepending the
3059 path to valgrind and the option "-q" (for quiet operation unless
3060 something triggers), we allocate a separate argv array. */
3062 for (i = 0; i < n_commands; i++)
3068 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3071 argv = XALLOCAVEC (const char *, argc + 3);
3073 argv[0] = VALGRIND_PATH;
3075 for (j = 2; j < argc + 2; j++)
3076 argv[j] = commands[i].argv[j - 2];
3079 commands[i].argv = argv;
3080 commands[i].prog = argv[0];
3084 /* Run each piped subprocess. */
3086 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3087 ? PEX_RECORD_TIMES : 0),
3088 programname, temp_filename);
3090 pfatal_with_name (_("pex_init failed"));
3092 for (i = 0; i < n_commands; i++)
3096 const char *string = commands[i].argv[0];
3098 errmsg = pex_run (pex,
3099 ((i + 1 == n_commands ? PEX_LAST : 0)
3100 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3101 string, CONST_CAST (char **, commands[i].argv),
3110 pfatal_with_name (errmsg);
3114 if (string != commands[i].prog)
3115 free (CONST_CAST (char *, string));
3120 /* Wait for all the subprocesses to finish. */
3124 struct pex_time *times = NULL;
3127 statuses = (int *) alloca (n_commands * sizeof (int));
3128 if (!pex_get_status (pex, n_commands, statuses))
3129 pfatal_with_name (_("failed to get exit status"));
3131 if (report_times || report_times_to_file)
3133 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3134 if (!pex_get_times (pex, n_commands, times))
3135 pfatal_with_name (_("failed to get process times"));
3140 for (i = 0; i < n_commands; ++i)
3142 int status = statuses[i];
3144 if (WIFSIGNALED (status))
3147 /* SIGPIPE is a special case. It happens in -pipe mode
3148 when the compiler dies before the preprocessor is done,
3149 or the assembler dies before the compiler is done.
3150 There's generally been an error already, and this is
3151 just fallout. So don't generate another error unless
3152 we would otherwise have succeeded. */
3153 if (WTERMSIG (status) == SIGPIPE
3154 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3162 Internal error: %s (program %s)\n\
3163 Please submit a full bug report.\n\
3164 See %s for instructions.",
3165 strsignal (WTERMSIG (status)), commands[i].prog,
3168 else if (WIFEXITED (status)
3169 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3171 if (WEXITSTATUS (status) > greatest_status)
3172 greatest_status = WEXITSTATUS (status);
3176 if (report_times || report_times_to_file)
3178 struct pex_time *pt = ×[i];
3181 ut = ((double) pt->user_seconds
3182 + (double) pt->user_microseconds / 1.0e6);
3183 st = ((double) pt->system_seconds
3184 + (double) pt->system_microseconds / 1.0e6);
3189 notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3191 if (report_times_to_file)
3194 const char *const *j;
3196 fprintf (report_times_to_file, "%g %g", ut, st);
3198 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3201 for (p = *j; *p; ++p)
3202 if (*p == '"' || *p == '\\' || *p == '$'
3208 fprintf (report_times_to_file, " \"");
3209 for (p = *j; *p; ++p)
3211 if (*p == '"' || *p == '\\' || *p == '$')
3212 fputc ('\\', report_times_to_file);
3213 fputc (*p, report_times_to_file);
3215 fputc ('"', report_times_to_file);
3218 fprintf (report_times_to_file, " %s", *j);
3221 fputc ('\n', report_times_to_file);
3231 /* Find all the switches given to us
3232 and make a vector describing them.
3233 The elements of the vector are strings, one per switch given.
3234 If a switch uses following arguments, then the `part1' field
3235 is the switch itself and the `args' field
3236 is a null-terminated vector containing the following arguments.
3237 Bits in the `live_cond' field are:
3238 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3239 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3240 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3241 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3242 in all do_spec calls afterwards. Used for %<S from self specs.
3243 The `validated' field is nonzero if any spec has looked at this switch;
3244 if it remains zero at the end of the run, it must be meaningless. */
3246 #define SWITCH_LIVE 0x1
3247 #define SWITCH_FALSE 0x2
3248 #define SWITCH_IGNORE 0x4
3249 #define SWITCH_IGNORE_PERMANENTLY 0x8
3255 unsigned int live_cond;
3256 unsigned char validated;
3257 unsigned char ordering;
3260 static struct switchstr *switches;
3262 static int n_switches;
3264 /* Set to zero if -fcompare-debug is disabled, positive if it's
3265 enabled and we're running the first compilation, negative if it's
3266 enabled and we're running the second compilation. For most of the
3267 time, it's in the range -1..1, but it can be temporarily set to 2
3268 or 3 to indicate that the -fcompare-debug flags didn't come from
3269 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3270 variable, until a synthesized -fcompare-debug flag is added to the
3274 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3275 int compare_debug_second;
3277 /* Set to the flags that should be passed to the second compilation in
3278 a -fcompare-debug compilation. */
3279 const char *compare_debug_opt;
3281 static struct switchstr *switches_debug_check[2];
3283 static int n_switches_debug_check[2];
3285 static char *debug_check_temp_file[2];
3287 /* Language is one of three things:
3289 1) The name of a real programming language.
3290 2) NULL, indicating that no one has figured out
3292 3) '*', indicating that the file should be passed
3297 const char *language;
3298 struct compiler *incompiler;
3303 /* Also a vector of input files specified. */
3305 static struct infile *infiles;
3309 /* True if multiple input files are being compiled to a single
3312 static bool combine_inputs;
3314 /* This counts the number of libraries added by lang_specific_driver, so that
3315 we can tell if there were any user supplied any files or libraries. */
3317 static int added_libraries;
3319 /* And a vector of corresponding output files is made up later. */
3321 const char **outfiles;
3323 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3325 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3326 is true if we should look for an executable suffix. DO_OBJ
3327 is true if we should look for an object suffix. */
3330 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3331 int do_obj ATTRIBUTE_UNUSED)
3333 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3341 len = strlen (name);
3343 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3344 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3345 if (do_obj && len > 2
3346 && name[len - 2] == '.'
3347 && name[len - 1] == 'o')
3349 obstack_grow (&obstack, name, len - 2);
3350 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3351 name = XOBFINISH (&obstack, const char *);
3355 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3356 /* If there is no filetype, make it the executable suffix (which includes
3357 the "."). But don't get confused if we have just "-o". */
3358 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3361 for (i = len - 1; i >= 0; i--)
3362 if (IS_DIR_SEPARATOR (name[i]))
3365 for (i++; i < len; i++)
3369 obstack_grow (&obstack, name, len);
3370 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3371 strlen (TARGET_EXECUTABLE_SUFFIX));
3372 name = XOBFINISH (&obstack, const char *);
3379 /* Display the command line switches accepted by gcc. */
3383 printf (_("Usage: %s [options] file...\n"), programname);
3384 fputs (_("Options:\n"), stdout);
3386 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3387 fputs (_(" --help Display this information\n"), stdout);
3388 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3389 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3390 fputs (_(" Display specific types of command line options\n"), stdout);
3392 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3393 fputs (_(" --version Display compiler version information\n"), stdout);
3394 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3395 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3396 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3397 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3398 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3399 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3400 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3401 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3403 -print-multi-lib Display the mapping between command line options and\n\
3404 multiple library search directories\n"), stdout);
3405 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3406 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3407 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3408 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3409 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3410 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3411 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3412 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3413 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3414 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3415 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3416 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3418 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3419 prefixes to other gcc components\n"), stdout);
3420 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3421 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3422 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3423 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3425 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3426 and libraries\n"), stdout);
3427 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3428 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3429 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3430 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3431 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3432 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3433 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3435 -x <language> Specify the language of the following input files\n\
3436 Permissible languages include: c c++ assembler none\n\
3437 'none' means revert to the default behavior of\n\
3438 guessing the language based on the file's extension\n\
3442 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3443 passed on to the various sub-processes invoked by %s. In order to pass\n\
3444 other options on to these processes the -W<letter> options must be used.\n\
3447 /* The rest of the options are displayed by invocations of the various
3452 add_preprocessor_option (const char *option, int len)
3454 n_preprocessor_options++;
3456 if (! preprocessor_options)
3457 preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3459 preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3460 n_preprocessor_options);
3462 preprocessor_options [n_preprocessor_options - 1] =
3463 save_string (option, len);
3467 add_assembler_option (const char *option, int len)
3469 n_assembler_options++;
3471 if (! assembler_options)
3472 assembler_options = XNEWVEC (char *, n_assembler_options);
3474 assembler_options = XRESIZEVEC (char *, assembler_options,
3475 n_assembler_options);
3477 assembler_options [n_assembler_options - 1] = save_string (option, len);
3481 add_linker_option (const char *option, int len)
3485 if (! linker_options)
3486 linker_options = XNEWVEC (char *, n_linker_options);
3488 linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3490 linker_options [n_linker_options - 1] = save_string (option, len);
3493 /* Create the vector `switches' and its contents.
3494 Store its length in `n_switches'. */
3497 process_command (int argc, const char **argv)
3502 const char *spec_lang = 0;
3503 int last_language_n_infiles;
3504 int lang_n_infiles = 0;
3505 #ifdef MODIFY_TARGET_NAME
3506 int is_modify_target_name;
3509 const char *tooldir_prefix;
3510 char *(*get_relative_prefix) (const char *, const char *,
3511 const char *) = NULL;
3513 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3517 added_libraries = 0;
3519 /* Figure compiler version from version string. */
3521 compiler_version = temp1 = xstrdup (version_string);
3523 for (; *temp1; ++temp1)
3532 /* Convert new-style -- options to old-style. */
3533 translate_options (&argc,
3534 CONST_CAST2 (const char *const **, const char ***,
3537 /* Handle any -no-canonical-prefixes flag early, to assign the function
3538 that builds relative prefixes. This function creates default search
3539 paths that are needed later in normal option handling. */
3541 for (i = 1; i < argc; i++)
3543 if (! strcmp (argv[i], "-no-canonical-prefixes"))
3545 get_relative_prefix = make_relative_prefix_ignore_links;
3549 if (! get_relative_prefix)
3550 get_relative_prefix = make_relative_prefix;
3552 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3553 see if we can create it from the pathname specified in argv[0]. */
3555 gcc_libexec_prefix = standard_libexec_prefix;
3557 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3558 if (!gcc_exec_prefix)
3560 gcc_exec_prefix = get_relative_prefix (argv[0],
3561 standard_bindir_prefix,
3562 standard_exec_prefix);
3563 gcc_libexec_prefix = get_relative_prefix (argv[0],
3564 standard_bindir_prefix,
3565 standard_libexec_prefix);
3566 if (gcc_exec_prefix)
3567 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3571 /* make_relative_prefix requires a program name, but
3572 GCC_EXEC_PREFIX is typically a directory name with a trailing
3573 / (which is ignored by make_relative_prefix), so append a
3575 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3576 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3577 standard_exec_prefix,
3578 standard_libexec_prefix);
3580 /* The path is unrelocated, so fallback to the original setting. */
3581 if (!gcc_libexec_prefix)
3582 gcc_libexec_prefix = standard_libexec_prefix;
3588 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3589 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3590 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3592 /* Do language-specific adjustment/addition of flags. */
3593 lang_specific_driver (&argc,
3594 CONST_CAST2 (const char *const **, const char ***,
3598 if (gcc_exec_prefix)
3600 int len = strlen (gcc_exec_prefix);
3602 if (len > (int) sizeof ("/lib/gcc/") - 1
3603 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3605 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3606 if (IS_DIR_SEPARATOR (*temp)
3607 && strncmp (temp + 1, "lib", 3) == 0
3608 && IS_DIR_SEPARATOR (temp[4])
3609 && strncmp (temp + 5, "gcc", 3) == 0)
3610 len -= sizeof ("/lib/gcc/") - 1;
3613 set_std_prefix (gcc_exec_prefix, len);
3614 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3615 PREFIX_PRIORITY_LAST, 0, 0);
3616 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3617 PREFIX_PRIORITY_LAST, 0, 0);
3620 /* COMPILER_PATH and LIBRARY_PATH have values
3621 that are lists of directory names with colons. */
3623 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3626 const char *startp, *endp;
3627 char *nstore = (char *) alloca (strlen (temp) + 3);
3629 startp = endp = temp;
3632 if (*endp == PATH_SEPARATOR || *endp == 0)
3634 strncpy (nstore, startp, endp - startp);
3636 strcpy (nstore, concat (".", dir_separator_str, NULL));
3637 else if (!IS_DIR_SEPARATOR (endp[-1]))
3639 nstore[endp - startp] = DIR_SEPARATOR;
3640 nstore[endp - startp + 1] = 0;
3643 nstore[endp - startp] = 0;
3644 add_prefix (&exec_prefixes, nstore, 0,
3645 PREFIX_PRIORITY_LAST, 0, 0);
3646 add_prefix (&include_prefixes, nstore, 0,
3647 PREFIX_PRIORITY_LAST, 0, 0);
3650 endp = startp = endp + 1;
3657 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3658 if (temp && *cross_compile == '0')
3660 const char *startp, *endp;
3661 char *nstore = (char *) alloca (strlen (temp) + 3);
3663 startp = endp = temp;
3666 if (*endp == PATH_SEPARATOR || *endp == 0)
3668 strncpy (nstore, startp, endp - startp);
3670 strcpy (nstore, concat (".", dir_separator_str, NULL));
3671 else if (!IS_DIR_SEPARATOR (endp[-1]))
3673 nstore[endp - startp] = DIR_SEPARATOR;
3674 nstore[endp - startp + 1] = 0;
3677 nstore[endp - startp] = 0;
3678 add_prefix (&startfile_prefixes, nstore, NULL,
3679 PREFIX_PRIORITY_LAST, 0, 1);
3682 endp = startp = endp + 1;
3689 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3690 GET_ENVIRONMENT (temp, "LPATH");
3691 if (temp && *cross_compile == '0')
3693 const char *startp, *endp;
3694 char *nstore = (char *) alloca (strlen (temp) + 3);
3696 startp = endp = temp;
3699 if (*endp == PATH_SEPARATOR || *endp == 0)
3701 strncpy (nstore, startp, endp - startp);
3703 strcpy (nstore, concat (".", dir_separator_str, NULL));
3704 else if (!IS_DIR_SEPARATOR (endp[-1]))
3706 nstore[endp - startp] = DIR_SEPARATOR;
3707 nstore[endp - startp + 1] = 0;
3710 nstore[endp - startp] = 0;
3711 add_prefix (&startfile_prefixes, nstore, NULL,
3712 PREFIX_PRIORITY_LAST, 0, 1);
3715 endp = startp = endp + 1;
3722 /* Scan argv twice. Here, the first time, just count how many switches
3723 there will be in their vector, and how many input files in theirs.
3724 Here we also parse the switches that cc itself uses (e.g. -v). */
3726 for (i = 1; i < argc; i++)
3728 if (! strcmp (argv[i], "-dumpspecs"))
3730 struct spec_list *sl;
3732 for (sl = specs; sl; sl = sl->next)
3733 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3734 if (link_command_spec)
3735 printf ("*link_command:\n%s\n\n", link_command_spec);
3738 else if (! strcmp (argv[i], "-dumpversion"))
3740 printf ("%s\n", spec_version);
3743 else if (! strcmp (argv[i], "-dumpmachine"))
3745 printf ("%s\n", spec_machine);
3748 else if (strcmp (argv[i], "-fversion") == 0)
3750 /* translate_options () has turned --version into -fversion. */
3753 /* We will be passing a dummy file on to the sub-processes. */
3757 /* CPP driver cannot obtain switch from cc1_options. */
3759 add_preprocessor_option ("--version", strlen ("--version"));
3760 add_assembler_option ("--version", strlen ("--version"));
3761 add_linker_option ("--version", strlen ("--version"));
3763 else if (strcmp (argv[i], "-fhelp") == 0)
3765 /* translate_options () has turned --help into -fhelp. */
3766 print_help_list = 1;
3768 /* We will be passing a dummy file on to the sub-processes. */
3772 /* CPP driver cannot obtain switch from cc1_options. */
3774 add_preprocessor_option ("--help", 6);
3775 add_assembler_option ("--help", 6);
3776 add_linker_option ("--help", 6);
3778 else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3780 /* translate_options () has turned --help into -fhelp. */
3781 print_subprocess_help = 2;
3783 /* We will be passing a dummy file on to the sub-processes. */
3787 else if (strcmp (argv[i], "-ftarget-help") == 0)
3789 /* translate_options() has turned --target-help into -ftarget-help. */
3790 print_subprocess_help = 1;
3792 /* We will be passing a dummy file on to the sub-processes. */
3796 /* CPP driver cannot obtain switch from cc1_options. */
3798 add_preprocessor_option ("--target-help", 13);
3799 add_assembler_option ("--target-help", 13);
3800 add_linker_option ("--target-help", 13);
3802 else if (! strcmp (argv[i], "-pass-exit-codes"))
3804 pass_exit_codes = 1;
3807 else if (! strcmp (argv[i], "-print-search-dirs"))
3808 print_search_dirs = 1;
3809 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3810 print_file_name = "libgcc.a";
3811 else if (! strncmp (argv[i], "-print-file-name=", 17))
3812 print_file_name = argv[i] + 17;
3813 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3814 print_prog_name = argv[i] + 17;
3815 else if (! strcmp (argv[i], "-print-multi-lib"))
3816 print_multi_lib = 1;
3817 else if (! strcmp (argv[i], "-print-multi-directory"))
3818 print_multi_directory = 1;
3819 else if (! strcmp (argv[i], "-print-sysroot"))
3821 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3822 print_multi_os_directory = 1;
3823 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3824 print_sysroot_headers_suffix = 1;
3825 else if (! strcmp (argv[i], "-fcompare-debug-second"))
3827 compare_debug_second = 1;
3830 else if (! strcmp (argv[i], "-fno-compare-debug"))
3832 argv[i] = "-fcompare-debug=";
3833 goto compare_debug_with_arg;
3835 else if (! strcmp (argv[i], "-fcompare-debug"))
3837 argv[i] = "-fcompare-debug=-gtoggle";
3838 goto compare_debug_with_arg;
3840 #define OPT "-fcompare-debug="
3841 else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3844 compare_debug_with_arg:
3845 opt = argv[i] + sizeof (OPT) - 1;
3851 if (compare_debug < 0)
3852 compare_debug_opt = NULL;
3854 compare_debug_opt = opt;
3857 else if (! strncmp (argv[i], "-Wa,", 4))
3860 /* Pass the rest of this option to the assembler. */
3862 /* Split the argument at commas. */
3864 for (j = 4; argv[i][j]; j++)
3865 if (argv[i][j] == ',')
3867 add_assembler_option (argv[i] + prev, j - prev);
3871 /* Record the part after the last comma. */
3872 add_assembler_option (argv[i] + prev, j - prev);
3874 else if (! strncmp (argv[i], "-Wp,", 4))
3877 /* Pass the rest of this option to the preprocessor. */
3879 /* Split the argument at commas. */
3881 for (j = 4; argv[i][j]; j++)
3882 if (argv[i][j] == ',')
3884 add_preprocessor_option (argv[i] + prev, j - prev);
3888 /* Record the part after the last comma. */
3889 add_preprocessor_option (argv[i] + prev, j - prev);
3891 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3892 /* The +e options to the C++ front-end. */
3894 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3897 /* Split the argument at commas. */
3898 for (j = 3; argv[i][j]; j++)
3899 n_infiles += (argv[i][j] == ',');
3901 else if (strcmp (argv[i], "-Xlinker") == 0)
3904 fatal ("argument to '-Xlinker' is missing");
3909 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3912 fatal ("argument to '-Xpreprocessor' is missing");
3914 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3916 else if (strcmp (argv[i], "-Xassembler") == 0)
3919 fatal ("argument to '-Xassembler' is missing");
3921 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3923 else if (strcmp (argv[i], "-l") == 0)
3926 fatal ("argument to '-l' is missing");
3931 else if (strncmp (argv[i], "-l", 2) == 0)
3933 else if (strcmp (argv[i], "-save-temps") == 0)
3935 save_temps_flag = SAVE_TEMPS_CWD;
3938 else if (strncmp (argv[i], "-save-temps=", 12) == 0)
3941 if (strcmp (argv[i]+12, "cwd") == 0)
3942 save_temps_flag = SAVE_TEMPS_CWD;
3943 else if (strcmp (argv[i]+12, "obj") == 0
3944 || strcmp (argv[i]+12, "object") == 0)
3945 save_temps_flag = SAVE_TEMPS_OBJ;
3947 fatal ("'%s' is an unknown -save-temps option", argv[i]);
3949 else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
3950 /* Already handled as a special case, so ignored here. */
3952 else if (strcmp (argv[i], "-combine") == 0)
3957 else if (strcmp (argv[i], "-specs") == 0)
3959 struct user_specs *user = XNEW (struct user_specs);
3961 fatal ("argument to '-specs' is missing");
3963 user->next = (struct user_specs *) 0;
3964 user->filename = argv[i];
3965 if (user_specs_tail)
3966 user_specs_tail->next = user;
3968 user_specs_head = user;
3969 user_specs_tail = user;
3971 else if (strncmp (argv[i], "-specs=", 7) == 0)
3973 struct user_specs *user = XNEW (struct user_specs);
3974 if (strlen (argv[i]) == 7)
3975 fatal ("argument to '-specs=' is missing");
3977 user->next = (struct user_specs *) 0;
3978 user->filename = argv[i] + 7;
3979 if (user_specs_tail)
3980 user_specs_tail->next = user;
3982 user_specs_head = user;
3983 user_specs_tail = user;
3985 else if (strcmp (argv[i], "-time") == 0)
3987 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
3989 if (report_times_to_file)
3990 fclose (report_times_to_file);
3991 report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
3993 else if (strcmp (argv[i], "-pipe") == 0)
3995 /* -pipe has to go into the switches array as well as
4000 else if (strcmp (argv[i], "-wrapper") == 0)
4003 fatal ("argument to '-wrapper' is missing");
4005 wrapper_string = argv[i];
4009 else if (strcmp (argv[i], "-###") == 0)
4011 /* This is similar to -v except that there is no execution
4012 of the commands and the echoed arguments are quoted. It
4013 is intended for use in shell scripts to capture the
4014 driver-generated command line. */
4015 verbose_only_flag++;
4018 else if (argv[i][0] == '-' && argv[i][1] != 0)
4020 const char *p = &argv[i][1];
4030 if (p[1] == 0 && i + 1 == argc)
4031 fatal ("argument to '-B' is missing");
4037 len = strlen (value);
4039 /* Catch the case where the user has forgotten to append a
4040 directory separator to the path. Note, they may be using
4041 -B to add an executable name prefix, eg "i386-elf-", in
4042 order to distinguish between multiple installations of
4043 GCC in the same directory. Hence we must check to see
4044 if appending a directory separator actually makes a
4045 valid directory name. */
4046 if (! IS_DIR_SEPARATOR (value [len - 1])
4047 && is_directory (value, false))
4049 char *tmp = XNEWVEC (char, len + 2);
4050 strcpy (tmp, value);
4051 tmp[len] = DIR_SEPARATOR;
4056 add_prefix (&exec_prefixes, value, NULL,
4057 PREFIX_PRIORITY_B_OPT, 0, 0);
4058 add_prefix (&startfile_prefixes, value, NULL,
4059 PREFIX_PRIORITY_B_OPT, 0, 0);
4060 add_prefix (&include_prefixes, value, NULL,
4061 PREFIX_PRIORITY_B_OPT, 0, 0);
4066 case 'v': /* Print our subcommands and print versions. */
4068 /* If they do anything other than exactly `-v', don't set
4069 verbose_flag; rather, continue on to give the error. */
4088 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4093 /* Forward scan, just in case -S, -E or -c is specified
4100 if (argv[j][0] == '-')
4102 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4108 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4109 j += skip - (argv[j][2] != 0);
4110 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4117 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4119 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4121 argv[i] = convert_filename (argv[i], ! have_c, 0);
4123 /* Save the output name in case -save-temps=obj was used. */
4124 if ((p[1] == 0) && argv[i + 1])
4125 save_temps_prefix = xstrdup(argv[i + 1]);
4127 save_temps_prefix = xstrdup(argv[i] + 1);
4133 #ifdef MODIFY_TARGET_NAME
4134 is_modify_target_name = 0;
4136 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4137 if (! strcmp (argv[i], modify_target[j].sw))
4139 char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
4140 + strlen (spec_machine));
4143 int made_addition = 0;
4145 is_modify_target_name = 1;
4146 for (p = spec_machine, q = new_name; *p != 0; )
4148 if (modify_target[j].add_del == DELETE
4149 && (! strncmp (q, modify_target[j].str,
4150 strlen (modify_target[j].str))))
4151 p += strlen (modify_target[j].str);
4152 else if (modify_target[j].add_del == ADD
4153 && ! made_addition && *p == '-')
4155 for (r = modify_target[j].str; *r != 0; )
4163 spec_machine = new_name;
4166 if (is_modify_target_name)
4172 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
4173 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
4174 else if (WORD_SWITCH_TAKES_ARG (p))
4175 i += WORD_SWITCH_TAKES_ARG (p);
4185 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4186 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4187 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4189 save_temps_length = strlen (save_temps_prefix);
4190 temp = strrchr (lbasename (save_temps_prefix), '.');
4193 save_temps_length -= strlen (temp);
4194 save_temps_prefix[save_temps_length] = '\0';
4198 else if (save_temps_prefix != NULL)
4200 free (save_temps_prefix);
4201 save_temps_prefix = NULL;
4204 if (save_temps_flag && use_pipes)
4206 /* -save-temps overrides -pipe, so that temp files are produced */
4207 if (save_temps_flag)
4208 error ("warning: -pipe ignored because -save-temps specified");
4214 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4216 if (gcd && gcd[0] == '-')
4219 compare_debug_opt = gcd;
4222 else if (gcd && *gcd && strcmp (gcd, "0"))
4225 compare_debug_opt = "-gtoggle";
4229 else if (compare_debug < 0)
4232 gcc_assert (!compare_debug_opt);
4235 /* Set up the search paths. We add directories that we expect to
4236 contain GNU Toolchain components before directories specified by
4237 the machine description so that we will find GNU components (like
4238 the GNU assembler) before those of the host system. */
4240 /* If we don't know where the toolchain has been installed, use the
4241 configured-in locations. */
4242 if (!gcc_exec_prefix)
4245 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4246 PREFIX_PRIORITY_LAST, 1, 0);
4247 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4248 PREFIX_PRIORITY_LAST, 2, 0);
4249 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4250 PREFIX_PRIORITY_LAST, 2, 0);
4252 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4253 PREFIX_PRIORITY_LAST, 1, 0);
4256 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4257 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4258 dir_separator_str, NULL);
4260 /* Look for tools relative to the location from which the driver is
4261 running, or, if that is not available, the configured prefix. */
4263 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4264 spec_machine, dir_separator_str,
4265 spec_version, dir_separator_str, tooldir_prefix, NULL);
4267 add_prefix (&exec_prefixes,
4268 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4269 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4270 add_prefix (&startfile_prefixes,
4271 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4272 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4274 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4275 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4276 then consider it to relocate with the rest of the GCC installation
4277 if GCC_EXEC_PREFIX is set.
4278 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4279 if (target_system_root && gcc_exec_prefix)
4281 char *tmp_prefix = get_relative_prefix (argv[0],
4282 standard_bindir_prefix,
4283 target_system_root);
4284 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4286 target_system_root = tmp_prefix;
4287 target_system_root_changed = 1;
4292 /* More prefixes are enabled in main, after we read the specs file
4293 and determine whether this is cross-compilation or not. */
4295 /* Then create the space for the vectors and scan again. */
4297 switches = XNEWVEC (struct switchstr, n_switches + 1);
4298 infiles = XNEWVEC (struct infile, n_infiles + 1);
4301 last_language_n_infiles = -1;
4303 /* This, time, copy the text of each switch and store a pointer
4304 to the copy in the vector of switches.
4305 Store all the infiles in their vector. */
4307 for (i = 1; i < argc; i++)
4309 /* Just skip the switches that were handled by the preceding loop. */
4310 #ifdef MODIFY_TARGET_NAME
4311 is_modify_target_name = 0;
4313 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4314 if (! strcmp (argv[i], modify_target[j].sw))
4315 is_modify_target_name = 1;
4317 if (is_modify_target_name)
4321 if (! strncmp (argv[i], "-Wa,", 4))
4323 else if (! strncmp (argv[i], "-Wp,", 4))
4325 else if (! strcmp (argv[i], "-no-canonical-prefixes"))
4327 else if (! strcmp (argv[i], "-pass-exit-codes"))
4329 else if (! strcmp (argv[i], "-print-search-dirs"))
4331 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4333 else if (! strncmp (argv[i], "-print-file-name=", 17))
4335 else if (! strncmp (argv[i], "-print-prog-name=", 17))
4337 else if (! strcmp (argv[i], "-print-multi-lib"))
4339 else if (! strcmp (argv[i], "-print-multi-directory"))
4341 else if (! strcmp (argv[i], "-print-sysroot"))
4343 else if (! strcmp (argv[i], "-print-multi-os-directory"))
4345 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4347 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4349 target_system_root = argv[i] + strlen ("--sysroot=");
4350 target_system_root_changed = 1;
4352 else if (argv[i][0] == '+' && argv[i][1] == 'e')
4354 /* Compensate for the +e options to the C++ front-end;
4355 they're there simply for cfront call-compatibility. We do
4356 some magic in default_compilers to pass them down properly.
4357 Note we deliberately start at the `+' here, to avoid passing
4358 -e0 or -e1 down into the linker. */
4359 switches[n_switches].part1 = &argv[i][0];
4360 switches[n_switches].args = 0;
4361 switches[n_switches].live_cond = 0;
4362 switches[n_switches].validated = 0;
4365 else if (strncmp (argv[i], "-Wl,", 4) == 0)
4368 /* Split the argument at commas. */
4370 for (j = 4; argv[i][j]; j++)
4371 if (argv[i][j] == ',')
4373 infiles[n_infiles].language = "*";
4374 infiles[n_infiles++].name
4375 = save_string (argv[i] + prev, j - prev);
4378 /* Record the part after the last comma. */
4379 infiles[n_infiles].language = "*";
4380 infiles[n_infiles++].name = argv[i] + prev;
4382 else if (strcmp (argv[i], "-Xlinker") == 0)
4384 infiles[n_infiles].language = "*";
4385 infiles[n_infiles++].name = argv[++i];
4387 /* Xassembler and Xpreprocessor were already handled in the first argv
4388 scan, so all we need to do here is ignore them and their argument. */
4389 else if (strcmp (argv[i], "-Xassembler") == 0)
4391 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4393 else if (strcmp (argv[i], "-l") == 0)
4394 { /* POSIX allows separation of -l and the lib arg;
4395 canonicalize by concatenating -l with its arg */
4396 infiles[n_infiles].language = "*";
4397 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4399 else if (strncmp (argv[i], "-l", 2) == 0)
4401 infiles[n_infiles].language = "*";
4402 infiles[n_infiles++].name = argv[i];
4404 else if (strcmp (argv[i], "-wrapper") == 0)
4406 else if (strcmp (argv[i], "-specs") == 0)
4408 else if (strncmp (argv[i], "-specs=", 7) == 0)
4410 else if (strcmp (argv[i], "-time") == 0)
4412 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4414 else if (strcmp (argv[i], "-###") == 0)
4416 else if (argv[i][0] == '-' && argv[i][1] != 0)
4418 const char *p = &argv[i][1];
4423 if (p[1] == 0 && i + 1 == argc)
4424 fatal ("argument to '-x' is missing");
4426 spec_lang = argv[++i];
4429 if (! strcmp (spec_lang, "none"))
4430 /* Suppress the warning if -xnone comes after the last input
4431 file, because alternate command interfaces like g++ might
4432 find it useful to place -xnone after each input file. */
4435 last_language_n_infiles = n_infiles;
4438 switches[n_switches].part1 = p;
4439 /* Deal with option arguments in separate argv elements. */
4440 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4441 || WORD_SWITCH_TAKES_ARG (p))
4444 int n_args = WORD_SWITCH_TAKES_ARG (p);
4448 /* Count only the option arguments in separate argv elements. */
4449 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4451 if (i + n_args >= argc)
4452 fatal ("argument to '-%s' is missing", p);
4453 switches[n_switches].args
4454 = XNEWVEC (const char *, n_args + 1);
4456 switches[n_switches].args[j++] = argv[++i];
4457 /* Null-terminate the vector. */
4458 switches[n_switches].args[j] = 0;
4460 else if (strchr (switches_need_spaces, c))
4462 /* On some systems, ld cannot handle some options without
4463 a space. So split the option from its argument. */
4464 char *part1 = XNEWVEC (char, 2);
4468 switches[n_switches].part1 = part1;
4469 switches[n_switches].args = XNEWVEC (const char *, 2);
4470 switches[n_switches].args[0] = xstrdup (p+1);
4471 switches[n_switches].args[1] = 0;
4474 switches[n_switches].args = 0;
4476 switches[n_switches].live_cond = 0;
4477 switches[n_switches].validated = 0;
4478 switches[n_switches].ordering = 0;
4479 /* These are always valid, since gcc.c itself understands the
4480 first four, gfortranspec.c understands -static-libgfortran
4481 and g++spec.c understands -static-libstdc++ */
4482 if (!strcmp (p, "save-temps")
4483 || !strcmp (p, "static-libgcc")
4484 || !strcmp (p, "shared-libgcc")
4485 || !strcmp (p, "pipe")
4486 || !strcmp (p, "static-libgfortran")
4487 || !strcmp (p, "static-libstdc++"))
4488 switches[n_switches].validated = 1;
4491 char ch = switches[n_switches].part1[0];
4493 switches[n_switches].validated = 1;
4499 const char *p = strrchr (argv[i], '@');
4503 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4504 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4506 /* For LTO static archive support we handle input file
4507 specifications that are composed of a filename and
4508 an offset like FNAME@OFFSET. */
4511 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4512 && strlen (p) == (unsigned int)consumed)
4514 fname = (char *)xmalloc (p - argv[i] + 1);
4515 memcpy (fname, argv[i], p - argv[i]);
4516 fname[p - argv[i]] = '\0';
4517 /* Only accept non-stdin and existing FNAME parts, otherwise
4518 try with the full name. */
4519 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4522 fname = xstrdup (argv[i]);
4526 fname = xstrdup (argv[i]);
4528 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4530 perror_with_name (fname);
4535 infiles[n_infiles].language = spec_lang;
4536 infiles[n_infiles++].name = argv[i];
4543 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4544 error ("warning: '-x %s' after last input file has no effect", spec_lang);
4546 if (compare_debug == 2 || compare_debug == 3)
4548 switches[n_switches].part1 = concat ("fcompare-debug=",
4551 switches[n_switches].args = 0;
4552 switches[n_switches].live_cond = 0;
4553 switches[n_switches].validated = 0;
4554 switches[n_switches].ordering = 0;
4559 /* Ensure we only invoke each subprocess once. */
4560 if (print_subprocess_help || print_help_list || print_version)
4564 /* Create a dummy input file, so that we can pass
4565 the help option on to the various sub-processes. */
4566 infiles[0].language = "c";
4567 infiles[0].name = "help-dummy";
4570 switches[n_switches].part1 = 0;
4571 infiles[n_infiles].name = 0;
4574 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4575 and place that in the environment. */
4578 set_collect_gcc_options (void)
4583 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4585 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4586 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4589 for (i = 0; (int) i < n_switches; i++)
4591 const char *const *args;
4594 obstack_grow (&collect_obstack, " ", 1);
4598 /* Ignore elided switches. */
4599 if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4602 obstack_grow (&collect_obstack, "'-", 2);
4603 q = switches[i].part1;
4604 while ((p = strchr (q, '\'')))
4606 obstack_grow (&collect_obstack, q, p - q);
4607 obstack_grow (&collect_obstack, "'\\''", 4);
4610 obstack_grow (&collect_obstack, q, strlen (q));
4611 obstack_grow (&collect_obstack, "'", 1);
4613 for (args = switches[i].args; args && *args; args++)
4615 obstack_grow (&collect_obstack, " '", 2);
4617 while ((p = strchr (q, '\'')))
4619 obstack_grow (&collect_obstack, q, p - q);
4620 obstack_grow (&collect_obstack, "'\\''", 4);
4623 obstack_grow (&collect_obstack, q, strlen (q));
4624 obstack_grow (&collect_obstack, "'", 1);
4627 obstack_grow (&collect_obstack, "\0", 1);
4628 xputenv (XOBFINISH (&collect_obstack, char *));
4631 /* Process a spec string, accumulating and running commands. */
4633 /* These variables describe the input file name.
4634 input_file_number is the index on outfiles of this file,
4635 so that the output file name can be stored for later use by %o.
4636 input_basename is the start of the part of the input file
4637 sans all directory names, and basename_length is the number
4638 of characters starting there excluding the suffix .c or whatever. */
4640 static const char *input_filename;
4641 static int input_file_number;
4642 size_t input_filename_length;
4643 static int basename_length;
4644 static int suffixed_basename_length;
4645 static const char *input_basename;
4646 static const char *input_suffix;
4647 #ifndef HOST_LACKS_INODE_NUMBERS
4648 static struct stat input_stat;
4650 static int input_stat_set;
4652 /* The compiler used to process the current input file. */
4653 static struct compiler *input_file_compiler;
4655 /* These are variables used within do_spec and do_spec_1. */
4657 /* Nonzero if an arg has been started and not yet terminated
4658 (with space, tab or newline). */
4659 static int arg_going;
4661 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4662 is a temporary file name. */
4663 static int delete_this_arg;
4665 /* Nonzero means %w has been seen; the next arg to be terminated
4666 is the output file name of this compilation. */
4667 static int this_is_output_file;
4669 /* Nonzero means %s has been seen; the next arg to be terminated
4670 is the name of a library file and we should try the standard
4671 search dirs for it. */
4672 static int this_is_library_file;
4674 /* Nonzero means %T has been seen; the next arg to be terminated
4675 is the name of a linker script and we should try all of the
4676 standard search dirs for it. If it is found insert a --script
4677 command line switch and then substitute the full path in place,
4678 otherwise generate an error message. */
4679 static int this_is_linker_script;
4681 /* Nonzero means that the input of this command is coming from a pipe. */
4682 static int input_from_pipe;
4684 /* Nonnull means substitute this for any suffix when outputting a switches
4686 static const char *suffix_subst;
4688 /* If there is an argument being accumulated, terminate it and store it. */
4691 end_going_arg (void)
4697 obstack_1grow (&obstack, 0);
4698 string = XOBFINISH (&obstack, const char *);
4699 if (this_is_library_file)
4700 string = find_file (string);
4701 if (this_is_linker_script)
4703 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4705 if (full_script_path == NULL)
4707 error (_("unable to locate default linker script '%s' in the library search paths"), string);
4708 /* Script was not found on search path. */
4711 store_arg ("--script", false, false);
4712 string = full_script_path;
4714 store_arg (string, delete_this_arg, this_is_output_file);
4715 if (this_is_output_file)
4716 outfiles[input_file_number] = string;
4722 /* Parse the WRAPPER string which is a comma separated list of the command line
4723 and insert them into the beginning of argbuf. */
4726 insert_wrapper (const char *wrapper)
4730 char *buf = xstrdup (wrapper);
4739 while ((p = strchr (p, ',')) != NULL);
4741 if (argbuf_index + n >= argbuf_length)
4743 argbuf_length = argbuf_length * 2;
4744 while (argbuf_length < argbuf_index + n)
4746 argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4748 for (i = argbuf_index - 1; i >= 0; i--)
4749 argbuf[i + n] = argbuf[i];
4762 while ((p = strchr (p, ',')) != NULL);
4763 gcc_assert (i == n);
4767 /* Process the spec SPEC and run the commands specified therein.
4768 Returns 0 if the spec is successfully processed; -1 if failed. */
4771 do_spec (const char *spec)
4775 value = do_spec_2 (spec);
4777 /* Force out any unfinished command.
4778 If -pipe, this forces out the last command if it ended in `|'. */
4781 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4784 set_collect_gcc_options ();
4786 if (argbuf_index > 0)
4794 do_spec_2 (const char *spec)
4800 delete_this_arg = 0;
4801 this_is_output_file = 0;
4802 this_is_library_file = 0;
4803 this_is_linker_script = 0;
4804 input_from_pipe = 0;
4805 suffix_subst = NULL;
4807 result = do_spec_1 (spec, 0, NULL);
4815 /* Process the given spec string and add any new options to the end
4816 of the switches/n_switches array. */
4819 do_option_spec (const char *name, const char *spec)
4821 unsigned int i, value_count, value_len;
4822 const char *p, *q, *value;
4823 char *tmp_spec, *tmp_spec_p;
4825 if (configure_default_options[0].name == NULL)
4828 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4829 if (strcmp (configure_default_options[i].name, name) == 0)
4831 if (i == ARRAY_SIZE (configure_default_options))
4834 value = configure_default_options[i].value;
4835 value_len = strlen (value);
4837 /* Compute the size of the final spec. */
4840 while ((p = strstr (p, "%(VALUE)")) != NULL)
4846 /* Replace each %(VALUE) by the specified value. */
4847 tmp_spec = (char *) alloca (strlen (spec) + 1
4848 + value_count * (value_len - strlen ("%(VALUE)")));
4849 tmp_spec_p = tmp_spec;
4851 while ((p = strstr (q, "%(VALUE)")) != NULL)
4853 memcpy (tmp_spec_p, q, p - q);
4854 tmp_spec_p = tmp_spec_p + (p - q);
4855 memcpy (tmp_spec_p, value, value_len);
4856 tmp_spec_p += value_len;
4857 q = p + strlen ("%(VALUE)");
4859 strcpy (tmp_spec_p, q);
4861 do_self_spec (tmp_spec);
4864 /* Process the given spec string and add any new options to the end
4865 of the switches/n_switches array. */
4868 do_self_spec (const char *spec)
4873 do_spec_1 (" ", 0, NULL);
4875 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4876 do_self_specs adds the replacements to switches array, so it shouldn't
4877 be processed afterwards. */
4878 for (i = 0; i < n_switches; i++)
4879 if ((switches[i].live_cond & SWITCH_IGNORE))
4880 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4882 if (argbuf_index > 0)
4884 switches = XRESIZEVEC (struct switchstr, switches,
4885 n_switches + argbuf_index + 1);
4887 for (i = 0; i < argbuf_index; i++)
4889 struct switchstr *sw;
4890 const char *p = argbuf[i];
4893 /* Each switch should start with '-'. */
4895 fatal ("switch '%s' does not start with '-'", argbuf[i]);
4900 sw = &switches[n_switches++];
4906 /* Deal with option arguments in separate argv elements. */
4907 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4908 || WORD_SWITCH_TAKES_ARG (p))
4911 int n_args = WORD_SWITCH_TAKES_ARG (p);
4915 /* Count only the option arguments in separate argv elements. */
4916 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4918 if (i + n_args >= argbuf_index)
4919 fatal ("argument to '-%s' is missing", p);
4921 = XNEWVEC (const char *, n_args + 1);
4923 sw->args[j++] = argbuf[++i];
4924 /* Null-terminate the vector. */
4927 else if (strchr (switches_need_spaces, c))
4929 /* On some systems, ld cannot handle some options without
4930 a space. So split the option from its argument. */
4931 char *part1 = XNEWVEC (char, 2);
4936 sw->args = XNEWVEC (const char *, 2);
4937 sw->args[0] = xstrdup (p+1);
4944 switches[n_switches].part1 = 0;
4948 /* Callback for processing %D and %I specs. */
4950 struct spec_path_info {
4955 bool separate_options;
4959 spec_path (char *path, void *data)
4961 struct spec_path_info *info = (struct spec_path_info *) data;
4965 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4968 if (info->append_len != 0)
4970 len = strlen (path);
4971 memcpy (path + len, info->append, info->append_len + 1);
4974 if (!is_directory (path, true))
4977 do_spec_1 (info->option, 1, NULL);
4978 if (info->separate_options)
4979 do_spec_1 (" ", 0, NULL);
4981 if (info->append_len == 0)
4983 len = strlen (path);
4984 save = path[len - 1];
4985 if (IS_DIR_SEPARATOR (path[len - 1]))
4986 path[len - 1] = '\0';
4989 do_spec_1 (path, 1, NULL);
4990 do_spec_1 (" ", 0, NULL);
4992 /* Must not damage the original path. */
4993 if (info->append_len == 0)
4994 path[len - 1] = save;
4999 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5003 create_at_file (char **argv)
5005 char *temp_file = make_temp_file ("");
5006 char *at_argument = concat ("@", temp_file, NULL);
5007 FILE *f = fopen (temp_file, "w");
5011 fatal ("could not open temporary response file %s",
5014 status = writeargv (argv, f);
5017 fatal ("could not write to temporary response file %s",
5020 status = fclose (f);
5023 fatal ("could not close temporary response file %s",
5026 store_arg (at_argument, 0, 0);
5028 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5031 /* True if we should compile INFILE. */
5034 compile_input_file_p (struct infile *infile)
5036 if ((!infile->language) || (infile->language[0] != '*'))
5037 if (infile->incompiler == input_file_compiler)
5042 /* Process the sub-spec SPEC as a portion of a larger spec.
5043 This is like processing a whole spec except that we do
5044 not initialize at the beginning and we do not supply a
5045 newline by default at the end.
5046 INSWITCH nonzero means don't process %-sequences in SPEC;
5047 in this case, % is treated as an ordinary character.
5048 This is used while substituting switches.
5049 INSWITCH nonzero also causes SPC not to terminate an argument.
5051 Value is zero unless a line was finished
5052 and the command on that line reported an error. */
5055 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5057 const char *p = spec;
5063 /* If substituting a switch, treat all chars like letters.
5064 Otherwise, NL, SPC, TAB and % are special. */
5065 switch (inswitch ? 'a' : c)
5070 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5072 /* A `|' before the newline means use a pipe here,
5073 but only if -pipe was specified.
5074 Otherwise, execute now and don't pass the `|' as an arg. */
5077 input_from_pipe = 1;
5084 set_collect_gcc_options ();
5086 if (argbuf_index > 0)
5092 /* Reinitialize for a new command, and for a new argument. */
5095 delete_this_arg = 0;
5096 this_is_output_file = 0;
5097 this_is_library_file = 0;
5098 this_is_linker_script = 0;
5099 input_from_pipe = 0;
5106 obstack_1grow (&obstack, c);
5114 /* Reinitialize for a new argument. */
5115 delete_this_arg = 0;
5116 this_is_output_file = 0;
5117 this_is_library_file = 0;
5118 this_is_linker_script = 0;
5125 fatal ("spec '%s' invalid", spec);
5128 if (save_temps_length)
5129 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5131 obstack_grow (&obstack, input_basename, basename_length);
5132 if (compare_debug < 0)
5133 obstack_grow (&obstack, ".gk", 3);
5138 if (save_temps_length)
5139 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5141 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5142 if (compare_debug < 0)
5143 obstack_grow (&obstack, ".gk", 3);
5148 delete_this_arg = 2;
5151 /* Dump out the directories specified with LIBRARY_PATH,
5152 followed by the absolute directories
5153 that we search for startfiles. */
5156 struct spec_path_info info;
5159 info.append_len = 0;
5160 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5161 /* Used on systems which record the specified -L dirs
5162 and use them to search for dynamic linking.
5163 Relative directories always come from -B,
5164 and it is better not to use them for searching
5165 at run time. In particular, stage1 loses. */
5166 info.omit_relative = true;
5168 info.omit_relative = false;
5170 info.separate_options = false;
5172 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5177 /* %efoo means report an error with `foo' as error message
5178 and don't execute any more commands for this file. */
5182 while (*p != 0 && *p != '\n')
5184 buf = (char *) alloca (p - q + 1);
5185 strncpy (buf, q, p - q);
5187 error ("%s", _(buf));
5192 /* %nfoo means report a notice with `foo' on stderr. */
5196 while (*p != 0 && *p != '\n')
5198 buf = (char *) alloca (p - q + 1);
5199 strncpy (buf, q, p - q);
5201 notice ("%s\n", _(buf));
5211 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5212 defined, and it is not a directory, and it is
5213 writable, use it. Otherwise, treat this like any
5214 other temporary file. */
5216 if ((!save_temps_flag)
5217 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5218 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5220 obstack_grow (&obstack, HOST_BIT_BUCKET,
5221 strlen (HOST_BIT_BUCKET));
5222 delete_this_arg = 0;
5227 goto create_temp_file;
5231 obstack_1grow (&obstack, '-');
5232 delete_this_arg = 0;
5235 /* consume suffix */
5236 while (*p == '.' || ISALNUM ((unsigned char) *p))
5238 if (p[0] == '%' && p[1] == 'O')
5243 goto create_temp_file;
5247 /* consume suffix */
5248 while (*p == '.' || ISALNUM ((unsigned char) *p))
5250 if (p[0] == '%' && p[1] == 'O')
5255 goto create_temp_file;
5261 struct temp_name *t;
5263 const char *suffix = p;
5264 char *saved_suffix = NULL;
5266 while (*p == '.' || ISALNUM ((unsigned char) *p))
5268 suffix_length = p - suffix;
5269 if (p[0] == '%' && p[1] == 'O')
5272 /* We don't support extra suffix characters after %O. */
5273 if (*p == '.' || ISALNUM ((unsigned char) *p))
5274 fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5275 if (suffix_length == 0)
5276 suffix = TARGET_OBJECT_SUFFIX;
5280 = XNEWVEC (char, suffix_length
5281 + strlen (TARGET_OBJECT_SUFFIX));
5282 strncpy (saved_suffix, suffix, suffix_length);
5283 strcpy (saved_suffix + suffix_length,
5284 TARGET_OBJECT_SUFFIX);
5286 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5289 if (compare_debug < 0)
5291 suffix = concat (".gk", suffix, NULL);
5295 /* If -save-temps=obj and -o were specified, use that for the
5297 if (save_temps_length)
5300 temp_filename_length
5301 = save_temps_length + suffix_length + 1;
5302 tmp = (char *) alloca (temp_filename_length);
5303 memcpy (tmp, save_temps_prefix, save_temps_length);
5304 memcpy (tmp + save_temps_length, suffix, suffix_length);
5305 tmp[save_temps_length + suffix_length] = '\0';
5306 temp_filename = save_string (tmp,
5307 temp_filename_length + 1);
5308 obstack_grow (&obstack, temp_filename,
5309 temp_filename_length);
5311 delete_this_arg = 0;
5315 /* If the input_filename has the same suffix specified
5316 for the %g, %u, or %U, and -save-temps is specified,
5317 we could end up using that file as an intermediate
5318 thus clobbering the user's source file (.e.g.,
5319 gcc -save-temps foo.s would clobber foo.s with the
5320 output of cpp0). So check for this condition and
5321 generate a temp file as the intermediate. */
5323 if (save_temps_flag)
5326 temp_filename_length = basename_length + suffix_length + 1;
5327 tmp = (char *) alloca (temp_filename_length);
5328 memcpy (tmp, input_basename, basename_length);
5329 memcpy (tmp + basename_length, suffix, suffix_length);
5330 tmp[basename_length + suffix_length] = '\0';
5331 temp_filename = tmp;
5333 if (strcmp (temp_filename, input_filename) != 0)
5335 #ifndef HOST_LACKS_INODE_NUMBERS
5336 struct stat st_temp;
5338 /* Note, set_input() resets input_stat_set to 0. */
5339 if (input_stat_set == 0)
5341 input_stat_set = stat (input_filename, &input_stat);
5342 if (input_stat_set >= 0)
5346 /* If we have the stat for the input_filename
5347 and we can do the stat for the temp_filename
5348 then the they could still refer to the same
5349 file if st_dev/st_ino's are the same. */
5350 if (input_stat_set != 1
5351 || stat (temp_filename, &st_temp) < 0
5352 || input_stat.st_dev != st_temp.st_dev
5353 || input_stat.st_ino != st_temp.st_ino)
5355 /* Just compare canonical pathnames. */
5356 char* input_realname = lrealpath (input_filename);
5357 char* temp_realname = lrealpath (temp_filename);
5358 bool files_differ = strcmp (input_realname, temp_realname);
5359 free (input_realname);
5360 free (temp_realname);
5364 temp_filename = save_string (temp_filename,
5365 temp_filename_length + 1);
5366 obstack_grow (&obstack, temp_filename,
5367 temp_filename_length);
5369 delete_this_arg = 0;
5375 /* See if we already have an association of %g/%u/%U and
5377 for (t = temp_names; t; t = t->next)
5378 if (t->length == suffix_length
5379 && strncmp (t->suffix, suffix, suffix_length) == 0
5380 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5383 /* Make a new association if needed. %u and %j
5385 if (t == 0 || c == 'u' || c == 'j')
5389 t = XNEW (struct temp_name);
5390 t->next = temp_names;
5393 t->length = suffix_length;
5396 t->suffix = saved_suffix;
5397 saved_suffix = NULL;
5400 t->suffix = save_string (suffix, suffix_length);
5401 t->unique = (c == 'u' || c == 'U' || c == 'j');
5402 temp_filename = make_temp_file (t->suffix);
5403 temp_filename_length = strlen (temp_filename);
5404 t->filename = temp_filename;
5405 t->filename_length = temp_filename_length;
5409 free (saved_suffix);
5411 obstack_grow (&obstack, t->filename, t->filename_length);
5412 delete_this_arg = 1;
5420 if (at_file_supplied)
5422 /* We are going to expand `%i' to `@FILE', where FILE
5423 is a newly-created temporary filename. The filenames
5424 that would usually be expanded in place of %o will be
5425 written to the temporary file. */
5430 for (i = 0; i < n_infiles; i++)
5431 if (compile_input_file_p (&infiles[i]))
5434 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5436 /* Copy the strings over. */
5437 for (i = 0, j = 0; i < n_infiles; i++)
5438 if (compile_input_file_p (&infiles[i]))
5440 argv[j] = CONST_CAST (char *, infiles[i].name);
5441 infiles[i].compiled = true;
5446 create_at_file (argv);
5449 for (i = 0; (int) i < n_infiles; i++)
5450 if (compile_input_file_p (&infiles[i]))
5452 store_arg (infiles[i].name, 0, 0);
5453 infiles[i].compiled = true;
5458 obstack_grow (&obstack, input_filename, input_filename_length);
5465 struct spec_path_info info;
5469 do_spec_1 ("-imultilib", 1, NULL);
5470 /* Make this a separate argument. */
5471 do_spec_1 (" ", 0, NULL);
5472 do_spec_1 (multilib_dir, 1, NULL);
5473 do_spec_1 (" ", 0, NULL);
5476 if (gcc_exec_prefix)
5478 do_spec_1 ("-iprefix", 1, NULL);
5479 /* Make this a separate argument. */
5480 do_spec_1 (" ", 0, NULL);
5481 do_spec_1 (gcc_exec_prefix, 1, NULL);
5482 do_spec_1 (" ", 0, NULL);
5485 if (target_system_root_changed ||
5486 (target_system_root && target_sysroot_hdrs_suffix))
5488 do_spec_1 ("-isysroot", 1, NULL);
5489 /* Make this a separate argument. */
5490 do_spec_1 (" ", 0, NULL);
5491 do_spec_1 (target_system_root, 1, NULL);
5492 if (target_sysroot_hdrs_suffix)
5493 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5494 do_spec_1 (" ", 0, NULL);
5497 info.option = "-isystem";
5498 info.append = "include";
5499 info.append_len = strlen (info.append);
5500 info.omit_relative = false;
5501 info.separate_options = true;
5503 for_each_path (&include_prefixes, false, info.append_len,
5506 info.append = "include-fixed";
5507 if (*sysroot_hdrs_suffix_spec)
5508 info.append = concat (info.append, dir_separator_str,
5509 multilib_dir, NULL);
5510 info.append_len = strlen (info.append);
5511 for_each_path (&include_prefixes, false, info.append_len,
5518 int max = n_infiles;
5519 max += lang_specific_extra_outfiles;
5521 if (HAVE_GNU_LD && at_file_supplied)
5523 /* We are going to expand `%o' to `@FILE', where FILE
5524 is a newly-created temporary filename. The filenames
5525 that would usually be expanded in place of %o will be
5526 written to the temporary file. */
5531 /* Convert OUTFILES into a form suitable for writeargv. */
5533 /* Determine how many are non-NULL. */
5534 for (n_files = 0, i = 0; i < max; i++)
5535 n_files += outfiles[i] != NULL;
5537 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5539 /* Copy the strings over. */
5540 for (i = 0, j = 0; i < max; i++)
5543 argv[j] = CONST_CAST (char *, outfiles[i]);
5548 create_at_file (argv);
5551 for (i = 0; i < max; i++)
5553 store_arg (outfiles[i], 0, 0);
5558 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5563 this_is_library_file = 1;
5567 this_is_linker_script = 1;
5571 outfiles[input_file_number] = NULL;
5575 this_is_output_file = 1;
5580 int cur_index = argbuf_index;
5581 /* Handle the {...} following the %W. */
5583 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5584 p = handle_braces (p + 1);
5588 /* If any args were output, mark the last one for deletion
5590 if (argbuf_index != cur_index)
5591 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5595 /* %x{OPTION} records OPTION for %X to output. */
5601 /* Skip past the option value and make a copy. */
5603 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5606 string = save_string (p1 + 1, p - p1 - 2);
5608 /* See if we already recorded this option. */
5609 for (i = 0; i < n_linker_options; i++)
5610 if (! strcmp (string, linker_options[i]))
5616 /* This option is new; add it. */
5617 add_linker_option (string, strlen (string));
5621 /* Dump out the options accumulated previously using %x. */
5623 for (i = 0; i < n_linker_options; i++)
5625 do_spec_1 (linker_options[i], 1, NULL);
5626 /* Make each accumulated option a separate argument. */
5627 do_spec_1 (" ", 0, NULL);
5631 /* Dump out the options accumulated previously using -Wa,. */
5633 for (i = 0; i < n_assembler_options; i++)
5635 do_spec_1 (assembler_options[i], 1, NULL);
5636 /* Make each accumulated option a separate argument. */
5637 do_spec_1 (" ", 0, NULL);
5641 /* Dump out the options accumulated previously using -Wp,. */
5643 for (i = 0; i < n_preprocessor_options; i++)
5645 do_spec_1 (preprocessor_options[i], 1, NULL);
5646 /* Make each accumulated option a separate argument. */
5647 do_spec_1 (" ", 0, NULL);
5651 /* Here are digits and numbers that just process
5652 a certain constant string as a spec. */
5655 value = do_spec_1 (cc1_spec, 0, NULL);
5661 value = do_spec_1 (cc1plus_spec, 0, NULL);
5667 value = do_spec_1 (asm_spec, 0, NULL);
5673 value = do_spec_1 (asm_final_spec, 0, NULL);
5680 const char *const spec
5681 = (input_file_compiler->cpp_spec
5682 ? input_file_compiler->cpp_spec
5684 value = do_spec_1 (spec, 0, NULL);
5691 value = do_spec_1 (endfile_spec, 0, NULL);
5697 value = do_spec_1 (link_spec, 0, NULL);
5703 value = do_spec_1 (lib_spec, 0, NULL);
5709 value = do_spec_1 (libgcc_spec, 0, NULL);
5715 /* We assume there is a directory
5716 separator at the end of this string. */
5717 if (target_system_root)
5719 obstack_grow (&obstack, target_system_root,
5720 strlen (target_system_root));
5721 if (target_sysroot_suffix)
5722 obstack_grow (&obstack, target_sysroot_suffix,
5723 strlen (target_sysroot_suffix));
5728 value = do_spec_1 (startfile_spec, 0, NULL);
5733 /* Here we define characters other than letters and digits. */
5736 p = handle_braces (p);
5742 p = handle_spec_function (p);
5748 obstack_1grow (&obstack, '%');
5755 while (p[len] && p[len] != ' ' && p[len] != '%')
5757 suffix_subst = save_string (p - 1, len + 1);
5762 /* Henceforth ignore the option(s) matching the pattern
5767 int have_wildcard = 0;
5770 while (p[len] && p[len] != ' ' && p[len] != '\t')
5773 if (p[len-1] == '*')
5776 for (i = 0; i < n_switches; i++)
5777 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5778 && (have_wildcard || switches[i].part1[len] == '\0'))
5780 switches[i].live_cond |= SWITCH_IGNORE;
5781 switches[i].validated = 1;
5789 if (soft_matched_part)
5791 do_spec_1 (soft_matched_part, 1, NULL);
5792 do_spec_1 (" ", 0, NULL);
5795 /* Catch the case where a spec string contains something like
5796 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5797 hand side of the :. */
5798 error ("spec failure: '%%*' has not been initialized by pattern match");
5801 /* Process a string found as the value of a spec given by name.
5802 This feature allows individual machine descriptions
5803 to add and use their own specs.
5804 %[...] modifies -D options the way %P does;
5805 %(...) uses the spec unmodified. */
5807 error ("warning: use of obsolete %%[ operator in specs");
5810 const char *name = p;
5811 struct spec_list *sl;
5814 /* The string after the S/P is the name of a spec that is to be
5816 while (*p && *p != ')' && *p != ']')
5819 /* See if it's in the list. */
5820 for (len = p - name, sl = specs; sl; sl = sl->next)
5821 if (sl->name_len == len && !strncmp (sl->name, name, len))
5823 name = *(sl->ptr_spec);
5825 notice ("Processing spec %c%s%c, which is '%s'\n",
5826 c, sl->name, (c == '(') ? ')' : ']', name);
5835 value = do_spec_1 (name, 0, NULL);
5841 char *x = (char *) alloca (strlen (name) * 2 + 1);
5843 const char *y = name;
5846 /* Copy all of NAME into BUF, but put __ after
5847 every -D and at the end of each arg. */
5850 if (! strncmp (y, "-D", 2))
5861 && (*y == ' ' || *y == '\t' || *y == '='
5862 || *y == '}' || *y == 0))
5875 value = do_spec_1 (buf, 0, NULL);
5881 /* Discard the closing paren or bracket. */
5888 error ("spec failure: unrecognized spec option '%c'", c);
5894 /* Backslash: treat next character as ordinary. */
5899 /* Ordinary character: put it into the current argument. */
5900 obstack_1grow (&obstack, c);
5904 /* End of string. If we are processing a spec function, we need to
5905 end any pending argument. */
5906 if (processing_spec_function)
5912 /* Look up a spec function. */
5914 static const struct spec_function *
5915 lookup_spec_function (const char *name)
5917 const struct spec_function *sf;
5919 for (sf = static_spec_functions; sf->name != NULL; sf++)
5920 if (strcmp (sf->name, name) == 0)
5926 /* Evaluate a spec function. */
5929 eval_spec_function (const char *func, const char *args)
5931 const struct spec_function *sf;
5932 const char *funcval;
5934 /* Saved spec processing context. */
5935 int save_argbuf_index;
5936 int save_argbuf_length;
5937 const char **save_argbuf;
5940 int save_delete_this_arg;
5941 int save_this_is_output_file;
5942 int save_this_is_library_file;
5943 int save_input_from_pipe;
5944 int save_this_is_linker_script;
5945 const char *save_suffix_subst;
5948 sf = lookup_spec_function (func);
5950 fatal ("unknown spec function '%s'", func);
5952 /* Push the spec processing context. */
5953 save_argbuf_index = argbuf_index;
5954 save_argbuf_length = argbuf_length;
5955 save_argbuf = argbuf;
5957 save_arg_going = arg_going;
5958 save_delete_this_arg = delete_this_arg;
5959 save_this_is_output_file = this_is_output_file;
5960 save_this_is_library_file = this_is_library_file;
5961 save_this_is_linker_script = this_is_linker_script;
5962 save_input_from_pipe = input_from_pipe;
5963 save_suffix_subst = suffix_subst;
5965 /* Create a new spec processing context, and build the function
5969 if (do_spec_2 (args) < 0)
5970 fatal ("error in args to spec function '%s'", func);
5972 /* argbuf_index is an index for the next argument to be inserted, and
5973 so contains the count of the args already inserted. */
5975 funcval = (*sf->func) (argbuf_index, argbuf);
5977 /* Pop the spec processing context. */
5978 argbuf_index = save_argbuf_index;
5979 argbuf_length = save_argbuf_length;
5981 argbuf = save_argbuf;
5983 arg_going = save_arg_going;
5984 delete_this_arg = save_delete_this_arg;
5985 this_is_output_file = save_this_is_output_file;
5986 this_is_library_file = save_this_is_library_file;
5987 this_is_linker_script = save_this_is_linker_script;
5988 input_from_pipe = save_input_from_pipe;
5989 suffix_subst = save_suffix_subst;
5994 /* Handle a spec function call of the form:
5998 ARGS is processed as a spec in a separate context and split into an
5999 argument vector in the normal fashion. The function returns a string
6000 containing a spec which we then process in the caller's context, or
6001 NULL if no processing is required. */
6004 handle_spec_function (const char *p)
6007 const char *endp, *funcval;
6010 processing_spec_function++;
6012 /* Get the function name. */
6013 for (endp = p; *endp != '\0'; endp++)
6015 if (*endp == '(') /* ) */
6017 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6018 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6019 fatal ("malformed spec function name");
6021 if (*endp != '(') /* ) */
6022 fatal ("no arguments for spec function");
6023 func = save_string (p, endp - p);
6026 /* Get the arguments. */
6027 for (count = 0; *endp != '\0'; endp++)
6036 else if (*endp == '(') /* ) */
6041 fatal ("malformed spec function arguments");
6042 args = save_string (p, endp - p);
6045 /* p now points to just past the end of the spec function expression. */
6047 funcval = eval_spec_function (func, args);
6048 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6054 processing_spec_function--;
6059 /* Inline subroutine of handle_braces. Returns true if the current
6060 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6062 input_suffix_matches (const char *atom, const char *end_atom)
6064 return (input_suffix
6065 && !strncmp (input_suffix, atom, end_atom - atom)
6066 && input_suffix[end_atom - atom] == '\0');
6069 /* Subroutine of handle_braces. Returns true if the current
6070 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6072 input_spec_matches (const char *atom, const char *end_atom)
6074 return (input_file_compiler
6075 && input_file_compiler->suffix
6076 && input_file_compiler->suffix[0] != '\0'
6077 && !strncmp (input_file_compiler->suffix + 1, atom,
6079 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6082 /* Subroutine of handle_braces. Returns true if a switch
6083 matching the atom bracketed by ATOM and END_ATOM appeared on the
6086 switch_matches (const char *atom, const char *end_atom, int starred)
6089 int len = end_atom - atom;
6090 int plen = starred ? len : -1;
6092 for (i = 0; i < n_switches; i++)
6093 if (!strncmp (switches[i].part1, atom, len)
6094 && (starred || switches[i].part1[len] == '\0')
6095 && check_live_switch (i, plen))
6101 /* Inline subroutine of handle_braces. Mark all of the switches which
6102 match ATOM (extends to END_ATOM; STARRED indicates whether there
6103 was a star after the atom) for later processing. */
6105 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6108 int len = end_atom - atom;
6109 int plen = starred ? len : -1;
6111 for (i = 0; i < n_switches; i++)
6112 if (!strncmp (switches[i].part1, atom, len)
6113 && (starred || switches[i].part1[len] == '\0')
6114 && check_live_switch (i, plen))
6115 switches[i].ordering = 1;
6118 /* Inline subroutine of handle_braces. Process all the currently
6119 marked switches through give_switch, and clear the marks. */
6121 process_marked_switches (void)
6125 for (i = 0; i < n_switches; i++)
6126 if (switches[i].ordering == 1)
6128 switches[i].ordering = 0;
6133 /* Handle a %{ ... } construct. P points just inside the leading {.
6134 Returns a pointer one past the end of the brace block, or 0
6135 if we call do_spec_1 and that returns -1. */
6138 handle_braces (const char *p)
6140 const char *atom, *end_atom;
6141 const char *d_atom = NULL, *d_end_atom = NULL;
6142 const char *orig = p;
6150 bool a_must_be_last = false;
6151 bool ordered_set = false;
6152 bool disjunct_set = false;
6153 bool disj_matched = false;
6154 bool disj_starred = true;
6155 bool n_way_choice = false;
6156 bool n_way_matched = false;
6158 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6165 /* Scan one "atom" (S in the description above of %{}, possibly
6166 with '!', '.', '@', ',', or '*' modifiers). */
6168 a_is_suffix = false;
6169 a_is_starred = false;
6170 a_is_negated = false;
6171 a_is_spectype = false;
6175 p++, a_is_negated = true;
6179 p++, a_is_suffix = true;
6181 p++, a_is_spectype = true;
6184 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6185 || *p == ',' || *p == '.' || *p == '@')
6190 p++, a_is_starred = 1;
6196 /* Substitute the switch(es) indicated by the current atom. */
6198 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6199 || a_is_spectype || atom == end_atom)
6202 mark_matching_switches (atom, end_atom, a_is_starred);
6205 process_marked_switches ();
6209 /* Substitute some text if the current atom appears as a switch
6211 disjunct_set = true;
6215 if (atom == end_atom)
6217 if (!n_way_choice || disj_matched || *p == '|'
6218 || a_is_negated || a_is_suffix || a_is_spectype
6222 /* An empty term may appear as the last choice of an
6223 N-way choice set; it means "otherwise". */
6224 a_must_be_last = true;
6225 disj_matched = !n_way_matched;
6226 disj_starred = false;
6230 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6234 disj_starred = false;
6236 /* Don't bother testing this atom if we already have a
6238 if (!disj_matched && !n_way_matched)
6241 a_matched = input_suffix_matches (atom, end_atom);
6242 else if (a_is_spectype)
6243 a_matched = input_spec_matches (atom, end_atom);
6245 a_matched = switch_matches (atom, end_atom, a_is_starred);
6247 if (a_matched != a_is_negated)
6249 disj_matched = true;
6251 d_end_atom = end_atom;
6258 /* Found the body, that is, the text to substitute if the
6259 current disjunction matches. */
6260 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6261 disj_matched && !n_way_matched);
6265 /* If we have an N-way choice, reset state for the next
6269 n_way_choice = true;
6270 n_way_matched |= disj_matched;
6271 disj_matched = false;
6272 disj_starred = true;
6273 d_atom = d_end_atom = NULL;
6282 while (*p++ != '}');
6287 fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6292 /* Subroutine of handle_braces. Scan and process a brace substitution body
6293 (X in the description of %{} syntax). P points one past the colon;
6294 ATOM and END_ATOM bracket the first atom which was found to be true
6295 (present) in the current disjunction; STARRED indicates whether all
6296 the atoms in the current disjunction were starred (for syntax validation);
6297 MATCHED indicates whether the disjunction matched or not, and therefore
6298 whether or not the body is to be processed through do_spec_1 or just
6299 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6303 process_brace_body (const char *p, const char *atom, const char *end_atom,
6304 int starred, int matched)
6306 const char *body, *end_body;
6307 unsigned int nesting_level;
6308 bool have_subst = false;
6310 /* Locate the closing } or ;, honoring nested braces.
6311 Trim trailing whitespace. */
6320 if (!--nesting_level)
6323 else if (*p == ';' && nesting_level == 1)
6325 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6327 else if (*p == '\0')
6333 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6336 if (have_subst && !starred)
6341 /* Copy the substitution body to permanent storage and execute it.
6342 If have_subst is false, this is a simple matter of running the
6343 body through do_spec_1... */
6344 char *string = save_string (body, end_body - body);
6347 if (do_spec_1 (string, 0, NULL) < 0)
6352 /* ... but if have_subst is true, we have to process the
6353 body once for each matching switch, with %* set to the
6354 variant part of the switch. */
6355 unsigned int hard_match_len = end_atom - atom;
6358 for (i = 0; i < n_switches; i++)
6359 if (!strncmp (switches[i].part1, atom, hard_match_len)
6360 && check_live_switch (i, hard_match_len))
6362 if (do_spec_1 (string, 0,
6363 &switches[i].part1[hard_match_len]) < 0)
6365 /* Pass any arguments this switch has. */
6367 suffix_subst = NULL;
6375 fatal ("braced spec body '%s' is invalid", body);
6378 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6379 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6380 spec, or -1 if either exact match or %* is used.
6382 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6383 whose value does not begin with "no-" is obsoleted by the same value
6384 with the "no-", similarly for a switch with the "no-" prefix. */
6387 check_live_switch (int switchnum, int prefix_length)
6389 const char *name = switches[switchnum].part1;
6392 /* If we already processed this switch and determined if it was
6393 live or not, return our past determination. */
6394 if (switches[switchnum].live_cond != 0)
6395 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6396 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6397 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6400 /* In the common case of {<at-most-one-letter>*}, a negating
6401 switch would always match, so ignore that case. We will just
6402 send the conflicting switches to the compiler phase. */
6403 if (prefix_length >= 0 && prefix_length <= 1)
6406 /* Now search for duplicate in a manner that depends on the name. */
6410 for (i = switchnum + 1; i < n_switches; i++)
6411 if (switches[i].part1[0] == 'O')
6413 switches[switchnum].validated = 1;
6414 switches[switchnum].live_cond = SWITCH_FALSE;
6419 case 'W': case 'f': case 'm':
6420 if (! strncmp (name + 1, "no-", 3))
6422 /* We have Xno-YYY, search for XYYY. */
6423 for (i = switchnum + 1; i < n_switches; i++)
6424 if (switches[i].part1[0] == name[0]
6425 && ! strcmp (&switches[i].part1[1], &name[4]))
6427 switches[switchnum].validated = 1;
6428 switches[switchnum].live_cond = SWITCH_FALSE;
6434 /* We have XYYY, search for Xno-YYY. */
6435 for (i = switchnum + 1; i < n_switches; i++)
6436 if (switches[i].part1[0] == name[0]
6437 && switches[i].part1[1] == 'n'
6438 && switches[i].part1[2] == 'o'
6439 && switches[i].part1[3] == '-'
6440 && !strcmp (&switches[i].part1[4], &name[1]))
6442 switches[switchnum].validated = 1;
6443 switches[switchnum].live_cond = SWITCH_FALSE;
6450 /* Otherwise the switch is live. */
6451 switches[switchnum].live_cond |= SWITCH_LIVE;
6455 /* Pass a switch to the current accumulating command
6456 in the same form that we received it.
6457 SWITCHNUM identifies the switch; it is an index into
6458 the vector of switches gcc received, which is `switches'.
6459 This cannot fail since it never finishes a command line.
6461 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6464 give_switch (int switchnum, int omit_first_word)
6466 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6469 if (!omit_first_word)
6471 do_spec_1 ("-", 0, NULL);
6472 do_spec_1 (switches[switchnum].part1, 1, NULL);
6475 if (switches[switchnum].args != 0)
6478 for (p = switches[switchnum].args; *p; p++)
6480 const char *arg = *p;
6482 do_spec_1 (" ", 0, NULL);
6485 unsigned length = strlen (arg);
6488 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6489 if (arg[length] == '.')
6491 (CONST_CAST(char *, arg))[length] = 0;
6495 do_spec_1 (arg, 1, NULL);
6497 (CONST_CAST(char *, arg))[length] = '.';
6498 do_spec_1 (suffix_subst, 1, NULL);
6501 do_spec_1 (arg, 1, NULL);
6505 do_spec_1 (" ", 0, NULL);
6506 switches[switchnum].validated = 1;
6509 /* Search for a file named NAME trying various prefixes including the
6510 user's -B prefix and some standard ones.
6511 Return the absolute file name found. If nothing is found, return NAME. */
6514 find_file (const char *name)
6516 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6517 return newname ? newname : name;
6520 /* Determine whether a directory exists. If LINKER, return 0 for
6521 certain fixed names not needed by the linker. */
6524 is_directory (const char *path1, bool linker)
6531 /* Ensure the string ends with "/.". The resulting path will be a
6532 directory even if the given path is a symbolic link. */
6533 len1 = strlen (path1);
6534 path = (char *) alloca (3 + len1);
6535 memcpy (path, path1, len1);
6537 if (!IS_DIR_SEPARATOR (cp[-1]))
6538 *cp++ = DIR_SEPARATOR;
6542 /* Exclude directories that the linker is known to search. */
6544 && IS_DIR_SEPARATOR (path[0])
6546 && strncmp (path + 1, "lib", 3) == 0)
6548 && strncmp (path + 1, "usr", 3) == 0
6549 && IS_DIR_SEPARATOR (path[4])
6550 && strncmp (path + 5, "lib", 3) == 0)))
6553 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6556 /* Set up the various global variables to indicate that we're processing
6557 the input file named FILENAME. */
6560 set_input (const char *filename)
6564 input_filename = filename;
6565 input_filename_length = strlen (input_filename);
6566 input_basename = lbasename (input_filename);
6568 /* Find a suffix starting with the last period,
6569 and set basename_length to exclude that suffix. */
6570 basename_length = strlen (input_basename);
6571 suffixed_basename_length = basename_length;
6572 p = input_basename + basename_length;
6573 while (p != input_basename && *p != '.')
6575 if (*p == '.' && p != input_basename)
6577 basename_length = p - input_basename;
6578 input_suffix = p + 1;
6583 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6584 we will need to do a stat on the input_filename. The
6585 INPUT_STAT_SET signals that the stat is needed. */
6589 /* On fatal signals, delete all the temporary files. */
6592 fatal_error (int signum)
6594 signal (signum, SIG_DFL);
6595 delete_failure_queue ();
6596 delete_temp_files ();
6597 /* Get the same signal again, this time not handled,
6598 so its normal effect occurs. */
6599 kill (getpid (), signum);
6602 /* Compare the contents of the two files named CMPFILE[0] and
6603 CMPFILE[1]. Return zero if they're identical, nonzero
6607 compare_files (char *cmpfile[])
6610 FILE *temp[2] = { NULL, NULL };
6616 void *map[2] = { NULL, NULL };
6618 for (i = 0; i < 2; i++)
6622 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6624 error ("%s: could not determine length of compare-debug file %s",
6625 input_filename, cmpfile[i]);
6630 length[i] = st.st_size;
6633 if (!ret && length[0] != length[1])
6635 error ("%s: -fcompare-debug failure (length)", input_filename);
6640 for (i = 0; i < 2; i++)
6642 int fd = open (cmpfile[i], O_RDONLY);
6645 error ("%s: could not open compare-debug file %s",
6646 input_filename, cmpfile[i]);
6651 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6654 if (map[i] == (void *) MAP_FAILED)
6663 if (memcmp (map[0], map[1], length[0]) != 0)
6665 error ("%s: -fcompare-debug failure", input_filename);
6670 for (i = 0; i < 2; i++)
6672 munmap ((caddr_t) map[i], length[i]);
6681 for (i = 0; i < 2; i++)
6683 temp[i] = fopen (cmpfile[i], "r");
6686 error ("%s: could not open compare-debug file %s",
6687 input_filename, cmpfile[i]);
6693 if (!ret && temp[0] && temp[1])
6697 c0 = fgetc (temp[0]);
6698 c1 = fgetc (temp[1]);
6702 error ("%s: -fcompare-debug failure",
6712 for (i = 1; i >= 0; i--)
6721 extern int main (int, char **);
6724 main (int argc, char **argv)
6728 int linker_was_run = 0;
6729 int lang_n_infiles = 0;
6730 int num_linker_inputs = 0;
6731 char *explicit_link_files;
6734 struct user_specs *uptr;
6735 char **old_argv = argv;
6737 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6738 on ?: in file-scope variable initializations. */
6739 asm_debug = ASM_DEBUG_SPEC;
6741 p = argv[0] + strlen (argv[0]);
6742 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6746 xmalloc_set_program_name (programname);
6748 expandargv (&argc, &argv);
6750 /* Determine if any expansions were made. */
6751 if (argv != old_argv)
6752 at_file_supplied = true;
6754 prune_options (&argc, &argv);
6756 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6757 /* Perform host dependent initialization when needed. */
6758 GCC_DRIVER_HOST_INITIALIZATION;
6761 /* Unlock the stdio streams. */
6762 unlock_std_streams ();
6764 gcc_init_libintl ();
6766 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6767 signal (SIGINT, fatal_error);
6769 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6770 signal (SIGHUP, fatal_error);
6772 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6773 signal (SIGTERM, fatal_error);
6775 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6776 signal (SIGPIPE, fatal_error);
6779 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6780 receive the signal. A different setting is inheritable */
6781 signal (SIGCHLD, SIG_DFL);
6784 /* Allocate the argument vector. */
6787 obstack_init (&obstack);
6789 /* Build multilib_select, et. al from the separate lines that make up each
6790 multilib selection. */
6792 const char *const *q = multilib_raw;
6795 obstack_init (&multilib_obstack);
6796 while ((p = *q++) != (char *) 0)
6797 obstack_grow (&multilib_obstack, p, strlen (p));
6799 obstack_1grow (&multilib_obstack, 0);
6800 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6802 q = multilib_matches_raw;
6803 while ((p = *q++) != (char *) 0)
6804 obstack_grow (&multilib_obstack, p, strlen (p));
6806 obstack_1grow (&multilib_obstack, 0);
6807 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6809 q = multilib_exclusions_raw;
6810 while ((p = *q++) != (char *) 0)
6811 obstack_grow (&multilib_obstack, p, strlen (p));
6813 obstack_1grow (&multilib_obstack, 0);
6814 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6817 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6820 obstack_1grow (&multilib_obstack, ' ');
6821 obstack_grow (&multilib_obstack,
6822 multilib_defaults_raw[i],
6823 strlen (multilib_defaults_raw[i]));
6827 obstack_1grow (&multilib_obstack, 0);
6828 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6831 #ifdef INIT_ENVIRONMENT
6832 /* Set up any other necessary machine specific environment variables. */
6833 xputenv (INIT_ENVIRONMENT);
6836 /* Make a table of what switches there are (switches, n_switches).
6837 Make a table of specified input files (infiles, n_infiles).
6838 Decode switches that are handled locally. */
6840 process_command (argc, CONST_CAST2 (const char **, char **, argv));
6842 /* Initialize the vector of specs to just the default.
6843 This means one element containing 0s, as a terminator. */
6845 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6846 memcpy (compilers, default_compilers, sizeof default_compilers);
6847 n_compilers = n_default_compilers;
6849 /* Read specs from a file if there is one. */
6851 machine_suffix = concat (spec_machine, dir_separator_str,
6852 spec_version, dir_separator_str, NULL);
6853 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6855 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6856 /* Read the specs file unless it is a default one. */
6857 if (specs_file != 0 && strcmp (specs_file, "specs"))
6858 read_specs (specs_file, TRUE);
6862 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6863 for any override of as, ld and libraries. */
6864 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6865 + strlen (just_machine_suffix) + sizeof ("specs"));
6867 strcpy (specs_file, standard_exec_prefix);
6868 strcat (specs_file, just_machine_suffix);
6869 strcat (specs_file, "specs");
6870 if (access (specs_file, R_OK) == 0)
6871 read_specs (specs_file, TRUE);
6873 /* Process any configure-time defaults specified for the command line
6874 options, via OPTION_DEFAULT_SPECS. */
6875 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6876 do_option_spec (option_default_specs[i].name,
6877 option_default_specs[i].spec);
6879 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6880 of the command line. */
6882 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6883 do_self_spec (driver_self_specs[i]);
6887 enum save_temps save;
6889 if (!compare_debug_second)
6891 n_switches_debug_check[1] = n_switches;
6892 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6895 do_self_spec ("%:compare-debug-self-opt()");
6896 n_switches_debug_check[0] = n_switches;
6897 switches_debug_check[0] = switches;
6899 n_switches = n_switches_debug_check[1];
6900 switches = switches_debug_check[1];
6903 /* Avoid crash when computing %j in this early. */
6904 save = save_temps_flag;
6905 save_temps_flag = SAVE_TEMPS_NONE;
6907 compare_debug = -compare_debug;
6908 do_self_spec ("%:compare-debug-self-opt()");
6910 save_temps_flag = save;
6912 if (!compare_debug_second)
6914 n_switches_debug_check[1] = n_switches;
6915 switches_debug_check[1] = switches;
6916 compare_debug = -compare_debug;
6917 n_switches = n_switches_debug_check[0];
6918 switches = switches_debug_check[0];
6922 /* If not cross-compiling, look for executables in the standard
6924 if (*cross_compile == '0')
6926 if (*md_exec_prefix)
6928 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6929 PREFIX_PRIORITY_LAST, 0, 0);
6933 /* Process sysroot_suffix_spec. */
6934 if (*sysroot_suffix_spec != 0
6935 && do_spec_2 (sysroot_suffix_spec) == 0)
6937 if (argbuf_index > 1)
6938 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6939 else if (argbuf_index == 1)
6940 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6943 #ifdef HAVE_LD_SYSROOT
6944 /* Pass the --sysroot option to the linker, if it supports that. If
6945 there is a sysroot_suffix_spec, it has already been processed by
6946 this point, so target_system_root really is the system root we
6948 if (target_system_root)
6950 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6951 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6952 set_spec ("link", XOBFINISH (&obstack, const char *));
6956 /* Process sysroot_hdrs_suffix_spec. */
6957 if (*sysroot_hdrs_suffix_spec != 0
6958 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6960 if (argbuf_index > 1)
6961 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6962 else if (argbuf_index == 1)
6963 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6966 /* Look for startfiles in the standard places. */
6967 if (*startfile_prefix_spec != 0
6968 && do_spec_2 (startfile_prefix_spec) == 0
6969 && do_spec_1 (" ", 0, NULL) == 0)
6972 for (ndx = 0; ndx < argbuf_index; ndx++)
6973 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6974 PREFIX_PRIORITY_LAST, 0, 1);
6976 /* We should eventually get rid of all these and stick to
6977 startfile_prefix_spec exclusively. */
6978 else if (*cross_compile == '0' || target_system_root)
6980 if (*md_startfile_prefix)
6981 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6982 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6984 if (*md_startfile_prefix_1)
6985 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6986 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6988 /* If standard_startfile_prefix is relative, base it on
6989 standard_exec_prefix. This lets us move the installed tree
6990 as a unit. If GCC_EXEC_PREFIX is defined, base
6991 standard_startfile_prefix on that as well.
6993 If the prefix is relative, only search it for native compilers;
6994 otherwise we will search a directory containing host libraries. */
6995 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6996 add_sysrooted_prefix (&startfile_prefixes,
6997 standard_startfile_prefix, "BINUTILS",
6998 PREFIX_PRIORITY_LAST, 0, 1);
6999 else if (*cross_compile == '0')
7001 add_prefix (&startfile_prefixes,
7002 concat (gcc_exec_prefix
7003 ? gcc_exec_prefix : standard_exec_prefix,
7005 standard_startfile_prefix, NULL),
7006 NULL, PREFIX_PRIORITY_LAST, 0, 1);
7009 /* Sysrooted prefixes are relocated because target_system_root is
7010 also relocated by gcc_exec_prefix. */
7011 if (*standard_startfile_prefix_1)
7012 add_sysrooted_prefix (&startfile_prefixes,
7013 standard_startfile_prefix_1, "BINUTILS",
7014 PREFIX_PRIORITY_LAST, 0, 1);
7015 if (*standard_startfile_prefix_2)
7016 add_sysrooted_prefix (&startfile_prefixes,
7017 standard_startfile_prefix_2, "BINUTILS",
7018 PREFIX_PRIORITY_LAST, 0, 1);
7021 /* Process any user specified specs in the order given on the command
7023 for (uptr = user_specs_head; uptr; uptr = uptr->next)
7025 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7027 read_specs (filename ? filename : uptr->filename, FALSE);
7030 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7031 if (gcc_exec_prefix)
7032 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7033 spec_version, dir_separator_str, NULL);
7035 /* Now we have the specs.
7036 Set the `valid' bits for switches that match anything in any spec. */
7038 validate_all_switches ();
7040 /* Now that we have the switches and the specs, set
7041 the subdirectory based on the options. */
7042 set_multilib_dir ();
7044 /* Set up to remember the pathname of gcc and any options
7045 needed for collect. We use argv[0] instead of programname because
7046 we need the complete pathname. */
7047 obstack_init (&collect_obstack);
7048 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7049 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7050 xputenv (XOBFINISH (&collect_obstack, char *));
7052 /* Set up to remember the pathname of the lto wrapper. */
7054 lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7055 if (lto_wrapper_spec)
7057 obstack_init (&collect_obstack);
7058 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7059 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7060 obstack_grow (&collect_obstack, lto_wrapper_spec,
7061 strlen (lto_wrapper_spec) + 1);
7062 xputenv (XOBFINISH (&collect_obstack, char *));
7065 /* Warn about any switches that no pass was interested in. */
7067 for (i = 0; (int) i < n_switches; i++)
7068 if (! switches[i].validated)
7069 error ("unrecognized option '-%s'", switches[i].part1);
7071 /* Obey some of the options. */
7073 if (print_search_dirs)
7075 printf (_("install: %s%s\n"),
7076 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7077 gcc_exec_prefix ? "" : machine_suffix);
7078 printf (_("programs: %s\n"),
7079 build_search_list (&exec_prefixes, "", false, false));
7080 printf (_("libraries: %s\n"),
7081 build_search_list (&startfile_prefixes, "", false, true));
7085 if (print_file_name)
7087 printf ("%s\n", find_file (print_file_name));
7091 if (print_prog_name)
7093 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7094 printf ("%s\n", (newname ? newname : print_prog_name));
7098 if (print_multi_lib)
7100 print_multilib_info ();
7104 if (print_multi_directory)
7106 if (multilib_dir == NULL)
7109 printf ("%s\n", multilib_dir);
7115 if (target_system_root)
7117 if (target_sysroot_suffix)
7118 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7120 printf ("%s\n", target_system_root);
7125 if (print_multi_os_directory)
7127 if (multilib_os_dir == NULL)
7130 printf ("%s\n", multilib_os_dir);
7134 if (print_sysroot_headers_suffix)
7136 if (*sysroot_hdrs_suffix_spec)
7138 printf("%s\n", (target_sysroot_hdrs_suffix
7139 ? target_sysroot_hdrs_suffix
7144 /* The error status indicates that only one set of fixed
7145 headers should be built. */
7146 fatal ("not configured with sysroot headers suffix");
7149 if (print_help_list)
7155 printf (_("\nFor bug reporting instructions, please see:\n"));
7156 printf ("%s.\n", bug_report_url);
7161 /* We do not exit here. Instead we have created a fake input file
7162 called 'help-dummy' which needs to be compiled, and we pass this
7163 on the various sub-processes, along with the --help switch.
7164 Ensure their output appears after ours. */
7165 fputc ('\n', stdout);
7171 printf (_("%s %s%s\n"), programname, pkgversion_string,
7173 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7175 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7176 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7181 /* We do not exit here. We use the same mechanism of --help to print
7182 the version of the sub-processes. */
7183 fputc ('\n', stdout);
7192 notice ("Target: %s\n", spec_machine);
7193 notice ("Configured with: %s\n", configuration_arguments);
7195 #ifdef THREAD_MODEL_SPEC
7196 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7197 but there's no point in doing all this processing just to get
7198 thread_model back. */
7199 obstack_init (&obstack);
7200 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7201 obstack_1grow (&obstack, '\0');
7202 thrmod = XOBFINISH (&obstack, const char *);
7204 thrmod = thread_model;
7207 notice ("Thread model: %s\n", thrmod);
7209 /* compiler_version is truncated at the first space when initialized
7210 from version string, so truncate version_string at the first space
7211 before comparing. */
7212 for (n = 0; version_string[n]; n++)
7213 if (version_string[n] == ' ')
7216 if (! strncmp (version_string, compiler_version, n)
7217 && compiler_version[n] == 0)
7218 notice ("gcc version %s %s\n", version_string, pkgversion_string);
7220 notice ("gcc driver version %s %sexecuting gcc version %s\n",
7221 version_string, pkgversion_string, compiler_version);
7227 if (n_infiles == added_libraries)
7228 fatal ("no input files");
7230 /* Make a place to record the compiler output file names
7231 that correspond to the input files. */
7234 i += lang_specific_extra_outfiles;
7235 outfiles = XCNEWVEC (const char *, i);
7237 /* Record which files were specified explicitly as link input. */
7239 explicit_link_files = XCNEWVEC (char, n_infiles);
7242 combine_inputs = true;
7244 combine_inputs = false;
7246 for (i = 0; (int) i < n_infiles; i++)
7248 const char *name = infiles[i].name;
7249 struct compiler *compiler = lookup_compiler (name,
7251 infiles[i].language);
7253 if (compiler && !(compiler->combinable))
7254 combine_inputs = false;
7256 if (lang_n_infiles > 0 && compiler != input_file_compiler
7257 && infiles[i].language && infiles[i].language[0] != '*')
7258 infiles[i].incompiler = compiler;
7262 input_file_compiler = compiler;
7263 infiles[i].incompiler = compiler;
7267 /* Since there is no compiler for this input file, assume it is a
7269 explicit_link_files[i] = 1;
7270 infiles[i].incompiler = NULL;
7272 infiles[i].compiled = false;
7273 infiles[i].preprocessed = false;
7276 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7277 fatal ("cannot specify -o with -c, -S or -E with multiple files");
7279 if (combine_flag && save_temps_flag)
7281 bool save_combine_inputs = combine_inputs;
7282 /* Must do a separate pre-processing pass for C & Objective-C files, to
7283 obtain individual .i files. */
7285 combine_inputs = false;
7286 for (i = 0; (int) i < n_infiles; i++)
7288 int this_file_error = 0;
7290 input_file_number = i;
7291 set_input (infiles[i].name);
7292 if (infiles[i].incompiler
7293 && (infiles[i].incompiler)->needs_preprocessing)
7294 input_file_compiler = infiles[i].incompiler;
7298 if (input_file_compiler)
7300 if (input_file_compiler->spec[0] == '#')
7302 error ("%s: %s compiler not installed on this system",
7303 input_filename, &input_file_compiler->spec[1]);
7304 this_file_error = 1;
7308 value = do_spec (input_file_compiler->spec);
7309 infiles[i].preprocessed = true;
7310 if (!have_o_argbuf_index)
7311 fatal ("spec '%s' is invalid", input_file_compiler->spec);
7312 infiles[i].name = argbuf[have_o_argbuf_index];
7313 infiles[i].incompiler
7314 = lookup_compiler (infiles[i].name,
7315 strlen (infiles[i].name),
7316 infiles[i].language);
7319 this_file_error = 1;
7323 if (this_file_error)
7325 delete_failure_queue ();
7329 clear_failure_queue ();
7331 combine_inputs = save_combine_inputs;
7334 for (i = 0; (int) i < n_infiles; i++)
7336 int this_file_error = 0;
7338 /* Tell do_spec what to substitute for %i. */
7340 input_file_number = i;
7341 set_input (infiles[i].name);
7343 if (infiles[i].compiled)
7346 /* Use the same thing in %o, unless cp->spec says otherwise. */
7348 outfiles[i] = input_filename;
7350 /* Figure out which compiler from the file's suffix. */
7352 if (! combine_inputs)
7354 = lookup_compiler (infiles[i].name, input_filename_length,
7355 infiles[i].language);
7357 input_file_compiler = infiles[i].incompiler;
7359 if (input_file_compiler)
7361 /* Ok, we found an applicable compiler. Run its spec. */
7363 if (input_file_compiler->spec[0] == '#')
7365 error ("%s: %s compiler not installed on this system",
7366 input_filename, &input_file_compiler->spec[1]);
7367 this_file_error = 1;
7373 if (debug_check_temp_file[0])
7374 free (debug_check_temp_file[0]);
7375 debug_check_temp_file[0] = NULL;
7377 if (debug_check_temp_file[1])
7378 free (debug_check_temp_file[1]);
7379 debug_check_temp_file[1] = NULL;
7382 value = do_spec (input_file_compiler->spec);
7383 infiles[i].compiled = true;
7385 this_file_error = 1;
7386 else if (compare_debug && debug_check_temp_file[0])
7389 error ("Recompiling with -fcompare-debug");
7391 compare_debug = -compare_debug;
7392 n_switches = n_switches_debug_check[1];
7393 switches = switches_debug_check[1];
7395 value = do_spec (input_file_compiler->spec);
7397 compare_debug = -compare_debug;
7398 n_switches = n_switches_debug_check[0];
7399 switches = switches_debug_check[0];
7403 error ("during -fcompare-debug recompilation");
7404 this_file_error = 1;
7407 gcc_assert (debug_check_temp_file[1]
7408 && strcmp (debug_check_temp_file[0],
7409 debug_check_temp_file[1]));
7412 error ("Comparing final insns dumps");
7414 if (compare_files (debug_check_temp_file))
7415 this_file_error = 1;
7420 if (debug_check_temp_file[0])
7421 free (debug_check_temp_file[0]);
7422 debug_check_temp_file[0] = NULL;
7424 if (debug_check_temp_file[1])
7425 free (debug_check_temp_file[1]);
7426 debug_check_temp_file[1] = NULL;
7431 /* If this file's name does not contain a recognized suffix,
7432 record it as explicit linker input. */
7435 explicit_link_files[i] = 1;
7437 /* Clear the delete-on-failure queue, deleting the files in it
7438 if this compilation failed. */
7440 if (this_file_error)
7442 delete_failure_queue ();
7445 /* If this compilation succeeded, don't delete those files later. */
7446 clear_failure_queue ();
7449 /* Reset the input file name to the first compile/object file name, for use
7450 with %b in LINK_SPEC. We use the first input file that we can find
7451 a compiler to compile it instead of using infiles.language since for
7452 languages other than C we use aliases that we then lookup later. */
7457 for (i = 0; i < n_infiles ; i++)
7458 if (infiles[i].language && infiles[i].language[0] != '*')
7460 set_input (infiles[i].name);
7465 if (error_count == 0)
7467 /* Make sure INPUT_FILE_NUMBER points to first available open
7469 input_file_number = n_infiles;
7470 if (lang_specific_pre_link ())
7474 /* Determine if there are any linker input files. */
7475 num_linker_inputs = 0;
7476 for (i = 0; (int) i < n_infiles; i++)
7477 if (explicit_link_files[i] || outfiles[i] != NULL)
7478 num_linker_inputs++;
7480 /* Run ld to link all the compiler output files. */
7482 if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7484 int tmp = execution_count;
7485 const char *fuse_linker_plugin = "fuse-linker-plugin";
7487 /* We'll use ld if we can't find collect2. */
7488 if (! strcmp (linker_name_spec, "collect2"))
7490 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7492 linker_name_spec = "ld";
7495 if (switch_matches (fuse_linker_plugin,
7496 fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7498 linker_plugin_file_spec = find_a_file (&exec_prefixes,
7499 "liblto_plugin.so", R_OK,
7501 if (!linker_plugin_file_spec)
7502 fatal ("-fuse-linker-plugin, but liblto_plugin.so not found");
7504 lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7506 if (!lto_libgcc_spec)
7507 fatal ("could not find libgcc.a");
7509 lto_gcc_spec = argv[0];
7511 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7513 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7514 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7516 if (print_subprocess_help == 1)
7518 printf (_("\nLinker options\n==============\n\n"));
7519 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7520 " to the linker.\n\n"));
7523 value = do_spec (link_command_spec);
7526 linker_was_run = (tmp != execution_count);
7529 /* If options said don't run linker,
7530 complain about input files to be given to the linker. */
7532 if (! linker_was_run && error_count == 0)
7533 for (i = 0; (int) i < n_infiles; i++)
7534 if (explicit_link_files[i]
7535 && !(infiles[i].language && infiles[i].language[0] == '*'))
7536 error ("%s: linker input file unused because linking not done",
7539 /* Delete some or all of the temporary files we made. */
7542 delete_failure_queue ();
7543 delete_temp_files ();
7545 if (print_help_list)
7547 printf (("\nFor bug reporting instructions, please see:\n"));
7548 printf ("%s\n", bug_report_url);
7551 return (signal_count != 0 ? 2
7552 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7556 /* Find the proper compilation spec for the file name NAME,
7557 whose length is LENGTH. LANGUAGE is the specified language,
7558 or 0 if this file is to be passed to the linker. */
7560 static struct compiler *
7561 lookup_compiler (const char *name, size_t length, const char *language)
7563 struct compiler *cp;
7565 /* If this was specified by the user to be a linker input, indicate that. */
7566 if (language != 0 && language[0] == '*')
7569 /* Otherwise, look for the language, if one is spec'd. */
7572 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7573 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7576 error ("language %s not recognized", language);
7580 /* Look for a suffix. */
7581 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7583 if (/* The suffix `-' matches only the file name `-'. */
7584 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7585 || (strlen (cp->suffix) < length
7586 /* See if the suffix matches the end of NAME. */
7587 && !strcmp (cp->suffix,
7588 name + length - strlen (cp->suffix))
7593 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7594 /* Look again, but case-insensitively this time. */
7596 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7598 if (/* The suffix `-' matches only the file name `-'. */
7599 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7600 || (strlen (cp->suffix) < length
7601 /* See if the suffix matches the end of NAME. */
7602 && ((!strcmp (cp->suffix,
7603 name + length - strlen (cp->suffix))
7604 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7605 && !strcasecmp (cp->suffix,
7606 name + length - strlen (cp->suffix)))
7612 if (cp >= compilers)
7614 if (cp->spec[0] != '@')
7615 /* A non-alias entry: return it. */
7618 /* An alias entry maps a suffix to a language.
7619 Search for the language; pass 0 for NAME and LENGTH
7620 to avoid infinite recursion if language not found. */
7621 return lookup_compiler (NULL, 0, cp->spec + 1);
7627 save_string (const char *s, int len)
7629 char *result = XNEWVEC (char, len + 1);
7631 memcpy (result, s, len);
7637 pfatal_with_name (const char *name)
7639 perror_with_name (name);
7640 delete_temp_files ();
7645 perror_with_name (const char *name)
7647 error ("%s: %s", name, xstrerror (errno));
7650 /* Output an error message and exit. */
7653 fancy_abort (const char *file, int line, const char *func)
7655 fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7658 /* Output an error message and exit. */
7661 fatal_ice (const char *cmsgid, ...)
7665 va_start (ap, cmsgid);
7667 fprintf (stderr, "%s: ", programname);
7668 vfprintf (stderr, _(cmsgid), ap);
7670 fprintf (stderr, "\n");
7671 delete_temp_files ();
7672 exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7676 fatal (const char *cmsgid, ...)
7680 va_start (ap, cmsgid);
7682 fprintf (stderr, "%s: ", programname);
7683 vfprintf (stderr, _(cmsgid), ap);
7685 fprintf (stderr, "\n");
7686 delete_temp_files ();
7690 /* The argument is actually c-format, not gcc-internal-format,
7691 but because functions with identical names are used through
7692 the rest of the compiler with gcc-internal-format, we just
7693 need to hope all users of these functions use the common
7694 subset between c-format and gcc-internal-format. */
7697 error (const char *gmsgid, ...)
7701 va_start (ap, gmsgid);
7702 fprintf (stderr, "%s: ", programname);
7703 vfprintf (stderr, _(gmsgid), ap);
7706 fprintf (stderr, "\n");
7710 notice (const char *cmsgid, ...)
7714 va_start (ap, cmsgid);
7715 vfprintf (stderr, _(cmsgid), ap);
7720 validate_switches_from_spec (const char *spec)
7722 const char *p = spec;
7725 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7726 /* We have a switch spec. */
7727 p = validate_switches (p + 1);
7731 validate_all_switches (void)
7733 struct compiler *comp;
7734 struct spec_list *spec;
7736 for (comp = compilers; comp->spec; comp++)
7737 validate_switches_from_spec (comp->spec);
7739 /* Look through the linked list of specs read from the specs file. */
7740 for (spec = specs; spec; spec = spec->next)
7741 validate_switches_from_spec (*spec->ptr_spec);
7743 validate_switches_from_spec (link_command_spec);
7746 /* Look at the switch-name that comes after START
7747 and mark as valid all supplied switches that match it. */
7750 validate_switches (const char *start)
7752 const char *p = start;
7756 bool suffix = false;
7757 bool starred = false;
7759 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7768 if (*p == '.' || *p == ',')
7772 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7773 || *p == ',' || *p == '.' || *p == '@')
7778 starred = true, p++;
7784 /* Mark all matching switches as valid. */
7785 for (i = 0; i < n_switches; i++)
7786 if (!strncmp (switches[i].part1, atom, len)
7787 && (starred || switches[i].part1[len] == 0))
7788 switches[i].validated = 1;
7792 if (*p && (p[-1] == '|' || p[-1] == '&'))
7795 if (*p && p[-1] == ':')
7797 while (*p && *p != ';' && *p != '}')
7802 if (*p == '{' || *p == '<')
7803 p = validate_switches (p+1);
7804 else if (p[0] == 'W' && p[1] == '{')
7805 p = validate_switches (p+2);
7812 if (*p && p[-1] == ';')
7826 static struct mdswitchstr *mdswitches;
7827 static int n_mdswitches;
7829 /* Check whether a particular argument was used. The first time we
7830 canonicalize the switches to keep only the ones we care about. */
7833 used_arg (const char *p, int len)
7838 const char *replace;
7843 static struct mswitchstr *mswitches;
7844 static int n_mswitches;
7849 struct mswitchstr *matches;
7853 /* Break multilib_matches into the component strings of string
7854 and replacement string. */
7855 for (q = multilib_matches; *q != '\0'; q++)
7860 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7862 q = multilib_matches;
7871 fatal ("multilib spec '%s' is invalid", multilib_matches);
7875 matches[i].len = q - matches[i].str;
7877 matches[i].replace = ++q;
7878 while (*q != ';' && *q != '\0')
7881 goto invalid_matches;
7884 matches[i].rep_len = q - matches[i].replace;
7890 /* Now build a list of the replacement string for switches that we care
7891 about. Make sure we allocate at least one entry. This prevents
7892 xmalloc from calling fatal, and prevents us from re-executing this
7895 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7896 for (i = 0; i < n_switches; i++)
7897 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7899 int xlen = strlen (switches[i].part1);
7900 for (j = 0; j < cnt; j++)
7901 if (xlen == matches[j].len
7902 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7904 mswitches[n_mswitches].str = matches[j].replace;
7905 mswitches[n_mswitches].len = matches[j].rep_len;
7906 mswitches[n_mswitches].replace = (char *) 0;
7907 mswitches[n_mswitches].rep_len = 0;
7913 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7914 on the command line nor any options mutually incompatible with
7916 for (i = 0; i < n_mdswitches; i++)
7920 for (q = multilib_options; *q != '\0'; q++)
7926 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7927 || strchr (" /", q[mdswitches[i].len]) == NULL)
7929 while (*q != ' ' && *q != '/' && *q != '\0')
7936 if (*q != ' ' && *q != '\0')
7938 while (*r != ' ' && *r != '\0')
7941 while (*q != ' ' && *q != '/' && *q != '\0')
7944 if (used_arg (r, q - r))
7949 mswitches[n_mswitches].str = mdswitches[i].str;
7950 mswitches[n_mswitches].len = mdswitches[i].len;
7951 mswitches[n_mswitches].replace = (char *) 0;
7952 mswitches[n_mswitches].rep_len = 0;
7965 for (i = 0; i < n_mswitches; i++)
7966 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7973 default_arg (const char *p, int len)
7977 for (i = 0; i < n_mdswitches; i++)
7978 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7984 /* Work out the subdirectory to use based on the options. The format of
7985 multilib_select is a list of elements. Each element is a subdirectory
7986 name followed by a list of options followed by a semicolon. The format
7987 of multilib_exclusions is the same, but without the preceding
7988 directory. First gcc will check the exclusions, if none of the options
7989 beginning with an exclamation point are present, and all of the other
7990 options are present, then we will ignore this completely. Passing
7991 that, gcc will consider each multilib_select in turn using the same
7992 rules for matching the options. If a match is found, that subdirectory
7996 set_multilib_dir (void)
7999 unsigned int this_path_len;
8000 const char *this_path, *this_arg;
8001 const char *start, *end;
8003 int ok, ndfltok, first;
8006 start = multilib_defaults;
8007 while (*start == ' ' || *start == '\t')
8009 while (*start != '\0')
8012 while (*start != ' ' && *start != '\t' && *start != '\0')
8014 while (*start == ' ' || *start == '\t')
8022 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8023 for (start = multilib_defaults; *start != '\0'; start = end + 1)
8025 while (*start == ' ' || *start == '\t')
8031 for (end = start + 1;
8032 *end != ' ' && *end != '\t' && *end != '\0'; end++)
8035 obstack_grow (&multilib_obstack, start, end - start);
8036 obstack_1grow (&multilib_obstack, 0);
8037 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8038 mdswitches[i++].len = end - start;
8045 p = multilib_exclusions;
8048 /* Ignore newlines. */
8055 /* Check the arguments. */
8062 fatal ("multilib exclusions '%s' is invalid",
8063 multilib_exclusions);
8073 while (*p != ' ' && *p != ';')
8076 goto invalid_exclusions;
8080 if (*this_arg != '!')
8088 ok = used_arg (this_arg, p - this_arg);
8103 p = multilib_select;
8106 /* Ignore newlines. */
8113 /* Get the initial path. */
8120 fatal ("multilib select '%s' is invalid",
8125 this_path_len = p - this_path;
8127 /* Check the arguments. */
8134 goto invalid_select;
8143 while (*p != ' ' && *p != ';')
8146 goto invalid_select;
8150 if (*this_arg != '!')
8158 /* If this is a default argument, we can just ignore it.
8159 This is true even if this_arg begins with '!'. Beginning
8160 with '!' does not mean that this argument is necessarily
8161 inappropriate for this library: it merely means that
8162 there is a more specific library which uses this
8163 argument. If this argument is a default, we need not
8164 consider that more specific library. */
8165 ok = used_arg (this_arg, p - this_arg);
8172 if (default_arg (this_arg, p - this_arg))
8181 if (this_path_len != 1
8182 || this_path[0] != '.')
8184 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8187 strncpy (new_multilib_dir, this_path, this_path_len);
8188 new_multilib_dir[this_path_len] = '\0';
8189 q = strchr (new_multilib_dir, ':');
8192 multilib_dir = new_multilib_dir;
8199 const char *q = this_path, *end = this_path + this_path_len;
8201 while (q < end && *q != ':')
8205 char *new_multilib_os_dir = XNEWVEC (char, end - q);
8206 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8207 new_multilib_os_dir[end - q - 1] = '\0';
8208 multilib_os_dir = new_multilib_os_dir;
8216 if (multilib_dir == NULL && multilib_os_dir != NULL
8217 && strcmp (multilib_os_dir, ".") == 0)
8219 free (CONST_CAST (char *, multilib_os_dir));
8220 multilib_os_dir = NULL;
8222 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8223 multilib_os_dir = multilib_dir;
8226 /* Print out the multiple library subdirectory selection
8227 information. This prints out a series of lines. Each line looks
8228 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8229 required. Only the desired options are printed out, the negative
8230 matches. The options are print without a leading dash. There are
8231 no spaces to make it easy to use the information in the shell.
8232 Each subdirectory is printed only once. This assumes the ordering
8233 generated by the genmultilib script. Also, we leave out ones that match
8237 print_multilib_info (void)
8239 const char *p = multilib_select;
8240 const char *last_path = 0, *this_path;
8242 unsigned int last_path_len = 0;
8247 /* Ignore newlines. */
8254 /* Get the initial path. */
8261 fatal ("multilib select '%s' is invalid", multilib_select);
8267 /* When --disable-multilib was used but target defines
8268 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8269 to find multilib_os_dir, so skip them from output. */
8270 if (this_path[0] == '.' && this_path[1] == ':')
8273 /* Check for matches with the multilib_exclusions. We don't bother
8274 with the '!' in either list. If any of the exclusion rules match
8275 all of its options with the select rule, we skip it. */
8277 const char *e = multilib_exclusions;
8278 const char *this_arg;
8283 /* Ignore newlines. */
8290 /* Check the arguments. */
8299 fatal ("multilib exclusion '%s' is invalid",
8300 multilib_exclusions);
8311 while (*e != ' ' && *e != ';')
8314 goto invalid_exclusion;
8322 int len = e - this_arg;
8325 goto invalid_select;
8329 while (*q != ' ' && *q != ';')
8332 goto invalid_select;
8336 if (! strncmp (arg, this_arg,
8337 (len < q - arg) ? q - arg : len)
8338 || default_arg (this_arg, e - this_arg))
8368 /* If this is a duplicate, skip it. */
8369 skip = (last_path != 0
8370 && (unsigned int) (p - this_path) == last_path_len
8371 && ! strncmp (last_path, this_path, last_path_len));
8373 last_path = this_path;
8374 last_path_len = p - this_path;
8377 /* If this directory requires any default arguments, we can skip
8378 it. We will already have printed a directory identical to
8379 this one which does not require that default argument. */
8390 goto invalid_select;
8397 while (*q != ' ' && *q != ';')
8400 goto invalid_select;
8405 && default_arg (arg, q - arg))
8420 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8431 goto invalid_select;
8439 use_arg = *p != '!';
8444 while (*p != ' ' && *p != ';')
8447 goto invalid_select;
8459 /* If there are extra options, print them now. */
8460 if (multilib_extra && *multilib_extra)
8462 int print_at = TRUE;
8465 for (q = multilib_extra; *q != '\0'; q++)
8486 /* getenv built-in spec function.
8488 Returns the value of the environment variable given by its first
8489 argument, concatenated with the second argument. If the
8490 environment variable is not defined, a fatal error is issued. */
8493 getenv_spec_function (int argc, const char **argv)
8503 value = getenv (argv[0]);
8505 fatal ("environment variable \"%s\" not defined", argv[0]);
8507 /* We have to escape every character of the environment variable so
8508 they are not interpreted as active spec characters. A
8509 particularly painful case is when we are reading a variable
8510 holding a windows path complete with \ separators. */
8511 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8512 result = XNEWVAR (char, len);
8513 for (ptr = result; *value; ptr += 2)
8519 strcpy (ptr, argv[1]);
8524 /* if-exists built-in spec function.
8526 Checks to see if the file specified by the absolute pathname in
8527 ARGS exists. Returns that pathname if found.
8529 The usual use for this function is to check for a library file
8530 (whose name has been expanded with %s). */
8533 if_exists_spec_function (int argc, const char **argv)
8535 /* Must have only one argument. */
8536 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8542 /* if-exists-else built-in spec function.
8544 This is like if-exists, but takes an additional argument which
8545 is returned if the first argument does not exist. */
8548 if_exists_else_spec_function (int argc, const char **argv)
8550 /* Must have exactly two arguments. */
8554 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8560 /* replace-outfile built-in spec function.
8562 This looks for the first argument in the outfiles array's name and
8563 replaces it with the second argument. */
8566 replace_outfile_spec_function (int argc, const char **argv)
8569 /* Must have exactly two arguments. */
8573 for (i = 0; i < n_infiles; i++)
8575 if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8576 outfiles[i] = xstrdup (argv[1]);
8581 /* Given two version numbers, compares the two numbers.
8582 A version number must match the regular expression
8583 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8586 compare_version_strings (const char *v1, const char *v2)
8591 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8592 REG_EXTENDED | REG_NOSUB) != 0)
8594 rresult = regexec (&r, v1, 0, NULL, 0);
8595 if (rresult == REG_NOMATCH)
8596 fatal ("invalid version number `%s'", v1);
8597 else if (rresult != 0)
8599 rresult = regexec (&r, v2, 0, NULL, 0);
8600 if (rresult == REG_NOMATCH)
8601 fatal ("invalid version number `%s'", v2);
8602 else if (rresult != 0)
8605 return strverscmp (v1, v2);
8609 /* version_compare built-in spec function.
8611 This takes an argument of the following form:
8613 <comparison-op> <arg1> [<arg2>] <switch> <result>
8615 and produces "result" if the comparison evaluates to true,
8616 and nothing if it doesn't.
8618 The supported <comparison-op> values are:
8620 >= true if switch is a later (or same) version than arg1
8622 < true if switch is an earlier version than arg1
8624 >< true if switch is arg1 or later, and earlier than arg2
8625 <> true if switch is earlier than arg1 or is arg2 or later
8627 If the switch is not present, the condition is false unless
8628 the first character of the <comparison-op> is '!'.
8631 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8632 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8635 version_compare_spec_function (int argc, const char **argv)
8639 const char *switch_value = NULL;
8644 fatal ("too few arguments to %%:version-compare");
8645 if (argv[0][0] == '\0')
8647 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8649 if (argc != nargs + 3)
8650 fatal ("too many arguments to %%:version-compare");
8652 switch_len = strlen (argv[nargs + 1]);
8653 for (i = 0; i < n_switches; i++)
8654 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8655 && check_live_switch (i, switch_len))
8656 switch_value = switches[i].part1 + switch_len;
8658 if (switch_value == NULL)
8662 comp1 = compare_version_strings (switch_value, argv[1]);
8664 comp2 = compare_version_strings (switch_value, argv[2]);
8666 comp2 = -1; /* This value unused. */
8669 switch (argv[0][0] << 8 | argv[0][1])
8671 case '>' << 8 | '=':
8672 result = comp1 >= 0;
8674 case '!' << 8 | '<':
8675 result = comp1 >= 0 || switch_value == NULL;
8680 case '!' << 8 | '>':
8681 result = comp1 < 0 || switch_value == NULL;
8683 case '>' << 8 | '<':
8684 result = comp1 >= 0 && comp2 < 0;
8686 case '<' << 8 | '>':
8687 result = comp1 < 0 || comp2 >= 0;
8691 fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8696 return argv[nargs + 2];
8699 /* %:include builtin spec function. This differs from %include in that it
8700 can be nested inside a spec, and thus be conditionalized. It takes
8701 one argument, the filename, and looks for it in the startfile path.
8702 The result is always NULL, i.e. an empty expansion. */
8705 include_spec_function (int argc, const char **argv)
8712 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8713 read_specs (file ? file : argv[0], FALSE);
8718 /* %:find-file spec function. This function replace its argument by
8719 the file found thru find_file, that is the -print-file-name gcc
8722 find_file_spec_function (int argc, const char**argv)
8729 file = find_file (argv[0]);
8734 /* %:print-asm-header spec function. Print a banner to say that the
8735 following output is from the assembler. */
8738 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8739 const char **argv ATTRIBUTE_UNUSED)
8741 printf (_("Assembler options\n=================\n\n"));
8742 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8747 /* Compute a timestamp to initialize flag_random_seed. */
8750 get_local_tick (void)
8754 /* Get some more or less random data. */
8755 #ifdef HAVE_GETTIMEOFDAY
8759 gettimeofday (&tv, NULL);
8760 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8764 time_t now = time (NULL);
8766 if (now != (time_t)-1)
8767 ret = (unsigned) now;
8774 /* %:compare-debug-dump-opt spec function. Save the last argument,
8775 expected to be the last -fdump-final-insns option, or generate a
8779 compare_debug_dump_opt_spec_function (int arg,
8780 const char **argv ATTRIBUTE_UNUSED)
8785 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8788 fatal ("too many arguments to %%:compare-debug-dump-opt");
8790 do_spec_2 ("%{fdump-final-insns=*:%*}");
8791 do_spec_1 (" ", 0, NULL);
8793 if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8798 name = xstrdup (argv[argbuf_index - 1]);
8803 const char *ext = NULL;
8805 if (argbuf_index > 0)
8807 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8810 else if (!compare_debug)
8813 do_spec_2 ("%g.gkd");
8815 do_spec_1 (" ", 0, NULL);
8817 gcc_assert (argbuf_index > 0);
8819 name = concat (argbuf[argbuf_index - 1], ext, NULL);
8821 ret = concat ("-fdump-final-insns=", name, NULL);
8824 which = compare_debug < 0;
8825 debug_check_temp_file[which] = name;
8829 unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8831 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8835 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8844 static const char *debug_auxbase_opt;
8846 /* %:compare-debug-self-opt spec function. Expands to the options
8847 that are to be passed in the second compilation of
8851 compare_debug_self_opt_spec_function (int arg,
8852 const char **argv ATTRIBUTE_UNUSED)
8855 fatal ("too many arguments to %%:compare-debug-self-opt");
8857 if (compare_debug >= 0)
8860 do_spec_2 ("%{c|S:%{o*:%*}}");
8861 do_spec_1 (" ", 0, NULL);
8863 if (argbuf_index > 0)
8864 debug_auxbase_opt = concat ("-auxbase-strip ",
8865 argbuf[argbuf_index - 1],
8868 debug_auxbase_opt = NULL;
8871 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8872 %<fdump-final-insns=* -w -S -o %j \
8873 %{!fcompare-debug-second:-fcompare-debug-second} \
8874 ", compare_debug_opt, NULL);
8877 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8878 options that are to be passed in the second compilation of
8879 compare-debug. It expects, as an argument, the basename of the
8880 current input file name, with the .gk suffix appended to it. */
8883 compare_debug_auxbase_opt_spec_function (int arg,
8890 fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8893 fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8895 if (compare_debug >= 0)
8898 len = strlen (argv[0]);
8899 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8900 fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8902 if (debug_auxbase_opt)
8903 return debug_auxbase_opt;
8905 #define OPT "-auxbase "
8908 name = (char*) xmalloc (sizeof (OPT) + len);
8909 memcpy (name, OPT, sizeof (OPT) - 1);
8910 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8911 name[sizeof (OPT) - 1 + len] = '\0';