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 inform (int, const char *, ...) ATTRIBUTE_PRINTF_2;
381 static void perror_with_name (const char *);
382 static void internal_error (const char *, ...)
383 ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
384 static void fnotice (FILE *, const char *, ...) ATTRIBUTE_PRINTF_2;
385 static void display_help (void);
386 static void add_preprocessor_option (const char *, int);
387 static void add_assembler_option (const char *, int);
388 static void add_linker_option (const char *, int);
389 static void process_command (int, const char **);
390 static int execute (void);
391 static void alloc_args (void);
392 static void clear_args (void);
393 static void fatal_signal (int);
394 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
395 static void init_gcc_specs (struct obstack *, const char *, const char *,
398 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
399 static const char *convert_filename (const char *, int, int);
402 static const char *getenv_spec_function (int, const char **);
403 static const char *if_exists_spec_function (int, const char **);
404 static const char *if_exists_else_spec_function (int, const char **);
405 static const char *replace_outfile_spec_function (int, const char **);
406 static const char *version_compare_spec_function (int, const char **);
407 static const char *include_spec_function (int, const char **);
408 static const char *find_file_spec_function (int, const char **);
409 static const char *print_asm_header_spec_function (int, const char **);
410 static const char *compare_debug_dump_opt_spec_function (int, const char **);
411 static const char *compare_debug_self_opt_spec_function (int, const char **);
412 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
414 /* The Specs Language
416 Specs are strings containing lines, each of which (if not blank)
417 is made up of a program name, and arguments separated by spaces.
418 The program name must be exact and start from root, since no path
419 is searched and it is unreliable to depend on the current working directory.
420 Redirection of input or output is not supported; the subprograms must
421 accept filenames saying what files to read and write.
423 In addition, the specs can contain %-sequences to substitute variable text
424 or for conditional text. Here is a table of all defined %-sequences.
425 Note that spaces are not generated automatically around the results of
426 expanding these sequences; therefore, you can concatenate them together
427 or with constant text in a single argument.
429 %% substitute one % into the program name or argument.
430 %i substitute the name of the input file being processed.
431 %b substitute the basename of the input file being processed.
432 This is the substring up to (and not including) the last period
433 and not including the directory unless -save-temps was specified
434 to put temporaries in a different location.
435 %B same as %b, but include the file suffix (text after the last period).
437 substitute a file name that has suffix SUFFIX and is chosen
438 once per compilation, and mark the argument a la %d. To reduce
439 exposure to denial-of-service attacks, the file name is now
440 chosen in a way that is hard to predict even when previously
441 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
442 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
443 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
444 had been pre-processed. Previously, %g was simply substituted
445 with a file name chosen once per compilation, without regard
446 to any appended suffix (which was therefore treated just like
447 ordinary text), making such attacks more likely to succeed.
449 like %g, but if -pipe is in effect, expands simply to "-".
451 like %g, but if -pipe is in effect, expands to nothing. (We have both
452 %| and %m to accommodate differences between system assemblers; see
453 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
455 like %g, but generates a new temporary file name even if %uSUFFIX
458 substitutes the last file name generated with %uSUFFIX, generating a
459 new one if there is no such last file name. In the absence of any
460 %uSUFFIX, this is just like %gSUFFIX, except they don't share
461 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
462 would involve the generation of two distinct file names, one
463 for each `%g.s' and another for each `%U.s'. Previously, %U was
464 simply substituted with a file name chosen for the previous %u,
465 without regard to any appended suffix.
467 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
468 writable, and if save-temps is off; otherwise, substitute the name
469 of a temporary file, just like %u. This temporary file is not
470 meant for communication between processes, but rather as a junk
473 substitutes .SUFFIX for the suffixes of a matched switch's args when
474 it is subsequently output with %*. SUFFIX is terminated by the next
476 %d marks the argument containing or following the %d as a
477 temporary file name, so that that file will be deleted if GCC exits
478 successfully. Unlike %g, this contributes no text to the argument.
479 %w marks the argument containing or following the %w as the
480 "output file" of this compilation. This puts the argument
481 into the sequence of arguments that %o will substitute later.
482 %V indicates that this compilation produces no "output file".
484 like %{...} but mark last argument supplied within
485 as a file to be deleted on failure.
486 %o substitutes the names of all the output files, with spaces
487 automatically placed around them. You should write spaces
488 around the %o as well or the results are undefined.
489 %o is for use in the specs for running the linker.
490 Input files whose names have no recognized suffix are not compiled
491 at all, but they are included among the output files, so they will
493 %O substitutes the suffix for object files. Note that this is
494 handled specially when it immediately follows %g, %u, or %U
495 (with or without a suffix argument) because of the need for
496 those to form complete file names. The handling is such that
497 %O is treated exactly as if it had already been substituted,
498 except that %g, %u, and %U do not currently support additional
499 SUFFIX characters following %O as they would following, for
501 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
502 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
503 and -B options) and -imultilib as necessary.
504 %s current argument is the name of a library or startup file of some sort.
505 Search for that file in a standard list of directories
506 and substitute the full name found.
507 %eSTR Print STR as an error message. STR is terminated by a newline.
508 Use this when inconsistent options are detected.
509 %nSTR Print STR as a notice. STR is terminated by a newline.
510 %x{OPTION} Accumulate an option for %X.
511 %X Output the accumulated linker options specified by compilations.
512 %Y Output the accumulated assembler options specified by compilations.
513 %Z Output the accumulated preprocessor options specified by compilations.
514 %a process ASM_SPEC as a spec.
515 This allows config.h to specify part of the spec for running as.
516 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
517 used here. This can be used to run a post-processor after the
518 assembler has done its job.
519 %D Dump out a -L option for each directory in startfile_prefixes.
520 If multilib_dir is set, extra entries are generated with it affixed.
521 %l process LINK_SPEC as a spec.
522 %L process LIB_SPEC as a spec.
523 %G process LIBGCC_SPEC as a spec.
524 %R Output the concatenation of target_system_root and
525 target_sysroot_suffix.
526 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
527 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
528 %C process CPP_SPEC as a spec.
529 %1 process CC1_SPEC as a spec.
530 %2 process CC1PLUS_SPEC as a spec.
531 %* substitute the variable part of a matched option. (See below.)
532 Note that each comma in the substituted string is replaced by
534 %<S remove all occurrences of -S from the command line.
535 Note - this command is position dependent. % commands in the
536 spec string before this one will see -S, % commands in the
537 spec string after this one will not.
538 %<S* remove all occurrences of all switches beginning with -S from the
541 Call the named function FUNCTION, passing it ARGS. ARGS is
542 first processed as a nested spec string, then split into an
543 argument vector in the usual fashion. The function returns
544 a string which is processed as if it had appeared literally
545 as part of the current spec.
546 %{S} substitutes the -S switch, if that switch was given to GCC.
547 If that switch was not specified, this substitutes nothing.
548 Here S is a metasyntactic variable.
549 %{S*} substitutes all the switches specified to GCC whose names start
550 with -S. This is used for -o, -I, etc; switches that take
551 arguments. GCC considers `-o foo' as being one switch whose
552 name starts with `o'. %{o*} would substitute this text,
553 including the space; thus, two arguments would be generated.
554 %{S*&T*} likewise, but preserve order of S and T options (the order
555 of S and T in the spec is not significant). Can be any number
556 of ampersand-separated variables; for each the wild card is
557 optional. Useful for CPP as %{D*&U*&A*}.
559 %{S:X} substitutes X, if the -S switch was given to GCC.
560 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
561 %{S*:X} substitutes X if one or more switches whose names start
562 with -S was given to GCC. Normally X is substituted only
563 once, no matter how many such switches appeared. However,
564 if %* appears somewhere in X, then X will be substituted
565 once for each matching switch, with the %* replaced by the
566 part of that switch that matched the '*'.
567 %{.S:X} substitutes X, if processing a file with suffix S.
568 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
569 %{,S:X} substitutes X, if processing a file which will use spec S.
570 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
572 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
573 combined with '!', '.', ',', and '*' as above binding stronger
575 If %* appears in X, all of the alternatives must be starred, and
576 only the first matching alternative is substituted.
577 %{S:X; if S was given to GCC, substitutes X;
578 T:Y; else if T was given to GCC, substitutes Y;
579 :D} else substitutes D. There can be as many clauses as you need.
580 This may be combined with '.', '!', ',', '|', and '*' as above.
582 %(Spec) processes a specification defined in a specs file as *Spec:
583 %[Spec] as above, but put __ around -D arguments
585 The conditional text X in a %{S:X} or similar construct may contain
586 other nested % constructs or spaces, or even newlines. They are
587 processed as usual, as described above. Trailing white space in X is
588 ignored. White space may also appear anywhere on the left side of the
589 colon in these constructs, except between . or * and the corresponding
592 The -O, -f, -m, and -W switches are handled specifically in these
593 constructs. If another value of -O or the negated form of a -f, -m, or
594 -W switch is found later in the command line, the earlier switch
595 value is ignored, except with {S*} where S is just one letter; this
596 passes all matching options.
598 The character | at the beginning of the predicate text is used to indicate
599 that a command should be piped to the following command, but only if -pipe
602 Note that it is built into GCC which switches take arguments and which
603 do not. You might think it would be useful to generalize this to
604 allow each compiler's spec to say which switches take arguments. But
605 this cannot be done in a consistent fashion. GCC cannot even decide
606 which input files have been specified without knowing which switches
607 take arguments, and it must know which input files to compile in order
608 to tell which compilers to run.
610 GCC also knows implicitly that arguments starting in `-l' are to be
611 treated as compiler output files, and passed to the linker in their
612 proper position among the other output files. */
614 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
616 /* config.h can define ASM_SPEC to provide extra args to the assembler
617 or extra switch-translations. */
622 /* config.h can define ASM_FINAL_SPEC to run a post processor after
623 the assembler has run. */
624 #ifndef ASM_FINAL_SPEC
625 #define ASM_FINAL_SPEC ""
628 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
629 or extra switch-translations. */
634 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
635 or extra switch-translations. */
640 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
641 or extra switch-translations. */
643 #define CC1PLUS_SPEC ""
646 /* config.h can define LINK_SPEC to provide extra args to the linker
647 or extra switch-translations. */
652 /* config.h can define LIB_SPEC to override the default libraries. */
654 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
659 /* XXX: valid only for GNU ld */
660 /* XXX: should exactly match hooks provided by libmudflap.a */
661 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
662 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
663 --wrap=mmap --wrap=munmap --wrap=alloca\
664 } %{fmudflapth: --wrap=pthread_create\
665 }} %{fmudflap|fmudflapth: --wrap=main}"
668 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
671 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
674 #if defined(REAL_LIBGCC_SPEC)
675 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
676 #elif defined(LINK_LIBGCC_SPECIAL_1)
677 /* Have gcc do the search for libgcc.a. */
678 #define LIBGCC_SPEC "libgcc.a%s"
680 #define LIBGCC_SPEC "-lgcc"
684 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
685 #ifndef STARTFILE_SPEC
686 #define STARTFILE_SPEC \
687 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
690 /* config.h can define SWITCHES_NEED_SPACES to control which options
691 require spaces between the option and the argument.
693 We define SWITCHES_NEED_SPACES to include "o" by default. This
694 causes "-ofoo.o" to be split into "-o foo.o" during the initial
695 processing of the command-line, before being seen by the specs
696 machinery. This makes sure we record "foo.o" as the temporary file
697 to be deleted in the case of error, rather than "-ofoo.o". */
698 #ifndef SWITCHES_NEED_SPACES
699 #define SWITCHES_NEED_SPACES "o"
702 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
704 #define ENDFILE_SPEC ""
708 #define LINKER_NAME "collect2"
711 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
712 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
717 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
719 #ifndef ASM_DEBUG_SPEC
720 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
721 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
722 # define ASM_DEBUG_SPEC \
723 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
724 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
725 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
727 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
728 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
730 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
731 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
735 #ifndef ASM_DEBUG_SPEC
736 # define ASM_DEBUG_SPEC ""
739 /* Here is the spec for running the linker, after compiling all files. */
741 /* This is overridable by the target in case they need to specify the
742 -lgcc and -lc order specially, yet not require them to override all
743 of LINK_COMMAND_SPEC. */
744 #ifndef LINK_GCC_C_SEQUENCE_SPEC
745 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
748 #ifndef LINK_SSP_SPEC
749 #ifdef TARGET_LIBC_PROVIDES_SSP
750 #define LINK_SSP_SPEC "%{fstack-protector:}"
752 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
756 #ifndef LINK_PIE_SPEC
758 #define LINK_PIE_SPEC "%{pie:-pie} "
760 #define LINK_PIE_SPEC "%{pie:} "
764 #ifndef LINK_BUILDID_SPEC
765 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
766 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
771 /* -u* was put back because both BSD and SysV seem to support it. */
772 /* %{static:} simply prevents an error message if the target machine
773 doesn't handle -static. */
774 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
775 scripts which exist in user specified directories, or in standard
777 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
778 to understand them. In practice, this means it had better be collect2. */
779 #ifndef LINK_COMMAND_SPEC
780 #define LINK_COMMAND_SPEC "\
781 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
783 %{fuse-linker-plugin: \
784 -plugin %(linker_plugin_file) \
785 -plugin-opt=%(lto_wrapper) \
786 -plugin-opt=-fresolution=%u.res \
787 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
788 %{static:-plugin-opt=-pass-through=-lc} \
790 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
791 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
792 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
793 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
794 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
795 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
796 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
797 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
800 #ifndef LINK_LIBGCC_SPEC
801 /* Generate -L options for startfile prefix list. */
802 # define LINK_LIBGCC_SPEC "%D"
805 #ifndef STARTFILE_PREFIX_SPEC
806 # define STARTFILE_PREFIX_SPEC ""
810 # define SYSROOT_SPEC "--sysroot=%R"
813 #ifndef SYSROOT_SUFFIX_SPEC
814 # define SYSROOT_SUFFIX_SPEC ""
817 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
818 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
821 static const char *asm_debug;
822 static const char *cpp_spec = CPP_SPEC;
823 static const char *cc1_spec = CC1_SPEC;
824 static const char *cc1plus_spec = CC1PLUS_SPEC;
825 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
826 static const char *link_ssp_spec = LINK_SSP_SPEC;
827 static const char *asm_spec = ASM_SPEC;
828 static const char *asm_final_spec = ASM_FINAL_SPEC;
829 static const char *link_spec = LINK_SPEC;
830 static const char *lib_spec = LIB_SPEC;
831 static const char *mfwrap_spec = MFWRAP_SPEC;
832 static const char *mflib_spec = MFLIB_SPEC;
833 static const char *link_gomp_spec = "";
834 static const char *libgcc_spec = LIBGCC_SPEC;
835 static const char *endfile_spec = ENDFILE_SPEC;
836 static const char *startfile_spec = STARTFILE_SPEC;
837 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
838 static const char *linker_name_spec = LINKER_NAME;
839 static const char *linker_plugin_file_spec = "";
840 static const char *lto_wrapper_spec = "";
841 static const char *lto_gcc_spec = "";
842 static const char *lto_libgcc_spec = "";
843 static const char *link_command_spec = LINK_COMMAND_SPEC;
844 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
845 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
846 static const char *sysroot_spec = SYSROOT_SPEC;
847 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
848 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
850 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
851 There should be no need to override these in target dependent files,
852 but we need to copy them to the specs file so that newer versions
853 of the GCC driver can correctly drive older tool chains with the
854 appropriate -B options. */
856 /* When cpplib handles traditional preprocessing, get rid of this, and
857 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
858 that we default the front end language better. */
859 static const char *trad_capable_cpp =
860 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
862 /* We don't wrap .d files in %W{} since a missing .d file, and
863 therefore no dependency entry, confuses make into thinking a .o
864 file that happens to exist is up-to-date. */
865 static const char *cpp_unique_options =
866 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
867 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
868 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
869 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
870 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
871 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
872 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
873 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
874 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
875 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
876 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
879 /* This contains cpp options which are common with cc1_options and are passed
880 only when preprocessing only to avoid duplication. We pass the cc1 spec
881 options to the preprocessor so that it the cc1 spec may manipulate
882 options used to set target flags. Those special target flags settings may
883 in turn cause preprocessor symbols to be defined specially. */
884 static const char *cpp_options =
885 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
886 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
887 %{undef} %{save-temps*:-fpch-preprocess}";
889 /* This contains cpp options which are not passed when the preprocessor
890 output will be used by another program. */
891 static const char *cpp_debug_options = "%{d*}";
893 /* NB: This is shared amongst all front-ends, except for Ada. */
894 static const char *cc1_options =
895 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
896 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
897 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{a*}\
898 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
899 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
900 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
901 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
902 %{Qn:-fno-ident} %{--help:--help}\
903 %{--target-help:--target-help}\
904 %{--help=*:--help=%(VALUE)}\
905 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
906 %{fsyntax-only:-o %j} %{-param*}\
907 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
908 %{coverage:-fprofile-arcs -ftest-coverage}";
910 static const char *asm_options =
911 "%{--target-help:%:print-asm-header()} "
913 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
914 to the assembler equivalents. */
915 "%{v} %{w:-W} %{I*} "
917 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
919 static const char *invoke_as =
920 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
922 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
923 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
927 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
928 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
932 /* Some compilers have limits on line lengths, and the multilib_select
933 and/or multilib_matches strings can be very long, so we build them at
935 static struct obstack multilib_obstack;
936 static const char *multilib_select;
937 static const char *multilib_matches;
938 static const char *multilib_defaults;
939 static const char *multilib_exclusions;
941 /* Check whether a particular argument is a default argument. */
943 #ifndef MULTILIB_DEFAULTS
944 #define MULTILIB_DEFAULTS { "" }
947 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
949 #ifndef DRIVER_SELF_SPECS
950 #define DRIVER_SELF_SPECS ""
953 /* Adding -fopenmp should imply pthreads. This is particularly important
954 for targets that use different start files and suchlike. */
955 #ifndef GOMP_SELF_SPECS
956 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
959 static const char *const driver_self_specs[] = {
960 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
961 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
964 #ifndef OPTION_DEFAULT_SPECS
965 #define OPTION_DEFAULT_SPECS { "", "" }
974 static const struct default_spec
975 option_default_specs[] = { OPTION_DEFAULT_SPECS };
979 struct user_specs *next;
980 const char *filename;
983 static struct user_specs *user_specs_head, *user_specs_tail;
985 #ifndef SWITCH_TAKES_ARG
986 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
989 #ifndef WORD_SWITCH_TAKES_ARG
990 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
993 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
994 /* This defines which switches stop a full compilation. */
995 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
996 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
998 #ifndef SWITCH_CURTAILS_COMPILATION
999 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
1000 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
1004 /* Record the mapping from file suffixes for compilation specs. */
1008 const char *suffix; /* Use this compiler for input files
1009 whose names end in this suffix. */
1011 const char *spec; /* To use this compiler, run this spec. */
1013 const char *cpp_spec; /* If non-NULL, substitute this spec
1014 for `%C', rather than the usual
1016 const int combinable; /* If nonzero, compiler can deal with
1017 multiple source files at once (IMA). */
1018 const int needs_preprocessing; /* If nonzero, source files need to
1019 be run through a preprocessor. */
1022 /* Pointer to a vector of `struct compiler' that gives the spec for
1023 compiling a file, based on its suffix.
1024 A file that does not end in any of these suffixes will be passed
1025 unchanged to the loader and nothing else will be done to it.
1027 An entry containing two 0s is used to terminate the vector.
1029 If multiple entries match a file, the last matching one is used. */
1031 static struct compiler *compilers;
1033 /* Number of entries in `compilers', not counting the null terminator. */
1035 static int n_compilers;
1037 /* The default list of file name suffixes and their compilation specs. */
1039 static const struct compiler default_compilers[] =
1041 /* Add lists of suffixes of known languages here. If those languages
1042 were not present when we built the driver, we will hit these copies
1043 and be given a more meaningful error than "file not used since
1044 linking is not done". */
1045 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1046 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1047 {".mii", "#Objective-C++", 0, 0, 0},
1048 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1049 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1050 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1051 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1052 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1053 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1054 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1055 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1056 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1057 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1058 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1059 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1060 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1061 {".r", "#Ratfor", 0, 0, 0},
1062 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1063 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1064 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1065 /* Next come the entries for C. */
1066 {".c", "@c", 0, 1, 1},
1068 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1069 external preprocessor if -save-temps is given. */
1070 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1072 %{traditional|ftraditional:\
1073 %eGNU C no longer supports -traditional without -E}\
1075 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1076 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1077 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1079 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1080 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1081 %{!fsyntax-only:%(invoke_as)}} \
1083 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1084 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1085 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1086 cc1 %(cpp_unique_options) %(cc1_options)}}\
1087 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1089 "%{!E:%e-E or -x required when input is from standard input}\
1090 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1091 {".h", "@c-header", 0, 0, 0},
1093 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1094 external preprocessor if -save-temps is given. */
1095 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1097 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1098 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1099 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1101 -o %g.s %{!o*:--output-pch=%i.gch}\
1102 %W{o*:--output-pch=%*}%V}\
1103 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1104 cc1 %(cpp_unique_options) %(cc1_options)\
1105 -o %g.s %{!o*:--output-pch=%i.gch}\
1106 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1107 {".i", "@cpp-output", 0, 1, 0},
1109 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1110 {".s", "@assembler", 0, 1, 0},
1112 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1113 {".sx", "@assembler-with-cpp", 0, 1, 0},
1114 {".S", "@assembler-with-cpp", 0, 1, 0},
1115 {"@assembler-with-cpp",
1116 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1117 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1118 %{E|M|MM:%(cpp_debug_options)}\
1119 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1120 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1122 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1123 %{E|M|MM:%(cpp_debug_options)}\
1124 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1125 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1130 /* Mark end of table. */
1134 /* Number of elements in default_compilers, not counting the terminator. */
1136 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1138 /* A vector of options to give to the linker.
1139 These options are accumulated by %x,
1140 and substituted into the linker command with %X. */
1141 static int n_linker_options;
1142 static char **linker_options;
1144 /* A vector of options to give to the assembler.
1145 These options are accumulated by -Wa,
1146 and substituted into the assembler command with %Y. */
1147 static int n_assembler_options;
1148 static char **assembler_options;
1150 /* A vector of options to give to the preprocessor.
1151 These options are accumulated by -Wp,
1152 and substituted into the preprocessor command with %Z. */
1153 static int n_preprocessor_options;
1154 static char **preprocessor_options;
1156 /* Define how to map long options into short ones. */
1158 /* This structure describes one mapping. */
1161 /* The long option's name. */
1162 const char *const name;
1163 /* The equivalent short option. */
1164 const char *const equivalent;
1165 /* Argument info. A string of flag chars; NULL equals no options.
1166 a => argument required.
1167 o => argument optional.
1168 j => join argument to equivalent, making one word.
1169 * => require other text after NAME as an argument. */
1170 const char *const arg_info;
1173 /* This is the table of mappings. Mappings are tried sequentially
1174 for each option encountered; the first one that matches, wins. */
1176 static const struct option_map option_map[] =
1178 {"--all-warnings", "-Wall", 0},
1179 {"--ansi", "-ansi", 0},
1180 {"--assemble", "-S", 0},
1181 {"--assert", "-A", "a"},
1182 {"--classpath", "-fclasspath=", "aj"},
1183 {"--bootclasspath", "-fbootclasspath=", "aj"},
1184 {"--CLASSPATH", "-fclasspath=", "aj"},
1185 {"--combine", "-combine", 0},
1186 {"--comments", "-C", 0},
1187 {"--comments-in-macros", "-CC", 0},
1188 {"--compile", "-c", 0},
1189 {"--debug", "-g", "oj"},
1190 {"--define-macro", "-D", "aj"},
1191 {"--dependencies", "-M", 0},
1192 {"--dump", "-d", "a"},
1193 {"--dumpbase", "-dumpbase", "a"},
1194 {"--dumpdir", "-dumpdir", "a"},
1195 {"--encoding", "-fencoding=", "aj"},
1196 {"--entry", "-e", 0},
1197 {"--extra-warnings", "-W", 0},
1198 {"--extdirs", "-fextdirs=", "aj"},
1199 {"--for-assembler", "-Wa", "a"},
1200 {"--for-linker", "-Xlinker", "a"},
1201 {"--force-link", "-u", "a"},
1202 {"--coverage", "-coverage", 0},
1203 {"--imacros", "-imacros", "a"},
1204 {"--include", "-include", "a"},
1205 {"--include-barrier", "-I-", 0},
1206 {"--include-directory", "-I", "aj"},
1207 {"--include-directory-after", "-idirafter", "a"},
1208 {"--include-prefix", "-iprefix", "a"},
1209 {"--include-with-prefix", "-iwithprefix", "a"},
1210 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1211 {"--include-with-prefix-after", "-iwithprefix", "a"},
1212 {"--language", "-x", "a"},
1213 {"--library-directory", "-L", "a"},
1214 {"--machine", "-m", "aj"},
1215 {"--machine-", "-m", "*j"},
1216 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1217 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1218 {"--no-line-commands", "-P", 0},
1219 {"--no-precompiled-includes", "-noprecomp", 0},
1220 {"--no-standard-includes", "-nostdinc", 0},
1221 {"--no-standard-libraries", "-nostdlib", 0},
1222 {"--no-warnings", "-w", 0},
1223 {"--optimize", "-O", "oj"},
1224 {"--output", "-o", "a"},
1225 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1226 {"--param", "--param", "a"},
1227 {"--pass-exit-codes", "-pass-exit-codes", 0},
1228 {"--pedantic", "-pedantic", 0},
1229 {"--pedantic-errors", "-pedantic-errors", 0},
1230 {"--pie", "-pie", 0},
1231 {"--pipe", "-pipe", 0},
1232 {"--prefix", "-B", "a"},
1233 {"--preprocess", "-E", 0},
1234 {"--print-search-dirs", "-print-search-dirs", 0},
1235 {"--print-file-name", "-print-file-name=", "aj"},
1236 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1237 {"--print-missing-file-dependencies", "-MG", 0},
1238 {"--print-multi-lib", "-print-multi-lib", 0},
1239 {"--print-multi-directory", "-print-multi-directory", 0},
1240 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1241 {"--print-prog-name", "-print-prog-name=", "aj"},
1242 {"--print-sysroot", "-print-sysroot", 0},
1243 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1244 {"--profile", "-p", 0},
1245 {"--profile-blocks", "-a", 0},
1246 {"--quiet", "-q", 0},
1247 {"--resource", "-fcompile-resource=", "aj"},
1248 {"--save-temps", "-save-temps", 0},
1249 {"--shared", "-shared", 0},
1250 {"--silent", "-q", 0},
1251 {"--specs", "-specs=", "aj"},
1252 {"--static", "-static", 0},
1253 {"--std", "-std=", "aj"},
1254 {"--symbolic", "-symbolic", 0},
1255 {"--sysroot", "--sysroot=", "aj"},
1256 {"--time", "-time", 0},
1257 {"--trace-includes", "-H", 0},
1258 {"--traditional", "-traditional", 0},
1259 {"--traditional-cpp", "-traditional-cpp", 0},
1260 {"--trigraphs", "-trigraphs", 0},
1261 {"--undefine-macro", "-U", "aj"},
1262 {"--user-dependencies", "-MM", 0},
1263 {"--verbose", "-v", 0},
1264 {"--warn-", "-W", "*j"},
1265 {"--write-dependencies", "-MD", 0},
1266 {"--write-user-dependencies", "-MMD", 0},
1271 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1272 static const struct {
1273 const char *const option_found;
1274 const char *const replacements;
1275 } target_option_translations[] =
1277 TARGET_OPTION_TRANSLATE_TABLE,
1282 /* Translate the options described by *ARGCP and *ARGVP.
1283 Make a new vector and store it back in *ARGVP,
1284 and store its length in *ARGCP. */
1287 translate_options (int *argcp, const char *const **argvp)
1291 const char *const *argv = *argvp;
1292 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1293 const char **newv = XNEWVAR (const char *, newvsize);
1297 newv[newindex++] = argv[i++];
1301 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1305 target_option_translations[tott_idx].option_found;
1308 if (strcmp (target_option_translations[tott_idx].option_found,
1315 for (sp = target_option_translations[tott_idx].replacements;
1322 newvsize += spaces * sizeof (const char *);
1323 newv = XRESIZEVAR (const char *, newv, newvsize);
1325 sp = target_option_translations[tott_idx].replacements;
1334 newv[newindex++] = np;
1335 while (*np != ' ' && *np)
1346 if (target_option_translations[tott_idx].option_found)
1350 /* Translate -- options. */
1351 if (argv[i][0] == '-' && argv[i][1] == '-')
1354 /* Find a mapping that applies to this option. */
1355 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1357 size_t optlen = strlen (option_map[j].name);
1358 size_t arglen = strlen (argv[i]);
1359 size_t complen = arglen > optlen ? optlen : arglen;
1360 const char *arginfo = option_map[j].arg_info;
1365 if (!strncmp (argv[i], option_map[j].name, complen))
1367 const char *arg = 0;
1369 if (arglen < optlen)
1372 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1373 if (strlen (option_map[k].name) >= arglen
1374 && !strncmp (argv[i], option_map[k].name, arglen))
1376 error ("ambiguous abbreviation %s", argv[i]);
1380 if (k != ARRAY_SIZE (option_map))
1384 if (arglen > optlen)
1386 /* If the option has an argument, accept that. */
1387 if (argv[i][optlen] == '=')
1388 arg = argv[i] + optlen + 1;
1390 /* If this mapping requires extra text at end of name,
1391 accept that as "argument". */
1392 else if (strchr (arginfo, '*') != 0)
1393 arg = argv[i] + optlen;
1395 /* Otherwise, extra text at end means mismatch.
1396 Try other mappings. */
1401 else if (strchr (arginfo, '*') != 0)
1403 error ("incomplete '%s' option", option_map[j].name);
1407 /* Handle arguments. */
1408 if (strchr (arginfo, 'a') != 0)
1414 error ("missing argument to '%s' option",
1415 option_map[j].name);
1422 else if (strchr (arginfo, '*') != 0)
1424 else if (strchr (arginfo, 'o') == 0)
1427 error ("extraneous argument to '%s' option",
1428 option_map[j].name);
1432 /* Store the translation as one argv elt or as two. */
1433 if (arg != 0 && strchr (arginfo, 'j') != 0)
1434 newv[newindex++] = concat (option_map[j].equivalent, arg,
1438 newv[newindex++] = option_map[j].equivalent;
1439 newv[newindex++] = arg;
1442 newv[newindex++] = option_map[j].equivalent;
1450 /* Handle old-fashioned options--just copy them through,
1451 with their arguments. */
1452 else if (argv[i][0] == '-')
1454 const char *p = argv[i] + 1;
1458 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1459 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1460 else if (WORD_SWITCH_TAKES_ARG (p))
1461 nskip += WORD_SWITCH_TAKES_ARG (p);
1462 else if ((c == 'B' || c == 'b' || c == 'x')
1465 else if (! strcmp (p, "Xlinker"))
1467 else if (! strcmp (p, "Xpreprocessor"))
1469 else if (! strcmp (p, "Xassembler"))
1472 /* Watch out for an option at the end of the command line that
1473 is missing arguments, and avoid skipping past the end of the
1475 if (nskip + i > argc)
1480 newv[newindex++] = argv[i++];
1485 /* Ordinary operands, or +e options. */
1486 newv[newindex++] = argv[i++];
1496 skip_whitespace (char *p)
1500 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1501 be considered whitespace. */
1502 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1504 else if (*p == '\n' || *p == ' ' || *p == '\t')
1518 /* Structures to keep track of prefixes to try when looking for files. */
1522 const char *prefix; /* String to prepend to the path. */
1523 struct prefix_list *next; /* Next in linked list. */
1524 int require_machine_suffix; /* Don't use without machine_suffix. */
1525 /* 2 means try both machine_suffix and just_machine_suffix. */
1526 int priority; /* Sort key - priority within list. */
1527 int os_multilib; /* 1 if OS multilib scheme should be used,
1528 0 for GCC multilib scheme. */
1533 struct prefix_list *plist; /* List of prefixes to try */
1534 int max_len; /* Max length of a prefix in PLIST */
1535 const char *name; /* Name of this list (used in config stuff) */
1538 /* List of prefixes to try when looking for executables. */
1540 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1542 /* List of prefixes to try when looking for startup (crt0) files. */
1544 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1546 /* List of prefixes to try when looking for include files. */
1548 static struct path_prefix include_prefixes = { 0, 0, "include" };
1550 /* Suffix to attach to directories searched for commands.
1551 This looks like `MACHINE/VERSION/'. */
1553 static const char *machine_suffix = 0;
1555 /* Suffix to attach to directories searched for commands.
1556 This is just `MACHINE/'. */
1558 static const char *just_machine_suffix = 0;
1560 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1562 static const char *gcc_exec_prefix;
1564 /* Adjusted value of standard_libexec_prefix. */
1566 static const char *gcc_libexec_prefix;
1568 /* Default prefixes to attach to command names. */
1570 #ifndef STANDARD_STARTFILE_PREFIX_1
1571 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1573 #ifndef STANDARD_STARTFILE_PREFIX_2
1574 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1577 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1578 #undef MD_EXEC_PREFIX
1579 #undef MD_STARTFILE_PREFIX
1580 #undef MD_STARTFILE_PREFIX_1
1583 /* If no prefixes defined, use the null string, which will disable them. */
1584 #ifndef MD_EXEC_PREFIX
1585 #define MD_EXEC_PREFIX ""
1587 #ifndef MD_STARTFILE_PREFIX
1588 #define MD_STARTFILE_PREFIX ""
1590 #ifndef MD_STARTFILE_PREFIX_1
1591 #define MD_STARTFILE_PREFIX_1 ""
1594 /* These directories are locations set at configure-time based on the
1595 --prefix option provided to configure. Their initializers are
1596 defined in Makefile.in. These paths are not *directly* used when
1597 gcc_exec_prefix is set because, in that case, we know where the
1598 compiler has been installed, and use paths relative to that
1599 location instead. */
1600 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1601 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1602 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1603 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1605 /* For native compilers, these are well-known paths containing
1606 components that may be provided by the system. For cross
1607 compilers, these paths are not used. */
1608 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1609 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1610 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1611 static const char *const standard_startfile_prefix_1
1612 = STANDARD_STARTFILE_PREFIX_1;
1613 static const char *const standard_startfile_prefix_2
1614 = STANDARD_STARTFILE_PREFIX_2;
1616 /* A relative path to be used in finding the location of tools
1617 relative to the driver. */
1618 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1620 /* Subdirectory to use for locating libraries. Set by
1621 set_multilib_dir based on the compilation options. */
1623 static const char *multilib_dir;
1625 /* Subdirectory to use for locating libraries in OS conventions. Set by
1626 set_multilib_dir based on the compilation options. */
1628 static const char *multilib_os_dir;
1630 /* Structure to keep track of the specs that have been defined so far.
1631 These are accessed using %(specname) or %[specname] in a compiler
1636 /* The following 2 fields must be first */
1637 /* to allow EXTRA_SPECS to be initialized */
1638 const char *name; /* name of the spec. */
1639 const char *ptr; /* available ptr if no static pointer */
1641 /* The following fields are not initialized */
1642 /* by EXTRA_SPECS */
1643 const char **ptr_spec; /* pointer to the spec itself. */
1644 struct spec_list *next; /* Next spec in linked list. */
1645 int name_len; /* length of the name */
1646 int alloc_p; /* whether string was allocated */
1649 #define INIT_STATIC_SPEC(NAME,PTR) \
1650 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1652 /* List of statically defined specs. */
1653 static struct spec_list static_specs[] =
1655 INIT_STATIC_SPEC ("asm", &asm_spec),
1656 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1657 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1658 INIT_STATIC_SPEC ("asm_options", &asm_options),
1659 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1660 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1661 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1662 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1663 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1664 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1665 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1666 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1667 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1668 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1669 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1670 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1671 INIT_STATIC_SPEC ("link", &link_spec),
1672 INIT_STATIC_SPEC ("lib", &lib_spec),
1673 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1674 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1675 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1676 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1677 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1678 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1679 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1680 INIT_STATIC_SPEC ("version", &compiler_version),
1681 INIT_STATIC_SPEC ("multilib", &multilib_select),
1682 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1683 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1684 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1685 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1686 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1687 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1688 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1689 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec),
1690 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec),
1691 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec),
1692 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1693 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1694 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1695 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1696 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1697 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1698 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1699 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1702 #ifdef EXTRA_SPECS /* additional specs needed */
1703 /* Structure to keep track of just the first two args of a spec_list.
1704 That is all that the EXTRA_SPECS macro gives us. */
1707 const char *const name;
1708 const char *const ptr;
1711 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1712 static struct spec_list *extra_specs = (struct spec_list *) 0;
1715 /* List of dynamically allocates specs that have been defined so far. */
1717 static struct spec_list *specs = (struct spec_list *) 0;
1719 /* List of static spec functions. */
1721 static const struct spec_function static_spec_functions[] =
1723 { "getenv", getenv_spec_function },
1724 { "if-exists", if_exists_spec_function },
1725 { "if-exists-else", if_exists_else_spec_function },
1726 { "replace-outfile", replace_outfile_spec_function },
1727 { "version-compare", version_compare_spec_function },
1728 { "include", include_spec_function },
1729 { "find-file", find_file_spec_function },
1730 { "print-asm-header", print_asm_header_spec_function },
1731 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1732 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1733 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1734 #ifdef EXTRA_SPEC_FUNCTIONS
1735 EXTRA_SPEC_FUNCTIONS
1740 static int processing_spec_function;
1742 /* Add appropriate libgcc specs to OBSTACK, taking into account
1743 various permutations of -shared-libgcc, -shared, and such. */
1745 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1747 #ifndef USE_LD_AS_NEEDED
1748 #define USE_LD_AS_NEEDED 0
1752 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1753 const char *static_name, const char *eh_name)
1757 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1758 "%{!static:%{!static-libgcc:"
1759 #if USE_LD_AS_NEEDED
1760 "%{!shared-libgcc:",
1761 static_name, " --as-needed ", shared_name, " --no-as-needed"
1764 shared_name, "%{!shared: ", static_name, "}"
1768 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1769 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1773 "%{shared-libgcc:", shared_name, "}"
1774 "%{!shared-libgcc:", static_name, "}"
1777 "%{shared:", shared_name, "}"
1782 obstack_grow (obstack, buf, strlen (buf));
1785 #endif /* ENABLE_SHARED_LIBGCC */
1787 /* Initialize the specs lookup routines. */
1792 struct spec_list *next = (struct spec_list *) 0;
1793 struct spec_list *sl = (struct spec_list *) 0;
1797 return; /* Already initialized. */
1800 fnotice (stderr, "Using built-in specs.\n");
1803 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1805 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1807 sl = &extra_specs[i];
1808 sl->name = extra_specs_1[i].name;
1809 sl->ptr = extra_specs_1[i].ptr;
1811 sl->name_len = strlen (sl->name);
1812 sl->ptr_spec = &sl->ptr;
1817 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1819 sl = &static_specs[i];
1824 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1825 /* ??? If neither -shared-libgcc nor --static-libgcc was
1826 seen, then we should be making an educated guess. Some proposed
1827 heuristics for ELF include:
1829 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1830 program will be doing dynamic loading, which will likely
1831 need the shared libgcc.
1833 (2) If "-ldl", then it's also a fair bet that we're doing
1836 (3) For each ET_DYN we're linking against (either through -lfoo
1837 or /some/path/foo.so), check to see whether it or one of
1838 its dependencies depends on a shared libgcc.
1842 If the runtime is fixed to look for program headers instead
1843 of calling __register_frame_info at all, for each object,
1844 use the shared libgcc if any EH symbol referenced.
1846 If crtstuff is fixed to not invoke __register_frame_info
1847 automatically, for each object, use the shared libgcc if
1848 any non-empty unwind section found.
1850 Doing any of this probably requires invoking an external program to
1851 do the actual object file scanning. */
1853 const char *p = libgcc_spec;
1856 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1857 when given the proper command line arguments. */
1860 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1862 init_gcc_specs (&obstack,
1864 #ifdef USE_LIBUNWIND_EXCEPTIONS
1870 #ifdef USE_LIBUNWIND_EXCEPTIONS
1871 # ifdef HAVE_LD_STATIC_DYNAMIC
1872 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1882 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1884 /* Ug. We don't know shared library extensions. Hope that
1885 systems that use this form don't do shared libraries. */
1886 init_gcc_specs (&obstack,
1890 #ifdef USE_LIBUNWIND_EXCEPTIONS
1899 obstack_1grow (&obstack, *p);
1900 in_sep = (*p == ' ');
1905 obstack_1grow (&obstack, '\0');
1906 libgcc_spec = XOBFINISH (&obstack, const char *);
1909 #ifdef USE_AS_TRADITIONAL_FORMAT
1910 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1912 static const char tf[] = "--traditional-format ";
1913 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1914 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1915 asm_spec = XOBFINISH (&obstack, const char *);
1919 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1920 # ifdef LINK_BUILDID_SPEC
1921 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1922 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1924 # ifdef LINK_EH_SPEC
1925 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1926 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1928 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1929 link_spec = XOBFINISH (&obstack, const char *);
1935 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1936 removed; If the spec starts with a + then SPEC is added to the end of the
1940 set_spec (const char *name, const char *spec)
1942 struct spec_list *sl;
1943 const char *old_spec;
1944 int name_len = strlen (name);
1947 /* If this is the first call, initialize the statically allocated specs. */
1950 struct spec_list *next = (struct spec_list *) 0;
1951 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1953 sl = &static_specs[i];
1960 /* See if the spec already exists. */
1961 for (sl = specs; sl; sl = sl->next)
1962 if (name_len == sl->name_len && !strcmp (sl->name, name))
1967 /* Not found - make it. */
1968 sl = XNEW (struct spec_list);
1969 sl->name = xstrdup (name);
1970 sl->name_len = name_len;
1971 sl->ptr_spec = &sl->ptr;
1973 *(sl->ptr_spec) = "";
1978 old_spec = *(sl->ptr_spec);
1979 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1980 ? concat (old_spec, spec + 1, NULL)
1985 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1988 /* Free the old spec. */
1989 if (old_spec && sl->alloc_p)
1990 free (CONST_CAST(char *, old_spec));
1995 /* Accumulate a command (program name and args), and run it. */
1997 /* Vector of pointers to arguments in the current line of specifications. */
1999 static const char **argbuf;
2001 /* Number of elements allocated in argbuf. */
2003 static int argbuf_length;
2005 /* Number of elements in argbuf currently in use (containing args). */
2007 static int argbuf_index;
2009 /* Position in the argbuf array containing the name of the output file
2010 (the value associated with the "-o" flag). */
2012 static int have_o_argbuf_index = 0;
2014 /* Were the options -c, -S or -E passed. */
2015 static int have_c = 0;
2017 /* Was the option -o passed. */
2018 static int have_o = 0;
2020 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2021 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2024 static struct temp_name {
2025 const char *suffix; /* suffix associated with the code. */
2026 int length; /* strlen (suffix). */
2027 int unique; /* Indicates whether %g or %u/%U was used. */
2028 const char *filename; /* associated filename. */
2029 int filename_length; /* strlen (filename). */
2030 struct temp_name *next;
2033 /* Number of commands executed so far. */
2035 static int execution_count;
2037 /* Number of commands that exited with a signal. */
2039 static int signal_count;
2041 /* Name with which this program was invoked. */
2043 static const char *programname;
2045 /* Allocate the argument vector. */
2051 argbuf = XNEWVEC (const char *, argbuf_length);
2054 /* Clear out the vector of arguments (after a command is executed). */
2062 /* Add one argument to the vector at the end.
2063 This is done when a space is seen or at the end of the line.
2064 If DELETE_ALWAYS is nonzero, the arg is a filename
2065 and the file should be deleted eventually.
2066 If DELETE_FAILURE is nonzero, the arg is a filename
2067 and the file should be deleted if this compilation fails. */
2070 store_arg (const char *arg, int delete_always, int delete_failure)
2072 if (argbuf_index + 1 == argbuf_length)
2073 argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
2075 argbuf[argbuf_index++] = arg;
2076 argbuf[argbuf_index] = 0;
2078 if (strcmp (arg, "-o") == 0)
2079 have_o_argbuf_index = argbuf_index;
2080 if (delete_always || delete_failure)
2083 /* If the temporary file we should delete is specified as
2084 part of a joined argument extract the filename. */
2086 && (p = strrchr (arg, '=')))
2088 record_temp_file (arg, delete_always, delete_failure);
2092 /* Load specs from a file name named FILENAME, replacing occurrences of
2093 various different types of line-endings, \r\n, \n\r and just \r, with
2097 load_specs (const char *filename)
2101 struct stat statbuf;
2108 fnotice (stderr, "Reading specs from %s\n", filename);
2110 /* Open and stat the file. */
2111 desc = open (filename, O_RDONLY, 0);
2113 pfatal_with_name (filename);
2114 if (stat (filename, &statbuf) < 0)
2115 pfatal_with_name (filename);
2117 /* Read contents of file into BUFFER. */
2118 buffer = XNEWVEC (char, statbuf.st_size + 1);
2119 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2121 pfatal_with_name (filename);
2122 buffer[readlen] = 0;
2125 specs = XNEWVEC (char, readlen + 1);
2127 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2133 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2135 else if (*(buffer_p + 1) == '\n') /* \r\n */
2149 /* Read compilation specs from a file named FILENAME,
2150 replacing the default ones.
2152 A suffix which starts with `*' is a definition for
2153 one of the machine-specific sub-specs. The "suffix" should be
2154 *asm, *cc1, *cpp, *link, *startfile, etc.
2155 The corresponding spec is stored in asm_spec, etc.,
2156 rather than in the `compilers' vector.
2158 Anything invalid in the file is a fatal error. */
2161 read_specs (const char *filename, int main_p)
2166 buffer = load_specs (filename);
2168 /* Scan BUFFER for specs, putting them in the vector. */
2174 char *in, *out, *p1, *p2, *p3;
2176 /* Advance P in BUFFER to the next nonblank nocomment line. */
2177 p = skip_whitespace (p);
2181 /* Is this a special command that starts with '%'? */
2182 /* Don't allow this for the main specs file, since it would
2183 encourage people to overwrite it. */
2184 if (*p == '%' && !main_p)
2187 while (*p && *p != '\n')
2193 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2194 && (p1[sizeof "%include" - 1] == ' '
2195 || p1[sizeof "%include" - 1] == '\t'))
2199 p1 += sizeof ("%include");
2200 while (*p1 == ' ' || *p1 == '\t')
2203 if (*p1++ != '<' || p[-2] != '>')
2204 fatal_error ("specs %%include syntax malformed after "
2206 (long) (p1 - buffer + 1));
2209 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2210 read_specs (new_filename ? new_filename : p1, FALSE);
2213 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2214 && (p1[sizeof "%include_noerr" - 1] == ' '
2215 || p1[sizeof "%include_noerr" - 1] == '\t'))
2219 p1 += sizeof "%include_noerr";
2220 while (*p1 == ' ' || *p1 == '\t')
2223 if (*p1++ != '<' || p[-2] != '>')
2224 fatal_error ("specs %%include syntax malformed after "
2226 (long) (p1 - buffer + 1));
2229 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2231 read_specs (new_filename, FALSE);
2232 else if (verbose_flag)
2233 fnotice (stderr, "could not find specs file %s\n", p1);
2236 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2237 && (p1[sizeof "%rename" - 1] == ' '
2238 || p1[sizeof "%rename" - 1] == '\t'))
2241 struct spec_list *sl;
2242 struct spec_list *newsl;
2244 /* Get original name. */
2245 p1 += sizeof "%rename";
2246 while (*p1 == ' ' || *p1 == '\t')
2249 if (! ISALPHA ((unsigned char) *p1))
2250 fatal_error ("specs %%rename syntax malformed after "
2252 (long) (p1 - buffer));
2255 while (*p2 && !ISSPACE ((unsigned char) *p2))
2258 if (*p2 != ' ' && *p2 != '\t')
2259 fatal_error ("specs %%rename syntax malformed after "
2261 (long) (p2 - buffer));
2265 while (*p2 == ' ' || *p2 == '\t')
2268 if (! ISALPHA ((unsigned char) *p2))
2269 fatal_error ("specs %%rename syntax malformed after "
2271 (long) (p2 - buffer));
2273 /* Get new spec name. */
2275 while (*p3 && !ISSPACE ((unsigned char) *p3))
2279 fatal_error ("specs %%rename syntax malformed after "
2281 (long) (p3 - buffer));
2284 for (sl = specs; sl; sl = sl->next)
2285 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2289 fatal_error ("specs %s spec was not found to be renamed", p1);
2291 if (strcmp (p1, p2) == 0)
2294 for (newsl = specs; newsl; newsl = newsl->next)
2295 if (strcmp (newsl->name, p2) == 0)
2296 fatal_error ("%s: attempt to rename spec '%s' to "
2297 "already defined spec '%s'",
2302 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2304 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2308 set_spec (p2, *(sl->ptr_spec));
2310 free (CONST_CAST (char *, *(sl->ptr_spec)));
2312 *(sl->ptr_spec) = "";
2317 fatal_error ("specs unknown %% command after %ld characters",
2318 (long) (p1 - buffer));
2321 /* Find the colon that should end the suffix. */
2323 while (*p1 && *p1 != ':' && *p1 != '\n')
2326 /* The colon shouldn't be missing. */
2328 fatal_error ("specs file malformed after %ld characters",
2329 (long) (p1 - buffer));
2331 /* Skip back over trailing whitespace. */
2333 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2336 /* Copy the suffix to a string. */
2337 suffix = save_string (p, p2 - p);
2338 /* Find the next line. */
2339 p = skip_whitespace (p1 + 1);
2341 fatal_error ("specs file malformed after %ld characters",
2342 (long) (p - buffer));
2345 /* Find next blank line or end of string. */
2346 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2349 /* Specs end at the blank line and do not include the newline. */
2350 spec = save_string (p, p1 - p);
2353 /* Delete backslash-newline sequences from the spec. */
2358 if (in[0] == '\\' && in[1] == '\n')
2360 else if (in[0] == '#')
2361 while (*in && *in != '\n')
2369 if (suffix[0] == '*')
2371 if (! strcmp (suffix, "*link_command"))
2372 link_command_spec = spec;
2374 set_spec (suffix + 1, spec);
2378 /* Add this pair to the vector. */
2380 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2382 compilers[n_compilers].suffix = suffix;
2383 compilers[n_compilers].spec = spec;
2385 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2389 link_command_spec = spec;
2392 if (link_command_spec == 0)
2393 fatal_error ("spec file has no spec for linking");
2396 /* Record the names of temporary files we tell compilers to write,
2397 and delete them at the end of the run. */
2399 /* This is the common prefix we use to make temp file names.
2400 It is chosen once for each run of this program.
2401 It is substituted into a spec by %g or %j.
2402 Thus, all temp file names contain this prefix.
2403 In practice, all temp file names start with this prefix.
2405 This prefix comes from the envvar TMPDIR if it is defined;
2406 otherwise, from the P_tmpdir macro if that is defined;
2407 otherwise, in /usr/tmp or /tmp;
2408 or finally the current directory if all else fails. */
2410 static const char *temp_filename;
2412 /* Length of the prefix. */
2414 static int temp_filename_length;
2416 /* Define the list of temporary files to delete. */
2421 struct temp_file *next;
2424 /* Queue of files to delete on success or failure of compilation. */
2425 static struct temp_file *always_delete_queue;
2426 /* Queue of files to delete on failure of compilation. */
2427 static struct temp_file *failure_delete_queue;
2429 /* Record FILENAME as a file to be deleted automatically.
2430 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2431 otherwise delete it in any case.
2432 FAIL_DELETE nonzero means delete it if a compilation step fails;
2433 otherwise delete it in any case. */
2436 record_temp_file (const char *filename, int always_delete, int fail_delete)
2438 char *const name = xstrdup (filename);
2442 struct temp_file *temp;
2443 for (temp = always_delete_queue; temp; temp = temp->next)
2444 if (! strcmp (name, temp->name))
2447 temp = XNEW (struct temp_file);
2448 temp->next = always_delete_queue;
2450 always_delete_queue = temp;
2457 struct temp_file *temp;
2458 for (temp = failure_delete_queue; temp; temp = temp->next)
2459 if (! strcmp (name, temp->name))
2462 temp = XNEW (struct temp_file);
2463 temp->next = failure_delete_queue;
2465 failure_delete_queue = temp;
2471 /* Delete all the temporary files whose names we previously recorded. */
2473 #ifndef DELETE_IF_ORDINARY
2474 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2477 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2478 if (unlink (NAME) < 0) \
2480 perror_with_name (NAME); \
2485 delete_if_ordinary (const char *name)
2491 printf ("Delete %s? (y or n) ", name);
2495 while ((c = getchar ()) != '\n' && c != EOF)
2498 if (i == 'y' || i == 'Y')
2500 DELETE_IF_ORDINARY (name, st, verbose_flag);
2504 delete_temp_files (void)
2506 struct temp_file *temp;
2508 for (temp = always_delete_queue; temp; temp = temp->next)
2509 delete_if_ordinary (temp->name);
2510 always_delete_queue = 0;
2513 /* Delete all the files to be deleted on error. */
2516 delete_failure_queue (void)
2518 struct temp_file *temp;
2520 for (temp = failure_delete_queue; temp; temp = temp->next)
2521 delete_if_ordinary (temp->name);
2525 clear_failure_queue (void)
2527 failure_delete_queue = 0;
2530 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2532 If DO_MULTI is true iterate over the paths twice, first with multilib
2533 suffix then without, otherwise iterate over the paths once without
2534 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2535 to avoid visiting the same path twice, but we could do better. For
2536 instance, /usr/lib/../lib is considered different from /usr/lib.
2537 At least EXTRA_SPACE chars past the end of the path passed to
2538 CALLBACK are available for use by the callback.
2539 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2541 Returns the value returned by CALLBACK. */
2544 for_each_path (const struct path_prefix *paths,
2547 void *(*callback) (char *, void *),
2548 void *callback_info)
2550 struct prefix_list *pl;
2551 const char *multi_dir = NULL;
2552 const char *multi_os_dir = NULL;
2553 const char *multi_suffix;
2554 const char *just_multi_suffix;
2557 bool skip_multi_dir = false;
2558 bool skip_multi_os_dir = false;
2560 multi_suffix = machine_suffix;
2561 just_multi_suffix = just_machine_suffix;
2562 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2564 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2565 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2566 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2568 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2569 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2573 size_t multi_dir_len = 0;
2574 size_t multi_os_dir_len = 0;
2576 size_t just_suffix_len;
2580 multi_dir_len = strlen (multi_dir);
2582 multi_os_dir_len = strlen (multi_os_dir);
2583 suffix_len = strlen (multi_suffix);
2584 just_suffix_len = strlen (just_multi_suffix);
2588 len = paths->max_len + extra_space + 1;
2589 if (suffix_len > multi_os_dir_len)
2592 len += multi_os_dir_len;
2593 path = XNEWVEC (char, len);
2596 for (pl = paths->plist; pl != 0; pl = pl->next)
2598 len = strlen (pl->prefix);
2599 memcpy (path, pl->prefix, len);
2601 /* Look first in MACHINE/VERSION subdirectory. */
2602 if (!skip_multi_dir)
2604 memcpy (path + len, multi_suffix, suffix_len + 1);
2605 ret = callback (path, callback_info);
2610 /* Some paths are tried with just the machine (ie. target)
2611 subdir. This is used for finding as, ld, etc. */
2613 && pl->require_machine_suffix == 2)
2615 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2616 ret = callback (path, callback_info);
2621 /* Now try the base path. */
2622 if (!pl->require_machine_suffix
2623 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2625 const char *this_multi;
2626 size_t this_multi_len;
2628 if (pl->os_multilib)
2630 this_multi = multi_os_dir;
2631 this_multi_len = multi_os_dir_len;
2635 this_multi = multi_dir;
2636 this_multi_len = multi_dir_len;
2640 memcpy (path + len, this_multi, this_multi_len + 1);
2644 ret = callback (path, callback_info);
2652 if (multi_dir == NULL && multi_os_dir == NULL)
2655 /* Run through the paths again, this time without multilibs.
2656 Don't repeat any we have already seen. */
2659 free (CONST_CAST (char *, multi_dir));
2661 free (CONST_CAST (char *, multi_suffix));
2662 multi_suffix = machine_suffix;
2663 free (CONST_CAST (char *, just_multi_suffix));
2664 just_multi_suffix = just_machine_suffix;
2667 skip_multi_dir = true;
2670 free (CONST_CAST (char *, multi_os_dir));
2671 multi_os_dir = NULL;
2674 skip_multi_os_dir = true;
2679 free (CONST_CAST (char *, multi_dir));
2680 free (CONST_CAST (char *, multi_suffix));
2681 free (CONST_CAST (char *, just_multi_suffix));
2684 free (CONST_CAST (char *, multi_os_dir));
2690 /* Callback for build_search_list. Adds path to obstack being built. */
2692 struct add_to_obstack_info {
2699 add_to_obstack (char *path, void *data)
2701 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2703 if (info->check_dir && !is_directory (path, false))
2706 if (!info->first_time)
2707 obstack_1grow (info->ob, PATH_SEPARATOR);
2709 obstack_grow (info->ob, path, strlen (path));
2711 info->first_time = false;
2715 /* Add or change the value of an environment variable, outputting the
2716 change to standard error if in verbose mode. */
2718 xputenv (const char *string)
2721 fnotice (stderr, "%s\n", string);
2722 putenv (CONST_CAST (char *, string));
2725 /* Build a list of search directories from PATHS.
2726 PREFIX is a string to prepend to the list.
2727 If CHECK_DIR_P is true we ensure the directory exists.
2728 If DO_MULTI is true, multilib paths are output first, then
2730 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2731 It is also used by the --print-search-dirs flag. */
2734 build_search_list (const struct path_prefix *paths, const char *prefix,
2735 bool check_dir, bool do_multi)
2737 struct add_to_obstack_info info;
2739 info.ob = &collect_obstack;
2740 info.check_dir = check_dir;
2741 info.first_time = true;
2743 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2744 obstack_1grow (&collect_obstack, '=');
2746 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2748 obstack_1grow (&collect_obstack, '\0');
2749 return XOBFINISH (&collect_obstack, char *);
2752 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2756 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2759 xputenv (build_search_list (paths, env_var, true, do_multi));
2762 /* Check whether NAME can be accessed in MODE. This is like access,
2763 except that it never considers directories to be executable. */
2766 access_check (const char *name, int mode)
2772 if (stat (name, &st) < 0
2773 || S_ISDIR (st.st_mode))
2777 return access (name, mode);
2780 /* Callback for find_a_file. Appends the file name to the directory
2781 path. If the resulting file exists in the right mode, return the
2782 full pathname to the file. */
2784 struct file_at_path_info {
2793 file_at_path (char *path, void *data)
2795 struct file_at_path_info *info = (struct file_at_path_info *) data;
2796 size_t len = strlen (path);
2798 memcpy (path + len, info->name, info->name_len);
2799 len += info->name_len;
2801 /* Some systems have a suffix for executable files.
2802 So try appending that first. */
2803 if (info->suffix_len)
2805 memcpy (path + len, info->suffix, info->suffix_len + 1);
2806 if (access_check (path, info->mode) == 0)
2811 if (access_check (path, info->mode) == 0)
2817 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2818 access to check permissions. If DO_MULTI is true, search multilib
2819 paths then non-multilib paths, otherwise do not search multilib paths.
2820 Return 0 if not found, otherwise return its name, allocated with malloc. */
2823 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2826 struct file_at_path_info info;
2828 #ifdef DEFAULT_ASSEMBLER
2829 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2830 return xstrdup (DEFAULT_ASSEMBLER);
2833 #ifdef DEFAULT_LINKER
2834 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2835 return xstrdup (DEFAULT_LINKER);
2838 /* Determine the filename to execute (special case for absolute paths). */
2840 if (IS_ABSOLUTE_PATH (name))
2842 if (access (name, mode) == 0)
2843 return xstrdup (name);
2849 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2850 info.name_len = strlen (info.name);
2851 info.suffix_len = strlen (info.suffix);
2854 return (char*) for_each_path (pprefix, do_multi,
2855 info.name_len + info.suffix_len,
2856 file_at_path, &info);
2859 /* Ranking of prefixes in the sort list. -B prefixes are put before
2862 enum path_prefix_priority
2864 PREFIX_PRIORITY_B_OPT,
2865 PREFIX_PRIORITY_LAST
2868 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2869 order according to PRIORITY. Within each PRIORITY, new entries are
2872 If WARN is nonzero, we will warn if no file is found
2873 through this prefix. WARN should point to an int
2874 which will be set to 1 if this entry is used.
2876 COMPONENT is the value to be passed to update_path.
2878 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2879 the complete value of machine_suffix.
2880 2 means try both machine_suffix and just_machine_suffix. */
2883 add_prefix (struct path_prefix *pprefix, const char *prefix,
2884 const char *component, /* enum prefix_priority */ int priority,
2885 int require_machine_suffix, int os_multilib)
2887 struct prefix_list *pl, **prev;
2890 for (prev = &pprefix->plist;
2891 (*prev) != NULL && (*prev)->priority <= priority;
2892 prev = &(*prev)->next)
2895 /* Keep track of the longest prefix. */
2897 prefix = update_path (prefix, component);
2898 len = strlen (prefix);
2899 if (len > pprefix->max_len)
2900 pprefix->max_len = len;
2902 pl = XNEW (struct prefix_list);
2903 pl->prefix = prefix;
2904 pl->require_machine_suffix = require_machine_suffix;
2905 pl->priority = priority;
2906 pl->os_multilib = os_multilib;
2908 /* Insert after PREV. */
2913 /* Same as add_prefix, but prepending target_system_root to prefix. */
2914 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2916 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2917 const char *component,
2918 /* enum prefix_priority */ int priority,
2919 int require_machine_suffix, int os_multilib)
2921 if (!IS_ABSOLUTE_PATH (prefix))
2922 fatal_error ("system path '%s' is not absolute", prefix);
2924 if (target_system_root)
2926 if (target_sysroot_suffix)
2927 prefix = concat (target_sysroot_suffix, prefix, NULL);
2928 prefix = concat (target_system_root, prefix, NULL);
2930 /* We have to override this because GCC's notion of sysroot
2931 moves along with GCC. */
2935 add_prefix (pprefix, prefix, component, priority,
2936 require_machine_suffix, os_multilib);
2939 /* Execute the command specified by the arguments on the current line of spec.
2940 When using pipes, this includes several piped-together commands
2941 with `|' between them.
2943 Return 0 if successful, -1 if failed. */
2949 int n_commands; /* # of command. */
2951 struct pex_obj *pex;
2954 const char *prog; /* program name. */
2955 const char **argv; /* vector of args. */
2958 struct command *commands; /* each command buffer with above info. */
2960 gcc_assert (!processing_spec_function);
2964 string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2965 argbuf[0] = (string) ? string : argbuf[0];
2966 insert_wrapper (wrapper_string);
2969 /* Count # of piped commands. */
2970 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2971 if (strcmp (argbuf[i], "|") == 0)
2974 /* Get storage for each command. */
2975 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2977 /* Split argbuf into its separate piped processes,
2978 and record info about each one.
2979 Also search for the programs that are to be run. */
2981 commands[0].prog = argbuf[0]; /* first command. */
2982 commands[0].argv = &argbuf[0];
2984 if (!wrapper_string)
2986 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2987 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2990 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2991 if (strcmp (argbuf[i], "|") == 0)
2992 { /* each command. */
2993 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2994 fatal_error ("-pipe not supported");
2996 argbuf[i] = 0; /* termination of command args. */
2997 commands[n_commands].prog = argbuf[i + 1];
2998 commands[n_commands].argv = &argbuf[i + 1];
2999 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
3002 commands[n_commands].argv[0] = string;
3006 argbuf[argbuf_index] = 0;
3008 /* If -v, print what we are about to do, and maybe query. */
3012 /* For help listings, put a blank line between sub-processes. */
3013 if (print_help_list)
3014 fputc ('\n', stderr);
3016 /* Print each piped command as a separate line. */
3017 for (i = 0; i < n_commands; i++)
3019 const char *const *j;
3021 if (verbose_only_flag)
3023 for (j = commands[i].argv; *j; j++)
3026 for (p = *j; *p; ++p)
3027 if (!ISALNUM ((unsigned char) *p)
3028 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
3032 fprintf (stderr, " \"");
3033 for (p = *j; *p; ++p)
3035 if (*p == '"' || *p == '\\' || *p == '$')
3036 fputc ('\\', stderr);
3039 fputc ('"', stderr);
3042 fprintf (stderr, " %s", *j);
3046 for (j = commands[i].argv; *j; j++)
3047 fprintf (stderr, " %s", *j);
3049 /* Print a pipe symbol after all but the last command. */
3050 if (i + 1 != n_commands)
3051 fprintf (stderr, " |");
3052 fprintf (stderr, "\n");
3055 if (verbose_only_flag != 0)
3057 /* verbose_only_flag should act as if the spec was
3058 executed, so increment execution_count before
3059 returning. This prevents spurious warnings about
3060 unused linker input files, etc. */
3065 fnotice (stderr, "\nGo ahead? (y or n) ");
3069 while (getchar () != '\n')
3072 if (i != 'y' && i != 'Y')
3077 #ifdef ENABLE_VALGRIND_CHECKING
3078 /* Run the each command through valgrind. To simplify prepending the
3079 path to valgrind and the option "-q" (for quiet operation unless
3080 something triggers), we allocate a separate argv array. */
3082 for (i = 0; i < n_commands; i++)
3088 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3091 argv = XALLOCAVEC (const char *, argc + 3);
3093 argv[0] = VALGRIND_PATH;
3095 for (j = 2; j < argc + 2; j++)
3096 argv[j] = commands[i].argv[j - 2];
3099 commands[i].argv = argv;
3100 commands[i].prog = argv[0];
3104 /* Run each piped subprocess. */
3106 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3107 ? PEX_RECORD_TIMES : 0),
3108 programname, temp_filename);
3110 pfatal_with_name (_("pex_init failed"));
3112 for (i = 0; i < n_commands; i++)
3116 const char *string = commands[i].argv[0];
3118 errmsg = pex_run (pex,
3119 ((i + 1 == n_commands ? PEX_LAST : 0)
3120 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3121 string, CONST_CAST (char **, commands[i].argv),
3126 fatal_error (errmsg);
3130 pfatal_with_name (errmsg);
3134 if (string != commands[i].prog)
3135 free (CONST_CAST (char *, string));
3140 /* Wait for all the subprocesses to finish. */
3144 struct pex_time *times = NULL;
3147 statuses = (int *) alloca (n_commands * sizeof (int));
3148 if (!pex_get_status (pex, n_commands, statuses))
3149 pfatal_with_name (_("failed to get exit status"));
3151 if (report_times || report_times_to_file)
3153 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3154 if (!pex_get_times (pex, n_commands, times))
3155 pfatal_with_name (_("failed to get process times"));
3160 for (i = 0; i < n_commands; ++i)
3162 int status = statuses[i];
3164 if (WIFSIGNALED (status))
3167 /* SIGPIPE is a special case. It happens in -pipe mode
3168 when the compiler dies before the preprocessor is done,
3169 or the assembler dies before the compiler is done.
3170 There's generally been an error already, and this is
3171 just fallout. So don't generate another error unless
3172 we would otherwise have succeeded. */
3173 if (WTERMSIG (status) == SIGPIPE
3174 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3182 Internal error: %s (program %s)\n\
3183 Please submit a full bug report.\n\
3184 See %s for instructions.",
3185 strsignal (WTERMSIG (status)), commands[i].prog,
3188 else if (WIFEXITED (status)
3189 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3191 if (WEXITSTATUS (status) > greatest_status)
3192 greatest_status = WEXITSTATUS (status);
3196 if (report_times || report_times_to_file)
3198 struct pex_time *pt = ×[i];
3201 ut = ((double) pt->user_seconds
3202 + (double) pt->user_microseconds / 1.0e6);
3203 st = ((double) pt->system_seconds
3204 + (double) pt->system_microseconds / 1.0e6);
3209 fnotice (stderr, "# %s %.2f %.2f\n",
3210 commands[i].prog, ut, st);
3212 if (report_times_to_file)
3215 const char *const *j;
3217 fprintf (report_times_to_file, "%g %g", ut, st);
3219 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3222 for (p = *j; *p; ++p)
3223 if (*p == '"' || *p == '\\' || *p == '$'
3229 fprintf (report_times_to_file, " \"");
3230 for (p = *j; *p; ++p)
3232 if (*p == '"' || *p == '\\' || *p == '$')
3233 fputc ('\\', report_times_to_file);
3234 fputc (*p, report_times_to_file);
3236 fputc ('"', report_times_to_file);
3239 fprintf (report_times_to_file, " %s", *j);
3242 fputc ('\n', report_times_to_file);
3252 /* Find all the switches given to us
3253 and make a vector describing them.
3254 The elements of the vector are strings, one per switch given.
3255 If a switch uses following arguments, then the `part1' field
3256 is the switch itself and the `args' field
3257 is a null-terminated vector containing the following arguments.
3258 Bits in the `live_cond' field are:
3259 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3260 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3261 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3262 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3263 in all do_spec calls afterwards. Used for %<S from self specs.
3264 The `validated' field is nonzero if any spec has looked at this switch;
3265 if it remains zero at the end of the run, it must be meaningless. */
3267 #define SWITCH_LIVE 0x1
3268 #define SWITCH_FALSE 0x2
3269 #define SWITCH_IGNORE 0x4
3270 #define SWITCH_IGNORE_PERMANENTLY 0x8
3276 unsigned int live_cond;
3277 unsigned char validated;
3278 unsigned char ordering;
3281 static struct switchstr *switches;
3283 static int n_switches;
3285 /* Set to zero if -fcompare-debug is disabled, positive if it's
3286 enabled and we're running the first compilation, negative if it's
3287 enabled and we're running the second compilation. For most of the
3288 time, it's in the range -1..1, but it can be temporarily set to 2
3289 or 3 to indicate that the -fcompare-debug flags didn't come from
3290 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3291 variable, until a synthesized -fcompare-debug flag is added to the
3295 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3296 int compare_debug_second;
3298 /* Set to the flags that should be passed to the second compilation in
3299 a -fcompare-debug compilation. */
3300 const char *compare_debug_opt;
3302 static struct switchstr *switches_debug_check[2];
3304 static int n_switches_debug_check[2];
3306 static char *debug_check_temp_file[2];
3308 /* Language is one of three things:
3310 1) The name of a real programming language.
3311 2) NULL, indicating that no one has figured out
3313 3) '*', indicating that the file should be passed
3318 const char *language;
3319 struct compiler *incompiler;
3324 /* Also a vector of input files specified. */
3326 static struct infile *infiles;
3330 /* True if multiple input files are being compiled to a single
3333 static bool combine_inputs;
3335 /* This counts the number of libraries added by lang_specific_driver, so that
3336 we can tell if there were any user supplied any files or libraries. */
3338 static int added_libraries;
3340 /* And a vector of corresponding output files is made up later. */
3342 const char **outfiles;
3344 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3346 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3347 is true if we should look for an executable suffix. DO_OBJ
3348 is true if we should look for an object suffix. */
3351 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3352 int do_obj ATTRIBUTE_UNUSED)
3354 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3362 len = strlen (name);
3364 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3365 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3366 if (do_obj && len > 2
3367 && name[len - 2] == '.'
3368 && name[len - 1] == 'o')
3370 obstack_grow (&obstack, name, len - 2);
3371 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3372 name = XOBFINISH (&obstack, const char *);
3376 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3377 /* If there is no filetype, make it the executable suffix (which includes
3378 the "."). But don't get confused if we have just "-o". */
3379 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3382 for (i = len - 1; i >= 0; i--)
3383 if (IS_DIR_SEPARATOR (name[i]))
3386 for (i++; i < len; i++)
3390 obstack_grow (&obstack, name, len);
3391 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3392 strlen (TARGET_EXECUTABLE_SUFFIX));
3393 name = XOBFINISH (&obstack, const char *);
3400 /* Display the command line switches accepted by gcc. */
3404 printf (_("Usage: %s [options] file...\n"), programname);
3405 fputs (_("Options:\n"), stdout);
3407 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3408 fputs (_(" --help Display this information\n"), stdout);
3409 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3410 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3411 fputs (_(" Display specific types of command line options\n"), stdout);
3413 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3414 fputs (_(" --version Display compiler version information\n"), stdout);
3415 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3416 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3417 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3418 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3419 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3420 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3421 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3422 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3424 -print-multi-lib Display the mapping between command line options and\n\
3425 multiple library search directories\n"), stdout);
3426 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3427 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3428 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3429 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3430 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3431 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3432 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3433 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3434 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3435 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3436 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3437 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3439 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3440 prefixes to other gcc components\n"), stdout);
3441 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3442 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3443 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3444 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3446 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3447 and libraries\n"), stdout);
3448 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3449 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3450 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3451 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3452 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3453 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3454 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3456 -x <language> Specify the language of the following input files\n\
3457 Permissible languages include: c c++ assembler none\n\
3458 'none' means revert to the default behavior of\n\
3459 guessing the language based on the file's extension\n\
3463 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3464 passed on to the various sub-processes invoked by %s. In order to pass\n\
3465 other options on to these processes the -W<letter> options must be used.\n\
3468 /* The rest of the options are displayed by invocations of the various
3473 add_preprocessor_option (const char *option, int len)
3475 n_preprocessor_options++;
3477 if (! preprocessor_options)
3478 preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3480 preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3481 n_preprocessor_options);
3483 preprocessor_options [n_preprocessor_options - 1] =
3484 save_string (option, len);
3488 add_assembler_option (const char *option, int len)
3490 n_assembler_options++;
3492 if (! assembler_options)
3493 assembler_options = XNEWVEC (char *, n_assembler_options);
3495 assembler_options = XRESIZEVEC (char *, assembler_options,
3496 n_assembler_options);
3498 assembler_options [n_assembler_options - 1] = save_string (option, len);
3502 add_linker_option (const char *option, int len)
3506 if (! linker_options)
3507 linker_options = XNEWVEC (char *, n_linker_options);
3509 linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3511 linker_options [n_linker_options - 1] = save_string (option, len);
3514 /* Create the vector `switches' and its contents.
3515 Store its length in `n_switches'. */
3518 process_command (int argc, const char **argv)
3523 const char *spec_lang = 0;
3524 int last_language_n_infiles;
3525 int lang_n_infiles = 0;
3526 #ifdef MODIFY_TARGET_NAME
3527 int is_modify_target_name;
3530 const char *tooldir_prefix;
3531 char *(*get_relative_prefix) (const char *, const char *,
3532 const char *) = NULL;
3534 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3538 added_libraries = 0;
3540 /* Figure compiler version from version string. */
3542 compiler_version = temp1 = xstrdup (version_string);
3544 for (; *temp1; ++temp1)
3553 /* Convert new-style -- options to old-style. */
3554 translate_options (&argc,
3555 CONST_CAST2 (const char *const **, const char ***,
3558 /* Handle any -no-canonical-prefixes flag early, to assign the function
3559 that builds relative prefixes. This function creates default search
3560 paths that are needed later in normal option handling. */
3562 for (i = 1; i < argc; i++)
3564 if (! strcmp (argv[i], "-no-canonical-prefixes"))
3566 get_relative_prefix = make_relative_prefix_ignore_links;
3570 if (! get_relative_prefix)
3571 get_relative_prefix = make_relative_prefix;
3573 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3574 see if we can create it from the pathname specified in argv[0]. */
3576 gcc_libexec_prefix = standard_libexec_prefix;
3578 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3579 if (!gcc_exec_prefix)
3581 gcc_exec_prefix = get_relative_prefix (argv[0],
3582 standard_bindir_prefix,
3583 standard_exec_prefix);
3584 gcc_libexec_prefix = get_relative_prefix (argv[0],
3585 standard_bindir_prefix,
3586 standard_libexec_prefix);
3587 if (gcc_exec_prefix)
3588 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3592 /* make_relative_prefix requires a program name, but
3593 GCC_EXEC_PREFIX is typically a directory name with a trailing
3594 / (which is ignored by make_relative_prefix), so append a
3596 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3597 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3598 standard_exec_prefix,
3599 standard_libexec_prefix);
3601 /* The path is unrelocated, so fallback to the original setting. */
3602 if (!gcc_libexec_prefix)
3603 gcc_libexec_prefix = standard_libexec_prefix;
3609 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3610 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3611 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3613 /* Do language-specific adjustment/addition of flags. */
3614 lang_specific_driver (&argc,
3615 CONST_CAST2 (const char *const **, const char ***,
3619 if (gcc_exec_prefix)
3621 int len = strlen (gcc_exec_prefix);
3623 if (len > (int) sizeof ("/lib/gcc/") - 1
3624 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3626 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3627 if (IS_DIR_SEPARATOR (*temp)
3628 && strncmp (temp + 1, "lib", 3) == 0
3629 && IS_DIR_SEPARATOR (temp[4])
3630 && strncmp (temp + 5, "gcc", 3) == 0)
3631 len -= sizeof ("/lib/gcc/") - 1;
3634 set_std_prefix (gcc_exec_prefix, len);
3635 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3636 PREFIX_PRIORITY_LAST, 0, 0);
3637 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3638 PREFIX_PRIORITY_LAST, 0, 0);
3641 /* COMPILER_PATH and LIBRARY_PATH have values
3642 that are lists of directory names with colons. */
3644 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3647 const char *startp, *endp;
3648 char *nstore = (char *) alloca (strlen (temp) + 3);
3650 startp = endp = temp;
3653 if (*endp == PATH_SEPARATOR || *endp == 0)
3655 strncpy (nstore, startp, endp - startp);
3657 strcpy (nstore, concat (".", dir_separator_str, NULL));
3658 else if (!IS_DIR_SEPARATOR (endp[-1]))
3660 nstore[endp - startp] = DIR_SEPARATOR;
3661 nstore[endp - startp + 1] = 0;
3664 nstore[endp - startp] = 0;
3665 add_prefix (&exec_prefixes, nstore, 0,
3666 PREFIX_PRIORITY_LAST, 0, 0);
3667 add_prefix (&include_prefixes, nstore, 0,
3668 PREFIX_PRIORITY_LAST, 0, 0);
3671 endp = startp = endp + 1;
3678 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3679 if (temp && *cross_compile == '0')
3681 const char *startp, *endp;
3682 char *nstore = (char *) alloca (strlen (temp) + 3);
3684 startp = endp = temp;
3687 if (*endp == PATH_SEPARATOR || *endp == 0)
3689 strncpy (nstore, startp, endp - startp);
3691 strcpy (nstore, concat (".", dir_separator_str, NULL));
3692 else if (!IS_DIR_SEPARATOR (endp[-1]))
3694 nstore[endp - startp] = DIR_SEPARATOR;
3695 nstore[endp - startp + 1] = 0;
3698 nstore[endp - startp] = 0;
3699 add_prefix (&startfile_prefixes, nstore, NULL,
3700 PREFIX_PRIORITY_LAST, 0, 1);
3703 endp = startp = endp + 1;
3710 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3711 GET_ENVIRONMENT (temp, "LPATH");
3712 if (temp && *cross_compile == '0')
3714 const char *startp, *endp;
3715 char *nstore = (char *) alloca (strlen (temp) + 3);
3717 startp = endp = temp;
3720 if (*endp == PATH_SEPARATOR || *endp == 0)
3722 strncpy (nstore, startp, endp - startp);
3724 strcpy (nstore, concat (".", dir_separator_str, NULL));
3725 else if (!IS_DIR_SEPARATOR (endp[-1]))
3727 nstore[endp - startp] = DIR_SEPARATOR;
3728 nstore[endp - startp + 1] = 0;
3731 nstore[endp - startp] = 0;
3732 add_prefix (&startfile_prefixes, nstore, NULL,
3733 PREFIX_PRIORITY_LAST, 0, 1);
3736 endp = startp = endp + 1;
3743 /* Scan argv twice. Here, the first time, just count how many switches
3744 there will be in their vector, and how many input files in theirs.
3745 Here we also parse the switches that cc itself uses (e.g. -v). */
3747 for (i = 1; i < argc; i++)
3749 if (! strcmp (argv[i], "-dumpspecs"))
3751 struct spec_list *sl;
3753 for (sl = specs; sl; sl = sl->next)
3754 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3755 if (link_command_spec)
3756 printf ("*link_command:\n%s\n\n", link_command_spec);
3759 else if (! strcmp (argv[i], "-dumpversion"))
3761 printf ("%s\n", spec_version);
3764 else if (! strcmp (argv[i], "-dumpmachine"))
3766 printf ("%s\n", spec_machine);
3769 else if (strcmp (argv[i], "-fversion") == 0)
3771 /* translate_options () has turned --version into -fversion. */
3774 /* We will be passing a dummy file on to the sub-processes. */
3778 /* CPP driver cannot obtain switch from cc1_options. */
3780 add_preprocessor_option ("--version", strlen ("--version"));
3781 add_assembler_option ("--version", strlen ("--version"));
3782 add_linker_option ("--version", strlen ("--version"));
3784 else if (strcmp (argv[i], "-fhelp") == 0)
3786 /* translate_options () has turned --help into -fhelp. */
3787 print_help_list = 1;
3789 /* We will be passing a dummy file on to the sub-processes. */
3793 /* CPP driver cannot obtain switch from cc1_options. */
3795 add_preprocessor_option ("--help", 6);
3796 add_assembler_option ("--help", 6);
3797 add_linker_option ("--help", 6);
3799 else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3801 /* translate_options () has turned --help into -fhelp. */
3802 print_subprocess_help = 2;
3804 /* We will be passing a dummy file on to the sub-processes. */
3808 else if (strcmp (argv[i], "-ftarget-help") == 0)
3810 /* translate_options() has turned --target-help into -ftarget-help. */
3811 print_subprocess_help = 1;
3813 /* We will be passing a dummy file on to the sub-processes. */
3817 /* CPP driver cannot obtain switch from cc1_options. */
3819 add_preprocessor_option ("--target-help", 13);
3820 add_assembler_option ("--target-help", 13);
3821 add_linker_option ("--target-help", 13);
3823 else if (! strcmp (argv[i], "-pass-exit-codes"))
3825 pass_exit_codes = 1;
3828 else if (! strcmp (argv[i], "-print-search-dirs"))
3829 print_search_dirs = 1;
3830 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3831 print_file_name = "libgcc.a";
3832 else if (! strncmp (argv[i], "-print-file-name=", 17))
3833 print_file_name = argv[i] + 17;
3834 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3835 print_prog_name = argv[i] + 17;
3836 else if (! strcmp (argv[i], "-print-multi-lib"))
3837 print_multi_lib = 1;
3838 else if (! strcmp (argv[i], "-print-multi-directory"))
3839 print_multi_directory = 1;
3840 else if (! strcmp (argv[i], "-print-sysroot"))
3842 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3843 print_multi_os_directory = 1;
3844 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3845 print_sysroot_headers_suffix = 1;
3846 else if (! strcmp (argv[i], "-fcompare-debug-second"))
3848 compare_debug_second = 1;
3851 else if (! strcmp (argv[i], "-fno-compare-debug"))
3853 argv[i] = "-fcompare-debug=";
3854 goto compare_debug_with_arg;
3856 else if (! strcmp (argv[i], "-fcompare-debug"))
3858 argv[i] = "-fcompare-debug=-gtoggle";
3859 goto compare_debug_with_arg;
3861 #define OPT "-fcompare-debug="
3862 else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3865 compare_debug_with_arg:
3866 opt = argv[i] + sizeof (OPT) - 1;
3872 if (compare_debug < 0)
3873 compare_debug_opt = NULL;
3875 compare_debug_opt = opt;
3878 else if (! strncmp (argv[i], "-Wa,", 4))
3881 /* Pass the rest of this option to the assembler. */
3883 /* Split the argument at commas. */
3885 for (j = 4; argv[i][j]; j++)
3886 if (argv[i][j] == ',')
3888 add_assembler_option (argv[i] + prev, j - prev);
3892 /* Record the part after the last comma. */
3893 add_assembler_option (argv[i] + prev, j - prev);
3895 else if (! strncmp (argv[i], "-Wp,", 4))
3898 /* Pass the rest of this option to the preprocessor. */
3900 /* Split the argument at commas. */
3902 for (j = 4; argv[i][j]; j++)
3903 if (argv[i][j] == ',')
3905 add_preprocessor_option (argv[i] + prev, j - prev);
3909 /* Record the part after the last comma. */
3910 add_preprocessor_option (argv[i] + prev, j - prev);
3912 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3913 /* The +e options to the C++ front-end. */
3915 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3918 /* Split the argument at commas. */
3919 for (j = 3; argv[i][j]; j++)
3920 n_infiles += (argv[i][j] == ',');
3922 else if (strcmp (argv[i], "-Xlinker") == 0)
3925 fatal_error ("argument to '-Xlinker' is missing");
3930 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3933 fatal_error ("argument to '-Xpreprocessor' is missing");
3935 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3937 else if (strcmp (argv[i], "-Xassembler") == 0)
3940 fatal_error ("argument to '-Xassembler' is missing");
3942 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3944 else if (strcmp (argv[i], "-l") == 0)
3947 fatal_error ("argument to '-l' is missing");
3952 else if (strncmp (argv[i], "-l", 2) == 0)
3954 else if (strcmp (argv[i], "-save-temps") == 0)
3956 save_temps_flag = SAVE_TEMPS_CWD;
3959 else if (strncmp (argv[i], "-save-temps=", 12) == 0)
3962 if (strcmp (argv[i]+12, "cwd") == 0)
3963 save_temps_flag = SAVE_TEMPS_CWD;
3964 else if (strcmp (argv[i]+12, "obj") == 0
3965 || strcmp (argv[i]+12, "object") == 0)
3966 save_temps_flag = SAVE_TEMPS_OBJ;
3968 fatal_error ("'%s' is an unknown -save-temps option", argv[i]);
3970 else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
3971 /* Already handled as a special case, so ignored here. */
3973 else if (strcmp (argv[i], "-combine") == 0)
3978 else if (strcmp (argv[i], "-specs") == 0)
3980 struct user_specs *user = XNEW (struct user_specs);
3982 fatal_error ("argument to '-specs' is missing");
3984 user->next = (struct user_specs *) 0;
3985 user->filename = argv[i];
3986 if (user_specs_tail)
3987 user_specs_tail->next = user;
3989 user_specs_head = user;
3990 user_specs_tail = user;
3992 else if (strncmp (argv[i], "-specs=", 7) == 0)
3994 struct user_specs *user = XNEW (struct user_specs);
3995 if (strlen (argv[i]) == 7)
3996 fatal_error ("argument to '-specs=' is missing");
3998 user->next = (struct user_specs *) 0;
3999 user->filename = argv[i] + 7;
4000 if (user_specs_tail)
4001 user_specs_tail->next = user;
4003 user_specs_head = user;
4004 user_specs_tail = user;
4006 else if (strcmp (argv[i], "-time") == 0)
4008 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4010 if (report_times_to_file)
4011 fclose (report_times_to_file);
4012 report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
4014 else if (strcmp (argv[i], "-pipe") == 0)
4016 /* -pipe has to go into the switches array as well as
4021 else if (strcmp (argv[i], "-wrapper") == 0)
4024 fatal_error ("argument to '-wrapper' is missing");
4026 wrapper_string = argv[i];
4030 else if (strcmp (argv[i], "-###") == 0)
4032 /* This is similar to -v except that there is no execution
4033 of the commands and the echoed arguments are quoted. It
4034 is intended for use in shell scripts to capture the
4035 driver-generated command line. */
4036 verbose_only_flag++;
4039 else if (argv[i][0] == '-' && argv[i][1] != 0)
4041 const char *p = &argv[i][1];
4051 if (p[1] == 0 && i + 1 == argc)
4052 fatal_error ("argument to '-B' is missing");
4058 len = strlen (value);
4060 /* Catch the case where the user has forgotten to append a
4061 directory separator to the path. Note, they may be using
4062 -B to add an executable name prefix, eg "i386-elf-", in
4063 order to distinguish between multiple installations of
4064 GCC in the same directory. Hence we must check to see
4065 if appending a directory separator actually makes a
4066 valid directory name. */
4067 if (! IS_DIR_SEPARATOR (value [len - 1])
4068 && is_directory (value, false))
4070 char *tmp = XNEWVEC (char, len + 2);
4071 strcpy (tmp, value);
4072 tmp[len] = DIR_SEPARATOR;
4077 add_prefix (&exec_prefixes, value, NULL,
4078 PREFIX_PRIORITY_B_OPT, 0, 0);
4079 add_prefix (&startfile_prefixes, value, NULL,
4080 PREFIX_PRIORITY_B_OPT, 0, 0);
4081 add_prefix (&include_prefixes, value, NULL,
4082 PREFIX_PRIORITY_B_OPT, 0, 0);
4087 case 'v': /* Print our subcommands and print versions. */
4089 /* If they do anything other than exactly `-v', don't set
4090 verbose_flag; rather, continue on to give the error. */
4109 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4114 /* Forward scan, just in case -S, -E or -c is specified
4121 if (argv[j][0] == '-')
4123 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4129 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4130 j += skip - (argv[j][2] != 0);
4131 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4138 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4140 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4142 argv[i] = convert_filename (argv[i], ! have_c, 0);
4144 /* Save the output name in case -save-temps=obj was used. */
4145 if ((p[1] == 0) && argv[i + 1])
4146 save_temps_prefix = xstrdup(argv[i + 1]);
4148 save_temps_prefix = xstrdup(argv[i] + 1);
4154 #ifdef MODIFY_TARGET_NAME
4155 is_modify_target_name = 0;
4157 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4158 if (! strcmp (argv[i], modify_target[j].sw))
4160 char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
4161 + strlen (spec_machine));
4164 int made_addition = 0;
4166 is_modify_target_name = 1;
4167 for (p = spec_machine, q = new_name; *p != 0; )
4169 if (modify_target[j].add_del == DELETE
4170 && (! strncmp (q, modify_target[j].str,
4171 strlen (modify_target[j].str))))
4172 p += strlen (modify_target[j].str);
4173 else if (modify_target[j].add_del == ADD
4174 && ! made_addition && *p == '-')
4176 for (r = modify_target[j].str; *r != 0; )
4184 spec_machine = new_name;
4187 if (is_modify_target_name)
4193 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
4194 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
4195 else if (WORD_SWITCH_TAKES_ARG (p))
4196 i += WORD_SWITCH_TAKES_ARG (p);
4206 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4207 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4208 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4210 save_temps_length = strlen (save_temps_prefix);
4211 temp = strrchr (lbasename (save_temps_prefix), '.');
4214 save_temps_length -= strlen (temp);
4215 save_temps_prefix[save_temps_length] = '\0';
4219 else if (save_temps_prefix != NULL)
4221 free (save_temps_prefix);
4222 save_temps_prefix = NULL;
4225 if (save_temps_flag && use_pipes)
4227 /* -save-temps overrides -pipe, so that temp files are produced */
4228 if (save_temps_flag)
4229 warning (0, "-pipe ignored because -save-temps specified");
4235 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4237 if (gcd && gcd[0] == '-')
4240 compare_debug_opt = gcd;
4243 else if (gcd && *gcd && strcmp (gcd, "0"))
4246 compare_debug_opt = "-gtoggle";
4250 else if (compare_debug < 0)
4253 gcc_assert (!compare_debug_opt);
4256 /* Set up the search paths. We add directories that we expect to
4257 contain GNU Toolchain components before directories specified by
4258 the machine description so that we will find GNU components (like
4259 the GNU assembler) before those of the host system. */
4261 /* If we don't know where the toolchain has been installed, use the
4262 configured-in locations. */
4263 if (!gcc_exec_prefix)
4266 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4267 PREFIX_PRIORITY_LAST, 1, 0);
4268 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4269 PREFIX_PRIORITY_LAST, 2, 0);
4270 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4271 PREFIX_PRIORITY_LAST, 2, 0);
4273 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4274 PREFIX_PRIORITY_LAST, 1, 0);
4277 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4278 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4279 dir_separator_str, NULL);
4281 /* Look for tools relative to the location from which the driver is
4282 running, or, if that is not available, the configured prefix. */
4284 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4285 spec_machine, dir_separator_str,
4286 spec_version, dir_separator_str, tooldir_prefix, NULL);
4288 add_prefix (&exec_prefixes,
4289 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4290 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4291 add_prefix (&startfile_prefixes,
4292 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4293 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4295 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4296 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4297 then consider it to relocate with the rest of the GCC installation
4298 if GCC_EXEC_PREFIX is set.
4299 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4300 if (target_system_root && gcc_exec_prefix)
4302 char *tmp_prefix = get_relative_prefix (argv[0],
4303 standard_bindir_prefix,
4304 target_system_root);
4305 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4307 target_system_root = tmp_prefix;
4308 target_system_root_changed = 1;
4313 /* More prefixes are enabled in main, after we read the specs file
4314 and determine whether this is cross-compilation or not. */
4316 /* Then create the space for the vectors and scan again. */
4318 switches = XNEWVEC (struct switchstr, n_switches + 1);
4319 infiles = XNEWVEC (struct infile, n_infiles + 1);
4322 last_language_n_infiles = -1;
4324 /* This, time, copy the text of each switch and store a pointer
4325 to the copy in the vector of switches.
4326 Store all the infiles in their vector. */
4328 for (i = 1; i < argc; i++)
4330 /* Just skip the switches that were handled by the preceding loop. */
4331 #ifdef MODIFY_TARGET_NAME
4332 is_modify_target_name = 0;
4334 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4335 if (! strcmp (argv[i], modify_target[j].sw))
4336 is_modify_target_name = 1;
4338 if (is_modify_target_name)
4342 if (! strncmp (argv[i], "-Wa,", 4))
4344 else if (! strncmp (argv[i], "-Wp,", 4))
4346 else if (! strcmp (argv[i], "-no-canonical-prefixes"))
4348 else if (! strcmp (argv[i], "-pass-exit-codes"))
4350 else if (! strcmp (argv[i], "-print-search-dirs"))
4352 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4354 else if (! strncmp (argv[i], "-print-file-name=", 17))
4356 else if (! strncmp (argv[i], "-print-prog-name=", 17))
4358 else if (! strcmp (argv[i], "-print-multi-lib"))
4360 else if (! strcmp (argv[i], "-print-multi-directory"))
4362 else if (! strcmp (argv[i], "-print-sysroot"))
4364 else if (! strcmp (argv[i], "-print-multi-os-directory"))
4366 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4368 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4370 target_system_root = argv[i] + strlen ("--sysroot=");
4371 target_system_root_changed = 1;
4373 else if (argv[i][0] == '+' && argv[i][1] == 'e')
4375 /* Compensate for the +e options to the C++ front-end;
4376 they're there simply for cfront call-compatibility. We do
4377 some magic in default_compilers to pass them down properly.
4378 Note we deliberately start at the `+' here, to avoid passing
4379 -e0 or -e1 down into the linker. */
4380 switches[n_switches].part1 = &argv[i][0];
4381 switches[n_switches].args = 0;
4382 switches[n_switches].live_cond = 0;
4383 switches[n_switches].validated = 0;
4386 else if (strncmp (argv[i], "-Wl,", 4) == 0)
4389 /* Split the argument at commas. */
4391 for (j = 4; argv[i][j]; j++)
4392 if (argv[i][j] == ',')
4394 infiles[n_infiles].language = "*";
4395 infiles[n_infiles++].name
4396 = save_string (argv[i] + prev, j - prev);
4399 /* Record the part after the last comma. */
4400 infiles[n_infiles].language = "*";
4401 infiles[n_infiles++].name = argv[i] + prev;
4403 else if (strcmp (argv[i], "-Xlinker") == 0)
4405 infiles[n_infiles].language = "*";
4406 infiles[n_infiles++].name = argv[++i];
4408 /* Xassembler and Xpreprocessor were already handled in the first argv
4409 scan, so all we need to do here is ignore them and their argument. */
4410 else if (strcmp (argv[i], "-Xassembler") == 0)
4412 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4414 else if (strcmp (argv[i], "-l") == 0)
4415 { /* POSIX allows separation of -l and the lib arg;
4416 canonicalize by concatenating -l with its arg */
4417 infiles[n_infiles].language = "*";
4418 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4420 else if (strncmp (argv[i], "-l", 2) == 0)
4422 infiles[n_infiles].language = "*";
4423 infiles[n_infiles++].name = argv[i];
4425 else if (strcmp (argv[i], "-wrapper") == 0)
4427 else if (strcmp (argv[i], "-specs") == 0)
4429 else if (strncmp (argv[i], "-specs=", 7) == 0)
4431 else if (strcmp (argv[i], "-time") == 0)
4433 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4435 else if (strcmp (argv[i], "-###") == 0)
4437 else if (argv[i][0] == '-' && argv[i][1] != 0)
4439 const char *p = &argv[i][1];
4444 if (p[1] == 0 && i + 1 == argc)
4445 fatal_error ("argument to '-x' is missing");
4447 spec_lang = argv[++i];
4450 if (! strcmp (spec_lang, "none"))
4451 /* Suppress the warning if -xnone comes after the last input
4452 file, because alternate command interfaces like g++ might
4453 find it useful to place -xnone after each input file. */
4456 last_language_n_infiles = n_infiles;
4459 switches[n_switches].part1 = p;
4460 /* Deal with option arguments in separate argv elements. */
4461 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4462 || WORD_SWITCH_TAKES_ARG (p))
4465 int n_args = WORD_SWITCH_TAKES_ARG (p);
4469 /* Count only the option arguments in separate argv elements. */
4470 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4472 if (i + n_args >= argc)
4473 fatal_error ("argument to '-%s' is missing", p);
4474 switches[n_switches].args
4475 = XNEWVEC (const char *, n_args + 1);
4477 switches[n_switches].args[j++] = argv[++i];
4478 /* Null-terminate the vector. */
4479 switches[n_switches].args[j] = 0;
4481 else if (strchr (switches_need_spaces, c))
4483 /* On some systems, ld cannot handle some options without
4484 a space. So split the option from its argument. */
4485 char *part1 = XNEWVEC (char, 2);
4489 switches[n_switches].part1 = part1;
4490 switches[n_switches].args = XNEWVEC (const char *, 2);
4491 switches[n_switches].args[0] = xstrdup (p+1);
4492 switches[n_switches].args[1] = 0;
4495 switches[n_switches].args = 0;
4497 switches[n_switches].live_cond = 0;
4498 switches[n_switches].validated = 0;
4499 switches[n_switches].ordering = 0;
4500 /* These are always valid, since gcc.c itself understands the
4501 first four, gfortranspec.c understands -static-libgfortran
4502 and g++spec.c understands -static-libstdc++ */
4503 if (!strcmp (p, "save-temps")
4504 || !strcmp (p, "static-libgcc")
4505 || !strcmp (p, "shared-libgcc")
4506 || !strcmp (p, "pipe")
4507 || !strcmp (p, "static-libgfortran")
4508 || !strcmp (p, "static-libstdc++"))
4509 switches[n_switches].validated = 1;
4512 char ch = switches[n_switches].part1[0];
4514 switches[n_switches].validated = 1;
4520 const char *p = strrchr (argv[i], '@');
4524 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4525 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4527 /* For LTO static archive support we handle input file
4528 specifications that are composed of a filename and
4529 an offset like FNAME@OFFSET. */
4532 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4533 && strlen (p) == (unsigned int)consumed)
4535 fname = (char *)xmalloc (p - argv[i] + 1);
4536 memcpy (fname, argv[i], p - argv[i]);
4537 fname[p - argv[i]] = '\0';
4538 /* Only accept non-stdin and existing FNAME parts, otherwise
4539 try with the full name. */
4540 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4543 fname = xstrdup (argv[i]);
4547 fname = xstrdup (argv[i]);
4549 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4551 perror_with_name (fname);
4556 infiles[n_infiles].language = spec_lang;
4557 infiles[n_infiles++].name = argv[i];
4564 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4565 warning (0, "'-x %s' after last input file has no effect", spec_lang);
4567 if (compare_debug == 2 || compare_debug == 3)
4569 switches[n_switches].part1 = concat ("fcompare-debug=",
4572 switches[n_switches].args = 0;
4573 switches[n_switches].live_cond = 0;
4574 switches[n_switches].validated = 0;
4575 switches[n_switches].ordering = 0;
4580 /* Ensure we only invoke each subprocess once. */
4581 if (print_subprocess_help || print_help_list || print_version)
4585 /* Create a dummy input file, so that we can pass
4586 the help option on to the various sub-processes. */
4587 infiles[0].language = "c";
4588 infiles[0].name = "help-dummy";
4591 switches[n_switches].part1 = 0;
4592 infiles[n_infiles].name = 0;
4595 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4596 and place that in the environment. */
4599 set_collect_gcc_options (void)
4604 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4606 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4607 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4610 for (i = 0; (int) i < n_switches; i++)
4612 const char *const *args;
4615 obstack_grow (&collect_obstack, " ", 1);
4619 /* Ignore elided switches. */
4620 if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4623 obstack_grow (&collect_obstack, "'-", 2);
4624 q = switches[i].part1;
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);
4634 for (args = switches[i].args; args && *args; args++)
4636 obstack_grow (&collect_obstack, " '", 2);
4638 while ((p = strchr (q, '\'')))
4640 obstack_grow (&collect_obstack, q, p - q);
4641 obstack_grow (&collect_obstack, "'\\''", 4);
4644 obstack_grow (&collect_obstack, q, strlen (q));
4645 obstack_grow (&collect_obstack, "'", 1);
4648 obstack_grow (&collect_obstack, "\0", 1);
4649 xputenv (XOBFINISH (&collect_obstack, char *));
4652 /* Process a spec string, accumulating and running commands. */
4654 /* These variables describe the input file name.
4655 input_file_number is the index on outfiles of this file,
4656 so that the output file name can be stored for later use by %o.
4657 input_basename is the start of the part of the input file
4658 sans all directory names, and basename_length is the number
4659 of characters starting there excluding the suffix .c or whatever. */
4661 static const char *input_filename;
4662 static int input_file_number;
4663 size_t input_filename_length;
4664 static int basename_length;
4665 static int suffixed_basename_length;
4666 static const char *input_basename;
4667 static const char *input_suffix;
4668 #ifndef HOST_LACKS_INODE_NUMBERS
4669 static struct stat input_stat;
4671 static int input_stat_set;
4673 /* The compiler used to process the current input file. */
4674 static struct compiler *input_file_compiler;
4676 /* These are variables used within do_spec and do_spec_1. */
4678 /* Nonzero if an arg has been started and not yet terminated
4679 (with space, tab or newline). */
4680 static int arg_going;
4682 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4683 is a temporary file name. */
4684 static int delete_this_arg;
4686 /* Nonzero means %w has been seen; the next arg to be terminated
4687 is the output file name of this compilation. */
4688 static int this_is_output_file;
4690 /* Nonzero means %s has been seen; the next arg to be terminated
4691 is the name of a library file and we should try the standard
4692 search dirs for it. */
4693 static int this_is_library_file;
4695 /* Nonzero means %T has been seen; the next arg to be terminated
4696 is the name of a linker script and we should try all of the
4697 standard search dirs for it. If it is found insert a --script
4698 command line switch and then substitute the full path in place,
4699 otherwise generate an error message. */
4700 static int this_is_linker_script;
4702 /* Nonzero means that the input of this command is coming from a pipe. */
4703 static int input_from_pipe;
4705 /* Nonnull means substitute this for any suffix when outputting a switches
4707 static const char *suffix_subst;
4709 /* If there is an argument being accumulated, terminate it and store it. */
4712 end_going_arg (void)
4718 obstack_1grow (&obstack, 0);
4719 string = XOBFINISH (&obstack, const char *);
4720 if (this_is_library_file)
4721 string = find_file (string);
4722 if (this_is_linker_script)
4724 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4726 if (full_script_path == NULL)
4728 error ("unable to locate default linker script '%s' in the library search paths", string);
4729 /* Script was not found on search path. */
4732 store_arg ("--script", false, false);
4733 string = full_script_path;
4735 store_arg (string, delete_this_arg, this_is_output_file);
4736 if (this_is_output_file)
4737 outfiles[input_file_number] = string;
4743 /* Parse the WRAPPER string which is a comma separated list of the command line
4744 and insert them into the beginning of argbuf. */
4747 insert_wrapper (const char *wrapper)
4751 char *buf = xstrdup (wrapper);
4760 while ((p = strchr (p, ',')) != NULL);
4762 if (argbuf_index + n >= argbuf_length)
4764 argbuf_length = argbuf_length * 2;
4765 while (argbuf_length < argbuf_index + n)
4767 argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4769 for (i = argbuf_index - 1; i >= 0; i--)
4770 argbuf[i + n] = argbuf[i];
4783 while ((p = strchr (p, ',')) != NULL);
4784 gcc_assert (i == n);
4788 /* Process the spec SPEC and run the commands specified therein.
4789 Returns 0 if the spec is successfully processed; -1 if failed. */
4792 do_spec (const char *spec)
4796 value = do_spec_2 (spec);
4798 /* Force out any unfinished command.
4799 If -pipe, this forces out the last command if it ended in `|'. */
4802 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4805 set_collect_gcc_options ();
4807 if (argbuf_index > 0)
4815 do_spec_2 (const char *spec)
4821 delete_this_arg = 0;
4822 this_is_output_file = 0;
4823 this_is_library_file = 0;
4824 this_is_linker_script = 0;
4825 input_from_pipe = 0;
4826 suffix_subst = NULL;
4828 result = do_spec_1 (spec, 0, NULL);
4836 /* Process the given spec string and add any new options to the end
4837 of the switches/n_switches array. */
4840 do_option_spec (const char *name, const char *spec)
4842 unsigned int i, value_count, value_len;
4843 const char *p, *q, *value;
4844 char *tmp_spec, *tmp_spec_p;
4846 if (configure_default_options[0].name == NULL)
4849 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4850 if (strcmp (configure_default_options[i].name, name) == 0)
4852 if (i == ARRAY_SIZE (configure_default_options))
4855 value = configure_default_options[i].value;
4856 value_len = strlen (value);
4858 /* Compute the size of the final spec. */
4861 while ((p = strstr (p, "%(VALUE)")) != NULL)
4867 /* Replace each %(VALUE) by the specified value. */
4868 tmp_spec = (char *) alloca (strlen (spec) + 1
4869 + value_count * (value_len - strlen ("%(VALUE)")));
4870 tmp_spec_p = tmp_spec;
4872 while ((p = strstr (q, "%(VALUE)")) != NULL)
4874 memcpy (tmp_spec_p, q, p - q);
4875 tmp_spec_p = tmp_spec_p + (p - q);
4876 memcpy (tmp_spec_p, value, value_len);
4877 tmp_spec_p += value_len;
4878 q = p + strlen ("%(VALUE)");
4880 strcpy (tmp_spec_p, q);
4882 do_self_spec (tmp_spec);
4885 /* Process the given spec string and add any new options to the end
4886 of the switches/n_switches array. */
4889 do_self_spec (const char *spec)
4894 do_spec_1 (" ", 0, NULL);
4896 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4897 do_self_specs adds the replacements to switches array, so it shouldn't
4898 be processed afterwards. */
4899 for (i = 0; i < n_switches; i++)
4900 if ((switches[i].live_cond & SWITCH_IGNORE))
4901 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4903 if (argbuf_index > 0)
4905 switches = XRESIZEVEC (struct switchstr, switches,
4906 n_switches + argbuf_index + 1);
4908 for (i = 0; i < argbuf_index; i++)
4910 struct switchstr *sw;
4911 const char *p = argbuf[i];
4914 /* Each switch should start with '-'. */
4916 fatal_error ("switch '%s' does not start with '-'", argbuf[i]);
4921 sw = &switches[n_switches++];
4927 /* Deal with option arguments in separate argv elements. */
4928 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4929 || WORD_SWITCH_TAKES_ARG (p))
4932 int n_args = WORD_SWITCH_TAKES_ARG (p);
4936 /* Count only the option arguments in separate argv elements. */
4937 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4939 if (i + n_args >= argbuf_index)
4940 fatal_error ("argument to '-%s' is missing", p);
4942 = XNEWVEC (const char *, n_args + 1);
4944 sw->args[j++] = argbuf[++i];
4945 /* Null-terminate the vector. */
4948 else if (strchr (switches_need_spaces, c))
4950 /* On some systems, ld cannot handle some options without
4951 a space. So split the option from its argument. */
4952 char *part1 = XNEWVEC (char, 2);
4957 sw->args = XNEWVEC (const char *, 2);
4958 sw->args[0] = xstrdup (p+1);
4965 switches[n_switches].part1 = 0;
4969 /* Callback for processing %D and %I specs. */
4971 struct spec_path_info {
4976 bool separate_options;
4980 spec_path (char *path, void *data)
4982 struct spec_path_info *info = (struct spec_path_info *) data;
4986 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4989 if (info->append_len != 0)
4991 len = strlen (path);
4992 memcpy (path + len, info->append, info->append_len + 1);
4995 if (!is_directory (path, true))
4998 do_spec_1 (info->option, 1, NULL);
4999 if (info->separate_options)
5000 do_spec_1 (" ", 0, NULL);
5002 if (info->append_len == 0)
5004 len = strlen (path);
5005 save = path[len - 1];
5006 if (IS_DIR_SEPARATOR (path[len - 1]))
5007 path[len - 1] = '\0';
5010 do_spec_1 (path, 1, NULL);
5011 do_spec_1 (" ", 0, NULL);
5013 /* Must not damage the original path. */
5014 if (info->append_len == 0)
5015 path[len - 1] = save;
5020 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5024 create_at_file (char **argv)
5026 char *temp_file = make_temp_file ("");
5027 char *at_argument = concat ("@", temp_file, NULL);
5028 FILE *f = fopen (temp_file, "w");
5032 fatal_error ("could not open temporary response file %s",
5035 status = writeargv (argv, f);
5038 fatal_error ("could not write to temporary response file %s",
5041 status = fclose (f);
5044 fatal_error ("could not close temporary response file %s",
5047 store_arg (at_argument, 0, 0);
5049 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5052 /* True if we should compile INFILE. */
5055 compile_input_file_p (struct infile *infile)
5057 if ((!infile->language) || (infile->language[0] != '*'))
5058 if (infile->incompiler == input_file_compiler)
5063 /* Process the sub-spec SPEC as a portion of a larger spec.
5064 This is like processing a whole spec except that we do
5065 not initialize at the beginning and we do not supply a
5066 newline by default at the end.
5067 INSWITCH nonzero means don't process %-sequences in SPEC;
5068 in this case, % is treated as an ordinary character.
5069 This is used while substituting switches.
5070 INSWITCH nonzero also causes SPC not to terminate an argument.
5072 Value is zero unless a line was finished
5073 and the command on that line reported an error. */
5076 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5078 const char *p = spec;
5084 /* If substituting a switch, treat all chars like letters.
5085 Otherwise, NL, SPC, TAB and % are special. */
5086 switch (inswitch ? 'a' : c)
5091 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5093 /* A `|' before the newline means use a pipe here,
5094 but only if -pipe was specified.
5095 Otherwise, execute now and don't pass the `|' as an arg. */
5098 input_from_pipe = 1;
5105 set_collect_gcc_options ();
5107 if (argbuf_index > 0)
5113 /* Reinitialize for a new command, and for a new argument. */
5116 delete_this_arg = 0;
5117 this_is_output_file = 0;
5118 this_is_library_file = 0;
5119 this_is_linker_script = 0;
5120 input_from_pipe = 0;
5127 obstack_1grow (&obstack, c);
5135 /* Reinitialize for a new argument. */
5136 delete_this_arg = 0;
5137 this_is_output_file = 0;
5138 this_is_library_file = 0;
5139 this_is_linker_script = 0;
5146 fatal_error ("spec '%s' invalid", spec);
5149 if (save_temps_length)
5150 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5152 obstack_grow (&obstack, input_basename, basename_length);
5153 if (compare_debug < 0)
5154 obstack_grow (&obstack, ".gk", 3);
5159 if (save_temps_length)
5160 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5162 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5163 if (compare_debug < 0)
5164 obstack_grow (&obstack, ".gk", 3);
5169 delete_this_arg = 2;
5172 /* Dump out the directories specified with LIBRARY_PATH,
5173 followed by the absolute directories
5174 that we search for startfiles. */
5177 struct spec_path_info info;
5180 info.append_len = 0;
5181 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5182 /* Used on systems which record the specified -L dirs
5183 and use them to search for dynamic linking.
5184 Relative directories always come from -B,
5185 and it is better not to use them for searching
5186 at run time. In particular, stage1 loses. */
5187 info.omit_relative = true;
5189 info.omit_relative = false;
5191 info.separate_options = false;
5193 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5198 /* %efoo means report an error with `foo' as error message
5199 and don't execute any more commands for this file. */
5203 while (*p != 0 && *p != '\n')
5205 buf = (char *) alloca (p - q + 1);
5206 strncpy (buf, q, p - q);
5208 error ("%s", _(buf));
5213 /* %nfoo means report a notice with `foo' on stderr. */
5217 while (*p != 0 && *p != '\n')
5219 buf = (char *) alloca (p - q + 1);
5220 strncpy (buf, q, p - q);
5222 inform (0, "%s", _(buf));
5232 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5233 defined, and it is not a directory, and it is
5234 writable, use it. Otherwise, treat this like any
5235 other temporary file. */
5237 if ((!save_temps_flag)
5238 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5239 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5241 obstack_grow (&obstack, HOST_BIT_BUCKET,
5242 strlen (HOST_BIT_BUCKET));
5243 delete_this_arg = 0;
5248 goto create_temp_file;
5252 obstack_1grow (&obstack, '-');
5253 delete_this_arg = 0;
5256 /* consume suffix */
5257 while (*p == '.' || ISALNUM ((unsigned char) *p))
5259 if (p[0] == '%' && p[1] == 'O')
5264 goto create_temp_file;
5268 /* consume suffix */
5269 while (*p == '.' || ISALNUM ((unsigned char) *p))
5271 if (p[0] == '%' && p[1] == 'O')
5276 goto create_temp_file;
5282 struct temp_name *t;
5284 const char *suffix = p;
5285 char *saved_suffix = NULL;
5287 while (*p == '.' || ISALNUM ((unsigned char) *p))
5289 suffix_length = p - suffix;
5290 if (p[0] == '%' && p[1] == 'O')
5293 /* We don't support extra suffix characters after %O. */
5294 if (*p == '.' || ISALNUM ((unsigned char) *p))
5295 fatal_error ("spec '%s' has invalid '%%0%c'", spec, *p);
5296 if (suffix_length == 0)
5297 suffix = TARGET_OBJECT_SUFFIX;
5301 = XNEWVEC (char, suffix_length
5302 + strlen (TARGET_OBJECT_SUFFIX));
5303 strncpy (saved_suffix, suffix, suffix_length);
5304 strcpy (saved_suffix + suffix_length,
5305 TARGET_OBJECT_SUFFIX);
5307 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5310 if (compare_debug < 0)
5312 suffix = concat (".gk", suffix, NULL);
5316 /* If -save-temps=obj and -o were specified, use that for the
5318 if (save_temps_length)
5321 temp_filename_length
5322 = save_temps_length + suffix_length + 1;
5323 tmp = (char *) alloca (temp_filename_length);
5324 memcpy (tmp, save_temps_prefix, save_temps_length);
5325 memcpy (tmp + save_temps_length, suffix, suffix_length);
5326 tmp[save_temps_length + suffix_length] = '\0';
5327 temp_filename = save_string (tmp,
5328 temp_filename_length + 1);
5329 obstack_grow (&obstack, temp_filename,
5330 temp_filename_length);
5332 delete_this_arg = 0;
5336 /* If the input_filename has the same suffix specified
5337 for the %g, %u, or %U, and -save-temps is specified,
5338 we could end up using that file as an intermediate
5339 thus clobbering the user's source file (.e.g.,
5340 gcc -save-temps foo.s would clobber foo.s with the
5341 output of cpp0). So check for this condition and
5342 generate a temp file as the intermediate. */
5344 if (save_temps_flag)
5347 temp_filename_length = basename_length + suffix_length + 1;
5348 tmp = (char *) alloca (temp_filename_length);
5349 memcpy (tmp, input_basename, basename_length);
5350 memcpy (tmp + basename_length, suffix, suffix_length);
5351 tmp[basename_length + suffix_length] = '\0';
5352 temp_filename = tmp;
5354 if (strcmp (temp_filename, input_filename) != 0)
5356 #ifndef HOST_LACKS_INODE_NUMBERS
5357 struct stat st_temp;
5359 /* Note, set_input() resets input_stat_set to 0. */
5360 if (input_stat_set == 0)
5362 input_stat_set = stat (input_filename, &input_stat);
5363 if (input_stat_set >= 0)
5367 /* If we have the stat for the input_filename
5368 and we can do the stat for the temp_filename
5369 then the they could still refer to the same
5370 file if st_dev/st_ino's are the same. */
5371 if (input_stat_set != 1
5372 || stat (temp_filename, &st_temp) < 0
5373 || input_stat.st_dev != st_temp.st_dev
5374 || input_stat.st_ino != st_temp.st_ino)
5376 /* Just compare canonical pathnames. */
5377 char* input_realname = lrealpath (input_filename);
5378 char* temp_realname = lrealpath (temp_filename);
5379 bool files_differ = strcmp (input_realname, temp_realname);
5380 free (input_realname);
5381 free (temp_realname);
5385 temp_filename = save_string (temp_filename,
5386 temp_filename_length + 1);
5387 obstack_grow (&obstack, temp_filename,
5388 temp_filename_length);
5390 delete_this_arg = 0;
5396 /* See if we already have an association of %g/%u/%U and
5398 for (t = temp_names; t; t = t->next)
5399 if (t->length == suffix_length
5400 && strncmp (t->suffix, suffix, suffix_length) == 0
5401 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5404 /* Make a new association if needed. %u and %j
5406 if (t == 0 || c == 'u' || c == 'j')
5410 t = XNEW (struct temp_name);
5411 t->next = temp_names;
5414 t->length = suffix_length;
5417 t->suffix = saved_suffix;
5418 saved_suffix = NULL;
5421 t->suffix = save_string (suffix, suffix_length);
5422 t->unique = (c == 'u' || c == 'U' || c == 'j');
5423 temp_filename = make_temp_file (t->suffix);
5424 temp_filename_length = strlen (temp_filename);
5425 t->filename = temp_filename;
5426 t->filename_length = temp_filename_length;
5430 free (saved_suffix);
5432 obstack_grow (&obstack, t->filename, t->filename_length);
5433 delete_this_arg = 1;
5441 if (at_file_supplied)
5443 /* We are going to expand `%i' to `@FILE', where FILE
5444 is a newly-created temporary filename. The filenames
5445 that would usually be expanded in place of %o will be
5446 written to the temporary file. */
5451 for (i = 0; i < n_infiles; i++)
5452 if (compile_input_file_p (&infiles[i]))
5455 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5457 /* Copy the strings over. */
5458 for (i = 0, j = 0; i < n_infiles; i++)
5459 if (compile_input_file_p (&infiles[i]))
5461 argv[j] = CONST_CAST (char *, infiles[i].name);
5462 infiles[i].compiled = true;
5467 create_at_file (argv);
5470 for (i = 0; (int) i < n_infiles; i++)
5471 if (compile_input_file_p (&infiles[i]))
5473 store_arg (infiles[i].name, 0, 0);
5474 infiles[i].compiled = true;
5479 obstack_grow (&obstack, input_filename, input_filename_length);
5486 struct spec_path_info info;
5490 do_spec_1 ("-imultilib", 1, NULL);
5491 /* Make this a separate argument. */
5492 do_spec_1 (" ", 0, NULL);
5493 do_spec_1 (multilib_dir, 1, NULL);
5494 do_spec_1 (" ", 0, NULL);
5497 if (gcc_exec_prefix)
5499 do_spec_1 ("-iprefix", 1, NULL);
5500 /* Make this a separate argument. */
5501 do_spec_1 (" ", 0, NULL);
5502 do_spec_1 (gcc_exec_prefix, 1, NULL);
5503 do_spec_1 (" ", 0, NULL);
5506 if (target_system_root_changed ||
5507 (target_system_root && target_sysroot_hdrs_suffix))
5509 do_spec_1 ("-isysroot", 1, NULL);
5510 /* Make this a separate argument. */
5511 do_spec_1 (" ", 0, NULL);
5512 do_spec_1 (target_system_root, 1, NULL);
5513 if (target_sysroot_hdrs_suffix)
5514 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5515 do_spec_1 (" ", 0, NULL);
5518 info.option = "-isystem";
5519 info.append = "include";
5520 info.append_len = strlen (info.append);
5521 info.omit_relative = false;
5522 info.separate_options = true;
5524 for_each_path (&include_prefixes, false, info.append_len,
5527 info.append = "include-fixed";
5528 if (*sysroot_hdrs_suffix_spec)
5529 info.append = concat (info.append, dir_separator_str,
5530 multilib_dir, NULL);
5531 info.append_len = strlen (info.append);
5532 for_each_path (&include_prefixes, false, info.append_len,
5539 int max = n_infiles;
5540 max += lang_specific_extra_outfiles;
5542 if (HAVE_GNU_LD && at_file_supplied)
5544 /* We are going to expand `%o' to `@FILE', where FILE
5545 is a newly-created temporary filename. The filenames
5546 that would usually be expanded in place of %o will be
5547 written to the temporary file. */
5552 /* Convert OUTFILES into a form suitable for writeargv. */
5554 /* Determine how many are non-NULL. */
5555 for (n_files = 0, i = 0; i < max; i++)
5556 n_files += outfiles[i] != NULL;
5558 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5560 /* Copy the strings over. */
5561 for (i = 0, j = 0; i < max; i++)
5564 argv[j] = CONST_CAST (char *, outfiles[i]);
5569 create_at_file (argv);
5572 for (i = 0; i < max; i++)
5574 store_arg (outfiles[i], 0, 0);
5579 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5584 this_is_library_file = 1;
5588 this_is_linker_script = 1;
5592 outfiles[input_file_number] = NULL;
5596 this_is_output_file = 1;
5601 int cur_index = argbuf_index;
5602 /* Handle the {...} following the %W. */
5604 fatal_error ("spec '%s' has invalid '%%W%c", spec, *p);
5605 p = handle_braces (p + 1);
5609 /* If any args were output, mark the last one for deletion
5611 if (argbuf_index != cur_index)
5612 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5616 /* %x{OPTION} records OPTION for %X to output. */
5622 /* Skip past the option value and make a copy. */
5624 fatal_error ("spec '%s' has invalid '%%x%c'", spec, *p);
5627 string = save_string (p1 + 1, p - p1 - 2);
5629 /* See if we already recorded this option. */
5630 for (i = 0; i < n_linker_options; i++)
5631 if (! strcmp (string, linker_options[i]))
5637 /* This option is new; add it. */
5638 add_linker_option (string, strlen (string));
5642 /* Dump out the options accumulated previously using %x. */
5644 for (i = 0; i < n_linker_options; i++)
5646 do_spec_1 (linker_options[i], 1, NULL);
5647 /* Make each accumulated option a separate argument. */
5648 do_spec_1 (" ", 0, NULL);
5652 /* Dump out the options accumulated previously using -Wa,. */
5654 for (i = 0; i < n_assembler_options; i++)
5656 do_spec_1 (assembler_options[i], 1, NULL);
5657 /* Make each accumulated option a separate argument. */
5658 do_spec_1 (" ", 0, NULL);
5662 /* Dump out the options accumulated previously using -Wp,. */
5664 for (i = 0; i < n_preprocessor_options; i++)
5666 do_spec_1 (preprocessor_options[i], 1, NULL);
5667 /* Make each accumulated option a separate argument. */
5668 do_spec_1 (" ", 0, NULL);
5672 /* Here are digits and numbers that just process
5673 a certain constant string as a spec. */
5676 value = do_spec_1 (cc1_spec, 0, NULL);
5682 value = do_spec_1 (cc1plus_spec, 0, NULL);
5688 value = do_spec_1 (asm_spec, 0, NULL);
5694 value = do_spec_1 (asm_final_spec, 0, NULL);
5701 const char *const spec
5702 = (input_file_compiler->cpp_spec
5703 ? input_file_compiler->cpp_spec
5705 value = do_spec_1 (spec, 0, NULL);
5712 value = do_spec_1 (endfile_spec, 0, NULL);
5718 value = do_spec_1 (link_spec, 0, NULL);
5724 value = do_spec_1 (lib_spec, 0, NULL);
5730 value = do_spec_1 (libgcc_spec, 0, NULL);
5736 /* We assume there is a directory
5737 separator at the end of this string. */
5738 if (target_system_root)
5740 obstack_grow (&obstack, target_system_root,
5741 strlen (target_system_root));
5742 if (target_sysroot_suffix)
5743 obstack_grow (&obstack, target_sysroot_suffix,
5744 strlen (target_sysroot_suffix));
5749 value = do_spec_1 (startfile_spec, 0, NULL);
5754 /* Here we define characters other than letters and digits. */
5757 p = handle_braces (p);
5763 p = handle_spec_function (p);
5769 obstack_1grow (&obstack, '%');
5776 while (p[len] && p[len] != ' ' && p[len] != '%')
5778 suffix_subst = save_string (p - 1, len + 1);
5783 /* Henceforth ignore the option(s) matching the pattern
5788 int have_wildcard = 0;
5791 while (p[len] && p[len] != ' ' && p[len] != '\t')
5794 if (p[len-1] == '*')
5797 for (i = 0; i < n_switches; i++)
5798 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5799 && (have_wildcard || switches[i].part1[len] == '\0'))
5801 switches[i].live_cond |= SWITCH_IGNORE;
5802 switches[i].validated = 1;
5810 if (soft_matched_part)
5812 do_spec_1 (soft_matched_part, 1, NULL);
5813 do_spec_1 (" ", 0, NULL);
5816 /* Catch the case where a spec string contains something like
5817 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5818 hand side of the :. */
5819 error ("spec failure: '%%*' has not been initialized by pattern match");
5822 /* Process a string found as the value of a spec given by name.
5823 This feature allows individual machine descriptions
5824 to add and use their own specs.
5825 %[...] modifies -D options the way %P does;
5826 %(...) uses the spec unmodified. */
5828 warning (0, "use of obsolete %%[ operator in specs");
5831 const char *name = p;
5832 struct spec_list *sl;
5835 /* The string after the S/P is the name of a spec that is to be
5837 while (*p && *p != ')' && *p != ']')
5840 /* See if it's in the list. */
5841 for (len = p - name, sl = specs; sl; sl = sl->next)
5842 if (sl->name_len == len && !strncmp (sl->name, name, len))
5844 name = *(sl->ptr_spec);
5846 fnotice (stderr, "Processing spec %c%s%c, which is '%s'\n",
5847 c, sl->name, (c == '(') ? ')' : ']', name);
5856 value = do_spec_1 (name, 0, NULL);
5862 char *x = (char *) alloca (strlen (name) * 2 + 1);
5864 const char *y = name;
5867 /* Copy all of NAME into BUF, but put __ after
5868 every -D and at the end of each arg. */
5871 if (! strncmp (y, "-D", 2))
5882 && (*y == ' ' || *y == '\t' || *y == '='
5883 || *y == '}' || *y == 0))
5896 value = do_spec_1 (buf, 0, NULL);
5902 /* Discard the closing paren or bracket. */
5909 error ("spec failure: unrecognized spec option '%c'", c);
5915 /* Backslash: treat next character as ordinary. */
5920 /* Ordinary character: put it into the current argument. */
5921 obstack_1grow (&obstack, c);
5925 /* End of string. If we are processing a spec function, we need to
5926 end any pending argument. */
5927 if (processing_spec_function)
5933 /* Look up a spec function. */
5935 static const struct spec_function *
5936 lookup_spec_function (const char *name)
5938 const struct spec_function *sf;
5940 for (sf = static_spec_functions; sf->name != NULL; sf++)
5941 if (strcmp (sf->name, name) == 0)
5947 /* Evaluate a spec function. */
5950 eval_spec_function (const char *func, const char *args)
5952 const struct spec_function *sf;
5953 const char *funcval;
5955 /* Saved spec processing context. */
5956 int save_argbuf_index;
5957 int save_argbuf_length;
5958 const char **save_argbuf;
5961 int save_delete_this_arg;
5962 int save_this_is_output_file;
5963 int save_this_is_library_file;
5964 int save_input_from_pipe;
5965 int save_this_is_linker_script;
5966 const char *save_suffix_subst;
5969 sf = lookup_spec_function (func);
5971 fatal_error ("unknown spec function '%s'", func);
5973 /* Push the spec processing context. */
5974 save_argbuf_index = argbuf_index;
5975 save_argbuf_length = argbuf_length;
5976 save_argbuf = argbuf;
5978 save_arg_going = arg_going;
5979 save_delete_this_arg = delete_this_arg;
5980 save_this_is_output_file = this_is_output_file;
5981 save_this_is_library_file = this_is_library_file;
5982 save_this_is_linker_script = this_is_linker_script;
5983 save_input_from_pipe = input_from_pipe;
5984 save_suffix_subst = suffix_subst;
5986 /* Create a new spec processing context, and build the function
5990 if (do_spec_2 (args) < 0)
5991 fatal_error ("error in args to spec function '%s'", func);
5993 /* argbuf_index is an index for the next argument to be inserted, and
5994 so contains the count of the args already inserted. */
5996 funcval = (*sf->func) (argbuf_index, argbuf);
5998 /* Pop the spec processing context. */
5999 argbuf_index = save_argbuf_index;
6000 argbuf_length = save_argbuf_length;
6002 argbuf = save_argbuf;
6004 arg_going = save_arg_going;
6005 delete_this_arg = save_delete_this_arg;
6006 this_is_output_file = save_this_is_output_file;
6007 this_is_library_file = save_this_is_library_file;
6008 this_is_linker_script = save_this_is_linker_script;
6009 input_from_pipe = save_input_from_pipe;
6010 suffix_subst = save_suffix_subst;
6015 /* Handle a spec function call of the form:
6019 ARGS is processed as a spec in a separate context and split into an
6020 argument vector in the normal fashion. The function returns a string
6021 containing a spec which we then process in the caller's context, or
6022 NULL if no processing is required. */
6025 handle_spec_function (const char *p)
6028 const char *endp, *funcval;
6031 processing_spec_function++;
6033 /* Get the function name. */
6034 for (endp = p; *endp != '\0'; endp++)
6036 if (*endp == '(') /* ) */
6038 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6039 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6040 fatal_error ("malformed spec function name");
6042 if (*endp != '(') /* ) */
6043 fatal_error ("no arguments for spec function");
6044 func = save_string (p, endp - p);
6047 /* Get the arguments. */
6048 for (count = 0; *endp != '\0'; endp++)
6057 else if (*endp == '(') /* ) */
6062 fatal_error ("malformed spec function arguments");
6063 args = save_string (p, endp - p);
6066 /* p now points to just past the end of the spec function expression. */
6068 funcval = eval_spec_function (func, args);
6069 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6075 processing_spec_function--;
6080 /* Inline subroutine of handle_braces. Returns true if the current
6081 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6083 input_suffix_matches (const char *atom, const char *end_atom)
6085 return (input_suffix
6086 && !strncmp (input_suffix, atom, end_atom - atom)
6087 && input_suffix[end_atom - atom] == '\0');
6090 /* Subroutine of handle_braces. Returns true if the current
6091 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6093 input_spec_matches (const char *atom, const char *end_atom)
6095 return (input_file_compiler
6096 && input_file_compiler->suffix
6097 && input_file_compiler->suffix[0] != '\0'
6098 && !strncmp (input_file_compiler->suffix + 1, atom,
6100 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6103 /* Subroutine of handle_braces. Returns true if a switch
6104 matching the atom bracketed by ATOM and END_ATOM appeared on the
6107 switch_matches (const char *atom, const char *end_atom, int starred)
6110 int len = end_atom - atom;
6111 int plen = starred ? len : -1;
6113 for (i = 0; i < n_switches; i++)
6114 if (!strncmp (switches[i].part1, atom, len)
6115 && (starred || switches[i].part1[len] == '\0')
6116 && check_live_switch (i, plen))
6122 /* Inline subroutine of handle_braces. Mark all of the switches which
6123 match ATOM (extends to END_ATOM; STARRED indicates whether there
6124 was a star after the atom) for later processing. */
6126 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6129 int len = end_atom - atom;
6130 int plen = starred ? len : -1;
6132 for (i = 0; i < n_switches; i++)
6133 if (!strncmp (switches[i].part1, atom, len)
6134 && (starred || switches[i].part1[len] == '\0')
6135 && check_live_switch (i, plen))
6136 switches[i].ordering = 1;
6139 /* Inline subroutine of handle_braces. Process all the currently
6140 marked switches through give_switch, and clear the marks. */
6142 process_marked_switches (void)
6146 for (i = 0; i < n_switches; i++)
6147 if (switches[i].ordering == 1)
6149 switches[i].ordering = 0;
6154 /* Handle a %{ ... } construct. P points just inside the leading {.
6155 Returns a pointer one past the end of the brace block, or 0
6156 if we call do_spec_1 and that returns -1. */
6159 handle_braces (const char *p)
6161 const char *atom, *end_atom;
6162 const char *d_atom = NULL, *d_end_atom = NULL;
6163 const char *orig = p;
6171 bool a_must_be_last = false;
6172 bool ordered_set = false;
6173 bool disjunct_set = false;
6174 bool disj_matched = false;
6175 bool disj_starred = true;
6176 bool n_way_choice = false;
6177 bool n_way_matched = false;
6179 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6186 /* Scan one "atom" (S in the description above of %{}, possibly
6187 with '!', '.', '@', ',', or '*' modifiers). */
6189 a_is_suffix = false;
6190 a_is_starred = false;
6191 a_is_negated = false;
6192 a_is_spectype = false;
6196 p++, a_is_negated = true;
6200 p++, a_is_suffix = true;
6202 p++, a_is_spectype = true;
6205 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6206 || *p == ',' || *p == '.' || *p == '@')
6211 p++, a_is_starred = 1;
6217 /* Substitute the switch(es) indicated by the current atom. */
6219 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6220 || a_is_spectype || atom == end_atom)
6223 mark_matching_switches (atom, end_atom, a_is_starred);
6226 process_marked_switches ();
6230 /* Substitute some text if the current atom appears as a switch
6232 disjunct_set = true;
6236 if (atom == end_atom)
6238 if (!n_way_choice || disj_matched || *p == '|'
6239 || a_is_negated || a_is_suffix || a_is_spectype
6243 /* An empty term may appear as the last choice of an
6244 N-way choice set; it means "otherwise". */
6245 a_must_be_last = true;
6246 disj_matched = !n_way_matched;
6247 disj_starred = false;
6251 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6255 disj_starred = false;
6257 /* Don't bother testing this atom if we already have a
6259 if (!disj_matched && !n_way_matched)
6262 a_matched = input_suffix_matches (atom, end_atom);
6263 else if (a_is_spectype)
6264 a_matched = input_spec_matches (atom, end_atom);
6266 a_matched = switch_matches (atom, end_atom, a_is_starred);
6268 if (a_matched != a_is_negated)
6270 disj_matched = true;
6272 d_end_atom = end_atom;
6279 /* Found the body, that is, the text to substitute if the
6280 current disjunction matches. */
6281 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6282 disj_matched && !n_way_matched);
6286 /* If we have an N-way choice, reset state for the next
6290 n_way_choice = true;
6291 n_way_matched |= disj_matched;
6292 disj_matched = false;
6293 disj_starred = true;
6294 d_atom = d_end_atom = NULL;
6303 while (*p++ != '}');
6308 fatal_error ("braced spec '%s' is invalid at '%c'", orig, *p);
6313 /* Subroutine of handle_braces. Scan and process a brace substitution body
6314 (X in the description of %{} syntax). P points one past the colon;
6315 ATOM and END_ATOM bracket the first atom which was found to be true
6316 (present) in the current disjunction; STARRED indicates whether all
6317 the atoms in the current disjunction were starred (for syntax validation);
6318 MATCHED indicates whether the disjunction matched or not, and therefore
6319 whether or not the body is to be processed through do_spec_1 or just
6320 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6324 process_brace_body (const char *p, const char *atom, const char *end_atom,
6325 int starred, int matched)
6327 const char *body, *end_body;
6328 unsigned int nesting_level;
6329 bool have_subst = false;
6331 /* Locate the closing } or ;, honoring nested braces.
6332 Trim trailing whitespace. */
6341 if (!--nesting_level)
6344 else if (*p == ';' && nesting_level == 1)
6346 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6348 else if (*p == '\0')
6354 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6357 if (have_subst && !starred)
6362 /* Copy the substitution body to permanent storage and execute it.
6363 If have_subst is false, this is a simple matter of running the
6364 body through do_spec_1... */
6365 char *string = save_string (body, end_body - body);
6368 if (do_spec_1 (string, 0, NULL) < 0)
6373 /* ... but if have_subst is true, we have to process the
6374 body once for each matching switch, with %* set to the
6375 variant part of the switch. */
6376 unsigned int hard_match_len = end_atom - atom;
6379 for (i = 0; i < n_switches; i++)
6380 if (!strncmp (switches[i].part1, atom, hard_match_len)
6381 && check_live_switch (i, hard_match_len))
6383 if (do_spec_1 (string, 0,
6384 &switches[i].part1[hard_match_len]) < 0)
6386 /* Pass any arguments this switch has. */
6388 suffix_subst = NULL;
6396 fatal_error ("braced spec body '%s' is invalid", body);
6399 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6400 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6401 spec, or -1 if either exact match or %* is used.
6403 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6404 whose value does not begin with "no-" is obsoleted by the same value
6405 with the "no-", similarly for a switch with the "no-" prefix. */
6408 check_live_switch (int switchnum, int prefix_length)
6410 const char *name = switches[switchnum].part1;
6413 /* If we already processed this switch and determined if it was
6414 live or not, return our past determination. */
6415 if (switches[switchnum].live_cond != 0)
6416 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6417 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6418 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6421 /* In the common case of {<at-most-one-letter>*}, a negating
6422 switch would always match, so ignore that case. We will just
6423 send the conflicting switches to the compiler phase. */
6424 if (prefix_length >= 0 && prefix_length <= 1)
6427 /* Now search for duplicate in a manner that depends on the name. */
6431 for (i = switchnum + 1; i < n_switches; i++)
6432 if (switches[i].part1[0] == 'O')
6434 switches[switchnum].validated = 1;
6435 switches[switchnum].live_cond = SWITCH_FALSE;
6440 case 'W': case 'f': case 'm':
6441 if (! strncmp (name + 1, "no-", 3))
6443 /* We have Xno-YYY, search for XYYY. */
6444 for (i = switchnum + 1; i < n_switches; i++)
6445 if (switches[i].part1[0] == name[0]
6446 && ! strcmp (&switches[i].part1[1], &name[4]))
6448 switches[switchnum].validated = 1;
6449 switches[switchnum].live_cond = SWITCH_FALSE;
6455 /* We have XYYY, search for Xno-YYY. */
6456 for (i = switchnum + 1; i < n_switches; i++)
6457 if (switches[i].part1[0] == name[0]
6458 && switches[i].part1[1] == 'n'
6459 && switches[i].part1[2] == 'o'
6460 && switches[i].part1[3] == '-'
6461 && !strcmp (&switches[i].part1[4], &name[1]))
6463 switches[switchnum].validated = 1;
6464 switches[switchnum].live_cond = SWITCH_FALSE;
6471 /* Otherwise the switch is live. */
6472 switches[switchnum].live_cond |= SWITCH_LIVE;
6476 /* Pass a switch to the current accumulating command
6477 in the same form that we received it.
6478 SWITCHNUM identifies the switch; it is an index into
6479 the vector of switches gcc received, which is `switches'.
6480 This cannot fail since it never finishes a command line.
6482 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6485 give_switch (int switchnum, int omit_first_word)
6487 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6490 if (!omit_first_word)
6492 do_spec_1 ("-", 0, NULL);
6493 do_spec_1 (switches[switchnum].part1, 1, NULL);
6496 if (switches[switchnum].args != 0)
6499 for (p = switches[switchnum].args; *p; p++)
6501 const char *arg = *p;
6503 do_spec_1 (" ", 0, NULL);
6506 unsigned length = strlen (arg);
6509 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6510 if (arg[length] == '.')
6512 (CONST_CAST(char *, arg))[length] = 0;
6516 do_spec_1 (arg, 1, NULL);
6518 (CONST_CAST(char *, arg))[length] = '.';
6519 do_spec_1 (suffix_subst, 1, NULL);
6522 do_spec_1 (arg, 1, NULL);
6526 do_spec_1 (" ", 0, NULL);
6527 switches[switchnum].validated = 1;
6530 /* Search for a file named NAME trying various prefixes including the
6531 user's -B prefix and some standard ones.
6532 Return the absolute file name found. If nothing is found, return NAME. */
6535 find_file (const char *name)
6537 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6538 return newname ? newname : name;
6541 /* Determine whether a directory exists. If LINKER, return 0 for
6542 certain fixed names not needed by the linker. */
6545 is_directory (const char *path1, bool linker)
6552 /* Ensure the string ends with "/.". The resulting path will be a
6553 directory even if the given path is a symbolic link. */
6554 len1 = strlen (path1);
6555 path = (char *) alloca (3 + len1);
6556 memcpy (path, path1, len1);
6558 if (!IS_DIR_SEPARATOR (cp[-1]))
6559 *cp++ = DIR_SEPARATOR;
6563 /* Exclude directories that the linker is known to search. */
6565 && IS_DIR_SEPARATOR (path[0])
6567 && strncmp (path + 1, "lib", 3) == 0)
6569 && strncmp (path + 1, "usr", 3) == 0
6570 && IS_DIR_SEPARATOR (path[4])
6571 && strncmp (path + 5, "lib", 3) == 0)))
6574 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6577 /* Set up the various global variables to indicate that we're processing
6578 the input file named FILENAME. */
6581 set_input (const char *filename)
6585 input_filename = filename;
6586 input_filename_length = strlen (input_filename);
6587 input_basename = lbasename (input_filename);
6589 /* Find a suffix starting with the last period,
6590 and set basename_length to exclude that suffix. */
6591 basename_length = strlen (input_basename);
6592 suffixed_basename_length = basename_length;
6593 p = input_basename + basename_length;
6594 while (p != input_basename && *p != '.')
6596 if (*p == '.' && p != input_basename)
6598 basename_length = p - input_basename;
6599 input_suffix = p + 1;
6604 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6605 we will need to do a stat on the input_filename. The
6606 INPUT_STAT_SET signals that the stat is needed. */
6610 /* On fatal signals, delete all the temporary files. */
6613 fatal_signal (int signum)
6615 signal (signum, SIG_DFL);
6616 delete_failure_queue ();
6617 delete_temp_files ();
6618 /* Get the same signal again, this time not handled,
6619 so its normal effect occurs. */
6620 kill (getpid (), signum);
6623 /* Compare the contents of the two files named CMPFILE[0] and
6624 CMPFILE[1]. Return zero if they're identical, nonzero
6628 compare_files (char *cmpfile[])
6631 FILE *temp[2] = { NULL, NULL };
6637 void *map[2] = { NULL, NULL };
6639 for (i = 0; i < 2; i++)
6643 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6645 error ("%s: could not determine length of compare-debug file %s",
6646 input_filename, cmpfile[i]);
6651 length[i] = st.st_size;
6654 if (!ret && length[0] != length[1])
6656 error ("%s: -fcompare-debug failure (length)", input_filename);
6661 for (i = 0; i < 2; i++)
6663 int fd = open (cmpfile[i], O_RDONLY);
6666 error ("%s: could not open compare-debug file %s",
6667 input_filename, cmpfile[i]);
6672 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6675 if (map[i] == (void *) MAP_FAILED)
6684 if (memcmp (map[0], map[1], length[0]) != 0)
6686 error ("%s: -fcompare-debug failure", input_filename);
6691 for (i = 0; i < 2; i++)
6693 munmap ((caddr_t) map[i], length[i]);
6702 for (i = 0; i < 2; i++)
6704 temp[i] = fopen (cmpfile[i], "r");
6707 error ("%s: could not open compare-debug file %s",
6708 input_filename, cmpfile[i]);
6714 if (!ret && temp[0] && temp[1])
6718 c0 = fgetc (temp[0]);
6719 c1 = fgetc (temp[1]);
6723 error ("%s: -fcompare-debug failure",
6733 for (i = 1; i >= 0; i--)
6742 extern int main (int, char **);
6745 main (int argc, char **argv)
6749 int linker_was_run = 0;
6750 int lang_n_infiles = 0;
6751 int num_linker_inputs = 0;
6752 char *explicit_link_files;
6755 struct user_specs *uptr;
6756 char **old_argv = argv;
6758 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6759 on ?: in file-scope variable initializations. */
6760 asm_debug = ASM_DEBUG_SPEC;
6762 p = argv[0] + strlen (argv[0]);
6763 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6767 xmalloc_set_program_name (programname);
6769 expandargv (&argc, &argv);
6771 /* Determine if any expansions were made. */
6772 if (argv != old_argv)
6773 at_file_supplied = true;
6775 prune_options (&argc, &argv);
6777 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6778 /* Perform host dependent initialization when needed. */
6779 GCC_DRIVER_HOST_INITIALIZATION;
6782 /* Unlock the stdio streams. */
6783 unlock_std_streams ();
6785 gcc_init_libintl ();
6787 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6788 signal (SIGINT, fatal_signal);
6790 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6791 signal (SIGHUP, fatal_signal);
6793 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6794 signal (SIGTERM, fatal_signal);
6796 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6797 signal (SIGPIPE, fatal_signal);
6800 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6801 receive the signal. A different setting is inheritable */
6802 signal (SIGCHLD, SIG_DFL);
6805 /* Allocate the argument vector. */
6808 obstack_init (&obstack);
6810 /* Build multilib_select, et. al from the separate lines that make up each
6811 multilib selection. */
6813 const char *const *q = multilib_raw;
6816 obstack_init (&multilib_obstack);
6817 while ((p = *q++) != (char *) 0)
6818 obstack_grow (&multilib_obstack, p, strlen (p));
6820 obstack_1grow (&multilib_obstack, 0);
6821 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6823 q = multilib_matches_raw;
6824 while ((p = *q++) != (char *) 0)
6825 obstack_grow (&multilib_obstack, p, strlen (p));
6827 obstack_1grow (&multilib_obstack, 0);
6828 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6830 q = multilib_exclusions_raw;
6831 while ((p = *q++) != (char *) 0)
6832 obstack_grow (&multilib_obstack, p, strlen (p));
6834 obstack_1grow (&multilib_obstack, 0);
6835 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6838 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6841 obstack_1grow (&multilib_obstack, ' ');
6842 obstack_grow (&multilib_obstack,
6843 multilib_defaults_raw[i],
6844 strlen (multilib_defaults_raw[i]));
6848 obstack_1grow (&multilib_obstack, 0);
6849 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6852 #ifdef INIT_ENVIRONMENT
6853 /* Set up any other necessary machine specific environment variables. */
6854 xputenv (INIT_ENVIRONMENT);
6857 /* Make a table of what switches there are (switches, n_switches).
6858 Make a table of specified input files (infiles, n_infiles).
6859 Decode switches that are handled locally. */
6861 process_command (argc, CONST_CAST2 (const char **, char **, argv));
6863 /* Initialize the vector of specs to just the default.
6864 This means one element containing 0s, as a terminator. */
6866 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6867 memcpy (compilers, default_compilers, sizeof default_compilers);
6868 n_compilers = n_default_compilers;
6870 /* Read specs from a file if there is one. */
6872 machine_suffix = concat (spec_machine, dir_separator_str,
6873 spec_version, dir_separator_str, NULL);
6874 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6876 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6877 /* Read the specs file unless it is a default one. */
6878 if (specs_file != 0 && strcmp (specs_file, "specs"))
6879 read_specs (specs_file, TRUE);
6883 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6884 for any override of as, ld and libraries. */
6885 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6886 + strlen (just_machine_suffix) + sizeof ("specs"));
6888 strcpy (specs_file, standard_exec_prefix);
6889 strcat (specs_file, just_machine_suffix);
6890 strcat (specs_file, "specs");
6891 if (access (specs_file, R_OK) == 0)
6892 read_specs (specs_file, TRUE);
6894 /* Process any configure-time defaults specified for the command line
6895 options, via OPTION_DEFAULT_SPECS. */
6896 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6897 do_option_spec (option_default_specs[i].name,
6898 option_default_specs[i].spec);
6900 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6901 of the command line. */
6903 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6904 do_self_spec (driver_self_specs[i]);
6908 enum save_temps save;
6910 if (!compare_debug_second)
6912 n_switches_debug_check[1] = n_switches;
6913 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6916 do_self_spec ("%:compare-debug-self-opt()");
6917 n_switches_debug_check[0] = n_switches;
6918 switches_debug_check[0] = switches;
6920 n_switches = n_switches_debug_check[1];
6921 switches = switches_debug_check[1];
6924 /* Avoid crash when computing %j in this early. */
6925 save = save_temps_flag;
6926 save_temps_flag = SAVE_TEMPS_NONE;
6928 compare_debug = -compare_debug;
6929 do_self_spec ("%:compare-debug-self-opt()");
6931 save_temps_flag = save;
6933 if (!compare_debug_second)
6935 n_switches_debug_check[1] = n_switches;
6936 switches_debug_check[1] = switches;
6937 compare_debug = -compare_debug;
6938 n_switches = n_switches_debug_check[0];
6939 switches = switches_debug_check[0];
6943 /* If not cross-compiling, look for executables in the standard
6945 if (*cross_compile == '0')
6947 if (*md_exec_prefix)
6949 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6950 PREFIX_PRIORITY_LAST, 0, 0);
6954 /* Process sysroot_suffix_spec. */
6955 if (*sysroot_suffix_spec != 0
6956 && do_spec_2 (sysroot_suffix_spec) == 0)
6958 if (argbuf_index > 1)
6959 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6960 else if (argbuf_index == 1)
6961 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6964 #ifdef HAVE_LD_SYSROOT
6965 /* Pass the --sysroot option to the linker, if it supports that. If
6966 there is a sysroot_suffix_spec, it has already been processed by
6967 this point, so target_system_root really is the system root we
6969 if (target_system_root)
6971 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6972 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6973 set_spec ("link", XOBFINISH (&obstack, const char *));
6977 /* Process sysroot_hdrs_suffix_spec. */
6978 if (*sysroot_hdrs_suffix_spec != 0
6979 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6981 if (argbuf_index > 1)
6982 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6983 else if (argbuf_index == 1)
6984 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6987 /* Look for startfiles in the standard places. */
6988 if (*startfile_prefix_spec != 0
6989 && do_spec_2 (startfile_prefix_spec) == 0
6990 && do_spec_1 (" ", 0, NULL) == 0)
6993 for (ndx = 0; ndx < argbuf_index; ndx++)
6994 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6995 PREFIX_PRIORITY_LAST, 0, 1);
6997 /* We should eventually get rid of all these and stick to
6998 startfile_prefix_spec exclusively. */
6999 else if (*cross_compile == '0' || target_system_root)
7001 if (*md_startfile_prefix)
7002 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
7003 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7005 if (*md_startfile_prefix_1)
7006 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
7007 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7009 /* If standard_startfile_prefix is relative, base it on
7010 standard_exec_prefix. This lets us move the installed tree
7011 as a unit. If GCC_EXEC_PREFIX is defined, base
7012 standard_startfile_prefix on that as well.
7014 If the prefix is relative, only search it for native compilers;
7015 otherwise we will search a directory containing host libraries. */
7016 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7017 add_sysrooted_prefix (&startfile_prefixes,
7018 standard_startfile_prefix, "BINUTILS",
7019 PREFIX_PRIORITY_LAST, 0, 1);
7020 else if (*cross_compile == '0')
7022 add_prefix (&startfile_prefixes,
7023 concat (gcc_exec_prefix
7024 ? gcc_exec_prefix : standard_exec_prefix,
7026 standard_startfile_prefix, NULL),
7027 NULL, PREFIX_PRIORITY_LAST, 0, 1);
7030 /* Sysrooted prefixes are relocated because target_system_root is
7031 also relocated by gcc_exec_prefix. */
7032 if (*standard_startfile_prefix_1)
7033 add_sysrooted_prefix (&startfile_prefixes,
7034 standard_startfile_prefix_1, "BINUTILS",
7035 PREFIX_PRIORITY_LAST, 0, 1);
7036 if (*standard_startfile_prefix_2)
7037 add_sysrooted_prefix (&startfile_prefixes,
7038 standard_startfile_prefix_2, "BINUTILS",
7039 PREFIX_PRIORITY_LAST, 0, 1);
7042 /* Process any user specified specs in the order given on the command
7044 for (uptr = user_specs_head; uptr; uptr = uptr->next)
7046 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7048 read_specs (filename ? filename : uptr->filename, FALSE);
7051 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7052 if (gcc_exec_prefix)
7053 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7054 spec_version, dir_separator_str, NULL);
7056 /* Now we have the specs.
7057 Set the `valid' bits for switches that match anything in any spec. */
7059 validate_all_switches ();
7061 /* Now that we have the switches and the specs, set
7062 the subdirectory based on the options. */
7063 set_multilib_dir ();
7065 /* Set up to remember the pathname of gcc and any options
7066 needed for collect. We use argv[0] instead of programname because
7067 we need the complete pathname. */
7068 obstack_init (&collect_obstack);
7069 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7070 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7071 xputenv (XOBFINISH (&collect_obstack, char *));
7073 /* Set up to remember the pathname of the lto wrapper. */
7075 lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7076 if (lto_wrapper_spec)
7078 obstack_init (&collect_obstack);
7079 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7080 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7081 obstack_grow (&collect_obstack, lto_wrapper_spec,
7082 strlen (lto_wrapper_spec) + 1);
7083 xputenv (XOBFINISH (&collect_obstack, char *));
7086 /* Warn about any switches that no pass was interested in. */
7088 for (i = 0; (int) i < n_switches; i++)
7089 if (! switches[i].validated)
7090 error ("unrecognized option '-%s'", switches[i].part1);
7092 /* Obey some of the options. */
7094 if (print_search_dirs)
7096 printf (_("install: %s%s\n"),
7097 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7098 gcc_exec_prefix ? "" : machine_suffix);
7099 printf (_("programs: %s\n"),
7100 build_search_list (&exec_prefixes, "", false, false));
7101 printf (_("libraries: %s\n"),
7102 build_search_list (&startfile_prefixes, "", false, true));
7106 if (print_file_name)
7108 printf ("%s\n", find_file (print_file_name));
7112 if (print_prog_name)
7114 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7115 printf ("%s\n", (newname ? newname : print_prog_name));
7119 if (print_multi_lib)
7121 print_multilib_info ();
7125 if (print_multi_directory)
7127 if (multilib_dir == NULL)
7130 printf ("%s\n", multilib_dir);
7136 if (target_system_root)
7138 if (target_sysroot_suffix)
7139 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7141 printf ("%s\n", target_system_root);
7146 if (print_multi_os_directory)
7148 if (multilib_os_dir == NULL)
7151 printf ("%s\n", multilib_os_dir);
7155 if (print_sysroot_headers_suffix)
7157 if (*sysroot_hdrs_suffix_spec)
7159 printf("%s\n", (target_sysroot_hdrs_suffix
7160 ? target_sysroot_hdrs_suffix
7165 /* The error status indicates that only one set of fixed
7166 headers should be built. */
7167 fatal_error ("not configured with sysroot headers suffix");
7170 if (print_help_list)
7176 printf (_("\nFor bug reporting instructions, please see:\n"));
7177 printf ("%s.\n", bug_report_url);
7182 /* We do not exit here. Instead we have created a fake input file
7183 called 'help-dummy' which needs to be compiled, and we pass this
7184 on the various sub-processes, along with the --help switch.
7185 Ensure their output appears after ours. */
7186 fputc ('\n', stdout);
7192 printf (_("%s %s%s\n"), programname, pkgversion_string,
7194 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7196 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7197 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7202 /* We do not exit here. We use the same mechanism of --help to print
7203 the version of the sub-processes. */
7204 fputc ('\n', stdout);
7213 fnotice (stderr, "Target: %s\n", spec_machine);
7214 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
7216 #ifdef THREAD_MODEL_SPEC
7217 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7218 but there's no point in doing all this processing just to get
7219 thread_model back. */
7220 obstack_init (&obstack);
7221 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7222 obstack_1grow (&obstack, '\0');
7223 thrmod = XOBFINISH (&obstack, const char *);
7225 thrmod = thread_model;
7228 fnotice (stderr, "Thread model: %s\n", thrmod);
7230 /* compiler_version is truncated at the first space when initialized
7231 from version string, so truncate version_string at the first space
7232 before comparing. */
7233 for (n = 0; version_string[n]; n++)
7234 if (version_string[n] == ' ')
7237 if (! strncmp (version_string, compiler_version, n)
7238 && compiler_version[n] == 0)
7239 fnotice (stderr, "gcc version %s %s\n", version_string,
7242 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
7243 version_string, pkgversion_string, compiler_version);
7249 if (n_infiles == added_libraries)
7250 fatal_error ("no input files");
7252 /* Make a place to record the compiler output file names
7253 that correspond to the input files. */
7256 i += lang_specific_extra_outfiles;
7257 outfiles = XCNEWVEC (const char *, i);
7259 /* Record which files were specified explicitly as link input. */
7261 explicit_link_files = XCNEWVEC (char, n_infiles);
7264 combine_inputs = true;
7266 combine_inputs = false;
7268 for (i = 0; (int) i < n_infiles; i++)
7270 const char *name = infiles[i].name;
7271 struct compiler *compiler = lookup_compiler (name,
7273 infiles[i].language);
7275 if (compiler && !(compiler->combinable))
7276 combine_inputs = false;
7278 if (lang_n_infiles > 0 && compiler != input_file_compiler
7279 && infiles[i].language && infiles[i].language[0] != '*')
7280 infiles[i].incompiler = compiler;
7284 input_file_compiler = compiler;
7285 infiles[i].incompiler = compiler;
7289 /* Since there is no compiler for this input file, assume it is a
7291 explicit_link_files[i] = 1;
7292 infiles[i].incompiler = NULL;
7294 infiles[i].compiled = false;
7295 infiles[i].preprocessed = false;
7298 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7299 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7301 if (combine_flag && save_temps_flag)
7303 bool save_combine_inputs = combine_inputs;
7304 /* Must do a separate pre-processing pass for C & Objective-C files, to
7305 obtain individual .i files. */
7307 combine_inputs = false;
7308 for (i = 0; (int) i < n_infiles; i++)
7310 int this_file_error = 0;
7312 input_file_number = i;
7313 set_input (infiles[i].name);
7314 if (infiles[i].incompiler
7315 && (infiles[i].incompiler)->needs_preprocessing)
7316 input_file_compiler = infiles[i].incompiler;
7320 if (input_file_compiler)
7322 if (input_file_compiler->spec[0] == '#')
7324 error ("%s: %s compiler not installed on this system",
7325 input_filename, &input_file_compiler->spec[1]);
7326 this_file_error = 1;
7330 value = do_spec (input_file_compiler->spec);
7331 infiles[i].preprocessed = true;
7332 if (!have_o_argbuf_index)
7333 fatal_error ("spec '%s' is invalid",
7334 input_file_compiler->spec);
7335 infiles[i].name = argbuf[have_o_argbuf_index];
7336 infiles[i].incompiler
7337 = lookup_compiler (infiles[i].name,
7338 strlen (infiles[i].name),
7339 infiles[i].language);
7342 this_file_error = 1;
7346 if (this_file_error)
7348 delete_failure_queue ();
7352 clear_failure_queue ();
7354 combine_inputs = save_combine_inputs;
7357 for (i = 0; (int) i < n_infiles; i++)
7359 int this_file_error = 0;
7361 /* Tell do_spec what to substitute for %i. */
7363 input_file_number = i;
7364 set_input (infiles[i].name);
7366 if (infiles[i].compiled)
7369 /* Use the same thing in %o, unless cp->spec says otherwise. */
7371 outfiles[i] = input_filename;
7373 /* Figure out which compiler from the file's suffix. */
7375 if (! combine_inputs)
7377 = lookup_compiler (infiles[i].name, input_filename_length,
7378 infiles[i].language);
7380 input_file_compiler = infiles[i].incompiler;
7382 if (input_file_compiler)
7384 /* Ok, we found an applicable compiler. Run its spec. */
7386 if (input_file_compiler->spec[0] == '#')
7388 error ("%s: %s compiler not installed on this system",
7389 input_filename, &input_file_compiler->spec[1]);
7390 this_file_error = 1;
7396 if (debug_check_temp_file[0])
7397 free (debug_check_temp_file[0]);
7398 debug_check_temp_file[0] = NULL;
7400 if (debug_check_temp_file[1])
7401 free (debug_check_temp_file[1]);
7402 debug_check_temp_file[1] = NULL;
7405 value = do_spec (input_file_compiler->spec);
7406 infiles[i].compiled = true;
7408 this_file_error = 1;
7409 else if (compare_debug && debug_check_temp_file[0])
7412 inform (0, "recompiling with -fcompare-debug");
7414 compare_debug = -compare_debug;
7415 n_switches = n_switches_debug_check[1];
7416 switches = switches_debug_check[1];
7418 value = do_spec (input_file_compiler->spec);
7420 compare_debug = -compare_debug;
7421 n_switches = n_switches_debug_check[0];
7422 switches = switches_debug_check[0];
7426 error ("during -fcompare-debug recompilation");
7427 this_file_error = 1;
7430 gcc_assert (debug_check_temp_file[1]
7431 && strcmp (debug_check_temp_file[0],
7432 debug_check_temp_file[1]));
7435 inform (0, "comparing final insns dumps");
7437 if (compare_files (debug_check_temp_file))
7438 this_file_error = 1;
7443 if (debug_check_temp_file[0])
7444 free (debug_check_temp_file[0]);
7445 debug_check_temp_file[0] = NULL;
7447 if (debug_check_temp_file[1])
7448 free (debug_check_temp_file[1]);
7449 debug_check_temp_file[1] = NULL;
7454 /* If this file's name does not contain a recognized suffix,
7455 record it as explicit linker input. */
7458 explicit_link_files[i] = 1;
7460 /* Clear the delete-on-failure queue, deleting the files in it
7461 if this compilation failed. */
7463 if (this_file_error)
7465 delete_failure_queue ();
7468 /* If this compilation succeeded, don't delete those files later. */
7469 clear_failure_queue ();
7472 /* Reset the input file name to the first compile/object file name, for use
7473 with %b in LINK_SPEC. We use the first input file that we can find
7474 a compiler to compile it instead of using infiles.language since for
7475 languages other than C we use aliases that we then lookup later. */
7480 for (i = 0; i < n_infiles ; i++)
7481 if (infiles[i].language && infiles[i].language[0] != '*')
7483 set_input (infiles[i].name);
7488 if (error_count == 0)
7490 /* Make sure INPUT_FILE_NUMBER points to first available open
7492 input_file_number = n_infiles;
7493 if (lang_specific_pre_link ())
7497 /* Determine if there are any linker input files. */
7498 num_linker_inputs = 0;
7499 for (i = 0; (int) i < n_infiles; i++)
7500 if (explicit_link_files[i] || outfiles[i] != NULL)
7501 num_linker_inputs++;
7503 /* Run ld to link all the compiler output files. */
7505 if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7507 int tmp = execution_count;
7508 const char *fuse_linker_plugin = "fuse-linker-plugin";
7510 /* We'll use ld if we can't find collect2. */
7511 if (! strcmp (linker_name_spec, "collect2"))
7513 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7515 linker_name_spec = "ld";
7518 if (switch_matches (fuse_linker_plugin,
7519 fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7521 linker_plugin_file_spec = find_a_file (&exec_prefixes,
7522 "liblto_plugin.so", R_OK,
7524 if (!linker_plugin_file_spec)
7525 fatal_error ("-fuse-linker-plugin, but liblto_plugin.so not found");
7527 lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7529 if (!lto_libgcc_spec)
7530 fatal_error ("could not find libgcc.a");
7532 lto_gcc_spec = argv[0];
7534 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7536 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7537 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7539 if (print_subprocess_help == 1)
7541 printf (_("\nLinker options\n==============\n\n"));
7542 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7543 " to the linker.\n\n"));
7546 value = do_spec (link_command_spec);
7549 linker_was_run = (tmp != execution_count);
7552 /* If options said don't run linker,
7553 complain about input files to be given to the linker. */
7555 if (! linker_was_run && error_count == 0)
7556 for (i = 0; (int) i < n_infiles; i++)
7557 if (explicit_link_files[i]
7558 && !(infiles[i].language && infiles[i].language[0] == '*'))
7559 warning (0, "%s: linker input file unused because linking not done",
7562 /* Delete some or all of the temporary files we made. */
7565 delete_failure_queue ();
7566 delete_temp_files ();
7568 if (print_help_list)
7570 printf (("\nFor bug reporting instructions, please see:\n"));
7571 printf ("%s\n", bug_report_url);
7574 return (signal_count != 0 ? 2
7575 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7579 /* Find the proper compilation spec for the file name NAME,
7580 whose length is LENGTH. LANGUAGE is the specified language,
7581 or 0 if this file is to be passed to the linker. */
7583 static struct compiler *
7584 lookup_compiler (const char *name, size_t length, const char *language)
7586 struct compiler *cp;
7588 /* If this was specified by the user to be a linker input, indicate that. */
7589 if (language != 0 && language[0] == '*')
7592 /* Otherwise, look for the language, if one is spec'd. */
7595 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7596 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7599 error ("language %s not recognized", language);
7603 /* Look for a suffix. */
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))
7616 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7617 /* Look again, but case-insensitively this time. */
7619 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7621 if (/* The suffix `-' matches only the file name `-'. */
7622 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7623 || (strlen (cp->suffix) < length
7624 /* See if the suffix matches the end of NAME. */
7625 && ((!strcmp (cp->suffix,
7626 name + length - strlen (cp->suffix))
7627 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7628 && !strcasecmp (cp->suffix,
7629 name + length - strlen (cp->suffix)))
7635 if (cp >= compilers)
7637 if (cp->spec[0] != '@')
7638 /* A non-alias entry: return it. */
7641 /* An alias entry maps a suffix to a language.
7642 Search for the language; pass 0 for NAME and LENGTH
7643 to avoid infinite recursion if language not found. */
7644 return lookup_compiler (NULL, 0, cp->spec + 1);
7650 save_string (const char *s, int len)
7652 char *result = XNEWVEC (char, len + 1);
7654 memcpy (result, s, len);
7660 pfatal_with_name (const char *name)
7662 perror_with_name (name);
7663 delete_temp_files ();
7668 perror_with_name (const char *name)
7670 error ("%s: %s", name, xstrerror (errno));
7673 /* Output an error message and exit. */
7676 fancy_abort (const char *file, int line, const char *func)
7678 internal_error ("internal gcc abort in %s, at %s:%d", func, file, line);
7681 /* Output an error message and exit. */
7684 internal_error (const char *gmsgid, ...)
7688 va_start (ap, gmsgid);
7690 fprintf (stderr, "%s: ", programname);
7691 vfprintf (stderr, _(gmsgid), ap);
7693 fprintf (stderr, "\n");
7694 delete_temp_files ();
7695 exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7699 fatal_error (const char *gmsgid, ...)
7703 va_start (ap, gmsgid);
7705 fprintf (stderr, "%s: ", programname);
7706 vfprintf (stderr, _(gmsgid), ap);
7708 fprintf (stderr, "\n");
7709 delete_temp_files ();
7713 /* The argument is actually c-format, not gcc-internal-format,
7714 but because functions with identical names are used through
7715 the rest of the compiler with gcc-internal-format, we just
7716 need to hope all users of these functions use the common
7717 subset between c-format and gcc-internal-format. */
7720 error (const char *gmsgid, ...)
7724 va_start (ap, gmsgid);
7726 fprintf (stderr, "%s: %s", programname, _("error: "));
7727 vfprintf (stderr, _(gmsgid), ap);
7730 fprintf (stderr, "\n");
7734 warning (int dummy ATTRIBUTE_UNUSED, const char *gmsgid, ...)
7738 va_start (ap, gmsgid);
7739 fprintf (stderr, "%s: %s", programname, _("warning: "));
7740 vfprintf (stderr, _(gmsgid), ap);
7743 fprintf (stderr, "\n");
7747 inform (int dummy ATTRIBUTE_UNUSED, const char *gmsgid, ...)
7751 va_start (ap, gmsgid);
7752 fprintf (stderr, "%s: %s", programname, _("note: "));
7753 vfprintf (stderr, _(gmsgid), ap);
7756 fprintf (stderr, "\n");
7760 fnotice (FILE *fp, const char *cmsgid, ...)
7764 va_start (ap, cmsgid);
7765 vfprintf (fp, _(cmsgid), ap);
7770 validate_switches_from_spec (const char *spec)
7772 const char *p = spec;
7775 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7776 /* We have a switch spec. */
7777 p = validate_switches (p + 1);
7781 validate_all_switches (void)
7783 struct compiler *comp;
7784 struct spec_list *spec;
7786 for (comp = compilers; comp->spec; comp++)
7787 validate_switches_from_spec (comp->spec);
7789 /* Look through the linked list of specs read from the specs file. */
7790 for (spec = specs; spec; spec = spec->next)
7791 validate_switches_from_spec (*spec->ptr_spec);
7793 validate_switches_from_spec (link_command_spec);
7796 /* Look at the switch-name that comes after START
7797 and mark as valid all supplied switches that match it. */
7800 validate_switches (const char *start)
7802 const char *p = start;
7806 bool suffix = false;
7807 bool starred = false;
7809 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7818 if (*p == '.' || *p == ',')
7822 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7823 || *p == ',' || *p == '.' || *p == '@')
7828 starred = true, p++;
7834 /* Mark all matching switches as valid. */
7835 for (i = 0; i < n_switches; i++)
7836 if (!strncmp (switches[i].part1, atom, len)
7837 && (starred || switches[i].part1[len] == 0))
7838 switches[i].validated = 1;
7842 if (*p && (p[-1] == '|' || p[-1] == '&'))
7845 if (*p && p[-1] == ':')
7847 while (*p && *p != ';' && *p != '}')
7852 if (*p == '{' || *p == '<')
7853 p = validate_switches (p+1);
7854 else if (p[0] == 'W' && p[1] == '{')
7855 p = validate_switches (p+2);
7862 if (*p && p[-1] == ';')
7876 static struct mdswitchstr *mdswitches;
7877 static int n_mdswitches;
7879 /* Check whether a particular argument was used. The first time we
7880 canonicalize the switches to keep only the ones we care about. */
7883 used_arg (const char *p, int len)
7888 const char *replace;
7893 static struct mswitchstr *mswitches;
7894 static int n_mswitches;
7899 struct mswitchstr *matches;
7903 /* Break multilib_matches into the component strings of string
7904 and replacement string. */
7905 for (q = multilib_matches; *q != '\0'; q++)
7910 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7912 q = multilib_matches;
7921 fatal_error ("multilib spec '%s' is invalid",
7926 matches[i].len = q - matches[i].str;
7928 matches[i].replace = ++q;
7929 while (*q != ';' && *q != '\0')
7932 goto invalid_matches;
7935 matches[i].rep_len = q - matches[i].replace;
7941 /* Now build a list of the replacement string for switches that we care
7942 about. Make sure we allocate at least one entry. This prevents
7943 xmalloc from calling fatal, and prevents us from re-executing this
7946 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7947 for (i = 0; i < n_switches; i++)
7948 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7950 int xlen = strlen (switches[i].part1);
7951 for (j = 0; j < cnt; j++)
7952 if (xlen == matches[j].len
7953 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7955 mswitches[n_mswitches].str = matches[j].replace;
7956 mswitches[n_mswitches].len = matches[j].rep_len;
7957 mswitches[n_mswitches].replace = (char *) 0;
7958 mswitches[n_mswitches].rep_len = 0;
7964 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7965 on the command line nor any options mutually incompatible with
7967 for (i = 0; i < n_mdswitches; i++)
7971 for (q = multilib_options; *q != '\0'; q++)
7977 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7978 || strchr (" /", q[mdswitches[i].len]) == NULL)
7980 while (*q != ' ' && *q != '/' && *q != '\0')
7987 if (*q != ' ' && *q != '\0')
7989 while (*r != ' ' && *r != '\0')
7992 while (*q != ' ' && *q != '/' && *q != '\0')
7995 if (used_arg (r, q - r))
8000 mswitches[n_mswitches].str = mdswitches[i].str;
8001 mswitches[n_mswitches].len = mdswitches[i].len;
8002 mswitches[n_mswitches].replace = (char *) 0;
8003 mswitches[n_mswitches].rep_len = 0;
8016 for (i = 0; i < n_mswitches; i++)
8017 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
8024 default_arg (const char *p, int len)
8028 for (i = 0; i < n_mdswitches; i++)
8029 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
8035 /* Work out the subdirectory to use based on the options. The format of
8036 multilib_select is a list of elements. Each element is a subdirectory
8037 name followed by a list of options followed by a semicolon. The format
8038 of multilib_exclusions is the same, but without the preceding
8039 directory. First gcc will check the exclusions, if none of the options
8040 beginning with an exclamation point are present, and all of the other
8041 options are present, then we will ignore this completely. Passing
8042 that, gcc will consider each multilib_select in turn using the same
8043 rules for matching the options. If a match is found, that subdirectory
8047 set_multilib_dir (void)
8050 unsigned int this_path_len;
8051 const char *this_path, *this_arg;
8052 const char *start, *end;
8054 int ok, ndfltok, first;
8057 start = multilib_defaults;
8058 while (*start == ' ' || *start == '\t')
8060 while (*start != '\0')
8063 while (*start != ' ' && *start != '\t' && *start != '\0')
8065 while (*start == ' ' || *start == '\t')
8073 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8074 for (start = multilib_defaults; *start != '\0'; start = end + 1)
8076 while (*start == ' ' || *start == '\t')
8082 for (end = start + 1;
8083 *end != ' ' && *end != '\t' && *end != '\0'; end++)
8086 obstack_grow (&multilib_obstack, start, end - start);
8087 obstack_1grow (&multilib_obstack, 0);
8088 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8089 mdswitches[i++].len = end - start;
8096 p = multilib_exclusions;
8099 /* Ignore newlines. */
8106 /* Check the arguments. */
8113 fatal_error ("multilib exclusions '%s' is invalid",
8114 multilib_exclusions);
8124 while (*p != ' ' && *p != ';')
8127 goto invalid_exclusions;
8131 if (*this_arg != '!')
8139 ok = used_arg (this_arg, p - this_arg);
8154 p = multilib_select;
8157 /* Ignore newlines. */
8164 /* Get the initial path. */
8171 fatal_error ("multilib select '%s' is invalid",
8176 this_path_len = p - this_path;
8178 /* Check the arguments. */
8185 goto invalid_select;
8194 while (*p != ' ' && *p != ';')
8197 goto invalid_select;
8201 if (*this_arg != '!')
8209 /* If this is a default argument, we can just ignore it.
8210 This is true even if this_arg begins with '!'. Beginning
8211 with '!' does not mean that this argument is necessarily
8212 inappropriate for this library: it merely means that
8213 there is a more specific library which uses this
8214 argument. If this argument is a default, we need not
8215 consider that more specific library. */
8216 ok = used_arg (this_arg, p - this_arg);
8223 if (default_arg (this_arg, p - this_arg))
8232 if (this_path_len != 1
8233 || this_path[0] != '.')
8235 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8238 strncpy (new_multilib_dir, this_path, this_path_len);
8239 new_multilib_dir[this_path_len] = '\0';
8240 q = strchr (new_multilib_dir, ':');
8243 multilib_dir = new_multilib_dir;
8250 const char *q = this_path, *end = this_path + this_path_len;
8252 while (q < end && *q != ':')
8256 char *new_multilib_os_dir = XNEWVEC (char, end - q);
8257 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8258 new_multilib_os_dir[end - q - 1] = '\0';
8259 multilib_os_dir = new_multilib_os_dir;
8267 if (multilib_dir == NULL && multilib_os_dir != NULL
8268 && strcmp (multilib_os_dir, ".") == 0)
8270 free (CONST_CAST (char *, multilib_os_dir));
8271 multilib_os_dir = NULL;
8273 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8274 multilib_os_dir = multilib_dir;
8277 /* Print out the multiple library subdirectory selection
8278 information. This prints out a series of lines. Each line looks
8279 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8280 required. Only the desired options are printed out, the negative
8281 matches. The options are print without a leading dash. There are
8282 no spaces to make it easy to use the information in the shell.
8283 Each subdirectory is printed only once. This assumes the ordering
8284 generated by the genmultilib script. Also, we leave out ones that match
8288 print_multilib_info (void)
8290 const char *p = multilib_select;
8291 const char *last_path = 0, *this_path;
8293 unsigned int last_path_len = 0;
8298 /* Ignore newlines. */
8305 /* Get the initial path. */
8312 fatal_error ("multilib select '%s' is invalid", multilib_select);
8318 /* When --disable-multilib was used but target defines
8319 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8320 to find multilib_os_dir, so skip them from output. */
8321 if (this_path[0] == '.' && this_path[1] == ':')
8324 /* Check for matches with the multilib_exclusions. We don't bother
8325 with the '!' in either list. If any of the exclusion rules match
8326 all of its options with the select rule, we skip it. */
8328 const char *e = multilib_exclusions;
8329 const char *this_arg;
8334 /* Ignore newlines. */
8341 /* Check the arguments. */
8350 fatal_error ("multilib exclusion '%s' is invalid",
8351 multilib_exclusions);
8362 while (*e != ' ' && *e != ';')
8365 goto invalid_exclusion;
8373 int len = e - this_arg;
8376 goto invalid_select;
8380 while (*q != ' ' && *q != ';')
8383 goto invalid_select;
8387 if (! strncmp (arg, this_arg,
8388 (len < q - arg) ? q - arg : len)
8389 || default_arg (this_arg, e - this_arg))
8419 /* If this is a duplicate, skip it. */
8420 skip = (last_path != 0
8421 && (unsigned int) (p - this_path) == last_path_len
8422 && ! strncmp (last_path, this_path, last_path_len));
8424 last_path = this_path;
8425 last_path_len = p - this_path;
8428 /* If this directory requires any default arguments, we can skip
8429 it. We will already have printed a directory identical to
8430 this one which does not require that default argument. */
8441 goto invalid_select;
8448 while (*q != ' ' && *q != ';')
8451 goto invalid_select;
8456 && default_arg (arg, q - arg))
8471 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8482 goto invalid_select;
8490 use_arg = *p != '!';
8495 while (*p != ' ' && *p != ';')
8498 goto invalid_select;
8510 /* If there are extra options, print them now. */
8511 if (multilib_extra && *multilib_extra)
8513 int print_at = TRUE;
8516 for (q = multilib_extra; *q != '\0'; q++)
8537 /* getenv built-in spec function.
8539 Returns the value of the environment variable given by its first
8540 argument, concatenated with the second argument. If the
8541 environment variable is not defined, a fatal error is issued. */
8544 getenv_spec_function (int argc, const char **argv)
8554 value = getenv (argv[0]);
8556 fatal_error ("environment variable \"%s\" not defined", argv[0]);
8558 /* We have to escape every character of the environment variable so
8559 they are not interpreted as active spec characters. A
8560 particularly painful case is when we are reading a variable
8561 holding a windows path complete with \ separators. */
8562 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8563 result = XNEWVAR (char, len);
8564 for (ptr = result; *value; ptr += 2)
8570 strcpy (ptr, argv[1]);
8575 /* if-exists built-in spec function.
8577 Checks to see if the file specified by the absolute pathname in
8578 ARGS exists. Returns that pathname if found.
8580 The usual use for this function is to check for a library file
8581 (whose name has been expanded with %s). */
8584 if_exists_spec_function (int argc, const char **argv)
8586 /* Must have only one argument. */
8587 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8593 /* if-exists-else built-in spec function.
8595 This is like if-exists, but takes an additional argument which
8596 is returned if the first argument does not exist. */
8599 if_exists_else_spec_function (int argc, const char **argv)
8601 /* Must have exactly two arguments. */
8605 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8611 /* replace-outfile built-in spec function.
8613 This looks for the first argument in the outfiles array's name and
8614 replaces it with the second argument. */
8617 replace_outfile_spec_function (int argc, const char **argv)
8620 /* Must have exactly two arguments. */
8624 for (i = 0; i < n_infiles; i++)
8626 if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8627 outfiles[i] = xstrdup (argv[1]);
8632 /* Given two version numbers, compares the two numbers.
8633 A version number must match the regular expression
8634 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8637 compare_version_strings (const char *v1, const char *v2)
8642 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8643 REG_EXTENDED | REG_NOSUB) != 0)
8645 rresult = regexec (&r, v1, 0, NULL, 0);
8646 if (rresult == REG_NOMATCH)
8647 fatal_error ("invalid version number `%s'", v1);
8648 else if (rresult != 0)
8650 rresult = regexec (&r, v2, 0, NULL, 0);
8651 if (rresult == REG_NOMATCH)
8652 fatal_error ("invalid version number `%s'", v2);
8653 else if (rresult != 0)
8656 return strverscmp (v1, v2);
8660 /* version_compare built-in spec function.
8662 This takes an argument of the following form:
8664 <comparison-op> <arg1> [<arg2>] <switch> <result>
8666 and produces "result" if the comparison evaluates to true,
8667 and nothing if it doesn't.
8669 The supported <comparison-op> values are:
8671 >= true if switch is a later (or same) version than arg1
8673 < true if switch is an earlier version than arg1
8675 >< true if switch is arg1 or later, and earlier than arg2
8676 <> true if switch is earlier than arg1 or is arg2 or later
8678 If the switch is not present, the condition is false unless
8679 the first character of the <comparison-op> is '!'.
8682 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8683 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8686 version_compare_spec_function (int argc, const char **argv)
8690 const char *switch_value = NULL;
8695 fatal_error ("too few arguments to %%:version-compare");
8696 if (argv[0][0] == '\0')
8698 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8700 if (argc != nargs + 3)
8701 fatal_error ("too many arguments to %%:version-compare");
8703 switch_len = strlen (argv[nargs + 1]);
8704 for (i = 0; i < n_switches; i++)
8705 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8706 && check_live_switch (i, switch_len))
8707 switch_value = switches[i].part1 + switch_len;
8709 if (switch_value == NULL)
8713 comp1 = compare_version_strings (switch_value, argv[1]);
8715 comp2 = compare_version_strings (switch_value, argv[2]);
8717 comp2 = -1; /* This value unused. */
8720 switch (argv[0][0] << 8 | argv[0][1])
8722 case '>' << 8 | '=':
8723 result = comp1 >= 0;
8725 case '!' << 8 | '<':
8726 result = comp1 >= 0 || switch_value == NULL;
8731 case '!' << 8 | '>':
8732 result = comp1 < 0 || switch_value == NULL;
8734 case '>' << 8 | '<':
8735 result = comp1 >= 0 && comp2 < 0;
8737 case '<' << 8 | '>':
8738 result = comp1 < 0 || comp2 >= 0;
8742 fatal_error ("unknown operator '%s' in %%:version-compare", argv[0]);
8747 return argv[nargs + 2];
8750 /* %:include builtin spec function. This differs from %include in that it
8751 can be nested inside a spec, and thus be conditionalized. It takes
8752 one argument, the filename, and looks for it in the startfile path.
8753 The result is always NULL, i.e. an empty expansion. */
8756 include_spec_function (int argc, const char **argv)
8763 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8764 read_specs (file ? file : argv[0], FALSE);
8769 /* %:find-file spec function. This function replace its argument by
8770 the file found thru find_file, that is the -print-file-name gcc
8773 find_file_spec_function (int argc, const char**argv)
8780 file = find_file (argv[0]);
8785 /* %:print-asm-header spec function. Print a banner to say that the
8786 following output is from the assembler. */
8789 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8790 const char **argv ATTRIBUTE_UNUSED)
8792 printf (_("Assembler options\n=================\n\n"));
8793 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8798 /* Compute a timestamp to initialize flag_random_seed. */
8801 get_local_tick (void)
8805 /* Get some more or less random data. */
8806 #ifdef HAVE_GETTIMEOFDAY
8810 gettimeofday (&tv, NULL);
8811 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8815 time_t now = time (NULL);
8817 if (now != (time_t)-1)
8818 ret = (unsigned) now;
8825 /* %:compare-debug-dump-opt spec function. Save the last argument,
8826 expected to be the last -fdump-final-insns option, or generate a
8830 compare_debug_dump_opt_spec_function (int arg,
8831 const char **argv ATTRIBUTE_UNUSED)
8836 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8839 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8841 do_spec_2 ("%{fdump-final-insns=*:%*}");
8842 do_spec_1 (" ", 0, NULL);
8844 if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8849 name = xstrdup (argv[argbuf_index - 1]);
8854 const char *ext = NULL;
8856 if (argbuf_index > 0)
8858 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8861 else if (!compare_debug)
8864 do_spec_2 ("%g.gkd");
8866 do_spec_1 (" ", 0, NULL);
8868 gcc_assert (argbuf_index > 0);
8870 name = concat (argbuf[argbuf_index - 1], ext, NULL);
8872 ret = concat ("-fdump-final-insns=", name, NULL);
8875 which = compare_debug < 0;
8876 debug_check_temp_file[which] = name;
8880 unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8882 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8886 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8895 static const char *debug_auxbase_opt;
8897 /* %:compare-debug-self-opt spec function. Expands to the options
8898 that are to be passed in the second compilation of
8902 compare_debug_self_opt_spec_function (int arg,
8903 const char **argv ATTRIBUTE_UNUSED)
8906 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8908 if (compare_debug >= 0)
8911 do_spec_2 ("%{c|S:%{o*:%*}}");
8912 do_spec_1 (" ", 0, NULL);
8914 if (argbuf_index > 0)
8915 debug_auxbase_opt = concat ("-auxbase-strip ",
8916 argbuf[argbuf_index - 1],
8919 debug_auxbase_opt = NULL;
8922 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8923 %<fdump-final-insns=* -w -S -o %j \
8924 %{!fcompare-debug-second:-fcompare-debug-second} \
8925 ", compare_debug_opt, NULL);
8928 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8929 options that are to be passed in the second compilation of
8930 compare-debug. It expects, as an argument, the basename of the
8931 current input file name, with the .gk suffix appended to it. */
8934 compare_debug_auxbase_opt_spec_function (int arg,
8941 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8944 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8946 if (compare_debug >= 0)
8949 len = strlen (argv[0]);
8950 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8951 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8952 "does not end in .gk");
8954 if (debug_auxbase_opt)
8955 return debug_auxbase_opt;
8957 #define OPT "-auxbase "
8960 name = (char*) xmalloc (sizeof (OPT) + len);
8961 memcpy (name, OPT, sizeof (OPT) - 1);
8962 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8963 name[sizeof (OPT) - 1 + len] = '\0';