bringing the front-end together
[official-gcc.git] / gcc / gcc.c
blob39788be97c0c2229ca0a328917914988c1ce3415
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,
4 2010
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
12 version.
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
17 for more details.
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
40 `--bar'.
42 1. Each command-line option is specified in the specs file. The
43 notation is described below in the comment entitled "The Specs
44 Language". Read it.
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 `-'
60 from `--baz'.
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(),
65 instead.
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(). */
71 #include "config.h"
72 #include "system.h"
73 #include "coretypes.h"
74 #include "multilib.h" /* before tm.h */
75 #include "tm.h"
76 #include <signal.h>
77 #if ! defined( SIGCHLD ) && defined( SIGCLD )
78 # define SIGCHLD SIGCLD
79 #endif
80 #include "xregex.h"
81 #include "obstack.h"
82 #include "intl.h"
83 #include "prefix.h"
84 #include "gcc.h"
85 #include "flags.h"
86 #include "opts.h"
88 #ifdef HAVE_MMAP_FILE
89 # include <sys/mman.h>
90 # ifdef HAVE_MINCORE
91 /* This is on Solaris. */
92 # include <sys/types.h>
93 # endif
94 #endif
96 #ifndef MAP_FAILED
97 # define MAP_FAILED ((void *)-1)
98 #endif
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
104 #endif
106 /* By default there is no special suffix for host executables. */
107 #ifdef HOST_EXECUTABLE_SUFFIX
108 #define HAVE_HOST_EXECUTABLE_SUFFIX
109 #else
110 #define HOST_EXECUTABLE_SUFFIX ""
111 #endif
113 /* By default, the suffix for target object files is ".o". */
114 #ifdef TARGET_OBJECT_SUFFIX
115 #define HAVE_TARGET_OBJECT_SUFFIX
116 #else
117 #define TARGET_OBJECT_SUFFIX ".o"
118 #endif
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"
125 #endif
127 #ifndef HAVE_KILL
128 #define kill(p,s) raise(s)
129 #endif
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. */
137 int is_cpp_driver;
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
181 sub-processes. */
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
190 headers. */
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;
223 #else
224 static const char *target_system_root = 0;
225 #endif
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 */
246 } save_temps_flag;
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";
278 #else
279 static const char *cross_compile = "0";
280 #endif
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;
297 #endif
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
304 now. */
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
314 and destructors. */
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
322 instead of just
323 program arguments */
324 static const char *wrapper_string;
326 /* Forward declaration for prototypes. */
327 struct path_prefix;
328 struct prefix_list;
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 *,
338 bool, bool);
339 static void xputenv (const char *);
340 static void putenv_from_prefixes (const struct path_prefix *, const char *,
341 bool);
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 *,
345 int, int, int);
346 static void add_sysrooted_prefix (struct path_prefix *, const char *,
347 const char *, int, int, int);
348 static void translate_options (int *, const char *const **);
349 static char *skip_whitespace (char *);
350 static void delete_if_ordinary (const char *);
351 static void delete_temp_files (void);
352 static void delete_failure_queue (void);
353 static void clear_failure_queue (void);
354 static int check_live_switch (int, int);
355 static const char *handle_braces (const char *);
356 static inline bool input_suffix_matches (const char *, const char *);
357 static inline bool switch_matches (const char *, const char *, int);
358 static inline void mark_matching_switches (const char *, const char *, int);
359 static inline void process_marked_switches (void);
360 static const char *process_brace_body (const char *, const char *, const char *, int, int);
361 static const struct spec_function *lookup_spec_function (const char *);
362 static const char *eval_spec_function (const char *, const char *);
363 static const char *handle_spec_function (const char *);
364 static char *save_string (const char *, int);
365 static void set_collect_gcc_options (void);
366 static int do_spec_1 (const char *, int, const char *);
367 static int do_spec_2 (const char *);
368 static void do_option_spec (const char *, const char *);
369 static void do_self_spec (const char *);
370 static const char *find_file (const char *);
371 static int is_directory (const char *, bool);
372 static const char *validate_switches (const char *);
373 static void validate_all_switches (void);
374 static inline void validate_switches_from_spec (const char *);
375 static void give_switch (int, int);
376 static int used_arg (const char *, int);
377 static int default_arg (const char *, int);
378 static void set_multilib_dir (void);
379 static void print_multilib_info (void);
380 static void perror_with_name (const char *);
381 static void fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
382 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
383 static void display_help (void);
384 static void add_preprocessor_option (const char *, int);
385 static void add_assembler_option (const char *, int);
386 static void add_linker_option (const char *, int);
387 static void process_command (int, const char **);
388 static int execute (void);
389 static void alloc_args (void);
390 static void clear_args (void);
391 static void fatal_error (int);
392 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
393 static void init_gcc_specs (struct obstack *, const char *, const char *,
394 const char *);
395 #endif
396 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
397 static const char *convert_filename (const char *, int, int);
398 #endif
400 static const char *getenv_spec_function (int, const char **);
401 static const char *if_exists_spec_function (int, const char **);
402 static const char *if_exists_else_spec_function (int, const char **);
403 static const char *replace_outfile_spec_function (int, const char **);
404 static const char *version_compare_spec_function (int, const char **);
405 static const char *include_spec_function (int, const char **);
406 static const char *find_file_spec_function (int, const char **);
407 static const char *print_asm_header_spec_function (int, const char **);
408 static const char *compare_debug_dump_opt_spec_function (int, const char **);
409 static const char *compare_debug_self_opt_spec_function (int, const char **);
410 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
412 /* The Specs Language
414 Specs are strings containing lines, each of which (if not blank)
415 is made up of a program name, and arguments separated by spaces.
416 The program name must be exact and start from root, since no path
417 is searched and it is unreliable to depend on the current working directory.
418 Redirection of input or output is not supported; the subprograms must
419 accept filenames saying what files to read and write.
421 In addition, the specs can contain %-sequences to substitute variable text
422 or for conditional text. Here is a table of all defined %-sequences.
423 Note that spaces are not generated automatically around the results of
424 expanding these sequences; therefore, you can concatenate them together
425 or with constant text in a single argument.
427 %% substitute one % into the program name or argument.
428 %i substitute the name of the input file being processed.
429 %b substitute the basename of the input file being processed.
430 This is the substring up to (and not including) the last period
431 and not including the directory unless -save-temps was specified
432 to put temporaries in a different location.
433 %B same as %b, but include the file suffix (text after the last period).
434 %gSUFFIX
435 substitute a file name that has suffix SUFFIX and is chosen
436 once per compilation, and mark the argument a la %d. To reduce
437 exposure to denial-of-service attacks, the file name is now
438 chosen in a way that is hard to predict even when previously
439 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
440 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
441 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
442 had been pre-processed. Previously, %g was simply substituted
443 with a file name chosen once per compilation, without regard
444 to any appended suffix (which was therefore treated just like
445 ordinary text), making such attacks more likely to succeed.
446 %|SUFFIX
447 like %g, but if -pipe is in effect, expands simply to "-".
448 %mSUFFIX
449 like %g, but if -pipe is in effect, expands to nothing. (We have both
450 %| and %m to accommodate differences between system assemblers; see
451 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
452 %uSUFFIX
453 like %g, but generates a new temporary file name even if %uSUFFIX
454 was already seen.
455 %USUFFIX
456 substitutes the last file name generated with %uSUFFIX, generating a
457 new one if there is no such last file name. In the absence of any
458 %uSUFFIX, this is just like %gSUFFIX, except they don't share
459 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
460 would involve the generation of two distinct file names, one
461 for each `%g.s' and another for each `%U.s'. Previously, %U was
462 simply substituted with a file name chosen for the previous %u,
463 without regard to any appended suffix.
464 %jSUFFIX
465 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
466 writable, and if save-temps is off; otherwise, substitute the name
467 of a temporary file, just like %u. This temporary file is not
468 meant for communication between processes, but rather as a junk
469 disposal mechanism.
470 %.SUFFIX
471 substitutes .SUFFIX for the suffixes of a matched switch's args when
472 it is subsequently output with %*. SUFFIX is terminated by the next
473 space or %.
474 %d marks the argument containing or following the %d as a
475 temporary file name, so that that file will be deleted if GCC exits
476 successfully. Unlike %g, this contributes no text to the argument.
477 %w marks the argument containing or following the %w as the
478 "output file" of this compilation. This puts the argument
479 into the sequence of arguments that %o will substitute later.
480 %V indicates that this compilation produces no "output file".
481 %W{...}
482 like %{...} but mark last argument supplied within
483 as a file to be deleted on failure.
484 %o substitutes the names of all the output files, with spaces
485 automatically placed around them. You should write spaces
486 around the %o as well or the results are undefined.
487 %o is for use in the specs for running the linker.
488 Input files whose names have no recognized suffix are not compiled
489 at all, but they are included among the output files, so they will
490 be linked.
491 %O substitutes the suffix for object files. Note that this is
492 handled specially when it immediately follows %g, %u, or %U
493 (with or without a suffix argument) because of the need for
494 those to form complete file names. The handling is such that
495 %O is treated exactly as if it had already been substituted,
496 except that %g, %u, and %U do not currently support additional
497 SUFFIX characters following %O as they would following, for
498 example, `.o'.
499 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
500 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
501 and -B options) and -imultilib as necessary.
502 %s current argument is the name of a library or startup file of some sort.
503 Search for that file in a standard list of directories
504 and substitute the full name found.
505 %eSTR Print STR as an error message. STR is terminated by a newline.
506 Use this when inconsistent options are detected.
507 %nSTR Print STR as a notice. STR is terminated by a newline.
508 %x{OPTION} Accumulate an option for %X.
509 %X Output the accumulated linker options specified by compilations.
510 %Y Output the accumulated assembler options specified by compilations.
511 %Z Output the accumulated preprocessor options specified by compilations.
512 %a process ASM_SPEC as a spec.
513 This allows config.h to specify part of the spec for running as.
514 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
515 used here. This can be used to run a post-processor after the
516 assembler has done its job.
517 %D Dump out a -L option for each directory in startfile_prefixes.
518 If multilib_dir is set, extra entries are generated with it affixed.
519 %l process LINK_SPEC as a spec.
520 %L process LIB_SPEC as a spec.
521 %G process LIBGCC_SPEC as a spec.
522 %R Output the concatenation of target_system_root and
523 target_sysroot_suffix.
524 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
525 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
526 %C process CPP_SPEC as a spec.
527 %1 process CC1_SPEC as a spec.
528 %2 process CC1PLUS_SPEC as a spec.
529 %* substitute the variable part of a matched option. (See below.)
530 Note that each comma in the substituted string is replaced by
531 a single space.
532 %<S remove all occurrences of -S from the command line.
533 Note - this command is position dependent. % commands in the
534 spec string before this one will see -S, % commands in the
535 spec string after this one will not.
536 %<S* remove all occurrences of all switches beginning with -S from the
537 command line.
538 %:function(args)
539 Call the named function FUNCTION, passing it ARGS. ARGS is
540 first processed as a nested spec string, then split into an
541 argument vector in the usual fashion. The function returns
542 a string which is processed as if it had appeared literally
543 as part of the current spec.
544 %{S} substitutes the -S switch, if that switch was given to GCC.
545 If that switch was not specified, this substitutes nothing.
546 Here S is a metasyntactic variable.
547 %{S*} substitutes all the switches specified to GCC whose names start
548 with -S. This is used for -o, -I, etc; switches that take
549 arguments. GCC considers `-o foo' as being one switch whose
550 name starts with `o'. %{o*} would substitute this text,
551 including the space; thus, two arguments would be generated.
552 %{S*&T*} likewise, but preserve order of S and T options (the order
553 of S and T in the spec is not significant). Can be any number
554 of ampersand-separated variables; for each the wild card is
555 optional. Useful for CPP as %{D*&U*&A*}.
557 %{S:X} substitutes X, if the -S switch was given to GCC.
558 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
559 %{S*:X} substitutes X if one or more switches whose names start
560 with -S was given to GCC. Normally X is substituted only
561 once, no matter how many such switches appeared. However,
562 if %* appears somewhere in X, then X will be substituted
563 once for each matching switch, with the %* replaced by the
564 part of that switch that matched the '*'.
565 %{.S:X} substitutes X, if processing a file with suffix S.
566 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
567 %{,S:X} substitutes X, if processing a file which will use spec S.
568 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
570 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
571 combined with '!', '.', ',', and '*' as above binding stronger
572 than the OR.
573 If %* appears in X, all of the alternatives must be starred, and
574 only the first matching alternative is substituted.
575 %{S:X; if S was given to GCC, substitutes X;
576 T:Y; else if T was given to GCC, substitutes Y;
577 :D} else substitutes D. There can be as many clauses as you need.
578 This may be combined with '.', '!', ',', '|', and '*' as above.
580 %(Spec) processes a specification defined in a specs file as *Spec:
581 %[Spec] as above, but put __ around -D arguments
583 The conditional text X in a %{S:X} or similar construct may contain
584 other nested % constructs or spaces, or even newlines. They are
585 processed as usual, as described above. Trailing white space in X is
586 ignored. White space may also appear anywhere on the left side of the
587 colon in these constructs, except between . or * and the corresponding
588 word.
590 The -O, -f, -m, and -W switches are handled specifically in these
591 constructs. If another value of -O or the negated form of a -f, -m, or
592 -W switch is found later in the command line, the earlier switch
593 value is ignored, except with {S*} where S is just one letter; this
594 passes all matching options.
596 The character | at the beginning of the predicate text is used to indicate
597 that a command should be piped to the following command, but only if -pipe
598 is specified.
600 Note that it is built into GCC which switches take arguments and which
601 do not. You might think it would be useful to generalize this to
602 allow each compiler's spec to say which switches take arguments. But
603 this cannot be done in a consistent fashion. GCC cannot even decide
604 which input files have been specified without knowing which switches
605 take arguments, and it must know which input files to compile in order
606 to tell which compilers to run.
608 GCC also knows implicitly that arguments starting in `-l' are to be
609 treated as compiler output files, and passed to the linker in their
610 proper position among the other output files. */
612 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
614 /* config.h can define ASM_SPEC to provide extra args to the assembler
615 or extra switch-translations. */
616 #ifndef ASM_SPEC
617 #define ASM_SPEC ""
618 #endif
620 /* config.h can define ASM_FINAL_SPEC to run a post processor after
621 the assembler has run. */
622 #ifndef ASM_FINAL_SPEC
623 #define ASM_FINAL_SPEC ""
624 #endif
626 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
627 or extra switch-translations. */
628 #ifndef CPP_SPEC
629 #define CPP_SPEC ""
630 #endif
632 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
633 or extra switch-translations. */
634 #ifndef CC1_SPEC
635 #define CC1_SPEC ""
636 #endif
638 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
639 or extra switch-translations. */
640 #ifndef CC1PLUS_SPEC
641 #define CC1PLUS_SPEC ""
642 #endif
644 /* config.h can define LINK_SPEC to provide extra args to the linker
645 or extra switch-translations. */
646 #ifndef LINK_SPEC
647 #define LINK_SPEC ""
648 #endif
650 /* config.h can define LIB_SPEC to override the default libraries. */
651 #ifndef LIB_SPEC
652 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
653 #endif
655 /* mudflap specs */
656 #ifndef MFWRAP_SPEC
657 /* XXX: valid only for GNU ld */
658 /* XXX: should exactly match hooks provided by libmudflap.a */
659 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
660 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
661 --wrap=mmap --wrap=munmap --wrap=alloca\
662 } %{fmudflapth: --wrap=pthread_create\
663 }} %{fmudflap|fmudflapth: --wrap=main}"
664 #endif
665 #ifndef MFLIB_SPEC
666 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
667 #endif
669 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
670 included. */
671 #ifndef LIBGCC_SPEC
672 #if defined(REAL_LIBGCC_SPEC)
673 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
674 #elif defined(LINK_LIBGCC_SPECIAL_1)
675 /* Have gcc do the search for libgcc.a. */
676 #define LIBGCC_SPEC "libgcc.a%s"
677 #else
678 #define LIBGCC_SPEC "-lgcc"
679 #endif
680 #endif
682 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
683 #ifndef STARTFILE_SPEC
684 #define STARTFILE_SPEC \
685 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
686 #endif
688 /* config.h can define SWITCHES_NEED_SPACES to control which options
689 require spaces between the option and the argument.
691 We define SWITCHES_NEED_SPACES to include "o" by default. This
692 causes "-ofoo.o" to be split into "-o foo.o" during the initial
693 processing of the command-line, before being seen by the specs
694 machinery. This makes sure we record "foo.o" as the temporary file
695 to be deleted in the case of error, rather than "-ofoo.o". */
696 #ifndef SWITCHES_NEED_SPACES
697 #define SWITCHES_NEED_SPACES "o"
698 #endif
700 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
701 #ifndef ENDFILE_SPEC
702 #define ENDFILE_SPEC ""
703 #endif
705 #ifndef LINKER_NAME
706 #define LINKER_NAME "collect2"
707 #endif
709 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
710 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
711 #else
712 #define ASM_MAP ""
713 #endif
715 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
716 to the assembler. */
717 #ifndef ASM_DEBUG_SPEC
718 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
719 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
720 # define ASM_DEBUG_SPEC \
721 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
722 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
723 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
724 # else
725 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
726 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
727 # endif
728 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
729 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
730 # endif
731 # endif
732 #endif
733 #ifndef ASM_DEBUG_SPEC
734 # define ASM_DEBUG_SPEC ""
735 #endif
737 /* Here is the spec for running the linker, after compiling all files. */
739 /* This is overridable by the target in case they need to specify the
740 -lgcc and -lc order specially, yet not require them to override all
741 of LINK_COMMAND_SPEC. */
742 #ifndef LINK_GCC_C_SEQUENCE_SPEC
743 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
744 #endif
746 #ifndef LINK_SSP_SPEC
747 #ifdef TARGET_LIBC_PROVIDES_SSP
748 #define LINK_SSP_SPEC "%{fstack-protector:}"
749 #else
750 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
751 #endif
752 #endif
754 #ifndef LINK_PIE_SPEC
755 #ifdef HAVE_LD_PIE
756 #define LINK_PIE_SPEC "%{pie:-pie} "
757 #else
758 #define LINK_PIE_SPEC "%{pie:} "
759 #endif
760 #endif
762 #ifndef LINK_BUILDID_SPEC
763 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
764 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
765 # endif
766 #endif
769 /* -u* was put back because both BSD and SysV seem to support it. */
770 /* %{static:} simply prevents an error message if the target machine
771 doesn't handle -static. */
772 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
773 scripts which exist in user specified directories, or in standard
774 directories. */
775 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
776 to understand them. In practice, this means it had better be collect2. */
777 #ifndef LINK_COMMAND_SPEC
778 #define LINK_COMMAND_SPEC "\
779 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
780 %(linker) \
781 %{fuse-linker-plugin: \
782 -plugin %(linker_plugin_file) \
783 -plugin-opt=%(lto_wrapper) \
784 -plugin-opt=-fresolution=%u.res \
785 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
786 %{static:-plugin-opt=-pass-through=-lc} \
788 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
789 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
790 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
791 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
792 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
793 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
794 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
795 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
796 #endif
798 #ifndef LINK_LIBGCC_SPEC
799 /* Generate -L options for startfile prefix list. */
800 # define LINK_LIBGCC_SPEC "%D"
801 #endif
803 #ifndef STARTFILE_PREFIX_SPEC
804 # define STARTFILE_PREFIX_SPEC ""
805 #endif
807 #ifndef SYSROOT_SPEC
808 # define SYSROOT_SPEC "--sysroot=%R"
809 #endif
811 #ifndef SYSROOT_SUFFIX_SPEC
812 # define SYSROOT_SUFFIX_SPEC ""
813 #endif
815 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
816 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
817 #endif
819 static const char *asm_debug;
820 static const char *cpp_spec = CPP_SPEC;
821 static const char *cc1_spec = CC1_SPEC;
822 static const char *cc1plus_spec = CC1PLUS_SPEC;
823 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
824 static const char *link_ssp_spec = LINK_SSP_SPEC;
825 static const char *asm_spec = ASM_SPEC;
826 static const char *asm_final_spec = ASM_FINAL_SPEC;
827 static const char *link_spec = LINK_SPEC;
828 static const char *lib_spec = LIB_SPEC;
829 static const char *mfwrap_spec = MFWRAP_SPEC;
830 static const char *mflib_spec = MFLIB_SPEC;
831 static const char *link_gomp_spec = "";
832 static const char *libgcc_spec = LIBGCC_SPEC;
833 static const char *endfile_spec = ENDFILE_SPEC;
834 static const char *startfile_spec = STARTFILE_SPEC;
835 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
836 static const char *linker_name_spec = LINKER_NAME;
837 static const char *linker_plugin_file_spec = "";
838 static const char *lto_wrapper_spec = "";
839 static const char *lto_gcc_spec = "";
840 static const char *lto_libgcc_spec = "";
841 static const char *link_command_spec = LINK_COMMAND_SPEC;
842 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
843 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
844 static const char *sysroot_spec = SYSROOT_SPEC;
845 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
846 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
848 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
849 There should be no need to override these in target dependent files,
850 but we need to copy them to the specs file so that newer versions
851 of the GCC driver can correctly drive older tool chains with the
852 appropriate -B options. */
854 /* When cpplib handles traditional preprocessing, get rid of this, and
855 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
856 that we default the front end language better. */
857 static const char *trad_capable_cpp =
858 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
860 /* We don't wrap .d files in %W{} since a missing .d file, and
861 therefore no dependency entry, confuses make into thinking a .o
862 file that happens to exist is up-to-date. */
863 static const char *cpp_unique_options =
864 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
865 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
866 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
867 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
868 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
869 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
870 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
871 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
872 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
873 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
874 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
875 %{E|M|MM:%W{o*}}";
877 /* This contains cpp options which are common with cc1_options and are passed
878 only when preprocessing only to avoid duplication. We pass the cc1 spec
879 options to the preprocessor so that it the cc1 spec may manipulate
880 options used to set target flags. Those special target flags settings may
881 in turn cause preprocessor symbols to be defined specially. */
882 static const char *cpp_options =
883 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
884 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
885 %{undef} %{save-temps*:-fpch-preprocess}";
887 /* This contains cpp options which are not passed when the preprocessor
888 output will be used by another program. */
889 static const char *cpp_debug_options = "%{d*}";
891 /* NB: This is shared amongst all front-ends, except for Ada. */
892 static const char *cc1_options =
893 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
894 %{!iplugindir*:%{fplugin*:-iplugindir=%:find-file(plugin)}}\
895 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{a*}\
896 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
897 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
898 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
899 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
900 %{Qn:-fno-ident} %{--help:--help}\
901 %{--target-help:--target-help}\
902 %{--help=*:--help=%(VALUE)}\
903 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
904 %{fsyntax-only:-o %j} %{-param*}\
905 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
906 %{coverage:-fprofile-arcs -ftest-coverage}";
908 static const char *asm_options =
909 "%{--target-help:%:print-asm-header()} "
910 #if HAVE_GNU_AS
911 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
912 to the assembler equivalents. */
913 "%{v} %{w:-W} %{I*} "
914 #endif
915 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
917 static const char *invoke_as =
918 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
919 "%{!fwpa:\
920 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
921 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
923 #else
924 "%{!fwpa:\
925 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
926 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
928 #endif
930 /* Some compilers have limits on line lengths, and the multilib_select
931 and/or multilib_matches strings can be very long, so we build them at
932 run time. */
933 static struct obstack multilib_obstack;
934 static const char *multilib_select;
935 static const char *multilib_matches;
936 static const char *multilib_defaults;
937 static const char *multilib_exclusions;
939 /* Check whether a particular argument is a default argument. */
941 #ifndef MULTILIB_DEFAULTS
942 #define MULTILIB_DEFAULTS { "" }
943 #endif
945 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
947 #ifndef DRIVER_SELF_SPECS
948 #define DRIVER_SELF_SPECS ""
949 #endif
951 /* Adding -fopenmp should imply pthreads. This is particularly important
952 for targets that use different start files and suchlike. */
953 #ifndef GOMP_SELF_SPECS
954 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
955 #endif
957 static const char *const driver_self_specs[] = {
958 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
959 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
962 #ifndef OPTION_DEFAULT_SPECS
963 #define OPTION_DEFAULT_SPECS { "", "" }
964 #endif
966 struct default_spec
968 const char *name;
969 const char *spec;
972 static const struct default_spec
973 option_default_specs[] = { OPTION_DEFAULT_SPECS };
975 struct user_specs
977 struct user_specs *next;
978 const char *filename;
981 static struct user_specs *user_specs_head, *user_specs_tail;
983 #ifndef SWITCH_TAKES_ARG
984 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
985 #endif
987 #ifndef WORD_SWITCH_TAKES_ARG
988 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
989 #endif
991 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
992 /* This defines which switches stop a full compilation. */
993 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
994 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
996 #ifndef SWITCH_CURTAILS_COMPILATION
997 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
998 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
999 #endif
1000 #endif
1002 /* Record the mapping from file suffixes for compilation specs. */
1004 struct compiler
1006 const char *suffix; /* Use this compiler for input files
1007 whose names end in this suffix. */
1009 const char *spec; /* To use this compiler, run this spec. */
1011 const char *cpp_spec; /* If non-NULL, substitute this spec
1012 for `%C', rather than the usual
1013 cpp_spec. */
1014 const int combinable; /* If nonzero, compiler can deal with
1015 multiple source files at once (IMA). */
1016 const int needs_preprocessing; /* If nonzero, source files need to
1017 be run through a preprocessor. */
1020 /* Pointer to a vector of `struct compiler' that gives the spec for
1021 compiling a file, based on its suffix.
1022 A file that does not end in any of these suffixes will be passed
1023 unchanged to the loader and nothing else will be done to it.
1025 An entry containing two 0s is used to terminate the vector.
1027 If multiple entries match a file, the last matching one is used. */
1029 static struct compiler *compilers;
1031 /* Number of entries in `compilers', not counting the null terminator. */
1033 static int n_compilers;
1035 /* The default list of file name suffixes and their compilation specs. */
1037 static const struct compiler default_compilers[] =
1039 /* Add lists of suffixes of known languages here. If those languages
1040 were not present when we built the driver, we will hit these copies
1041 and be given a more meaningful error than "file not used since
1042 linking is not done". */
1043 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1044 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1045 {".mii", "#Objective-C++", 0, 0, 0},
1046 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1047 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1048 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1049 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1050 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1051 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1052 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1053 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1054 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1055 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1056 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1057 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1058 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1059 {".r", "#Ratfor", 0, 0, 0},
1060 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1061 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1062 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1063 /* Next come the entries for C. */
1064 {".c", "@c", 0, 1, 1},
1065 {"@c",
1066 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1067 external preprocessor if -save-temps is given. */
1068 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1069 %{!E:%{!M:%{!MM:\
1070 %{traditional|ftraditional:\
1071 %eGNU C no longer supports -traditional without -E}\
1072 %{!combine:\
1073 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1074 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1075 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1076 %(cc1_options)}\
1077 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1078 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1079 %{!fsyntax-only:%(invoke_as)}} \
1080 %{combine:\
1081 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1082 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1083 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1084 cc1 %(cpp_unique_options) %(cc1_options)}}\
1085 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1086 {"-",
1087 "%{!E:%e-E or -x required when input is from standard input}\
1088 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1089 {".h", "@c-header", 0, 0, 0},
1090 {"@c-header",
1091 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1092 external preprocessor if -save-temps is given. */
1093 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1094 %{!E:%{!M:%{!MM:\
1095 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1096 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1097 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1098 %(cc1_options)\
1099 -o %g.s %{!o*:--output-pch=%i.gch}\
1100 %W{o*:--output-pch=%*}%V}\
1101 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1102 cc1 %(cpp_unique_options) %(cc1_options)\
1103 -o %g.s %{!o*:--output-pch=%i.gch}\
1104 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1105 {".i", "@cpp-output", 0, 1, 0},
1106 {"@cpp-output",
1107 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1108 {".s", "@assembler", 0, 1, 0},
1109 {"@assembler",
1110 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1111 {".sx", "@assembler-with-cpp", 0, 1, 0},
1112 {".S", "@assembler-with-cpp", 0, 1, 0},
1113 {"@assembler-with-cpp",
1114 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1115 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1116 %{E|M|MM:%(cpp_debug_options)}\
1117 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1118 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1119 #else
1120 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1121 %{E|M|MM:%(cpp_debug_options)}\
1122 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1123 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1124 #endif
1125 , 0, 1, 0},
1127 #include "specs.h"
1128 /* Mark end of table. */
1129 {0, 0, 0, 0, 0}
1132 /* Number of elements in default_compilers, not counting the terminator. */
1134 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1136 /* A vector of options to give to the linker.
1137 These options are accumulated by %x,
1138 and substituted into the linker command with %X. */
1139 static int n_linker_options;
1140 static char **linker_options;
1142 /* A vector of options to give to the assembler.
1143 These options are accumulated by -Wa,
1144 and substituted into the assembler command with %Y. */
1145 static int n_assembler_options;
1146 static char **assembler_options;
1148 /* A vector of options to give to the preprocessor.
1149 These options are accumulated by -Wp,
1150 and substituted into the preprocessor command with %Z. */
1151 static int n_preprocessor_options;
1152 static char **preprocessor_options;
1154 /* Define how to map long options into short ones. */
1156 /* This structure describes one mapping. */
1157 struct option_map
1159 /* The long option's name. */
1160 const char *const name;
1161 /* The equivalent short option. */
1162 const char *const equivalent;
1163 /* Argument info. A string of flag chars; NULL equals no options.
1164 a => argument required.
1165 o => argument optional.
1166 j => join argument to equivalent, making one word.
1167 * => require other text after NAME as an argument. */
1168 const char *const arg_info;
1171 /* This is the table of mappings. Mappings are tried sequentially
1172 for each option encountered; the first one that matches, wins. */
1174 static const struct option_map option_map[] =
1176 {"--all-warnings", "-Wall", 0},
1177 {"--ansi", "-ansi", 0},
1178 {"--assemble", "-S", 0},
1179 {"--assert", "-A", "a"},
1180 {"--classpath", "-fclasspath=", "aj"},
1181 {"--bootclasspath", "-fbootclasspath=", "aj"},
1182 {"--CLASSPATH", "-fclasspath=", "aj"},
1183 {"--combine", "-combine", 0},
1184 {"--comments", "-C", 0},
1185 {"--comments-in-macros", "-CC", 0},
1186 {"--compile", "-c", 0},
1187 {"--debug", "-g", "oj"},
1188 {"--define-macro", "-D", "aj"},
1189 {"--dependencies", "-M", 0},
1190 {"--dump", "-d", "a"},
1191 {"--dumpbase", "-dumpbase", "a"},
1192 {"--dumpdir", "-dumpdir", "a"},
1193 {"--encoding", "-fencoding=", "aj"},
1194 {"--entry", "-e", 0},
1195 {"--extra-warnings", "-W", 0},
1196 {"--extdirs", "-fextdirs=", "aj"},
1197 {"--for-assembler", "-Wa", "a"},
1198 {"--for-linker", "-Xlinker", "a"},
1199 {"--force-link", "-u", "a"},
1200 {"--coverage", "-coverage", 0},
1201 {"--imacros", "-imacros", "a"},
1202 {"--include", "-include", "a"},
1203 {"--include-barrier", "-I-", 0},
1204 {"--include-directory", "-I", "aj"},
1205 {"--include-directory-after", "-idirafter", "a"},
1206 {"--include-prefix", "-iprefix", "a"},
1207 {"--include-with-prefix", "-iwithprefix", "a"},
1208 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1209 {"--include-with-prefix-after", "-iwithprefix", "a"},
1210 {"--language", "-x", "a"},
1211 {"--library-directory", "-L", "a"},
1212 {"--machine", "-m", "aj"},
1213 {"--machine-", "-m", "*j"},
1214 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1215 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1216 {"--no-line-commands", "-P", 0},
1217 {"--no-precompiled-includes", "-noprecomp", 0},
1218 {"--no-standard-includes", "-nostdinc", 0},
1219 {"--no-standard-libraries", "-nostdlib", 0},
1220 {"--no-warnings", "-w", 0},
1221 {"--optimize", "-O", "oj"},
1222 {"--output", "-o", "a"},
1223 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1224 {"--param", "--param", "a"},
1225 {"--pass-exit-codes", "-pass-exit-codes", 0},
1226 {"--pedantic", "-pedantic", 0},
1227 {"--pedantic-errors", "-pedantic-errors", 0},
1228 {"--pie", "-pie", 0},
1229 {"--pipe", "-pipe", 0},
1230 {"--prefix", "-B", "a"},
1231 {"--preprocess", "-E", 0},
1232 {"--print-search-dirs", "-print-search-dirs", 0},
1233 {"--print-file-name", "-print-file-name=", "aj"},
1234 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1235 {"--print-missing-file-dependencies", "-MG", 0},
1236 {"--print-multi-lib", "-print-multi-lib", 0},
1237 {"--print-multi-directory", "-print-multi-directory", 0},
1238 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1239 {"--print-prog-name", "-print-prog-name=", "aj"},
1240 {"--print-sysroot", "-print-sysroot", 0},
1241 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1242 {"--profile", "-p", 0},
1243 {"--profile-blocks", "-a", 0},
1244 {"--quiet", "-q", 0},
1245 {"--resource", "-fcompile-resource=", "aj"},
1246 {"--save-temps", "-save-temps", 0},
1247 {"--shared", "-shared", 0},
1248 {"--silent", "-q", 0},
1249 {"--specs", "-specs=", "aj"},
1250 {"--static", "-static", 0},
1251 {"--std", "-std=", "aj"},
1252 {"--symbolic", "-symbolic", 0},
1253 {"--sysroot", "--sysroot=", "aj"},
1254 {"--time", "-time", 0},
1255 {"--trace-includes", "-H", 0},
1256 {"--traditional", "-traditional", 0},
1257 {"--traditional-cpp", "-traditional-cpp", 0},
1258 {"--trigraphs", "-trigraphs", 0},
1259 {"--undefine-macro", "-U", "aj"},
1260 {"--user-dependencies", "-MM", 0},
1261 {"--verbose", "-v", 0},
1262 {"--warn-", "-W", "*j"},
1263 {"--write-dependencies", "-MD", 0},
1264 {"--write-user-dependencies", "-MMD", 0},
1265 {"--", "-f", "*j"}
1269 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1270 static const struct {
1271 const char *const option_found;
1272 const char *const replacements;
1273 } target_option_translations[] =
1275 TARGET_OPTION_TRANSLATE_TABLE,
1276 { 0, 0 }
1278 #endif
1280 /* Translate the options described by *ARGCP and *ARGVP.
1281 Make a new vector and store it back in *ARGVP,
1282 and store its length in *ARGCP. */
1284 static void
1285 translate_options (int *argcp, const char *const **argvp)
1287 int i;
1288 int argc = *argcp;
1289 const char *const *argv = *argvp;
1290 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1291 const char **newv = XNEWVAR (const char *, newvsize);
1292 int newindex = 0;
1294 i = 0;
1295 newv[newindex++] = argv[i++];
1297 while (i < argc)
1299 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1300 int tott_idx;
1302 for (tott_idx = 0;
1303 target_option_translations[tott_idx].option_found;
1304 tott_idx++)
1306 if (strcmp (target_option_translations[tott_idx].option_found,
1307 argv[i]) == 0)
1309 int spaces = 1;
1310 const char *sp;
1311 char *np;
1313 for (sp = target_option_translations[tott_idx].replacements;
1314 *sp; sp++)
1316 if (*sp == ' ')
1317 spaces ++;
1320 newvsize += spaces * sizeof (const char *);
1321 newv = XRESIZEVAR (const char *, newv, newvsize);
1323 sp = target_option_translations[tott_idx].replacements;
1324 np = xstrdup (sp);
1326 while (1)
1328 while (*np == ' ')
1329 np++;
1330 if (*np == 0)
1331 break;
1332 newv[newindex++] = np;
1333 while (*np != ' ' && *np)
1334 np++;
1335 if (*np == 0)
1336 break;
1337 *np++ = 0;
1340 i ++;
1341 break;
1344 if (target_option_translations[tott_idx].option_found)
1345 continue;
1346 #endif
1348 /* Translate -- options. */
1349 if (argv[i][0] == '-' && argv[i][1] == '-')
1351 size_t j;
1352 /* Find a mapping that applies to this option. */
1353 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1355 size_t optlen = strlen (option_map[j].name);
1356 size_t arglen = strlen (argv[i]);
1357 size_t complen = arglen > optlen ? optlen : arglen;
1358 const char *arginfo = option_map[j].arg_info;
1360 if (arginfo == 0)
1361 arginfo = "";
1363 if (!strncmp (argv[i], option_map[j].name, complen))
1365 const char *arg = 0;
1367 if (arglen < optlen)
1369 size_t k;
1370 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1371 if (strlen (option_map[k].name) >= arglen
1372 && !strncmp (argv[i], option_map[k].name, arglen))
1374 error ("ambiguous abbreviation %s", argv[i]);
1375 break;
1378 if (k != ARRAY_SIZE (option_map))
1379 break;
1382 if (arglen > optlen)
1384 /* If the option has an argument, accept that. */
1385 if (argv[i][optlen] == '=')
1386 arg = argv[i] + optlen + 1;
1388 /* If this mapping requires extra text at end of name,
1389 accept that as "argument". */
1390 else if (strchr (arginfo, '*') != 0)
1391 arg = argv[i] + optlen;
1393 /* Otherwise, extra text at end means mismatch.
1394 Try other mappings. */
1395 else
1396 continue;
1399 else if (strchr (arginfo, '*') != 0)
1401 error ("incomplete '%s' option", option_map[j].name);
1402 break;
1405 /* Handle arguments. */
1406 if (strchr (arginfo, 'a') != 0)
1408 if (arg == 0)
1410 if (i + 1 == argc)
1412 error ("missing argument to '%s' option",
1413 option_map[j].name);
1414 break;
1417 arg = argv[++i];
1420 else if (strchr (arginfo, '*') != 0)
1422 else if (strchr (arginfo, 'o') == 0)
1424 if (arg != 0)
1425 error ("extraneous argument to '%s' option",
1426 option_map[j].name);
1427 arg = 0;
1430 /* Store the translation as one argv elt or as two. */
1431 if (arg != 0 && strchr (arginfo, 'j') != 0)
1432 newv[newindex++] = concat (option_map[j].equivalent, arg,
1433 NULL);
1434 else if (arg != 0)
1436 newv[newindex++] = option_map[j].equivalent;
1437 newv[newindex++] = arg;
1439 else
1440 newv[newindex++] = option_map[j].equivalent;
1442 break;
1445 i++;
1448 /* Handle old-fashioned options--just copy them through,
1449 with their arguments. */
1450 else if (argv[i][0] == '-')
1452 const char *p = argv[i] + 1;
1453 int c = *p;
1454 int nskip = 1;
1456 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1457 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1458 else if (WORD_SWITCH_TAKES_ARG (p))
1459 nskip += WORD_SWITCH_TAKES_ARG (p);
1460 else if ((c == 'B' || c == 'b' || c == 'x')
1461 && p[1] == 0)
1462 nskip += 1;
1463 else if (! strcmp (p, "Xlinker"))
1464 nskip += 1;
1465 else if (! strcmp (p, "Xpreprocessor"))
1466 nskip += 1;
1467 else if (! strcmp (p, "Xassembler"))
1468 nskip += 1;
1470 /* Watch out for an option at the end of the command line that
1471 is missing arguments, and avoid skipping past the end of the
1472 command line. */
1473 if (nskip + i > argc)
1474 nskip = argc - i;
1476 while (nskip > 0)
1478 newv[newindex++] = argv[i++];
1479 nskip--;
1482 else
1483 /* Ordinary operands, or +e options. */
1484 newv[newindex++] = argv[i++];
1487 newv[newindex] = 0;
1489 *argvp = newv;
1490 *argcp = newindex;
1493 static char *
1494 skip_whitespace (char *p)
1496 while (1)
1498 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1499 be considered whitespace. */
1500 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1501 return p + 1;
1502 else if (*p == '\n' || *p == ' ' || *p == '\t')
1503 p++;
1504 else if (*p == '#')
1506 while (*p != '\n')
1507 p++;
1508 p++;
1510 else
1511 break;
1514 return p;
1516 /* Structures to keep track of prefixes to try when looking for files. */
1518 struct prefix_list
1520 const char *prefix; /* String to prepend to the path. */
1521 struct prefix_list *next; /* Next in linked list. */
1522 int require_machine_suffix; /* Don't use without machine_suffix. */
1523 /* 2 means try both machine_suffix and just_machine_suffix. */
1524 int priority; /* Sort key - priority within list. */
1525 int os_multilib; /* 1 if OS multilib scheme should be used,
1526 0 for GCC multilib scheme. */
1529 struct path_prefix
1531 struct prefix_list *plist; /* List of prefixes to try */
1532 int max_len; /* Max length of a prefix in PLIST */
1533 const char *name; /* Name of this list (used in config stuff) */
1536 /* List of prefixes to try when looking for executables. */
1538 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1540 /* List of prefixes to try when looking for startup (crt0) files. */
1542 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1544 /* List of prefixes to try when looking for include files. */
1546 static struct path_prefix include_prefixes = { 0, 0, "include" };
1548 /* Suffix to attach to directories searched for commands.
1549 This looks like `MACHINE/VERSION/'. */
1551 static const char *machine_suffix = 0;
1553 /* Suffix to attach to directories searched for commands.
1554 This is just `MACHINE/'. */
1556 static const char *just_machine_suffix = 0;
1558 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1560 static const char *gcc_exec_prefix;
1562 /* Adjusted value of standard_libexec_prefix. */
1564 static const char *gcc_libexec_prefix;
1566 /* Default prefixes to attach to command names. */
1568 #ifndef STANDARD_STARTFILE_PREFIX_1
1569 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1570 #endif
1571 #ifndef STANDARD_STARTFILE_PREFIX_2
1572 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1573 #endif
1575 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1576 #undef MD_EXEC_PREFIX
1577 #undef MD_STARTFILE_PREFIX
1578 #undef MD_STARTFILE_PREFIX_1
1579 #endif
1581 /* If no prefixes defined, use the null string, which will disable them. */
1582 #ifndef MD_EXEC_PREFIX
1583 #define MD_EXEC_PREFIX ""
1584 #endif
1585 #ifndef MD_STARTFILE_PREFIX
1586 #define MD_STARTFILE_PREFIX ""
1587 #endif
1588 #ifndef MD_STARTFILE_PREFIX_1
1589 #define MD_STARTFILE_PREFIX_1 ""
1590 #endif
1592 /* These directories are locations set at configure-time based on the
1593 --prefix option provided to configure. Their initializers are
1594 defined in Makefile.in. These paths are not *directly* used when
1595 gcc_exec_prefix is set because, in that case, we know where the
1596 compiler has been installed, and use paths relative to that
1597 location instead. */
1598 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1599 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1600 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1601 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1603 /* For native compilers, these are well-known paths containing
1604 components that may be provided by the system. For cross
1605 compilers, these paths are not used. */
1606 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1607 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1608 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1609 static const char *const standard_startfile_prefix_1
1610 = STANDARD_STARTFILE_PREFIX_1;
1611 static const char *const standard_startfile_prefix_2
1612 = STANDARD_STARTFILE_PREFIX_2;
1614 /* A relative path to be used in finding the location of tools
1615 relative to the driver. */
1616 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1618 /* Subdirectory to use for locating libraries. Set by
1619 set_multilib_dir based on the compilation options. */
1621 static const char *multilib_dir;
1623 /* Subdirectory to use for locating libraries in OS conventions. Set by
1624 set_multilib_dir based on the compilation options. */
1626 static const char *multilib_os_dir;
1628 /* Structure to keep track of the specs that have been defined so far.
1629 These are accessed using %(specname) or %[specname] in a compiler
1630 or link spec. */
1632 struct spec_list
1634 /* The following 2 fields must be first */
1635 /* to allow EXTRA_SPECS to be initialized */
1636 const char *name; /* name of the spec. */
1637 const char *ptr; /* available ptr if no static pointer */
1639 /* The following fields are not initialized */
1640 /* by EXTRA_SPECS */
1641 const char **ptr_spec; /* pointer to the spec itself. */
1642 struct spec_list *next; /* Next spec in linked list. */
1643 int name_len; /* length of the name */
1644 int alloc_p; /* whether string was allocated */
1647 #define INIT_STATIC_SPEC(NAME,PTR) \
1648 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1650 /* List of statically defined specs. */
1651 static struct spec_list static_specs[] =
1653 INIT_STATIC_SPEC ("asm", &asm_spec),
1654 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1655 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1656 INIT_STATIC_SPEC ("asm_options", &asm_options),
1657 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1658 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1659 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1660 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1661 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1662 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1663 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1664 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1665 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1666 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1667 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1668 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1669 INIT_STATIC_SPEC ("link", &link_spec),
1670 INIT_STATIC_SPEC ("lib", &lib_spec),
1671 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1672 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1673 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1674 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1675 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1676 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1677 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1678 INIT_STATIC_SPEC ("version", &compiler_version),
1679 INIT_STATIC_SPEC ("multilib", &multilib_select),
1680 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1681 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1682 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1683 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1684 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1685 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1686 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1687 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1688 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1689 INIT_STATIC_SPEC ("lto_libgcc", &lto_libgcc_spec),
1690 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1691 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1692 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1693 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1694 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1695 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1696 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1697 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1700 #ifdef EXTRA_SPECS /* additional specs needed */
1701 /* Structure to keep track of just the first two args of a spec_list.
1702 That is all that the EXTRA_SPECS macro gives us. */
1703 struct spec_list_1
1705 const char *const name;
1706 const char *const ptr;
1709 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1710 static struct spec_list *extra_specs = (struct spec_list *) 0;
1711 #endif
1713 /* List of dynamically allocates specs that have been defined so far. */
1715 static struct spec_list *specs = (struct spec_list *) 0;
1717 /* List of static spec functions. */
1719 static const struct spec_function static_spec_functions[] =
1721 { "getenv", getenv_spec_function },
1722 { "if-exists", if_exists_spec_function },
1723 { "if-exists-else", if_exists_else_spec_function },
1724 { "replace-outfile", replace_outfile_spec_function },
1725 { "version-compare", version_compare_spec_function },
1726 { "include", include_spec_function },
1727 { "find-file", find_file_spec_function },
1728 { "print-asm-header", print_asm_header_spec_function },
1729 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1730 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1731 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1732 #ifdef EXTRA_SPEC_FUNCTIONS
1733 EXTRA_SPEC_FUNCTIONS
1734 #endif
1735 { 0, 0 }
1738 static int processing_spec_function;
1740 /* Add appropriate libgcc specs to OBSTACK, taking into account
1741 various permutations of -shared-libgcc, -shared, and such. */
1743 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1745 #ifndef USE_LD_AS_NEEDED
1746 #define USE_LD_AS_NEEDED 0
1747 #endif
1749 static void
1750 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1751 const char *static_name, const char *eh_name)
1753 char *buf;
1755 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1756 "%{!static:%{!static-libgcc:"
1757 #if USE_LD_AS_NEEDED
1758 "%{!shared-libgcc:",
1759 static_name, " --as-needed ", shared_name, " --no-as-needed"
1761 "%{shared-libgcc:",
1762 shared_name, "%{!shared: ", static_name, "}"
1764 #else
1765 "%{!shared:"
1766 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1767 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1769 #ifdef LINK_EH_SPEC
1770 "%{shared:"
1771 "%{shared-libgcc:", shared_name, "}"
1772 "%{!shared-libgcc:", static_name, "}"
1774 #else
1775 "%{shared:", shared_name, "}"
1776 #endif
1777 #endif
1778 "}}", NULL);
1780 obstack_grow (obstack, buf, strlen (buf));
1781 free (buf);
1783 #endif /* ENABLE_SHARED_LIBGCC */
1785 /* Initialize the specs lookup routines. */
1787 static void
1788 init_spec (void)
1790 struct spec_list *next = (struct spec_list *) 0;
1791 struct spec_list *sl = (struct spec_list *) 0;
1792 int i;
1794 if (specs)
1795 return; /* Already initialized. */
1797 if (verbose_flag)
1798 notice ("Using built-in specs.\n");
1800 #ifdef EXTRA_SPECS
1801 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1803 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1805 sl = &extra_specs[i];
1806 sl->name = extra_specs_1[i].name;
1807 sl->ptr = extra_specs_1[i].ptr;
1808 sl->next = next;
1809 sl->name_len = strlen (sl->name);
1810 sl->ptr_spec = &sl->ptr;
1811 next = sl;
1813 #endif
1815 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1817 sl = &static_specs[i];
1818 sl->next = next;
1819 next = sl;
1822 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1823 /* ??? If neither -shared-libgcc nor --static-libgcc was
1824 seen, then we should be making an educated guess. Some proposed
1825 heuristics for ELF include:
1827 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1828 program will be doing dynamic loading, which will likely
1829 need the shared libgcc.
1831 (2) If "-ldl", then it's also a fair bet that we're doing
1832 dynamic loading.
1834 (3) For each ET_DYN we're linking against (either through -lfoo
1835 or /some/path/foo.so), check to see whether it or one of
1836 its dependencies depends on a shared libgcc.
1838 (4) If "-shared"
1840 If the runtime is fixed to look for program headers instead
1841 of calling __register_frame_info at all, for each object,
1842 use the shared libgcc if any EH symbol referenced.
1844 If crtstuff is fixed to not invoke __register_frame_info
1845 automatically, for each object, use the shared libgcc if
1846 any non-empty unwind section found.
1848 Doing any of this probably requires invoking an external program to
1849 do the actual object file scanning. */
1851 const char *p = libgcc_spec;
1852 int in_sep = 1;
1854 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1855 when given the proper command line arguments. */
1856 while (*p)
1858 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1860 init_gcc_specs (&obstack,
1861 "-lgcc_s"
1862 #ifdef USE_LIBUNWIND_EXCEPTIONS
1863 " -lunwind"
1864 #endif
1866 "-lgcc",
1867 "-lgcc_eh"
1868 #ifdef USE_LIBUNWIND_EXCEPTIONS
1869 # ifdef HAVE_LD_STATIC_DYNAMIC
1870 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1871 # else
1872 " -lunwind"
1873 # endif
1874 #endif
1877 p += 5;
1878 in_sep = 0;
1880 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1882 /* Ug. We don't know shared library extensions. Hope that
1883 systems that use this form don't do shared libraries. */
1884 init_gcc_specs (&obstack,
1885 "-lgcc_s",
1886 "libgcc.a%s",
1887 "libgcc_eh.a%s"
1888 #ifdef USE_LIBUNWIND_EXCEPTIONS
1889 " -lunwind"
1890 #endif
1892 p += 10;
1893 in_sep = 0;
1895 else
1897 obstack_1grow (&obstack, *p);
1898 in_sep = (*p == ' ');
1899 p += 1;
1903 obstack_1grow (&obstack, '\0');
1904 libgcc_spec = XOBFINISH (&obstack, const char *);
1906 #endif
1907 #ifdef USE_AS_TRADITIONAL_FORMAT
1908 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1910 static const char tf[] = "--traditional-format ";
1911 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1912 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1913 asm_spec = XOBFINISH (&obstack, const char *);
1915 #endif
1917 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1918 # ifdef LINK_BUILDID_SPEC
1919 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1920 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1921 # endif
1922 # ifdef LINK_EH_SPEC
1923 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1924 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1925 # endif
1926 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1927 link_spec = XOBFINISH (&obstack, const char *);
1928 #endif
1930 specs = sl;
1933 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1934 removed; If the spec starts with a + then SPEC is added to the end of the
1935 current spec. */
1937 static void
1938 set_spec (const char *name, const char *spec)
1940 struct spec_list *sl;
1941 const char *old_spec;
1942 int name_len = strlen (name);
1943 int i;
1945 /* If this is the first call, initialize the statically allocated specs. */
1946 if (!specs)
1948 struct spec_list *next = (struct spec_list *) 0;
1949 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1951 sl = &static_specs[i];
1952 sl->next = next;
1953 next = sl;
1955 specs = sl;
1958 /* See if the spec already exists. */
1959 for (sl = specs; sl; sl = sl->next)
1960 if (name_len == sl->name_len && !strcmp (sl->name, name))
1961 break;
1963 if (!sl)
1965 /* Not found - make it. */
1966 sl = XNEW (struct spec_list);
1967 sl->name = xstrdup (name);
1968 sl->name_len = name_len;
1969 sl->ptr_spec = &sl->ptr;
1970 sl->alloc_p = 0;
1971 *(sl->ptr_spec) = "";
1972 sl->next = specs;
1973 specs = sl;
1976 old_spec = *(sl->ptr_spec);
1977 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1978 ? concat (old_spec, spec + 1, NULL)
1979 : xstrdup (spec));
1981 #ifdef DEBUG_SPECS
1982 if (verbose_flag)
1983 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1984 #endif
1986 /* Free the old spec. */
1987 if (old_spec && sl->alloc_p)
1988 free (CONST_CAST(char *, old_spec));
1990 sl->alloc_p = 1;
1993 /* Accumulate a command (program name and args), and run it. */
1995 /* Vector of pointers to arguments in the current line of specifications. */
1997 static const char **argbuf;
1999 /* Number of elements allocated in argbuf. */
2001 static int argbuf_length;
2003 /* Number of elements in argbuf currently in use (containing args). */
2005 static int argbuf_index;
2007 /* Position in the argbuf array containing the name of the output file
2008 (the value associated with the "-o" flag). */
2010 static int have_o_argbuf_index = 0;
2012 /* Were the options -c, -S or -E passed. */
2013 static int have_c = 0;
2015 /* Was the option -o passed. */
2016 static int have_o = 0;
2018 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2019 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2020 it here. */
2022 static struct temp_name {
2023 const char *suffix; /* suffix associated with the code. */
2024 int length; /* strlen (suffix). */
2025 int unique; /* Indicates whether %g or %u/%U was used. */
2026 const char *filename; /* associated filename. */
2027 int filename_length; /* strlen (filename). */
2028 struct temp_name *next;
2029 } *temp_names;
2031 /* Number of commands executed so far. */
2033 static int execution_count;
2035 /* Number of commands that exited with a signal. */
2037 static int signal_count;
2039 /* Name with which this program was invoked. */
2041 static const char *programname;
2043 /* Allocate the argument vector. */
2045 static void
2046 alloc_args (void)
2048 argbuf_length = 10;
2049 argbuf = XNEWVEC (const char *, argbuf_length);
2052 /* Clear out the vector of arguments (after a command is executed). */
2054 static void
2055 clear_args (void)
2057 argbuf_index = 0;
2060 /* Add one argument to the vector at the end.
2061 This is done when a space is seen or at the end of the line.
2062 If DELETE_ALWAYS is nonzero, the arg is a filename
2063 and the file should be deleted eventually.
2064 If DELETE_FAILURE is nonzero, the arg is a filename
2065 and the file should be deleted if this compilation fails. */
2067 static void
2068 store_arg (const char *arg, int delete_always, int delete_failure)
2070 if (argbuf_index + 1 == argbuf_length)
2071 argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
2073 argbuf[argbuf_index++] = arg;
2074 argbuf[argbuf_index] = 0;
2076 if (strcmp (arg, "-o") == 0)
2077 have_o_argbuf_index = argbuf_index;
2078 if (delete_always || delete_failure)
2080 const char *p;
2081 /* If the temporary file we should delete is specified as
2082 part of a joined argument extract the filename. */
2083 if (arg[0] == '-'
2084 && (p = strrchr (arg, '=')))
2085 arg = p + 1;
2086 record_temp_file (arg, delete_always, delete_failure);
2090 /* Load specs from a file name named FILENAME, replacing occurrences of
2091 various different types of line-endings, \r\n, \n\r and just \r, with
2092 a single \n. */
2094 static char *
2095 load_specs (const char *filename)
2097 int desc;
2098 int readlen;
2099 struct stat statbuf;
2100 char *buffer;
2101 char *buffer_p;
2102 char *specs;
2103 char *specs_p;
2105 if (verbose_flag)
2106 notice ("Reading specs from %s\n", filename);
2108 /* Open and stat the file. */
2109 desc = open (filename, O_RDONLY, 0);
2110 if (desc < 0)
2111 pfatal_with_name (filename);
2112 if (stat (filename, &statbuf) < 0)
2113 pfatal_with_name (filename);
2115 /* Read contents of file into BUFFER. */
2116 buffer = XNEWVEC (char, statbuf.st_size + 1);
2117 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2118 if (readlen < 0)
2119 pfatal_with_name (filename);
2120 buffer[readlen] = 0;
2121 close (desc);
2123 specs = XNEWVEC (char, readlen + 1);
2124 specs_p = specs;
2125 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2127 int skip = 0;
2128 char c = *buffer_p;
2129 if (c == '\r')
2131 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2132 skip = 1;
2133 else if (*(buffer_p + 1) == '\n') /* \r\n */
2134 skip = 1;
2135 else /* \r */
2136 c = '\n';
2138 if (! skip)
2139 *specs_p++ = c;
2141 *specs_p = '\0';
2143 free (buffer);
2144 return (specs);
2147 /* Read compilation specs from a file named FILENAME,
2148 replacing the default ones.
2150 A suffix which starts with `*' is a definition for
2151 one of the machine-specific sub-specs. The "suffix" should be
2152 *asm, *cc1, *cpp, *link, *startfile, etc.
2153 The corresponding spec is stored in asm_spec, etc.,
2154 rather than in the `compilers' vector.
2156 Anything invalid in the file is a fatal error. */
2158 static void
2159 read_specs (const char *filename, int main_p)
2161 char *buffer;
2162 char *p;
2164 buffer = load_specs (filename);
2166 /* Scan BUFFER for specs, putting them in the vector. */
2167 p = buffer;
2168 while (1)
2170 char *suffix;
2171 char *spec;
2172 char *in, *out, *p1, *p2, *p3;
2174 /* Advance P in BUFFER to the next nonblank nocomment line. */
2175 p = skip_whitespace (p);
2176 if (*p == 0)
2177 break;
2179 /* Is this a special command that starts with '%'? */
2180 /* Don't allow this for the main specs file, since it would
2181 encourage people to overwrite it. */
2182 if (*p == '%' && !main_p)
2184 p1 = p;
2185 while (*p && *p != '\n')
2186 p++;
2188 /* Skip '\n'. */
2189 p++;
2191 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2192 && (p1[sizeof "%include" - 1] == ' '
2193 || p1[sizeof "%include" - 1] == '\t'))
2195 char *new_filename;
2197 p1 += sizeof ("%include");
2198 while (*p1 == ' ' || *p1 == '\t')
2199 p1++;
2201 if (*p1++ != '<' || p[-2] != '>')
2202 fatal ("specs %%include syntax malformed after %ld characters",
2203 (long) (p1 - buffer + 1));
2205 p[-2] = '\0';
2206 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2207 read_specs (new_filename ? new_filename : p1, FALSE);
2208 continue;
2210 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2211 && (p1[sizeof "%include_noerr" - 1] == ' '
2212 || p1[sizeof "%include_noerr" - 1] == '\t'))
2214 char *new_filename;
2216 p1 += sizeof "%include_noerr";
2217 while (*p1 == ' ' || *p1 == '\t')
2218 p1++;
2220 if (*p1++ != '<' || p[-2] != '>')
2221 fatal ("specs %%include syntax malformed after %ld characters",
2222 (long) (p1 - buffer + 1));
2224 p[-2] = '\0';
2225 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2226 if (new_filename)
2227 read_specs (new_filename, FALSE);
2228 else if (verbose_flag)
2229 notice ("could not find specs file %s\n", p1);
2230 continue;
2232 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2233 && (p1[sizeof "%rename" - 1] == ' '
2234 || p1[sizeof "%rename" - 1] == '\t'))
2236 int name_len;
2237 struct spec_list *sl;
2238 struct spec_list *newsl;
2240 /* Get original name. */
2241 p1 += sizeof "%rename";
2242 while (*p1 == ' ' || *p1 == '\t')
2243 p1++;
2245 if (! ISALPHA ((unsigned char) *p1))
2246 fatal ("specs %%rename syntax malformed after %ld characters",
2247 (long) (p1 - buffer));
2249 p2 = p1;
2250 while (*p2 && !ISSPACE ((unsigned char) *p2))
2251 p2++;
2253 if (*p2 != ' ' && *p2 != '\t')
2254 fatal ("specs %%rename syntax malformed after %ld characters",
2255 (long) (p2 - buffer));
2257 name_len = p2 - p1;
2258 *p2++ = '\0';
2259 while (*p2 == ' ' || *p2 == '\t')
2260 p2++;
2262 if (! ISALPHA ((unsigned char) *p2))
2263 fatal ("specs %%rename syntax malformed after %ld characters",
2264 (long) (p2 - buffer));
2266 /* Get new spec name. */
2267 p3 = p2;
2268 while (*p3 && !ISSPACE ((unsigned char) *p3))
2269 p3++;
2271 if (p3 != p - 1)
2272 fatal ("specs %%rename syntax malformed after %ld characters",
2273 (long) (p3 - buffer));
2274 *p3 = '\0';
2276 for (sl = specs; sl; sl = sl->next)
2277 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2278 break;
2280 if (!sl)
2281 fatal ("specs %s spec was not found to be renamed", p1);
2283 if (strcmp (p1, p2) == 0)
2284 continue;
2286 for (newsl = specs; newsl; newsl = newsl->next)
2287 if (strcmp (newsl->name, p2) == 0)
2288 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2289 filename, p1, p2);
2291 if (verbose_flag)
2293 notice ("rename spec %s to %s\n", p1, p2);
2294 #ifdef DEBUG_SPECS
2295 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2296 #endif
2299 set_spec (p2, *(sl->ptr_spec));
2300 if (sl->alloc_p)
2301 free (CONST_CAST (char *, *(sl->ptr_spec)));
2303 *(sl->ptr_spec) = "";
2304 sl->alloc_p = 0;
2305 continue;
2307 else
2308 fatal ("specs unknown %% command after %ld characters",
2309 (long) (p1 - buffer));
2312 /* Find the colon that should end the suffix. */
2313 p1 = p;
2314 while (*p1 && *p1 != ':' && *p1 != '\n')
2315 p1++;
2317 /* The colon shouldn't be missing. */
2318 if (*p1 != ':')
2319 fatal ("specs file malformed after %ld characters",
2320 (long) (p1 - buffer));
2322 /* Skip back over trailing whitespace. */
2323 p2 = p1;
2324 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2325 p2--;
2327 /* Copy the suffix to a string. */
2328 suffix = save_string (p, p2 - p);
2329 /* Find the next line. */
2330 p = skip_whitespace (p1 + 1);
2331 if (p[1] == 0)
2332 fatal ("specs file malformed after %ld characters",
2333 (long) (p - buffer));
2335 p1 = p;
2336 /* Find next blank line or end of string. */
2337 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2338 p1++;
2340 /* Specs end at the blank line and do not include the newline. */
2341 spec = save_string (p, p1 - p);
2342 p = p1;
2344 /* Delete backslash-newline sequences from the spec. */
2345 in = spec;
2346 out = spec;
2347 while (*in != 0)
2349 if (in[0] == '\\' && in[1] == '\n')
2350 in += 2;
2351 else if (in[0] == '#')
2352 while (*in && *in != '\n')
2353 in++;
2355 else
2356 *out++ = *in++;
2358 *out = 0;
2360 if (suffix[0] == '*')
2362 if (! strcmp (suffix, "*link_command"))
2363 link_command_spec = spec;
2364 else
2365 set_spec (suffix + 1, spec);
2367 else
2369 /* Add this pair to the vector. */
2370 compilers
2371 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2373 compilers[n_compilers].suffix = suffix;
2374 compilers[n_compilers].spec = spec;
2375 n_compilers++;
2376 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2379 if (*suffix == 0)
2380 link_command_spec = spec;
2383 if (link_command_spec == 0)
2384 fatal ("spec file has no spec for linking");
2387 /* Record the names of temporary files we tell compilers to write,
2388 and delete them at the end of the run. */
2390 /* This is the common prefix we use to make temp file names.
2391 It is chosen once for each run of this program.
2392 It is substituted into a spec by %g or %j.
2393 Thus, all temp file names contain this prefix.
2394 In practice, all temp file names start with this prefix.
2396 This prefix comes from the envvar TMPDIR if it is defined;
2397 otherwise, from the P_tmpdir macro if that is defined;
2398 otherwise, in /usr/tmp or /tmp;
2399 or finally the current directory if all else fails. */
2401 static const char *temp_filename;
2403 /* Length of the prefix. */
2405 static int temp_filename_length;
2407 /* Define the list of temporary files to delete. */
2409 struct temp_file
2411 const char *name;
2412 struct temp_file *next;
2415 /* Queue of files to delete on success or failure of compilation. */
2416 static struct temp_file *always_delete_queue;
2417 /* Queue of files to delete on failure of compilation. */
2418 static struct temp_file *failure_delete_queue;
2420 /* Record FILENAME as a file to be deleted automatically.
2421 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2422 otherwise delete it in any case.
2423 FAIL_DELETE nonzero means delete it if a compilation step fails;
2424 otherwise delete it in any case. */
2426 void
2427 record_temp_file (const char *filename, int always_delete, int fail_delete)
2429 char *const name = xstrdup (filename);
2431 if (always_delete)
2433 struct temp_file *temp;
2434 for (temp = always_delete_queue; temp; temp = temp->next)
2435 if (! strcmp (name, temp->name))
2436 goto already1;
2438 temp = XNEW (struct temp_file);
2439 temp->next = always_delete_queue;
2440 temp->name = name;
2441 always_delete_queue = temp;
2443 already1:;
2446 if (fail_delete)
2448 struct temp_file *temp;
2449 for (temp = failure_delete_queue; temp; temp = temp->next)
2450 if (! strcmp (name, temp->name))
2451 goto already2;
2453 temp = XNEW (struct temp_file);
2454 temp->next = failure_delete_queue;
2455 temp->name = name;
2456 failure_delete_queue = temp;
2458 already2:;
2462 /* Delete all the temporary files whose names we previously recorded. */
2464 #ifndef DELETE_IF_ORDINARY
2465 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2466 do \
2468 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2469 if (unlink (NAME) < 0) \
2470 if (VERBOSE_FLAG) \
2471 perror_with_name (NAME); \
2472 } while (0)
2473 #endif
2475 static void
2476 delete_if_ordinary (const char *name)
2478 struct stat st;
2479 #ifdef DEBUG
2480 int i, c;
2482 printf ("Delete %s? (y or n) ", name);
2483 fflush (stdout);
2484 i = getchar ();
2485 if (i != '\n')
2486 while ((c = getchar ()) != '\n' && c != EOF)
2489 if (i == 'y' || i == 'Y')
2490 #endif /* DEBUG */
2491 DELETE_IF_ORDINARY (name, st, verbose_flag);
2494 static void
2495 delete_temp_files (void)
2497 struct temp_file *temp;
2499 for (temp = always_delete_queue; temp; temp = temp->next)
2500 delete_if_ordinary (temp->name);
2501 always_delete_queue = 0;
2504 /* Delete all the files to be deleted on error. */
2506 static void
2507 delete_failure_queue (void)
2509 struct temp_file *temp;
2511 for (temp = failure_delete_queue; temp; temp = temp->next)
2512 delete_if_ordinary (temp->name);
2515 static void
2516 clear_failure_queue (void)
2518 failure_delete_queue = 0;
2521 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2522 returns non-NULL.
2523 If DO_MULTI is true iterate over the paths twice, first with multilib
2524 suffix then without, otherwise iterate over the paths once without
2525 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2526 to avoid visiting the same path twice, but we could do better. For
2527 instance, /usr/lib/../lib is considered different from /usr/lib.
2528 At least EXTRA_SPACE chars past the end of the path passed to
2529 CALLBACK are available for use by the callback.
2530 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2532 Returns the value returned by CALLBACK. */
2534 static void *
2535 for_each_path (const struct path_prefix *paths,
2536 bool do_multi,
2537 size_t extra_space,
2538 void *(*callback) (char *, void *),
2539 void *callback_info)
2541 struct prefix_list *pl;
2542 const char *multi_dir = NULL;
2543 const char *multi_os_dir = NULL;
2544 const char *multi_suffix;
2545 const char *just_multi_suffix;
2546 char *path = NULL;
2547 void *ret = NULL;
2548 bool skip_multi_dir = false;
2549 bool skip_multi_os_dir = false;
2551 multi_suffix = machine_suffix;
2552 just_multi_suffix = just_machine_suffix;
2553 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2555 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2556 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2557 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2559 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2560 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2562 while (1)
2564 size_t multi_dir_len = 0;
2565 size_t multi_os_dir_len = 0;
2566 size_t suffix_len;
2567 size_t just_suffix_len;
2568 size_t len;
2570 if (multi_dir)
2571 multi_dir_len = strlen (multi_dir);
2572 if (multi_os_dir)
2573 multi_os_dir_len = strlen (multi_os_dir);
2574 suffix_len = strlen (multi_suffix);
2575 just_suffix_len = strlen (just_multi_suffix);
2577 if (path == NULL)
2579 len = paths->max_len + extra_space + 1;
2580 if (suffix_len > multi_os_dir_len)
2581 len += suffix_len;
2582 else
2583 len += multi_os_dir_len;
2584 path = XNEWVEC (char, len);
2587 for (pl = paths->plist; pl != 0; pl = pl->next)
2589 len = strlen (pl->prefix);
2590 memcpy (path, pl->prefix, len);
2592 /* Look first in MACHINE/VERSION subdirectory. */
2593 if (!skip_multi_dir)
2595 memcpy (path + len, multi_suffix, suffix_len + 1);
2596 ret = callback (path, callback_info);
2597 if (ret)
2598 break;
2601 /* Some paths are tried with just the machine (ie. target)
2602 subdir. This is used for finding as, ld, etc. */
2603 if (!skip_multi_dir
2604 && pl->require_machine_suffix == 2)
2606 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2607 ret = callback (path, callback_info);
2608 if (ret)
2609 break;
2612 /* Now try the base path. */
2613 if (!pl->require_machine_suffix
2614 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2616 const char *this_multi;
2617 size_t this_multi_len;
2619 if (pl->os_multilib)
2621 this_multi = multi_os_dir;
2622 this_multi_len = multi_os_dir_len;
2624 else
2626 this_multi = multi_dir;
2627 this_multi_len = multi_dir_len;
2630 if (this_multi_len)
2631 memcpy (path + len, this_multi, this_multi_len + 1);
2632 else
2633 path[len] = '\0';
2635 ret = callback (path, callback_info);
2636 if (ret)
2637 break;
2640 if (pl)
2641 break;
2643 if (multi_dir == NULL && multi_os_dir == NULL)
2644 break;
2646 /* Run through the paths again, this time without multilibs.
2647 Don't repeat any we have already seen. */
2648 if (multi_dir)
2650 free (CONST_CAST (char *, multi_dir));
2651 multi_dir = NULL;
2652 free (CONST_CAST (char *, multi_suffix));
2653 multi_suffix = machine_suffix;
2654 free (CONST_CAST (char *, just_multi_suffix));
2655 just_multi_suffix = just_machine_suffix;
2657 else
2658 skip_multi_dir = true;
2659 if (multi_os_dir)
2661 free (CONST_CAST (char *, multi_os_dir));
2662 multi_os_dir = NULL;
2664 else
2665 skip_multi_os_dir = true;
2668 if (multi_dir)
2670 free (CONST_CAST (char *, multi_dir));
2671 free (CONST_CAST (char *, multi_suffix));
2672 free (CONST_CAST (char *, just_multi_suffix));
2674 if (multi_os_dir)
2675 free (CONST_CAST (char *, multi_os_dir));
2676 if (ret != path)
2677 free (path);
2678 return ret;
2681 /* Callback for build_search_list. Adds path to obstack being built. */
2683 struct add_to_obstack_info {
2684 struct obstack *ob;
2685 bool check_dir;
2686 bool first_time;
2689 static void *
2690 add_to_obstack (char *path, void *data)
2692 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2694 if (info->check_dir && !is_directory (path, false))
2695 return NULL;
2697 if (!info->first_time)
2698 obstack_1grow (info->ob, PATH_SEPARATOR);
2700 obstack_grow (info->ob, path, strlen (path));
2702 info->first_time = false;
2703 return NULL;
2706 /* Add or change the value of an environment variable, outputting the
2707 change to standard error if in verbose mode. */
2708 static void
2709 xputenv (const char *string)
2711 if (verbose_flag)
2712 notice ("%s\n", string);
2713 putenv (CONST_CAST (char *, string));
2716 /* Build a list of search directories from PATHS.
2717 PREFIX is a string to prepend to the list.
2718 If CHECK_DIR_P is true we ensure the directory exists.
2719 If DO_MULTI is true, multilib paths are output first, then
2720 non-multilib paths.
2721 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2722 It is also used by the --print-search-dirs flag. */
2724 static char *
2725 build_search_list (const struct path_prefix *paths, const char *prefix,
2726 bool check_dir, bool do_multi)
2728 struct add_to_obstack_info info;
2730 info.ob = &collect_obstack;
2731 info.check_dir = check_dir;
2732 info.first_time = true;
2734 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2735 obstack_1grow (&collect_obstack, '=');
2737 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2739 obstack_1grow (&collect_obstack, '\0');
2740 return XOBFINISH (&collect_obstack, char *);
2743 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2744 for collect. */
2746 static void
2747 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2748 bool do_multi)
2750 xputenv (build_search_list (paths, env_var, true, do_multi));
2753 /* Check whether NAME can be accessed in MODE. This is like access,
2754 except that it never considers directories to be executable. */
2756 static int
2757 access_check (const char *name, int mode)
2759 if (mode == X_OK)
2761 struct stat st;
2763 if (stat (name, &st) < 0
2764 || S_ISDIR (st.st_mode))
2765 return -1;
2768 return access (name, mode);
2771 /* Callback for find_a_file. Appends the file name to the directory
2772 path. If the resulting file exists in the right mode, return the
2773 full pathname to the file. */
2775 struct file_at_path_info {
2776 const char *name;
2777 const char *suffix;
2778 int name_len;
2779 int suffix_len;
2780 int mode;
2783 static void *
2784 file_at_path (char *path, void *data)
2786 struct file_at_path_info *info = (struct file_at_path_info *) data;
2787 size_t len = strlen (path);
2789 memcpy (path + len, info->name, info->name_len);
2790 len += info->name_len;
2792 /* Some systems have a suffix for executable files.
2793 So try appending that first. */
2794 if (info->suffix_len)
2796 memcpy (path + len, info->suffix, info->suffix_len + 1);
2797 if (access_check (path, info->mode) == 0)
2798 return path;
2801 path[len] = '\0';
2802 if (access_check (path, info->mode) == 0)
2803 return path;
2805 return NULL;
2808 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2809 access to check permissions. If DO_MULTI is true, search multilib
2810 paths then non-multilib paths, otherwise do not search multilib paths.
2811 Return 0 if not found, otherwise return its name, allocated with malloc. */
2813 static char *
2814 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2815 bool do_multi)
2817 struct file_at_path_info info;
2819 #ifdef DEFAULT_ASSEMBLER
2820 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2821 return xstrdup (DEFAULT_ASSEMBLER);
2822 #endif
2824 #ifdef DEFAULT_LINKER
2825 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2826 return xstrdup (DEFAULT_LINKER);
2827 #endif
2829 /* Determine the filename to execute (special case for absolute paths). */
2831 if (IS_ABSOLUTE_PATH (name))
2833 if (access (name, mode) == 0)
2834 return xstrdup (name);
2836 return NULL;
2839 info.name = name;
2840 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2841 info.name_len = strlen (info.name);
2842 info.suffix_len = strlen (info.suffix);
2843 info.mode = mode;
2845 return (char*) for_each_path (pprefix, do_multi,
2846 info.name_len + info.suffix_len,
2847 file_at_path, &info);
2850 /* Ranking of prefixes in the sort list. -B prefixes are put before
2851 all others. */
2853 enum path_prefix_priority
2855 PREFIX_PRIORITY_B_OPT,
2856 PREFIX_PRIORITY_LAST
2859 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2860 order according to PRIORITY. Within each PRIORITY, new entries are
2861 appended.
2863 If WARN is nonzero, we will warn if no file is found
2864 through this prefix. WARN should point to an int
2865 which will be set to 1 if this entry is used.
2867 COMPONENT is the value to be passed to update_path.
2869 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2870 the complete value of machine_suffix.
2871 2 means try both machine_suffix and just_machine_suffix. */
2873 static void
2874 add_prefix (struct path_prefix *pprefix, const char *prefix,
2875 const char *component, /* enum prefix_priority */ int priority,
2876 int require_machine_suffix, int os_multilib)
2878 struct prefix_list *pl, **prev;
2879 int len;
2881 for (prev = &pprefix->plist;
2882 (*prev) != NULL && (*prev)->priority <= priority;
2883 prev = &(*prev)->next)
2886 /* Keep track of the longest prefix. */
2888 prefix = update_path (prefix, component);
2889 len = strlen (prefix);
2890 if (len > pprefix->max_len)
2891 pprefix->max_len = len;
2893 pl = XNEW (struct prefix_list);
2894 pl->prefix = prefix;
2895 pl->require_machine_suffix = require_machine_suffix;
2896 pl->priority = priority;
2897 pl->os_multilib = os_multilib;
2899 /* Insert after PREV. */
2900 pl->next = (*prev);
2901 (*prev) = pl;
2904 /* Same as add_prefix, but prepending target_system_root to prefix. */
2905 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2906 static void
2907 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2908 const char *component,
2909 /* enum prefix_priority */ int priority,
2910 int require_machine_suffix, int os_multilib)
2912 if (!IS_ABSOLUTE_PATH (prefix))
2913 fatal ("system path '%s' is not absolute", prefix);
2915 if (target_system_root)
2917 if (target_sysroot_suffix)
2918 prefix = concat (target_sysroot_suffix, prefix, NULL);
2919 prefix = concat (target_system_root, prefix, NULL);
2921 /* We have to override this because GCC's notion of sysroot
2922 moves along with GCC. */
2923 component = "GCC";
2926 add_prefix (pprefix, prefix, component, priority,
2927 require_machine_suffix, os_multilib);
2930 /* Execute the command specified by the arguments on the current line of spec.
2931 When using pipes, this includes several piped-together commands
2932 with `|' between them.
2934 Return 0 if successful, -1 if failed. */
2936 static int
2937 execute (void)
2939 int i;
2940 int n_commands; /* # of command. */
2941 char *string;
2942 struct pex_obj *pex;
2943 struct command
2945 const char *prog; /* program name. */
2946 const char **argv; /* vector of args. */
2949 struct command *commands; /* each command buffer with above info. */
2951 gcc_assert (!processing_spec_function);
2953 if (wrapper_string)
2955 string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2956 argbuf[0] = (string) ? string : argbuf[0];
2957 insert_wrapper (wrapper_string);
2960 /* Count # of piped commands. */
2961 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2962 if (strcmp (argbuf[i], "|") == 0)
2963 n_commands++;
2965 /* Get storage for each command. */
2966 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2968 /* Split argbuf into its separate piped processes,
2969 and record info about each one.
2970 Also search for the programs that are to be run. */
2972 commands[0].prog = argbuf[0]; /* first command. */
2973 commands[0].argv = &argbuf[0];
2975 if (!wrapper_string)
2977 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2978 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2981 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2982 if (strcmp (argbuf[i], "|") == 0)
2983 { /* each command. */
2984 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2985 fatal ("-pipe not supported");
2986 #endif
2987 argbuf[i] = 0; /* termination of command args. */
2988 commands[n_commands].prog = argbuf[i + 1];
2989 commands[n_commands].argv = &argbuf[i + 1];
2990 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2991 X_OK, false);
2992 if (string)
2993 commands[n_commands].argv[0] = string;
2994 n_commands++;
2997 argbuf[argbuf_index] = 0;
2999 /* If -v, print what we are about to do, and maybe query. */
3001 if (verbose_flag)
3003 /* For help listings, put a blank line between sub-processes. */
3004 if (print_help_list)
3005 fputc ('\n', stderr);
3007 /* Print each piped command as a separate line. */
3008 for (i = 0; i < n_commands; i++)
3010 const char *const *j;
3012 if (verbose_only_flag)
3014 for (j = commands[i].argv; *j; j++)
3016 const char *p;
3017 for (p = *j; *p; ++p)
3018 if (!ISALNUM ((unsigned char) *p)
3019 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
3020 break;
3021 if (*p || !*j)
3023 fprintf (stderr, " \"");
3024 for (p = *j; *p; ++p)
3026 if (*p == '"' || *p == '\\' || *p == '$')
3027 fputc ('\\', stderr);
3028 fputc (*p, stderr);
3030 fputc ('"', stderr);
3032 else
3033 fprintf (stderr, " %s", *j);
3036 else
3037 for (j = commands[i].argv; *j; j++)
3038 fprintf (stderr, " %s", *j);
3040 /* Print a pipe symbol after all but the last command. */
3041 if (i + 1 != n_commands)
3042 fprintf (stderr, " |");
3043 fprintf (stderr, "\n");
3045 fflush (stderr);
3046 if (verbose_only_flag != 0)
3048 /* verbose_only_flag should act as if the spec was
3049 executed, so increment execution_count before
3050 returning. This prevents spurious warnings about
3051 unused linker input files, etc. */
3052 execution_count++;
3053 return 0;
3055 #ifdef DEBUG
3056 notice ("\nGo ahead? (y or n) ");
3057 fflush (stderr);
3058 i = getchar ();
3059 if (i != '\n')
3060 while (getchar () != '\n')
3063 if (i != 'y' && i != 'Y')
3064 return 0;
3065 #endif /* DEBUG */
3068 #ifdef ENABLE_VALGRIND_CHECKING
3069 /* Run the each command through valgrind. To simplify prepending the
3070 path to valgrind and the option "-q" (for quiet operation unless
3071 something triggers), we allocate a separate argv array. */
3073 for (i = 0; i < n_commands; i++)
3075 const char **argv;
3076 int argc;
3077 int j;
3079 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3082 argv = XALLOCAVEC (const char *, argc + 3);
3084 argv[0] = VALGRIND_PATH;
3085 argv[1] = "-q";
3086 for (j = 2; j < argc + 2; j++)
3087 argv[j] = commands[i].argv[j - 2];
3088 argv[j] = NULL;
3090 commands[i].argv = argv;
3091 commands[i].prog = argv[0];
3093 #endif
3095 /* Run each piped subprocess. */
3097 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3098 ? PEX_RECORD_TIMES : 0),
3099 programname, temp_filename);
3100 if (pex == NULL)
3101 pfatal_with_name (_("pex_init failed"));
3103 for (i = 0; i < n_commands; i++)
3105 const char *errmsg;
3106 int err;
3107 const char *string = commands[i].argv[0];
3109 errmsg = pex_run (pex,
3110 ((i + 1 == n_commands ? PEX_LAST : 0)
3111 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3112 string, CONST_CAST (char **, commands[i].argv),
3113 NULL, NULL, &err);
3114 if (errmsg != NULL)
3116 if (err == 0)
3117 fatal (errmsg);
3118 else
3120 errno = err;
3121 pfatal_with_name (errmsg);
3125 if (string != commands[i].prog)
3126 free (CONST_CAST (char *, string));
3129 execution_count++;
3131 /* Wait for all the subprocesses to finish. */
3134 int *statuses;
3135 struct pex_time *times = NULL;
3136 int ret_code = 0;
3138 statuses = (int *) alloca (n_commands * sizeof (int));
3139 if (!pex_get_status (pex, n_commands, statuses))
3140 pfatal_with_name (_("failed to get exit status"));
3142 if (report_times || report_times_to_file)
3144 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3145 if (!pex_get_times (pex, n_commands, times))
3146 pfatal_with_name (_("failed to get process times"));
3149 pex_free (pex);
3151 for (i = 0; i < n_commands; ++i)
3153 int status = statuses[i];
3155 if (WIFSIGNALED (status))
3157 #ifdef SIGPIPE
3158 /* SIGPIPE is a special case. It happens in -pipe mode
3159 when the compiler dies before the preprocessor is done,
3160 or the assembler dies before the compiler is done.
3161 There's generally been an error already, and this is
3162 just fallout. So don't generate another error unless
3163 we would otherwise have succeeded. */
3164 if (WTERMSIG (status) == SIGPIPE
3165 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3167 signal_count++;
3168 ret_code = -1;
3170 else
3171 #endif
3172 fatal_ice ("\
3173 Internal error: %s (program %s)\n\
3174 Please submit a full bug report.\n\
3175 See %s for instructions.",
3176 strsignal (WTERMSIG (status)), commands[i].prog,
3177 bug_report_url);
3179 else if (WIFEXITED (status)
3180 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3182 if (WEXITSTATUS (status) > greatest_status)
3183 greatest_status = WEXITSTATUS (status);
3184 ret_code = -1;
3187 if (report_times || report_times_to_file)
3189 struct pex_time *pt = &times[i];
3190 double ut, st;
3192 ut = ((double) pt->user_seconds
3193 + (double) pt->user_microseconds / 1.0e6);
3194 st = ((double) pt->system_seconds
3195 + (double) pt->system_microseconds / 1.0e6);
3197 if (ut + st != 0)
3199 if (report_times)
3200 notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3202 if (report_times_to_file)
3204 int c = 0;
3205 const char *const *j;
3207 fprintf (report_times_to_file, "%g %g", ut, st);
3209 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3211 const char *p;
3212 for (p = *j; *p; ++p)
3213 if (*p == '"' || *p == '\\' || *p == '$'
3214 || ISSPACE (*p))
3215 break;
3217 if (*p)
3219 fprintf (report_times_to_file, " \"");
3220 for (p = *j; *p; ++p)
3222 if (*p == '"' || *p == '\\' || *p == '$')
3223 fputc ('\\', report_times_to_file);
3224 fputc (*p, report_times_to_file);
3226 fputc ('"', report_times_to_file);
3228 else
3229 fprintf (report_times_to_file, " %s", *j);
3232 fputc ('\n', report_times_to_file);
3238 return ret_code;
3242 /* Find all the switches given to us
3243 and make a vector describing them.
3244 The elements of the vector are strings, one per switch given.
3245 If a switch uses following arguments, then the `part1' field
3246 is the switch itself and the `args' field
3247 is a null-terminated vector containing the following arguments.
3248 Bits in the `live_cond' field are:
3249 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3250 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3251 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3252 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3253 in all do_spec calls afterwards. Used for %<S from self specs.
3254 The `validated' field is nonzero if any spec has looked at this switch;
3255 if it remains zero at the end of the run, it must be meaningless. */
3257 #define SWITCH_LIVE 0x1
3258 #define SWITCH_FALSE 0x2
3259 #define SWITCH_IGNORE 0x4
3260 #define SWITCH_IGNORE_PERMANENTLY 0x8
3262 struct switchstr
3264 const char *part1;
3265 const char **args;
3266 unsigned int live_cond;
3267 unsigned char validated;
3268 unsigned char ordering;
3271 static struct switchstr *switches;
3273 static int n_switches;
3275 /* Set to zero if -fcompare-debug is disabled, positive if it's
3276 enabled and we're running the first compilation, negative if it's
3277 enabled and we're running the second compilation. For most of the
3278 time, it's in the range -1..1, but it can be temporarily set to 2
3279 or 3 to indicate that the -fcompare-debug flags didn't come from
3280 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3281 variable, until a synthesized -fcompare-debug flag is added to the
3282 command line. */
3283 int compare_debug;
3285 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3286 int compare_debug_second;
3288 /* Set to the flags that should be passed to the second compilation in
3289 a -fcompare-debug compilation. */
3290 const char *compare_debug_opt;
3292 static struct switchstr *switches_debug_check[2];
3294 static int n_switches_debug_check[2];
3296 static char *debug_check_temp_file[2];
3298 /* Language is one of three things:
3300 1) The name of a real programming language.
3301 2) NULL, indicating that no one has figured out
3302 what it is yet.
3303 3) '*', indicating that the file should be passed
3304 to the linker. */
3305 struct infile
3307 const char *name;
3308 const char *language;
3309 struct compiler *incompiler;
3310 bool compiled;
3311 bool preprocessed;
3314 /* Also a vector of input files specified. */
3316 static struct infile *infiles;
3318 int n_infiles;
3320 /* True if multiple input files are being compiled to a single
3321 assembly file. */
3323 static bool combine_inputs;
3325 /* This counts the number of libraries added by lang_specific_driver, so that
3326 we can tell if there were any user supplied any files or libraries. */
3328 static int added_libraries;
3330 /* And a vector of corresponding output files is made up later. */
3332 const char **outfiles;
3334 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3336 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3337 is true if we should look for an executable suffix. DO_OBJ
3338 is true if we should look for an object suffix. */
3340 static const char *
3341 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3342 int do_obj ATTRIBUTE_UNUSED)
3344 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3345 int i;
3346 #endif
3347 int len;
3349 if (name == NULL)
3350 return NULL;
3352 len = strlen (name);
3354 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3355 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3356 if (do_obj && len > 2
3357 && name[len - 2] == '.'
3358 && name[len - 1] == 'o')
3360 obstack_grow (&obstack, name, len - 2);
3361 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3362 name = XOBFINISH (&obstack, const char *);
3364 #endif
3366 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3367 /* If there is no filetype, make it the executable suffix (which includes
3368 the "."). But don't get confused if we have just "-o". */
3369 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3370 return name;
3372 for (i = len - 1; i >= 0; i--)
3373 if (IS_DIR_SEPARATOR (name[i]))
3374 break;
3376 for (i++; i < len; i++)
3377 if (name[i] == '.')
3378 return name;
3380 obstack_grow (&obstack, name, len);
3381 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3382 strlen (TARGET_EXECUTABLE_SUFFIX));
3383 name = XOBFINISH (&obstack, const char *);
3384 #endif
3386 return name;
3388 #endif
3390 /* Display the command line switches accepted by gcc. */
3391 static void
3392 display_help (void)
3394 printf (_("Usage: %s [options] file...\n"), programname);
3395 fputs (_("Options:\n"), stdout);
3397 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3398 fputs (_(" --help Display this information\n"), stdout);
3399 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3400 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3401 fputs (_(" Display specific types of command line options\n"), stdout);
3402 if (! verbose_flag)
3403 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3404 fputs (_(" --version Display compiler version information\n"), stdout);
3405 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3406 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3407 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3408 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3409 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3410 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3411 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3412 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3413 fputs (_("\
3414 -print-multi-lib Display the mapping between command line options and\n\
3415 multiple library search directories\n"), stdout);
3416 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3417 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3418 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3419 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3420 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3421 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3422 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3423 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3424 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3425 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3426 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3427 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3428 fputs (_("\
3429 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3430 prefixes to other gcc components\n"), stdout);
3431 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3432 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3433 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3434 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3435 fputs (_("\
3436 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3437 and libraries\n"), stdout);
3438 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3439 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3440 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3441 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3442 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3443 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3444 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3445 fputs (_("\
3446 -x <language> Specify the language of the following input files\n\
3447 Permissible languages include: c c++ assembler none\n\
3448 'none' means revert to the default behavior of\n\
3449 guessing the language based on the file's extension\n\
3450 "), stdout);
3452 printf (_("\
3453 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3454 passed on to the various sub-processes invoked by %s. In order to pass\n\
3455 other options on to these processes the -W<letter> options must be used.\n\
3456 "), programname);
3458 /* The rest of the options are displayed by invocations of the various
3459 sub-processes. */
3462 static void
3463 add_preprocessor_option (const char *option, int len)
3465 n_preprocessor_options++;
3467 if (! preprocessor_options)
3468 preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3469 else
3470 preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3471 n_preprocessor_options);
3473 preprocessor_options [n_preprocessor_options - 1] =
3474 save_string (option, len);
3477 static void
3478 add_assembler_option (const char *option, int len)
3480 n_assembler_options++;
3482 if (! assembler_options)
3483 assembler_options = XNEWVEC (char *, n_assembler_options);
3484 else
3485 assembler_options = XRESIZEVEC (char *, assembler_options,
3486 n_assembler_options);
3488 assembler_options [n_assembler_options - 1] = save_string (option, len);
3491 static void
3492 add_linker_option (const char *option, int len)
3494 n_linker_options++;
3496 if (! linker_options)
3497 linker_options = XNEWVEC (char *, n_linker_options);
3498 else
3499 linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3501 linker_options [n_linker_options - 1] = save_string (option, len);
3504 /* Create the vector `switches' and its contents.
3505 Store its length in `n_switches'. */
3507 static void
3508 process_command (int argc, const char **argv)
3510 int i;
3511 const char *temp;
3512 char *temp1;
3513 const char *spec_lang = 0;
3514 int last_language_n_infiles;
3515 int lang_n_infiles = 0;
3516 #ifdef MODIFY_TARGET_NAME
3517 int is_modify_target_name;
3518 unsigned int j;
3519 #endif
3520 const char *tooldir_prefix;
3521 char *(*get_relative_prefix) (const char *, const char *,
3522 const char *) = NULL;
3524 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3526 n_switches = 0;
3527 n_infiles = 0;
3528 added_libraries = 0;
3530 /* Figure compiler version from version string. */
3532 compiler_version = temp1 = xstrdup (version_string);
3534 for (; *temp1; ++temp1)
3536 if (*temp1 == ' ')
3538 *temp1 = '\0';
3539 break;
3543 /* Convert new-style -- options to old-style. */
3544 translate_options (&argc,
3545 CONST_CAST2 (const char *const **, const char ***,
3546 &argv));
3548 /* Handle any -no-canonical-prefixes flag early, to assign the function
3549 that builds relative prefixes. This function creates default search
3550 paths that are needed later in normal option handling. */
3552 for (i = 1; i < argc; i++)
3554 if (! strcmp (argv[i], "-no-canonical-prefixes"))
3556 get_relative_prefix = make_relative_prefix_ignore_links;
3557 break;
3560 if (! get_relative_prefix)
3561 get_relative_prefix = make_relative_prefix;
3563 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3564 see if we can create it from the pathname specified in argv[0]. */
3566 gcc_libexec_prefix = standard_libexec_prefix;
3567 #ifndef VMS
3568 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3569 if (!gcc_exec_prefix)
3571 gcc_exec_prefix = get_relative_prefix (argv[0],
3572 standard_bindir_prefix,
3573 standard_exec_prefix);
3574 gcc_libexec_prefix = get_relative_prefix (argv[0],
3575 standard_bindir_prefix,
3576 standard_libexec_prefix);
3577 if (gcc_exec_prefix)
3578 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3580 else
3582 /* make_relative_prefix requires a program name, but
3583 GCC_EXEC_PREFIX is typically a directory name with a trailing
3584 / (which is ignored by make_relative_prefix), so append a
3585 program name. */
3586 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3587 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3588 standard_exec_prefix,
3589 standard_libexec_prefix);
3591 /* The path is unrelocated, so fallback to the original setting. */
3592 if (!gcc_libexec_prefix)
3593 gcc_libexec_prefix = standard_libexec_prefix;
3595 free (tmp_prefix);
3597 #else
3598 #endif
3599 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3600 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3601 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3603 /* Do language-specific adjustment/addition of flags. */
3604 lang_specific_driver (&argc,
3605 CONST_CAST2 (const char *const **, const char ***,
3606 &argv),
3607 &added_libraries);
3609 if (gcc_exec_prefix)
3611 int len = strlen (gcc_exec_prefix);
3613 if (len > (int) sizeof ("/lib/gcc/") - 1
3614 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3616 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3617 if (IS_DIR_SEPARATOR (*temp)
3618 && strncmp (temp + 1, "lib", 3) == 0
3619 && IS_DIR_SEPARATOR (temp[4])
3620 && strncmp (temp + 5, "gcc", 3) == 0)
3621 len -= sizeof ("/lib/gcc/") - 1;
3624 set_std_prefix (gcc_exec_prefix, len);
3625 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3626 PREFIX_PRIORITY_LAST, 0, 0);
3627 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3628 PREFIX_PRIORITY_LAST, 0, 0);
3631 /* COMPILER_PATH and LIBRARY_PATH have values
3632 that are lists of directory names with colons. */
3634 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3635 if (temp)
3637 const char *startp, *endp;
3638 char *nstore = (char *) alloca (strlen (temp) + 3);
3640 startp = endp = temp;
3641 while (1)
3643 if (*endp == PATH_SEPARATOR || *endp == 0)
3645 strncpy (nstore, startp, endp - startp);
3646 if (endp == startp)
3647 strcpy (nstore, concat (".", dir_separator_str, NULL));
3648 else if (!IS_DIR_SEPARATOR (endp[-1]))
3650 nstore[endp - startp] = DIR_SEPARATOR;
3651 nstore[endp - startp + 1] = 0;
3653 else
3654 nstore[endp - startp] = 0;
3655 add_prefix (&exec_prefixes, nstore, 0,
3656 PREFIX_PRIORITY_LAST, 0, 0);
3657 add_prefix (&include_prefixes, nstore, 0,
3658 PREFIX_PRIORITY_LAST, 0, 0);
3659 if (*endp == 0)
3660 break;
3661 endp = startp = endp + 1;
3663 else
3664 endp++;
3668 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3669 if (temp && *cross_compile == '0')
3671 const char *startp, *endp;
3672 char *nstore = (char *) alloca (strlen (temp) + 3);
3674 startp = endp = temp;
3675 while (1)
3677 if (*endp == PATH_SEPARATOR || *endp == 0)
3679 strncpy (nstore, startp, endp - startp);
3680 if (endp == startp)
3681 strcpy (nstore, concat (".", dir_separator_str, NULL));
3682 else if (!IS_DIR_SEPARATOR (endp[-1]))
3684 nstore[endp - startp] = DIR_SEPARATOR;
3685 nstore[endp - startp + 1] = 0;
3687 else
3688 nstore[endp - startp] = 0;
3689 add_prefix (&startfile_prefixes, nstore, NULL,
3690 PREFIX_PRIORITY_LAST, 0, 1);
3691 if (*endp == 0)
3692 break;
3693 endp = startp = endp + 1;
3695 else
3696 endp++;
3700 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3701 GET_ENVIRONMENT (temp, "LPATH");
3702 if (temp && *cross_compile == '0')
3704 const char *startp, *endp;
3705 char *nstore = (char *) alloca (strlen (temp) + 3);
3707 startp = endp = temp;
3708 while (1)
3710 if (*endp == PATH_SEPARATOR || *endp == 0)
3712 strncpy (nstore, startp, endp - startp);
3713 if (endp == startp)
3714 strcpy (nstore, concat (".", dir_separator_str, NULL));
3715 else if (!IS_DIR_SEPARATOR (endp[-1]))
3717 nstore[endp - startp] = DIR_SEPARATOR;
3718 nstore[endp - startp + 1] = 0;
3720 else
3721 nstore[endp - startp] = 0;
3722 add_prefix (&startfile_prefixes, nstore, NULL,
3723 PREFIX_PRIORITY_LAST, 0, 1);
3724 if (*endp == 0)
3725 break;
3726 endp = startp = endp + 1;
3728 else
3729 endp++;
3733 /* Scan argv twice. Here, the first time, just count how many switches
3734 there will be in their vector, and how many input files in theirs.
3735 Here we also parse the switches that cc itself uses (e.g. -v). */
3737 for (i = 1; i < argc; i++)
3739 if (! strcmp (argv[i], "-dumpspecs"))
3741 struct spec_list *sl;
3742 init_spec ();
3743 for (sl = specs; sl; sl = sl->next)
3744 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3745 if (link_command_spec)
3746 printf ("*link_command:\n%s\n\n", link_command_spec);
3747 exit (0);
3749 else if (! strcmp (argv[i], "-dumpversion"))
3751 printf ("%s\n", spec_version);
3752 exit (0);
3754 else if (! strcmp (argv[i], "-dumpmachine"))
3756 printf ("%s\n", spec_machine);
3757 exit (0);
3759 else if (strcmp (argv[i], "-fversion") == 0)
3761 /* translate_options () has turned --version into -fversion. */
3762 print_version = 1;
3764 /* We will be passing a dummy file on to the sub-processes. */
3765 n_infiles++;
3766 n_switches++;
3768 /* CPP driver cannot obtain switch from cc1_options. */
3769 if (is_cpp_driver)
3770 add_preprocessor_option ("--version", strlen ("--version"));
3771 add_assembler_option ("--version", strlen ("--version"));
3772 add_linker_option ("--version", strlen ("--version"));
3774 else if (strcmp (argv[i], "-fhelp") == 0)
3776 /* translate_options () has turned --help into -fhelp. */
3777 print_help_list = 1;
3779 /* We will be passing a dummy file on to the sub-processes. */
3780 n_infiles++;
3781 n_switches++;
3783 /* CPP driver cannot obtain switch from cc1_options. */
3784 if (is_cpp_driver)
3785 add_preprocessor_option ("--help", 6);
3786 add_assembler_option ("--help", 6);
3787 add_linker_option ("--help", 6);
3789 else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3791 /* translate_options () has turned --help into -fhelp. */
3792 print_subprocess_help = 2;
3794 /* We will be passing a dummy file on to the sub-processes. */
3795 n_infiles++;
3796 n_switches++;
3798 else if (strcmp (argv[i], "-ftarget-help") == 0)
3800 /* translate_options() has turned --target-help into -ftarget-help. */
3801 print_subprocess_help = 1;
3803 /* We will be passing a dummy file on to the sub-processes. */
3804 n_infiles++;
3805 n_switches++;
3807 /* CPP driver cannot obtain switch from cc1_options. */
3808 if (is_cpp_driver)
3809 add_preprocessor_option ("--target-help", 13);
3810 add_assembler_option ("--target-help", 13);
3811 add_linker_option ("--target-help", 13);
3813 else if (! strcmp (argv[i], "-pass-exit-codes"))
3815 pass_exit_codes = 1;
3816 n_switches++;
3818 else if (! strcmp (argv[i], "-print-search-dirs"))
3819 print_search_dirs = 1;
3820 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3821 print_file_name = "libgcc.a";
3822 else if (! strncmp (argv[i], "-print-file-name=", 17))
3823 print_file_name = argv[i] + 17;
3824 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3825 print_prog_name = argv[i] + 17;
3826 else if (! strcmp (argv[i], "-print-multi-lib"))
3827 print_multi_lib = 1;
3828 else if (! strcmp (argv[i], "-print-multi-directory"))
3829 print_multi_directory = 1;
3830 else if (! strcmp (argv[i], "-print-sysroot"))
3831 print_sysroot = 1;
3832 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3833 print_multi_os_directory = 1;
3834 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3835 print_sysroot_headers_suffix = 1;
3836 else if (! strcmp (argv[i], "-fcompare-debug-second"))
3838 compare_debug_second = 1;
3839 n_switches++;
3841 else if (! strcmp (argv[i], "-fno-compare-debug"))
3843 argv[i] = "-fcompare-debug=";
3844 goto compare_debug_with_arg;
3846 else if (! strcmp (argv[i], "-fcompare-debug"))
3848 argv[i] = "-fcompare-debug=-gtoggle";
3849 goto compare_debug_with_arg;
3851 #define OPT "-fcompare-debug="
3852 else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3854 const char *opt;
3855 compare_debug_with_arg:
3856 opt = argv[i] + sizeof (OPT) - 1;
3857 #undef OPT
3858 if (*opt)
3859 compare_debug = 1;
3860 else
3861 compare_debug = -1;
3862 if (compare_debug < 0)
3863 compare_debug_opt = NULL;
3864 else
3865 compare_debug_opt = opt;
3866 n_switches++;
3868 else if (! strncmp (argv[i], "-Wa,", 4))
3870 int prev, j;
3871 /* Pass the rest of this option to the assembler. */
3873 /* Split the argument at commas. */
3874 prev = 4;
3875 for (j = 4; argv[i][j]; j++)
3876 if (argv[i][j] == ',')
3878 add_assembler_option (argv[i] + prev, j - prev);
3879 prev = j + 1;
3882 /* Record the part after the last comma. */
3883 add_assembler_option (argv[i] + prev, j - prev);
3885 else if (! strncmp (argv[i], "-Wp,", 4))
3887 int prev, j;
3888 /* Pass the rest of this option to the preprocessor. */
3890 /* Split the argument at commas. */
3891 prev = 4;
3892 for (j = 4; argv[i][j]; j++)
3893 if (argv[i][j] == ',')
3895 add_preprocessor_option (argv[i] + prev, j - prev);
3896 prev = j + 1;
3899 /* Record the part after the last comma. */
3900 add_preprocessor_option (argv[i] + prev, j - prev);
3902 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3903 /* The +e options to the C++ front-end. */
3904 n_switches++;
3905 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3907 int j;
3908 /* Split the argument at commas. */
3909 for (j = 3; argv[i][j]; j++)
3910 n_infiles += (argv[i][j] == ',');
3912 else if (strcmp (argv[i], "-Xlinker") == 0)
3914 if (i + 1 == argc)
3915 fatal ("argument to '-Xlinker' is missing");
3917 n_infiles++;
3918 i++;
3920 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3922 if (i + 1 == argc)
3923 fatal ("argument to '-Xpreprocessor' is missing");
3925 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3927 else if (strcmp (argv[i], "-Xassembler") == 0)
3929 if (i + 1 == argc)
3930 fatal ("argument to '-Xassembler' is missing");
3932 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3934 else if (strcmp (argv[i], "-l") == 0)
3936 if (i + 1 == argc)
3937 fatal ("argument to '-l' is missing");
3939 n_infiles++;
3940 i++;
3942 else if (strncmp (argv[i], "-l", 2) == 0)
3943 n_infiles++;
3944 else if (strcmp (argv[i], "-save-temps") == 0)
3946 save_temps_flag = SAVE_TEMPS_CWD;
3947 n_switches++;
3949 else if (strncmp (argv[i], "-save-temps=", 12) == 0)
3951 n_switches++;
3952 if (strcmp (argv[i]+12, "cwd") == 0)
3953 save_temps_flag = SAVE_TEMPS_CWD;
3954 else if (strcmp (argv[i]+12, "obj") == 0
3955 || strcmp (argv[i]+12, "object") == 0)
3956 save_temps_flag = SAVE_TEMPS_OBJ;
3957 else
3958 fatal ("'%s' is an unknown -save-temps option", argv[i]);
3960 else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
3961 /* Already handled as a special case, so ignored here. */
3963 else if (strcmp (argv[i], "-combine") == 0)
3965 combine_flag = 1;
3966 n_switches++;
3968 else if (strcmp (argv[i], "-specs") == 0)
3970 struct user_specs *user = XNEW (struct user_specs);
3971 if (++i >= argc)
3972 fatal ("argument to '-specs' is missing");
3974 user->next = (struct user_specs *) 0;
3975 user->filename = argv[i];
3976 if (user_specs_tail)
3977 user_specs_tail->next = user;
3978 else
3979 user_specs_head = user;
3980 user_specs_tail = user;
3982 else if (strncmp (argv[i], "-specs=", 7) == 0)
3984 struct user_specs *user = XNEW (struct user_specs);
3985 if (strlen (argv[i]) == 7)
3986 fatal ("argument to '-specs=' is missing");
3988 user->next = (struct user_specs *) 0;
3989 user->filename = argv[i] + 7;
3990 if (user_specs_tail)
3991 user_specs_tail->next = user;
3992 else
3993 user_specs_head = user;
3994 user_specs_tail = user;
3996 else if (strcmp (argv[i], "-time") == 0)
3997 report_times = 1;
3998 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4000 if (report_times_to_file)
4001 fclose (report_times_to_file);
4002 report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
4004 else if (strcmp (argv[i], "-pipe") == 0)
4006 /* -pipe has to go into the switches array as well as
4007 setting a flag. */
4008 use_pipes = 1;
4009 n_switches++;
4011 else if (strcmp (argv[i], "-wrapper") == 0)
4013 if (++i >= argc)
4014 fatal ("argument to '-wrapper' is missing");
4016 wrapper_string = argv[i];
4017 n_switches++;
4018 n_switches++;
4020 else if (strcmp (argv[i], "-###") == 0)
4022 /* This is similar to -v except that there is no execution
4023 of the commands and the echoed arguments are quoted. It
4024 is intended for use in shell scripts to capture the
4025 driver-generated command line. */
4026 verbose_only_flag++;
4027 verbose_flag++;
4029 else if (argv[i][0] == '-' && argv[i][1] != 0)
4031 const char *p = &argv[i][1];
4032 int c = *p;
4034 switch (c)
4036 case 'B':
4038 const char *value;
4039 int len;
4041 if (p[1] == 0 && i + 1 == argc)
4042 fatal ("argument to '-B' is missing");
4043 if (p[1] == 0)
4044 value = argv[++i];
4045 else
4046 value = p + 1;
4048 len = strlen (value);
4050 /* Catch the case where the user has forgotten to append a
4051 directory separator to the path. Note, they may be using
4052 -B to add an executable name prefix, eg "i386-elf-", in
4053 order to distinguish between multiple installations of
4054 GCC in the same directory. Hence we must check to see
4055 if appending a directory separator actually makes a
4056 valid directory name. */
4057 if (! IS_DIR_SEPARATOR (value [len - 1])
4058 && is_directory (value, false))
4060 char *tmp = XNEWVEC (char, len + 2);
4061 strcpy (tmp, value);
4062 tmp[len] = DIR_SEPARATOR;
4063 tmp[++ len] = 0;
4064 value = tmp;
4067 add_prefix (&exec_prefixes, value, NULL,
4068 PREFIX_PRIORITY_B_OPT, 0, 0);
4069 add_prefix (&startfile_prefixes, value, NULL,
4070 PREFIX_PRIORITY_B_OPT, 0, 0);
4071 add_prefix (&include_prefixes, value, NULL,
4072 PREFIX_PRIORITY_B_OPT, 0, 0);
4073 n_switches++;
4075 break;
4077 case 'v': /* Print our subcommands and print versions. */
4078 n_switches++;
4079 /* If they do anything other than exactly `-v', don't set
4080 verbose_flag; rather, continue on to give the error. */
4081 if (p[1] != 0)
4082 break;
4083 verbose_flag++;
4084 break;
4086 case 'S':
4087 case 'c':
4088 case 'E':
4089 if (p[1] == 0)
4091 have_c = 1;
4092 n_switches++;
4093 break;
4095 goto normal_switch;
4097 case 'o':
4098 have_o = 1;
4099 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4100 if (! have_c)
4102 int skip;
4104 /* Forward scan, just in case -S, -E or -c is specified
4105 after -o. */
4106 int j = i + 1;
4107 if (p[1] == 0)
4108 ++j;
4109 while (j < argc)
4111 if (argv[j][0] == '-')
4113 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4114 && argv[j][2] == 0)
4116 have_c = 1;
4117 break;
4119 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4120 j += skip - (argv[j][2] != 0);
4121 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4122 j += skip;
4124 j++;
4127 #endif
4128 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4129 if (p[1] == 0)
4130 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4131 else
4132 argv[i] = convert_filename (argv[i], ! have_c, 0);
4133 #endif
4134 /* Save the output name in case -save-temps=obj was used. */
4135 if ((p[1] == 0) && argv[i + 1])
4136 save_temps_prefix = xstrdup(argv[i + 1]);
4137 else
4138 save_temps_prefix = xstrdup(argv[i] + 1);
4139 goto normal_switch;
4141 default:
4142 normal_switch:
4144 #ifdef MODIFY_TARGET_NAME
4145 is_modify_target_name = 0;
4147 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4148 if (! strcmp (argv[i], modify_target[j].sw))
4150 char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
4151 + strlen (spec_machine));
4152 const char *p, *r;
4153 char *q;
4154 int made_addition = 0;
4156 is_modify_target_name = 1;
4157 for (p = spec_machine, q = new_name; *p != 0; )
4159 if (modify_target[j].add_del == DELETE
4160 && (! strncmp (q, modify_target[j].str,
4161 strlen (modify_target[j].str))))
4162 p += strlen (modify_target[j].str);
4163 else if (modify_target[j].add_del == ADD
4164 && ! made_addition && *p == '-')
4166 for (r = modify_target[j].str; *r != 0; )
4167 *q++ = *r++;
4168 made_addition = 1;
4171 *q++ = *p++;
4174 spec_machine = new_name;
4177 if (is_modify_target_name)
4178 break;
4179 #endif
4181 n_switches++;
4183 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
4184 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
4185 else if (WORD_SWITCH_TAKES_ARG (p))
4186 i += WORD_SWITCH_TAKES_ARG (p);
4189 else
4191 n_infiles++;
4192 lang_n_infiles++;
4196 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4197 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4198 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4200 save_temps_length = strlen (save_temps_prefix);
4201 temp = strrchr (lbasename (save_temps_prefix), '.');
4202 if (temp)
4204 save_temps_length -= strlen (temp);
4205 save_temps_prefix[save_temps_length] = '\0';
4209 else if (save_temps_prefix != NULL)
4211 free (save_temps_prefix);
4212 save_temps_prefix = NULL;
4215 if (save_temps_flag && use_pipes)
4217 /* -save-temps overrides -pipe, so that temp files are produced */
4218 if (save_temps_flag)
4219 error ("warning: -pipe ignored because -save-temps specified");
4220 use_pipes = 0;
4223 if (!compare_debug)
4225 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4227 if (gcd && gcd[0] == '-')
4229 compare_debug = 2;
4230 compare_debug_opt = gcd;
4231 n_switches++;
4233 else if (gcd && *gcd && strcmp (gcd, "0"))
4235 compare_debug = 3;
4236 compare_debug_opt = "-gtoggle";
4237 n_switches++;
4240 else if (compare_debug < 0)
4242 compare_debug = 0;
4243 gcc_assert (!compare_debug_opt);
4246 /* Set up the search paths. We add directories that we expect to
4247 contain GNU Toolchain components before directories specified by
4248 the machine description so that we will find GNU components (like
4249 the GNU assembler) before those of the host system. */
4251 /* If we don't know where the toolchain has been installed, use the
4252 configured-in locations. */
4253 if (!gcc_exec_prefix)
4255 #ifndef OS2
4256 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4257 PREFIX_PRIORITY_LAST, 1, 0);
4258 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4259 PREFIX_PRIORITY_LAST, 2, 0);
4260 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4261 PREFIX_PRIORITY_LAST, 2, 0);
4262 #endif
4263 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4264 PREFIX_PRIORITY_LAST, 1, 0);
4267 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4268 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4269 dir_separator_str, NULL);
4271 /* Look for tools relative to the location from which the driver is
4272 running, or, if that is not available, the configured prefix. */
4273 tooldir_prefix
4274 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4275 spec_machine, dir_separator_str,
4276 spec_version, dir_separator_str, tooldir_prefix, NULL);
4278 add_prefix (&exec_prefixes,
4279 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4280 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4281 add_prefix (&startfile_prefixes,
4282 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4283 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4285 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4286 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4287 then consider it to relocate with the rest of the GCC installation
4288 if GCC_EXEC_PREFIX is set.
4289 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4290 if (target_system_root && gcc_exec_prefix)
4292 char *tmp_prefix = get_relative_prefix (argv[0],
4293 standard_bindir_prefix,
4294 target_system_root);
4295 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4297 target_system_root = tmp_prefix;
4298 target_system_root_changed = 1;
4301 #endif
4303 /* More prefixes are enabled in main, after we read the specs file
4304 and determine whether this is cross-compilation or not. */
4306 /* Then create the space for the vectors and scan again. */
4308 switches = XNEWVEC (struct switchstr, n_switches + 1);
4309 infiles = XNEWVEC (struct infile, n_infiles + 1);
4310 n_switches = 0;
4311 n_infiles = 0;
4312 last_language_n_infiles = -1;
4314 /* This, time, copy the text of each switch and store a pointer
4315 to the copy in the vector of switches.
4316 Store all the infiles in their vector. */
4318 for (i = 1; i < argc; i++)
4320 /* Just skip the switches that were handled by the preceding loop. */
4321 #ifdef MODIFY_TARGET_NAME
4322 is_modify_target_name = 0;
4324 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4325 if (! strcmp (argv[i], modify_target[j].sw))
4326 is_modify_target_name = 1;
4328 if (is_modify_target_name)
4330 else
4331 #endif
4332 if (! strncmp (argv[i], "-Wa,", 4))
4334 else if (! strncmp (argv[i], "-Wp,", 4))
4336 else if (! strcmp (argv[i], "-no-canonical-prefixes"))
4338 else if (! strcmp (argv[i], "-pass-exit-codes"))
4340 else if (! strcmp (argv[i], "-print-search-dirs"))
4342 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4344 else if (! strncmp (argv[i], "-print-file-name=", 17))
4346 else if (! strncmp (argv[i], "-print-prog-name=", 17))
4348 else if (! strcmp (argv[i], "-print-multi-lib"))
4350 else if (! strcmp (argv[i], "-print-multi-directory"))
4352 else if (! strcmp (argv[i], "-print-sysroot"))
4354 else if (! strcmp (argv[i], "-print-multi-os-directory"))
4356 else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4358 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4360 target_system_root = argv[i] + strlen ("--sysroot=");
4361 target_system_root_changed = 1;
4363 else if (argv[i][0] == '+' && argv[i][1] == 'e')
4365 /* Compensate for the +e options to the C++ front-end;
4366 they're there simply for cfront call-compatibility. We do
4367 some magic in default_compilers to pass them down properly.
4368 Note we deliberately start at the `+' here, to avoid passing
4369 -e0 or -e1 down into the linker. */
4370 switches[n_switches].part1 = &argv[i][0];
4371 switches[n_switches].args = 0;
4372 switches[n_switches].live_cond = 0;
4373 switches[n_switches].validated = 0;
4374 n_switches++;
4376 else if (strncmp (argv[i], "-Wl,", 4) == 0)
4378 int prev, j;
4379 /* Split the argument at commas. */
4380 prev = 4;
4381 for (j = 4; argv[i][j]; j++)
4382 if (argv[i][j] == ',')
4384 infiles[n_infiles].language = "*";
4385 infiles[n_infiles++].name
4386 = save_string (argv[i] + prev, j - prev);
4387 prev = j + 1;
4389 /* Record the part after the last comma. */
4390 infiles[n_infiles].language = "*";
4391 infiles[n_infiles++].name = argv[i] + prev;
4393 else if (strcmp (argv[i], "-Xlinker") == 0)
4395 infiles[n_infiles].language = "*";
4396 infiles[n_infiles++].name = argv[++i];
4398 /* Xassembler and Xpreprocessor were already handled in the first argv
4399 scan, so all we need to do here is ignore them and their argument. */
4400 else if (strcmp (argv[i], "-Xassembler") == 0)
4401 i++;
4402 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4403 i++;
4404 else if (strcmp (argv[i], "-l") == 0)
4405 { /* POSIX allows separation of -l and the lib arg;
4406 canonicalize by concatenating -l with its arg */
4407 infiles[n_infiles].language = "*";
4408 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4410 else if (strncmp (argv[i], "-l", 2) == 0)
4412 infiles[n_infiles].language = "*";
4413 infiles[n_infiles++].name = argv[i];
4415 else if (strcmp (argv[i], "-wrapper") == 0)
4416 i++;
4417 else if (strcmp (argv[i], "-specs") == 0)
4418 i++;
4419 else if (strncmp (argv[i], "-specs=", 7) == 0)
4421 else if (strcmp (argv[i], "-time") == 0)
4423 else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4425 else if (strcmp (argv[i], "-###") == 0)
4427 else if (argv[i][0] == '-' && argv[i][1] != 0)
4429 const char *p = &argv[i][1];
4430 int c = *p;
4432 if (c == 'x')
4434 if (p[1] == 0 && i + 1 == argc)
4435 fatal ("argument to '-x' is missing");
4436 if (p[1] == 0)
4437 spec_lang = argv[++i];
4438 else
4439 spec_lang = p + 1;
4440 if (! strcmp (spec_lang, "none"))
4441 /* Suppress the warning if -xnone comes after the last input
4442 file, because alternate command interfaces like g++ might
4443 find it useful to place -xnone after each input file. */
4444 spec_lang = 0;
4445 else
4446 last_language_n_infiles = n_infiles;
4447 continue;
4449 switches[n_switches].part1 = p;
4450 /* Deal with option arguments in separate argv elements. */
4451 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4452 || WORD_SWITCH_TAKES_ARG (p))
4454 int j = 0;
4455 int n_args = WORD_SWITCH_TAKES_ARG (p);
4457 if (n_args == 0)
4459 /* Count only the option arguments in separate argv elements. */
4460 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4462 if (i + n_args >= argc)
4463 fatal ("argument to '-%s' is missing", p);
4464 switches[n_switches].args
4465 = XNEWVEC (const char *, n_args + 1);
4466 while (j < n_args)
4467 switches[n_switches].args[j++] = argv[++i];
4468 /* Null-terminate the vector. */
4469 switches[n_switches].args[j] = 0;
4471 else if (strchr (switches_need_spaces, c))
4473 /* On some systems, ld cannot handle some options without
4474 a space. So split the option from its argument. */
4475 char *part1 = XNEWVEC (char, 2);
4476 part1[0] = c;
4477 part1[1] = '\0';
4479 switches[n_switches].part1 = part1;
4480 switches[n_switches].args = XNEWVEC (const char *, 2);
4481 switches[n_switches].args[0] = xstrdup (p+1);
4482 switches[n_switches].args[1] = 0;
4484 else
4485 switches[n_switches].args = 0;
4487 switches[n_switches].live_cond = 0;
4488 switches[n_switches].validated = 0;
4489 switches[n_switches].ordering = 0;
4490 /* These are always valid, since gcc.c itself understands the
4491 first four, gfortranspec.c understands -static-libgfortran
4492 and g++spec.c understands -static-libstdc++ */
4493 if (!strcmp (p, "save-temps")
4494 || !strcmp (p, "static-libgcc")
4495 || !strcmp (p, "shared-libgcc")
4496 || !strcmp (p, "pipe")
4497 || !strcmp (p, "static-libgfortran")
4498 || !strcmp (p, "static-libstdc++"))
4499 switches[n_switches].validated = 1;
4500 else
4502 char ch = switches[n_switches].part1[0];
4503 if (ch == 'B')
4504 switches[n_switches].validated = 1;
4506 n_switches++;
4508 else
4510 const char *p = strrchr (argv[i], '@');
4511 char *fname;
4512 long offset;
4513 int consumed;
4514 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4515 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4516 #endif
4517 /* For LTO static archive support we handle input file
4518 specifications that are composed of a filename and
4519 an offset like FNAME@OFFSET. */
4520 if (p
4521 && p != argv[i]
4522 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4523 && strlen (p) == (unsigned int)consumed)
4525 fname = (char *)xmalloc (p - argv[i] + 1);
4526 memcpy (fname, argv[i], p - argv[i]);
4527 fname[p - argv[i]] = '\0';
4528 /* Only accept non-stdin and existing FNAME parts, otherwise
4529 try with the full name. */
4530 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4532 free (fname);
4533 fname = xstrdup (argv[i]);
4536 else
4537 fname = xstrdup (argv[i]);
4539 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4541 perror_with_name (fname);
4542 error_count++;
4544 else
4546 infiles[n_infiles].language = spec_lang;
4547 infiles[n_infiles++].name = argv[i];
4550 free (fname);
4554 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4555 error ("warning: '-x %s' after last input file has no effect", spec_lang);
4557 if (compare_debug == 2 || compare_debug == 3)
4559 switches[n_switches].part1 = concat ("fcompare-debug=",
4560 compare_debug_opt,
4561 NULL);
4562 switches[n_switches].args = 0;
4563 switches[n_switches].live_cond = 0;
4564 switches[n_switches].validated = 0;
4565 switches[n_switches].ordering = 0;
4566 n_switches++;
4567 compare_debug = 1;
4570 /* Ensure we only invoke each subprocess once. */
4571 if (print_subprocess_help || print_help_list || print_version)
4573 n_infiles = 1;
4575 /* Create a dummy input file, so that we can pass
4576 the help option on to the various sub-processes. */
4577 infiles[0].language = "c";
4578 infiles[0].name = "help-dummy";
4581 switches[n_switches].part1 = 0;
4582 infiles[n_infiles].name = 0;
4585 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4586 and place that in the environment. */
4588 static void
4589 set_collect_gcc_options (void)
4591 int i;
4592 int first_time;
4594 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4595 the compiler. */
4596 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4597 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4599 first_time = TRUE;
4600 for (i = 0; (int) i < n_switches; i++)
4602 const char *const *args;
4603 const char *p, *q;
4604 if (!first_time)
4605 obstack_grow (&collect_obstack, " ", 1);
4607 first_time = FALSE;
4609 /* Ignore elided switches. */
4610 if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4611 continue;
4613 obstack_grow (&collect_obstack, "'-", 2);
4614 q = switches[i].part1;
4615 while ((p = strchr (q, '\'')))
4617 obstack_grow (&collect_obstack, q, p - q);
4618 obstack_grow (&collect_obstack, "'\\''", 4);
4619 q = ++p;
4621 obstack_grow (&collect_obstack, q, strlen (q));
4622 obstack_grow (&collect_obstack, "'", 1);
4624 for (args = switches[i].args; args && *args; args++)
4626 obstack_grow (&collect_obstack, " '", 2);
4627 q = *args;
4628 while ((p = strchr (q, '\'')))
4630 obstack_grow (&collect_obstack, q, p - q);
4631 obstack_grow (&collect_obstack, "'\\''", 4);
4632 q = ++p;
4634 obstack_grow (&collect_obstack, q, strlen (q));
4635 obstack_grow (&collect_obstack, "'", 1);
4638 obstack_grow (&collect_obstack, "\0", 1);
4639 xputenv (XOBFINISH (&collect_obstack, char *));
4642 /* Process a spec string, accumulating and running commands. */
4644 /* These variables describe the input file name.
4645 input_file_number is the index on outfiles of this file,
4646 so that the output file name can be stored for later use by %o.
4647 input_basename is the start of the part of the input file
4648 sans all directory names, and basename_length is the number
4649 of characters starting there excluding the suffix .c or whatever. */
4651 static const char *input_filename;
4652 static int input_file_number;
4653 size_t input_filename_length;
4654 static int basename_length;
4655 static int suffixed_basename_length;
4656 static const char *input_basename;
4657 static const char *input_suffix;
4658 #ifndef HOST_LACKS_INODE_NUMBERS
4659 static struct stat input_stat;
4660 #endif
4661 static int input_stat_set;
4663 /* The compiler used to process the current input file. */
4664 static struct compiler *input_file_compiler;
4666 /* These are variables used within do_spec and do_spec_1. */
4668 /* Nonzero if an arg has been started and not yet terminated
4669 (with space, tab or newline). */
4670 static int arg_going;
4672 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4673 is a temporary file name. */
4674 static int delete_this_arg;
4676 /* Nonzero means %w has been seen; the next arg to be terminated
4677 is the output file name of this compilation. */
4678 static int this_is_output_file;
4680 /* Nonzero means %s has been seen; the next arg to be terminated
4681 is the name of a library file and we should try the standard
4682 search dirs for it. */
4683 static int this_is_library_file;
4685 /* Nonzero means %T has been seen; the next arg to be terminated
4686 is the name of a linker script and we should try all of the
4687 standard search dirs for it. If it is found insert a --script
4688 command line switch and then substitute the full path in place,
4689 otherwise generate an error message. */
4690 static int this_is_linker_script;
4692 /* Nonzero means that the input of this command is coming from a pipe. */
4693 static int input_from_pipe;
4695 /* Nonnull means substitute this for any suffix when outputting a switches
4696 arguments. */
4697 static const char *suffix_subst;
4699 /* If there is an argument being accumulated, terminate it and store it. */
4701 static void
4702 end_going_arg (void)
4704 if (arg_going)
4706 const char *string;
4708 obstack_1grow (&obstack, 0);
4709 string = XOBFINISH (&obstack, const char *);
4710 if (this_is_library_file)
4711 string = find_file (string);
4712 if (this_is_linker_script)
4714 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4716 if (full_script_path == NULL)
4718 error (_("unable to locate default linker script '%s' in the library search paths"), string);
4719 /* Script was not found on search path. */
4720 return;
4722 store_arg ("--script", false, false);
4723 string = full_script_path;
4725 store_arg (string, delete_this_arg, this_is_output_file);
4726 if (this_is_output_file)
4727 outfiles[input_file_number] = string;
4728 arg_going = 0;
4733 /* Parse the WRAPPER string which is a comma separated list of the command line
4734 and insert them into the beginning of argbuf. */
4736 static void
4737 insert_wrapper (const char *wrapper)
4739 int n = 0;
4740 int i;
4741 char *buf = xstrdup (wrapper);
4742 char *p = buf;
4746 n++;
4747 while (*p == ',')
4748 p++;
4750 while ((p = strchr (p, ',')) != NULL);
4752 if (argbuf_index + n >= argbuf_length)
4754 argbuf_length = argbuf_length * 2;
4755 while (argbuf_length < argbuf_index + n)
4756 argbuf_length *= 2;
4757 argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4759 for (i = argbuf_index - 1; i >= 0; i--)
4760 argbuf[i + n] = argbuf[i];
4762 i = 0;
4763 p = buf;
4766 while (*p == ',')
4768 *p = 0;
4769 p++;
4771 argbuf[i++] = p;
4773 while ((p = strchr (p, ',')) != NULL);
4774 gcc_assert (i == n);
4775 argbuf_index += n;
4778 /* Process the spec SPEC and run the commands specified therein.
4779 Returns 0 if the spec is successfully processed; -1 if failed. */
4782 do_spec (const char *spec)
4784 int value;
4786 value = do_spec_2 (spec);
4788 /* Force out any unfinished command.
4789 If -pipe, this forces out the last command if it ended in `|'. */
4790 if (value == 0)
4792 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4793 argbuf_index--;
4795 set_collect_gcc_options ();
4797 if (argbuf_index > 0)
4798 value = execute ();
4801 return value;
4804 static int
4805 do_spec_2 (const char *spec)
4807 int result;
4809 clear_args ();
4810 arg_going = 0;
4811 delete_this_arg = 0;
4812 this_is_output_file = 0;
4813 this_is_library_file = 0;
4814 this_is_linker_script = 0;
4815 input_from_pipe = 0;
4816 suffix_subst = NULL;
4818 result = do_spec_1 (spec, 0, NULL);
4820 end_going_arg ();
4822 return result;
4826 /* Process the given spec string and add any new options to the end
4827 of the switches/n_switches array. */
4829 static void
4830 do_option_spec (const char *name, const char *spec)
4832 unsigned int i, value_count, value_len;
4833 const char *p, *q, *value;
4834 char *tmp_spec, *tmp_spec_p;
4836 if (configure_default_options[0].name == NULL)
4837 return;
4839 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4840 if (strcmp (configure_default_options[i].name, name) == 0)
4841 break;
4842 if (i == ARRAY_SIZE (configure_default_options))
4843 return;
4845 value = configure_default_options[i].value;
4846 value_len = strlen (value);
4848 /* Compute the size of the final spec. */
4849 value_count = 0;
4850 p = spec;
4851 while ((p = strstr (p, "%(VALUE)")) != NULL)
4853 p ++;
4854 value_count ++;
4857 /* Replace each %(VALUE) by the specified value. */
4858 tmp_spec = (char *) alloca (strlen (spec) + 1
4859 + value_count * (value_len - strlen ("%(VALUE)")));
4860 tmp_spec_p = tmp_spec;
4861 q = spec;
4862 while ((p = strstr (q, "%(VALUE)")) != NULL)
4864 memcpy (tmp_spec_p, q, p - q);
4865 tmp_spec_p = tmp_spec_p + (p - q);
4866 memcpy (tmp_spec_p, value, value_len);
4867 tmp_spec_p += value_len;
4868 q = p + strlen ("%(VALUE)");
4870 strcpy (tmp_spec_p, q);
4872 do_self_spec (tmp_spec);
4875 /* Process the given spec string and add any new options to the end
4876 of the switches/n_switches array. */
4878 static void
4879 do_self_spec (const char *spec)
4881 int i;
4883 do_spec_2 (spec);
4884 do_spec_1 (" ", 0, NULL);
4886 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4887 do_self_specs adds the replacements to switches array, so it shouldn't
4888 be processed afterwards. */
4889 for (i = 0; i < n_switches; i++)
4890 if ((switches[i].live_cond & SWITCH_IGNORE))
4891 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4893 if (argbuf_index > 0)
4895 switches = XRESIZEVEC (struct switchstr, switches,
4896 n_switches + argbuf_index + 1);
4898 for (i = 0; i < argbuf_index; i++)
4900 struct switchstr *sw;
4901 const char *p = argbuf[i];
4902 int c = *p;
4904 /* Each switch should start with '-'. */
4905 if (c != '-')
4906 fatal ("switch '%s' does not start with '-'", argbuf[i]);
4908 p++;
4909 c = *p;
4911 sw = &switches[n_switches++];
4912 sw->part1 = p;
4913 sw->live_cond = 0;
4914 sw->validated = 0;
4915 sw->ordering = 0;
4917 /* Deal with option arguments in separate argv elements. */
4918 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4919 || WORD_SWITCH_TAKES_ARG (p))
4921 int j = 0;
4922 int n_args = WORD_SWITCH_TAKES_ARG (p);
4924 if (n_args == 0)
4926 /* Count only the option arguments in separate argv elements. */
4927 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4929 if (i + n_args >= argbuf_index)
4930 fatal ("argument to '-%s' is missing", p);
4931 sw->args
4932 = XNEWVEC (const char *, n_args + 1);
4933 while (j < n_args)
4934 sw->args[j++] = argbuf[++i];
4935 /* Null-terminate the vector. */
4936 sw->args[j] = 0;
4938 else if (strchr (switches_need_spaces, c))
4940 /* On some systems, ld cannot handle some options without
4941 a space. So split the option from its argument. */
4942 char *part1 = XNEWVEC (char, 2);
4943 part1[0] = c;
4944 part1[1] = '\0';
4946 sw->part1 = part1;
4947 sw->args = XNEWVEC (const char *, 2);
4948 sw->args[0] = xstrdup (p+1);
4949 sw->args[1] = 0;
4951 else
4952 sw->args = 0;
4955 switches[n_switches].part1 = 0;
4959 /* Callback for processing %D and %I specs. */
4961 struct spec_path_info {
4962 const char *option;
4963 const char *append;
4964 size_t append_len;
4965 bool omit_relative;
4966 bool separate_options;
4969 static void *
4970 spec_path (char *path, void *data)
4972 struct spec_path_info *info = (struct spec_path_info *) data;
4973 size_t len = 0;
4974 char save = 0;
4976 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4977 return NULL;
4979 if (info->append_len != 0)
4981 len = strlen (path);
4982 memcpy (path + len, info->append, info->append_len + 1);
4985 if (!is_directory (path, true))
4986 return NULL;
4988 do_spec_1 (info->option, 1, NULL);
4989 if (info->separate_options)
4990 do_spec_1 (" ", 0, NULL);
4992 if (info->append_len == 0)
4994 len = strlen (path);
4995 save = path[len - 1];
4996 if (IS_DIR_SEPARATOR (path[len - 1]))
4997 path[len - 1] = '\0';
5000 do_spec_1 (path, 1, NULL);
5001 do_spec_1 (" ", 0, NULL);
5003 /* Must not damage the original path. */
5004 if (info->append_len == 0)
5005 path[len - 1] = save;
5007 return NULL;
5010 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5011 argument list. */
5013 static void
5014 create_at_file (char **argv)
5016 char *temp_file = make_temp_file ("");
5017 char *at_argument = concat ("@", temp_file, NULL);
5018 FILE *f = fopen (temp_file, "w");
5019 int status;
5021 if (f == NULL)
5022 fatal ("could not open temporary response file %s",
5023 temp_file);
5025 status = writeargv (argv, f);
5027 if (status)
5028 fatal ("could not write to temporary response file %s",
5029 temp_file);
5031 status = fclose (f);
5033 if (EOF == status)
5034 fatal ("could not close temporary response file %s",
5035 temp_file);
5037 store_arg (at_argument, 0, 0);
5039 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5042 /* True if we should compile INFILE. */
5044 static bool
5045 compile_input_file_p (struct infile *infile)
5047 if ((!infile->language) || (infile->language[0] != '*'))
5048 if (infile->incompiler == input_file_compiler)
5049 return true;
5050 return false;
5053 /* Process the sub-spec SPEC as a portion of a larger spec.
5054 This is like processing a whole spec except that we do
5055 not initialize at the beginning and we do not supply a
5056 newline by default at the end.
5057 INSWITCH nonzero means don't process %-sequences in SPEC;
5058 in this case, % is treated as an ordinary character.
5059 This is used while substituting switches.
5060 INSWITCH nonzero also causes SPC not to terminate an argument.
5062 Value is zero unless a line was finished
5063 and the command on that line reported an error. */
5065 static int
5066 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5068 const char *p = spec;
5069 int c;
5070 int i;
5071 int value;
5073 while ((c = *p++))
5074 /* If substituting a switch, treat all chars like letters.
5075 Otherwise, NL, SPC, TAB and % are special. */
5076 switch (inswitch ? 'a' : c)
5078 case '\n':
5079 end_going_arg ();
5081 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5083 /* A `|' before the newline means use a pipe here,
5084 but only if -pipe was specified.
5085 Otherwise, execute now and don't pass the `|' as an arg. */
5086 if (use_pipes)
5088 input_from_pipe = 1;
5089 break;
5091 else
5092 argbuf_index--;
5095 set_collect_gcc_options ();
5097 if (argbuf_index > 0)
5099 value = execute ();
5100 if (value)
5101 return value;
5103 /* Reinitialize for a new command, and for a new argument. */
5104 clear_args ();
5105 arg_going = 0;
5106 delete_this_arg = 0;
5107 this_is_output_file = 0;
5108 this_is_library_file = 0;
5109 this_is_linker_script = 0;
5110 input_from_pipe = 0;
5111 break;
5113 case '|':
5114 end_going_arg ();
5116 /* Use pipe */
5117 obstack_1grow (&obstack, c);
5118 arg_going = 1;
5119 break;
5121 case '\t':
5122 case ' ':
5123 end_going_arg ();
5125 /* Reinitialize for a new argument. */
5126 delete_this_arg = 0;
5127 this_is_output_file = 0;
5128 this_is_library_file = 0;
5129 this_is_linker_script = 0;
5130 break;
5132 case '%':
5133 switch (c = *p++)
5135 case 0:
5136 fatal ("spec '%s' invalid", spec);
5138 case 'b':
5139 if (save_temps_length)
5140 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5141 else
5142 obstack_grow (&obstack, input_basename, basename_length);
5143 if (compare_debug < 0)
5144 obstack_grow (&obstack, ".gk", 3);
5145 arg_going = 1;
5146 break;
5148 case 'B':
5149 if (save_temps_length)
5150 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5151 else
5152 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5153 if (compare_debug < 0)
5154 obstack_grow (&obstack, ".gk", 3);
5155 arg_going = 1;
5156 break;
5158 case 'd':
5159 delete_this_arg = 2;
5160 break;
5162 /* Dump out the directories specified with LIBRARY_PATH,
5163 followed by the absolute directories
5164 that we search for startfiles. */
5165 case 'D':
5167 struct spec_path_info info;
5169 info.option = "-L";
5170 info.append_len = 0;
5171 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5172 /* Used on systems which record the specified -L dirs
5173 and use them to search for dynamic linking.
5174 Relative directories always come from -B,
5175 and it is better not to use them for searching
5176 at run time. In particular, stage1 loses. */
5177 info.omit_relative = true;
5178 #else
5179 info.omit_relative = false;
5180 #endif
5181 info.separate_options = false;
5183 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5185 break;
5187 case 'e':
5188 /* %efoo means report an error with `foo' as error message
5189 and don't execute any more commands for this file. */
5191 const char *q = p;
5192 char *buf;
5193 while (*p != 0 && *p != '\n')
5194 p++;
5195 buf = (char *) alloca (p - q + 1);
5196 strncpy (buf, q, p - q);
5197 buf[p - q] = 0;
5198 error ("%s", _(buf));
5199 return -1;
5201 break;
5202 case 'n':
5203 /* %nfoo means report a notice with `foo' on stderr. */
5205 const char *q = p;
5206 char *buf;
5207 while (*p != 0 && *p != '\n')
5208 p++;
5209 buf = (char *) alloca (p - q + 1);
5210 strncpy (buf, q, p - q);
5211 buf[p - q] = 0;
5212 notice ("%s\n", _(buf));
5213 if (*p)
5214 p++;
5216 break;
5218 case 'j':
5220 struct stat st;
5222 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5223 defined, and it is not a directory, and it is
5224 writable, use it. Otherwise, treat this like any
5225 other temporary file. */
5227 if ((!save_temps_flag)
5228 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5229 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5231 obstack_grow (&obstack, HOST_BIT_BUCKET,
5232 strlen (HOST_BIT_BUCKET));
5233 delete_this_arg = 0;
5234 arg_going = 1;
5235 break;
5238 goto create_temp_file;
5239 case '|':
5240 if (use_pipes)
5242 obstack_1grow (&obstack, '-');
5243 delete_this_arg = 0;
5244 arg_going = 1;
5246 /* consume suffix */
5247 while (*p == '.' || ISALNUM ((unsigned char) *p))
5248 p++;
5249 if (p[0] == '%' && p[1] == 'O')
5250 p += 2;
5252 break;
5254 goto create_temp_file;
5255 case 'm':
5256 if (use_pipes)
5258 /* consume suffix */
5259 while (*p == '.' || ISALNUM ((unsigned char) *p))
5260 p++;
5261 if (p[0] == '%' && p[1] == 'O')
5262 p += 2;
5264 break;
5266 goto create_temp_file;
5267 case 'g':
5268 case 'u':
5269 case 'U':
5270 create_temp_file:
5272 struct temp_name *t;
5273 int suffix_length;
5274 const char *suffix = p;
5275 char *saved_suffix = NULL;
5277 while (*p == '.' || ISALNUM ((unsigned char) *p))
5278 p++;
5279 suffix_length = p - suffix;
5280 if (p[0] == '%' && p[1] == 'O')
5282 p += 2;
5283 /* We don't support extra suffix characters after %O. */
5284 if (*p == '.' || ISALNUM ((unsigned char) *p))
5285 fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5286 if (suffix_length == 0)
5287 suffix = TARGET_OBJECT_SUFFIX;
5288 else
5290 saved_suffix
5291 = XNEWVEC (char, suffix_length
5292 + strlen (TARGET_OBJECT_SUFFIX));
5293 strncpy (saved_suffix, suffix, suffix_length);
5294 strcpy (saved_suffix + suffix_length,
5295 TARGET_OBJECT_SUFFIX);
5297 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5300 if (compare_debug < 0)
5302 suffix = concat (".gk", suffix, NULL);
5303 suffix_length += 3;
5306 /* If -save-temps=obj and -o were specified, use that for the
5307 temp file. */
5308 if (save_temps_length)
5310 char *tmp;
5311 temp_filename_length
5312 = save_temps_length + suffix_length + 1;
5313 tmp = (char *) alloca (temp_filename_length);
5314 memcpy (tmp, save_temps_prefix, save_temps_length);
5315 memcpy (tmp + save_temps_length, suffix, suffix_length);
5316 tmp[save_temps_length + suffix_length] = '\0';
5317 temp_filename = save_string (tmp,
5318 temp_filename_length + 1);
5319 obstack_grow (&obstack, temp_filename,
5320 temp_filename_length);
5321 arg_going = 1;
5322 delete_this_arg = 0;
5323 break;
5326 /* If the input_filename has the same suffix specified
5327 for the %g, %u, or %U, and -save-temps is specified,
5328 we could end up using that file as an intermediate
5329 thus clobbering the user's source file (.e.g.,
5330 gcc -save-temps foo.s would clobber foo.s with the
5331 output of cpp0). So check for this condition and
5332 generate a temp file as the intermediate. */
5334 if (save_temps_flag)
5336 char *tmp;
5337 temp_filename_length = basename_length + suffix_length + 1;
5338 tmp = (char *) alloca (temp_filename_length);
5339 memcpy (tmp, input_basename, basename_length);
5340 memcpy (tmp + basename_length, suffix, suffix_length);
5341 tmp[basename_length + suffix_length] = '\0';
5342 temp_filename = tmp;
5344 if (strcmp (temp_filename, input_filename) != 0)
5346 #ifndef HOST_LACKS_INODE_NUMBERS
5347 struct stat st_temp;
5349 /* Note, set_input() resets input_stat_set to 0. */
5350 if (input_stat_set == 0)
5352 input_stat_set = stat (input_filename, &input_stat);
5353 if (input_stat_set >= 0)
5354 input_stat_set = 1;
5357 /* If we have the stat for the input_filename
5358 and we can do the stat for the temp_filename
5359 then the they could still refer to the same
5360 file if st_dev/st_ino's are the same. */
5361 if (input_stat_set != 1
5362 || stat (temp_filename, &st_temp) < 0
5363 || input_stat.st_dev != st_temp.st_dev
5364 || input_stat.st_ino != st_temp.st_ino)
5365 #else
5366 /* Just compare canonical pathnames. */
5367 char* input_realname = lrealpath (input_filename);
5368 char* temp_realname = lrealpath (temp_filename);
5369 bool files_differ = strcmp (input_realname, temp_realname);
5370 free (input_realname);
5371 free (temp_realname);
5372 if (files_differ)
5373 #endif
5375 temp_filename = save_string (temp_filename,
5376 temp_filename_length + 1);
5377 obstack_grow (&obstack, temp_filename,
5378 temp_filename_length);
5379 arg_going = 1;
5380 delete_this_arg = 0;
5381 break;
5386 /* See if we already have an association of %g/%u/%U and
5387 suffix. */
5388 for (t = temp_names; t; t = t->next)
5389 if (t->length == suffix_length
5390 && strncmp (t->suffix, suffix, suffix_length) == 0
5391 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5392 break;
5394 /* Make a new association if needed. %u and %j
5395 require one. */
5396 if (t == 0 || c == 'u' || c == 'j')
5398 if (t == 0)
5400 t = XNEW (struct temp_name);
5401 t->next = temp_names;
5402 temp_names = t;
5404 t->length = suffix_length;
5405 if (saved_suffix)
5407 t->suffix = saved_suffix;
5408 saved_suffix = NULL;
5410 else
5411 t->suffix = save_string (suffix, suffix_length);
5412 t->unique = (c == 'u' || c == 'U' || c == 'j');
5413 temp_filename = make_temp_file (t->suffix);
5414 temp_filename_length = strlen (temp_filename);
5415 t->filename = temp_filename;
5416 t->filename_length = temp_filename_length;
5419 if (saved_suffix)
5420 free (saved_suffix);
5422 obstack_grow (&obstack, t->filename, t->filename_length);
5423 delete_this_arg = 1;
5425 arg_going = 1;
5426 break;
5428 case 'i':
5429 if (combine_inputs)
5431 if (at_file_supplied)
5433 /* We are going to expand `%i' to `@FILE', where FILE
5434 is a newly-created temporary filename. The filenames
5435 that would usually be expanded in place of %o will be
5436 written to the temporary file. */
5437 char **argv;
5438 int n_files = 0;
5439 int j;
5441 for (i = 0; i < n_infiles; i++)
5442 if (compile_input_file_p (&infiles[i]))
5443 n_files++;
5445 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5447 /* Copy the strings over. */
5448 for (i = 0, j = 0; i < n_infiles; i++)
5449 if (compile_input_file_p (&infiles[i]))
5451 argv[j] = CONST_CAST (char *, infiles[i].name);
5452 infiles[i].compiled = true;
5453 j++;
5455 argv[j] = NULL;
5457 create_at_file (argv);
5459 else
5460 for (i = 0; (int) i < n_infiles; i++)
5461 if (compile_input_file_p (&infiles[i]))
5463 store_arg (infiles[i].name, 0, 0);
5464 infiles[i].compiled = true;
5467 else
5469 obstack_grow (&obstack, input_filename, input_filename_length);
5470 arg_going = 1;
5472 break;
5474 case 'I':
5476 struct spec_path_info info;
5478 if (multilib_dir)
5480 do_spec_1 ("-imultilib", 1, NULL);
5481 /* Make this a separate argument. */
5482 do_spec_1 (" ", 0, NULL);
5483 do_spec_1 (multilib_dir, 1, NULL);
5484 do_spec_1 (" ", 0, NULL);
5487 if (gcc_exec_prefix)
5489 do_spec_1 ("-iprefix", 1, NULL);
5490 /* Make this a separate argument. */
5491 do_spec_1 (" ", 0, NULL);
5492 do_spec_1 (gcc_exec_prefix, 1, NULL);
5493 do_spec_1 (" ", 0, NULL);
5496 if (target_system_root_changed ||
5497 (target_system_root && target_sysroot_hdrs_suffix))
5499 do_spec_1 ("-isysroot", 1, NULL);
5500 /* Make this a separate argument. */
5501 do_spec_1 (" ", 0, NULL);
5502 do_spec_1 (target_system_root, 1, NULL);
5503 if (target_sysroot_hdrs_suffix)
5504 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5505 do_spec_1 (" ", 0, NULL);
5508 info.option = "-isystem";
5509 info.append = "include";
5510 info.append_len = strlen (info.append);
5511 info.omit_relative = false;
5512 info.separate_options = true;
5514 for_each_path (&include_prefixes, false, info.append_len,
5515 spec_path, &info);
5517 info.append = "include-fixed";
5518 if (*sysroot_hdrs_suffix_spec)
5519 info.append = concat (info.append, dir_separator_str,
5520 multilib_dir, NULL);
5521 info.append_len = strlen (info.append);
5522 for_each_path (&include_prefixes, false, info.append_len,
5523 spec_path, &info);
5525 break;
5527 case 'o':
5529 int max = n_infiles;
5530 max += lang_specific_extra_outfiles;
5532 if (HAVE_GNU_LD && at_file_supplied)
5534 /* We are going to expand `%o' to `@FILE', where FILE
5535 is a newly-created temporary filename. The filenames
5536 that would usually be expanded in place of %o will be
5537 written to the temporary file. */
5539 char **argv;
5540 int n_files, j;
5542 /* Convert OUTFILES into a form suitable for writeargv. */
5544 /* Determine how many are non-NULL. */
5545 for (n_files = 0, i = 0; i < max; i++)
5546 n_files += outfiles[i] != NULL;
5548 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5550 /* Copy the strings over. */
5551 for (i = 0, j = 0; i < max; i++)
5552 if (outfiles[i])
5554 argv[j] = CONST_CAST (char *, outfiles[i]);
5555 j++;
5557 argv[j] = NULL;
5559 create_at_file (argv);
5561 else
5562 for (i = 0; i < max; i++)
5563 if (outfiles[i])
5564 store_arg (outfiles[i], 0, 0);
5565 break;
5568 case 'O':
5569 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5570 arg_going = 1;
5571 break;
5573 case 's':
5574 this_is_library_file = 1;
5575 break;
5577 case 'T':
5578 this_is_linker_script = 1;
5579 break;
5581 case 'V':
5582 outfiles[input_file_number] = NULL;
5583 break;
5585 case 'w':
5586 this_is_output_file = 1;
5587 break;
5589 case 'W':
5591 int cur_index = argbuf_index;
5592 /* Handle the {...} following the %W. */
5593 if (*p != '{')
5594 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5595 p = handle_braces (p + 1);
5596 if (p == 0)
5597 return -1;
5598 end_going_arg ();
5599 /* If any args were output, mark the last one for deletion
5600 on failure. */
5601 if (argbuf_index != cur_index)
5602 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5603 break;
5606 /* %x{OPTION} records OPTION for %X to output. */
5607 case 'x':
5609 const char *p1 = p;
5610 char *string;
5612 /* Skip past the option value and make a copy. */
5613 if (*p != '{')
5614 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5615 while (*p++ != '}')
5617 string = save_string (p1 + 1, p - p1 - 2);
5619 /* See if we already recorded this option. */
5620 for (i = 0; i < n_linker_options; i++)
5621 if (! strcmp (string, linker_options[i]))
5623 free (string);
5624 return 0;
5627 /* This option is new; add it. */
5628 add_linker_option (string, strlen (string));
5630 break;
5632 /* Dump out the options accumulated previously using %x. */
5633 case 'X':
5634 for (i = 0; i < n_linker_options; i++)
5636 do_spec_1 (linker_options[i], 1, NULL);
5637 /* Make each accumulated option a separate argument. */
5638 do_spec_1 (" ", 0, NULL);
5640 break;
5642 /* Dump out the options accumulated previously using -Wa,. */
5643 case 'Y':
5644 for (i = 0; i < n_assembler_options; i++)
5646 do_spec_1 (assembler_options[i], 1, NULL);
5647 /* Make each accumulated option a separate argument. */
5648 do_spec_1 (" ", 0, NULL);
5650 break;
5652 /* Dump out the options accumulated previously using -Wp,. */
5653 case 'Z':
5654 for (i = 0; i < n_preprocessor_options; i++)
5656 do_spec_1 (preprocessor_options[i], 1, NULL);
5657 /* Make each accumulated option a separate argument. */
5658 do_spec_1 (" ", 0, NULL);
5660 break;
5662 /* Here are digits and numbers that just process
5663 a certain constant string as a spec. */
5665 case '1':
5666 value = do_spec_1 (cc1_spec, 0, NULL);
5667 if (value != 0)
5668 return value;
5669 break;
5671 case '2':
5672 value = do_spec_1 (cc1plus_spec, 0, NULL);
5673 if (value != 0)
5674 return value;
5675 break;
5677 case 'a':
5678 value = do_spec_1 (asm_spec, 0, NULL);
5679 if (value != 0)
5680 return value;
5681 break;
5683 case 'A':
5684 value = do_spec_1 (asm_final_spec, 0, NULL);
5685 if (value != 0)
5686 return value;
5687 break;
5689 case 'C':
5691 const char *const spec
5692 = (input_file_compiler->cpp_spec
5693 ? input_file_compiler->cpp_spec
5694 : cpp_spec);
5695 value = do_spec_1 (spec, 0, NULL);
5696 if (value != 0)
5697 return value;
5699 break;
5701 case 'E':
5702 value = do_spec_1 (endfile_spec, 0, NULL);
5703 if (value != 0)
5704 return value;
5705 break;
5707 case 'l':
5708 value = do_spec_1 (link_spec, 0, NULL);
5709 if (value != 0)
5710 return value;
5711 break;
5713 case 'L':
5714 value = do_spec_1 (lib_spec, 0, NULL);
5715 if (value != 0)
5716 return value;
5717 break;
5719 case 'G':
5720 value = do_spec_1 (libgcc_spec, 0, NULL);
5721 if (value != 0)
5722 return value;
5723 break;
5725 case 'R':
5726 /* We assume there is a directory
5727 separator at the end of this string. */
5728 if (target_system_root)
5730 obstack_grow (&obstack, target_system_root,
5731 strlen (target_system_root));
5732 if (target_sysroot_suffix)
5733 obstack_grow (&obstack, target_sysroot_suffix,
5734 strlen (target_sysroot_suffix));
5736 break;
5738 case 'S':
5739 value = do_spec_1 (startfile_spec, 0, NULL);
5740 if (value != 0)
5741 return value;
5742 break;
5744 /* Here we define characters other than letters and digits. */
5746 case '{':
5747 p = handle_braces (p);
5748 if (p == 0)
5749 return -1;
5750 break;
5752 case ':':
5753 p = handle_spec_function (p);
5754 if (p == 0)
5755 return -1;
5756 break;
5758 case '%':
5759 obstack_1grow (&obstack, '%');
5760 break;
5762 case '.':
5764 unsigned len = 0;
5766 while (p[len] && p[len] != ' ' && p[len] != '%')
5767 len++;
5768 suffix_subst = save_string (p - 1, len + 1);
5769 p += len;
5771 break;
5773 /* Henceforth ignore the option(s) matching the pattern
5774 after the %<. */
5775 case '<':
5777 unsigned len = 0;
5778 int have_wildcard = 0;
5779 int i;
5781 while (p[len] && p[len] != ' ' && p[len] != '\t')
5782 len++;
5784 if (p[len-1] == '*')
5785 have_wildcard = 1;
5787 for (i = 0; i < n_switches; i++)
5788 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5789 && (have_wildcard || switches[i].part1[len] == '\0'))
5791 switches[i].live_cond |= SWITCH_IGNORE;
5792 switches[i].validated = 1;
5795 p += len;
5797 break;
5799 case '*':
5800 if (soft_matched_part)
5802 do_spec_1 (soft_matched_part, 1, NULL);
5803 do_spec_1 (" ", 0, NULL);
5805 else
5806 /* Catch the case where a spec string contains something like
5807 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5808 hand side of the :. */
5809 error ("spec failure: '%%*' has not been initialized by pattern match");
5810 break;
5812 /* Process a string found as the value of a spec given by name.
5813 This feature allows individual machine descriptions
5814 to add and use their own specs.
5815 %[...] modifies -D options the way %P does;
5816 %(...) uses the spec unmodified. */
5817 case '[':
5818 error ("warning: use of obsolete %%[ operator in specs");
5819 case '(':
5821 const char *name = p;
5822 struct spec_list *sl;
5823 int len;
5825 /* The string after the S/P is the name of a spec that is to be
5826 processed. */
5827 while (*p && *p != ')' && *p != ']')
5828 p++;
5830 /* See if it's in the list. */
5831 for (len = p - name, sl = specs; sl; sl = sl->next)
5832 if (sl->name_len == len && !strncmp (sl->name, name, len))
5834 name = *(sl->ptr_spec);
5835 #ifdef DEBUG_SPECS
5836 notice ("Processing spec %c%s%c, which is '%s'\n",
5837 c, sl->name, (c == '(') ? ')' : ']', name);
5838 #endif
5839 break;
5842 if (sl)
5844 if (c == '(')
5846 value = do_spec_1 (name, 0, NULL);
5847 if (value != 0)
5848 return value;
5850 else
5852 char *x = (char *) alloca (strlen (name) * 2 + 1);
5853 char *buf = x;
5854 const char *y = name;
5855 int flag = 0;
5857 /* Copy all of NAME into BUF, but put __ after
5858 every -D and at the end of each arg. */
5859 while (1)
5861 if (! strncmp (y, "-D", 2))
5863 *x++ = '-';
5864 *x++ = 'D';
5865 *x++ = '_';
5866 *x++ = '_';
5867 y += 2;
5868 flag = 1;
5869 continue;
5871 else if (flag
5872 && (*y == ' ' || *y == '\t' || *y == '='
5873 || *y == '}' || *y == 0))
5875 *x++ = '_';
5876 *x++ = '_';
5877 flag = 0;
5879 if (*y == 0)
5880 break;
5881 else
5882 *x++ = *y++;
5884 *x = 0;
5886 value = do_spec_1 (buf, 0, NULL);
5887 if (value != 0)
5888 return value;
5892 /* Discard the closing paren or bracket. */
5893 if (*p)
5894 p++;
5896 break;
5898 default:
5899 error ("spec failure: unrecognized spec option '%c'", c);
5900 break;
5902 break;
5904 case '\\':
5905 /* Backslash: treat next character as ordinary. */
5906 c = *p++;
5908 /* Fall through. */
5909 default:
5910 /* Ordinary character: put it into the current argument. */
5911 obstack_1grow (&obstack, c);
5912 arg_going = 1;
5915 /* End of string. If we are processing a spec function, we need to
5916 end any pending argument. */
5917 if (processing_spec_function)
5918 end_going_arg ();
5920 return 0;
5923 /* Look up a spec function. */
5925 static const struct spec_function *
5926 lookup_spec_function (const char *name)
5928 const struct spec_function *sf;
5930 for (sf = static_spec_functions; sf->name != NULL; sf++)
5931 if (strcmp (sf->name, name) == 0)
5932 return sf;
5934 return NULL;
5937 /* Evaluate a spec function. */
5939 static const char *
5940 eval_spec_function (const char *func, const char *args)
5942 const struct spec_function *sf;
5943 const char *funcval;
5945 /* Saved spec processing context. */
5946 int save_argbuf_index;
5947 int save_argbuf_length;
5948 const char **save_argbuf;
5950 int save_arg_going;
5951 int save_delete_this_arg;
5952 int save_this_is_output_file;
5953 int save_this_is_library_file;
5954 int save_input_from_pipe;
5955 int save_this_is_linker_script;
5956 const char *save_suffix_subst;
5959 sf = lookup_spec_function (func);
5960 if (sf == NULL)
5961 fatal ("unknown spec function '%s'", func);
5963 /* Push the spec processing context. */
5964 save_argbuf_index = argbuf_index;
5965 save_argbuf_length = argbuf_length;
5966 save_argbuf = argbuf;
5968 save_arg_going = arg_going;
5969 save_delete_this_arg = delete_this_arg;
5970 save_this_is_output_file = this_is_output_file;
5971 save_this_is_library_file = this_is_library_file;
5972 save_this_is_linker_script = this_is_linker_script;
5973 save_input_from_pipe = input_from_pipe;
5974 save_suffix_subst = suffix_subst;
5976 /* Create a new spec processing context, and build the function
5977 arguments. */
5979 alloc_args ();
5980 if (do_spec_2 (args) < 0)
5981 fatal ("error in args to spec function '%s'", func);
5983 /* argbuf_index is an index for the next argument to be inserted, and
5984 so contains the count of the args already inserted. */
5986 funcval = (*sf->func) (argbuf_index, argbuf);
5988 /* Pop the spec processing context. */
5989 argbuf_index = save_argbuf_index;
5990 argbuf_length = save_argbuf_length;
5991 free (argbuf);
5992 argbuf = save_argbuf;
5994 arg_going = save_arg_going;
5995 delete_this_arg = save_delete_this_arg;
5996 this_is_output_file = save_this_is_output_file;
5997 this_is_library_file = save_this_is_library_file;
5998 this_is_linker_script = save_this_is_linker_script;
5999 input_from_pipe = save_input_from_pipe;
6000 suffix_subst = save_suffix_subst;
6002 return funcval;
6005 /* Handle a spec function call of the form:
6007 %:function(args)
6009 ARGS is processed as a spec in a separate context and split into an
6010 argument vector in the normal fashion. The function returns a string
6011 containing a spec which we then process in the caller's context, or
6012 NULL if no processing is required. */
6014 static const char *
6015 handle_spec_function (const char *p)
6017 char *func, *args;
6018 const char *endp, *funcval;
6019 int count;
6021 processing_spec_function++;
6023 /* Get the function name. */
6024 for (endp = p; *endp != '\0'; endp++)
6026 if (*endp == '(') /* ) */
6027 break;
6028 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6029 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6030 fatal ("malformed spec function name");
6032 if (*endp != '(') /* ) */
6033 fatal ("no arguments for spec function");
6034 func = save_string (p, endp - p);
6035 p = ++endp;
6037 /* Get the arguments. */
6038 for (count = 0; *endp != '\0'; endp++)
6040 /* ( */
6041 if (*endp == ')')
6043 if (count == 0)
6044 break;
6045 count--;
6047 else if (*endp == '(') /* ) */
6048 count++;
6050 /* ( */
6051 if (*endp != ')')
6052 fatal ("malformed spec function arguments");
6053 args = save_string (p, endp - p);
6054 p = ++endp;
6056 /* p now points to just past the end of the spec function expression. */
6058 funcval = eval_spec_function (func, args);
6059 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6060 p = NULL;
6062 free (func);
6063 free (args);
6065 processing_spec_function--;
6067 return p;
6070 /* Inline subroutine of handle_braces. Returns true if the current
6071 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6072 static inline bool
6073 input_suffix_matches (const char *atom, const char *end_atom)
6075 return (input_suffix
6076 && !strncmp (input_suffix, atom, end_atom - atom)
6077 && input_suffix[end_atom - atom] == '\0');
6080 /* Subroutine of handle_braces. Returns true if the current
6081 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6082 static bool
6083 input_spec_matches (const char *atom, const char *end_atom)
6085 return (input_file_compiler
6086 && input_file_compiler->suffix
6087 && input_file_compiler->suffix[0] != '\0'
6088 && !strncmp (input_file_compiler->suffix + 1, atom,
6089 end_atom - atom)
6090 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6093 /* Subroutine of handle_braces. Returns true if a switch
6094 matching the atom bracketed by ATOM and END_ATOM appeared on the
6095 command line. */
6096 static bool
6097 switch_matches (const char *atom, const char *end_atom, int starred)
6099 int i;
6100 int len = end_atom - atom;
6101 int plen = starred ? len : -1;
6103 for (i = 0; i < n_switches; i++)
6104 if (!strncmp (switches[i].part1, atom, len)
6105 && (starred || switches[i].part1[len] == '\0')
6106 && check_live_switch (i, plen))
6107 return true;
6109 return false;
6112 /* Inline subroutine of handle_braces. Mark all of the switches which
6113 match ATOM (extends to END_ATOM; STARRED indicates whether there
6114 was a star after the atom) for later processing. */
6115 static inline void
6116 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6118 int i;
6119 int len = end_atom - atom;
6120 int plen = starred ? len : -1;
6122 for (i = 0; i < n_switches; i++)
6123 if (!strncmp (switches[i].part1, atom, len)
6124 && (starred || switches[i].part1[len] == '\0')
6125 && check_live_switch (i, plen))
6126 switches[i].ordering = 1;
6129 /* Inline subroutine of handle_braces. Process all the currently
6130 marked switches through give_switch, and clear the marks. */
6131 static inline void
6132 process_marked_switches (void)
6134 int i;
6136 for (i = 0; i < n_switches; i++)
6137 if (switches[i].ordering == 1)
6139 switches[i].ordering = 0;
6140 give_switch (i, 0);
6144 /* Handle a %{ ... } construct. P points just inside the leading {.
6145 Returns a pointer one past the end of the brace block, or 0
6146 if we call do_spec_1 and that returns -1. */
6148 static const char *
6149 handle_braces (const char *p)
6151 const char *atom, *end_atom;
6152 const char *d_atom = NULL, *d_end_atom = NULL;
6153 const char *orig = p;
6155 bool a_is_suffix;
6156 bool a_is_spectype;
6157 bool a_is_starred;
6158 bool a_is_negated;
6159 bool a_matched;
6161 bool a_must_be_last = false;
6162 bool ordered_set = false;
6163 bool disjunct_set = false;
6164 bool disj_matched = false;
6165 bool disj_starred = true;
6166 bool n_way_choice = false;
6167 bool n_way_matched = false;
6169 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6173 if (a_must_be_last)
6174 goto invalid;
6176 /* Scan one "atom" (S in the description above of %{}, possibly
6177 with '!', '.', '@', ',', or '*' modifiers). */
6178 a_matched = false;
6179 a_is_suffix = false;
6180 a_is_starred = false;
6181 a_is_negated = false;
6182 a_is_spectype = false;
6184 SKIP_WHITE();
6185 if (*p == '!')
6186 p++, a_is_negated = true;
6188 SKIP_WHITE();
6189 if (*p == '.')
6190 p++, a_is_suffix = true;
6191 else if (*p == ',')
6192 p++, a_is_spectype = true;
6194 atom = p;
6195 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6196 || *p == ',' || *p == '.' || *p == '@')
6197 p++;
6198 end_atom = p;
6200 if (*p == '*')
6201 p++, a_is_starred = 1;
6203 SKIP_WHITE();
6204 switch (*p)
6206 case '&': case '}':
6207 /* Substitute the switch(es) indicated by the current atom. */
6208 ordered_set = true;
6209 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6210 || a_is_spectype || atom == end_atom)
6211 goto invalid;
6213 mark_matching_switches (atom, end_atom, a_is_starred);
6215 if (*p == '}')
6216 process_marked_switches ();
6217 break;
6219 case '|': case ':':
6220 /* Substitute some text if the current atom appears as a switch
6221 or suffix. */
6222 disjunct_set = true;
6223 if (ordered_set)
6224 goto invalid;
6226 if (atom == end_atom)
6228 if (!n_way_choice || disj_matched || *p == '|'
6229 || a_is_negated || a_is_suffix || a_is_spectype
6230 || a_is_starred)
6231 goto invalid;
6233 /* An empty term may appear as the last choice of an
6234 N-way choice set; it means "otherwise". */
6235 a_must_be_last = true;
6236 disj_matched = !n_way_matched;
6237 disj_starred = false;
6239 else
6241 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6242 goto invalid;
6244 if (!a_is_starred)
6245 disj_starred = false;
6247 /* Don't bother testing this atom if we already have a
6248 match. */
6249 if (!disj_matched && !n_way_matched)
6251 if (a_is_suffix)
6252 a_matched = input_suffix_matches (atom, end_atom);
6253 else if (a_is_spectype)
6254 a_matched = input_spec_matches (atom, end_atom);
6255 else
6256 a_matched = switch_matches (atom, end_atom, a_is_starred);
6258 if (a_matched != a_is_negated)
6260 disj_matched = true;
6261 d_atom = atom;
6262 d_end_atom = end_atom;
6267 if (*p == ':')
6269 /* Found the body, that is, the text to substitute if the
6270 current disjunction matches. */
6271 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6272 disj_matched && !n_way_matched);
6273 if (p == 0)
6274 return 0;
6276 /* If we have an N-way choice, reset state for the next
6277 disjunction. */
6278 if (*p == ';')
6280 n_way_choice = true;
6281 n_way_matched |= disj_matched;
6282 disj_matched = false;
6283 disj_starred = true;
6284 d_atom = d_end_atom = NULL;
6287 break;
6289 default:
6290 goto invalid;
6293 while (*p++ != '}');
6295 return p;
6297 invalid:
6298 fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6300 #undef SKIP_WHITE
6303 /* Subroutine of handle_braces. Scan and process a brace substitution body
6304 (X in the description of %{} syntax). P points one past the colon;
6305 ATOM and END_ATOM bracket the first atom which was found to be true
6306 (present) in the current disjunction; STARRED indicates whether all
6307 the atoms in the current disjunction were starred (for syntax validation);
6308 MATCHED indicates whether the disjunction matched or not, and therefore
6309 whether or not the body is to be processed through do_spec_1 or just
6310 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6311 returns -1. */
6313 static const char *
6314 process_brace_body (const char *p, const char *atom, const char *end_atom,
6315 int starred, int matched)
6317 const char *body, *end_body;
6318 unsigned int nesting_level;
6319 bool have_subst = false;
6321 /* Locate the closing } or ;, honoring nested braces.
6322 Trim trailing whitespace. */
6323 body = p;
6324 nesting_level = 1;
6325 for (;;)
6327 if (*p == '{')
6328 nesting_level++;
6329 else if (*p == '}')
6331 if (!--nesting_level)
6332 break;
6334 else if (*p == ';' && nesting_level == 1)
6335 break;
6336 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6337 have_subst = true;
6338 else if (*p == '\0')
6339 goto invalid;
6340 p++;
6343 end_body = p;
6344 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6345 end_body--;
6347 if (have_subst && !starred)
6348 goto invalid;
6350 if (matched)
6352 /* Copy the substitution body to permanent storage and execute it.
6353 If have_subst is false, this is a simple matter of running the
6354 body through do_spec_1... */
6355 char *string = save_string (body, end_body - body);
6356 if (!have_subst)
6358 if (do_spec_1 (string, 0, NULL) < 0)
6359 return 0;
6361 else
6363 /* ... but if have_subst is true, we have to process the
6364 body once for each matching switch, with %* set to the
6365 variant part of the switch. */
6366 unsigned int hard_match_len = end_atom - atom;
6367 int i;
6369 for (i = 0; i < n_switches; i++)
6370 if (!strncmp (switches[i].part1, atom, hard_match_len)
6371 && check_live_switch (i, hard_match_len))
6373 if (do_spec_1 (string, 0,
6374 &switches[i].part1[hard_match_len]) < 0)
6375 return 0;
6376 /* Pass any arguments this switch has. */
6377 give_switch (i, 1);
6378 suffix_subst = NULL;
6383 return p;
6385 invalid:
6386 fatal ("braced spec body '%s' is invalid", body);
6389 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6390 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6391 spec, or -1 if either exact match or %* is used.
6393 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6394 whose value does not begin with "no-" is obsoleted by the same value
6395 with the "no-", similarly for a switch with the "no-" prefix. */
6397 static int
6398 check_live_switch (int switchnum, int prefix_length)
6400 const char *name = switches[switchnum].part1;
6401 int i;
6403 /* If we already processed this switch and determined if it was
6404 live or not, return our past determination. */
6405 if (switches[switchnum].live_cond != 0)
6406 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6407 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6408 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6409 == 0);
6411 /* In the common case of {<at-most-one-letter>*}, a negating
6412 switch would always match, so ignore that case. We will just
6413 send the conflicting switches to the compiler phase. */
6414 if (prefix_length >= 0 && prefix_length <= 1)
6415 return 1;
6417 /* Now search for duplicate in a manner that depends on the name. */
6418 switch (*name)
6420 case 'O':
6421 for (i = switchnum + 1; i < n_switches; i++)
6422 if (switches[i].part1[0] == 'O')
6424 switches[switchnum].validated = 1;
6425 switches[switchnum].live_cond = SWITCH_FALSE;
6426 return 0;
6428 break;
6430 case 'W': case 'f': case 'm':
6431 if (! strncmp (name + 1, "no-", 3))
6433 /* We have Xno-YYY, search for XYYY. */
6434 for (i = switchnum + 1; i < n_switches; i++)
6435 if (switches[i].part1[0] == name[0]
6436 && ! strcmp (&switches[i].part1[1], &name[4]))
6438 switches[switchnum].validated = 1;
6439 switches[switchnum].live_cond = SWITCH_FALSE;
6440 return 0;
6443 else
6445 /* We have XYYY, search for Xno-YYY. */
6446 for (i = switchnum + 1; i < n_switches; i++)
6447 if (switches[i].part1[0] == name[0]
6448 && switches[i].part1[1] == 'n'
6449 && switches[i].part1[2] == 'o'
6450 && switches[i].part1[3] == '-'
6451 && !strcmp (&switches[i].part1[4], &name[1]))
6453 switches[switchnum].validated = 1;
6454 switches[switchnum].live_cond = SWITCH_FALSE;
6455 return 0;
6458 break;
6461 /* Otherwise the switch is live. */
6462 switches[switchnum].live_cond |= SWITCH_LIVE;
6463 return 1;
6466 /* Pass a switch to the current accumulating command
6467 in the same form that we received it.
6468 SWITCHNUM identifies the switch; it is an index into
6469 the vector of switches gcc received, which is `switches'.
6470 This cannot fail since it never finishes a command line.
6472 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6474 static void
6475 give_switch (int switchnum, int omit_first_word)
6477 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6478 return;
6480 if (!omit_first_word)
6482 do_spec_1 ("-", 0, NULL);
6483 do_spec_1 (switches[switchnum].part1, 1, NULL);
6486 if (switches[switchnum].args != 0)
6488 const char **p;
6489 for (p = switches[switchnum].args; *p; p++)
6491 const char *arg = *p;
6493 do_spec_1 (" ", 0, NULL);
6494 if (suffix_subst)
6496 unsigned length = strlen (arg);
6497 int dot = 0;
6499 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6500 if (arg[length] == '.')
6502 (CONST_CAST(char *, arg))[length] = 0;
6503 dot = 1;
6504 break;
6506 do_spec_1 (arg, 1, NULL);
6507 if (dot)
6508 (CONST_CAST(char *, arg))[length] = '.';
6509 do_spec_1 (suffix_subst, 1, NULL);
6511 else
6512 do_spec_1 (arg, 1, NULL);
6516 do_spec_1 (" ", 0, NULL);
6517 switches[switchnum].validated = 1;
6520 /* Search for a file named NAME trying various prefixes including the
6521 user's -B prefix and some standard ones.
6522 Return the absolute file name found. If nothing is found, return NAME. */
6524 static const char *
6525 find_file (const char *name)
6527 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6528 return newname ? newname : name;
6531 /* Determine whether a directory exists. If LINKER, return 0 for
6532 certain fixed names not needed by the linker. */
6534 static int
6535 is_directory (const char *path1, bool linker)
6537 int len1;
6538 char *path;
6539 char *cp;
6540 struct stat st;
6542 /* Ensure the string ends with "/.". The resulting path will be a
6543 directory even if the given path is a symbolic link. */
6544 len1 = strlen (path1);
6545 path = (char *) alloca (3 + len1);
6546 memcpy (path, path1, len1);
6547 cp = path + len1;
6548 if (!IS_DIR_SEPARATOR (cp[-1]))
6549 *cp++ = DIR_SEPARATOR;
6550 *cp++ = '.';
6551 *cp = '\0';
6553 /* Exclude directories that the linker is known to search. */
6554 if (linker
6555 && IS_DIR_SEPARATOR (path[0])
6556 && ((cp - path == 6
6557 && strncmp (path + 1, "lib", 3) == 0)
6558 || (cp - path == 10
6559 && strncmp (path + 1, "usr", 3) == 0
6560 && IS_DIR_SEPARATOR (path[4])
6561 && strncmp (path + 5, "lib", 3) == 0)))
6562 return 0;
6564 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6567 /* Set up the various global variables to indicate that we're processing
6568 the input file named FILENAME. */
6570 void
6571 set_input (const char *filename)
6573 const char *p;
6575 input_filename = filename;
6576 input_filename_length = strlen (input_filename);
6577 input_basename = lbasename (input_filename);
6579 /* Find a suffix starting with the last period,
6580 and set basename_length to exclude that suffix. */
6581 basename_length = strlen (input_basename);
6582 suffixed_basename_length = basename_length;
6583 p = input_basename + basename_length;
6584 while (p != input_basename && *p != '.')
6585 --p;
6586 if (*p == '.' && p != input_basename)
6588 basename_length = p - input_basename;
6589 input_suffix = p + 1;
6591 else
6592 input_suffix = "";
6594 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6595 we will need to do a stat on the input_filename. The
6596 INPUT_STAT_SET signals that the stat is needed. */
6597 input_stat_set = 0;
6600 /* On fatal signals, delete all the temporary files. */
6602 static void
6603 fatal_error (int signum)
6605 signal (signum, SIG_DFL);
6606 delete_failure_queue ();
6607 delete_temp_files ();
6608 /* Get the same signal again, this time not handled,
6609 so its normal effect occurs. */
6610 kill (getpid (), signum);
6613 /* Compare the contents of the two files named CMPFILE[0] and
6614 CMPFILE[1]. Return zero if they're identical, nonzero
6615 otherwise. */
6617 static int
6618 compare_files (char *cmpfile[])
6620 int ret = 0;
6621 FILE *temp[2] = { NULL, NULL };
6622 int i;
6624 #if HAVE_MMAP_FILE
6626 size_t length[2];
6627 void *map[2] = { NULL, NULL };
6629 for (i = 0; i < 2; i++)
6631 struct stat st;
6633 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6635 error ("%s: could not determine length of compare-debug file %s",
6636 input_filename, cmpfile[i]);
6637 ret = 1;
6638 break;
6641 length[i] = st.st_size;
6644 if (!ret && length[0] != length[1])
6646 error ("%s: -fcompare-debug failure (length)", input_filename);
6647 ret = 1;
6650 if (!ret)
6651 for (i = 0; i < 2; i++)
6653 int fd = open (cmpfile[i], O_RDONLY);
6654 if (fd < 0)
6656 error ("%s: could not open compare-debug file %s",
6657 input_filename, cmpfile[i]);
6658 ret = 1;
6659 break;
6662 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6663 close (fd);
6665 if (map[i] == (void *) MAP_FAILED)
6667 ret = -1;
6668 break;
6672 if (!ret)
6674 if (memcmp (map[0], map[1], length[0]) != 0)
6676 error ("%s: -fcompare-debug failure", input_filename);
6677 ret = 1;
6681 for (i = 0; i < 2; i++)
6682 if (map[i])
6683 munmap ((caddr_t) map[i], length[i]);
6685 if (ret >= 0)
6686 return ret;
6688 ret = 0;
6690 #endif
6692 for (i = 0; i < 2; i++)
6694 temp[i] = fopen (cmpfile[i], "r");
6695 if (!temp[i])
6697 error ("%s: could not open compare-debug file %s",
6698 input_filename, cmpfile[i]);
6699 ret = 1;
6700 break;
6704 if (!ret && temp[0] && temp[1])
6705 for (;;)
6707 int c0, c1;
6708 c0 = fgetc (temp[0]);
6709 c1 = fgetc (temp[1]);
6711 if (c0 != c1)
6713 error ("%s: -fcompare-debug failure",
6714 input_filename);
6715 ret = 1;
6716 break;
6719 if (c0 == EOF)
6720 break;
6723 for (i = 1; i >= 0; i--)
6725 if (temp[i])
6726 fclose (temp[i]);
6729 return ret;
6732 extern int main (int, char **);
6735 main (int argc, char **argv)
6737 size_t i;
6738 int value;
6739 int linker_was_run = 0;
6740 int lang_n_infiles = 0;
6741 int num_linker_inputs = 0;
6742 char *explicit_link_files;
6743 char *specs_file;
6744 const char *p;
6745 struct user_specs *uptr;
6746 char **old_argv = argv;
6748 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6749 on ?: in file-scope variable initializations. */
6750 asm_debug = ASM_DEBUG_SPEC;
6752 p = argv[0] + strlen (argv[0]);
6753 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6754 --p;
6755 programname = p;
6757 xmalloc_set_program_name (programname);
6759 expandargv (&argc, &argv);
6761 /* Determine if any expansions were made. */
6762 if (argv != old_argv)
6763 at_file_supplied = true;
6765 prune_options (&argc, &argv);
6767 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6768 /* Perform host dependent initialization when needed. */
6769 GCC_DRIVER_HOST_INITIALIZATION;
6770 #endif
6772 /* Unlock the stdio streams. */
6773 unlock_std_streams ();
6775 gcc_init_libintl ();
6777 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6778 signal (SIGINT, fatal_error);
6779 #ifdef SIGHUP
6780 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6781 signal (SIGHUP, fatal_error);
6782 #endif
6783 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6784 signal (SIGTERM, fatal_error);
6785 #ifdef SIGPIPE
6786 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6787 signal (SIGPIPE, fatal_error);
6788 #endif
6789 #ifdef SIGCHLD
6790 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6791 receive the signal. A different setting is inheritable */
6792 signal (SIGCHLD, SIG_DFL);
6793 #endif
6795 /* Allocate the argument vector. */
6796 alloc_args ();
6798 obstack_init (&obstack);
6800 /* Build multilib_select, et. al from the separate lines that make up each
6801 multilib selection. */
6803 const char *const *q = multilib_raw;
6804 int need_space;
6806 obstack_init (&multilib_obstack);
6807 while ((p = *q++) != (char *) 0)
6808 obstack_grow (&multilib_obstack, p, strlen (p));
6810 obstack_1grow (&multilib_obstack, 0);
6811 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6813 q = multilib_matches_raw;
6814 while ((p = *q++) != (char *) 0)
6815 obstack_grow (&multilib_obstack, p, strlen (p));
6817 obstack_1grow (&multilib_obstack, 0);
6818 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6820 q = multilib_exclusions_raw;
6821 while ((p = *q++) != (char *) 0)
6822 obstack_grow (&multilib_obstack, p, strlen (p));
6824 obstack_1grow (&multilib_obstack, 0);
6825 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6827 need_space = FALSE;
6828 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6830 if (need_space)
6831 obstack_1grow (&multilib_obstack, ' ');
6832 obstack_grow (&multilib_obstack,
6833 multilib_defaults_raw[i],
6834 strlen (multilib_defaults_raw[i]));
6835 need_space = TRUE;
6838 obstack_1grow (&multilib_obstack, 0);
6839 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6842 #ifdef INIT_ENVIRONMENT
6843 /* Set up any other necessary machine specific environment variables. */
6844 xputenv (INIT_ENVIRONMENT);
6845 #endif
6847 /* Make a table of what switches there are (switches, n_switches).
6848 Make a table of specified input files (infiles, n_infiles).
6849 Decode switches that are handled locally. */
6851 process_command (argc, CONST_CAST2 (const char **, char **, argv));
6853 /* Initialize the vector of specs to just the default.
6854 This means one element containing 0s, as a terminator. */
6856 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6857 memcpy (compilers, default_compilers, sizeof default_compilers);
6858 n_compilers = n_default_compilers;
6860 /* Read specs from a file if there is one. */
6862 machine_suffix = concat (spec_machine, dir_separator_str,
6863 spec_version, dir_separator_str, NULL);
6864 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6866 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6867 /* Read the specs file unless it is a default one. */
6868 if (specs_file != 0 && strcmp (specs_file, "specs"))
6869 read_specs (specs_file, TRUE);
6870 else
6871 init_spec ();
6873 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6874 for any override of as, ld and libraries. */
6875 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6876 + strlen (just_machine_suffix) + sizeof ("specs"));
6878 strcpy (specs_file, standard_exec_prefix);
6879 strcat (specs_file, just_machine_suffix);
6880 strcat (specs_file, "specs");
6881 if (access (specs_file, R_OK) == 0)
6882 read_specs (specs_file, TRUE);
6884 /* Process any configure-time defaults specified for the command line
6885 options, via OPTION_DEFAULT_SPECS. */
6886 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6887 do_option_spec (option_default_specs[i].name,
6888 option_default_specs[i].spec);
6890 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6891 of the command line. */
6893 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6894 do_self_spec (driver_self_specs[i]);
6896 if (compare_debug)
6898 enum save_temps save;
6900 if (!compare_debug_second)
6902 n_switches_debug_check[1] = n_switches;
6903 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6904 n_switches + 1);
6906 do_self_spec ("%:compare-debug-self-opt()");
6907 n_switches_debug_check[0] = n_switches;
6908 switches_debug_check[0] = switches;
6910 n_switches = n_switches_debug_check[1];
6911 switches = switches_debug_check[1];
6914 /* Avoid crash when computing %j in this early. */
6915 save = save_temps_flag;
6916 save_temps_flag = SAVE_TEMPS_NONE;
6918 compare_debug = -compare_debug;
6919 do_self_spec ("%:compare-debug-self-opt()");
6921 save_temps_flag = save;
6923 if (!compare_debug_second)
6925 n_switches_debug_check[1] = n_switches;
6926 switches_debug_check[1] = switches;
6927 compare_debug = -compare_debug;
6928 n_switches = n_switches_debug_check[0];
6929 switches = switches_debug_check[0];
6933 /* If not cross-compiling, look for executables in the standard
6934 places. */
6935 if (*cross_compile == '0')
6937 if (*md_exec_prefix)
6939 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6940 PREFIX_PRIORITY_LAST, 0, 0);
6944 /* Process sysroot_suffix_spec. */
6945 if (*sysroot_suffix_spec != 0
6946 && do_spec_2 (sysroot_suffix_spec) == 0)
6948 if (argbuf_index > 1)
6949 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6950 else if (argbuf_index == 1)
6951 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6954 #ifdef HAVE_LD_SYSROOT
6955 /* Pass the --sysroot option to the linker, if it supports that. If
6956 there is a sysroot_suffix_spec, it has already been processed by
6957 this point, so target_system_root really is the system root we
6958 should be using. */
6959 if (target_system_root)
6961 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6962 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6963 set_spec ("link", XOBFINISH (&obstack, const char *));
6965 #endif
6967 /* Process sysroot_hdrs_suffix_spec. */
6968 if (*sysroot_hdrs_suffix_spec != 0
6969 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6971 if (argbuf_index > 1)
6972 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6973 else if (argbuf_index == 1)
6974 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6977 /* Look for startfiles in the standard places. */
6978 if (*startfile_prefix_spec != 0
6979 && do_spec_2 (startfile_prefix_spec) == 0
6980 && do_spec_1 (" ", 0, NULL) == 0)
6982 int ndx;
6983 for (ndx = 0; ndx < argbuf_index; ndx++)
6984 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6985 PREFIX_PRIORITY_LAST, 0, 1);
6987 /* We should eventually get rid of all these and stick to
6988 startfile_prefix_spec exclusively. */
6989 else if (*cross_compile == '0' || target_system_root)
6991 if (*md_startfile_prefix)
6992 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6993 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6995 if (*md_startfile_prefix_1)
6996 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6997 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6999 /* If standard_startfile_prefix is relative, base it on
7000 standard_exec_prefix. This lets us move the installed tree
7001 as a unit. If GCC_EXEC_PREFIX is defined, base
7002 standard_startfile_prefix on that as well.
7004 If the prefix is relative, only search it for native compilers;
7005 otherwise we will search a directory containing host libraries. */
7006 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7007 add_sysrooted_prefix (&startfile_prefixes,
7008 standard_startfile_prefix, "BINUTILS",
7009 PREFIX_PRIORITY_LAST, 0, 1);
7010 else if (*cross_compile == '0')
7012 add_prefix (&startfile_prefixes,
7013 concat (gcc_exec_prefix
7014 ? gcc_exec_prefix : standard_exec_prefix,
7015 machine_suffix,
7016 standard_startfile_prefix, NULL),
7017 NULL, PREFIX_PRIORITY_LAST, 0, 1);
7020 /* Sysrooted prefixes are relocated because target_system_root is
7021 also relocated by gcc_exec_prefix. */
7022 if (*standard_startfile_prefix_1)
7023 add_sysrooted_prefix (&startfile_prefixes,
7024 standard_startfile_prefix_1, "BINUTILS",
7025 PREFIX_PRIORITY_LAST, 0, 1);
7026 if (*standard_startfile_prefix_2)
7027 add_sysrooted_prefix (&startfile_prefixes,
7028 standard_startfile_prefix_2, "BINUTILS",
7029 PREFIX_PRIORITY_LAST, 0, 1);
7032 /* Process any user specified specs in the order given on the command
7033 line. */
7034 for (uptr = user_specs_head; uptr; uptr = uptr->next)
7036 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7037 R_OK, true);
7038 read_specs (filename ? filename : uptr->filename, FALSE);
7041 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7042 if (gcc_exec_prefix)
7043 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7044 spec_version, dir_separator_str, NULL);
7046 /* Now we have the specs.
7047 Set the `valid' bits for switches that match anything in any spec. */
7049 validate_all_switches ();
7051 /* Now that we have the switches and the specs, set
7052 the subdirectory based on the options. */
7053 set_multilib_dir ();
7055 /* Set up to remember the pathname of gcc and any options
7056 needed for collect. We use argv[0] instead of programname because
7057 we need the complete pathname. */
7058 obstack_init (&collect_obstack);
7059 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7060 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7061 xputenv (XOBFINISH (&collect_obstack, char *));
7063 /* Set up to remember the pathname of the lto wrapper. */
7065 lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7066 if (lto_wrapper_spec)
7068 obstack_init (&collect_obstack);
7069 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7070 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7071 obstack_grow (&collect_obstack, lto_wrapper_spec,
7072 strlen (lto_wrapper_spec) + 1);
7073 xputenv (XOBFINISH (&collect_obstack, char *));
7076 /* Warn about any switches that no pass was interested in. */
7078 for (i = 0; (int) i < n_switches; i++)
7079 if (! switches[i].validated)
7080 error ("unrecognized option '-%s'", switches[i].part1);
7082 /* Obey some of the options. */
7084 if (print_search_dirs)
7086 printf (_("install: %s%s\n"),
7087 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7088 gcc_exec_prefix ? "" : machine_suffix);
7089 printf (_("programs: %s\n"),
7090 build_search_list (&exec_prefixes, "", false, false));
7091 printf (_("libraries: %s\n"),
7092 build_search_list (&startfile_prefixes, "", false, true));
7093 return (0);
7096 if (print_file_name)
7098 printf ("%s\n", find_file (print_file_name));
7099 return (0);
7102 if (print_prog_name)
7104 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7105 printf ("%s\n", (newname ? newname : print_prog_name));
7106 return (0);
7109 if (print_multi_lib)
7111 print_multilib_info ();
7112 return (0);
7115 if (print_multi_directory)
7117 if (multilib_dir == NULL)
7118 printf (".\n");
7119 else
7120 printf ("%s\n", multilib_dir);
7121 return (0);
7124 if (print_sysroot)
7126 if (target_system_root)
7128 if (target_sysroot_suffix)
7129 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7130 else
7131 printf ("%s\n", target_system_root);
7133 return (0);
7136 if (print_multi_os_directory)
7138 if (multilib_os_dir == NULL)
7139 printf (".\n");
7140 else
7141 printf ("%s\n", multilib_os_dir);
7142 return (0);
7145 if (print_sysroot_headers_suffix)
7147 if (*sysroot_hdrs_suffix_spec)
7149 printf("%s\n", (target_sysroot_hdrs_suffix
7150 ? target_sysroot_hdrs_suffix
7151 : ""));
7152 return (0);
7154 else
7155 /* The error status indicates that only one set of fixed
7156 headers should be built. */
7157 fatal ("not configured with sysroot headers suffix");
7160 if (print_help_list)
7162 display_help ();
7164 if (! verbose_flag)
7166 printf (_("\nFor bug reporting instructions, please see:\n"));
7167 printf ("%s.\n", bug_report_url);
7169 return (0);
7172 /* We do not exit here. Instead we have created a fake input file
7173 called 'help-dummy' which needs to be compiled, and we pass this
7174 on the various sub-processes, along with the --help switch.
7175 Ensure their output appears after ours. */
7176 fputc ('\n', stdout);
7177 fflush (stdout);
7180 if (print_version)
7182 printf (_("%s %s%s\n"), programname, pkgversion_string,
7183 version_string);
7184 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7185 _("(C)"));
7186 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7187 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7188 stdout);
7189 if (! verbose_flag)
7190 return 0;
7192 /* We do not exit here. We use the same mechanism of --help to print
7193 the version of the sub-processes. */
7194 fputc ('\n', stdout);
7195 fflush (stdout);
7198 if (verbose_flag)
7200 int n;
7201 const char *thrmod;
7203 notice ("Target: %s\n", spec_machine);
7204 notice ("Configured with: %s\n", configuration_arguments);
7206 #ifdef THREAD_MODEL_SPEC
7207 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7208 but there's no point in doing all this processing just to get
7209 thread_model back. */
7210 obstack_init (&obstack);
7211 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7212 obstack_1grow (&obstack, '\0');
7213 thrmod = XOBFINISH (&obstack, const char *);
7214 #else
7215 thrmod = thread_model;
7216 #endif
7218 notice ("Thread model: %s\n", thrmod);
7220 /* compiler_version is truncated at the first space when initialized
7221 from version string, so truncate version_string at the first space
7222 before comparing. */
7223 for (n = 0; version_string[n]; n++)
7224 if (version_string[n] == ' ')
7225 break;
7227 if (! strncmp (version_string, compiler_version, n)
7228 && compiler_version[n] == 0)
7229 notice ("gcc version %s %s\n", version_string, pkgversion_string);
7230 else
7231 notice ("gcc driver version %s %sexecuting gcc version %s\n",
7232 version_string, pkgversion_string, compiler_version);
7234 if (n_infiles == 0)
7235 return (0);
7238 if (n_infiles == added_libraries)
7239 fatal ("no input files");
7241 /* Make a place to record the compiler output file names
7242 that correspond to the input files. */
7244 i = n_infiles;
7245 i += lang_specific_extra_outfiles;
7246 outfiles = XCNEWVEC (const char *, i);
7248 /* Record which files were specified explicitly as link input. */
7250 explicit_link_files = XCNEWVEC (char, n_infiles);
7252 if (combine_flag)
7253 combine_inputs = true;
7254 else
7255 combine_inputs = false;
7257 for (i = 0; (int) i < n_infiles; i++)
7259 const char *name = infiles[i].name;
7260 struct compiler *compiler = lookup_compiler (name,
7261 strlen (name),
7262 infiles[i].language);
7264 if (compiler && !(compiler->combinable))
7265 combine_inputs = false;
7267 if (lang_n_infiles > 0 && compiler != input_file_compiler
7268 && infiles[i].language && infiles[i].language[0] != '*')
7269 infiles[i].incompiler = compiler;
7270 else if (compiler)
7272 lang_n_infiles++;
7273 input_file_compiler = compiler;
7274 infiles[i].incompiler = compiler;
7276 else
7278 /* Since there is no compiler for this input file, assume it is a
7279 linker file. */
7280 explicit_link_files[i] = 1;
7281 infiles[i].incompiler = NULL;
7283 infiles[i].compiled = false;
7284 infiles[i].preprocessed = false;
7287 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7288 fatal ("cannot specify -o with -c, -S or -E with multiple files");
7290 if (combine_flag && save_temps_flag)
7292 bool save_combine_inputs = combine_inputs;
7293 /* Must do a separate pre-processing pass for C & Objective-C files, to
7294 obtain individual .i files. */
7296 combine_inputs = false;
7297 for (i = 0; (int) i < n_infiles; i++)
7299 int this_file_error = 0;
7301 input_file_number = i;
7302 set_input (infiles[i].name);
7303 if (infiles[i].incompiler
7304 && (infiles[i].incompiler)->needs_preprocessing)
7305 input_file_compiler = infiles[i].incompiler;
7306 else
7307 continue;
7309 if (input_file_compiler)
7311 if (input_file_compiler->spec[0] == '#')
7313 error ("%s: %s compiler not installed on this system",
7314 input_filename, &input_file_compiler->spec[1]);
7315 this_file_error = 1;
7317 else
7319 value = do_spec (input_file_compiler->spec);
7320 infiles[i].preprocessed = true;
7321 if (!have_o_argbuf_index)
7322 fatal ("spec '%s' is invalid", input_file_compiler->spec);
7323 infiles[i].name = argbuf[have_o_argbuf_index];
7324 infiles[i].incompiler
7325 = lookup_compiler (infiles[i].name,
7326 strlen (infiles[i].name),
7327 infiles[i].language);
7329 if (value < 0)
7330 this_file_error = 1;
7334 if (this_file_error)
7336 delete_failure_queue ();
7337 error_count++;
7338 break;
7340 clear_failure_queue ();
7342 combine_inputs = save_combine_inputs;
7345 for (i = 0; (int) i < n_infiles; i++)
7347 int this_file_error = 0;
7349 /* Tell do_spec what to substitute for %i. */
7351 input_file_number = i;
7352 set_input (infiles[i].name);
7354 if (infiles[i].compiled)
7355 continue;
7357 /* Use the same thing in %o, unless cp->spec says otherwise. */
7359 outfiles[i] = input_filename;
7361 /* Figure out which compiler from the file's suffix. */
7363 if (! combine_inputs)
7364 input_file_compiler
7365 = lookup_compiler (infiles[i].name, input_filename_length,
7366 infiles[i].language);
7367 else
7368 input_file_compiler = infiles[i].incompiler;
7370 if (input_file_compiler)
7372 /* Ok, we found an applicable compiler. Run its spec. */
7374 if (input_file_compiler->spec[0] == '#')
7376 error ("%s: %s compiler not installed on this system",
7377 input_filename, &input_file_compiler->spec[1]);
7378 this_file_error = 1;
7380 else
7382 if (compare_debug)
7384 if (debug_check_temp_file[0])
7385 free (debug_check_temp_file[0]);
7386 debug_check_temp_file[0] = NULL;
7388 if (debug_check_temp_file[1])
7389 free (debug_check_temp_file[1]);
7390 debug_check_temp_file[1] = NULL;
7393 value = do_spec (input_file_compiler->spec);
7394 infiles[i].compiled = true;
7395 if (value < 0)
7396 this_file_error = 1;
7397 else if (compare_debug && debug_check_temp_file[0])
7399 if (verbose_flag)
7400 error ("Recompiling with -fcompare-debug");
7402 compare_debug = -compare_debug;
7403 n_switches = n_switches_debug_check[1];
7404 switches = switches_debug_check[1];
7406 value = do_spec (input_file_compiler->spec);
7408 compare_debug = -compare_debug;
7409 n_switches = n_switches_debug_check[0];
7410 switches = switches_debug_check[0];
7412 if (value < 0)
7414 error ("during -fcompare-debug recompilation");
7415 this_file_error = 1;
7418 gcc_assert (debug_check_temp_file[1]
7419 && strcmp (debug_check_temp_file[0],
7420 debug_check_temp_file[1]));
7422 if (verbose_flag)
7423 error ("Comparing final insns dumps");
7425 if (compare_files (debug_check_temp_file))
7426 this_file_error = 1;
7429 if (compare_debug)
7431 if (debug_check_temp_file[0])
7432 free (debug_check_temp_file[0]);
7433 debug_check_temp_file[0] = NULL;
7435 if (debug_check_temp_file[1])
7436 free (debug_check_temp_file[1]);
7437 debug_check_temp_file[1] = NULL;
7442 /* If this file's name does not contain a recognized suffix,
7443 record it as explicit linker input. */
7445 else
7446 explicit_link_files[i] = 1;
7448 /* Clear the delete-on-failure queue, deleting the files in it
7449 if this compilation failed. */
7451 if (this_file_error)
7453 delete_failure_queue ();
7454 error_count++;
7456 /* If this compilation succeeded, don't delete those files later. */
7457 clear_failure_queue ();
7460 /* Reset the input file name to the first compile/object file name, for use
7461 with %b in LINK_SPEC. We use the first input file that we can find
7462 a compiler to compile it instead of using infiles.language since for
7463 languages other than C we use aliases that we then lookup later. */
7464 if (n_infiles > 0)
7466 int i;
7468 for (i = 0; i < n_infiles ; i++)
7469 if (infiles[i].language && infiles[i].language[0] != '*')
7471 set_input (infiles[i].name);
7472 break;
7476 if (error_count == 0)
7478 /* Make sure INPUT_FILE_NUMBER points to first available open
7479 slot. */
7480 input_file_number = n_infiles;
7481 if (lang_specific_pre_link ())
7482 error_count++;
7485 /* Determine if there are any linker input files. */
7486 num_linker_inputs = 0;
7487 for (i = 0; (int) i < n_infiles; i++)
7488 if (explicit_link_files[i] || outfiles[i] != NULL)
7489 num_linker_inputs++;
7491 /* Run ld to link all the compiler output files. */
7493 if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7495 int tmp = execution_count;
7496 const char *fuse_linker_plugin = "fuse-linker-plugin";
7498 /* We'll use ld if we can't find collect2. */
7499 if (! strcmp (linker_name_spec, "collect2"))
7501 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7502 if (s == NULL)
7503 linker_name_spec = "ld";
7506 if (switch_matches (fuse_linker_plugin,
7507 fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7509 linker_plugin_file_spec = find_a_file (&exec_prefixes,
7510 "liblto_plugin.so", R_OK,
7511 false);
7512 if (!linker_plugin_file_spec)
7513 fatal ("-fuse-linker-plugin, but liblto_plugin.so not found");
7515 lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7516 R_OK, true);
7517 if (!lto_libgcc_spec)
7518 fatal ("could not find libgcc.a");
7520 lto_gcc_spec = argv[0];
7522 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7523 for collect. */
7524 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7525 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7527 if (print_subprocess_help == 1)
7529 printf (_("\nLinker options\n==============\n\n"));
7530 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7531 " to the linker.\n\n"));
7532 fflush (stdout);
7534 value = do_spec (link_command_spec);
7535 if (value < 0)
7536 error_count = 1;
7537 linker_was_run = (tmp != execution_count);
7540 /* If options said don't run linker,
7541 complain about input files to be given to the linker. */
7543 if (! linker_was_run && error_count == 0)
7544 for (i = 0; (int) i < n_infiles; i++)
7545 if (explicit_link_files[i]
7546 && !(infiles[i].language && infiles[i].language[0] == '*'))
7547 error ("%s: linker input file unused because linking not done",
7548 outfiles[i]);
7550 /* Delete some or all of the temporary files we made. */
7552 if (error_count)
7553 delete_failure_queue ();
7554 delete_temp_files ();
7556 if (print_help_list)
7558 printf (("\nFor bug reporting instructions, please see:\n"));
7559 printf ("%s\n", bug_report_url);
7562 return (signal_count != 0 ? 2
7563 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7564 : 0);
7567 /* Find the proper compilation spec for the file name NAME,
7568 whose length is LENGTH. LANGUAGE is the specified language,
7569 or 0 if this file is to be passed to the linker. */
7571 static struct compiler *
7572 lookup_compiler (const char *name, size_t length, const char *language)
7574 struct compiler *cp;
7576 /* If this was specified by the user to be a linker input, indicate that. */
7577 if (language != 0 && language[0] == '*')
7578 return 0;
7580 /* Otherwise, look for the language, if one is spec'd. */
7581 if (language != 0)
7583 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7584 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7585 return cp;
7587 error ("language %s not recognized", language);
7588 return 0;
7591 /* Look for a suffix. */
7592 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7594 if (/* The suffix `-' matches only the file name `-'. */
7595 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7596 || (strlen (cp->suffix) < length
7597 /* See if the suffix matches the end of NAME. */
7598 && !strcmp (cp->suffix,
7599 name + length - strlen (cp->suffix))
7601 break;
7604 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7605 /* Look again, but case-insensitively this time. */
7606 if (cp < compilers)
7607 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7609 if (/* The suffix `-' matches only the file name `-'. */
7610 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7611 || (strlen (cp->suffix) < length
7612 /* See if the suffix matches the end of NAME. */
7613 && ((!strcmp (cp->suffix,
7614 name + length - strlen (cp->suffix))
7615 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7616 && !strcasecmp (cp->suffix,
7617 name + length - strlen (cp->suffix)))
7619 break;
7621 #endif
7623 if (cp >= compilers)
7625 if (cp->spec[0] != '@')
7626 /* A non-alias entry: return it. */
7627 return cp;
7629 /* An alias entry maps a suffix to a language.
7630 Search for the language; pass 0 for NAME and LENGTH
7631 to avoid infinite recursion if language not found. */
7632 return lookup_compiler (NULL, 0, cp->spec + 1);
7634 return 0;
7637 static char *
7638 save_string (const char *s, int len)
7640 char *result = XNEWVEC (char, len + 1);
7642 memcpy (result, s, len);
7643 result[len] = 0;
7644 return result;
7647 void
7648 pfatal_with_name (const char *name)
7650 perror_with_name (name);
7651 delete_temp_files ();
7652 exit (1);
7655 static void
7656 perror_with_name (const char *name)
7658 error ("%s: %s", name, xstrerror (errno));
7661 /* Output an error message and exit. */
7663 void
7664 fancy_abort (const char *file, int line, const char *func)
7666 fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7669 /* Output an error message and exit. */
7671 void
7672 fatal_ice (const char *cmsgid, ...)
7674 va_list ap;
7676 va_start (ap, cmsgid);
7678 fprintf (stderr, "%s: ", programname);
7679 vfprintf (stderr, _(cmsgid), ap);
7680 va_end (ap);
7681 fprintf (stderr, "\n");
7682 delete_temp_files ();
7683 exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7686 void
7687 fatal (const char *cmsgid, ...)
7689 va_list ap;
7691 va_start (ap, cmsgid);
7693 fprintf (stderr, "%s: ", programname);
7694 vfprintf (stderr, _(cmsgid), ap);
7695 va_end (ap);
7696 fprintf (stderr, "\n");
7697 delete_temp_files ();
7698 exit (1);
7701 /* The argument is actually c-format, not gcc-internal-format,
7702 but because functions with identical names are used through
7703 the rest of the compiler with gcc-internal-format, we just
7704 need to hope all users of these functions use the common
7705 subset between c-format and gcc-internal-format. */
7707 void
7708 error (const char *gmsgid, ...)
7710 va_list ap;
7712 va_start (ap, gmsgid);
7713 fprintf (stderr, "%s: ", programname);
7714 vfprintf (stderr, _(gmsgid), ap);
7715 va_end (ap);
7717 fprintf (stderr, "\n");
7720 static void
7721 notice (const char *cmsgid, ...)
7723 va_list ap;
7725 va_start (ap, cmsgid);
7726 vfprintf (stderr, _(cmsgid), ap);
7727 va_end (ap);
7730 static inline void
7731 validate_switches_from_spec (const char *spec)
7733 const char *p = spec;
7734 char c;
7735 while ((c = *p++))
7736 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7737 /* We have a switch spec. */
7738 p = validate_switches (p + 1);
7741 static void
7742 validate_all_switches (void)
7744 struct compiler *comp;
7745 struct spec_list *spec;
7747 for (comp = compilers; comp->spec; comp++)
7748 validate_switches_from_spec (comp->spec);
7750 /* Look through the linked list of specs read from the specs file. */
7751 for (spec = specs; spec; spec = spec->next)
7752 validate_switches_from_spec (*spec->ptr_spec);
7754 validate_switches_from_spec (link_command_spec);
7757 /* Look at the switch-name that comes after START
7758 and mark as valid all supplied switches that match it. */
7760 static const char *
7761 validate_switches (const char *start)
7763 const char *p = start;
7764 const char *atom;
7765 size_t len;
7766 int i;
7767 bool suffix = false;
7768 bool starred = false;
7770 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7772 next_member:
7773 SKIP_WHITE ();
7775 if (*p == '!')
7776 p++;
7778 SKIP_WHITE ();
7779 if (*p == '.' || *p == ',')
7780 suffix = true, p++;
7782 atom = p;
7783 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7784 || *p == ',' || *p == '.' || *p == '@')
7785 p++;
7786 len = p - atom;
7788 if (*p == '*')
7789 starred = true, p++;
7791 SKIP_WHITE ();
7793 if (!suffix)
7795 /* Mark all matching switches as valid. */
7796 for (i = 0; i < n_switches; i++)
7797 if (!strncmp (switches[i].part1, atom, len)
7798 && (starred || switches[i].part1[len] == 0))
7799 switches[i].validated = 1;
7802 if (*p) p++;
7803 if (*p && (p[-1] == '|' || p[-1] == '&'))
7804 goto next_member;
7806 if (*p && p[-1] == ':')
7808 while (*p && *p != ';' && *p != '}')
7810 if (*p == '%')
7812 p++;
7813 if (*p == '{' || *p == '<')
7814 p = validate_switches (p+1);
7815 else if (p[0] == 'W' && p[1] == '{')
7816 p = validate_switches (p+2);
7818 else
7819 p++;
7822 if (*p) p++;
7823 if (*p && p[-1] == ';')
7824 goto next_member;
7827 return p;
7828 #undef SKIP_WHITE
7831 struct mdswitchstr
7833 const char *str;
7834 int len;
7837 static struct mdswitchstr *mdswitches;
7838 static int n_mdswitches;
7840 /* Check whether a particular argument was used. The first time we
7841 canonicalize the switches to keep only the ones we care about. */
7843 static int
7844 used_arg (const char *p, int len)
7846 struct mswitchstr
7848 const char *str;
7849 const char *replace;
7850 int len;
7851 int rep_len;
7854 static struct mswitchstr *mswitches;
7855 static int n_mswitches;
7856 int i, j;
7858 if (!mswitches)
7860 struct mswitchstr *matches;
7861 const char *q;
7862 int cnt = 0;
7864 /* Break multilib_matches into the component strings of string
7865 and replacement string. */
7866 for (q = multilib_matches; *q != '\0'; q++)
7867 if (*q == ';')
7868 cnt++;
7870 matches
7871 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7872 i = 0;
7873 q = multilib_matches;
7874 while (*q != '\0')
7876 matches[i].str = q;
7877 while (*q != ' ')
7879 if (*q == '\0')
7881 invalid_matches:
7882 fatal ("multilib spec '%s' is invalid", multilib_matches);
7884 q++;
7886 matches[i].len = q - matches[i].str;
7888 matches[i].replace = ++q;
7889 while (*q != ';' && *q != '\0')
7891 if (*q == ' ')
7892 goto invalid_matches;
7893 q++;
7895 matches[i].rep_len = q - matches[i].replace;
7896 i++;
7897 if (*q == ';')
7898 q++;
7901 /* Now build a list of the replacement string for switches that we care
7902 about. Make sure we allocate at least one entry. This prevents
7903 xmalloc from calling fatal, and prevents us from re-executing this
7904 block of code. */
7905 mswitches
7906 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7907 for (i = 0; i < n_switches; i++)
7908 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7910 int xlen = strlen (switches[i].part1);
7911 for (j = 0; j < cnt; j++)
7912 if (xlen == matches[j].len
7913 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7915 mswitches[n_mswitches].str = matches[j].replace;
7916 mswitches[n_mswitches].len = matches[j].rep_len;
7917 mswitches[n_mswitches].replace = (char *) 0;
7918 mswitches[n_mswitches].rep_len = 0;
7919 n_mswitches++;
7920 break;
7924 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7925 on the command line nor any options mutually incompatible with
7926 them. */
7927 for (i = 0; i < n_mdswitches; i++)
7929 const char *r;
7931 for (q = multilib_options; *q != '\0'; q++)
7933 while (*q == ' ')
7934 q++;
7936 r = q;
7937 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7938 || strchr (" /", q[mdswitches[i].len]) == NULL)
7940 while (*q != ' ' && *q != '/' && *q != '\0')
7941 q++;
7942 if (*q != '/')
7943 break;
7944 q++;
7947 if (*q != ' ' && *q != '\0')
7949 while (*r != ' ' && *r != '\0')
7951 q = r;
7952 while (*q != ' ' && *q != '/' && *q != '\0')
7953 q++;
7955 if (used_arg (r, q - r))
7956 break;
7958 if (*q != '/')
7960 mswitches[n_mswitches].str = mdswitches[i].str;
7961 mswitches[n_mswitches].len = mdswitches[i].len;
7962 mswitches[n_mswitches].replace = (char *) 0;
7963 mswitches[n_mswitches].rep_len = 0;
7964 n_mswitches++;
7965 break;
7968 r = q + 1;
7970 break;
7976 for (i = 0; i < n_mswitches; i++)
7977 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7978 return 1;
7980 return 0;
7983 static int
7984 default_arg (const char *p, int len)
7986 int i;
7988 for (i = 0; i < n_mdswitches; i++)
7989 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7990 return 1;
7992 return 0;
7995 /* Work out the subdirectory to use based on the options. The format of
7996 multilib_select is a list of elements. Each element is a subdirectory
7997 name followed by a list of options followed by a semicolon. The format
7998 of multilib_exclusions is the same, but without the preceding
7999 directory. First gcc will check the exclusions, if none of the options
8000 beginning with an exclamation point are present, and all of the other
8001 options are present, then we will ignore this completely. Passing
8002 that, gcc will consider each multilib_select in turn using the same
8003 rules for matching the options. If a match is found, that subdirectory
8004 will be used. */
8006 static void
8007 set_multilib_dir (void)
8009 const char *p;
8010 unsigned int this_path_len;
8011 const char *this_path, *this_arg;
8012 const char *start, *end;
8013 int not_arg;
8014 int ok, ndfltok, first;
8016 n_mdswitches = 0;
8017 start = multilib_defaults;
8018 while (*start == ' ' || *start == '\t')
8019 start++;
8020 while (*start != '\0')
8022 n_mdswitches++;
8023 while (*start != ' ' && *start != '\t' && *start != '\0')
8024 start++;
8025 while (*start == ' ' || *start == '\t')
8026 start++;
8029 if (n_mdswitches)
8031 int i = 0;
8033 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8034 for (start = multilib_defaults; *start != '\0'; start = end + 1)
8036 while (*start == ' ' || *start == '\t')
8037 start++;
8039 if (*start == '\0')
8040 break;
8042 for (end = start + 1;
8043 *end != ' ' && *end != '\t' && *end != '\0'; end++)
8046 obstack_grow (&multilib_obstack, start, end - start);
8047 obstack_1grow (&multilib_obstack, 0);
8048 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8049 mdswitches[i++].len = end - start;
8051 if (*end == '\0')
8052 break;
8056 p = multilib_exclusions;
8057 while (*p != '\0')
8059 /* Ignore newlines. */
8060 if (*p == '\n')
8062 ++p;
8063 continue;
8066 /* Check the arguments. */
8067 ok = 1;
8068 while (*p != ';')
8070 if (*p == '\0')
8072 invalid_exclusions:
8073 fatal ("multilib exclusions '%s' is invalid",
8074 multilib_exclusions);
8077 if (! ok)
8079 ++p;
8080 continue;
8083 this_arg = p;
8084 while (*p != ' ' && *p != ';')
8086 if (*p == '\0')
8087 goto invalid_exclusions;
8088 ++p;
8091 if (*this_arg != '!')
8092 not_arg = 0;
8093 else
8095 not_arg = 1;
8096 ++this_arg;
8099 ok = used_arg (this_arg, p - this_arg);
8100 if (not_arg)
8101 ok = ! ok;
8103 if (*p == ' ')
8104 ++p;
8107 if (ok)
8108 return;
8110 ++p;
8113 first = 1;
8114 p = multilib_select;
8115 while (*p != '\0')
8117 /* Ignore newlines. */
8118 if (*p == '\n')
8120 ++p;
8121 continue;
8124 /* Get the initial path. */
8125 this_path = p;
8126 while (*p != ' ')
8128 if (*p == '\0')
8130 invalid_select:
8131 fatal ("multilib select '%s' is invalid",
8132 multilib_select);
8134 ++p;
8136 this_path_len = p - this_path;
8138 /* Check the arguments. */
8139 ok = 1;
8140 ndfltok = 1;
8141 ++p;
8142 while (*p != ';')
8144 if (*p == '\0')
8145 goto invalid_select;
8147 if (! ok)
8149 ++p;
8150 continue;
8153 this_arg = p;
8154 while (*p != ' ' && *p != ';')
8156 if (*p == '\0')
8157 goto invalid_select;
8158 ++p;
8161 if (*this_arg != '!')
8162 not_arg = 0;
8163 else
8165 not_arg = 1;
8166 ++this_arg;
8169 /* If this is a default argument, we can just ignore it.
8170 This is true even if this_arg begins with '!'. Beginning
8171 with '!' does not mean that this argument is necessarily
8172 inappropriate for this library: it merely means that
8173 there is a more specific library which uses this
8174 argument. If this argument is a default, we need not
8175 consider that more specific library. */
8176 ok = used_arg (this_arg, p - this_arg);
8177 if (not_arg)
8178 ok = ! ok;
8180 if (! ok)
8181 ndfltok = 0;
8183 if (default_arg (this_arg, p - this_arg))
8184 ok = 1;
8186 if (*p == ' ')
8187 ++p;
8190 if (ok && first)
8192 if (this_path_len != 1
8193 || this_path[0] != '.')
8195 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8196 char *q;
8198 strncpy (new_multilib_dir, this_path, this_path_len);
8199 new_multilib_dir[this_path_len] = '\0';
8200 q = strchr (new_multilib_dir, ':');
8201 if (q != NULL)
8202 *q = '\0';
8203 multilib_dir = new_multilib_dir;
8205 first = 0;
8208 if (ndfltok)
8210 const char *q = this_path, *end = this_path + this_path_len;
8212 while (q < end && *q != ':')
8213 q++;
8214 if (q < end)
8216 char *new_multilib_os_dir = XNEWVEC (char, end - q);
8217 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8218 new_multilib_os_dir[end - q - 1] = '\0';
8219 multilib_os_dir = new_multilib_os_dir;
8220 break;
8224 ++p;
8227 if (multilib_dir == NULL && multilib_os_dir != NULL
8228 && strcmp (multilib_os_dir, ".") == 0)
8230 free (CONST_CAST (char *, multilib_os_dir));
8231 multilib_os_dir = NULL;
8233 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8234 multilib_os_dir = multilib_dir;
8237 /* Print out the multiple library subdirectory selection
8238 information. This prints out a series of lines. Each line looks
8239 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8240 required. Only the desired options are printed out, the negative
8241 matches. The options are print without a leading dash. There are
8242 no spaces to make it easy to use the information in the shell.
8243 Each subdirectory is printed only once. This assumes the ordering
8244 generated by the genmultilib script. Also, we leave out ones that match
8245 the exclusions. */
8247 static void
8248 print_multilib_info (void)
8250 const char *p = multilib_select;
8251 const char *last_path = 0, *this_path;
8252 int skip;
8253 unsigned int last_path_len = 0;
8255 while (*p != '\0')
8257 skip = 0;
8258 /* Ignore newlines. */
8259 if (*p == '\n')
8261 ++p;
8262 continue;
8265 /* Get the initial path. */
8266 this_path = p;
8267 while (*p != ' ')
8269 if (*p == '\0')
8271 invalid_select:
8272 fatal ("multilib select '%s' is invalid", multilib_select);
8275 ++p;
8278 /* When --disable-multilib was used but target defines
8279 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8280 to find multilib_os_dir, so skip them from output. */
8281 if (this_path[0] == '.' && this_path[1] == ':')
8282 skip = 1;
8284 /* Check for matches with the multilib_exclusions. We don't bother
8285 with the '!' in either list. If any of the exclusion rules match
8286 all of its options with the select rule, we skip it. */
8288 const char *e = multilib_exclusions;
8289 const char *this_arg;
8291 while (*e != '\0')
8293 int m = 1;
8294 /* Ignore newlines. */
8295 if (*e == '\n')
8297 ++e;
8298 continue;
8301 /* Check the arguments. */
8302 while (*e != ';')
8304 const char *q;
8305 int mp = 0;
8307 if (*e == '\0')
8309 invalid_exclusion:
8310 fatal ("multilib exclusion '%s' is invalid",
8311 multilib_exclusions);
8314 if (! m)
8316 ++e;
8317 continue;
8320 this_arg = e;
8322 while (*e != ' ' && *e != ';')
8324 if (*e == '\0')
8325 goto invalid_exclusion;
8326 ++e;
8329 q = p + 1;
8330 while (*q != ';')
8332 const char *arg;
8333 int len = e - this_arg;
8335 if (*q == '\0')
8336 goto invalid_select;
8338 arg = q;
8340 while (*q != ' ' && *q != ';')
8342 if (*q == '\0')
8343 goto invalid_select;
8344 ++q;
8347 if (! strncmp (arg, this_arg,
8348 (len < q - arg) ? q - arg : len)
8349 || default_arg (this_arg, e - this_arg))
8351 mp = 1;
8352 break;
8355 if (*q == ' ')
8356 ++q;
8359 if (! mp)
8360 m = 0;
8362 if (*e == ' ')
8363 ++e;
8366 if (m)
8368 skip = 1;
8369 break;
8372 if (*e != '\0')
8373 ++e;
8377 if (! skip)
8379 /* If this is a duplicate, skip it. */
8380 skip = (last_path != 0
8381 && (unsigned int) (p - this_path) == last_path_len
8382 && ! strncmp (last_path, this_path, last_path_len));
8384 last_path = this_path;
8385 last_path_len = p - this_path;
8388 /* If this directory requires any default arguments, we can skip
8389 it. We will already have printed a directory identical to
8390 this one which does not require that default argument. */
8391 if (! skip)
8393 const char *q;
8395 q = p + 1;
8396 while (*q != ';')
8398 const char *arg;
8400 if (*q == '\0')
8401 goto invalid_select;
8403 if (*q == '!')
8404 arg = NULL;
8405 else
8406 arg = q;
8408 while (*q != ' ' && *q != ';')
8410 if (*q == '\0')
8411 goto invalid_select;
8412 ++q;
8415 if (arg != NULL
8416 && default_arg (arg, q - arg))
8418 skip = 1;
8419 break;
8422 if (*q == ' ')
8423 ++q;
8427 if (! skip)
8429 const char *p1;
8431 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8432 putchar (*p1);
8433 putchar (';');
8436 ++p;
8437 while (*p != ';')
8439 int use_arg;
8441 if (*p == '\0')
8442 goto invalid_select;
8444 if (skip)
8446 ++p;
8447 continue;
8450 use_arg = *p != '!';
8452 if (use_arg)
8453 putchar ('@');
8455 while (*p != ' ' && *p != ';')
8457 if (*p == '\0')
8458 goto invalid_select;
8459 if (use_arg)
8460 putchar (*p);
8461 ++p;
8464 if (*p == ' ')
8465 ++p;
8468 if (! skip)
8470 /* If there are extra options, print them now. */
8471 if (multilib_extra && *multilib_extra)
8473 int print_at = TRUE;
8474 const char *q;
8476 for (q = multilib_extra; *q != '\0'; q++)
8478 if (*q == ' ')
8479 print_at = TRUE;
8480 else
8482 if (print_at)
8483 putchar ('@');
8484 putchar (*q);
8485 print_at = FALSE;
8490 putchar ('\n');
8493 ++p;
8497 /* getenv built-in spec function.
8499 Returns the value of the environment variable given by its first
8500 argument, concatenated with the second argument. If the
8501 environment variable is not defined, a fatal error is issued. */
8503 static const char *
8504 getenv_spec_function (int argc, const char **argv)
8506 char *value;
8507 char *result;
8508 char *ptr;
8509 size_t len;
8511 if (argc != 2)
8512 return NULL;
8514 value = getenv (argv[0]);
8515 if (!value)
8516 fatal ("environment variable \"%s\" not defined", argv[0]);
8518 /* We have to escape every character of the environment variable so
8519 they are not interpreted as active spec characters. A
8520 particularly painful case is when we are reading a variable
8521 holding a windows path complete with \ separators. */
8522 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8523 result = XNEWVAR (char, len);
8524 for (ptr = result; *value; ptr += 2)
8526 ptr[0] = '\\';
8527 ptr[1] = *value++;
8530 strcpy (ptr, argv[1]);
8532 return result;
8535 /* if-exists built-in spec function.
8537 Checks to see if the file specified by the absolute pathname in
8538 ARGS exists. Returns that pathname if found.
8540 The usual use for this function is to check for a library file
8541 (whose name has been expanded with %s). */
8543 static const char *
8544 if_exists_spec_function (int argc, const char **argv)
8546 /* Must have only one argument. */
8547 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8548 return argv[0];
8550 return NULL;
8553 /* if-exists-else built-in spec function.
8555 This is like if-exists, but takes an additional argument which
8556 is returned if the first argument does not exist. */
8558 static const char *
8559 if_exists_else_spec_function (int argc, const char **argv)
8561 /* Must have exactly two arguments. */
8562 if (argc != 2)
8563 return NULL;
8565 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8566 return argv[0];
8568 return argv[1];
8571 /* replace-outfile built-in spec function.
8573 This looks for the first argument in the outfiles array's name and
8574 replaces it with the second argument. */
8576 static const char *
8577 replace_outfile_spec_function (int argc, const char **argv)
8579 int i;
8580 /* Must have exactly two arguments. */
8581 if (argc != 2)
8582 abort ();
8584 for (i = 0; i < n_infiles; i++)
8586 if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8587 outfiles[i] = xstrdup (argv[1]);
8589 return NULL;
8592 /* Given two version numbers, compares the two numbers.
8593 A version number must match the regular expression
8594 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8596 static int
8597 compare_version_strings (const char *v1, const char *v2)
8599 int rresult;
8600 regex_t r;
8602 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8603 REG_EXTENDED | REG_NOSUB) != 0)
8604 abort ();
8605 rresult = regexec (&r, v1, 0, NULL, 0);
8606 if (rresult == REG_NOMATCH)
8607 fatal ("invalid version number `%s'", v1);
8608 else if (rresult != 0)
8609 abort ();
8610 rresult = regexec (&r, v2, 0, NULL, 0);
8611 if (rresult == REG_NOMATCH)
8612 fatal ("invalid version number `%s'", v2);
8613 else if (rresult != 0)
8614 abort ();
8616 return strverscmp (v1, v2);
8620 /* version_compare built-in spec function.
8622 This takes an argument of the following form:
8624 <comparison-op> <arg1> [<arg2>] <switch> <result>
8626 and produces "result" if the comparison evaluates to true,
8627 and nothing if it doesn't.
8629 The supported <comparison-op> values are:
8631 >= true if switch is a later (or same) version than arg1
8632 !> opposite of >=
8633 < true if switch is an earlier version than arg1
8634 !< opposite of <
8635 >< true if switch is arg1 or later, and earlier than arg2
8636 <> true if switch is earlier than arg1 or is arg2 or later
8638 If the switch is not present, the condition is false unless
8639 the first character of the <comparison-op> is '!'.
8641 For example,
8642 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8643 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8645 static const char *
8646 version_compare_spec_function (int argc, const char **argv)
8648 int comp1, comp2;
8649 size_t switch_len;
8650 const char *switch_value = NULL;
8651 int nargs = 1, i;
8652 bool result;
8654 if (argc < 3)
8655 fatal ("too few arguments to %%:version-compare");
8656 if (argv[0][0] == '\0')
8657 abort ();
8658 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8659 nargs = 2;
8660 if (argc != nargs + 3)
8661 fatal ("too many arguments to %%:version-compare");
8663 switch_len = strlen (argv[nargs + 1]);
8664 for (i = 0; i < n_switches; i++)
8665 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8666 && check_live_switch (i, switch_len))
8667 switch_value = switches[i].part1 + switch_len;
8669 if (switch_value == NULL)
8670 comp1 = comp2 = -1;
8671 else
8673 comp1 = compare_version_strings (switch_value, argv[1]);
8674 if (nargs == 2)
8675 comp2 = compare_version_strings (switch_value, argv[2]);
8676 else
8677 comp2 = -1; /* This value unused. */
8680 switch (argv[0][0] << 8 | argv[0][1])
8682 case '>' << 8 | '=':
8683 result = comp1 >= 0;
8684 break;
8685 case '!' << 8 | '<':
8686 result = comp1 >= 0 || switch_value == NULL;
8687 break;
8688 case '<' << 8:
8689 result = comp1 < 0;
8690 break;
8691 case '!' << 8 | '>':
8692 result = comp1 < 0 || switch_value == NULL;
8693 break;
8694 case '>' << 8 | '<':
8695 result = comp1 >= 0 && comp2 < 0;
8696 break;
8697 case '<' << 8 | '>':
8698 result = comp1 < 0 || comp2 >= 0;
8699 break;
8701 default:
8702 fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8704 if (! result)
8705 return NULL;
8707 return argv[nargs + 2];
8710 /* %:include builtin spec function. This differs from %include in that it
8711 can be nested inside a spec, and thus be conditionalized. It takes
8712 one argument, the filename, and looks for it in the startfile path.
8713 The result is always NULL, i.e. an empty expansion. */
8715 static const char *
8716 include_spec_function (int argc, const char **argv)
8718 char *file;
8720 if (argc != 1)
8721 abort ();
8723 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8724 read_specs (file ? file : argv[0], FALSE);
8726 return NULL;
8729 /* %:find-file spec function. This function replace its argument by
8730 the file found thru find_file, that is the -print-file-name gcc
8731 program option. */
8732 static const char *
8733 find_file_spec_function (int argc, const char**argv)
8735 const char *file;
8737 if (argc != 1)
8738 abort ();
8740 file = find_file (argv[0]);
8741 return file;
8745 /* %:print-asm-header spec function. Print a banner to say that the
8746 following output is from the assembler. */
8748 static const char *
8749 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8750 const char **argv ATTRIBUTE_UNUSED)
8752 printf (_("Assembler options\n=================\n\n"));
8753 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8754 fflush (stdout);
8755 return NULL;
8758 /* Compute a timestamp to initialize flag_random_seed. */
8760 static unsigned
8761 get_local_tick (void)
8763 unsigned ret = 0;
8765 /* Get some more or less random data. */
8766 #ifdef HAVE_GETTIMEOFDAY
8768 struct timeval tv;
8770 gettimeofday (&tv, NULL);
8771 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8773 #else
8775 time_t now = time (NULL);
8777 if (now != (time_t)-1)
8778 ret = (unsigned) now;
8780 #endif
8782 return ret;
8785 /* %:compare-debug-dump-opt spec function. Save the last argument,
8786 expected to be the last -fdump-final-insns option, or generate a
8787 temporary. */
8789 static const char *
8790 compare_debug_dump_opt_spec_function (int arg,
8791 const char **argv ATTRIBUTE_UNUSED)
8793 const char *ret;
8794 char *name;
8795 int which;
8796 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8798 if (arg != 0)
8799 fatal ("too many arguments to %%:compare-debug-dump-opt");
8801 do_spec_2 ("%{fdump-final-insns=*:%*}");
8802 do_spec_1 (" ", 0, NULL);
8804 if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8806 if (!compare_debug)
8807 return NULL;
8809 name = xstrdup (argv[argbuf_index - 1]);
8810 ret = NULL;
8812 else
8814 const char *ext = NULL;
8816 if (argbuf_index > 0)
8818 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8819 ext = ".gkd";
8821 else if (!compare_debug)
8822 return NULL;
8823 else
8824 do_spec_2 ("%g.gkd");
8826 do_spec_1 (" ", 0, NULL);
8828 gcc_assert (argbuf_index > 0);
8830 name = concat (argbuf[argbuf_index - 1], ext, NULL);
8832 ret = concat ("-fdump-final-insns=", name, NULL);
8835 which = compare_debug < 0;
8836 debug_check_temp_file[which] = name;
8838 if (!which)
8840 unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8842 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8845 if (*random_seed)
8846 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8847 ret, NULL);
8849 if (which)
8850 *random_seed = 0;
8852 return ret;
8855 static const char *debug_auxbase_opt;
8857 /* %:compare-debug-self-opt spec function. Expands to the options
8858 that are to be passed in the second compilation of
8859 compare-debug. */
8861 static const char *
8862 compare_debug_self_opt_spec_function (int arg,
8863 const char **argv ATTRIBUTE_UNUSED)
8865 if (arg != 0)
8866 fatal ("too many arguments to %%:compare-debug-self-opt");
8868 if (compare_debug >= 0)
8869 return NULL;
8871 do_spec_2 ("%{c|S:%{o*:%*}}");
8872 do_spec_1 (" ", 0, NULL);
8874 if (argbuf_index > 0)
8875 debug_auxbase_opt = concat ("-auxbase-strip ",
8876 argbuf[argbuf_index - 1],
8877 NULL);
8878 else
8879 debug_auxbase_opt = NULL;
8881 return concat ("\
8882 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8883 %<fdump-final-insns=* -w -S -o %j \
8884 %{!fcompare-debug-second:-fcompare-debug-second} \
8885 ", compare_debug_opt, NULL);
8888 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8889 options that are to be passed in the second compilation of
8890 compare-debug. It expects, as an argument, the basename of the
8891 current input file name, with the .gk suffix appended to it. */
8893 static const char *
8894 compare_debug_auxbase_opt_spec_function (int arg,
8895 const char **argv)
8897 char *name;
8898 int len;
8900 if (arg == 0)
8901 fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8903 if (arg != 1)
8904 fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8906 if (compare_debug >= 0)
8907 return NULL;
8909 len = strlen (argv[0]);
8910 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8911 fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8913 if (debug_auxbase_opt)
8914 return debug_auxbase_opt;
8916 #define OPT "-auxbase "
8918 len -= 3;
8919 name = (char*) xmalloc (sizeof (OPT) + len);
8920 memcpy (name, OPT, sizeof (OPT) - 1);
8921 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8922 name[sizeof (OPT) - 1 + len] = '\0';
8924 #undef OPT
8926 return name;