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)
2087 /* If the temporary file we should delete is specified as
2088 part of a joined argument extract the filename. */
2090 && (p = strrchr (arg, '=')))
2092 record_temp_file (arg, delete_always, delete_failure);
2096 /* Load specs from a file name named FILENAME, replacing occurrences of
2097 various different types of line-endings, \r\n, \n\r and just \r, with
2101 load_specs (const char *filename)
2105 struct stat statbuf;
2112 notice ("Reading specs from %s\n", filename);
2114 /* Open and stat the file. */
2115 desc = open (filename, O_RDONLY, 0);
2117 pfatal_with_name (filename);
2118 if (stat (filename, &statbuf) < 0)
2119 pfatal_with_name (filename);
2121 /* Read contents of file into BUFFER. */
2122 buffer = XNEWVEC (char, statbuf.st_size + 1);
2123 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2125 pfatal_with_name (filename);
2126 buffer[readlen] = 0;
2129 specs = XNEWVEC (char, readlen + 1);
2131 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2137 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2139 else if (*(buffer_p + 1) == '\n') /* \r\n */
2153 /* Read compilation specs from a file named FILENAME,
2154 replacing the default ones.
2156 A suffix which starts with `*' is a definition for
2157 one of the machine-specific sub-specs. The "suffix" should be
2158 *asm, *cc1, *cpp, *link, *startfile, etc.
2159 The corresponding spec is stored in asm_spec, etc.,
2160 rather than in the `compilers' vector.
2162 Anything invalid in the file is a fatal error. */
2165 read_specs (const char *filename, int main_p)
2170 buffer = load_specs (filename);
2172 /* Scan BUFFER for specs, putting them in the vector. */
2178 char *in, *out, *p1, *p2, *p3;
2180 /* Advance P in BUFFER to the next nonblank nocomment line. */
2181 p = skip_whitespace (p);
2185 /* Is this a special command that starts with '%'? */
2186 /* Don't allow this for the main specs file, since it would
2187 encourage people to overwrite it. */
2188 if (*p == '%' && !main_p)
2191 while (*p && *p != '\n')
2197 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2198 && (p1[sizeof "%include" - 1] == ' '
2199 || p1[sizeof "%include" - 1] == '\t'))
2203 p1 += sizeof ("%include");
2204 while (*p1 == ' ' || *p1 == '\t')
2207 if (*p1++ != '<' || p[-2] != '>')
2208 fatal ("specs %%include syntax malformed after %ld characters",
2209 (long) (p1 - buffer + 1));
2212 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2213 read_specs (new_filename ? new_filename : p1, FALSE);
2216 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2217 && (p1[sizeof "%include_noerr" - 1] == ' '
2218 || p1[sizeof "%include_noerr" - 1] == '\t'))
2222 p1 += sizeof "%include_noerr";
2223 while (*p1 == ' ' || *p1 == '\t')
2226 if (*p1++ != '<' || p[-2] != '>')
2227 fatal ("specs %%include syntax malformed after %ld characters",
2228 (long) (p1 - buffer + 1));
2231 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2233 read_specs (new_filename, FALSE);
2234 else if (verbose_flag)
2235 notice ("could not find specs file %s\n", p1);
2238 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2239 && (p1[sizeof "%rename" - 1] == ' '
2240 || p1[sizeof "%rename" - 1] == '\t'))
2243 struct spec_list *sl;
2244 struct spec_list *newsl;
2246 /* Get original name. */
2247 p1 += sizeof "%rename";
2248 while (*p1 == ' ' || *p1 == '\t')
2251 if (! ISALPHA ((unsigned char) *p1))
2252 fatal ("specs %%rename syntax malformed after %ld characters",
2253 (long) (p1 - buffer));
2256 while (*p2 && !ISSPACE ((unsigned char) *p2))
2259 if (*p2 != ' ' && *p2 != '\t')
2260 fatal ("specs %%rename syntax malformed after %ld characters",
2261 (long) (p2 - buffer));
2265 while (*p2 == ' ' || *p2 == '\t')
2268 if (! ISALPHA ((unsigned char) *p2))
2269 fatal ("specs %%rename syntax malformed after %ld characters",
2270 (long) (p2 - buffer));
2272 /* Get new spec name. */
2274 while (*p3 && !ISSPACE ((unsigned char) *p3))
2278 fatal ("specs %%rename syntax malformed after %ld characters",
2279 (long) (p3 - buffer));
2282 for (sl = specs; sl; sl = sl->next)
2283 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2287 fatal ("specs %s spec was not found to be renamed", p1);
2289 if (strcmp (p1, p2) == 0)
2292 for (newsl = specs; newsl; newsl = newsl->next)
2293 if (strcmp (newsl->name, p2) == 0)
2294 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2299 notice ("rename spec %s to %s\n", p1, p2);
2301 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2305 set_spec (p2, *(sl->ptr_spec));
2307 free (CONST_CAST (char *, *(sl->ptr_spec)));
2309 *(sl->ptr_spec) = "";
2314 fatal ("specs unknown %% command after %ld characters",
2315 (long) (p1 - buffer));
2318 /* Find the colon that should end the suffix. */
2320 while (*p1 && *p1 != ':' && *p1 != '\n')
2323 /* The colon shouldn't be missing. */
2325 fatal ("specs file malformed after %ld characters",
2326 (long) (p1 - buffer));
2328 /* Skip back over trailing whitespace. */
2330 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2333 /* Copy the suffix to a string. */
2334 suffix = save_string (p, p2 - p);
2335 /* Find the next line. */
2336 p = skip_whitespace (p1 + 1);
2338 fatal ("specs file malformed after %ld characters",
2339 (long) (p - buffer));
2342 /* Find next blank line or end of string. */
2343 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2346 /* Specs end at the blank line and do not include the newline. */
2347 spec = save_string (p, p1 - p);
2350 /* Delete backslash-newline sequences from the spec. */
2355 if (in[0] == '\\' && in[1] == '\n')
2357 else if (in[0] == '#')
2358 while (*in && *in != '\n')
2366 if (suffix[0] == '*')
2368 if (! strcmp (suffix, "*link_command"))
2369 link_command_spec = spec;
2371 set_spec (suffix + 1, spec);
2375 /* Add this pair to the vector. */
2377 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2379 compilers[n_compilers].suffix = suffix;
2380 compilers[n_compilers].spec = spec;
2382 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2386 link_command_spec = spec;
2389 if (link_command_spec == 0)
2390 fatal ("spec file has no spec for linking");
2393 /* Record the names of temporary files we tell compilers to write,
2394 and delete them at the end of the run. */
2396 /* This is the common prefix we use to make temp file names.
2397 It is chosen once for each run of this program.
2398 It is substituted into a spec by %g or %j.
2399 Thus, all temp file names contain this prefix.
2400 In practice, all temp file names start with this prefix.
2402 This prefix comes from the envvar TMPDIR if it is defined;
2403 otherwise, from the P_tmpdir macro if that is defined;
2404 otherwise, in /usr/tmp or /tmp;
2405 or finally the current directory if all else fails. */
2407 static const char *temp_filename;
2409 /* Length of the prefix. */
2411 static int temp_filename_length;
2413 /* Define the list of temporary files to delete. */
2418 struct temp_file *next;
2421 /* Queue of files to delete on success or failure of compilation. */
2422 static struct temp_file *always_delete_queue;
2423 /* Queue of files to delete on failure of compilation. */
2424 static struct temp_file *failure_delete_queue;
2426 /* Record FILENAME as a file to be deleted automatically.
2427 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2428 otherwise delete it in any case.
2429 FAIL_DELETE nonzero means delete it if a compilation step fails;
2430 otherwise delete it in any case. */
2433 record_temp_file (const char *filename, int always_delete, int fail_delete)
2435 char *const name = xstrdup (filename);
2439 struct temp_file *temp;
2440 for (temp = always_delete_queue; temp; temp = temp->next)
2441 if (! strcmp (name, temp->name))
2444 temp = XNEW (struct temp_file);
2445 temp->next = always_delete_queue;
2447 always_delete_queue = temp;
2454 struct temp_file *temp;
2455 for (temp = failure_delete_queue; temp; temp = temp->next)
2456 if (! strcmp (name, temp->name))
2459 temp = XNEW (struct temp_file);
2460 temp->next = failure_delete_queue;
2462 failure_delete_queue = temp;
2468 /* Delete all the temporary files whose names we previously recorded. */
2470 #ifndef DELETE_IF_ORDINARY
2471 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2474 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2475 if (unlink (NAME) < 0) \
2477 perror_with_name (NAME); \
2482 delete_if_ordinary (const char *name)
2488 printf ("Delete %s? (y or n) ", name);
2492 while ((c = getchar ()) != '\n' && c != EOF)
2495 if (i == 'y' || i == 'Y')
2497 DELETE_IF_ORDINARY (name, st, verbose_flag);
2501 delete_temp_files (void)
2503 struct temp_file *temp;
2505 for (temp = always_delete_queue; temp; temp = temp->next)
2506 delete_if_ordinary (temp->name);
2507 always_delete_queue = 0;
2510 /* Delete all the files to be deleted on error. */
2513 delete_failure_queue (void)
2515 struct temp_file *temp;
2517 for (temp = failure_delete_queue; temp; temp = temp->next)
2518 delete_if_ordinary (temp->name);
2522 clear_failure_queue (void)
2524 failure_delete_queue = 0;
2527 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2529 If DO_MULTI is true iterate over the paths twice, first with multilib
2530 suffix then without, otherwise iterate over the paths once without
2531 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2532 to avoid visiting the same path twice, but we could do better. For
2533 instance, /usr/lib/../lib is considered different from /usr/lib.
2534 At least EXTRA_SPACE chars past the end of the path passed to
2535 CALLBACK are available for use by the callback.
2536 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2538 Returns the value returned by CALLBACK. */
2541 for_each_path (const struct path_prefix *paths,
2544 void *(*callback) (char *, void *),
2545 void *callback_info)
2547 struct prefix_list *pl;
2548 const char *multi_dir = NULL;
2549 const char *multi_os_dir = NULL;
2550 const char *multi_suffix;
2551 const char *just_multi_suffix;
2554 bool skip_multi_dir = false;
2555 bool skip_multi_os_dir = false;
2557 multi_suffix = machine_suffix;
2558 just_multi_suffix = just_machine_suffix;
2559 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2561 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2562 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2563 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2565 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2566 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2570 size_t multi_dir_len = 0;
2571 size_t multi_os_dir_len = 0;
2573 size_t just_suffix_len;
2577 multi_dir_len = strlen (multi_dir);
2579 multi_os_dir_len = strlen (multi_os_dir);
2580 suffix_len = strlen (multi_suffix);
2581 just_suffix_len = strlen (just_multi_suffix);
2585 len = paths->max_len + extra_space + 1;
2586 if (suffix_len > multi_os_dir_len)
2589 len += multi_os_dir_len;
2590 path = XNEWVEC (char, len);
2593 for (pl = paths->plist; pl != 0; pl = pl->next)
2595 len = strlen (pl->prefix);
2596 memcpy (path, pl->prefix, len);
2598 /* Look first in MACHINE/VERSION subdirectory. */
2599 if (!skip_multi_dir)
2601 memcpy (path + len, multi_suffix, suffix_len + 1);
2602 ret = callback (path, callback_info);
2607 /* Some paths are tried with just the machine (ie. target)
2608 subdir. This is used for finding as, ld, etc. */
2610 && pl->require_machine_suffix == 2)
2612 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2613 ret = callback (path, callback_info);
2618 /* Now try the base path. */
2619 if (!pl->require_machine_suffix
2620 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2622 const char *this_multi;
2623 size_t this_multi_len;
2625 if (pl->os_multilib)
2627 this_multi = multi_os_dir;
2628 this_multi_len = multi_os_dir_len;
2632 this_multi = multi_dir;
2633 this_multi_len = multi_dir_len;
2637 memcpy (path + len, this_multi, this_multi_len + 1);
2641 ret = callback (path, callback_info);
2649 if (multi_dir == NULL && multi_os_dir == NULL)
2652 /* Run through the paths again, this time without multilibs.
2653 Don't repeat any we have already seen. */
2656 free (CONST_CAST (char *, multi_dir));
2658 free (CONST_CAST (char *, multi_suffix));
2659 multi_suffix = machine_suffix;
2660 free (CONST_CAST (char *, just_multi_suffix));
2661 just_multi_suffix = just_machine_suffix;
2664 skip_multi_dir = true;
2667 free (CONST_CAST (char *, multi_os_dir));
2668 multi_os_dir = NULL;
2671 skip_multi_os_dir = true;
2676 free (CONST_CAST (char *, multi_dir));
2677 free (CONST_CAST (char *, multi_suffix));
2678 free (CONST_CAST (char *, just_multi_suffix));
2681 free (CONST_CAST (char *, multi_os_dir));
2687 /* Callback for build_search_list. Adds path to obstack being built. */
2689 struct add_to_obstack_info {
2696 add_to_obstack (char *path, void *data)
2698 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2700 if (info->check_dir && !is_directory (path, false))
2703 if (!info->first_time)
2704 obstack_1grow (info->ob, PATH_SEPARATOR);
2706 obstack_grow (info->ob, path, strlen (path));
2708 info->first_time = false;
2712 /* Add or change the value of an environment variable, outputting the
2713 change to standard error if in verbose mode. */
2715 xputenv (const char *string)
2718 notice ("%s\n", string);
2719 putenv (CONST_CAST (char *, string));
2722 /* Build a list of search directories from PATHS.
2723 PREFIX is a string to prepend to the list.
2724 If CHECK_DIR_P is true we ensure the directory exists.
2725 If DO_MULTI is true, multilib paths are output first, then
2727 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2728 It is also used by the --print-search-dirs flag. */
2731 build_search_list (const struct path_prefix *paths, const char *prefix,
2732 bool check_dir, bool do_multi)
2734 struct add_to_obstack_info info;
2736 info.ob = &collect_obstack;
2737 info.check_dir = check_dir;
2738 info.first_time = true;
2740 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2741 obstack_1grow (&collect_obstack, '=');
2743 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2745 obstack_1grow (&collect_obstack, '\0');
2746 return XOBFINISH (&collect_obstack, char *);
2749 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2753 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2756 xputenv (build_search_list (paths, env_var, true, do_multi));
2759 /* Check whether NAME can be accessed in MODE. This is like access,
2760 except that it never considers directories to be executable. */
2763 access_check (const char *name, int mode)
2769 if (stat (name, &st) < 0
2770 || S_ISDIR (st.st_mode))
2774 return access (name, mode);
2777 /* Callback for find_a_file. Appends the file name to the directory
2778 path. If the resulting file exists in the right mode, return the
2779 full pathname to the file. */
2781 struct file_at_path_info {
2790 file_at_path (char *path, void *data)
2792 struct file_at_path_info *info = (struct file_at_path_info *) data;
2793 size_t len = strlen (path);
2795 memcpy (path + len, info->name, info->name_len);
2796 len += info->name_len;
2798 /* Some systems have a suffix for executable files.
2799 So try appending that first. */
2800 if (info->suffix_len)
2802 memcpy (path + len, info->suffix, info->suffix_len + 1);
2803 if (access_check (path, info->mode) == 0)
2808 if (access_check (path, info->mode) == 0)
2814 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2815 access to check permissions. If DO_MULTI is true, search multilib
2816 paths then non-multilib paths, otherwise do not search multilib paths.
2817 Return 0 if not found, otherwise return its name, allocated with malloc. */
2820 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2823 struct file_at_path_info info;
2825 #ifdef DEFAULT_ASSEMBLER
2826 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2827 return xstrdup (DEFAULT_ASSEMBLER);
2830 #ifdef DEFAULT_LINKER
2831 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2832 return xstrdup (DEFAULT_LINKER);
2835 /* Determine the filename to execute (special case for absolute paths). */
2837 if (IS_ABSOLUTE_PATH (name))
2839 if (access (name, mode) == 0)
2840 return xstrdup (name);
2846 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2847 info.name_len = strlen (info.name);
2848 info.suffix_len = strlen (info.suffix);
2851 return (char*) for_each_path (pprefix, do_multi,
2852 info.name_len + info.suffix_len,
2853 file_at_path, &info);
2856 /* Ranking of prefixes in the sort list. -B prefixes are put before
2859 enum path_prefix_priority
2861 PREFIX_PRIORITY_B_OPT,
2862 PREFIX_PRIORITY_LAST
2865 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2866 order according to PRIORITY. Within each PRIORITY, new entries are
2869 If WARN is nonzero, we will warn if no file is found
2870 through this prefix. WARN should point to an int
2871 which will be set to 1 if this entry is used.
2873 COMPONENT is the value to be passed to update_path.
2875 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2876 the complete value of machine_suffix.
2877 2 means try both machine_suffix and just_machine_suffix. */
2880 add_prefix (struct path_prefix *pprefix, const char *prefix,
2881 const char *component, /* enum prefix_priority */ int priority,
2882 int require_machine_suffix, int os_multilib)
2884 struct prefix_list *pl, **prev;
2887 for (prev = &pprefix->plist;
2888 (*prev) != NULL && (*prev)->priority <= priority;
2889 prev = &(*prev)->next)
2892 /* Keep track of the longest prefix. */
2894 prefix = update_path (prefix, component);
2895 len = strlen (prefix);
2896 if (len > pprefix->max_len)
2897 pprefix->max_len = len;
2899 pl = XNEW (struct prefix_list);
2900 pl->prefix = prefix;
2901 pl->require_machine_suffix = require_machine_suffix;
2902 pl->priority = priority;
2903 pl->os_multilib = os_multilib;
2905 /* Insert after PREV. */
2910 /* Same as add_prefix, but prepending target_system_root to prefix. */
2911 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2913 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2914 const char *component,
2915 /* enum prefix_priority */ int priority,
2916 int require_machine_suffix, int os_multilib)
2918 if (!IS_ABSOLUTE_PATH (prefix))
2919 fatal ("system path '%s' is not absolute", prefix);
2921 if (target_system_root)
2923 if (target_sysroot_suffix)
2924 prefix = concat (target_sysroot_suffix, prefix, NULL);
2925 prefix = concat (target_system_root, prefix, NULL);
2927 /* We have to override this because GCC's notion of sysroot
2928 moves along with GCC. */
2932 add_prefix (pprefix, prefix, component, priority,
2933 require_machine_suffix, os_multilib);
2936 /* Execute the command specified by the arguments on the current line of spec.
2937 When using pipes, this includes several piped-together commands
2938 with `|' between them.
2940 Return 0 if successful, -1 if failed. */
2946 int n_commands; /* # of command. */
2948 struct pex_obj *pex;
2951 const char *prog; /* program name. */
2952 const char **argv; /* vector of args. */
2955 struct command *commands; /* each command buffer with above info. */
2957 gcc_assert (!processing_spec_function);
2961 string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2962 argbuf[0] = (string) ? string : argbuf[0];
2963 insert_wrapper (wrapper_string);
2966 /* Count # of piped commands. */
2967 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2968 if (strcmp (argbuf[i], "|") == 0)
2971 /* Get storage for each command. */
2972 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2974 /* Split argbuf into its separate piped processes,
2975 and record info about each one.
2976 Also search for the programs that are to be run. */
2978 commands[0].prog = argbuf[0]; /* first command. */
2979 commands[0].argv = &argbuf[0];
2981 if (!wrapper_string)
2983 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2984 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2987 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2988 if (strcmp (argbuf[i], "|") == 0)
2989 { /* each command. */
2990 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2991 fatal ("-pipe not supported");
2993 argbuf[i] = 0; /* termination of command args. */
2994 commands[n_commands].prog = argbuf[i + 1];
2995 commands[n_commands].argv = &argbuf[i + 1];
2996 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2999 commands[n_commands].argv[0] = string;
3003 argbuf[argbuf_index] = 0;
3005 /* If -v, print what we are about to do, and maybe query. */
3009 /* For help listings, put a blank line between sub-processes. */
3010 if (print_help_list)
3011 fputc ('\n', stderr);
3013 /* Print each piped command as a separate line. */
3014 for (i = 0; i < n_commands; i++)
3016 const char *const *j;
3018 if (verbose_only_flag)
3020 for (j = commands[i].argv; *j; j++)
3023 fprintf (stderr, " \"");
3024 for (p = *j; *p; ++p)
3026 if (*p == '"' || *p == '\\' || *p == '$')
3027 fputc ('\\', stderr);
3030 fputc ('"', stderr);
3034 for (j = commands[i].argv; *j; j++)
3035 fprintf (stderr, " %s", *j);
3037 /* Print a pipe symbol after all but the last command. */
3038 if (i + 1 != n_commands)
3039 fprintf (stderr, " |");
3040 fprintf (stderr, "\n");
3043 if (verbose_only_flag != 0)
3045 /* verbose_only_flag should act as if the spec was
3046 executed, so increment execution_count before
3047 returning. This prevents spurious warnings about
3048 unused linker input files, etc. */
3053 notice ("\nGo ahead? (y or n) ");
3057 while (getchar () != '\n')
3060 if (i != 'y' && i != 'Y')
3065 #ifdef ENABLE_VALGRIND_CHECKING
3066 /* Run the each command through valgrind. To simplify prepending the
3067 path to valgrind and the option "-q" (for quiet operation unless
3068 something triggers), we allocate a separate argv array. */
3070 for (i = 0; i < n_commands; i++)
3076 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3079 argv = XALLOCAVEC (const char *, argc + 3);
3081 argv[0] = VALGRIND_PATH;
3083 for (j = 2; j < argc + 2; j++)
3084 argv[j] = commands[i].argv[j - 2];
3087 commands[i].argv = argv;
3088 commands[i].prog = argv[0];
3092 /* Run each piped subprocess. */
3094 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3095 ? PEX_RECORD_TIMES : 0),
3096 programname, temp_filename);
3098 pfatal_with_name (_("pex_init failed"));
3100 for (i = 0; i < n_commands; i++)
3104 const char *string = commands[i].argv[0];
3106 errmsg = pex_run (pex,
3107 ((i + 1 == n_commands ? PEX_LAST : 0)
3108 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3109 string, CONST_CAST (char **, commands[i].argv),
3118 pfatal_with_name (errmsg);
3122 if (string != commands[i].prog)
3123 free (CONST_CAST (char *, string));
3128 /* Wait for all the subprocesses to finish. */
3132 struct pex_time *times = NULL;
3135 statuses = (int *) alloca (n_commands * sizeof (int));
3136 if (!pex_get_status (pex, n_commands, statuses))
3137 pfatal_with_name (_("failed to get exit status"));
3139 if (report_times || report_times_to_file)
3141 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3142 if (!pex_get_times (pex, n_commands, times))
3143 pfatal_with_name (_("failed to get process times"));
3148 for (i = 0; i < n_commands; ++i)
3150 int status = statuses[i];
3152 if (WIFSIGNALED (status))
3155 /* SIGPIPE is a special case. It happens in -pipe mode
3156 when the compiler dies before the preprocessor is done,
3157 or the assembler dies before the compiler is done.
3158 There's generally been an error already, and this is
3159 just fallout. So don't generate another error unless
3160 we would otherwise have succeeded. */
3161 if (WTERMSIG (status) == SIGPIPE
3162 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3170 Internal error: %s (program %s)\n\
3171 Please submit a full bug report.\n\
3172 See %s for instructions.",
3173 strsignal (WTERMSIG (status)), commands[i].prog,
3176 else if (WIFEXITED (status)
3177 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3179 if (WEXITSTATUS (status) > greatest_status)
3180 greatest_status = WEXITSTATUS (status);
3184 if (report_times || report_times_to_file)
3186 struct pex_time *pt = ×[i];
3189 ut = ((double) pt->user_seconds
3190 + (double) pt->user_microseconds / 1.0e6);
3191 st = ((double) pt->system_seconds
3192 + (double) pt->system_microseconds / 1.0e6);
3197 notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3199 if (report_times_to_file)
3202 const char *const *j;
3204 fprintf (report_times_to_file, "%g %g", ut, st);
3206 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3209 for (p = *j; *p; ++p)
3210 if (*p == '"' || *p == '\\' || *p == '$'
3216 fprintf (report_times_to_file, " \"");
3217 for (p = *j; *p; ++p)
3219 if (*p == '"' || *p == '\\' || *p == '$')
3220 fputc ('\\', report_times_to_file);
3221 fputc (*p, report_times_to_file);
3223 fputc ('"', report_times_to_file);
3226 fprintf (report_times_to_file, " %s", *j);
3229 fputc ('\n', report_times_to_file);
3239 /* Find all the switches given to us
3240 and make a vector describing them.
3241 The elements of the vector are strings, one per switch given.
3242 If a switch uses following arguments, then the `part1' field
3243 is the switch itself and the `args' field
3244 is a null-terminated vector containing the following arguments.
3245 Bits in the `live_cond' field are:
3246 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3247 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3248 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3249 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3250 in all do_spec calls afterwards. Used for %<S from self specs.
3251 The `validated' field is nonzero if any spec has looked at this switch;
3252 if it remains zero at the end of the run, it must be meaningless. */
3254 #define SWITCH_LIVE 0x1
3255 #define SWITCH_FALSE 0x2
3256 #define SWITCH_IGNORE 0x4
3257 #define SWITCH_IGNORE_PERMANENTLY 0x8
3263 unsigned int live_cond;
3264 unsigned char validated;
3265 unsigned char ordering;
3268 static struct switchstr *switches;
3270 static int n_switches;
3272 /* Set to zero if -fcompare-debug is disabled, positive if it's
3273 enabled and we're running the first compilation, negative if it's
3274 enabled and we're running the second compilation. For most of the
3275 time, it's in the range -1..1, but it can be temporarily set to 2
3276 or 3 to indicate that the -fcompare-debug flags didn't come from
3277 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3278 variable, until a synthesized -fcompare-debug flag is added to the
3282 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3283 int compare_debug_second;
3285 /* Set to the flags that should be passed to the second compilation in
3286 a -fcompare-debug compilation. */
3287 const char *compare_debug_opt;
3289 static struct switchstr *switches_debug_check[2];
3291 static int n_switches_debug_check[2];
3293 static char *debug_check_temp_file[2];
3295 /* Language is one of three things:
3297 1) The name of a real programming language.
3298 2) NULL, indicating that no one has figured out
3300 3) '*', indicating that the file should be passed
3305 const char *language;
3306 struct compiler *incompiler;
3311 /* Also a vector of input files specified. */
3313 static struct infile *infiles;
3317 /* True if multiple input files are being compiled to a single
3320 static bool combine_inputs;
3322 /* This counts the number of libraries added by lang_specific_driver, so that
3323 we can tell if there were any user supplied any files or libraries. */
3325 static int added_libraries;
3327 /* And a vector of corresponding output files is made up later. */
3329 const char **outfiles;
3331 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3333 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3334 is true if we should look for an executable suffix. DO_OBJ
3335 is true if we should look for an object suffix. */
3338 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3339 int do_obj ATTRIBUTE_UNUSED)
3341 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3349 len = strlen (name);
3351 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3352 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3353 if (do_obj && len > 2
3354 && name[len - 2] == '.'
3355 && name[len - 1] == 'o')
3357 obstack_grow (&obstack, name, len - 2);
3358 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3359 name = XOBFINISH (&obstack, const char *);
3363 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3364 /* If there is no filetype, make it the executable suffix (which includes
3365 the "."). But don't get confused if we have just "-o". */
3366 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3369 for (i = len - 1; i >= 0; i--)
3370 if (IS_DIR_SEPARATOR (name[i]))
3373 for (i++; i < len; i++)
3377 obstack_grow (&obstack, name, len);
3378 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3379 strlen (TARGET_EXECUTABLE_SUFFIX));
3380 name = XOBFINISH (&obstack, const char *);
3387 /* Display the command line switches accepted by gcc. */
3391 printf (_("Usage: %s [options] file...\n"), programname);
3392 fputs (_("Options:\n"), stdout);
3394 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3395 fputs (_(" --help Display this information\n"), stdout);
3396 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3397 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3398 fputs (_(" Display specific types of command line options\n"), stdout);
3400 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3401 fputs (_(" --version Display compiler version information\n"), stdout);
3402 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3403 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3404 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3405 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3406 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3407 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3408 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3409 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3411 -print-multi-lib Display the mapping between command line options and\n\
3412 multiple library search directories\n"), stdout);
3413 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3414 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3415 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3416 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3417 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3418 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3419 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3420 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3421 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3422 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3423 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3424 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3426 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3427 prefixes to other gcc components\n"), stdout);
3428 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3429 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3430 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3431 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3433 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3434 and libraries\n"), stdout);
3435 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3436 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3437 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3438 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3439 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3440 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3441 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3443 -x <language> Specify the language of the following input files\n\
3444 Permissible languages include: c c++ assembler none\n\
3445 'none' means revert to the default behavior of\n\
3446 guessing the language based on the file's extension\n\
3450 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3451 passed on to the various sub-processes invoked by %s. In order to pass\n\
3452 other options on to these processes the -W<letter> options must be used.\n\
3455 /* The rest of the options are displayed by invocations of the various
3460 add_preprocessor_option (const char *option, int len)
3462 n_preprocessor_options++;
3464 if (! preprocessor_options)
3465 preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3467 preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3468 n_preprocessor_options);
3470 preprocessor_options [n_preprocessor_options - 1] =
3471 save_string (option, len);
3475 add_assembler_option (const char *option, int len)
3477 n_assembler_options++;
3479 if (! assembler_options)
3480 assembler_options = XNEWVEC (char *, n_assembler_options);
3482 assembler_options = XRESIZEVEC (char *, assembler_options,
3483 n_assembler_options);
3485 assembler_options [n_assembler_options - 1] = save_string (option, len);
3489 add_linker_option (const char *option, int len)
3493 if (! linker_options)
3494 linker_options = XNEWVEC (char *, n_linker_options);
3496 linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3498 linker_options [n_linker_options - 1] = save_string (option, len);
3501 /* Create the vector `switches' and its contents.
3502 Store its length in `n_switches'. */
3505 process_command (int argc, const char **argv)
3510 const char *spec_lang = 0;
3511 int last_language_n_infiles;
3512 int lang_n_infiles = 0;
3513 #ifdef MODIFY_TARGET_NAME
3514 int is_modify_target_name;
3517 const char *tooldir_prefix;
3518 char *(*get_relative_prefix) (const char *, const char *,
3519 const char *) = NULL;
3521 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3525 added_libraries = 0;
3527 /* Figure compiler version from version string. */
3529 compiler_version = temp1 = xstrdup (version_string);
3531 for (; *temp1; ++temp1)
3540 /* Convert new-style -- options to old-style. */
3541 translate_options (&argc,
3542 CONST_CAST2 (const char *const **, const char ***,
3545 /* Handle any -no-canonical-prefixes flag early, to assign the function
3546 that builds relative prefixes. This function creates default search
3547 paths that are needed later in normal option handling. */
3549 for (i = 1; i < argc; i++)
3551 if (! strcmp (argv[i], "-no-canonical-prefixes"))
3553 get_relative_prefix = make_relative_prefix_ignore_links;
3557 if (! get_relative_prefix)
3558 get_relative_prefix = make_relative_prefix;
3560 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3561 see if we can create it from the pathname specified in argv[0]. */
3563 gcc_libexec_prefix = standard_libexec_prefix;
3565 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3566 if (!gcc_exec_prefix)
3568 gcc_exec_prefix = get_relative_prefix (argv[0],
3569 standard_bindir_prefix,
3570 standard_exec_prefix);
3571 gcc_libexec_prefix = get_relative_prefix (argv[0],
3572 standard_bindir_prefix,
3573 standard_libexec_prefix);
3574 if (gcc_exec_prefix)
3575 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3579 /* make_relative_prefix requires a program name, but
3580 GCC_EXEC_PREFIX is typically a directory name with a trailing
3581 / (which is ignored by make_relative_prefix), so append a
3583 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3584 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3585 standard_exec_prefix,
3586 standard_libexec_prefix);
3588 /* The path is unrelocated, so fallback to the original setting. */
3589 if (!gcc_libexec_prefix)
3590 gcc_libexec_prefix = standard_libexec_prefix;
3596 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3597 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3598 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3600 /* Do language-specific adjustment/addition of flags. */
3601 lang_specific_driver (&argc,
3602 CONST_CAST2 (const char *const **, const char ***,
3606 if (gcc_exec_prefix)
3608 int len = strlen (gcc_exec_prefix);
3610 if (len > (int) sizeof ("/lib/gcc/") - 1
3611 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3613 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3614 if (IS_DIR_SEPARATOR (*temp)
3615 && strncmp (temp + 1, "lib", 3) == 0
3616 && IS_DIR_SEPARATOR (temp[4])
3617 && strncmp (temp + 5, "gcc", 3) == 0)
3618 len -= sizeof ("/lib/gcc/") - 1;
3621 set_std_prefix (gcc_exec_prefix, len);
3622 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3623 PREFIX_PRIORITY_LAST, 0, 0);
3624 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3625 PREFIX_PRIORITY_LAST, 0, 0);
3628 /* COMPILER_PATH and LIBRARY_PATH have values
3629 that are lists of directory names with colons. */
3631 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3634 const char *startp, *endp;
3635 char *nstore = (char *) alloca (strlen (temp) + 3);
3637 startp = endp = temp;
3640 if (*endp == PATH_SEPARATOR || *endp == 0)
3642 strncpy (nstore, startp, endp - startp);
3644 strcpy (nstore, concat (".", dir_separator_str, NULL));
3645 else if (!IS_DIR_SEPARATOR (endp[-1]))
3647 nstore[endp - startp] = DIR_SEPARATOR;
3648 nstore[endp - startp + 1] = 0;
3651 nstore[endp - startp] = 0;
3652 add_prefix (&exec_prefixes, nstore, 0,
3653 PREFIX_PRIORITY_LAST, 0, 0);
3654 add_prefix (&include_prefixes, nstore, 0,
3655 PREFIX_PRIORITY_LAST, 0, 0);
3658 endp = startp = endp + 1;
3665 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3666 if (temp && *cross_compile == '0')
3668 const char *startp, *endp;
3669 char *nstore = (char *) alloca (strlen (temp) + 3);
3671 startp = endp = temp;
3674 if (*endp == PATH_SEPARATOR || *endp == 0)
3676 strncpy (nstore, startp, endp - startp);
3678 strcpy (nstore, concat (".", dir_separator_str, NULL));
3679 else if (!IS_DIR_SEPARATOR (endp[-1]))
3681 nstore[endp - startp] = DIR_SEPARATOR;
3682 nstore[endp - startp + 1] = 0;
3685 nstore[endp - startp] = 0;
3686 add_prefix (&startfile_prefixes, nstore, NULL,
3687 PREFIX_PRIORITY_LAST, 0, 1);
3690 endp = startp = endp + 1;
3697 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3698 GET_ENVIRONMENT (temp, "LPATH");
3699 if (temp && *cross_compile == '0')
3701 const char *startp, *endp;
3702 char *nstore = (char *) alloca (strlen (temp) + 3);
3704 startp = endp = temp;
3707 if (*endp == PATH_SEPARATOR || *endp == 0)
3709 strncpy (nstore, startp, endp - startp);
3711 strcpy (nstore, concat (".", dir_separator_str, NULL));
3712 else if (!IS_DIR_SEPARATOR (endp[-1]))
3714 nstore[endp - startp] = DIR_SEPARATOR;
3715 nstore[endp - startp + 1] = 0;
3718 nstore[endp - startp] = 0;
3719 add_prefix (&startfile_prefixes, nstore, NULL,
3720 PREFIX_PRIORITY_LAST, 0, 1);
3723 endp = startp = endp + 1;
3730 /* Scan argv twice. Here, the first time, just count how many switches
3731 there will be in their vector, and how many input files in theirs.
3732 Here we also parse the switches that cc itself uses (e.g. -v). */
3734 for (i = 1; i < argc; i++)
3736 if (! strcmp (argv[i], "-dumpspecs"))
3738 struct spec_list *sl;
3740 for (sl = specs; sl; sl = sl->next)
3741 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3742 if (link_command_spec)
3743 printf ("*link_command:\n%s\n\n", link_command_spec);
3746 else if (! strcmp (argv[i], "-dumpversion"))
3748 printf ("%s\n", spec_version);
3751 else if (! strcmp (argv[i], "-dumpmachine"))
3753 printf ("%s\n", spec_machine);
3756 else if (strcmp (argv[i], "-fversion") == 0)
3758 /* translate_options () has turned --version into -fversion. */
3761 /* We will be passing a dummy file on to the sub-processes. */
3765 /* CPP driver cannot obtain switch from cc1_options. */
3767 add_preprocessor_option ("--version", strlen ("--version"));
3768 add_assembler_option ("--version", strlen ("--version"));
3769 add_linker_option ("--version", strlen ("--version"));
3771 else if (strcmp (argv[i], "-fhelp") == 0)
3773 /* translate_options () has turned --help into -fhelp. */
3774 print_help_list = 1;
3776 /* We will be passing a dummy file on to the sub-processes. */
3780 /* CPP driver cannot obtain switch from cc1_options. */
3782 add_preprocessor_option ("--help", 6);
3783 add_assembler_option ("--help", 6);
3784 add_linker_option ("--help", 6);
3786 else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3788 /* translate_options () has turned --help into -fhelp. */
3789 print_subprocess_help = 2;
3791 /* We will be passing a dummy file on to the sub-processes. */
3795 else if (strcmp (argv[i], "-ftarget-help") == 0)
3797 /* translate_options() has turned --target-help into -ftarget-help. */
3798 print_subprocess_help = 1;
3800 /* We will be passing a dummy file on to the sub-processes. */
3804 /* CPP driver cannot obtain switch from cc1_options. */
3806 add_preprocessor_option ("--target-help", 13);
3807 add_assembler_option ("--target-help", 13);
3808 add_linker_option ("--target-help", 13);
3810 else if (! strcmp (argv[i], "-pass-exit-codes"))
3812 pass_exit_codes = 1;
3815 else if (! strcmp (argv[i], "-print-search-dirs"))
3816 print_search_dirs = 1;
3817 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3818 print_file_name = "libgcc.a";
3819 else if (! strncmp (argv[i], "-print-file-name=", 17))
3820 print_file_name = argv[i] + 17;
3821 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3822 print_prog_name = argv[i] + 17;
3823 else if (! strcmp (argv[i], "-print-multi-lib"))
3824 print_multi_lib = 1;
3825 else if (! strcmp (argv[i], "-print-multi-directory"))
3826 print_multi_directory = 1;
3827 else if (! strcmp (argv[i], "-print-sysroot"))
3829 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3830 print_multi_os_directory = 1;
3831 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3832 print_sysroot_headers_suffix = 1;
3833 else if (! strcmp (argv[i], "-fcompare-debug-second"))
3835 compare_debug_second = 1;
3838 else if (! strcmp (argv[i], "-fno-compare-debug"))
3840 argv[i] = "-fcompare-debug=";
3841 goto compare_debug_with_arg;
3843 else if (! strcmp (argv[i], "-fcompare-debug"))
3845 argv[i] = "-fcompare-debug=-gtoggle";
3846 goto compare_debug_with_arg;
3848 #define OPT "-fcompare-debug="
3849 else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3852 compare_debug_with_arg:
3853 opt = argv[i] + sizeof (OPT) - 1;
3859 if (compare_debug < 0)
3860 compare_debug_opt = NULL;
3862 compare_debug_opt = opt;
3865 else if (! strncmp (argv[i], "-Wa,", 4))
3868 /* Pass the rest of this option to the assembler. */
3870 /* Split the argument at commas. */
3872 for (j = 4; argv[i][j]; j++)
3873 if (argv[i][j] == ',')
3875 add_assembler_option (argv[i] + prev, j - prev);
3879 /* Record the part after the last comma. */
3880 add_assembler_option (argv[i] + prev, j - prev);
3882 else if (! strncmp (argv[i], "-Wp,", 4))
3885 /* Pass the rest of this option to the preprocessor. */
3887 /* Split the argument at commas. */
3889 for (j = 4; argv[i][j]; j++)
3890 if (argv[i][j] == ',')
3892 add_preprocessor_option (argv[i] + prev, j - prev);
3896 /* Record the part after the last comma. */
3897 add_preprocessor_option (argv[i] + prev, j - prev);
3899 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3900 /* The +e options to the C++ front-end. */
3902 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3905 /* Split the argument at commas. */
3906 for (j = 3; argv[i][j]; j++)
3907 n_infiles += (argv[i][j] == ',');
3909 else if (strcmp (argv[i], "-Xlinker") == 0)
3912 fatal ("argument to '-Xlinker' is missing");
3917 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3920 fatal ("argument to '-Xpreprocessor' is missing");
3922 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3924 else if (strcmp (argv[i], "-Xassembler") == 0)
3927 fatal ("argument to '-Xassembler' is missing");
3929 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3931 else if (strcmp (argv[i], "-l") == 0)
3934 fatal ("argument to '-l' is missing");
3939 else if (strncmp (argv[i], "-l", 2) == 0)
3941 else if (strcmp (argv[i], "-save-temps") == 0)
3943 save_temps_flag = SAVE_TEMPS_CWD;
3946 else if (strncmp (argv[i], "-save-temps=", 12) == 0)
3949 if (strcmp (argv[i]+12, "cwd") == 0)
3950 save_temps_flag = SAVE_TEMPS_CWD;
3951 else if (strcmp (argv[i]+12, "obj") == 0
3952 || strcmp (argv[i]+12, "object") == 0)
3953 save_temps_flag = SAVE_TEMPS_OBJ;
3955 fatal ("'%s' is an unknown -save-temps option", argv[i]);
3957 else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
3958 /* Already handled as a special case, so ignored here. */
3960 else if (strcmp (argv[i], "-combine") == 0)
3965 else if (strcmp (argv[i], "-specs") == 0)
3967 struct user_specs *user = XNEW (struct user_specs);
3969 fatal ("argument to '-specs' is missing");
3971 user->next = (struct user_specs *) 0;
3972 user->filename = argv[i];
3973 if (user_specs_tail)
3974 user_specs_tail->next = user;
3976 user_specs_head = user;
3977 user_specs_tail = user;
3979 else if (strncmp (argv[i], "-specs=", 7) == 0)
3981 struct user_specs *user = XNEW (struct user_specs);
3982 if (strlen (argv[i]) == 7)
3983 fatal ("argument to '-specs=' is missing");
3985 user->next = (struct user_specs *) 0;
3986 user->filename = argv[i] + 7;
3987 if (user_specs_tail)
3988 user_specs_tail->next = user;
3990 user_specs_head = user;
3991 user_specs_tail = user;
3993 else if (strcmp (argv[i], "-time") == 0)
3995 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
3997 if (report_times_to_file)
3998 fclose (report_times_to_file);
3999 report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
4001 else if (strcmp (argv[i], "-pipe") == 0)
4003 /* -pipe has to go into the switches array as well as
4008 else if (strcmp (argv[i], "-wrapper") == 0)
4011 fatal ("argument to '-wrapper' is missing");
4013 wrapper_string = argv[i];
4017 else if (strcmp (argv[i], "-###") == 0)
4019 /* This is similar to -v except that there is no execution
4020 of the commands and the echoed arguments are quoted. It
4021 is intended for use in shell scripts to capture the
4022 driver-generated command line. */
4023 verbose_only_flag++;
4026 else if (argv[i][0] == '-' && argv[i][1] != 0)
4028 const char *p = &argv[i][1];
4038 if (p[1] == 0 && i + 1 == argc)
4039 fatal ("argument to '-B' is missing");
4045 len = strlen (value);
4047 /* Catch the case where the user has forgotten to append a
4048 directory separator to the path. Note, they may be using
4049 -B to add an executable name prefix, eg "i386-elf-", in
4050 order to distinguish between multiple installations of
4051 GCC in the same directory. Hence we must check to see
4052 if appending a directory separator actually makes a
4053 valid directory name. */
4054 if (! IS_DIR_SEPARATOR (value [len - 1])
4055 && is_directory (value, false))
4057 char *tmp = XNEWVEC (char, len + 2);
4058 strcpy (tmp, value);
4059 tmp[len] = DIR_SEPARATOR;
4064 add_prefix (&exec_prefixes, value, NULL,
4065 PREFIX_PRIORITY_B_OPT, 0, 0);
4066 add_prefix (&startfile_prefixes, value, NULL,
4067 PREFIX_PRIORITY_B_OPT, 0, 0);
4068 add_prefix (&include_prefixes, value, NULL,
4069 PREFIX_PRIORITY_B_OPT, 0, 0);
4074 case 'v': /* Print our subcommands and print versions. */
4076 /* If they do anything other than exactly `-v', don't set
4077 verbose_flag; rather, continue on to give the error. */
4096 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4101 /* Forward scan, just in case -S, -E or -c is specified
4108 if (argv[j][0] == '-')
4110 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4116 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4117 j += skip - (argv[j][2] != 0);
4118 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4125 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4127 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4129 argv[i] = convert_filename (argv[i], ! have_c, 0);
4131 /* Save the output name in case -save-temps=obj was used. */
4132 if ((p[1] == 0) && argv[i + 1])
4133 save_temps_prefix = xstrdup(argv[i + 1]);
4135 save_temps_prefix = xstrdup(argv[i] + 1);
4141 #ifdef MODIFY_TARGET_NAME
4142 is_modify_target_name = 0;
4144 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4145 if (! strcmp (argv[i], modify_target[j].sw))
4147 char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
4148 + strlen (spec_machine));
4151 int made_addition = 0;
4153 is_modify_target_name = 1;
4154 for (p = spec_machine, q = new_name; *p != 0; )
4156 if (modify_target[j].add_del == DELETE
4157 && (! strncmp (q, modify_target[j].str,
4158 strlen (modify_target[j].str))))
4159 p += strlen (modify_target[j].str);
4160 else if (modify_target[j].add_del == ADD
4161 && ! made_addition && *p == '-')
4163 for (r = modify_target[j].str; *r != 0; )
4171 spec_machine = new_name;
4174 if (is_modify_target_name)
4180 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
4181 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
4182 else if (WORD_SWITCH_TAKES_ARG (p))
4183 i += WORD_SWITCH_TAKES_ARG (p);
4193 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4194 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4195 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4197 save_temps_length = strlen (save_temps_prefix);
4198 temp = strrchr (lbasename (save_temps_prefix), '.');
4201 save_temps_length -= strlen (temp);
4202 save_temps_prefix[save_temps_length] = '\0';
4206 else if (save_temps_prefix != NULL)
4208 free (save_temps_prefix);
4209 save_temps_prefix = NULL;
4212 if (save_temps_flag && use_pipes)
4214 /* -save-temps overrides -pipe, so that temp files are produced */
4215 if (save_temps_flag)
4216 error ("warning: -pipe ignored because -save-temps specified");
4222 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4224 if (gcd && gcd[0] == '-')
4227 compare_debug_opt = gcd;
4230 else if (gcd && *gcd && strcmp (gcd, "0"))
4233 compare_debug_opt = "-gtoggle";
4237 else if (compare_debug < 0)
4240 gcc_assert (!compare_debug_opt);
4243 /* Set up the search paths. We add directories that we expect to
4244 contain GNU Toolchain components before directories specified by
4245 the machine description so that we will find GNU components (like
4246 the GNU assembler) before those of the host system. */
4248 /* If we don't know where the toolchain has been installed, use the
4249 configured-in locations. */
4250 if (!gcc_exec_prefix)
4253 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4254 PREFIX_PRIORITY_LAST, 1, 0);
4255 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4256 PREFIX_PRIORITY_LAST, 2, 0);
4257 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4258 PREFIX_PRIORITY_LAST, 2, 0);
4260 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4261 PREFIX_PRIORITY_LAST, 1, 0);
4264 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4265 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4266 dir_separator_str, NULL);
4268 /* Look for tools relative to the location from which the driver is
4269 running, or, if that is not available, the configured prefix. */
4271 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4272 spec_machine, dir_separator_str,
4273 spec_version, dir_separator_str, tooldir_prefix, NULL);
4275 add_prefix (&exec_prefixes,
4276 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4277 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4278 add_prefix (&startfile_prefixes,
4279 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4280 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4282 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4283 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4284 then consider it to relocate with the rest of the GCC installation
4285 if GCC_EXEC_PREFIX is set.
4286 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4287 if (target_system_root && gcc_exec_prefix)
4289 char *tmp_prefix = get_relative_prefix (argv[0],
4290 standard_bindir_prefix,
4291 target_system_root);
4292 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4294 target_system_root = tmp_prefix;
4295 target_system_root_changed = 1;
4300 /* More prefixes are enabled in main, after we read the specs file
4301 and determine whether this is cross-compilation or not. */
4303 /* Then create the space for the vectors and scan again. */
4305 switches = XNEWVEC (struct switchstr, n_switches + 1);
4306 infiles = XNEWVEC (struct infile, n_infiles + 1);
4309 last_language_n_infiles = -1;
4311 /* This, time, copy the text of each switch and store a pointer
4312 to the copy in the vector of switches.
4313 Store all the infiles in their vector. */
4315 for (i = 1; i < argc; i++)
4317 /* Just skip the switches that were handled by the preceding loop. */
4318 #ifdef MODIFY_TARGET_NAME
4319 is_modify_target_name = 0;
4321 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4322 if (! strcmp (argv[i], modify_target[j].sw))
4323 is_modify_target_name = 1;
4325 if (is_modify_target_name)
4329 if (! strncmp (argv[i], "-Wa,", 4))
4331 else if (! strncmp (argv[i], "-Wp,", 4))
4333 else if (! strcmp (argv[i], "-no-canonical-prefixes"))
4335 else if (! strcmp (argv[i], "-pass-exit-codes"))
4337 else if (! strcmp (argv[i], "-print-search-dirs"))
4339 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4341 else if (! strncmp (argv[i], "-print-file-name=", 17))
4343 else if (! strncmp (argv[i], "-print-prog-name=", 17))
4345 else if (! strcmp (argv[i], "-print-multi-lib"))
4347 else if (! strcmp (argv[i], "-print-multi-directory"))
4349 else if (! strcmp (argv[i], "-print-sysroot"))
4351 else if (! strcmp (argv[i], "-print-multi-os-directory"))
4353 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4355 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4357 target_system_root = argv[i] + strlen ("--sysroot=");
4358 target_system_root_changed = 1;
4360 else if (argv[i][0] == '+' && argv[i][1] == 'e')
4362 /* Compensate for the +e options to the C++ front-end;
4363 they're there simply for cfront call-compatibility. We do
4364 some magic in default_compilers to pass them down properly.
4365 Note we deliberately start at the `+' here, to avoid passing
4366 -e0 or -e1 down into the linker. */
4367 switches[n_switches].part1 = &argv[i][0];
4368 switches[n_switches].args = 0;
4369 switches[n_switches].live_cond = 0;
4370 switches[n_switches].validated = 0;
4373 else if (strncmp (argv[i], "-Wl,", 4) == 0)
4376 /* Split the argument at commas. */
4378 for (j = 4; argv[i][j]; j++)
4379 if (argv[i][j] == ',')
4381 infiles[n_infiles].language = "*";
4382 infiles[n_infiles++].name
4383 = save_string (argv[i] + prev, j - prev);
4386 /* Record the part after the last comma. */
4387 infiles[n_infiles].language = "*";
4388 infiles[n_infiles++].name = argv[i] + prev;
4390 else if (strcmp (argv[i], "-Xlinker") == 0)
4392 infiles[n_infiles].language = "*";
4393 infiles[n_infiles++].name = argv[++i];
4395 /* Xassembler and Xpreprocessor were already handled in the first argv
4396 scan, so all we need to do here is ignore them and their argument. */
4397 else if (strcmp (argv[i], "-Xassembler") == 0)
4399 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4401 else if (strcmp (argv[i], "-l") == 0)
4402 { /* POSIX allows separation of -l and the lib arg;
4403 canonicalize by concatenating -l with its arg */
4404 infiles[n_infiles].language = "*";
4405 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4407 else if (strncmp (argv[i], "-l", 2) == 0)
4409 infiles[n_infiles].language = "*";
4410 infiles[n_infiles++].name = argv[i];
4412 else if (strcmp (argv[i], "-wrapper") == 0)
4414 else if (strcmp (argv[i], "-specs") == 0)
4416 else if (strncmp (argv[i], "-specs=", 7) == 0)
4418 else if (strcmp (argv[i], "-time") == 0)
4420 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4422 else if (strcmp (argv[i], "-###") == 0)
4424 else if (argv[i][0] == '-' && argv[i][1] != 0)
4426 const char *p = &argv[i][1];
4431 if (p[1] == 0 && i + 1 == argc)
4432 fatal ("argument to '-x' is missing");
4434 spec_lang = argv[++i];
4437 if (! strcmp (spec_lang, "none"))
4438 /* Suppress the warning if -xnone comes after the last input
4439 file, because alternate command interfaces like g++ might
4440 find it useful to place -xnone after each input file. */
4443 last_language_n_infiles = n_infiles;
4446 switches[n_switches].part1 = p;
4447 /* Deal with option arguments in separate argv elements. */
4448 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4449 || WORD_SWITCH_TAKES_ARG (p))
4452 int n_args = WORD_SWITCH_TAKES_ARG (p);
4456 /* Count only the option arguments in separate argv elements. */
4457 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4459 if (i + n_args >= argc)
4460 fatal ("argument to '-%s' is missing", p);
4461 switches[n_switches].args
4462 = XNEWVEC (const char *, n_args + 1);
4464 switches[n_switches].args[j++] = argv[++i];
4465 /* Null-terminate the vector. */
4466 switches[n_switches].args[j] = 0;
4468 else if (strchr (switches_need_spaces, c))
4470 /* On some systems, ld cannot handle some options without
4471 a space. So split the option from its argument. */
4472 char *part1 = XNEWVEC (char, 2);
4476 switches[n_switches].part1 = part1;
4477 switches[n_switches].args = XNEWVEC (const char *, 2);
4478 switches[n_switches].args[0] = xstrdup (p+1);
4479 switches[n_switches].args[1] = 0;
4482 switches[n_switches].args = 0;
4484 switches[n_switches].live_cond = 0;
4485 switches[n_switches].validated = 0;
4486 switches[n_switches].ordering = 0;
4487 /* These are always valid, since gcc.c itself understands the
4488 first four, gfortranspec.c understands -static-libgfortran
4489 and g++spec.c understands -static-libstdc++ */
4490 if (!strcmp (p, "save-temps")
4491 || !strcmp (p, "static-libgcc")
4492 || !strcmp (p, "shared-libgcc")
4493 || !strcmp (p, "pipe")
4494 || !strcmp (p, "static-libgfortran")
4495 || !strcmp (p, "static-libstdc++"))
4496 switches[n_switches].validated = 1;
4499 char ch = switches[n_switches].part1[0];
4501 switches[n_switches].validated = 1;
4507 const char *p = strrchr (argv[i], '@');
4511 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4512 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4514 /* For LTO static archive support we handle input file
4515 specifications that are composed of a filename and
4516 an offset like FNAME@OFFSET. */
4519 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4520 && strlen (p) == (unsigned int)consumed)
4522 fname = (char *)xmalloc (p - argv[i] + 1);
4523 memcpy (fname, argv[i], p - argv[i]);
4524 fname[p - argv[i]] = '\0';
4525 /* Only accept non-stdin and existing FNAME parts, otherwise
4526 try with the full name. */
4527 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4530 fname = xstrdup (argv[i]);
4534 fname = xstrdup (argv[i]);
4536 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4538 perror_with_name (fname);
4543 infiles[n_infiles].language = spec_lang;
4544 infiles[n_infiles++].name = argv[i];
4551 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4552 error ("warning: '-x %s' after last input file has no effect", spec_lang);
4554 if (compare_debug == 2 || compare_debug == 3)
4556 switches[n_switches].part1 = concat ("fcompare-debug=",
4559 switches[n_switches].args = 0;
4560 switches[n_switches].live_cond = 0;
4561 switches[n_switches].validated = 0;
4562 switches[n_switches].ordering = 0;
4567 /* Ensure we only invoke each subprocess once. */
4568 if (print_subprocess_help || print_help_list || print_version)
4572 /* Create a dummy input file, so that we can pass
4573 the help option on to the various sub-processes. */
4574 infiles[0].language = "c";
4575 infiles[0].name = "help-dummy";
4578 switches[n_switches].part1 = 0;
4579 infiles[n_infiles].name = 0;
4582 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4583 and place that in the environment. */
4586 set_collect_gcc_options (void)
4591 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4593 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4594 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4597 for (i = 0; (int) i < n_switches; i++)
4599 const char *const *args;
4602 obstack_grow (&collect_obstack, " ", 1);
4606 /* Ignore elided switches. */
4607 if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4610 obstack_grow (&collect_obstack, "'-", 2);
4611 q = switches[i].part1;
4612 while ((p = strchr (q, '\'')))
4614 obstack_grow (&collect_obstack, q, p - q);
4615 obstack_grow (&collect_obstack, "'\\''", 4);
4618 obstack_grow (&collect_obstack, q, strlen (q));
4619 obstack_grow (&collect_obstack, "'", 1);
4621 for (args = switches[i].args; args && *args; args++)
4623 obstack_grow (&collect_obstack, " '", 2);
4625 while ((p = strchr (q, '\'')))
4627 obstack_grow (&collect_obstack, q, p - q);
4628 obstack_grow (&collect_obstack, "'\\''", 4);
4631 obstack_grow (&collect_obstack, q, strlen (q));
4632 obstack_grow (&collect_obstack, "'", 1);
4635 obstack_grow (&collect_obstack, "\0", 1);
4636 xputenv (XOBFINISH (&collect_obstack, char *));
4639 /* Process a spec string, accumulating and running commands. */
4641 /* These variables describe the input file name.
4642 input_file_number is the index on outfiles of this file,
4643 so that the output file name can be stored for later use by %o.
4644 input_basename is the start of the part of the input file
4645 sans all directory names, and basename_length is the number
4646 of characters starting there excluding the suffix .c or whatever. */
4648 static const char *input_filename;
4649 static int input_file_number;
4650 size_t input_filename_length;
4651 static int basename_length;
4652 static int suffixed_basename_length;
4653 static const char *input_basename;
4654 static const char *input_suffix;
4655 #ifndef HOST_LACKS_INODE_NUMBERS
4656 static struct stat input_stat;
4658 static int input_stat_set;
4660 /* The compiler used to process the current input file. */
4661 static struct compiler *input_file_compiler;
4663 /* These are variables used within do_spec and do_spec_1. */
4665 /* Nonzero if an arg has been started and not yet terminated
4666 (with space, tab or newline). */
4667 static int arg_going;
4669 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4670 is a temporary file name. */
4671 static int delete_this_arg;
4673 /* Nonzero means %w has been seen; the next arg to be terminated
4674 is the output file name of this compilation. */
4675 static int this_is_output_file;
4677 /* Nonzero means %s has been seen; the next arg to be terminated
4678 is the name of a library file and we should try the standard
4679 search dirs for it. */
4680 static int this_is_library_file;
4682 /* Nonzero means %T has been seen; the next arg to be terminated
4683 is the name of a linker script and we should try all of the
4684 standard search dirs for it. If it is found insert a --script
4685 command line switch and then substitute the full path in place,
4686 otherwise generate an error message. */
4687 static int this_is_linker_script;
4689 /* Nonzero means that the input of this command is coming from a pipe. */
4690 static int input_from_pipe;
4692 /* Nonnull means substitute this for any suffix when outputting a switches
4694 static const char *suffix_subst;
4696 /* If there is an argument being accumulated, terminate it and store it. */
4699 end_going_arg (void)
4705 obstack_1grow (&obstack, 0);
4706 string = XOBFINISH (&obstack, const char *);
4707 if (this_is_library_file)
4708 string = find_file (string);
4709 if (this_is_linker_script)
4711 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4713 if (full_script_path == NULL)
4715 error (_("unable to locate default linker script '%s' in the library search paths"), string);
4716 /* Script was not found on search path. */
4719 store_arg ("--script", false, false);
4720 string = full_script_path;
4722 store_arg (string, delete_this_arg, this_is_output_file);
4723 if (this_is_output_file)
4724 outfiles[input_file_number] = string;
4730 /* Parse the WRAPPER string which is a comma separated list of the command line
4731 and insert them into the beginning of argbuf. */
4734 insert_wrapper (const char *wrapper)
4738 char *buf = xstrdup (wrapper);
4747 while ((p = strchr (p, ',')) != NULL);
4749 if (argbuf_index + n >= argbuf_length)
4751 argbuf_length = argbuf_length * 2;
4752 while (argbuf_length < argbuf_index + n)
4754 argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4756 for (i = argbuf_index - 1; i >= 0; i--)
4757 argbuf[i + n] = argbuf[i];
4770 while ((p = strchr (p, ',')) != NULL);
4771 gcc_assert (i == n);
4775 /* Process the spec SPEC and run the commands specified therein.
4776 Returns 0 if the spec is successfully processed; -1 if failed. */
4779 do_spec (const char *spec)
4783 value = do_spec_2 (spec);
4785 /* Force out any unfinished command.
4786 If -pipe, this forces out the last command if it ended in `|'. */
4789 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4792 set_collect_gcc_options ();
4794 if (argbuf_index > 0)
4802 do_spec_2 (const char *spec)
4808 delete_this_arg = 0;
4809 this_is_output_file = 0;
4810 this_is_library_file = 0;
4811 this_is_linker_script = 0;
4812 input_from_pipe = 0;
4813 suffix_subst = NULL;
4815 result = do_spec_1 (spec, 0, NULL);
4823 /* Process the given spec string and add any new options to the end
4824 of the switches/n_switches array. */
4827 do_option_spec (const char *name, const char *spec)
4829 unsigned int i, value_count, value_len;
4830 const char *p, *q, *value;
4831 char *tmp_spec, *tmp_spec_p;
4833 if (configure_default_options[0].name == NULL)
4836 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4837 if (strcmp (configure_default_options[i].name, name) == 0)
4839 if (i == ARRAY_SIZE (configure_default_options))
4842 value = configure_default_options[i].value;
4843 value_len = strlen (value);
4845 /* Compute the size of the final spec. */
4848 while ((p = strstr (p, "%(VALUE)")) != NULL)
4854 /* Replace each %(VALUE) by the specified value. */
4855 tmp_spec = (char *) alloca (strlen (spec) + 1
4856 + value_count * (value_len - strlen ("%(VALUE)")));
4857 tmp_spec_p = tmp_spec;
4859 while ((p = strstr (q, "%(VALUE)")) != NULL)
4861 memcpy (tmp_spec_p, q, p - q);
4862 tmp_spec_p = tmp_spec_p + (p - q);
4863 memcpy (tmp_spec_p, value, value_len);
4864 tmp_spec_p += value_len;
4865 q = p + strlen ("%(VALUE)");
4867 strcpy (tmp_spec_p, q);
4869 do_self_spec (tmp_spec);
4872 /* Process the given spec string and add any new options to the end
4873 of the switches/n_switches array. */
4876 do_self_spec (const char *spec)
4881 do_spec_1 (" ", 0, NULL);
4883 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4884 do_self_specs adds the replacements to switches array, so it shouldn't
4885 be processed afterwards. */
4886 for (i = 0; i < n_switches; i++)
4887 if ((switches[i].live_cond & SWITCH_IGNORE))
4888 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4890 if (argbuf_index > 0)
4892 switches = XRESIZEVEC (struct switchstr, switches,
4893 n_switches + argbuf_index + 1);
4895 for (i = 0; i < argbuf_index; i++)
4897 struct switchstr *sw;
4898 const char *p = argbuf[i];
4901 /* Each switch should start with '-'. */
4903 fatal ("switch '%s' does not start with '-'", argbuf[i]);
4908 sw = &switches[n_switches++];
4914 /* Deal with option arguments in separate argv elements. */
4915 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4916 || WORD_SWITCH_TAKES_ARG (p))
4919 int n_args = WORD_SWITCH_TAKES_ARG (p);
4923 /* Count only the option arguments in separate argv elements. */
4924 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4926 if (i + n_args >= argbuf_index)
4927 fatal ("argument to '-%s' is missing", p);
4929 = XNEWVEC (const char *, n_args + 1);
4931 sw->args[j++] = argbuf[++i];
4932 /* Null-terminate the vector. */
4935 else if (strchr (switches_need_spaces, c))
4937 /* On some systems, ld cannot handle some options without
4938 a space. So split the option from its argument. */
4939 char *part1 = XNEWVEC (char, 2);
4944 sw->args = XNEWVEC (const char *, 2);
4945 sw->args[0] = xstrdup (p+1);
4952 switches[n_switches].part1 = 0;
4956 /* Callback for processing %D and %I specs. */
4958 struct spec_path_info {
4963 bool separate_options;
4967 spec_path (char *path, void *data)
4969 struct spec_path_info *info = (struct spec_path_info *) data;
4973 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4976 if (info->append_len != 0)
4978 len = strlen (path);
4979 memcpy (path + len, info->append, info->append_len + 1);
4982 if (!is_directory (path, true))
4985 do_spec_1 (info->option, 1, NULL);
4986 if (info->separate_options)
4987 do_spec_1 (" ", 0, NULL);
4989 if (info->append_len == 0)
4991 len = strlen (path);
4992 save = path[len - 1];
4993 if (IS_DIR_SEPARATOR (path[len - 1]))
4994 path[len - 1] = '\0';
4997 do_spec_1 (path, 1, NULL);
4998 do_spec_1 (" ", 0, NULL);
5000 /* Must not damage the original path. */
5001 if (info->append_len == 0)
5002 path[len - 1] = save;
5007 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5011 create_at_file (char **argv)
5013 char *temp_file = make_temp_file ("");
5014 char *at_argument = concat ("@", temp_file, NULL);
5015 FILE *f = fopen (temp_file, "w");
5019 fatal ("could not open temporary response file %s",
5022 status = writeargv (argv, f);
5025 fatal ("could not write to temporary response file %s",
5028 status = fclose (f);
5031 fatal ("could not close temporary response file %s",
5034 store_arg (at_argument, 0, 0);
5036 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5039 /* True if we should compile INFILE. */
5042 compile_input_file_p (struct infile *infile)
5044 if ((!infile->language) || (infile->language[0] != '*'))
5045 if (infile->incompiler == input_file_compiler)
5050 /* Process the sub-spec SPEC as a portion of a larger spec.
5051 This is like processing a whole spec except that we do
5052 not initialize at the beginning and we do not supply a
5053 newline by default at the end.
5054 INSWITCH nonzero means don't process %-sequences in SPEC;
5055 in this case, % is treated as an ordinary character.
5056 This is used while substituting switches.
5057 INSWITCH nonzero also causes SPC not to terminate an argument.
5059 Value is zero unless a line was finished
5060 and the command on that line reported an error. */
5063 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5065 const char *p = spec;
5071 /* If substituting a switch, treat all chars like letters.
5072 Otherwise, NL, SPC, TAB and % are special. */
5073 switch (inswitch ? 'a' : c)
5078 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5080 /* A `|' before the newline means use a pipe here,
5081 but only if -pipe was specified.
5082 Otherwise, execute now and don't pass the `|' as an arg. */
5085 input_from_pipe = 1;
5092 set_collect_gcc_options ();
5094 if (argbuf_index > 0)
5100 /* Reinitialize for a new command, and for a new argument. */
5103 delete_this_arg = 0;
5104 this_is_output_file = 0;
5105 this_is_library_file = 0;
5106 this_is_linker_script = 0;
5107 input_from_pipe = 0;
5114 obstack_1grow (&obstack, c);
5122 /* Reinitialize for a new argument. */
5123 delete_this_arg = 0;
5124 this_is_output_file = 0;
5125 this_is_library_file = 0;
5126 this_is_linker_script = 0;
5133 fatal ("spec '%s' invalid", spec);
5136 if (save_temps_length)
5137 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5139 obstack_grow (&obstack, input_basename, basename_length);
5140 if (compare_debug < 0)
5141 obstack_grow (&obstack, ".gk", 3);
5146 if (save_temps_length)
5147 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5149 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5150 if (compare_debug < 0)
5151 obstack_grow (&obstack, ".gk", 3);
5156 delete_this_arg = 2;
5159 /* Dump out the directories specified with LIBRARY_PATH,
5160 followed by the absolute directories
5161 that we search for startfiles. */
5164 struct spec_path_info info;
5167 info.append_len = 0;
5168 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5169 /* Used on systems which record the specified -L dirs
5170 and use them to search for dynamic linking.
5171 Relative directories always come from -B,
5172 and it is better not to use them for searching
5173 at run time. In particular, stage1 loses. */
5174 info.omit_relative = true;
5176 info.omit_relative = false;
5178 info.separate_options = false;
5180 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5185 /* %efoo means report an error with `foo' as error message
5186 and don't execute any more commands for this file. */
5190 while (*p != 0 && *p != '\n')
5192 buf = (char *) alloca (p - q + 1);
5193 strncpy (buf, q, p - q);
5195 error ("%s", _(buf));
5200 /* %nfoo means report a notice with `foo' on stderr. */
5204 while (*p != 0 && *p != '\n')
5206 buf = (char *) alloca (p - q + 1);
5207 strncpy (buf, q, p - q);
5209 notice ("%s\n", _(buf));
5219 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5220 defined, and it is not a directory, and it is
5221 writable, use it. Otherwise, treat this like any
5222 other temporary file. */
5224 if ((!save_temps_flag)
5225 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5226 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5228 obstack_grow (&obstack, HOST_BIT_BUCKET,
5229 strlen (HOST_BIT_BUCKET));
5230 delete_this_arg = 0;
5235 goto create_temp_file;
5239 obstack_1grow (&obstack, '-');
5240 delete_this_arg = 0;
5243 /* consume suffix */
5244 while (*p == '.' || ISALNUM ((unsigned char) *p))
5246 if (p[0] == '%' && p[1] == 'O')
5251 goto create_temp_file;
5255 /* consume suffix */
5256 while (*p == '.' || ISALNUM ((unsigned char) *p))
5258 if (p[0] == '%' && p[1] == 'O')
5263 goto create_temp_file;
5269 struct temp_name *t;
5271 const char *suffix = p;
5272 char *saved_suffix = NULL;
5274 while (*p == '.' || ISALNUM ((unsigned char) *p))
5276 suffix_length = p - suffix;
5277 if (p[0] == '%' && p[1] == 'O')
5280 /* We don't support extra suffix characters after %O. */
5281 if (*p == '.' || ISALNUM ((unsigned char) *p))
5282 fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5283 if (suffix_length == 0)
5284 suffix = TARGET_OBJECT_SUFFIX;
5288 = XNEWVEC (char, suffix_length
5289 + strlen (TARGET_OBJECT_SUFFIX));
5290 strncpy (saved_suffix, suffix, suffix_length);
5291 strcpy (saved_suffix + suffix_length,
5292 TARGET_OBJECT_SUFFIX);
5294 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5297 if (compare_debug < 0)
5299 suffix = concat (".gk", suffix, NULL);
5303 /* If -save-temps=obj and -o were specified, use that for the
5305 if (save_temps_length)
5308 temp_filename_length
5309 = save_temps_length + suffix_length + 1;
5310 tmp = (char *) alloca (temp_filename_length);
5311 memcpy (tmp, save_temps_prefix, save_temps_length);
5312 memcpy (tmp + save_temps_length, suffix, suffix_length);
5313 tmp[save_temps_length + suffix_length] = '\0';
5314 temp_filename = save_string (tmp,
5315 temp_filename_length + 1);
5316 obstack_grow (&obstack, temp_filename,
5317 temp_filename_length);
5319 delete_this_arg = 0;
5323 /* If the input_filename has the same suffix specified
5324 for the %g, %u, or %U, and -save-temps is specified,
5325 we could end up using that file as an intermediate
5326 thus clobbering the user's source file (.e.g.,
5327 gcc -save-temps foo.s would clobber foo.s with the
5328 output of cpp0). So check for this condition and
5329 generate a temp file as the intermediate. */
5331 if (save_temps_flag)
5334 temp_filename_length = basename_length + suffix_length + 1;
5335 tmp = (char *) alloca (temp_filename_length);
5336 memcpy (tmp, input_basename, basename_length);
5337 memcpy (tmp + basename_length, suffix, suffix_length);
5338 tmp[basename_length + suffix_length] = '\0';
5339 temp_filename = tmp;
5341 if (strcmp (temp_filename, input_filename) != 0)
5343 #ifndef HOST_LACKS_INODE_NUMBERS
5344 struct stat st_temp;
5346 /* Note, set_input() resets input_stat_set to 0. */
5347 if (input_stat_set == 0)
5349 input_stat_set = stat (input_filename, &input_stat);
5350 if (input_stat_set >= 0)
5354 /* If we have the stat for the input_filename
5355 and we can do the stat for the temp_filename
5356 then the they could still refer to the same
5357 file if st_dev/st_ino's are the same. */
5358 if (input_stat_set != 1
5359 || stat (temp_filename, &st_temp) < 0
5360 || input_stat.st_dev != st_temp.st_dev
5361 || input_stat.st_ino != st_temp.st_ino)
5363 /* Just compare canonical pathnames. */
5364 char* input_realname = lrealpath (input_filename);
5365 char* temp_realname = lrealpath (temp_filename);
5366 bool files_differ = strcmp (input_realname, temp_realname);
5367 free (input_realname);
5368 free (temp_realname);
5372 temp_filename = save_string (temp_filename,
5373 temp_filename_length + 1);
5374 obstack_grow (&obstack, temp_filename,
5375 temp_filename_length);
5377 delete_this_arg = 0;
5383 /* See if we already have an association of %g/%u/%U and
5385 for (t = temp_names; t; t = t->next)
5386 if (t->length == suffix_length
5387 && strncmp (t->suffix, suffix, suffix_length) == 0
5388 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5391 /* Make a new association if needed. %u and %j
5393 if (t == 0 || c == 'u' || c == 'j')
5397 t = XNEW (struct temp_name);
5398 t->next = temp_names;
5401 t->length = suffix_length;
5404 t->suffix = saved_suffix;
5405 saved_suffix = NULL;
5408 t->suffix = save_string (suffix, suffix_length);
5409 t->unique = (c == 'u' || c == 'U' || c == 'j');
5410 temp_filename = make_temp_file (t->suffix);
5411 temp_filename_length = strlen (temp_filename);
5412 t->filename = temp_filename;
5413 t->filename_length = temp_filename_length;
5417 free (saved_suffix);
5419 obstack_grow (&obstack, t->filename, t->filename_length);
5420 delete_this_arg = 1;
5428 if (at_file_supplied)
5430 /* We are going to expand `%i' to `@FILE', where FILE
5431 is a newly-created temporary filename. The filenames
5432 that would usually be expanded in place of %o will be
5433 written to the temporary file. */
5438 for (i = 0; i < n_infiles; i++)
5439 if (compile_input_file_p (&infiles[i]))
5442 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5444 /* Copy the strings over. */
5445 for (i = 0, j = 0; i < n_infiles; i++)
5446 if (compile_input_file_p (&infiles[i]))
5448 argv[j] = CONST_CAST (char *, infiles[i].name);
5449 infiles[i].compiled = true;
5454 create_at_file (argv);
5457 for (i = 0; (int) i < n_infiles; i++)
5458 if (compile_input_file_p (&infiles[i]))
5460 store_arg (infiles[i].name, 0, 0);
5461 infiles[i].compiled = true;
5466 obstack_grow (&obstack, input_filename, input_filename_length);
5473 struct spec_path_info info;
5477 do_spec_1 ("-imultilib", 1, NULL);
5478 /* Make this a separate argument. */
5479 do_spec_1 (" ", 0, NULL);
5480 do_spec_1 (multilib_dir, 1, NULL);
5481 do_spec_1 (" ", 0, NULL);
5484 if (gcc_exec_prefix)
5486 do_spec_1 ("-iprefix", 1, NULL);
5487 /* Make this a separate argument. */
5488 do_spec_1 (" ", 0, NULL);
5489 do_spec_1 (gcc_exec_prefix, 1, NULL);
5490 do_spec_1 (" ", 0, NULL);
5493 if (target_system_root_changed ||
5494 (target_system_root && target_sysroot_hdrs_suffix))
5496 do_spec_1 ("-isysroot", 1, NULL);
5497 /* Make this a separate argument. */
5498 do_spec_1 (" ", 0, NULL);
5499 do_spec_1 (target_system_root, 1, NULL);
5500 if (target_sysroot_hdrs_suffix)
5501 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5502 do_spec_1 (" ", 0, NULL);
5505 info.option = "-isystem";
5506 info.append = "include";
5507 info.append_len = strlen (info.append);
5508 info.omit_relative = false;
5509 info.separate_options = true;
5511 for_each_path (&include_prefixes, false, info.append_len,
5514 info.append = "include-fixed";
5515 if (*sysroot_hdrs_suffix_spec)
5516 info.append = concat (info.append, dir_separator_str,
5517 multilib_dir, NULL);
5518 info.append_len = strlen (info.append);
5519 for_each_path (&include_prefixes, false, info.append_len,
5526 int max = n_infiles;
5527 max += lang_specific_extra_outfiles;
5529 if (HAVE_GNU_LD && at_file_supplied)
5531 /* We are going to expand `%o' to `@FILE', where FILE
5532 is a newly-created temporary filename. The filenames
5533 that would usually be expanded in place of %o will be
5534 written to the temporary file. */
5539 /* Convert OUTFILES into a form suitable for writeargv. */
5541 /* Determine how many are non-NULL. */
5542 for (n_files = 0, i = 0; i < max; i++)
5543 n_files += outfiles[i] != NULL;
5545 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5547 /* Copy the strings over. */
5548 for (i = 0, j = 0; i < max; i++)
5551 argv[j] = CONST_CAST (char *, outfiles[i]);
5556 create_at_file (argv);
5559 for (i = 0; i < max; i++)
5561 store_arg (outfiles[i], 0, 0);
5566 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5571 this_is_library_file = 1;
5575 this_is_linker_script = 1;
5579 outfiles[input_file_number] = NULL;
5583 this_is_output_file = 1;
5588 int cur_index = argbuf_index;
5589 /* Handle the {...} following the %W. */
5591 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5592 p = handle_braces (p + 1);
5596 /* If any args were output, mark the last one for deletion
5598 if (argbuf_index != cur_index)
5599 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5603 /* %x{OPTION} records OPTION for %X to output. */
5609 /* Skip past the option value and make a copy. */
5611 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5614 string = save_string (p1 + 1, p - p1 - 2);
5616 /* See if we already recorded this option. */
5617 for (i = 0; i < n_linker_options; i++)
5618 if (! strcmp (string, linker_options[i]))
5624 /* This option is new; add it. */
5625 add_linker_option (string, strlen (string));
5629 /* Dump out the options accumulated previously using %x. */
5631 for (i = 0; i < n_linker_options; i++)
5633 do_spec_1 (linker_options[i], 1, NULL);
5634 /* Make each accumulated option a separate argument. */
5635 do_spec_1 (" ", 0, NULL);
5639 /* Dump out the options accumulated previously using -Wa,. */
5641 for (i = 0; i < n_assembler_options; i++)
5643 do_spec_1 (assembler_options[i], 1, NULL);
5644 /* Make each accumulated option a separate argument. */
5645 do_spec_1 (" ", 0, NULL);
5649 /* Dump out the options accumulated previously using -Wp,. */
5651 for (i = 0; i < n_preprocessor_options; i++)
5653 do_spec_1 (preprocessor_options[i], 1, NULL);
5654 /* Make each accumulated option a separate argument. */
5655 do_spec_1 (" ", 0, NULL);
5659 /* Here are digits and numbers that just process
5660 a certain constant string as a spec. */
5663 value = do_spec_1 (cc1_spec, 0, NULL);
5669 value = do_spec_1 (cc1plus_spec, 0, NULL);
5675 value = do_spec_1 (asm_spec, 0, NULL);
5681 value = do_spec_1 (asm_final_spec, 0, NULL);
5688 const char *const spec
5689 = (input_file_compiler->cpp_spec
5690 ? input_file_compiler->cpp_spec
5692 value = do_spec_1 (spec, 0, NULL);
5699 value = do_spec_1 (endfile_spec, 0, NULL);
5705 value = do_spec_1 (link_spec, 0, NULL);
5711 value = do_spec_1 (lib_spec, 0, NULL);
5717 value = do_spec_1 (libgcc_spec, 0, NULL);
5723 /* We assume there is a directory
5724 separator at the end of this string. */
5725 if (target_system_root)
5727 obstack_grow (&obstack, target_system_root,
5728 strlen (target_system_root));
5729 if (target_sysroot_suffix)
5730 obstack_grow (&obstack, target_sysroot_suffix,
5731 strlen (target_sysroot_suffix));
5736 value = do_spec_1 (startfile_spec, 0, NULL);
5741 /* Here we define characters other than letters and digits. */
5744 p = handle_braces (p);
5750 p = handle_spec_function (p);
5756 obstack_1grow (&obstack, '%');
5763 while (p[len] && p[len] != ' ' && p[len] != '%')
5765 suffix_subst = save_string (p - 1, len + 1);
5770 /* Henceforth ignore the option(s) matching the pattern
5775 int have_wildcard = 0;
5778 while (p[len] && p[len] != ' ' && p[len] != '\t')
5781 if (p[len-1] == '*')
5784 for (i = 0; i < n_switches; i++)
5785 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5786 && (have_wildcard || switches[i].part1[len] == '\0'))
5788 switches[i].live_cond |= SWITCH_IGNORE;
5789 switches[i].validated = 1;
5797 if (soft_matched_part)
5799 do_spec_1 (soft_matched_part, 1, NULL);
5800 do_spec_1 (" ", 0, NULL);
5803 /* Catch the case where a spec string contains something like
5804 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5805 hand side of the :. */
5806 error ("spec failure: '%%*' has not been initialized by pattern match");
5809 /* Process a string found as the value of a spec given by name.
5810 This feature allows individual machine descriptions
5811 to add and use their own specs.
5812 %[...] modifies -D options the way %P does;
5813 %(...) uses the spec unmodified. */
5815 error ("warning: use of obsolete %%[ operator in specs");
5818 const char *name = p;
5819 struct spec_list *sl;
5822 /* The string after the S/P is the name of a spec that is to be
5824 while (*p && *p != ')' && *p != ']')
5827 /* See if it's in the list. */
5828 for (len = p - name, sl = specs; sl; sl = sl->next)
5829 if (sl->name_len == len && !strncmp (sl->name, name, len))
5831 name = *(sl->ptr_spec);
5833 notice ("Processing spec %c%s%c, which is '%s'\n",
5834 c, sl->name, (c == '(') ? ')' : ']', name);
5843 value = do_spec_1 (name, 0, NULL);
5849 char *x = (char *) alloca (strlen (name) * 2 + 1);
5851 const char *y = name;
5854 /* Copy all of NAME into BUF, but put __ after
5855 every -D and at the end of each arg. */
5858 if (! strncmp (y, "-D", 2))
5869 && (*y == ' ' || *y == '\t' || *y == '='
5870 || *y == '}' || *y == 0))
5883 value = do_spec_1 (buf, 0, NULL);
5889 /* Discard the closing paren or bracket. */
5896 error ("spec failure: unrecognized spec option '%c'", c);
5902 /* Backslash: treat next character as ordinary. */
5907 /* Ordinary character: put it into the current argument. */
5908 obstack_1grow (&obstack, c);
5912 /* End of string. If we are processing a spec function, we need to
5913 end any pending argument. */
5914 if (processing_spec_function)
5920 /* Look up a spec function. */
5922 static const struct spec_function *
5923 lookup_spec_function (const char *name)
5925 const struct spec_function *sf;
5927 for (sf = static_spec_functions; sf->name != NULL; sf++)
5928 if (strcmp (sf->name, name) == 0)
5934 /* Evaluate a spec function. */
5937 eval_spec_function (const char *func, const char *args)
5939 const struct spec_function *sf;
5940 const char *funcval;
5942 /* Saved spec processing context. */
5943 int save_argbuf_index;
5944 int save_argbuf_length;
5945 const char **save_argbuf;
5948 int save_delete_this_arg;
5949 int save_this_is_output_file;
5950 int save_this_is_library_file;
5951 int save_input_from_pipe;
5952 int save_this_is_linker_script;
5953 const char *save_suffix_subst;
5956 sf = lookup_spec_function (func);
5958 fatal ("unknown spec function '%s'", func);
5960 /* Push the spec processing context. */
5961 save_argbuf_index = argbuf_index;
5962 save_argbuf_length = argbuf_length;
5963 save_argbuf = argbuf;
5965 save_arg_going = arg_going;
5966 save_delete_this_arg = delete_this_arg;
5967 save_this_is_output_file = this_is_output_file;
5968 save_this_is_library_file = this_is_library_file;
5969 save_this_is_linker_script = this_is_linker_script;
5970 save_input_from_pipe = input_from_pipe;
5971 save_suffix_subst = suffix_subst;
5973 /* Create a new spec processing context, and build the function
5977 if (do_spec_2 (args) < 0)
5978 fatal ("error in args to spec function '%s'", func);
5980 /* argbuf_index is an index for the next argument to be inserted, and
5981 so contains the count of the args already inserted. */
5983 funcval = (*sf->func) (argbuf_index, argbuf);
5985 /* Pop the spec processing context. */
5986 argbuf_index = save_argbuf_index;
5987 argbuf_length = save_argbuf_length;
5989 argbuf = save_argbuf;
5991 arg_going = save_arg_going;
5992 delete_this_arg = save_delete_this_arg;
5993 this_is_output_file = save_this_is_output_file;
5994 this_is_library_file = save_this_is_library_file;
5995 this_is_linker_script = save_this_is_linker_script;
5996 input_from_pipe = save_input_from_pipe;
5997 suffix_subst = save_suffix_subst;
6002 /* Handle a spec function call of the form:
6006 ARGS is processed as a spec in a separate context and split into an
6007 argument vector in the normal fashion. The function returns a string
6008 containing a spec which we then process in the caller's context, or
6009 NULL if no processing is required. */
6012 handle_spec_function (const char *p)
6015 const char *endp, *funcval;
6018 processing_spec_function++;
6020 /* Get the function name. */
6021 for (endp = p; *endp != '\0'; endp++)
6023 if (*endp == '(') /* ) */
6025 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6026 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6027 fatal ("malformed spec function name");
6029 if (*endp != '(') /* ) */
6030 fatal ("no arguments for spec function");
6031 func = save_string (p, endp - p);
6034 /* Get the arguments. */
6035 for (count = 0; *endp != '\0'; endp++)
6044 else if (*endp == '(') /* ) */
6049 fatal ("malformed spec function arguments");
6050 args = save_string (p, endp - p);
6053 /* p now points to just past the end of the spec function expression. */
6055 funcval = eval_spec_function (func, args);
6056 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6062 processing_spec_function--;
6067 /* Inline subroutine of handle_braces. Returns true if the current
6068 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6070 input_suffix_matches (const char *atom, const char *end_atom)
6072 return (input_suffix
6073 && !strncmp (input_suffix, atom, end_atom - atom)
6074 && input_suffix[end_atom - atom] == '\0');
6077 /* Subroutine of handle_braces. Returns true if the current
6078 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6080 input_spec_matches (const char *atom, const char *end_atom)
6082 return (input_file_compiler
6083 && input_file_compiler->suffix
6084 && input_file_compiler->suffix[0] != '\0'
6085 && !strncmp (input_file_compiler->suffix + 1, atom,
6087 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6090 /* Subroutine of handle_braces. Returns true if a switch
6091 matching the atom bracketed by ATOM and END_ATOM appeared on the
6094 switch_matches (const char *atom, const char *end_atom, int starred)
6097 int len = end_atom - atom;
6098 int plen = starred ? len : -1;
6100 for (i = 0; i < n_switches; i++)
6101 if (!strncmp (switches[i].part1, atom, len)
6102 && (starred || switches[i].part1[len] == '\0')
6103 && check_live_switch (i, plen))
6109 /* Inline subroutine of handle_braces. Mark all of the switches which
6110 match ATOM (extends to END_ATOM; STARRED indicates whether there
6111 was a star after the atom) for later processing. */
6113 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6116 int len = end_atom - atom;
6117 int plen = starred ? len : -1;
6119 for (i = 0; i < n_switches; i++)
6120 if (!strncmp (switches[i].part1, atom, len)
6121 && (starred || switches[i].part1[len] == '\0')
6122 && check_live_switch (i, plen))
6123 switches[i].ordering = 1;
6126 /* Inline subroutine of handle_braces. Process all the currently
6127 marked switches through give_switch, and clear the marks. */
6129 process_marked_switches (void)
6133 for (i = 0; i < n_switches; i++)
6134 if (switches[i].ordering == 1)
6136 switches[i].ordering = 0;
6141 /* Handle a %{ ... } construct. P points just inside the leading {.
6142 Returns a pointer one past the end of the brace block, or 0
6143 if we call do_spec_1 and that returns -1. */
6146 handle_braces (const char *p)
6148 const char *atom, *end_atom;
6149 const char *d_atom = NULL, *d_end_atom = NULL;
6150 const char *orig = p;
6158 bool a_must_be_last = false;
6159 bool ordered_set = false;
6160 bool disjunct_set = false;
6161 bool disj_matched = false;
6162 bool disj_starred = true;
6163 bool n_way_choice = false;
6164 bool n_way_matched = false;
6166 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6173 /* Scan one "atom" (S in the description above of %{}, possibly
6174 with '!', '.', '@', ',', or '*' modifiers). */
6176 a_is_suffix = false;
6177 a_is_starred = false;
6178 a_is_negated = false;
6179 a_is_spectype = false;
6183 p++, a_is_negated = true;
6187 p++, a_is_suffix = true;
6189 p++, a_is_spectype = true;
6192 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6193 || *p == ',' || *p == '.' || *p == '@')
6198 p++, a_is_starred = 1;
6204 /* Substitute the switch(es) indicated by the current atom. */
6206 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6207 || a_is_spectype || atom == end_atom)
6210 mark_matching_switches (atom, end_atom, a_is_starred);
6213 process_marked_switches ();
6217 /* Substitute some text if the current atom appears as a switch
6219 disjunct_set = true;
6223 if (atom == end_atom)
6225 if (!n_way_choice || disj_matched || *p == '|'
6226 || a_is_negated || a_is_suffix || a_is_spectype
6230 /* An empty term may appear as the last choice of an
6231 N-way choice set; it means "otherwise". */
6232 a_must_be_last = true;
6233 disj_matched = !n_way_matched;
6234 disj_starred = false;
6238 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6242 disj_starred = false;
6244 /* Don't bother testing this atom if we already have a
6246 if (!disj_matched && !n_way_matched)
6249 a_matched = input_suffix_matches (atom, end_atom);
6250 else if (a_is_spectype)
6251 a_matched = input_spec_matches (atom, end_atom);
6253 a_matched = switch_matches (atom, end_atom, a_is_starred);
6255 if (a_matched != a_is_negated)
6257 disj_matched = true;
6259 d_end_atom = end_atom;
6266 /* Found the body, that is, the text to substitute if the
6267 current disjunction matches. */
6268 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6269 disj_matched && !n_way_matched);
6273 /* If we have an N-way choice, reset state for the next
6277 n_way_choice = true;
6278 n_way_matched |= disj_matched;
6279 disj_matched = false;
6280 disj_starred = true;
6281 d_atom = d_end_atom = NULL;
6290 while (*p++ != '}');
6295 fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6300 /* Subroutine of handle_braces. Scan and process a brace substitution body
6301 (X in the description of %{} syntax). P points one past the colon;
6302 ATOM and END_ATOM bracket the first atom which was found to be true
6303 (present) in the current disjunction; STARRED indicates whether all
6304 the atoms in the current disjunction were starred (for syntax validation);
6305 MATCHED indicates whether the disjunction matched or not, and therefore
6306 whether or not the body is to be processed through do_spec_1 or just
6307 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6311 process_brace_body (const char *p, const char *atom, const char *end_atom,
6312 int starred, int matched)
6314 const char *body, *end_body;
6315 unsigned int nesting_level;
6316 bool have_subst = false;
6318 /* Locate the closing } or ;, honoring nested braces.
6319 Trim trailing whitespace. */
6328 if (!--nesting_level)
6331 else if (*p == ';' && nesting_level == 1)
6333 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6335 else if (*p == '\0')
6341 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6344 if (have_subst && !starred)
6349 /* Copy the substitution body to permanent storage and execute it.
6350 If have_subst is false, this is a simple matter of running the
6351 body through do_spec_1... */
6352 char *string = save_string (body, end_body - body);
6355 if (do_spec_1 (string, 0, NULL) < 0)
6360 /* ... but if have_subst is true, we have to process the
6361 body once for each matching switch, with %* set to the
6362 variant part of the switch. */
6363 unsigned int hard_match_len = end_atom - atom;
6366 for (i = 0; i < n_switches; i++)
6367 if (!strncmp (switches[i].part1, atom, hard_match_len)
6368 && check_live_switch (i, hard_match_len))
6370 if (do_spec_1 (string, 0,
6371 &switches[i].part1[hard_match_len]) < 0)
6373 /* Pass any arguments this switch has. */
6375 suffix_subst = NULL;
6383 fatal ("braced spec body '%s' is invalid", body);
6386 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6387 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6388 spec, or -1 if either exact match or %* is used.
6390 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6391 whose value does not begin with "no-" is obsoleted by the same value
6392 with the "no-", similarly for a switch with the "no-" prefix. */
6395 check_live_switch (int switchnum, int prefix_length)
6397 const char *name = switches[switchnum].part1;
6400 /* If we already processed this switch and determined if it was
6401 live or not, return our past determination. */
6402 if (switches[switchnum].live_cond != 0)
6403 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6404 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6405 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6408 /* In the common case of {<at-most-one-letter>*}, a negating
6409 switch would always match, so ignore that case. We will just
6410 send the conflicting switches to the compiler phase. */
6411 if (prefix_length >= 0 && prefix_length <= 1)
6414 /* Now search for duplicate in a manner that depends on the name. */
6418 for (i = switchnum + 1; i < n_switches; i++)
6419 if (switches[i].part1[0] == 'O')
6421 switches[switchnum].validated = 1;
6422 switches[switchnum].live_cond = SWITCH_FALSE;
6427 case 'W': case 'f': case 'm':
6428 if (! strncmp (name + 1, "no-", 3))
6430 /* We have Xno-YYY, search for XYYY. */
6431 for (i = switchnum + 1; i < n_switches; i++)
6432 if (switches[i].part1[0] == name[0]
6433 && ! strcmp (&switches[i].part1[1], &name[4]))
6435 switches[switchnum].validated = 1;
6436 switches[switchnum].live_cond = SWITCH_FALSE;
6442 /* We have XYYY, search for Xno-YYY. */
6443 for (i = switchnum + 1; i < n_switches; i++)
6444 if (switches[i].part1[0] == name[0]
6445 && switches[i].part1[1] == 'n'
6446 && switches[i].part1[2] == 'o'
6447 && switches[i].part1[3] == '-'
6448 && !strcmp (&switches[i].part1[4], &name[1]))
6450 switches[switchnum].validated = 1;
6451 switches[switchnum].live_cond = SWITCH_FALSE;
6458 /* Otherwise the switch is live. */
6459 switches[switchnum].live_cond |= SWITCH_LIVE;
6463 /* Pass a switch to the current accumulating command
6464 in the same form that we received it.
6465 SWITCHNUM identifies the switch; it is an index into
6466 the vector of switches gcc received, which is `switches'.
6467 This cannot fail since it never finishes a command line.
6469 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6472 give_switch (int switchnum, int omit_first_word)
6474 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6477 if (!omit_first_word)
6479 do_spec_1 ("-", 0, NULL);
6480 do_spec_1 (switches[switchnum].part1, 1, NULL);
6483 if (switches[switchnum].args != 0)
6486 for (p = switches[switchnum].args; *p; p++)
6488 const char *arg = *p;
6490 do_spec_1 (" ", 0, NULL);
6493 unsigned length = strlen (arg);
6496 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6497 if (arg[length] == '.')
6499 (CONST_CAST(char *, arg))[length] = 0;
6503 do_spec_1 (arg, 1, NULL);
6505 (CONST_CAST(char *, arg))[length] = '.';
6506 do_spec_1 (suffix_subst, 1, NULL);
6509 do_spec_1 (arg, 1, NULL);
6513 do_spec_1 (" ", 0, NULL);
6514 switches[switchnum].validated = 1;
6517 /* Search for a file named NAME trying various prefixes including the
6518 user's -B prefix and some standard ones.
6519 Return the absolute file name found. If nothing is found, return NAME. */
6522 find_file (const char *name)
6524 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6525 return newname ? newname : name;
6528 /* Determine whether a directory exists. If LINKER, return 0 for
6529 certain fixed names not needed by the linker. */
6532 is_directory (const char *path1, bool linker)
6539 /* Ensure the string ends with "/.". The resulting path will be a
6540 directory even if the given path is a symbolic link. */
6541 len1 = strlen (path1);
6542 path = (char *) alloca (3 + len1);
6543 memcpy (path, path1, len1);
6545 if (!IS_DIR_SEPARATOR (cp[-1]))
6546 *cp++ = DIR_SEPARATOR;
6550 /* Exclude directories that the linker is known to search. */
6552 && IS_DIR_SEPARATOR (path[0])
6554 && strncmp (path + 1, "lib", 3) == 0)
6556 && strncmp (path + 1, "usr", 3) == 0
6557 && IS_DIR_SEPARATOR (path[4])
6558 && strncmp (path + 5, "lib", 3) == 0)))
6561 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6564 /* Set up the various global variables to indicate that we're processing
6565 the input file named FILENAME. */
6568 set_input (const char *filename)
6572 input_filename = filename;
6573 input_filename_length = strlen (input_filename);
6574 input_basename = lbasename (input_filename);
6576 /* Find a suffix starting with the last period,
6577 and set basename_length to exclude that suffix. */
6578 basename_length = strlen (input_basename);
6579 suffixed_basename_length = basename_length;
6580 p = input_basename + basename_length;
6581 while (p != input_basename && *p != '.')
6583 if (*p == '.' && p != input_basename)
6585 basename_length = p - input_basename;
6586 input_suffix = p + 1;
6591 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6592 we will need to do a stat on the input_filename. The
6593 INPUT_STAT_SET signals that the stat is needed. */
6597 /* On fatal signals, delete all the temporary files. */
6600 fatal_error (int signum)
6602 signal (signum, SIG_DFL);
6603 delete_failure_queue ();
6604 delete_temp_files ();
6605 /* Get the same signal again, this time not handled,
6606 so its normal effect occurs. */
6607 kill (getpid (), signum);
6610 /* Compare the contents of the two files named CMPFILE[0] and
6611 CMPFILE[1]. Return zero if they're identical, nonzero
6615 compare_files (char *cmpfile[])
6618 FILE *temp[2] = { NULL, NULL };
6624 void *map[2] = { NULL, NULL };
6626 for (i = 0; i < 2; i++)
6630 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6632 error ("%s: could not determine length of compare-debug file %s",
6633 input_filename, cmpfile[i]);
6638 length[i] = st.st_size;
6641 if (!ret && length[0] != length[1])
6643 error ("%s: -fcompare-debug failure (length)", input_filename);
6648 for (i = 0; i < 2; i++)
6650 int fd = open (cmpfile[i], O_RDONLY);
6653 error ("%s: could not open compare-debug file %s",
6654 input_filename, cmpfile[i]);
6659 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6662 if (map[i] == (void *) MAP_FAILED)
6671 if (memcmp (map[0], map[1], length[0]) != 0)
6673 error ("%s: -fcompare-debug failure", input_filename);
6678 for (i = 0; i < 2; i++)
6680 munmap ((caddr_t) map[i], length[i]);
6689 for (i = 0; i < 2; i++)
6691 temp[i] = fopen (cmpfile[i], "r");
6694 error ("%s: could not open compare-debug file %s",
6695 input_filename, cmpfile[i]);
6701 if (!ret && temp[0] && temp[1])
6705 c0 = fgetc (temp[0]);
6706 c1 = fgetc (temp[1]);
6710 error ("%s: -fcompare-debug failure",
6720 for (i = 1; i >= 0; i--)
6729 extern int main (int, char **);
6732 main (int argc, char **argv)
6736 int linker_was_run = 0;
6737 int lang_n_infiles = 0;
6738 int num_linker_inputs = 0;
6739 char *explicit_link_files;
6742 struct user_specs *uptr;
6743 char **old_argv = argv;
6745 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6746 on ?: in file-scope variable initializations. */
6747 asm_debug = ASM_DEBUG_SPEC;
6749 p = argv[0] + strlen (argv[0]);
6750 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6754 xmalloc_set_program_name (programname);
6756 expandargv (&argc, &argv);
6758 /* Determine if any expansions were made. */
6759 if (argv != old_argv)
6760 at_file_supplied = true;
6762 prune_options (&argc, &argv);
6764 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6765 /* Perform host dependent initialization when needed. */
6766 GCC_DRIVER_HOST_INITIALIZATION;
6769 /* Unlock the stdio streams. */
6770 unlock_std_streams ();
6772 gcc_init_libintl ();
6774 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6775 signal (SIGINT, fatal_error);
6777 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6778 signal (SIGHUP, fatal_error);
6780 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6781 signal (SIGTERM, fatal_error);
6783 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6784 signal (SIGPIPE, fatal_error);
6787 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6788 receive the signal. A different setting is inheritable */
6789 signal (SIGCHLD, SIG_DFL);
6792 /* Allocate the argument vector. */
6795 obstack_init (&obstack);
6797 /* Build multilib_select, et. al from the separate lines that make up each
6798 multilib selection. */
6800 const char *const *q = multilib_raw;
6803 obstack_init (&multilib_obstack);
6804 while ((p = *q++) != (char *) 0)
6805 obstack_grow (&multilib_obstack, p, strlen (p));
6807 obstack_1grow (&multilib_obstack, 0);
6808 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6810 q = multilib_matches_raw;
6811 while ((p = *q++) != (char *) 0)
6812 obstack_grow (&multilib_obstack, p, strlen (p));
6814 obstack_1grow (&multilib_obstack, 0);
6815 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6817 q = multilib_exclusions_raw;
6818 while ((p = *q++) != (char *) 0)
6819 obstack_grow (&multilib_obstack, p, strlen (p));
6821 obstack_1grow (&multilib_obstack, 0);
6822 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6825 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6828 obstack_1grow (&multilib_obstack, ' ');
6829 obstack_grow (&multilib_obstack,
6830 multilib_defaults_raw[i],
6831 strlen (multilib_defaults_raw[i]));
6835 obstack_1grow (&multilib_obstack, 0);
6836 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6839 #ifdef INIT_ENVIRONMENT
6840 /* Set up any other necessary machine specific environment variables. */
6841 xputenv (INIT_ENVIRONMENT);
6844 /* Make a table of what switches there are (switches, n_switches).
6845 Make a table of specified input files (infiles, n_infiles).
6846 Decode switches that are handled locally. */
6848 process_command (argc, CONST_CAST2 (const char **, char **, argv));
6850 /* Initialize the vector of specs to just the default.
6851 This means one element containing 0s, as a terminator. */
6853 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6854 memcpy (compilers, default_compilers, sizeof default_compilers);
6855 n_compilers = n_default_compilers;
6857 /* Read specs from a file if there is one. */
6859 machine_suffix = concat (spec_machine, dir_separator_str,
6860 spec_version, dir_separator_str, NULL);
6861 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6863 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6864 /* Read the specs file unless it is a default one. */
6865 if (specs_file != 0 && strcmp (specs_file, "specs"))
6866 read_specs (specs_file, TRUE);
6870 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6871 for any override of as, ld and libraries. */
6872 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6873 + strlen (just_machine_suffix) + sizeof ("specs"));
6875 strcpy (specs_file, standard_exec_prefix);
6876 strcat (specs_file, just_machine_suffix);
6877 strcat (specs_file, "specs");
6878 if (access (specs_file, R_OK) == 0)
6879 read_specs (specs_file, TRUE);
6881 /* Process any configure-time defaults specified for the command line
6882 options, via OPTION_DEFAULT_SPECS. */
6883 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6884 do_option_spec (option_default_specs[i].name,
6885 option_default_specs[i].spec);
6887 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6888 of the command line. */
6890 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6891 do_self_spec (driver_self_specs[i]);
6895 enum save_temps save;
6897 if (!compare_debug_second)
6899 n_switches_debug_check[1] = n_switches;
6900 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6903 do_self_spec ("%:compare-debug-self-opt()");
6904 n_switches_debug_check[0] = n_switches;
6905 switches_debug_check[0] = switches;
6907 n_switches = n_switches_debug_check[1];
6908 switches = switches_debug_check[1];
6911 /* Avoid crash when computing %j in this early. */
6912 save = save_temps_flag;
6913 save_temps_flag = SAVE_TEMPS_NONE;
6915 compare_debug = -compare_debug;
6916 do_self_spec ("%:compare-debug-self-opt()");
6918 save_temps_flag = save;
6920 if (!compare_debug_second)
6922 n_switches_debug_check[1] = n_switches;
6923 switches_debug_check[1] = switches;
6924 compare_debug = -compare_debug;
6925 n_switches = n_switches_debug_check[0];
6926 switches = switches_debug_check[0];
6930 /* If not cross-compiling, look for executables in the standard
6932 if (*cross_compile == '0')
6934 if (*md_exec_prefix)
6936 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6937 PREFIX_PRIORITY_LAST, 0, 0);
6941 /* Process sysroot_suffix_spec. */
6942 if (*sysroot_suffix_spec != 0
6943 && do_spec_2 (sysroot_suffix_spec) == 0)
6945 if (argbuf_index > 1)
6946 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6947 else if (argbuf_index == 1)
6948 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6951 #ifdef HAVE_LD_SYSROOT
6952 /* Pass the --sysroot option to the linker, if it supports that. If
6953 there is a sysroot_suffix_spec, it has already been processed by
6954 this point, so target_system_root really is the system root we
6956 if (target_system_root)
6958 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6959 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6960 set_spec ("link", XOBFINISH (&obstack, const char *));
6964 /* Process sysroot_hdrs_suffix_spec. */
6965 if (*sysroot_hdrs_suffix_spec != 0
6966 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6968 if (argbuf_index > 1)
6969 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6970 else if (argbuf_index == 1)
6971 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6974 /* Look for startfiles in the standard places. */
6975 if (*startfile_prefix_spec != 0
6976 && do_spec_2 (startfile_prefix_spec) == 0
6977 && do_spec_1 (" ", 0, NULL) == 0)
6980 for (ndx = 0; ndx < argbuf_index; ndx++)
6981 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6982 PREFIX_PRIORITY_LAST, 0, 1);
6984 /* We should eventually get rid of all these and stick to
6985 startfile_prefix_spec exclusively. */
6986 else if (*cross_compile == '0' || target_system_root)
6988 if (*md_startfile_prefix)
6989 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6990 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6992 if (*md_startfile_prefix_1)
6993 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6994 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6996 /* If standard_startfile_prefix is relative, base it on
6997 standard_exec_prefix. This lets us move the installed tree
6998 as a unit. If GCC_EXEC_PREFIX is defined, base
6999 standard_startfile_prefix on that as well.
7001 If the prefix is relative, only search it for native compilers;
7002 otherwise we will search a directory containing host libraries. */
7003 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7004 add_sysrooted_prefix (&startfile_prefixes,
7005 standard_startfile_prefix, "BINUTILS",
7006 PREFIX_PRIORITY_LAST, 0, 1);
7007 else if (*cross_compile == '0')
7009 add_prefix (&startfile_prefixes,
7010 concat (gcc_exec_prefix
7011 ? gcc_exec_prefix : standard_exec_prefix,
7013 standard_startfile_prefix, NULL),
7014 NULL, PREFIX_PRIORITY_LAST, 0, 1);
7017 /* Sysrooted prefixes are relocated because target_system_root is
7018 also relocated by gcc_exec_prefix. */
7019 if (*standard_startfile_prefix_1)
7020 add_sysrooted_prefix (&startfile_prefixes,
7021 standard_startfile_prefix_1, "BINUTILS",
7022 PREFIX_PRIORITY_LAST, 0, 1);
7023 if (*standard_startfile_prefix_2)
7024 add_sysrooted_prefix (&startfile_prefixes,
7025 standard_startfile_prefix_2, "BINUTILS",
7026 PREFIX_PRIORITY_LAST, 0, 1);
7029 /* Process any user specified specs in the order given on the command
7031 for (uptr = user_specs_head; uptr; uptr = uptr->next)
7033 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7035 read_specs (filename ? filename : uptr->filename, FALSE);
7038 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7039 if (gcc_exec_prefix)
7040 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7041 spec_version, dir_separator_str, NULL);
7043 /* Now we have the specs.
7044 Set the `valid' bits for switches that match anything in any spec. */
7046 validate_all_switches ();
7048 /* Now that we have the switches and the specs, set
7049 the subdirectory based on the options. */
7050 set_multilib_dir ();
7052 /* Set up to remember the pathname of gcc and any options
7053 needed for collect. We use argv[0] instead of programname because
7054 we need the complete pathname. */
7055 obstack_init (&collect_obstack);
7056 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7057 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7058 xputenv (XOBFINISH (&collect_obstack, char *));
7060 /* Set up to remember the pathname of the lto wrapper. */
7062 lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7063 if (lto_wrapper_spec)
7065 obstack_init (&collect_obstack);
7066 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7067 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7068 obstack_grow (&collect_obstack, lto_wrapper_spec,
7069 strlen (lto_wrapper_spec) + 1);
7070 xputenv (XOBFINISH (&collect_obstack, char *));
7073 /* Warn about any switches that no pass was interested in. */
7075 for (i = 0; (int) i < n_switches; i++)
7076 if (! switches[i].validated)
7077 error ("unrecognized option '-%s'", switches[i].part1);
7079 /* Obey some of the options. */
7081 if (print_search_dirs)
7083 printf (_("install: %s%s\n"),
7084 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7085 gcc_exec_prefix ? "" : machine_suffix);
7086 printf (_("programs: %s\n"),
7087 build_search_list (&exec_prefixes, "", false, false));
7088 printf (_("libraries: %s\n"),
7089 build_search_list (&startfile_prefixes, "", false, true));
7093 if (print_file_name)
7095 printf ("%s\n", find_file (print_file_name));
7099 if (print_prog_name)
7101 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7102 printf ("%s\n", (newname ? newname : print_prog_name));
7106 if (print_multi_lib)
7108 print_multilib_info ();
7112 if (print_multi_directory)
7114 if (multilib_dir == NULL)
7117 printf ("%s\n", multilib_dir);
7123 if (target_system_root)
7125 if (target_sysroot_suffix)
7126 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7128 printf ("%s\n", target_system_root);
7133 if (print_multi_os_directory)
7135 if (multilib_os_dir == NULL)
7138 printf ("%s\n", multilib_os_dir);
7142 if (print_sysroot_headers_suffix)
7144 if (*sysroot_hdrs_suffix_spec)
7146 printf("%s\n", (target_sysroot_hdrs_suffix
7147 ? target_sysroot_hdrs_suffix
7152 /* The error status indicates that only one set of fixed
7153 headers should be built. */
7154 fatal ("not configured with sysroot headers suffix");
7157 if (print_help_list)
7163 printf (_("\nFor bug reporting instructions, please see:\n"));
7164 printf ("%s.\n", bug_report_url);
7169 /* We do not exit here. Instead we have created a fake input file
7170 called 'help-dummy' which needs to be compiled, and we pass this
7171 on the various sub-processes, along with the --help switch.
7172 Ensure their output appears after ours. */
7173 fputc ('\n', stdout);
7179 printf (_("%s %s%s\n"), programname, pkgversion_string,
7181 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7183 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7184 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7189 /* We do not exit here. We use the same mechanism of --help to print
7190 the version of the sub-processes. */
7191 fputc ('\n', stdout);
7200 notice ("Target: %s\n", spec_machine);
7201 notice ("Configured with: %s\n", configuration_arguments);
7203 #ifdef THREAD_MODEL_SPEC
7204 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7205 but there's no point in doing all this processing just to get
7206 thread_model back. */
7207 obstack_init (&obstack);
7208 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7209 obstack_1grow (&obstack, '\0');
7210 thrmod = XOBFINISH (&obstack, const char *);
7212 thrmod = thread_model;
7215 notice ("Thread model: %s\n", thrmod);
7217 /* compiler_version is truncated at the first space when initialized
7218 from version string, so truncate version_string at the first space
7219 before comparing. */
7220 for (n = 0; version_string[n]; n++)
7221 if (version_string[n] == ' ')
7224 if (! strncmp (version_string, compiler_version, n)
7225 && compiler_version[n] == 0)
7226 notice ("gcc version %s %s\n", version_string, pkgversion_string);
7228 notice ("gcc driver version %s %sexecuting gcc version %s\n",
7229 version_string, pkgversion_string, compiler_version);
7235 if (n_infiles == added_libraries)
7236 fatal ("no input files");
7238 /* Make a place to record the compiler output file names
7239 that correspond to the input files. */
7242 i += lang_specific_extra_outfiles;
7243 outfiles = XCNEWVEC (const char *, i);
7245 /* Record which files were specified explicitly as link input. */
7247 explicit_link_files = XCNEWVEC (char, n_infiles);
7250 combine_inputs = true;
7252 combine_inputs = false;
7254 for (i = 0; (int) i < n_infiles; i++)
7256 const char *name = infiles[i].name;
7257 struct compiler *compiler = lookup_compiler (name,
7259 infiles[i].language);
7261 if (compiler && !(compiler->combinable))
7262 combine_inputs = false;
7264 if (lang_n_infiles > 0 && compiler != input_file_compiler
7265 && infiles[i].language && infiles[i].language[0] != '*')
7266 infiles[i].incompiler = compiler;
7270 input_file_compiler = compiler;
7271 infiles[i].incompiler = compiler;
7275 /* Since there is no compiler for this input file, assume it is a
7277 explicit_link_files[i] = 1;
7278 infiles[i].incompiler = NULL;
7280 infiles[i].compiled = false;
7281 infiles[i].preprocessed = false;
7284 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7285 fatal ("cannot specify -o with -c, -S or -E with multiple files");
7287 if (combine_flag && save_temps_flag)
7289 bool save_combine_inputs = combine_inputs;
7290 /* Must do a separate pre-processing pass for C & Objective-C files, to
7291 obtain individual .i files. */
7293 combine_inputs = false;
7294 for (i = 0; (int) i < n_infiles; i++)
7296 int this_file_error = 0;
7298 input_file_number = i;
7299 set_input (infiles[i].name);
7300 if (infiles[i].incompiler
7301 && (infiles[i].incompiler)->needs_preprocessing)
7302 input_file_compiler = infiles[i].incompiler;
7306 if (input_file_compiler)
7308 if (input_file_compiler->spec[0] == '#')
7310 error ("%s: %s compiler not installed on this system",
7311 input_filename, &input_file_compiler->spec[1]);
7312 this_file_error = 1;
7316 value = do_spec (input_file_compiler->spec);
7317 infiles[i].preprocessed = true;
7318 if (!have_o_argbuf_index)
7319 fatal ("spec '%s' is invalid", input_file_compiler->spec);
7320 infiles[i].name = argbuf[have_o_argbuf_index];
7321 infiles[i].incompiler
7322 = lookup_compiler (infiles[i].name,
7323 strlen (infiles[i].name),
7324 infiles[i].language);
7327 this_file_error = 1;
7331 if (this_file_error)
7333 delete_failure_queue ();
7337 clear_failure_queue ();
7339 combine_inputs = save_combine_inputs;
7342 for (i = 0; (int) i < n_infiles; i++)
7344 int this_file_error = 0;
7346 /* Tell do_spec what to substitute for %i. */
7348 input_file_number = i;
7349 set_input (infiles[i].name);
7351 if (infiles[i].compiled)
7354 /* Use the same thing in %o, unless cp->spec says otherwise. */
7356 outfiles[i] = input_filename;
7358 /* Figure out which compiler from the file's suffix. */
7360 if (! combine_inputs)
7362 = lookup_compiler (infiles[i].name, input_filename_length,
7363 infiles[i].language);
7365 input_file_compiler = infiles[i].incompiler;
7367 if (input_file_compiler)
7369 /* Ok, we found an applicable compiler. Run its spec. */
7371 if (input_file_compiler->spec[0] == '#')
7373 error ("%s: %s compiler not installed on this system",
7374 input_filename, &input_file_compiler->spec[1]);
7375 this_file_error = 1;
7381 if (debug_check_temp_file[0])
7382 free (debug_check_temp_file[0]);
7383 debug_check_temp_file[0] = NULL;
7385 if (debug_check_temp_file[1])
7386 free (debug_check_temp_file[1]);
7387 debug_check_temp_file[1] = NULL;
7390 value = do_spec (input_file_compiler->spec);
7391 infiles[i].compiled = true;
7393 this_file_error = 1;
7394 else if (compare_debug && debug_check_temp_file[0])
7397 error ("Recompiling with -fcompare-debug");
7399 compare_debug = -compare_debug;
7400 n_switches = n_switches_debug_check[1];
7401 switches = switches_debug_check[1];
7403 value = do_spec (input_file_compiler->spec);
7405 compare_debug = -compare_debug;
7406 n_switches = n_switches_debug_check[0];
7407 switches = switches_debug_check[0];
7411 error ("during -fcompare-debug recompilation");
7412 this_file_error = 1;
7415 gcc_assert (debug_check_temp_file[1]
7416 && strcmp (debug_check_temp_file[0],
7417 debug_check_temp_file[1]));
7420 error ("Comparing final insns dumps");
7422 if (compare_files (debug_check_temp_file))
7423 this_file_error = 1;
7428 if (debug_check_temp_file[0])
7429 free (debug_check_temp_file[0]);
7430 debug_check_temp_file[0] = NULL;
7432 if (debug_check_temp_file[1])
7433 free (debug_check_temp_file[1]);
7434 debug_check_temp_file[1] = NULL;
7439 /* If this file's name does not contain a recognized suffix,
7440 record it as explicit linker input. */
7443 explicit_link_files[i] = 1;
7445 /* Clear the delete-on-failure queue, deleting the files in it
7446 if this compilation failed. */
7448 if (this_file_error)
7450 delete_failure_queue ();
7453 /* If this compilation succeeded, don't delete those files later. */
7454 clear_failure_queue ();
7457 /* Reset the input file name to the first compile/object file name, for use
7458 with %b in LINK_SPEC. We use the first input file that we can find
7459 a compiler to compile it instead of using infiles.language since for
7460 languages other than C we use aliases that we then lookup later. */
7465 for (i = 0; i < n_infiles ; i++)
7466 if (infiles[i].language && infiles[i].language[0] != '*')
7468 set_input (infiles[i].name);
7473 if (error_count == 0)
7475 /* Make sure INPUT_FILE_NUMBER points to first available open
7477 input_file_number = n_infiles;
7478 if (lang_specific_pre_link ())
7482 /* Determine if there are any linker input files. */
7483 num_linker_inputs = 0;
7484 for (i = 0; (int) i < n_infiles; i++)
7485 if (explicit_link_files[i] || outfiles[i] != NULL)
7486 num_linker_inputs++;
7488 /* Run ld to link all the compiler output files. */
7490 if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7492 int tmp = execution_count;
7493 const char *fuse_linker_plugin = "fuse-linker-plugin";
7495 /* We'll use ld if we can't find collect2. */
7496 if (! strcmp (linker_name_spec, "collect2"))
7498 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7500 linker_name_spec = "ld";
7503 if (switch_matches (fuse_linker_plugin,
7504 fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7506 linker_plugin_file_spec = find_a_file (&exec_prefixes,
7507 "liblto_plugin.so", R_OK,
7509 if (!linker_plugin_file_spec)
7510 fatal ("-fuse-linker-plugin, but liblto_plugin.so not found");
7512 lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7514 if (!lto_libgcc_spec)
7515 fatal ("could not find libgcc.a");
7517 lto_gcc_spec = argv[0];
7519 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7521 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7522 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7524 if (print_subprocess_help == 1)
7526 printf (_("\nLinker options\n==============\n\n"));
7527 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7528 " to the linker.\n\n"));
7531 value = do_spec (link_command_spec);
7534 linker_was_run = (tmp != execution_count);
7537 /* If options said don't run linker,
7538 complain about input files to be given to the linker. */
7540 if (! linker_was_run && error_count == 0)
7541 for (i = 0; (int) i < n_infiles; i++)
7542 if (explicit_link_files[i]
7543 && !(infiles[i].language && infiles[i].language[0] == '*'))
7544 error ("%s: linker input file unused because linking not done",
7547 /* Delete some or all of the temporary files we made. */
7550 delete_failure_queue ();
7551 delete_temp_files ();
7553 if (print_help_list)
7555 printf (("\nFor bug reporting instructions, please see:\n"));
7556 printf ("%s\n", bug_report_url);
7559 return (signal_count != 0 ? 2
7560 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7564 /* Find the proper compilation spec for the file name NAME,
7565 whose length is LENGTH. LANGUAGE is the specified language,
7566 or 0 if this file is to be passed to the linker. */
7568 static struct compiler *
7569 lookup_compiler (const char *name, size_t length, const char *language)
7571 struct compiler *cp;
7573 /* If this was specified by the user to be a linker input, indicate that. */
7574 if (language != 0 && language[0] == '*')
7577 /* Otherwise, look for the language, if one is spec'd. */
7580 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7581 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7584 error ("language %s not recognized", language);
7588 /* Look for a suffix. */
7589 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7591 if (/* The suffix `-' matches only the file name `-'. */
7592 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7593 || (strlen (cp->suffix) < length
7594 /* See if the suffix matches the end of NAME. */
7595 && !strcmp (cp->suffix,
7596 name + length - strlen (cp->suffix))
7601 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7602 /* Look again, but case-insensitively this time. */
7604 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7606 if (/* The suffix `-' matches only the file name `-'. */
7607 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7608 || (strlen (cp->suffix) < length
7609 /* See if the suffix matches the end of NAME. */
7610 && ((!strcmp (cp->suffix,
7611 name + length - strlen (cp->suffix))
7612 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7613 && !strcasecmp (cp->suffix,
7614 name + length - strlen (cp->suffix)))
7620 if (cp >= compilers)
7622 if (cp->spec[0] != '@')
7623 /* A non-alias entry: return it. */
7626 /* An alias entry maps a suffix to a language.
7627 Search for the language; pass 0 for NAME and LENGTH
7628 to avoid infinite recursion if language not found. */
7629 return lookup_compiler (NULL, 0, cp->spec + 1);
7635 save_string (const char *s, int len)
7637 char *result = XNEWVEC (char, len + 1);
7639 memcpy (result, s, len);
7645 pfatal_with_name (const char *name)
7647 perror_with_name (name);
7648 delete_temp_files ();
7653 perror_with_name (const char *name)
7655 error ("%s: %s", name, xstrerror (errno));
7658 /* Output an error message and exit. */
7661 fancy_abort (const char *file, int line, const char *func)
7663 fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7666 /* Output an error message and exit. */
7669 fatal_ice (const char *cmsgid, ...)
7673 va_start (ap, cmsgid);
7675 fprintf (stderr, "%s: ", programname);
7676 vfprintf (stderr, _(cmsgid), ap);
7678 fprintf (stderr, "\n");
7679 delete_temp_files ();
7680 exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7684 fatal (const char *cmsgid, ...)
7688 va_start (ap, cmsgid);
7690 fprintf (stderr, "%s: ", programname);
7691 vfprintf (stderr, _(cmsgid), ap);
7693 fprintf (stderr, "\n");
7694 delete_temp_files ();
7698 /* The argument is actually c-format, not gcc-internal-format,
7699 but because functions with identical names are used through
7700 the rest of the compiler with gcc-internal-format, we just
7701 need to hope all users of these functions use the common
7702 subset between c-format and gcc-internal-format. */
7705 error (const char *gmsgid, ...)
7709 va_start (ap, gmsgid);
7710 fprintf (stderr, "%s: ", programname);
7711 vfprintf (stderr, _(gmsgid), ap);
7714 fprintf (stderr, "\n");
7718 notice (const char *cmsgid, ...)
7722 va_start (ap, cmsgid);
7723 vfprintf (stderr, _(cmsgid), ap);
7728 validate_switches_from_spec (const char *spec)
7730 const char *p = spec;
7733 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7734 /* We have a switch spec. */
7735 p = validate_switches (p + 1);
7739 validate_all_switches (void)
7741 struct compiler *comp;
7742 struct spec_list *spec;
7744 for (comp = compilers; comp->spec; comp++)
7745 validate_switches_from_spec (comp->spec);
7747 /* Look through the linked list of specs read from the specs file. */
7748 for (spec = specs; spec; spec = spec->next)
7749 validate_switches_from_spec (*spec->ptr_spec);
7751 validate_switches_from_spec (link_command_spec);
7754 /* Look at the switch-name that comes after START
7755 and mark as valid all supplied switches that match it. */
7758 validate_switches (const char *start)
7760 const char *p = start;
7764 bool suffix = false;
7765 bool starred = false;
7767 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7776 if (*p == '.' || *p == ',')
7780 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7781 || *p == ',' || *p == '.' || *p == '@')
7786 starred = true, p++;
7792 /* Mark all matching switches as valid. */
7793 for (i = 0; i < n_switches; i++)
7794 if (!strncmp (switches[i].part1, atom, len)
7795 && (starred || switches[i].part1[len] == 0))
7796 switches[i].validated = 1;
7800 if (*p && (p[-1] == '|' || p[-1] == '&'))
7803 if (*p && p[-1] == ':')
7805 while (*p && *p != ';' && *p != '}')
7810 if (*p == '{' || *p == '<')
7811 p = validate_switches (p+1);
7812 else if (p[0] == 'W' && p[1] == '{')
7813 p = validate_switches (p+2);
7820 if (*p && p[-1] == ';')
7834 static struct mdswitchstr *mdswitches;
7835 static int n_mdswitches;
7837 /* Check whether a particular argument was used. The first time we
7838 canonicalize the switches to keep only the ones we care about. */
7841 used_arg (const char *p, int len)
7846 const char *replace;
7851 static struct mswitchstr *mswitches;
7852 static int n_mswitches;
7857 struct mswitchstr *matches;
7861 /* Break multilib_matches into the component strings of string
7862 and replacement string. */
7863 for (q = multilib_matches; *q != '\0'; q++)
7868 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7870 q = multilib_matches;
7879 fatal ("multilib spec '%s' is invalid", multilib_matches);
7883 matches[i].len = q - matches[i].str;
7885 matches[i].replace = ++q;
7886 while (*q != ';' && *q != '\0')
7889 goto invalid_matches;
7892 matches[i].rep_len = q - matches[i].replace;
7898 /* Now build a list of the replacement string for switches that we care
7899 about. Make sure we allocate at least one entry. This prevents
7900 xmalloc from calling fatal, and prevents us from re-executing this
7903 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7904 for (i = 0; i < n_switches; i++)
7905 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7907 int xlen = strlen (switches[i].part1);
7908 for (j = 0; j < cnt; j++)
7909 if (xlen == matches[j].len
7910 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7912 mswitches[n_mswitches].str = matches[j].replace;
7913 mswitches[n_mswitches].len = matches[j].rep_len;
7914 mswitches[n_mswitches].replace = (char *) 0;
7915 mswitches[n_mswitches].rep_len = 0;
7921 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7922 on the command line nor any options mutually incompatible with
7924 for (i = 0; i < n_mdswitches; i++)
7928 for (q = multilib_options; *q != '\0'; q++)
7934 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7935 || strchr (" /", q[mdswitches[i].len]) == NULL)
7937 while (*q != ' ' && *q != '/' && *q != '\0')
7944 if (*q != ' ' && *q != '\0')
7946 while (*r != ' ' && *r != '\0')
7949 while (*q != ' ' && *q != '/' && *q != '\0')
7952 if (used_arg (r, q - r))
7957 mswitches[n_mswitches].str = mdswitches[i].str;
7958 mswitches[n_mswitches].len = mdswitches[i].len;
7959 mswitches[n_mswitches].replace = (char *) 0;
7960 mswitches[n_mswitches].rep_len = 0;
7973 for (i = 0; i < n_mswitches; i++)
7974 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7981 default_arg (const char *p, int len)
7985 for (i = 0; i < n_mdswitches; i++)
7986 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7992 /* Work out the subdirectory to use based on the options. The format of
7993 multilib_select is a list of elements. Each element is a subdirectory
7994 name followed by a list of options followed by a semicolon. The format
7995 of multilib_exclusions is the same, but without the preceding
7996 directory. First gcc will check the exclusions, if none of the options
7997 beginning with an exclamation point are present, and all of the other
7998 options are present, then we will ignore this completely. Passing
7999 that, gcc will consider each multilib_select in turn using the same
8000 rules for matching the options. If a match is found, that subdirectory
8004 set_multilib_dir (void)
8007 unsigned int this_path_len;
8008 const char *this_path, *this_arg;
8009 const char *start, *end;
8011 int ok, ndfltok, first;
8014 start = multilib_defaults;
8015 while (*start == ' ' || *start == '\t')
8017 while (*start != '\0')
8020 while (*start != ' ' && *start != '\t' && *start != '\0')
8022 while (*start == ' ' || *start == '\t')
8030 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8031 for (start = multilib_defaults; *start != '\0'; start = end + 1)
8033 while (*start == ' ' || *start == '\t')
8039 for (end = start + 1;
8040 *end != ' ' && *end != '\t' && *end != '\0'; end++)
8043 obstack_grow (&multilib_obstack, start, end - start);
8044 obstack_1grow (&multilib_obstack, 0);
8045 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8046 mdswitches[i++].len = end - start;
8053 p = multilib_exclusions;
8056 /* Ignore newlines. */
8063 /* Check the arguments. */
8070 fatal ("multilib exclusions '%s' is invalid",
8071 multilib_exclusions);
8081 while (*p != ' ' && *p != ';')
8084 goto invalid_exclusions;
8088 if (*this_arg != '!')
8096 ok = used_arg (this_arg, p - this_arg);
8111 p = multilib_select;
8114 /* Ignore newlines. */
8121 /* Get the initial path. */
8128 fatal ("multilib select '%s' is invalid",
8133 this_path_len = p - this_path;
8135 /* Check the arguments. */
8142 goto invalid_select;
8151 while (*p != ' ' && *p != ';')
8154 goto invalid_select;
8158 if (*this_arg != '!')
8166 /* If this is a default argument, we can just ignore it.
8167 This is true even if this_arg begins with '!'. Beginning
8168 with '!' does not mean that this argument is necessarily
8169 inappropriate for this library: it merely means that
8170 there is a more specific library which uses this
8171 argument. If this argument is a default, we need not
8172 consider that more specific library. */
8173 ok = used_arg (this_arg, p - this_arg);
8180 if (default_arg (this_arg, p - this_arg))
8189 if (this_path_len != 1
8190 || this_path[0] != '.')
8192 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8195 strncpy (new_multilib_dir, this_path, this_path_len);
8196 new_multilib_dir[this_path_len] = '\0';
8197 q = strchr (new_multilib_dir, ':');
8200 multilib_dir = new_multilib_dir;
8207 const char *q = this_path, *end = this_path + this_path_len;
8209 while (q < end && *q != ':')
8213 char *new_multilib_os_dir = XNEWVEC (char, end - q);
8214 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8215 new_multilib_os_dir[end - q - 1] = '\0';
8216 multilib_os_dir = new_multilib_os_dir;
8224 if (multilib_dir == NULL && multilib_os_dir != NULL
8225 && strcmp (multilib_os_dir, ".") == 0)
8227 free (CONST_CAST (char *, multilib_os_dir));
8228 multilib_os_dir = NULL;
8230 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8231 multilib_os_dir = multilib_dir;
8234 /* Print out the multiple library subdirectory selection
8235 information. This prints out a series of lines. Each line looks
8236 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8237 required. Only the desired options are printed out, the negative
8238 matches. The options are print without a leading dash. There are
8239 no spaces to make it easy to use the information in the shell.
8240 Each subdirectory is printed only once. This assumes the ordering
8241 generated by the genmultilib script. Also, we leave out ones that match
8245 print_multilib_info (void)
8247 const char *p = multilib_select;
8248 const char *last_path = 0, *this_path;
8250 unsigned int last_path_len = 0;
8255 /* Ignore newlines. */
8262 /* Get the initial path. */
8269 fatal ("multilib select '%s' is invalid", multilib_select);
8275 /* When --disable-multilib was used but target defines
8276 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8277 to find multilib_os_dir, so skip them from output. */
8278 if (this_path[0] == '.' && this_path[1] == ':')
8281 /* Check for matches with the multilib_exclusions. We don't bother
8282 with the '!' in either list. If any of the exclusion rules match
8283 all of its options with the select rule, we skip it. */
8285 const char *e = multilib_exclusions;
8286 const char *this_arg;
8291 /* Ignore newlines. */
8298 /* Check the arguments. */
8307 fatal ("multilib exclusion '%s' is invalid",
8308 multilib_exclusions);
8319 while (*e != ' ' && *e != ';')
8322 goto invalid_exclusion;
8330 int len = e - this_arg;
8333 goto invalid_select;
8337 while (*q != ' ' && *q != ';')
8340 goto invalid_select;
8344 if (! strncmp (arg, this_arg,
8345 (len < q - arg) ? q - arg : len)
8346 || default_arg (this_arg, e - this_arg))
8376 /* If this is a duplicate, skip it. */
8377 skip = (last_path != 0
8378 && (unsigned int) (p - this_path) == last_path_len
8379 && ! strncmp (last_path, this_path, last_path_len));
8381 last_path = this_path;
8382 last_path_len = p - this_path;
8385 /* If this directory requires any default arguments, we can skip
8386 it. We will already have printed a directory identical to
8387 this one which does not require that default argument. */
8398 goto invalid_select;
8405 while (*q != ' ' && *q != ';')
8408 goto invalid_select;
8413 && default_arg (arg, q - arg))
8428 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8439 goto invalid_select;
8447 use_arg = *p != '!';
8452 while (*p != ' ' && *p != ';')
8455 goto invalid_select;
8467 /* If there are extra options, print them now. */
8468 if (multilib_extra && *multilib_extra)
8470 int print_at = TRUE;
8473 for (q = multilib_extra; *q != '\0'; q++)
8494 /* getenv built-in spec function.
8496 Returns the value of the environment variable given by its first
8497 argument, concatenated with the second argument. If the
8498 environment variable is not defined, a fatal error is issued. */
8501 getenv_spec_function (int argc, const char **argv)
8511 value = getenv (argv[0]);
8513 fatal ("environment variable \"%s\" not defined", argv[0]);
8515 /* We have to escape every character of the environment variable so
8516 they are not interpreted as active spec characters. A
8517 particularly painful case is when we are reading a variable
8518 holding a windows path complete with \ separators. */
8519 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8520 result = XNEWVAR (char, len);
8521 for (ptr = result; *value; ptr += 2)
8527 strcpy (ptr, argv[1]);
8532 /* if-exists built-in spec function.
8534 Checks to see if the file specified by the absolute pathname in
8535 ARGS exists. Returns that pathname if found.
8537 The usual use for this function is to check for a library file
8538 (whose name has been expanded with %s). */
8541 if_exists_spec_function (int argc, const char **argv)
8543 /* Must have only one argument. */
8544 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8550 /* if-exists-else built-in spec function.
8552 This is like if-exists, but takes an additional argument which
8553 is returned if the first argument does not exist. */
8556 if_exists_else_spec_function (int argc, const char **argv)
8558 /* Must have exactly two arguments. */
8562 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8568 /* replace-outfile built-in spec function.
8570 This looks for the first argument in the outfiles array's name and
8571 replaces it with the second argument. */
8574 replace_outfile_spec_function (int argc, const char **argv)
8577 /* Must have exactly two arguments. */
8581 for (i = 0; i < n_infiles; i++)
8583 if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8584 outfiles[i] = xstrdup (argv[1]);
8589 /* Given two version numbers, compares the two numbers.
8590 A version number must match the regular expression
8591 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8594 compare_version_strings (const char *v1, const char *v2)
8599 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8600 REG_EXTENDED | REG_NOSUB) != 0)
8602 rresult = regexec (&r, v1, 0, NULL, 0);
8603 if (rresult == REG_NOMATCH)
8604 fatal ("invalid version number `%s'", v1);
8605 else if (rresult != 0)
8607 rresult = regexec (&r, v2, 0, NULL, 0);
8608 if (rresult == REG_NOMATCH)
8609 fatal ("invalid version number `%s'", v2);
8610 else if (rresult != 0)
8613 return strverscmp (v1, v2);
8617 /* version_compare built-in spec function.
8619 This takes an argument of the following form:
8621 <comparison-op> <arg1> [<arg2>] <switch> <result>
8623 and produces "result" if the comparison evaluates to true,
8624 and nothing if it doesn't.
8626 The supported <comparison-op> values are:
8628 >= true if switch is a later (or same) version than arg1
8630 < true if switch is an earlier version than arg1
8632 >< true if switch is arg1 or later, and earlier than arg2
8633 <> true if switch is earlier than arg1 or is arg2 or later
8635 If the switch is not present, the condition is false unless
8636 the first character of the <comparison-op> is '!'.
8639 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8640 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8643 version_compare_spec_function (int argc, const char **argv)
8647 const char *switch_value = NULL;
8652 fatal ("too few arguments to %%:version-compare");
8653 if (argv[0][0] == '\0')
8655 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8657 if (argc != nargs + 3)
8658 fatal ("too many arguments to %%:version-compare");
8660 switch_len = strlen (argv[nargs + 1]);
8661 for (i = 0; i < n_switches; i++)
8662 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8663 && check_live_switch (i, switch_len))
8664 switch_value = switches[i].part1 + switch_len;
8666 if (switch_value == NULL)
8670 comp1 = compare_version_strings (switch_value, argv[1]);
8672 comp2 = compare_version_strings (switch_value, argv[2]);
8674 comp2 = -1; /* This value unused. */
8677 switch (argv[0][0] << 8 | argv[0][1])
8679 case '>' << 8 | '=':
8680 result = comp1 >= 0;
8682 case '!' << 8 | '<':
8683 result = comp1 >= 0 || switch_value == NULL;
8688 case '!' << 8 | '>':
8689 result = comp1 < 0 || switch_value == NULL;
8691 case '>' << 8 | '<':
8692 result = comp1 >= 0 && comp2 < 0;
8694 case '<' << 8 | '>':
8695 result = comp1 < 0 || comp2 >= 0;
8699 fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8704 return argv[nargs + 2];
8707 /* %:include builtin spec function. This differs from %include in that it
8708 can be nested inside a spec, and thus be conditionalized. It takes
8709 one argument, the filename, and looks for it in the startfile path.
8710 The result is always NULL, i.e. an empty expansion. */
8713 include_spec_function (int argc, const char **argv)
8720 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8721 read_specs (file ? file : argv[0], FALSE);
8726 /* %:find-file spec function. This function replace its argument by
8727 the file found thru find_file, that is the -print-file-name gcc
8730 find_file_spec_function (int argc, const char**argv)
8737 file = find_file (argv[0]);
8742 /* %:print-asm-header spec function. Print a banner to say that the
8743 following output is from the assembler. */
8746 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8747 const char **argv ATTRIBUTE_UNUSED)
8749 printf (_("Assembler options\n=================\n\n"));
8750 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8755 /* Compute a timestamp to initialize flag_random_seed. */
8758 get_local_tick (void)
8762 /* Get some more or less random data. */
8763 #ifdef HAVE_GETTIMEOFDAY
8767 gettimeofday (&tv, NULL);
8768 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8772 time_t now = time (NULL);
8774 if (now != (time_t)-1)
8775 ret = (unsigned) now;
8782 /* %:compare-debug-dump-opt spec function. Save the last argument,
8783 expected to be the last -fdump-final-insns option, or generate a
8787 compare_debug_dump_opt_spec_function (int arg,
8788 const char **argv ATTRIBUTE_UNUSED)
8793 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8796 fatal ("too many arguments to %%:compare-debug-dump-opt");
8798 do_spec_2 ("%{fdump-final-insns=*:%*}");
8799 do_spec_1 (" ", 0, NULL);
8801 if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8806 name = xstrdup (argv[argbuf_index - 1]);
8811 const char *ext = NULL;
8813 if (argbuf_index > 0)
8815 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8818 else if (!compare_debug)
8821 do_spec_2 ("%g.gkd");
8823 do_spec_1 (" ", 0, NULL);
8825 gcc_assert (argbuf_index > 0);
8827 name = concat (argbuf[argbuf_index - 1], ext, NULL);
8829 ret = concat ("-fdump-final-insns=", name, NULL);
8832 which = compare_debug < 0;
8833 debug_check_temp_file[which] = name;
8837 unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8839 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8843 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8852 static const char *debug_auxbase_opt;
8854 /* %:compare-debug-self-opt spec function. Expands to the options
8855 that are to be passed in the second compilation of
8859 compare_debug_self_opt_spec_function (int arg,
8860 const char **argv ATTRIBUTE_UNUSED)
8863 fatal ("too many arguments to %%:compare-debug-self-opt");
8865 if (compare_debug >= 0)
8868 do_spec_2 ("%{c|S:%{o*:%*}}");
8869 do_spec_1 (" ", 0, NULL);
8871 if (argbuf_index > 0)
8872 debug_auxbase_opt = concat ("-auxbase-strip ",
8873 argbuf[argbuf_index - 1],
8876 debug_auxbase_opt = NULL;
8879 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8880 %<fdump-final-insns=* -w -S -o %j \
8881 %{!fcompare-debug-second:-fcompare-debug-second} \
8882 ", compare_debug_opt, NULL);
8885 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8886 options that are to be passed in the second compilation of
8887 compare-debug. It expects, as an argument, the basename of the
8888 current input file name, with the .gk suffix appended to it. */
8891 compare_debug_auxbase_opt_spec_function (int arg,
8898 fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8901 fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8903 if (compare_debug >= 0)
8906 len = strlen (argv[0]);
8907 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8908 fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8910 if (debug_auxbase_opt)
8911 return debug_auxbase_opt;
8913 #define OPT "-auxbase "
8916 name = (char*) xmalloc (sizeof (OPT) + len);
8917 memcpy (name, OPT, sizeof (OPT) - 1);
8918 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8919 name[sizeof (OPT) - 1 + len] = '\0';
OSDN Git Service
