1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers. It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec". */
33 /* A Short Introduction to Adding a Command-Line Option.
35 Before adding a command-line option, consider if it is really
36 necessary. Each additional command-line option adds complexity and
37 is difficult to remove in subsequent versions.
39 In the following, consider adding the command-line argument
42 1. Each command-line option is specified in the specs file. The
43 notation is described below in the comment entitled "The Specs
46 2. In this file, add an entry to "option_map" equating the long
47 `--' argument version and any shorter, single letter version. Read
48 the comments in the declaration of "struct option_map" for an
49 explanation. Do not omit the first `-'.
51 3. Look in the "specs" file to determine which program or option
52 list should be given the argument, e.g., "cc1_options". Add the
53 appropriate syntax for the shorter option version to the
54 corresponding "const char *" entry in this file. Omit the first
55 `-' from the option. For example, use `-bar', rather than `--bar'.
57 4. If the argument takes an argument, e.g., `--baz argument1',
58 modify either DEFAULT_SWITCH_TAKES_ARG or
59 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
62 5. Document the option in this file's display_help(). If the
63 option is passed to a subprogram, modify its corresponding
64 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
67 6. Compile and test. Make sure that your new specs file is being
68 read. For example, use a debugger to investigate the value of
69 "specs_file" in main(). */
73 #include "coretypes.h"
74 #include "multilib.h" /* before tm.h */
77 #if ! defined( SIGCHLD ) && defined( SIGCLD )
78 # define SIGCHLD SIGCLD
85 #include "diagnostic.h"
90 # include <sys/mman.h>
92 /* This is on Solaris. */
93 # include <sys/types.h>
98 # define MAP_FAILED ((void *)-1)
101 /* By default there is no special suffix for target executables. */
102 /* FIXME: when autoconf is fixed, remove the host check - dj */
103 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
104 #define HAVE_TARGET_EXECUTABLE_SUFFIX
107 /* By default there is no special suffix for host executables. */
108 #ifdef HOST_EXECUTABLE_SUFFIX
109 #define HAVE_HOST_EXECUTABLE_SUFFIX
111 #define HOST_EXECUTABLE_SUFFIX ""
114 /* By default, the suffix for target object files is ".o". */
115 #ifdef TARGET_OBJECT_SUFFIX
116 #define HAVE_TARGET_OBJECT_SUFFIX
118 #define TARGET_OBJECT_SUFFIX ".o"
121 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
123 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
124 #ifndef LIBRARY_PATH_ENV
125 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
129 #define kill(p,s) raise(s)
132 /* If a stage of compilation returns an exit status >= 1,
133 compilation of that file ceases. */
135 #define MIN_FATAL_STATUS 1
137 /* Flag set by cppspec.c to 1. */
140 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
141 static bool at_file_supplied
;
143 /* Flag saying to pass the greatest exit code returned by a sub-process
144 to the calling program. */
145 static int pass_exit_codes
;
147 /* Definition of string containing the arguments given to configure. */
148 #include "configargs.h"
150 /* Flag saying to print the directories gcc will search through looking for
151 programs, libraries, etc. */
153 static int print_search_dirs
;
155 /* Flag saying to print the full filename of this file
156 as found through our usual search mechanism. */
158 static const char *print_file_name
= NULL
;
160 /* As print_file_name, but search for executable file. */
162 static const char *print_prog_name
= NULL
;
164 /* Flag saying to print the relative path we'd use to
165 find libgcc.a given the current compiler flags. */
167 static int print_multi_directory
;
169 static int print_sysroot
;
171 /* Flag saying to print the relative path we'd use to
172 find OS libraries given the current compiler flags. */
174 static int print_multi_os_directory
;
176 /* Flag saying to print the list of subdirectories and
177 compiler flags used to select them in a standard form. */
179 static int print_multi_lib
;
181 /* Flag saying to print the command line options understood by gcc and its
184 static int print_help_list
;
186 /* Flag saying to print the version of gcc and its sub-processes. */
188 static int print_version
;
190 /* Flag saying to print the sysroot suffix used for searching for
193 static int print_sysroot_headers_suffix
;
195 /* Flag indicating whether we should print the command and arguments */
197 static int verbose_flag
;
199 /* Flag indicating whether we should ONLY print the command and
200 arguments (like verbose_flag) without executing the command.
201 Displayed arguments are quoted so that the generated command
202 line is suitable for execution. This is intended for use in
203 shell scripts to capture the driver-generated command line. */
204 static int verbose_only_flag
;
206 /* Flag indicating how to print command line options of sub-processes. */
208 static int print_subprocess_help
;
210 /* Flag indicating whether we should report subprocess execution times
211 (if this is supported by the system - see pexecute.c). */
213 static int report_times
;
215 /* Whether we should report subprocess execution times to a file. */
217 FILE *report_times_to_file
= NULL
;
219 /* Nonzero means place this string before uses of /, so that include
220 and library files can be found in an alternate location. */
222 #ifdef TARGET_SYSTEM_ROOT
223 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
225 static const char *target_system_root
= 0;
228 /* Nonzero means pass the updated target_system_root to the compiler. */
230 static int target_system_root_changed
;
232 /* Nonzero means append this string to target_system_root. */
234 static const char *target_sysroot_suffix
= 0;
236 /* Nonzero means append this string to target_system_root for headers. */
238 static const char *target_sysroot_hdrs_suffix
= 0;
240 /* Nonzero means write "temp" files in source directory
241 and use the source file's name in them, and don't delete them. */
243 static enum save_temps
{
244 SAVE_TEMPS_NONE
, /* no -save-temps */
245 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
246 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
249 /* Output file to use to get the object directory for -save-temps=obj */
250 static char *save_temps_prefix
= 0;
251 static size_t save_temps_length
= 0;
253 /* Nonzero means pass multiple source files to the compiler at one time. */
255 static int combine_flag
= 0;
257 /* Nonzero means use pipes to communicate between subprocesses.
258 Overridden by either of the above two flags. */
260 static int use_pipes
;
262 /* The compiler version. */
264 static const char *compiler_version
;
266 /* The target version. */
268 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
270 /* The target machine. */
272 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
274 /* Nonzero if cross-compiling.
275 When -b is used, the value comes from the `specs' file. */
277 #ifdef CROSS_DIRECTORY_STRUCTURE
278 static const char *cross_compile
= "1";
280 static const char *cross_compile
= "0";
283 /* Greatest exit code of sub-processes that has been encountered up to
285 static int greatest_status
= 1;
287 /* This is the obstack which we use to allocate many strings. */
289 static struct obstack obstack
;
291 /* This is the obstack to build an environment variable to pass to
292 collect2 that describes all of the relevant switches of what to
293 pass the compiler in building the list of pointers to constructors
296 static struct obstack collect_obstack
;
298 /* This is a list of a wrapper program and its arguments.
299 e.g. wrapper_string of "strace,-c"
300 will cause all programs to run as
301 strace -c program arguments
304 static const char *wrapper_string
;
306 /* Forward declaration for prototypes. */
310 static void init_spec (void);
311 static void store_arg (const char *, int, int);
312 static void insert_wrapper (const char *);
313 static char *load_specs (const char *);
314 static void read_specs (const char *, int);
315 static void set_spec (const char *, const char *);
316 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
317 static char *build_search_list (const struct path_prefix
*, const char *,
319 static void xputenv (const char *);
320 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
322 static int access_check (const char *, int);
323 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
324 static void add_prefix (struct path_prefix
*, const char *, const char *,
326 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
327 const char *, int, int, int);
328 static void translate_options (int *, const char *const **);
329 static char *skip_whitespace (char *);
330 static void delete_if_ordinary (const char *);
331 static void delete_temp_files (void);
332 static void delete_failure_queue (void);
333 static void clear_failure_queue (void);
334 static int check_live_switch (int, int);
335 static const char *handle_braces (const char *);
336 static inline bool input_suffix_matches (const char *, const char *);
337 static inline bool switch_matches (const char *, const char *, int);
338 static inline void mark_matching_switches (const char *, const char *, int);
339 static inline void process_marked_switches (void);
340 static const char *process_brace_body (const char *, const char *, const char *, int, int);
341 static const struct spec_function
*lookup_spec_function (const char *);
342 static const char *eval_spec_function (const char *, const char *);
343 static const char *handle_spec_function (const char *);
344 static char *save_string (const char *, int);
345 static void set_collect_gcc_options (void);
346 static int do_spec_1 (const char *, int, const char *);
347 static int do_spec_2 (const char *);
348 static void do_option_spec (const char *, const char *);
349 static void do_self_spec (const char *);
350 static const char *find_file (const char *);
351 static int is_directory (const char *, bool);
352 static const char *validate_switches (const char *);
353 static void validate_all_switches (void);
354 static inline void validate_switches_from_spec (const char *);
355 static void give_switch (int, int);
356 static int used_arg (const char *, int);
357 static int default_arg (const char *, int);
358 static void set_multilib_dir (void);
359 static void print_multilib_info (void);
360 static void perror_with_name (const char *);
361 static void display_help (void);
362 static void add_preprocessor_option (const char *, int);
363 static void add_assembler_option (const char *, int);
364 static void add_linker_option (const char *, int);
365 static void process_command (int, const char **);
366 static int execute (void);
367 static void alloc_args (void);
368 static void clear_args (void);
369 static void fatal_signal (int);
370 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
371 static void init_gcc_specs (struct obstack
*, const char *, const char *,
374 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
375 static const char *convert_filename (const char *, int, int);
378 static const char *getenv_spec_function (int, const char **);
379 static const char *if_exists_spec_function (int, const char **);
380 static const char *if_exists_else_spec_function (int, const char **);
381 static const char *replace_outfile_spec_function (int, const char **);
382 static const char *version_compare_spec_function (int, const char **);
383 static const char *include_spec_function (int, const char **);
384 static const char *find_file_spec_function (int, const char **);
385 static const char *find_plugindir_spec_function (int, const char **);
386 static const char *print_asm_header_spec_function (int, const char **);
387 static const char *compare_debug_dump_opt_spec_function (int, const char **);
388 static const char *compare_debug_self_opt_spec_function (int, const char **);
389 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
391 /* The Specs Language
393 Specs are strings containing lines, each of which (if not blank)
394 is made up of a program name, and arguments separated by spaces.
395 The program name must be exact and start from root, since no path
396 is searched and it is unreliable to depend on the current working directory.
397 Redirection of input or output is not supported; the subprograms must
398 accept filenames saying what files to read and write.
400 In addition, the specs can contain %-sequences to substitute variable text
401 or for conditional text. Here is a table of all defined %-sequences.
402 Note that spaces are not generated automatically around the results of
403 expanding these sequences; therefore, you can concatenate them together
404 or with constant text in a single argument.
406 %% substitute one % into the program name or argument.
407 %i substitute the name of the input file being processed.
408 %b substitute the basename of the input file being processed.
409 This is the substring up to (and not including) the last period
410 and not including the directory unless -save-temps was specified
411 to put temporaries in a different location.
412 %B same as %b, but include the file suffix (text after the last period).
414 substitute a file name that has suffix SUFFIX and is chosen
415 once per compilation, and mark the argument a la %d. To reduce
416 exposure to denial-of-service attacks, the file name is now
417 chosen in a way that is hard to predict even when previously
418 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
419 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
420 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
421 had been pre-processed. Previously, %g was simply substituted
422 with a file name chosen once per compilation, without regard
423 to any appended suffix (which was therefore treated just like
424 ordinary text), making such attacks more likely to succeed.
426 like %g, but if -pipe is in effect, expands simply to "-".
428 like %g, but if -pipe is in effect, expands to nothing. (We have both
429 %| and %m to accommodate differences between system assemblers; see
430 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
432 like %g, but generates a new temporary file name even if %uSUFFIX
435 substitutes the last file name generated with %uSUFFIX, generating a
436 new one if there is no such last file name. In the absence of any
437 %uSUFFIX, this is just like %gSUFFIX, except they don't share
438 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
439 would involve the generation of two distinct file names, one
440 for each `%g.s' and another for each `%U.s'. Previously, %U was
441 simply substituted with a file name chosen for the previous %u,
442 without regard to any appended suffix.
444 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
445 writable, and if save-temps is off; otherwise, substitute the name
446 of a temporary file, just like %u. This temporary file is not
447 meant for communication between processes, but rather as a junk
450 substitutes .SUFFIX for the suffixes of a matched switch's args when
451 it is subsequently output with %*. SUFFIX is terminated by the next
453 %d marks the argument containing or following the %d as a
454 temporary file name, so that that file will be deleted if GCC exits
455 successfully. Unlike %g, this contributes no text to the argument.
456 %w marks the argument containing or following the %w as the
457 "output file" of this compilation. This puts the argument
458 into the sequence of arguments that %o will substitute later.
459 %V indicates that this compilation produces no "output file".
461 like %{...} but mark last argument supplied within
462 as a file to be deleted on failure.
463 %o substitutes the names of all the output files, with spaces
464 automatically placed around them. You should write spaces
465 around the %o as well or the results are undefined.
466 %o is for use in the specs for running the linker.
467 Input files whose names have no recognized suffix are not compiled
468 at all, but they are included among the output files, so they will
470 %O substitutes the suffix for object files. Note that this is
471 handled specially when it immediately follows %g, %u, or %U
472 (with or without a suffix argument) because of the need for
473 those to form complete file names. The handling is such that
474 %O is treated exactly as if it had already been substituted,
475 except that %g, %u, and %U do not currently support additional
476 SUFFIX characters following %O as they would following, for
478 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
479 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
480 and -B options) and -imultilib as necessary.
481 %s current argument is the name of a library or startup file of some sort.
482 Search for that file in a standard list of directories
483 and substitute the full name found.
484 %eSTR Print STR as an error message. STR is terminated by a newline.
485 Use this when inconsistent options are detected.
486 %nSTR Print STR as a notice. STR is terminated by a newline.
487 %x{OPTION} Accumulate an option for %X.
488 %X Output the accumulated linker options specified by compilations.
489 %Y Output the accumulated assembler options specified by compilations.
490 %Z Output the accumulated preprocessor options specified by compilations.
491 %a process ASM_SPEC as a spec.
492 This allows config.h to specify part of the spec for running as.
493 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
494 used here. This can be used to run a post-processor after the
495 assembler has done its job.
496 %D Dump out a -L option for each directory in startfile_prefixes.
497 If multilib_dir is set, extra entries are generated with it affixed.
498 %l process LINK_SPEC as a spec.
499 %L process LIB_SPEC as a spec.
500 %G process LIBGCC_SPEC as a spec.
501 %R Output the concatenation of target_system_root and
502 target_sysroot_suffix.
503 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
504 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
505 %C process CPP_SPEC as a spec.
506 %1 process CC1_SPEC as a spec.
507 %2 process CC1PLUS_SPEC as a spec.
508 %* substitute the variable part of a matched option. (See below.)
509 Note that each comma in the substituted string is replaced by
511 %<S remove all occurrences of -S from the command line.
512 Note - this command is position dependent. % commands in the
513 spec string before this one will see -S, % commands in the
514 spec string after this one will not.
515 %<S* remove all occurrences of all switches beginning with -S from the
518 Call the named function FUNCTION, passing it ARGS. ARGS is
519 first processed as a nested spec string, then split into an
520 argument vector in the usual fashion. The function returns
521 a string which is processed as if it had appeared literally
522 as part of the current spec.
523 %{S} substitutes the -S switch, if that switch was given to GCC.
524 If that switch was not specified, this substitutes nothing.
525 Here S is a metasyntactic variable.
526 %{S*} substitutes all the switches specified to GCC whose names start
527 with -S. This is used for -o, -I, etc; switches that take
528 arguments. GCC considers `-o foo' as being one switch whose
529 name starts with `o'. %{o*} would substitute this text,
530 including the space; thus, two arguments would be generated.
531 %{S*&T*} likewise, but preserve order of S and T options (the order
532 of S and T in the spec is not significant). Can be any number
533 of ampersand-separated variables; for each the wild card is
534 optional. Useful for CPP as %{D*&U*&A*}.
536 %{S:X} substitutes X, if the -S switch was given to GCC.
537 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
538 %{S*:X} substitutes X if one or more switches whose names start
539 with -S was given to GCC. Normally X is substituted only
540 once, no matter how many such switches appeared. However,
541 if %* appears somewhere in X, then X will be substituted
542 once for each matching switch, with the %* replaced by the
543 part of that switch that matched the '*'.
544 %{.S:X} substitutes X, if processing a file with suffix S.
545 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
546 %{,S:X} substitutes X, if processing a file which will use spec S.
547 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
549 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
550 combined with '!', '.', ',', and '*' as above binding stronger
552 If %* appears in X, all of the alternatives must be starred, and
553 only the first matching alternative is substituted.
554 %{S:X; if S was given to GCC, substitutes X;
555 T:Y; else if T was given to GCC, substitutes Y;
556 :D} else substitutes D. There can be as many clauses as you need.
557 This may be combined with '.', '!', ',', '|', and '*' as above.
559 %(Spec) processes a specification defined in a specs file as *Spec:
560 %[Spec] as above, but put __ around -D arguments
562 The conditional text X in a %{S:X} or similar construct may contain
563 other nested % constructs or spaces, or even newlines. They are
564 processed as usual, as described above. Trailing white space in X is
565 ignored. White space may also appear anywhere on the left side of the
566 colon in these constructs, except between . or * and the corresponding
569 The -O, -f, -m, and -W switches are handled specifically in these
570 constructs. If another value of -O or the negated form of a -f, -m, or
571 -W switch is found later in the command line, the earlier switch
572 value is ignored, except with {S*} where S is just one letter; this
573 passes all matching options.
575 The character | at the beginning of the predicate text is used to indicate
576 that a command should be piped to the following command, but only if -pipe
579 Note that it is built into GCC which switches take arguments and which
580 do not. You might think it would be useful to generalize this to
581 allow each compiler's spec to say which switches take arguments. But
582 this cannot be done in a consistent fashion. GCC cannot even decide
583 which input files have been specified without knowing which switches
584 take arguments, and it must know which input files to compile in order
585 to tell which compilers to run.
587 GCC also knows implicitly that arguments starting in `-l' are to be
588 treated as compiler output files, and passed to the linker in their
589 proper position among the other output files. */
591 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
593 /* config.h can define ASM_SPEC to provide extra args to the assembler
594 or extra switch-translations. */
599 /* config.h can define ASM_FINAL_SPEC to run a post processor after
600 the assembler has run. */
601 #ifndef ASM_FINAL_SPEC
602 #define ASM_FINAL_SPEC ""
605 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
606 or extra switch-translations. */
611 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
612 or extra switch-translations. */
617 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
618 or extra switch-translations. */
620 #define CC1PLUS_SPEC ""
623 /* config.h can define LINK_SPEC to provide extra args to the linker
624 or extra switch-translations. */
629 /* config.h can define LIB_SPEC to override the default libraries. */
631 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
636 /* XXX: valid only for GNU ld */
637 /* XXX: should exactly match hooks provided by libmudflap.a */
638 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
639 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
640 --wrap=mmap --wrap=munmap --wrap=alloca\
641 } %{fmudflapth: --wrap=pthread_create\
642 }} %{fmudflap|fmudflapth: --wrap=main}"
645 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
648 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
651 #if defined(REAL_LIBGCC_SPEC)
652 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
653 #elif defined(LINK_LIBGCC_SPECIAL_1)
654 /* Have gcc do the search for libgcc.a. */
655 #define LIBGCC_SPEC "libgcc.a%s"
657 #define LIBGCC_SPEC "-lgcc"
661 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
662 #ifndef STARTFILE_SPEC
663 #define STARTFILE_SPEC \
664 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
667 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
669 #define ENDFILE_SPEC ""
673 #define LINKER_NAME "collect2"
676 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
677 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
682 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
684 #ifndef ASM_DEBUG_SPEC
685 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
686 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
687 # define ASM_DEBUG_SPEC \
688 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
689 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
690 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
692 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
693 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
695 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
696 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
700 #ifndef ASM_DEBUG_SPEC
701 # define ASM_DEBUG_SPEC ""
704 /* Here is the spec for running the linker, after compiling all files. */
706 /* This is overridable by the target in case they need to specify the
707 -lgcc and -lc order specially, yet not require them to override all
708 of LINK_COMMAND_SPEC. */
709 #ifndef LINK_GCC_C_SEQUENCE_SPEC
710 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
713 #ifndef LINK_SSP_SPEC
714 #ifdef TARGET_LIBC_PROVIDES_SSP
715 #define LINK_SSP_SPEC "%{fstack-protector:}"
717 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
721 #ifndef LINK_PIE_SPEC
723 #define LINK_PIE_SPEC "%{pie:-pie} "
725 #define LINK_PIE_SPEC "%{pie:} "
729 #ifndef LINK_BUILDID_SPEC
730 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
731 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
736 /* -u* was put back because both BSD and SysV seem to support it. */
737 /* %{static:} simply prevents an error message if the target machine
738 doesn't handle -static. */
739 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
740 scripts which exist in user specified directories, or in standard
742 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
743 to understand them. In practice, this means it had better be collect2. */
744 #ifndef LINK_COMMAND_SPEC
745 #define LINK_COMMAND_SPEC "\
746 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
748 %{fuse-linker-plugin: \
749 -plugin %(linker_plugin_file) \
750 -plugin-opt=%(lto_wrapper) \
751 -plugin-opt=-fresolution=%u.res \
752 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
753 %{static:-plugin-opt=-pass-through=-lc} \
755 %{flto:%<fcompare-debug*} %{fwhopr*:%<fcompare-debug*} \
756 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
757 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
758 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
759 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
760 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
761 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
762 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
763 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
766 #ifndef LINK_LIBGCC_SPEC
767 /* Generate -L options for startfile prefix list. */
768 # define LINK_LIBGCC_SPEC "%D"
771 #ifndef STARTFILE_PREFIX_SPEC
772 # define STARTFILE_PREFIX_SPEC ""
776 # define SYSROOT_SPEC "--sysroot=%R"
779 #ifndef SYSROOT_SUFFIX_SPEC
780 # define SYSROOT_SUFFIX_SPEC ""
783 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
784 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
787 static const char *asm_debug
;
788 static const char *cpp_spec
= CPP_SPEC
;
789 static const char *cc1_spec
= CC1_SPEC
;
790 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
791 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
792 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
793 static const char *asm_spec
= ASM_SPEC
;
794 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
795 static const char *link_spec
= LINK_SPEC
;
796 static const char *lib_spec
= LIB_SPEC
;
797 static const char *mfwrap_spec
= MFWRAP_SPEC
;
798 static const char *mflib_spec
= MFLIB_SPEC
;
799 static const char *link_gomp_spec
= "";
800 static const char *libgcc_spec
= LIBGCC_SPEC
;
801 static const char *endfile_spec
= ENDFILE_SPEC
;
802 static const char *startfile_spec
= STARTFILE_SPEC
;
803 static const char *linker_name_spec
= LINKER_NAME
;
804 static const char *linker_plugin_file_spec
= "";
805 static const char *lto_wrapper_spec
= "";
806 static const char *lto_gcc_spec
= "";
807 static const char *lto_libgcc_spec
= "";
808 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
809 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
810 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
811 static const char *sysroot_spec
= SYSROOT_SPEC
;
812 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
813 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
815 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
816 There should be no need to override these in target dependent files,
817 but we need to copy them to the specs file so that newer versions
818 of the GCC driver can correctly drive older tool chains with the
819 appropriate -B options. */
821 /* When cpplib handles traditional preprocessing, get rid of this, and
822 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
823 that we default the front end language better. */
824 static const char *trad_capable_cpp
=
825 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
827 /* We don't wrap .d files in %W{} since a missing .d file, and
828 therefore no dependency entry, confuses make into thinking a .o
829 file that happens to exist is up-to-date. */
830 static const char *cpp_unique_options
=
831 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
832 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
833 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
834 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
835 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
836 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
837 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
838 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
839 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
840 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
843 /* This contains cpp options which are common with cc1_options and are passed
844 only when preprocessing only to avoid duplication. We pass the cc1 spec
845 options to the preprocessor so that it the cc1 spec may manipulate
846 options used to set target flags. Those special target flags settings may
847 in turn cause preprocessor symbols to be defined specially. */
848 static const char *cpp_options
=
849 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
850 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
851 %{undef} %{save-temps*:-fpch-preprocess}";
853 /* This contains cpp options which are not passed when the preprocessor
854 output will be used by another program. */
855 static const char *cpp_debug_options
= "%{d*}";
857 /* NB: This is shared amongst all front-ends, except for Ada. */
858 static const char *cc1_options
=
859 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
860 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
861 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
862 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
863 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
864 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
865 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
866 %{Qn:-fno-ident} %{--help:--help}\
867 %{--target-help:--target-help}\
868 %{--help=*:--help=%(VALUE)}\
869 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
870 %{fsyntax-only:-o %j} %{-param*}\
871 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
872 %{coverage:-fprofile-arcs -ftest-coverage}";
874 static const char *asm_options
=
875 "%{--target-help:%:print-asm-header()} "
877 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
878 to the assembler equivalents. */
879 "%{v} %{w:-W} %{I*} "
881 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
883 static const char *invoke_as
=
884 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
886 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
887 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
891 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
892 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
896 /* Some compilers have limits on line lengths, and the multilib_select
897 and/or multilib_matches strings can be very long, so we build them at
899 static struct obstack multilib_obstack
;
900 static const char *multilib_select
;
901 static const char *multilib_matches
;
902 static const char *multilib_defaults
;
903 static const char *multilib_exclusions
;
905 /* Check whether a particular argument is a default argument. */
907 #ifndef MULTILIB_DEFAULTS
908 #define MULTILIB_DEFAULTS { "" }
911 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
913 #ifndef DRIVER_SELF_SPECS
914 #define DRIVER_SELF_SPECS ""
917 /* Adding -fopenmp should imply pthreads. This is particularly important
918 for targets that use different start files and suchlike. */
919 #ifndef GOMP_SELF_SPECS
920 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
923 static const char *const driver_self_specs
[] = {
924 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
925 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
928 #ifndef OPTION_DEFAULT_SPECS
929 #define OPTION_DEFAULT_SPECS { "", "" }
938 static const struct default_spec
939 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
943 struct user_specs
*next
;
944 const char *filename
;
947 static struct user_specs
*user_specs_head
, *user_specs_tail
;
950 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
951 /* This defines which switches stop a full compilation. */
952 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
953 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
955 #ifndef SWITCH_CURTAILS_COMPILATION
956 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
957 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
961 /* Record the mapping from file suffixes for compilation specs. */
965 const char *suffix
; /* Use this compiler for input files
966 whose names end in this suffix. */
968 const char *spec
; /* To use this compiler, run this spec. */
970 const char *cpp_spec
; /* If non-NULL, substitute this spec
971 for `%C', rather than the usual
973 const int combinable
; /* If nonzero, compiler can deal with
974 multiple source files at once (IMA). */
975 const int needs_preprocessing
; /* If nonzero, source files need to
976 be run through a preprocessor. */
979 /* Pointer to a vector of `struct compiler' that gives the spec for
980 compiling a file, based on its suffix.
981 A file that does not end in any of these suffixes will be passed
982 unchanged to the loader and nothing else will be done to it.
984 An entry containing two 0s is used to terminate the vector.
986 If multiple entries match a file, the last matching one is used. */
988 static struct compiler
*compilers
;
990 /* Number of entries in `compilers', not counting the null terminator. */
992 static int n_compilers
;
994 /* The default list of file name suffixes and their compilation specs. */
996 static const struct compiler default_compilers
[] =
998 /* Add lists of suffixes of known languages here. If those languages
999 were not present when we built the driver, we will hit these copies
1000 and be given a more meaningful error than "file not used since
1001 linking is not done". */
1002 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1003 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1004 {".mii", "#Objective-C++", 0, 0, 0},
1005 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1006 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1007 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1008 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1009 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1010 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1011 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1012 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1013 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1014 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1015 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1016 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1017 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1018 {".r", "#Ratfor", 0, 0, 0},
1019 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1020 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1021 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1022 /* Next come the entries for C. */
1023 {".c", "@c", 0, 1, 1},
1025 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1026 external preprocessor if -save-temps is given. */
1027 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1029 %{traditional|ftraditional:\
1030 %eGNU C no longer supports -traditional without -E}\
1032 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1033 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1034 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1036 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1037 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1038 %{!fsyntax-only:%(invoke_as)}} \
1040 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1041 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1042 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1043 cc1 %(cpp_unique_options) %(cc1_options)}}\
1044 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1046 "%{!E:%e-E or -x required when input is from standard input}\
1047 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1048 {".h", "@c-header", 0, 0, 0},
1050 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1051 external preprocessor if -save-temps is given. */
1052 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1054 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1055 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1056 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1058 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1059 %W{o*:--output-pch=%*}}%V}\
1060 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1061 cc1 %(cpp_unique_options) %(cc1_options)\
1062 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1063 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1064 {".i", "@cpp-output", 0, 1, 0},
1066 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1067 {".s", "@assembler", 0, 1, 0},
1069 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1070 {".sx", "@assembler-with-cpp", 0, 1, 0},
1071 {".S", "@assembler-with-cpp", 0, 1, 0},
1072 {"@assembler-with-cpp",
1073 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1074 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1075 %{E|M|MM:%(cpp_debug_options)}\
1076 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1077 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1079 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1080 %{E|M|MM:%(cpp_debug_options)}\
1081 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1082 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1087 /* Mark end of table. */
1091 /* Number of elements in default_compilers, not counting the terminator. */
1093 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1095 /* A vector of options to give to the linker.
1096 These options are accumulated by %x,
1097 and substituted into the linker command with %X. */
1098 static int n_linker_options
;
1099 static char **linker_options
;
1101 /* A vector of options to give to the assembler.
1102 These options are accumulated by -Wa,
1103 and substituted into the assembler command with %Y. */
1104 static int n_assembler_options
;
1105 static char **assembler_options
;
1107 /* A vector of options to give to the preprocessor.
1108 These options are accumulated by -Wp,
1109 and substituted into the preprocessor command with %Z. */
1110 static int n_preprocessor_options
;
1111 static char **preprocessor_options
;
1113 /* Define how to map long options into short ones. */
1115 /* This structure describes one mapping. */
1118 /* The long option's name. */
1119 const char *const name
;
1120 /* The equivalent short option. */
1121 const char *const equivalent
;
1122 /* Argument info. A string of flag chars; NULL equals no options.
1123 a => argument required.
1124 o => argument optional.
1125 j => join argument to equivalent, making one word.
1126 * => require other text after NAME as an argument. */
1127 const char *const arg_info
;
1130 /* This is the table of mappings. Mappings are tried sequentially
1131 for each option encountered; the first one that matches, wins. */
1133 static const struct option_map option_map
[] =
1135 {"--all-warnings", "-Wall", 0},
1136 {"--ansi", "-ansi", 0},
1137 {"--assemble", "-S", 0},
1138 {"--assert", "-A", "a"},
1139 {"--classpath", "-fclasspath=", "aj"},
1140 {"--bootclasspath", "-fbootclasspath=", "aj"},
1141 {"--CLASSPATH", "-fclasspath=", "aj"},
1142 {"--combine", "-combine", 0},
1143 {"--comments", "-C", 0},
1144 {"--comments-in-macros", "-CC", 0},
1145 {"--compile", "-c", 0},
1146 {"--debug", "-g", "oj"},
1147 {"--define-macro", "-D", "aj"},
1148 {"--dependencies", "-M", 0},
1149 {"--dump", "-d", "a"},
1150 {"--dumpbase", "-dumpbase", "a"},
1151 {"--dumpdir", "-dumpdir", "a"},
1152 {"--encoding", "-fencoding=", "aj"},
1153 {"--entry", "-e", 0},
1154 {"--extra-warnings", "-W", 0},
1155 {"--extdirs", "-fextdirs=", "aj"},
1156 {"--for-assembler", "-Wa", "a"},
1157 {"--for-linker", "-Xlinker", "a"},
1158 {"--force-link", "-u", "a"},
1159 {"--coverage", "-coverage", 0},
1160 {"--imacros", "-imacros", "a"},
1161 {"--include", "-include", "a"},
1162 {"--include-barrier", "-I-", 0},
1163 {"--include-directory", "-I", "aj"},
1164 {"--include-directory-after", "-idirafter", "a"},
1165 {"--include-prefix", "-iprefix", "a"},
1166 {"--include-with-prefix", "-iwithprefix", "a"},
1167 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1168 {"--include-with-prefix-after", "-iwithprefix", "a"},
1169 {"--language", "-x", "a"},
1170 {"--library-directory", "-L", "a"},
1171 {"--machine", "-m", "aj"},
1172 {"--machine-", "-m", "*j"},
1173 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1174 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1175 {"--no-line-commands", "-P", 0},
1176 {"--no-precompiled-includes", "-noprecomp", 0},
1177 {"--no-standard-includes", "-nostdinc", 0},
1178 {"--no-standard-libraries", "-nostdlib", 0},
1179 {"--no-warnings", "-w", 0},
1180 {"--optimize", "-O", "oj"},
1181 {"--output", "-o", "a"},
1182 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1183 {"--param", "--param", "a"},
1184 {"--pass-exit-codes", "-pass-exit-codes", 0},
1185 {"--pedantic", "-pedantic", 0},
1186 {"--pedantic-errors", "-pedantic-errors", 0},
1187 {"--pie", "-pie", 0},
1188 {"--pipe", "-pipe", 0},
1189 {"--prefix", "-B", "a"},
1190 {"--preprocess", "-E", 0},
1191 {"--print-search-dirs", "-print-search-dirs", 0},
1192 {"--print-file-name", "-print-file-name=", "aj"},
1193 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1194 {"--print-missing-file-dependencies", "-MG", 0},
1195 {"--print-multi-lib", "-print-multi-lib", 0},
1196 {"--print-multi-directory", "-print-multi-directory", 0},
1197 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1198 {"--print-prog-name", "-print-prog-name=", "aj"},
1199 {"--print-sysroot", "-print-sysroot", 0},
1200 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1201 {"--profile", "-p", 0},
1202 {"--resource", "-fcompile-resource=", "aj"},
1203 {"--save-temps", "-save-temps", 0},
1204 {"--shared", "-shared", 0},
1205 {"--specs", "-specs=", "aj"},
1206 {"--static", "-static", 0},
1207 {"--std", "-std=", "aj"},
1208 {"--symbolic", "-symbolic", 0},
1209 {"--sysroot", "--sysroot=", "aj"},
1210 {"--time", "-time", 0},
1211 {"--trace-includes", "-H", 0},
1212 {"--traditional", "-traditional", 0},
1213 {"--traditional-cpp", "-traditional-cpp", 0},
1214 {"--trigraphs", "-trigraphs", 0},
1215 {"--undefine-macro", "-U", "aj"},
1216 {"--user-dependencies", "-MM", 0},
1217 {"--verbose", "-v", 0},
1218 {"--warn-", "-W", "*j"},
1219 {"--write-dependencies", "-MD", 0},
1220 {"--write-user-dependencies", "-MMD", 0},
1225 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1226 static const struct {
1227 const char *const option_found
;
1228 const char *const replacements
;
1229 } target_option_translations
[] =
1231 TARGET_OPTION_TRANSLATE_TABLE
,
1236 /* Translate the options described by *ARGCP and *ARGVP.
1237 Make a new vector and store it back in *ARGVP,
1238 and store its length in *ARGCP. */
1241 translate_options (int *argcp
, const char *const **argvp
)
1245 const char *const *argv
= *argvp
;
1246 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1247 const char **newv
= XNEWVAR (const char *, newvsize
);
1251 newv
[newindex
++] = argv
[i
++];
1255 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1259 target_option_translations
[tott_idx
].option_found
;
1262 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1269 for (sp
= target_option_translations
[tott_idx
].replacements
;
1276 newvsize
+= spaces
* sizeof (const char *);
1277 newv
= XRESIZEVAR (const char *, newv
, newvsize
);
1279 sp
= target_option_translations
[tott_idx
].replacements
;
1288 newv
[newindex
++] = np
;
1289 while (*np
!= ' ' && *np
)
1300 if (target_option_translations
[tott_idx
].option_found
)
1304 /* Translate -- options. */
1305 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1308 /* Find a mapping that applies to this option. */
1309 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1311 size_t optlen
= strlen (option_map
[j
].name
);
1312 size_t arglen
= strlen (argv
[i
]);
1313 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1314 const char *arginfo
= option_map
[j
].arg_info
;
1319 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1321 const char *arg
= 0;
1323 if (arglen
< optlen
)
1326 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1327 if (strlen (option_map
[k
].name
) >= arglen
1328 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1330 error ("ambiguous abbreviation %s", argv
[i
]);
1334 if (k
!= ARRAY_SIZE (option_map
))
1338 if (arglen
> optlen
)
1340 /* If the option has an argument, accept that. */
1341 if (argv
[i
][optlen
] == '=')
1342 arg
= argv
[i
] + optlen
+ 1;
1344 /* If this mapping requires extra text at end of name,
1345 accept that as "argument". */
1346 else if (strchr (arginfo
, '*') != 0)
1347 arg
= argv
[i
] + optlen
;
1349 /* Otherwise, extra text at end means mismatch.
1350 Try other mappings. */
1355 else if (strchr (arginfo
, '*') != 0)
1357 error ("incomplete %qs option", option_map
[j
].name
);
1361 /* Handle arguments. */
1362 if (strchr (arginfo
, 'a') != 0)
1368 error ("missing argument to %qs option",
1369 option_map
[j
].name
);
1376 else if (strchr (arginfo
, '*') != 0)
1378 else if (strchr (arginfo
, 'o') == 0)
1381 error ("extraneous argument to %qs option",
1382 option_map
[j
].name
);
1386 /* Store the translation as one argv elt or as two. */
1387 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1388 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1392 newv
[newindex
++] = option_map
[j
].equivalent
;
1393 newv
[newindex
++] = arg
;
1396 newv
[newindex
++] = option_map
[j
].equivalent
;
1404 /* Handle old-fashioned options--just copy them through,
1405 with their arguments. */
1406 else if (argv
[i
][0] == '-')
1408 const char *p
= argv
[i
] + 1;
1412 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1413 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1414 else if (WORD_SWITCH_TAKES_ARG (p
))
1415 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1416 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1419 else if (! strcmp (p
, "Xlinker"))
1421 else if (! strcmp (p
, "Xpreprocessor"))
1423 else if (! strcmp (p
, "Xassembler"))
1426 /* Watch out for an option at the end of the command line that
1427 is missing arguments, and avoid skipping past the end of the
1429 if (nskip
+ i
> argc
)
1434 newv
[newindex
++] = argv
[i
++];
1439 /* Ordinary operands. */
1440 newv
[newindex
++] = argv
[i
++];
1450 skip_whitespace (char *p
)
1454 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1455 be considered whitespace. */
1456 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1458 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1472 /* Structures to keep track of prefixes to try when looking for files. */
1476 const char *prefix
; /* String to prepend to the path. */
1477 struct prefix_list
*next
; /* Next in linked list. */
1478 int require_machine_suffix
; /* Don't use without machine_suffix. */
1479 /* 2 means try both machine_suffix and just_machine_suffix. */
1480 int priority
; /* Sort key - priority within list. */
1481 int os_multilib
; /* 1 if OS multilib scheme should be used,
1482 0 for GCC multilib scheme. */
1487 struct prefix_list
*plist
; /* List of prefixes to try */
1488 int max_len
; /* Max length of a prefix in PLIST */
1489 const char *name
; /* Name of this list (used in config stuff) */
1492 /* List of prefixes to try when looking for executables. */
1494 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1496 /* List of prefixes to try when looking for startup (crt0) files. */
1498 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1500 /* List of prefixes to try when looking for include files. */
1502 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1504 /* Suffix to attach to directories searched for commands.
1505 This looks like `MACHINE/VERSION/'. */
1507 static const char *machine_suffix
= 0;
1509 /* Suffix to attach to directories searched for commands.
1510 This is just `MACHINE/'. */
1512 static const char *just_machine_suffix
= 0;
1514 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1516 static const char *gcc_exec_prefix
;
1518 /* Adjusted value of standard_libexec_prefix. */
1520 static const char *gcc_libexec_prefix
;
1522 /* Default prefixes to attach to command names. */
1524 #ifndef STANDARD_STARTFILE_PREFIX_1
1525 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1527 #ifndef STANDARD_STARTFILE_PREFIX_2
1528 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1531 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1532 #undef MD_EXEC_PREFIX
1533 #undef MD_STARTFILE_PREFIX
1534 #undef MD_STARTFILE_PREFIX_1
1537 /* If no prefixes defined, use the null string, which will disable them. */
1538 #ifndef MD_EXEC_PREFIX
1539 #define MD_EXEC_PREFIX ""
1541 #ifndef MD_STARTFILE_PREFIX
1542 #define MD_STARTFILE_PREFIX ""
1544 #ifndef MD_STARTFILE_PREFIX_1
1545 #define MD_STARTFILE_PREFIX_1 ""
1548 /* These directories are locations set at configure-time based on the
1549 --prefix option provided to configure. Their initializers are
1550 defined in Makefile.in. These paths are not *directly* used when
1551 gcc_exec_prefix is set because, in that case, we know where the
1552 compiler has been installed, and use paths relative to that
1553 location instead. */
1554 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1555 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1556 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1557 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1559 /* For native compilers, these are well-known paths containing
1560 components that may be provided by the system. For cross
1561 compilers, these paths are not used. */
1562 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1563 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1564 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1565 static const char *const standard_startfile_prefix_1
1566 = STANDARD_STARTFILE_PREFIX_1
;
1567 static const char *const standard_startfile_prefix_2
1568 = STANDARD_STARTFILE_PREFIX_2
;
1570 /* A relative path to be used in finding the location of tools
1571 relative to the driver. */
1572 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1574 /* Subdirectory to use for locating libraries. Set by
1575 set_multilib_dir based on the compilation options. */
1577 static const char *multilib_dir
;
1579 /* Subdirectory to use for locating libraries in OS conventions. Set by
1580 set_multilib_dir based on the compilation options. */
1582 static const char *multilib_os_dir
;
1584 /* Structure to keep track of the specs that have been defined so far.
1585 These are accessed using %(specname) or %[specname] in a compiler
1590 /* The following 2 fields must be first */
1591 /* to allow EXTRA_SPECS to be initialized */
1592 const char *name
; /* name of the spec. */
1593 const char *ptr
; /* available ptr if no static pointer */
1595 /* The following fields are not initialized */
1596 /* by EXTRA_SPECS */
1597 const char **ptr_spec
; /* pointer to the spec itself. */
1598 struct spec_list
*next
; /* Next spec in linked list. */
1599 int name_len
; /* length of the name */
1600 int alloc_p
; /* whether string was allocated */
1603 #define INIT_STATIC_SPEC(NAME,PTR) \
1604 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1606 /* List of statically defined specs. */
1607 static struct spec_list static_specs
[] =
1609 INIT_STATIC_SPEC ("asm", &asm_spec
),
1610 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1611 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1612 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1613 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1614 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1615 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1616 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1617 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1618 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1619 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1620 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1621 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1622 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1623 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1624 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1625 INIT_STATIC_SPEC ("link", &link_spec
),
1626 INIT_STATIC_SPEC ("lib", &lib_spec
),
1627 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1628 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1629 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1630 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1631 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1632 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1633 INIT_STATIC_SPEC ("version", &compiler_version
),
1634 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1635 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1636 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1637 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1638 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1639 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1640 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1641 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1642 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1643 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1644 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec
),
1645 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1646 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1647 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1648 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1649 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1650 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1651 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1652 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1655 #ifdef EXTRA_SPECS /* additional specs needed */
1656 /* Structure to keep track of just the first two args of a spec_list.
1657 That is all that the EXTRA_SPECS macro gives us. */
1660 const char *const name
;
1661 const char *const ptr
;
1664 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1665 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1668 /* List of dynamically allocates specs that have been defined so far. */
1670 static struct spec_list
*specs
= (struct spec_list
*) 0;
1672 /* List of static spec functions. */
1674 static const struct spec_function static_spec_functions
[] =
1676 { "getenv", getenv_spec_function
},
1677 { "if-exists", if_exists_spec_function
},
1678 { "if-exists-else", if_exists_else_spec_function
},
1679 { "replace-outfile", replace_outfile_spec_function
},
1680 { "version-compare", version_compare_spec_function
},
1681 { "include", include_spec_function
},
1682 { "find-file", find_file_spec_function
},
1683 { "find-plugindir", find_plugindir_spec_function
},
1684 { "print-asm-header", print_asm_header_spec_function
},
1685 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1686 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1687 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1688 #ifdef EXTRA_SPEC_FUNCTIONS
1689 EXTRA_SPEC_FUNCTIONS
1694 static int processing_spec_function
;
1696 /* Add appropriate libgcc specs to OBSTACK, taking into account
1697 various permutations of -shared-libgcc, -shared, and such. */
1699 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1701 #ifndef USE_LD_AS_NEEDED
1702 #define USE_LD_AS_NEEDED 0
1706 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1707 const char *static_name
, const char *eh_name
)
1711 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1712 "%{!static:%{!static-libgcc:"
1713 #if USE_LD_AS_NEEDED
1714 "%{!shared-libgcc:",
1715 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1718 shared_name
, "%{!shared: ", static_name
, "}"
1722 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1723 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1727 "%{shared-libgcc:", shared_name
, "}"
1728 "%{!shared-libgcc:", static_name
, "}"
1731 "%{shared:", shared_name
, "}"
1736 obstack_grow (obstack
, buf
, strlen (buf
));
1739 #endif /* ENABLE_SHARED_LIBGCC */
1741 /* Initialize the specs lookup routines. */
1746 struct spec_list
*next
= (struct spec_list
*) 0;
1747 struct spec_list
*sl
= (struct spec_list
*) 0;
1751 return; /* Already initialized. */
1754 fnotice (stderr
, "Using built-in specs.\n");
1757 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1759 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1761 sl
= &extra_specs
[i
];
1762 sl
->name
= extra_specs_1
[i
].name
;
1763 sl
->ptr
= extra_specs_1
[i
].ptr
;
1765 sl
->name_len
= strlen (sl
->name
);
1766 sl
->ptr_spec
= &sl
->ptr
;
1771 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1773 sl
= &static_specs
[i
];
1778 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1779 /* ??? If neither -shared-libgcc nor --static-libgcc was
1780 seen, then we should be making an educated guess. Some proposed
1781 heuristics for ELF include:
1783 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1784 program will be doing dynamic loading, which will likely
1785 need the shared libgcc.
1787 (2) If "-ldl", then it's also a fair bet that we're doing
1790 (3) For each ET_DYN we're linking against (either through -lfoo
1791 or /some/path/foo.so), check to see whether it or one of
1792 its dependencies depends on a shared libgcc.
1796 If the runtime is fixed to look for program headers instead
1797 of calling __register_frame_info at all, for each object,
1798 use the shared libgcc if any EH symbol referenced.
1800 If crtstuff is fixed to not invoke __register_frame_info
1801 automatically, for each object, use the shared libgcc if
1802 any non-empty unwind section found.
1804 Doing any of this probably requires invoking an external program to
1805 do the actual object file scanning. */
1807 const char *p
= libgcc_spec
;
1810 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1811 when given the proper command line arguments. */
1814 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1816 init_gcc_specs (&obstack
,
1818 #ifdef USE_LIBUNWIND_EXCEPTIONS
1824 #ifdef USE_LIBUNWIND_EXCEPTIONS
1825 # ifdef HAVE_LD_STATIC_DYNAMIC
1826 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1836 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1838 /* Ug. We don't know shared library extensions. Hope that
1839 systems that use this form don't do shared libraries. */
1840 init_gcc_specs (&obstack
,
1844 #ifdef USE_LIBUNWIND_EXCEPTIONS
1853 obstack_1grow (&obstack
, *p
);
1854 in_sep
= (*p
== ' ');
1859 obstack_1grow (&obstack
, '\0');
1860 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1863 #ifdef USE_AS_TRADITIONAL_FORMAT
1864 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1866 static const char tf
[] = "--traditional-format ";
1867 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1868 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1869 asm_spec
= XOBFINISH (&obstack
, const char *);
1873 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1874 # ifdef LINK_BUILDID_SPEC
1875 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1876 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1878 # ifdef LINK_EH_SPEC
1879 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1880 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1882 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1883 link_spec
= XOBFINISH (&obstack
, const char *);
1889 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1890 removed; If the spec starts with a + then SPEC is added to the end of the
1894 set_spec (const char *name
, const char *spec
)
1896 struct spec_list
*sl
;
1897 const char *old_spec
;
1898 int name_len
= strlen (name
);
1901 /* If this is the first call, initialize the statically allocated specs. */
1904 struct spec_list
*next
= (struct spec_list
*) 0;
1905 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1907 sl
= &static_specs
[i
];
1914 /* See if the spec already exists. */
1915 for (sl
= specs
; sl
; sl
= sl
->next
)
1916 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1921 /* Not found - make it. */
1922 sl
= XNEW (struct spec_list
);
1923 sl
->name
= xstrdup (name
);
1924 sl
->name_len
= name_len
;
1925 sl
->ptr_spec
= &sl
->ptr
;
1927 *(sl
->ptr_spec
) = "";
1932 old_spec
= *(sl
->ptr_spec
);
1933 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1934 ? concat (old_spec
, spec
+ 1, NULL
)
1939 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1942 /* Free the old spec. */
1943 if (old_spec
&& sl
->alloc_p
)
1944 free (CONST_CAST(char *, old_spec
));
1949 /* Accumulate a command (program name and args), and run it. */
1951 /* Vector of pointers to arguments in the current line of specifications. */
1953 static const char **argbuf
;
1955 /* Number of elements allocated in argbuf. */
1957 static int argbuf_length
;
1959 /* Number of elements in argbuf currently in use (containing args). */
1961 static int argbuf_index
;
1963 /* Position in the argbuf array containing the name of the output file
1964 (the value associated with the "-o" flag). */
1966 static int have_o_argbuf_index
= 0;
1968 /* Were the options -c, -S or -E passed. */
1969 static int have_c
= 0;
1971 /* Was the option -o passed. */
1972 static int have_o
= 0;
1974 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1975 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1978 static struct temp_name
{
1979 const char *suffix
; /* suffix associated with the code. */
1980 int length
; /* strlen (suffix). */
1981 int unique
; /* Indicates whether %g or %u/%U was used. */
1982 const char *filename
; /* associated filename. */
1983 int filename_length
; /* strlen (filename). */
1984 struct temp_name
*next
;
1987 /* Number of commands executed so far. */
1989 static int execution_count
;
1991 /* Number of commands that exited with a signal. */
1993 static int signal_count
;
1995 /* Allocate the argument vector. */
2001 argbuf
= XNEWVEC (const char *, argbuf_length
);
2004 /* Clear out the vector of arguments (after a command is executed). */
2012 /* Add one argument to the vector at the end.
2013 This is done when a space is seen or at the end of the line.
2014 If DELETE_ALWAYS is nonzero, the arg is a filename
2015 and the file should be deleted eventually.
2016 If DELETE_FAILURE is nonzero, the arg is a filename
2017 and the file should be deleted if this compilation fails. */
2020 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2022 if (argbuf_index
+ 1 == argbuf_length
)
2023 argbuf
= XRESIZEVEC (const char *, argbuf
, (argbuf_length
*= 2));
2025 argbuf
[argbuf_index
++] = arg
;
2026 argbuf
[argbuf_index
] = 0;
2028 if (strcmp (arg
, "-o") == 0)
2029 have_o_argbuf_index
= argbuf_index
;
2030 if (delete_always
|| delete_failure
)
2033 /* If the temporary file we should delete is specified as
2034 part of a joined argument extract the filename. */
2036 && (p
= strrchr (arg
, '=')))
2038 record_temp_file (arg
, delete_always
, delete_failure
);
2042 /* Load specs from a file name named FILENAME, replacing occurrences of
2043 various different types of line-endings, \r\n, \n\r and just \r, with
2047 load_specs (const char *filename
)
2051 struct stat statbuf
;
2058 fnotice (stderr
, "Reading specs from %s\n", filename
);
2060 /* Open and stat the file. */
2061 desc
= open (filename
, O_RDONLY
, 0);
2063 pfatal_with_name (filename
);
2064 if (stat (filename
, &statbuf
) < 0)
2065 pfatal_with_name (filename
);
2067 /* Read contents of file into BUFFER. */
2068 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2069 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2071 pfatal_with_name (filename
);
2072 buffer
[readlen
] = 0;
2075 specs
= XNEWVEC (char, readlen
+ 1);
2077 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2083 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2085 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2099 /* Read compilation specs from a file named FILENAME,
2100 replacing the default ones.
2102 A suffix which starts with `*' is a definition for
2103 one of the machine-specific sub-specs. The "suffix" should be
2104 *asm, *cc1, *cpp, *link, *startfile, etc.
2105 The corresponding spec is stored in asm_spec, etc.,
2106 rather than in the `compilers' vector.
2108 Anything invalid in the file is a fatal error. */
2111 read_specs (const char *filename
, int main_p
)
2116 buffer
= load_specs (filename
);
2118 /* Scan BUFFER for specs, putting them in the vector. */
2124 char *in
, *out
, *p1
, *p2
, *p3
;
2126 /* Advance P in BUFFER to the next nonblank nocomment line. */
2127 p
= skip_whitespace (p
);
2131 /* Is this a special command that starts with '%'? */
2132 /* Don't allow this for the main specs file, since it would
2133 encourage people to overwrite it. */
2134 if (*p
== '%' && !main_p
)
2137 while (*p
&& *p
!= '\n')
2143 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2144 && (p1
[sizeof "%include" - 1] == ' '
2145 || p1
[sizeof "%include" - 1] == '\t'))
2149 p1
+= sizeof ("%include");
2150 while (*p1
== ' ' || *p1
== '\t')
2153 if (*p1
++ != '<' || p
[-2] != '>')
2154 fatal_error ("specs %%include syntax malformed after "
2156 (long) (p1
- buffer
+ 1));
2159 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2160 read_specs (new_filename
? new_filename
: p1
, FALSE
);
2163 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2164 && (p1
[sizeof "%include_noerr" - 1] == ' '
2165 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2169 p1
+= sizeof "%include_noerr";
2170 while (*p1
== ' ' || *p1
== '\t')
2173 if (*p1
++ != '<' || p
[-2] != '>')
2174 fatal_error ("specs %%include syntax malformed after "
2176 (long) (p1
- buffer
+ 1));
2179 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2181 read_specs (new_filename
, FALSE
);
2182 else if (verbose_flag
)
2183 fnotice (stderr
, "could not find specs file %s\n", p1
);
2186 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2187 && (p1
[sizeof "%rename" - 1] == ' '
2188 || p1
[sizeof "%rename" - 1] == '\t'))
2191 struct spec_list
*sl
;
2192 struct spec_list
*newsl
;
2194 /* Get original name. */
2195 p1
+= sizeof "%rename";
2196 while (*p1
== ' ' || *p1
== '\t')
2199 if (! ISALPHA ((unsigned char) *p1
))
2200 fatal_error ("specs %%rename syntax malformed after "
2202 (long) (p1
- buffer
));
2205 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2208 if (*p2
!= ' ' && *p2
!= '\t')
2209 fatal_error ("specs %%rename syntax malformed after "
2211 (long) (p2
- buffer
));
2215 while (*p2
== ' ' || *p2
== '\t')
2218 if (! ISALPHA ((unsigned char) *p2
))
2219 fatal_error ("specs %%rename syntax malformed after "
2221 (long) (p2
- buffer
));
2223 /* Get new spec name. */
2225 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2229 fatal_error ("specs %%rename syntax malformed after "
2231 (long) (p3
- buffer
));
2234 for (sl
= specs
; sl
; sl
= sl
->next
)
2235 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2239 fatal_error ("specs %s spec was not found to be renamed", p1
);
2241 if (strcmp (p1
, p2
) == 0)
2244 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2245 if (strcmp (newsl
->name
, p2
) == 0)
2246 fatal_error ("%s: attempt to rename spec %qs to "
2247 "already defined spec %qs",
2252 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2254 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2258 set_spec (p2
, *(sl
->ptr_spec
));
2260 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2262 *(sl
->ptr_spec
) = "";
2267 fatal_error ("specs unknown %% command after %ld characters",
2268 (long) (p1
- buffer
));
2271 /* Find the colon that should end the suffix. */
2273 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2276 /* The colon shouldn't be missing. */
2278 fatal_error ("specs file malformed after %ld characters",
2279 (long) (p1
- buffer
));
2281 /* Skip back over trailing whitespace. */
2283 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2286 /* Copy the suffix to a string. */
2287 suffix
= save_string (p
, p2
- p
);
2288 /* Find the next line. */
2289 p
= skip_whitespace (p1
+ 1);
2291 fatal_error ("specs file malformed after %ld characters",
2292 (long) (p
- buffer
));
2295 /* Find next blank line or end of string. */
2296 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2299 /* Specs end at the blank line and do not include the newline. */
2300 spec
= save_string (p
, p1
- p
);
2303 /* Delete backslash-newline sequences from the spec. */
2308 if (in
[0] == '\\' && in
[1] == '\n')
2310 else if (in
[0] == '#')
2311 while (*in
&& *in
!= '\n')
2319 if (suffix
[0] == '*')
2321 if (! strcmp (suffix
, "*link_command"))
2322 link_command_spec
= spec
;
2324 set_spec (suffix
+ 1, spec
);
2328 /* Add this pair to the vector. */
2330 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2332 compilers
[n_compilers
].suffix
= suffix
;
2333 compilers
[n_compilers
].spec
= spec
;
2335 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2339 link_command_spec
= spec
;
2342 if (link_command_spec
== 0)
2343 fatal_error ("spec file has no spec for linking");
2346 /* Record the names of temporary files we tell compilers to write,
2347 and delete them at the end of the run. */
2349 /* This is the common prefix we use to make temp file names.
2350 It is chosen once for each run of this program.
2351 It is substituted into a spec by %g or %j.
2352 Thus, all temp file names contain this prefix.
2353 In practice, all temp file names start with this prefix.
2355 This prefix comes from the envvar TMPDIR if it is defined;
2356 otherwise, from the P_tmpdir macro if that is defined;
2357 otherwise, in /usr/tmp or /tmp;
2358 or finally the current directory if all else fails. */
2360 static const char *temp_filename
;
2362 /* Length of the prefix. */
2364 static int temp_filename_length
;
2366 /* Define the list of temporary files to delete. */
2371 struct temp_file
*next
;
2374 /* Queue of files to delete on success or failure of compilation. */
2375 static struct temp_file
*always_delete_queue
;
2376 /* Queue of files to delete on failure of compilation. */
2377 static struct temp_file
*failure_delete_queue
;
2379 /* Record FILENAME as a file to be deleted automatically.
2380 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2381 otherwise delete it in any case.
2382 FAIL_DELETE nonzero means delete it if a compilation step fails;
2383 otherwise delete it in any case. */
2386 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2388 char *const name
= xstrdup (filename
);
2392 struct temp_file
*temp
;
2393 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2394 if (! strcmp (name
, temp
->name
))
2397 temp
= XNEW (struct temp_file
);
2398 temp
->next
= always_delete_queue
;
2400 always_delete_queue
= temp
;
2407 struct temp_file
*temp
;
2408 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2409 if (! strcmp (name
, temp
->name
))
2412 temp
= XNEW (struct temp_file
);
2413 temp
->next
= failure_delete_queue
;
2415 failure_delete_queue
= temp
;
2421 /* Delete all the temporary files whose names we previously recorded. */
2423 #ifndef DELETE_IF_ORDINARY
2424 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2427 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2428 if (unlink (NAME) < 0) \
2430 perror_with_name (NAME); \
2435 delete_if_ordinary (const char *name
)
2441 printf ("Delete %s? (y or n) ", name
);
2445 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2448 if (i
== 'y' || i
== 'Y')
2450 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2454 delete_temp_files (void)
2456 struct temp_file
*temp
;
2458 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2459 delete_if_ordinary (temp
->name
);
2460 always_delete_queue
= 0;
2463 /* Delete all the files to be deleted on error. */
2466 delete_failure_queue (void)
2468 struct temp_file
*temp
;
2470 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2471 delete_if_ordinary (temp
->name
);
2475 clear_failure_queue (void)
2477 failure_delete_queue
= 0;
2480 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2482 If DO_MULTI is true iterate over the paths twice, first with multilib
2483 suffix then without, otherwise iterate over the paths once without
2484 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2485 to avoid visiting the same path twice, but we could do better. For
2486 instance, /usr/lib/../lib is considered different from /usr/lib.
2487 At least EXTRA_SPACE chars past the end of the path passed to
2488 CALLBACK are available for use by the callback.
2489 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2491 Returns the value returned by CALLBACK. */
2494 for_each_path (const struct path_prefix
*paths
,
2497 void *(*callback
) (char *, void *),
2498 void *callback_info
)
2500 struct prefix_list
*pl
;
2501 const char *multi_dir
= NULL
;
2502 const char *multi_os_dir
= NULL
;
2503 const char *multi_suffix
;
2504 const char *just_multi_suffix
;
2507 bool skip_multi_dir
= false;
2508 bool skip_multi_os_dir
= false;
2510 multi_suffix
= machine_suffix
;
2511 just_multi_suffix
= just_machine_suffix
;
2512 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2514 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2515 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2516 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2518 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2519 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2523 size_t multi_dir_len
= 0;
2524 size_t multi_os_dir_len
= 0;
2526 size_t just_suffix_len
;
2530 multi_dir_len
= strlen (multi_dir
);
2532 multi_os_dir_len
= strlen (multi_os_dir
);
2533 suffix_len
= strlen (multi_suffix
);
2534 just_suffix_len
= strlen (just_multi_suffix
);
2538 len
= paths
->max_len
+ extra_space
+ 1;
2539 if (suffix_len
> multi_os_dir_len
)
2542 len
+= multi_os_dir_len
;
2543 path
= XNEWVEC (char, len
);
2546 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2548 len
= strlen (pl
->prefix
);
2549 memcpy (path
, pl
->prefix
, len
);
2551 /* Look first in MACHINE/VERSION subdirectory. */
2552 if (!skip_multi_dir
)
2554 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2555 ret
= callback (path
, callback_info
);
2560 /* Some paths are tried with just the machine (ie. target)
2561 subdir. This is used for finding as, ld, etc. */
2563 && pl
->require_machine_suffix
== 2)
2565 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2566 ret
= callback (path
, callback_info
);
2571 /* Now try the base path. */
2572 if (!pl
->require_machine_suffix
2573 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2575 const char *this_multi
;
2576 size_t this_multi_len
;
2578 if (pl
->os_multilib
)
2580 this_multi
= multi_os_dir
;
2581 this_multi_len
= multi_os_dir_len
;
2585 this_multi
= multi_dir
;
2586 this_multi_len
= multi_dir_len
;
2590 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2594 ret
= callback (path
, callback_info
);
2602 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2605 /* Run through the paths again, this time without multilibs.
2606 Don't repeat any we have already seen. */
2609 free (CONST_CAST (char *, multi_dir
));
2611 free (CONST_CAST (char *, multi_suffix
));
2612 multi_suffix
= machine_suffix
;
2613 free (CONST_CAST (char *, just_multi_suffix
));
2614 just_multi_suffix
= just_machine_suffix
;
2617 skip_multi_dir
= true;
2620 free (CONST_CAST (char *, multi_os_dir
));
2621 multi_os_dir
= NULL
;
2624 skip_multi_os_dir
= true;
2629 free (CONST_CAST (char *, multi_dir
));
2630 free (CONST_CAST (char *, multi_suffix
));
2631 free (CONST_CAST (char *, just_multi_suffix
));
2634 free (CONST_CAST (char *, multi_os_dir
));
2640 /* Callback for build_search_list. Adds path to obstack being built. */
2642 struct add_to_obstack_info
{
2649 add_to_obstack (char *path
, void *data
)
2651 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2653 if (info
->check_dir
&& !is_directory (path
, false))
2656 if (!info
->first_time
)
2657 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2659 obstack_grow (info
->ob
, path
, strlen (path
));
2661 info
->first_time
= false;
2665 /* Add or change the value of an environment variable, outputting the
2666 change to standard error if in verbose mode. */
2668 xputenv (const char *string
)
2671 fnotice (stderr
, "%s\n", string
);
2672 putenv (CONST_CAST (char *, string
));
2675 /* Build a list of search directories from PATHS.
2676 PREFIX is a string to prepend to the list.
2677 If CHECK_DIR_P is true we ensure the directory exists.
2678 If DO_MULTI is true, multilib paths are output first, then
2680 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2681 It is also used by the --print-search-dirs flag. */
2684 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2685 bool check_dir
, bool do_multi
)
2687 struct add_to_obstack_info info
;
2689 info
.ob
= &collect_obstack
;
2690 info
.check_dir
= check_dir
;
2691 info
.first_time
= true;
2693 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2694 obstack_1grow (&collect_obstack
, '=');
2696 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2698 obstack_1grow (&collect_obstack
, '\0');
2699 return XOBFINISH (&collect_obstack
, char *);
2702 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2706 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2709 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2712 /* Check whether NAME can be accessed in MODE. This is like access,
2713 except that it never considers directories to be executable. */
2716 access_check (const char *name
, int mode
)
2722 if (stat (name
, &st
) < 0
2723 || S_ISDIR (st
.st_mode
))
2727 return access (name
, mode
);
2730 /* Callback for find_a_file. Appends the file name to the directory
2731 path. If the resulting file exists in the right mode, return the
2732 full pathname to the file. */
2734 struct file_at_path_info
{
2743 file_at_path (char *path
, void *data
)
2745 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2746 size_t len
= strlen (path
);
2748 memcpy (path
+ len
, info
->name
, info
->name_len
);
2749 len
+= info
->name_len
;
2751 /* Some systems have a suffix for executable files.
2752 So try appending that first. */
2753 if (info
->suffix_len
)
2755 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2756 if (access_check (path
, info
->mode
) == 0)
2761 if (access_check (path
, info
->mode
) == 0)
2767 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2768 access to check permissions. If DO_MULTI is true, search multilib
2769 paths then non-multilib paths, otherwise do not search multilib paths.
2770 Return 0 if not found, otherwise return its name, allocated with malloc. */
2773 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2776 struct file_at_path_info info
;
2778 #ifdef DEFAULT_ASSEMBLER
2779 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2780 return xstrdup (DEFAULT_ASSEMBLER
);
2783 #ifdef DEFAULT_LINKER
2784 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2785 return xstrdup (DEFAULT_LINKER
);
2788 /* Determine the filename to execute (special case for absolute paths). */
2790 if (IS_ABSOLUTE_PATH (name
))
2792 if (access (name
, mode
) == 0)
2793 return xstrdup (name
);
2799 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2800 info
.name_len
= strlen (info
.name
);
2801 info
.suffix_len
= strlen (info
.suffix
);
2804 return (char*) for_each_path (pprefix
, do_multi
,
2805 info
.name_len
+ info
.suffix_len
,
2806 file_at_path
, &info
);
2809 /* Ranking of prefixes in the sort list. -B prefixes are put before
2812 enum path_prefix_priority
2814 PREFIX_PRIORITY_B_OPT
,
2815 PREFIX_PRIORITY_LAST
2818 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2819 order according to PRIORITY. Within each PRIORITY, new entries are
2822 If WARN is nonzero, we will warn if no file is found
2823 through this prefix. WARN should point to an int
2824 which will be set to 1 if this entry is used.
2826 COMPONENT is the value to be passed to update_path.
2828 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2829 the complete value of machine_suffix.
2830 2 means try both machine_suffix and just_machine_suffix. */
2833 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2834 const char *component
, /* enum prefix_priority */ int priority
,
2835 int require_machine_suffix
, int os_multilib
)
2837 struct prefix_list
*pl
, **prev
;
2840 for (prev
= &pprefix
->plist
;
2841 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2842 prev
= &(*prev
)->next
)
2845 /* Keep track of the longest prefix. */
2847 prefix
= update_path (prefix
, component
);
2848 len
= strlen (prefix
);
2849 if (len
> pprefix
->max_len
)
2850 pprefix
->max_len
= len
;
2852 pl
= XNEW (struct prefix_list
);
2853 pl
->prefix
= prefix
;
2854 pl
->require_machine_suffix
= require_machine_suffix
;
2855 pl
->priority
= priority
;
2856 pl
->os_multilib
= os_multilib
;
2858 /* Insert after PREV. */
2863 /* Same as add_prefix, but prepending target_system_root to prefix. */
2864 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2866 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2867 const char *component
,
2868 /* enum prefix_priority */ int priority
,
2869 int require_machine_suffix
, int os_multilib
)
2871 if (!IS_ABSOLUTE_PATH (prefix
))
2872 fatal_error ("system path %qs is not absolute", prefix
);
2874 if (target_system_root
)
2876 if (target_sysroot_suffix
)
2877 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2878 prefix
= concat (target_system_root
, prefix
, NULL
);
2880 /* We have to override this because GCC's notion of sysroot
2881 moves along with GCC. */
2885 add_prefix (pprefix
, prefix
, component
, priority
,
2886 require_machine_suffix
, os_multilib
);
2889 /* Execute the command specified by the arguments on the current line of spec.
2890 When using pipes, this includes several piped-together commands
2891 with `|' between them.
2893 Return 0 if successful, -1 if failed. */
2899 int n_commands
; /* # of command. */
2901 struct pex_obj
*pex
;
2904 const char *prog
; /* program name. */
2905 const char **argv
; /* vector of args. */
2908 struct command
*commands
; /* each command buffer with above info. */
2910 gcc_assert (!processing_spec_function
);
2914 string
= find_a_file (&exec_prefixes
, argbuf
[0], X_OK
, false);
2915 argbuf
[0] = (string
) ? string
: argbuf
[0];
2916 insert_wrapper (wrapper_string
);
2919 /* Count # of piped commands. */
2920 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2921 if (strcmp (argbuf
[i
], "|") == 0)
2924 /* Get storage for each command. */
2925 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2927 /* Split argbuf into its separate piped processes,
2928 and record info about each one.
2929 Also search for the programs that are to be run. */
2931 commands
[0].prog
= argbuf
[0]; /* first command. */
2932 commands
[0].argv
= &argbuf
[0];
2934 if (!wrapper_string
)
2936 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2937 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2940 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2941 if (strcmp (argbuf
[i
], "|") == 0)
2942 { /* each command. */
2943 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2944 fatal_error ("-pipe not supported");
2946 argbuf
[i
] = 0; /* termination of command args. */
2947 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2948 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2949 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2952 commands
[n_commands
].argv
[0] = string
;
2956 argbuf
[argbuf_index
] = 0;
2958 /* If -v, print what we are about to do, and maybe query. */
2962 /* For help listings, put a blank line between sub-processes. */
2963 if (print_help_list
)
2964 fputc ('\n', stderr
);
2966 /* Print each piped command as a separate line. */
2967 for (i
= 0; i
< n_commands
; i
++)
2969 const char *const *j
;
2971 if (verbose_only_flag
)
2973 for (j
= commands
[i
].argv
; *j
; j
++)
2976 for (p
= *j
; *p
; ++p
)
2977 if (!ISALNUM ((unsigned char) *p
)
2978 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2982 fprintf (stderr
, " \"");
2983 for (p
= *j
; *p
; ++p
)
2985 if (*p
== '"' || *p
== '\\' || *p
== '$')
2986 fputc ('\\', stderr
);
2989 fputc ('"', stderr
);
2992 fprintf (stderr
, " %s", *j
);
2996 for (j
= commands
[i
].argv
; *j
; j
++)
2997 fprintf (stderr
, " %s", *j
);
2999 /* Print a pipe symbol after all but the last command. */
3000 if (i
+ 1 != n_commands
)
3001 fprintf (stderr
, " |");
3002 fprintf (stderr
, "\n");
3005 if (verbose_only_flag
!= 0)
3007 /* verbose_only_flag should act as if the spec was
3008 executed, so increment execution_count before
3009 returning. This prevents spurious warnings about
3010 unused linker input files, etc. */
3015 fnotice (stderr
, "\nGo ahead? (y or n) ");
3019 while (getchar () != '\n')
3022 if (i
!= 'y' && i
!= 'Y')
3027 #ifdef ENABLE_VALGRIND_CHECKING
3028 /* Run the each command through valgrind. To simplify prepending the
3029 path to valgrind and the option "-q" (for quiet operation unless
3030 something triggers), we allocate a separate argv array. */
3032 for (i
= 0; i
< n_commands
; i
++)
3038 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3041 argv
= XALLOCAVEC (const char *, argc
+ 3);
3043 argv
[0] = VALGRIND_PATH
;
3045 for (j
= 2; j
< argc
+ 2; j
++)
3046 argv
[j
] = commands
[i
].argv
[j
- 2];
3049 commands
[i
].argv
= argv
;
3050 commands
[i
].prog
= argv
[0];
3054 /* Run each piped subprocess. */
3056 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3057 ? PEX_RECORD_TIMES
: 0),
3058 progname
, temp_filename
);
3060 fatal_error ("pex_init failed: %m");
3062 for (i
= 0; i
< n_commands
; i
++)
3066 const char *string
= commands
[i
].argv
[0];
3068 errmsg
= pex_run (pex
,
3069 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3070 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3071 string
, CONST_CAST (char **, commands
[i
].argv
),
3076 fatal_error (errmsg
);
3080 pfatal_with_name (errmsg
);
3084 if (string
!= commands
[i
].prog
)
3085 free (CONST_CAST (char *, string
));
3090 /* Wait for all the subprocesses to finish. */
3094 struct pex_time
*times
= NULL
;
3097 statuses
= (int *) alloca (n_commands
* sizeof (int));
3098 if (!pex_get_status (pex
, n_commands
, statuses
))
3099 fatal_error ("failed to get exit status: %m");
3101 if (report_times
|| report_times_to_file
)
3103 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3104 if (!pex_get_times (pex
, n_commands
, times
))
3105 fatal_error ("failed to get process times: %m");
3110 for (i
= 0; i
< n_commands
; ++i
)
3112 int status
= statuses
[i
];
3114 if (WIFSIGNALED (status
))
3117 /* SIGPIPE is a special case. It happens in -pipe mode
3118 when the compiler dies before the preprocessor is done,
3119 or the assembler dies before the compiler is done.
3120 There's generally been an error already, and this is
3121 just fallout. So don't generate another error unless
3122 we would otherwise have succeeded. */
3123 if (WTERMSIG (status
) == SIGPIPE
3124 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3131 internal_error ("%s (program %s)",
3132 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
3134 else if (WIFEXITED (status
)
3135 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3137 if (WEXITSTATUS (status
) > greatest_status
)
3138 greatest_status
= WEXITSTATUS (status
);
3142 if (report_times
|| report_times_to_file
)
3144 struct pex_time
*pt
= ×
[i
];
3147 ut
= ((double) pt
->user_seconds
3148 + (double) pt
->user_microseconds
/ 1.0e6
);
3149 st
= ((double) pt
->system_seconds
3150 + (double) pt
->system_microseconds
/ 1.0e6
);
3155 fnotice (stderr
, "# %s %.2f %.2f\n",
3156 commands
[i
].prog
, ut
, st
);
3158 if (report_times_to_file
)
3161 const char *const *j
;
3163 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3165 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3168 for (p
= *j
; *p
; ++p
)
3169 if (*p
== '"' || *p
== '\\' || *p
== '$'
3175 fprintf (report_times_to_file
, " \"");
3176 for (p
= *j
; *p
; ++p
)
3178 if (*p
== '"' || *p
== '\\' || *p
== '$')
3179 fputc ('\\', report_times_to_file
);
3180 fputc (*p
, report_times_to_file
);
3182 fputc ('"', report_times_to_file
);
3185 fprintf (report_times_to_file
, " %s", *j
);
3188 fputc ('\n', report_times_to_file
);
3198 /* Find all the switches given to us
3199 and make a vector describing them.
3200 The elements of the vector are strings, one per switch given.
3201 If a switch uses following arguments, then the `part1' field
3202 is the switch itself and the `args' field
3203 is a null-terminated vector containing the following arguments.
3204 Bits in the `live_cond' field are:
3205 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3206 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3207 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3208 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3209 in all do_spec calls afterwards. Used for %<S from self specs.
3210 The `validated' field is nonzero if any spec has looked at this switch;
3211 if it remains zero at the end of the run, it must be meaningless. */
3213 #define SWITCH_LIVE 0x1
3214 #define SWITCH_FALSE 0x2
3215 #define SWITCH_IGNORE 0x4
3216 #define SWITCH_IGNORE_PERMANENTLY 0x8
3222 unsigned int live_cond
;
3223 unsigned char validated
;
3224 unsigned char ordering
;
3227 static struct switchstr
*switches
;
3229 static int n_switches
;
3231 static int n_switches_alloc
;
3233 /* Set to zero if -fcompare-debug is disabled, positive if it's
3234 enabled and we're running the first compilation, negative if it's
3235 enabled and we're running the second compilation. For most of the
3236 time, it's in the range -1..1, but it can be temporarily set to 2
3237 or 3 to indicate that the -fcompare-debug flags didn't come from
3238 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3239 variable, until a synthesized -fcompare-debug flag is added to the
3243 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3244 int compare_debug_second
;
3246 /* Set to the flags that should be passed to the second compilation in
3247 a -fcompare-debug compilation. */
3248 const char *compare_debug_opt
;
3250 static struct switchstr
*switches_debug_check
[2];
3252 static int n_switches_debug_check
[2];
3254 static char *debug_check_temp_file
[2];
3256 /* Language is one of three things:
3258 1) The name of a real programming language.
3259 2) NULL, indicating that no one has figured out
3261 3) '*', indicating that the file should be passed
3266 const char *language
;
3267 struct compiler
*incompiler
;
3272 /* Also a vector of input files specified. */
3274 static struct infile
*infiles
;
3278 static int n_infiles_alloc
;
3280 /* True if multiple input files are being compiled to a single
3283 static bool combine_inputs
;
3285 /* This counts the number of libraries added by lang_specific_driver, so that
3286 we can tell if there were any user supplied any files or libraries. */
3288 static int added_libraries
;
3290 /* And a vector of corresponding output files is made up later. */
3292 const char **outfiles
;
3294 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3296 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3297 is true if we should look for an executable suffix. DO_OBJ
3298 is true if we should look for an object suffix. */
3301 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3302 int do_obj ATTRIBUTE_UNUSED
)
3304 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3312 len
= strlen (name
);
3314 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3315 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3316 if (do_obj
&& len
> 2
3317 && name
[len
- 2] == '.'
3318 && name
[len
- 1] == 'o')
3320 obstack_grow (&obstack
, name
, len
- 2);
3321 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3322 name
= XOBFINISH (&obstack
, const char *);
3326 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3327 /* If there is no filetype, make it the executable suffix (which includes
3328 the "."). But don't get confused if we have just "-o". */
3329 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3332 for (i
= len
- 1; i
>= 0; i
--)
3333 if (IS_DIR_SEPARATOR (name
[i
]))
3336 for (i
++; i
< len
; i
++)
3340 obstack_grow (&obstack
, name
, len
);
3341 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3342 strlen (TARGET_EXECUTABLE_SUFFIX
));
3343 name
= XOBFINISH (&obstack
, const char *);
3350 /* Display the command line switches accepted by gcc. */
3354 printf (_("Usage: %s [options] file...\n"), progname
);
3355 fputs (_("Options:\n"), stdout
);
3357 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3358 fputs (_(" --help Display this information\n"), stdout
);
3359 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3360 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3361 fputs (_(" Display specific types of command line options\n"), stdout
);
3363 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3364 fputs (_(" --version Display compiler version information\n"), stdout
);
3365 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3366 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3367 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3368 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3369 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3370 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3371 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3372 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3374 -print-multi-lib Display the mapping between command line options and\n\
3375 multiple library search directories\n"), stdout
);
3376 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3377 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3378 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3379 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3380 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3381 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3382 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3383 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3384 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3385 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout
);
3386 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3387 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3389 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3390 prefixes to other gcc components\n"), stdout
);
3391 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3392 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3393 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3394 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3396 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3397 and libraries\n"), stdout
);
3398 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3399 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3400 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3401 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3402 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3403 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3404 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3406 -x <language> Specify the language of the following input files\n\
3407 Permissible languages include: c c++ assembler none\n\
3408 'none' means revert to the default behavior of\n\
3409 guessing the language based on the file's extension\n\
3413 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3414 passed on to the various sub-processes invoked by %s. In order to pass\n\
3415 other options on to these processes the -W<letter> options must be used.\n\
3418 /* The rest of the options are displayed by invocations of the various
3423 add_preprocessor_option (const char *option
, int len
)
3425 n_preprocessor_options
++;
3427 if (! preprocessor_options
)
3428 preprocessor_options
= XNEWVEC (char *, n_preprocessor_options
);
3430 preprocessor_options
= XRESIZEVEC (char *, preprocessor_options
,
3431 n_preprocessor_options
);
3433 preprocessor_options
[n_preprocessor_options
- 1] =
3434 save_string (option
, len
);
3438 add_assembler_option (const char *option
, int len
)
3440 n_assembler_options
++;
3442 if (! assembler_options
)
3443 assembler_options
= XNEWVEC (char *, n_assembler_options
);
3445 assembler_options
= XRESIZEVEC (char *, assembler_options
,
3446 n_assembler_options
);
3448 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3452 add_linker_option (const char *option
, int len
)
3456 if (! linker_options
)
3457 linker_options
= XNEWVEC (char *, n_linker_options
);
3459 linker_options
= XRESIZEVEC (char *, linker_options
, n_linker_options
);
3461 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3464 /* Allocate space for an input file in infiles. */
3469 if (n_infiles_alloc
== 0)
3471 n_infiles_alloc
= 16;
3472 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3474 else if (n_infiles_alloc
== n_infiles
)
3476 n_infiles_alloc
*= 2;
3477 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3481 /* Store an input file with the given NAME and LANGUAGE in
3485 add_infile (const char *name
, const char *language
)
3488 infiles
[n_infiles
].name
= name
;
3489 infiles
[n_infiles
++].language
= language
;
3492 /* Allocate space for a switch in switches. */
3497 if (n_switches_alloc
== 0)
3499 n_switches_alloc
= 16;
3500 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3502 else if (n_switches_alloc
== n_switches
)
3504 n_switches_alloc
*= 2;
3505 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3509 /* Create the vector `switches' and its contents.
3510 Store its length in `n_switches'. */
3513 process_command (int argc
, const char **argv
)
3518 const char *spec_lang
= 0;
3519 int last_language_n_infiles
;
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");
3528 added_libraries
= 0;
3530 /* Figure compiler version from version string. */
3532 compiler_version
= temp1
= xstrdup (version_string
);
3534 for (; *temp1
; ++temp1
)
3543 /* Convert new-style -- options to old-style. */
3544 translate_options (&argc
,
3545 CONST_CAST2 (const char *const **, const char ***,
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
;
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
;
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
));
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
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
;
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 ***,
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");
3637 const char *startp
, *endp
;
3638 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3640 startp
= endp
= temp
;
3643 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3645 strncpy (nstore
, startp
, 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;
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);
3661 endp
= startp
= endp
+ 1;
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
;
3677 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3679 strncpy (nstore
, startp
, 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;
3688 nstore
[endp
- startp
] = 0;
3689 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3690 PREFIX_PRIORITY_LAST
, 0, 1);
3693 endp
= startp
= endp
+ 1;
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
;
3710 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3712 strncpy (nstore
, startp
, 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;
3721 nstore
[endp
- startp
] = 0;
3722 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3723 PREFIX_PRIORITY_LAST
, 0, 1);
3726 endp
= startp
= endp
+ 1;
3733 /* Process the options and store input files and switches in their
3736 last_language_n_infiles
= -1;
3738 for (i
= 1; i
< argc
; i
++)
3740 const char *p
= NULL
;
3743 if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3749 if (! strcmp (argv
[i
], "-dumpspecs"))
3751 struct spec_list
*sl
;
3753 for (sl
= specs
; sl
; sl
= sl
->next
)
3754 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3755 if (link_command_spec
)
3756 printf ("*link_command:\n%s\n\n", link_command_spec
);
3759 else if (! strcmp (argv
[i
], "-dumpversion"))
3761 printf ("%s\n", spec_version
);
3764 else if (! strcmp (argv
[i
], "-dumpmachine"))
3766 printf ("%s\n", spec_machine
);
3769 else if (strcmp (argv
[i
], "-fversion") == 0)
3771 /* translate_options () has turned --version into -fversion. */
3774 /* CPP driver cannot obtain switch from cc1_options. */
3776 add_preprocessor_option ("--version", strlen ("--version"));
3777 add_assembler_option ("--version", strlen ("--version"));
3778 add_linker_option ("--version", strlen ("--version"));
3782 else if (strcmp (argv
[i
], "-fhelp") == 0)
3784 /* translate_options () has turned --help into -fhelp. */
3785 print_help_list
= 1;
3787 /* CPP driver cannot obtain switch from cc1_options. */
3789 add_preprocessor_option ("--help", 6);
3790 add_assembler_option ("--help", 6);
3791 add_linker_option ("--help", 6);
3795 else if (strncmp (argv
[i
], "-fhelp=", 7) == 0)
3797 /* translate_options () has turned --help into -fhelp. */
3798 print_subprocess_help
= 2;
3802 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3804 /* translate_options() has turned --target-help into -ftarget-help. */
3805 print_subprocess_help
= 1;
3807 /* CPP driver cannot obtain switch from cc1_options. */
3809 add_preprocessor_option ("--target-help", 13);
3810 add_assembler_option ("--target-help", 13);
3811 add_linker_option ("--target-help", 13);
3815 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3817 pass_exit_codes
= 1;
3819 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3820 print_search_dirs
= 1;
3821 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3822 print_file_name
= "libgcc.a";
3823 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3824 print_file_name
= argv
[i
] + 17;
3825 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3826 print_prog_name
= argv
[i
] + 17;
3827 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3828 print_multi_lib
= 1;
3829 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3830 print_multi_directory
= 1;
3831 else if (! strcmp (argv
[i
], "-print-sysroot"))
3833 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3834 print_multi_os_directory
= 1;
3835 else if (! strcmp (argv
[i
], "-print-sysroot-headers-suffix"))
3836 print_sysroot_headers_suffix
= 1;
3837 else if (! strcmp (argv
[i
], "-fcompare-debug-second"))
3839 compare_debug_second
= 1;
3842 else if (! strcmp (argv
[i
], "-fno-compare-debug"))
3844 argv
[i
] = "-fcompare-debug=";
3846 goto compare_debug_with_arg
;
3848 else if (! strcmp (argv
[i
], "-fcompare-debug"))
3850 argv
[i
] = "-fcompare-debug=-gtoggle";
3852 goto compare_debug_with_arg
;
3854 #define OPT "-fcompare-debug="
3855 else if (! strncmp (argv
[i
], OPT
, sizeof (OPT
) - 1))
3858 compare_debug_with_arg
:
3859 opt
= argv
[i
] + sizeof (OPT
) - 1;
3865 if (compare_debug
< 0)
3866 compare_debug_opt
= NULL
;
3868 compare_debug_opt
= opt
;
3871 else if (! strncmp (argv
[i
], "-Wa,", 4))
3874 /* Pass the rest of this option to the assembler. */
3876 /* Split the argument at commas. */
3878 for (j
= 4; argv
[i
][j
]; j
++)
3879 if (argv
[i
][j
] == ',')
3881 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3885 /* Record the part after the last comma. */
3886 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3888 else if (! strncmp (argv
[i
], "-Wp,", 4))
3891 /* Pass the rest of this option to the preprocessor. */
3893 /* Split the argument at commas. */
3895 for (j
= 4; argv
[i
][j
]; j
++)
3896 if (argv
[i
][j
] == ',')
3898 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3902 /* Record the part after the last comma. */
3903 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3905 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3908 /* Split the argument at commas. */
3910 for (j
= 4; argv
[i
][j
]; j
++)
3911 if (argv
[i
][j
] == ',')
3913 add_infile (save_string (argv
[i
] + prev
, j
- prev
), "*");
3916 /* Record the part after the last comma. */
3917 add_infile (argv
[i
] + prev
, "*");
3919 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3922 fatal_error ("argument to %<-Xlinker%> is missing");
3924 add_infile (argv
[i
+1], "*");
3927 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3930 fatal_error ("argument to %<-Xpreprocessor%> is missing");
3932 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3935 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3938 fatal_error ("argument to %<-Xassembler%> is missing");
3940 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3943 else if (strcmp (argv
[i
], "-l") == 0)
3946 fatal_error ("argument to %<-l%> is missing");
3948 /* POSIX allows separation of -l and the lib arg;
3949 canonicalize by concatenating -l with its arg */
3950 add_infile (concat ("-l", argv
[i
+ 1], NULL
), "*");
3953 else if (strncmp (argv
[i
], "-l", 2) == 0)
3955 add_infile (argv
[i
], "*");
3957 else if (strcmp (argv
[i
], "-save-temps") == 0)
3959 save_temps_flag
= SAVE_TEMPS_CWD
;
3962 else if (strncmp (argv
[i
], "-save-temps=", 12) == 0)
3964 if (strcmp (argv
[i
]+12, "cwd") == 0)
3965 save_temps_flag
= SAVE_TEMPS_CWD
;
3966 else if (strcmp (argv
[i
]+12, "obj") == 0
3967 || strcmp (argv
[i
]+12, "object") == 0)
3968 save_temps_flag
= SAVE_TEMPS_OBJ
;
3970 fatal_error ("%qs is an unknown -save-temps option", argv
[i
]);
3973 else if (strcmp (argv
[i
], "-no-canonical-prefixes") == 0)
3974 /* Already handled as a special case, so ignored here. */
3976 else if (strcmp (argv
[i
], "-combine") == 0)
3981 else if (strcmp (argv
[i
], "-specs") == 0)
3983 struct user_specs
*user
= XNEW (struct user_specs
);
3985 fatal_error ("argument to %<-specs%> is missing");
3987 user
->next
= (struct user_specs
*) 0;
3988 user
->filename
= argv
[i
];
3989 if (user_specs_tail
)
3990 user_specs_tail
->next
= user
;
3992 user_specs_head
= user
;
3993 user_specs_tail
= user
;
3995 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3997 struct user_specs
*user
= XNEW (struct user_specs
);
3998 if (strlen (argv
[i
]) == 7)
3999 fatal_error ("argument to %<-specs=%> is missing");
4001 user
->next
= (struct user_specs
*) 0;
4002 user
->filename
= argv
[i
] + 7;
4003 if (user_specs_tail
)
4004 user_specs_tail
->next
= user
;
4006 user_specs_head
= user
;
4007 user_specs_tail
= user
;
4009 else if (! strncmp (argv
[i
], "--sysroot=", strlen ("--sysroot=")))
4011 target_system_root
= argv
[i
] + strlen ("--sysroot=");
4012 target_system_root_changed
= 1;
4014 else if (strcmp (argv
[i
], "-time") == 0)
4016 else if (strncmp (argv
[i
], "-time=", sizeof ("-time=") - 1) == 0)
4018 if (report_times_to_file
)
4019 fclose (report_times_to_file
);
4020 report_times_to_file
= fopen (argv
[i
] + sizeof ("-time=") - 1, "a");
4022 else if (strcmp (argv
[i
], "-pipe") == 0)
4024 /* -pipe has to go into the switches array as well as
4029 else if (strcmp (argv
[i
], "-wrapper") == 0)
4032 fatal_error ("argument to %<-wrapper%> is missing");
4034 wrapper_string
= argv
[i
];
4036 else if (strcmp (argv
[i
], "-###") == 0)
4038 /* This is similar to -v except that there is no execution
4039 of the commands and the echoed arguments are quoted. It
4040 is intended for use in shell scripts to capture the
4041 driver-generated command line. */
4042 verbose_only_flag
++;
4045 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
4054 if (p
[1] == 0 && i
+ 1 == argc
)
4055 fatal_error ("argument to %<-B%> is missing");
4057 value
= argv
[i
+ 1];
4061 len
= strlen (value
);
4063 /* Catch the case where the user has forgotten to append a
4064 directory separator to the path. Note, they may be using
4065 -B to add an executable name prefix, eg "i386-elf-", in
4066 order to distinguish between multiple installations of
4067 GCC in the same directory. Hence we must check to see
4068 if appending a directory separator actually makes a
4069 valid directory name. */
4070 if (! IS_DIR_SEPARATOR (value
[len
- 1])
4071 && is_directory (value
, false))
4073 char *tmp
= XNEWVEC (char, len
+ 2);
4074 strcpy (tmp
, value
);
4075 tmp
[len
] = DIR_SEPARATOR
;
4080 add_prefix (&exec_prefixes
, value
, NULL
,
4081 PREFIX_PRIORITY_B_OPT
, 0, 0);
4082 add_prefix (&startfile_prefixes
, value
, NULL
,
4083 PREFIX_PRIORITY_B_OPT
, 0, 0);
4084 add_prefix (&include_prefixes
, value
, NULL
,
4085 PREFIX_PRIORITY_B_OPT
, 0, 0);
4089 case 'v': /* Print our subcommands and print versions. */
4090 /* If they do anything other than exactly `-v', don't set
4091 verbose_flag; rather, continue on to give the error. */
4098 if (p
[1] == 0 && i
+ 1 == argc
)
4099 fatal_error ("argument to %<-x%> is missing");
4101 spec_lang
= argv
[++i
];
4104 if (! strcmp (spec_lang
, "none"))
4105 /* Suppress the warning if -xnone comes after the last input
4106 file, because alternate command interfaces like g++ might
4107 find it useful to place -xnone after each input file. */
4110 last_language_n_infiles
= n_infiles
;
4122 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4127 /* Forward scan, just in case -S, -E or -c is specified
4134 if (argv
[j
][0] == '-')
4136 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
4142 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
4143 j
+= skip
- (argv
[j
][2] != 0);
4144 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
4151 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4153 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
4156 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
4160 /* Save the output name in case -save-temps=obj was used. */
4161 if ((p
[1] == 0) && argv
[i
+ 1])
4162 save_temps_prefix
= xstrdup(argv
[i
+ 1]);
4164 save_temps_prefix
= xstrdup(argv
[i
] + 1);
4171 switches
[n_switches
].part1
= p
;
4172 /* Deal with option arguments in separate argv elements. */
4173 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4174 || WORD_SWITCH_TAKES_ARG (p
))
4177 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4181 /* Count only the option arguments in separate
4183 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4185 if (i
+ n_args
>= argc
)
4186 fatal_error ("argument to %<-%s%> is missing", p
);
4187 switches
[n_switches
].args
4188 = XNEWVEC (const char *, n_args
+ 1);
4190 switches
[n_switches
].args
[j
++] = argv
[++i
];
4191 /* Null-terminate the vector. */
4192 switches
[n_switches
].args
[j
] = 0;
4196 /* On some systems, ld cannot handle "-o" without
4197 a space. So split the option from its argument. */
4198 char *part1
= XNEWVEC (char, 2);
4202 switches
[n_switches
].part1
= part1
;
4203 switches
[n_switches
].args
= XNEWVEC (const char *, 2);
4204 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4205 switches
[n_switches
].args
[1] = 0;
4208 switches
[n_switches
].args
= 0;
4210 switches
[n_switches
].live_cond
= 0;
4211 switches
[n_switches
].validated
= 0;
4212 switches
[n_switches
].ordering
= 0;
4213 /* These are always valid, since gcc.c itself understands the
4214 first four, gfortranspec.c understands -static-libgfortran
4215 and g++spec.c understands -static-libstdc++ */
4216 if (!strcmp (p
, "save-temps")
4217 || !strcmp (p
, "static-libgcc")
4218 || !strcmp (p
, "shared-libgcc")
4219 || !strcmp (p
, "pipe")
4220 || !strcmp (p
, "static-libgfortran")
4221 || !strcmp (p
, "static-libstdc++"))
4222 switches
[n_switches
].validated
= 1;
4225 char ch
= switches
[n_switches
].part1
[0];
4227 switches
[n_switches
].validated
= 1;
4234 const char *p
= strrchr (argv
[i
], '@');
4238 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4239 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4241 /* For LTO static archive support we handle input file
4242 specifications that are composed of a filename and
4243 an offset like FNAME@OFFSET. */
4246 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4247 && strlen (p
) == (unsigned int)consumed
)
4249 fname
= (char *)xmalloc (p
- argv
[i
] + 1);
4250 memcpy (fname
, argv
[i
], p
- argv
[i
]);
4251 fname
[p
- argv
[i
]] = '\0';
4252 /* Only accept non-stdin and existing FNAME parts, otherwise
4253 try with the full name. */
4254 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4257 fname
= xstrdup (argv
[i
]);
4261 fname
= xstrdup (argv
[i
]);
4263 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4264 perror_with_name (fname
);
4266 add_infile (argv
[i
], spec_lang
);
4272 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4273 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4274 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4276 save_temps_length
= strlen (save_temps_prefix
);
4277 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4280 save_temps_length
-= strlen (temp
);
4281 save_temps_prefix
[save_temps_length
] = '\0';
4285 else if (save_temps_prefix
!= NULL
)
4287 free (save_temps_prefix
);
4288 save_temps_prefix
= NULL
;
4291 if (save_temps_flag
&& use_pipes
)
4293 /* -save-temps overrides -pipe, so that temp files are produced */
4294 if (save_temps_flag
)
4295 warning (0, "-pipe ignored because -save-temps specified");
4301 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
4303 if (gcd
&& gcd
[0] == '-')
4306 compare_debug_opt
= gcd
;
4308 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4311 compare_debug_opt
= "-gtoggle";
4314 else if (compare_debug
< 0)
4317 gcc_assert (!compare_debug_opt
);
4320 /* Set up the search paths. We add directories that we expect to
4321 contain GNU Toolchain components before directories specified by
4322 the machine description so that we will find GNU components (like
4323 the GNU assembler) before those of the host system. */
4325 /* If we don't know where the toolchain has been installed, use the
4326 configured-in locations. */
4327 if (!gcc_exec_prefix
)
4330 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4331 PREFIX_PRIORITY_LAST
, 1, 0);
4332 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4333 PREFIX_PRIORITY_LAST
, 2, 0);
4334 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4335 PREFIX_PRIORITY_LAST
, 2, 0);
4337 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4338 PREFIX_PRIORITY_LAST
, 1, 0);
4341 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4342 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
4343 dir_separator_str
, NULL
);
4345 /* Look for tools relative to the location from which the driver is
4346 running, or, if that is not available, the configured prefix. */
4348 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4349 spec_machine
, dir_separator_str
,
4350 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
4352 add_prefix (&exec_prefixes
,
4353 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4354 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4355 add_prefix (&startfile_prefixes
,
4356 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4357 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4359 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4360 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4361 then consider it to relocate with the rest of the GCC installation
4362 if GCC_EXEC_PREFIX is set.
4363 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4364 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4366 char *tmp_prefix
= get_relative_prefix (argv
[0],
4367 standard_bindir_prefix
,
4368 target_system_root
);
4369 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4371 target_system_root
= tmp_prefix
;
4372 target_system_root_changed
= 1;
4377 /* More prefixes are enabled in main, after we read the specs file
4378 and determine whether this is cross-compilation or not. */
4380 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4381 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4383 if (compare_debug
== 2 || compare_debug
== 3)
4386 switches
[n_switches
].part1
= concat ("fcompare-debug=",
4389 switches
[n_switches
].args
= 0;
4390 switches
[n_switches
].live_cond
= 0;
4391 switches
[n_switches
].validated
= 0;
4392 switches
[n_switches
].ordering
= 0;
4397 /* Ensure we only invoke each subprocess once. */
4398 if (print_subprocess_help
|| print_help_list
|| print_version
)
4402 /* Create a dummy input file, so that we can pass
4403 the help option on to the various sub-processes. */
4404 add_infile ("help-dummy", "c");
4408 switches
[n_switches
].part1
= 0;
4410 infiles
[n_infiles
].name
= 0;
4413 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4414 and place that in the environment. */
4417 set_collect_gcc_options (void)
4422 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4424 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4425 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4428 for (i
= 0; (int) i
< n_switches
; i
++)
4430 const char *const *args
;
4433 obstack_grow (&collect_obstack
, " ", 1);
4437 /* Ignore elided switches. */
4438 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) != 0)
4441 obstack_grow (&collect_obstack
, "'-", 2);
4442 q
= switches
[i
].part1
;
4443 while ((p
= strchr (q
, '\'')))
4445 obstack_grow (&collect_obstack
, q
, p
- q
);
4446 obstack_grow (&collect_obstack
, "'\\''", 4);
4449 obstack_grow (&collect_obstack
, q
, strlen (q
));
4450 obstack_grow (&collect_obstack
, "'", 1);
4452 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4454 obstack_grow (&collect_obstack
, " '", 2);
4456 while ((p
= strchr (q
, '\'')))
4458 obstack_grow (&collect_obstack
, q
, p
- q
);
4459 obstack_grow (&collect_obstack
, "'\\''", 4);
4462 obstack_grow (&collect_obstack
, q
, strlen (q
));
4463 obstack_grow (&collect_obstack
, "'", 1);
4466 obstack_grow (&collect_obstack
, "\0", 1);
4467 xputenv (XOBFINISH (&collect_obstack
, char *));
4470 /* Process a spec string, accumulating and running commands. */
4472 /* These variables describe the input file name.
4473 input_file_number is the index on outfiles of this file,
4474 so that the output file name can be stored for later use by %o.
4475 input_basename is the start of the part of the input file
4476 sans all directory names, and basename_length is the number
4477 of characters starting there excluding the suffix .c or whatever. */
4479 static const char *gcc_input_filename
;
4480 static int input_file_number
;
4481 size_t input_filename_length
;
4482 static int basename_length
;
4483 static int suffixed_basename_length
;
4484 static const char *input_basename
;
4485 static const char *input_suffix
;
4486 #ifndef HOST_LACKS_INODE_NUMBERS
4487 static struct stat input_stat
;
4489 static int input_stat_set
;
4491 /* The compiler used to process the current input file. */
4492 static struct compiler
*input_file_compiler
;
4494 /* These are variables used within do_spec and do_spec_1. */
4496 /* Nonzero if an arg has been started and not yet terminated
4497 (with space, tab or newline). */
4498 static int arg_going
;
4500 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4501 is a temporary file name. */
4502 static int delete_this_arg
;
4504 /* Nonzero means %w has been seen; the next arg to be terminated
4505 is the output file name of this compilation. */
4506 static int this_is_output_file
;
4508 /* Nonzero means %s has been seen; the next arg to be terminated
4509 is the name of a library file and we should try the standard
4510 search dirs for it. */
4511 static int this_is_library_file
;
4513 /* Nonzero means %T has been seen; the next arg to be terminated
4514 is the name of a linker script and we should try all of the
4515 standard search dirs for it. If it is found insert a --script
4516 command line switch and then substitute the full path in place,
4517 otherwise generate an error message. */
4518 static int this_is_linker_script
;
4520 /* Nonzero means that the input of this command is coming from a pipe. */
4521 static int input_from_pipe
;
4523 /* Nonnull means substitute this for any suffix when outputting a switches
4525 static const char *suffix_subst
;
4527 /* If there is an argument being accumulated, terminate it and store it. */
4530 end_going_arg (void)
4536 obstack_1grow (&obstack
, 0);
4537 string
= XOBFINISH (&obstack
, const char *);
4538 if (this_is_library_file
)
4539 string
= find_file (string
);
4540 if (this_is_linker_script
)
4542 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4544 if (full_script_path
== NULL
)
4546 error ("unable to locate default linker script %qs in the library search paths", string
);
4547 /* Script was not found on search path. */
4550 store_arg ("--script", false, false);
4551 string
= full_script_path
;
4553 store_arg (string
, delete_this_arg
, this_is_output_file
);
4554 if (this_is_output_file
)
4555 outfiles
[input_file_number
] = string
;
4561 /* Parse the WRAPPER string which is a comma separated list of the command line
4562 and insert them into the beginning of argbuf. */
4565 insert_wrapper (const char *wrapper
)
4569 char *buf
= xstrdup (wrapper
);
4578 while ((p
= strchr (p
, ',')) != NULL
);
4580 if (argbuf_index
+ n
>= argbuf_length
)
4582 argbuf_length
= argbuf_length
* 2;
4583 while (argbuf_length
< argbuf_index
+ n
)
4585 argbuf
= XRESIZEVEC (const char *, argbuf
, argbuf_length
);
4587 for (i
= argbuf_index
- 1; i
>= 0; i
--)
4588 argbuf
[i
+ n
] = argbuf
[i
];
4601 while ((p
= strchr (p
, ',')) != NULL
);
4602 gcc_assert (i
== n
);
4606 /* Process the spec SPEC and run the commands specified therein.
4607 Returns 0 if the spec is successfully processed; -1 if failed. */
4610 do_spec (const char *spec
)
4614 value
= do_spec_2 (spec
);
4616 /* Force out any unfinished command.
4617 If -pipe, this forces out the last command if it ended in `|'. */
4620 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4623 set_collect_gcc_options ();
4625 if (argbuf_index
> 0)
4633 do_spec_2 (const char *spec
)
4639 delete_this_arg
= 0;
4640 this_is_output_file
= 0;
4641 this_is_library_file
= 0;
4642 this_is_linker_script
= 0;
4643 input_from_pipe
= 0;
4644 suffix_subst
= NULL
;
4646 result
= do_spec_1 (spec
, 0, NULL
);
4654 /* Process the given spec string and add any new options to the end
4655 of the switches/n_switches array. */
4658 do_option_spec (const char *name
, const char *spec
)
4660 unsigned int i
, value_count
, value_len
;
4661 const char *p
, *q
, *value
;
4662 char *tmp_spec
, *tmp_spec_p
;
4664 if (configure_default_options
[0].name
== NULL
)
4667 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4668 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4670 if (i
== ARRAY_SIZE (configure_default_options
))
4673 value
= configure_default_options
[i
].value
;
4674 value_len
= strlen (value
);
4676 /* Compute the size of the final spec. */
4679 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4685 /* Replace each %(VALUE) by the specified value. */
4686 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4687 + value_count
* (value_len
- strlen ("%(VALUE)")));
4688 tmp_spec_p
= tmp_spec
;
4690 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4692 memcpy (tmp_spec_p
, q
, p
- q
);
4693 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4694 memcpy (tmp_spec_p
, value
, value_len
);
4695 tmp_spec_p
+= value_len
;
4696 q
= p
+ strlen ("%(VALUE)");
4698 strcpy (tmp_spec_p
, q
);
4700 do_self_spec (tmp_spec
);
4703 /* Process the given spec string and add any new options to the end
4704 of the switches/n_switches array. */
4707 do_self_spec (const char *spec
)
4712 do_spec_1 (" ", 0, NULL
);
4714 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4715 do_self_specs adds the replacements to switches array, so it shouldn't
4716 be processed afterwards. */
4717 for (i
= 0; i
< n_switches
; i
++)
4718 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4719 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4721 if (argbuf_index
> 0)
4723 switches
= XRESIZEVEC (struct switchstr
, switches
,
4724 n_switches
+ argbuf_index
+ 1);
4726 for (i
= 0; i
< argbuf_index
; i
++)
4728 struct switchstr
*sw
;
4729 const char *p
= argbuf
[i
];
4732 /* Each switch should start with '-'. */
4734 fatal_error ("switch %qs does not start with %<-%>", argbuf
[i
]);
4739 sw
= &switches
[n_switches
++];
4745 /* Deal with option arguments in separate argv elements. */
4746 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4747 || WORD_SWITCH_TAKES_ARG (p
))
4750 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4754 /* Count only the option arguments in separate argv elements. */
4755 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4757 if (i
+ n_args
>= argbuf_index
)
4758 fatal_error ("argument to %<-%s%> is missing", p
);
4760 = XNEWVEC (const char *, n_args
+ 1);
4762 sw
->args
[j
++] = argbuf
[++i
];
4763 /* Null-terminate the vector. */
4768 /* On some systems, ld cannot handle "-o" without
4769 a space. So split the option from its argument. */
4770 char *part1
= XNEWVEC (char, 2);
4775 sw
->args
= XNEWVEC (const char *, 2);
4776 sw
->args
[0] = xstrdup (p
+1);
4783 switches
[n_switches
].part1
= 0;
4787 /* Callback for processing %D and %I specs. */
4789 struct spec_path_info
{
4794 bool separate_options
;
4798 spec_path (char *path
, void *data
)
4800 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4804 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4807 if (info
->append_len
!= 0)
4809 len
= strlen (path
);
4810 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4813 if (!is_directory (path
, true))
4816 do_spec_1 (info
->option
, 1, NULL
);
4817 if (info
->separate_options
)
4818 do_spec_1 (" ", 0, NULL
);
4820 if (info
->append_len
== 0)
4822 len
= strlen (path
);
4823 save
= path
[len
- 1];
4824 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4825 path
[len
- 1] = '\0';
4828 do_spec_1 (path
, 1, NULL
);
4829 do_spec_1 (" ", 0, NULL
);
4831 /* Must not damage the original path. */
4832 if (info
->append_len
== 0)
4833 path
[len
- 1] = save
;
4838 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4842 create_at_file (char **argv
)
4844 char *temp_file
= make_temp_file ("");
4845 char *at_argument
= concat ("@", temp_file
, NULL
);
4846 FILE *f
= fopen (temp_file
, "w");
4850 fatal_error ("could not open temporary response file %s",
4853 status
= writeargv (argv
, f
);
4856 fatal_error ("could not write to temporary response file %s",
4859 status
= fclose (f
);
4862 fatal_error ("could not close temporary response file %s",
4865 store_arg (at_argument
, 0, 0);
4867 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4870 /* True if we should compile INFILE. */
4873 compile_input_file_p (struct infile
*infile
)
4875 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4876 if (infile
->incompiler
== input_file_compiler
)
4881 /* Process the sub-spec SPEC as a portion of a larger spec.
4882 This is like processing a whole spec except that we do
4883 not initialize at the beginning and we do not supply a
4884 newline by default at the end.
4885 INSWITCH nonzero means don't process %-sequences in SPEC;
4886 in this case, % is treated as an ordinary character.
4887 This is used while substituting switches.
4888 INSWITCH nonzero also causes SPC not to terminate an argument.
4890 Value is zero unless a line was finished
4891 and the command on that line reported an error. */
4894 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4896 const char *p
= spec
;
4902 /* If substituting a switch, treat all chars like letters.
4903 Otherwise, NL, SPC, TAB and % are special. */
4904 switch (inswitch
? 'a' : c
)
4909 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4911 /* A `|' before the newline means use a pipe here,
4912 but only if -pipe was specified.
4913 Otherwise, execute now and don't pass the `|' as an arg. */
4916 input_from_pipe
= 1;
4923 set_collect_gcc_options ();
4925 if (argbuf_index
> 0)
4931 /* Reinitialize for a new command, and for a new argument. */
4934 delete_this_arg
= 0;
4935 this_is_output_file
= 0;
4936 this_is_library_file
= 0;
4937 this_is_linker_script
= 0;
4938 input_from_pipe
= 0;
4945 obstack_1grow (&obstack
, c
);
4953 /* Reinitialize for a new argument. */
4954 delete_this_arg
= 0;
4955 this_is_output_file
= 0;
4956 this_is_library_file
= 0;
4957 this_is_linker_script
= 0;
4964 fatal_error ("spec %qs invalid", spec
);
4967 if (save_temps_length
)
4968 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4970 obstack_grow (&obstack
, input_basename
, basename_length
);
4971 if (compare_debug
< 0)
4972 obstack_grow (&obstack
, ".gk", 3);
4977 if (save_temps_length
)
4978 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4980 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4981 if (compare_debug
< 0)
4982 obstack_grow (&obstack
, ".gk", 3);
4987 delete_this_arg
= 2;
4990 /* Dump out the directories specified with LIBRARY_PATH,
4991 followed by the absolute directories
4992 that we search for startfiles. */
4995 struct spec_path_info info
;
4998 info
.append_len
= 0;
4999 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5000 /* Used on systems which record the specified -L dirs
5001 and use them to search for dynamic linking.
5002 Relative directories always come from -B,
5003 and it is better not to use them for searching
5004 at run time. In particular, stage1 loses. */
5005 info
.omit_relative
= true;
5007 info
.omit_relative
= false;
5009 info
.separate_options
= false;
5011 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
5016 /* %efoo means report an error with `foo' as error message
5017 and don't execute any more commands for this file. */
5021 while (*p
!= 0 && *p
!= '\n')
5023 buf
= (char *) alloca (p
- q
+ 1);
5024 strncpy (buf
, q
, p
- q
);
5026 error ("%s", _(buf
));
5031 /* %nfoo means report a notice with `foo' on stderr. */
5035 while (*p
!= 0 && *p
!= '\n')
5037 buf
= (char *) alloca (p
- q
+ 1);
5038 strncpy (buf
, q
, p
- q
);
5040 inform (0, "%s", _(buf
));
5050 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5051 defined, and it is not a directory, and it is
5052 writable, use it. Otherwise, treat this like any
5053 other temporary file. */
5055 if ((!save_temps_flag
)
5056 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
5057 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
5059 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
5060 strlen (HOST_BIT_BUCKET
));
5061 delete_this_arg
= 0;
5066 goto create_temp_file
;
5070 obstack_1grow (&obstack
, '-');
5071 delete_this_arg
= 0;
5074 /* consume suffix */
5075 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5077 if (p
[0] == '%' && p
[1] == 'O')
5082 goto create_temp_file
;
5086 /* consume suffix */
5087 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5089 if (p
[0] == '%' && p
[1] == 'O')
5094 goto create_temp_file
;
5100 struct temp_name
*t
;
5102 const char *suffix
= p
;
5103 char *saved_suffix
= NULL
;
5105 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5107 suffix_length
= p
- suffix
;
5108 if (p
[0] == '%' && p
[1] == 'O')
5111 /* We don't support extra suffix characters after %O. */
5112 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5113 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
5114 if (suffix_length
== 0)
5115 suffix
= TARGET_OBJECT_SUFFIX
;
5119 = XNEWVEC (char, suffix_length
5120 + strlen (TARGET_OBJECT_SUFFIX
));
5121 strncpy (saved_suffix
, suffix
, suffix_length
);
5122 strcpy (saved_suffix
+ suffix_length
,
5123 TARGET_OBJECT_SUFFIX
);
5125 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5128 if (compare_debug
< 0)
5130 suffix
= concat (".gk", suffix
, NULL
);
5134 /* If -save-temps=obj and -o were specified, use that for the
5136 if (save_temps_length
)
5139 temp_filename_length
5140 = save_temps_length
+ suffix_length
+ 1;
5141 tmp
= (char *) alloca (temp_filename_length
);
5142 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5143 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5144 tmp
[save_temps_length
+ suffix_length
] = '\0';
5145 temp_filename
= save_string (tmp
,
5146 temp_filename_length
+ 1);
5147 obstack_grow (&obstack
, temp_filename
,
5148 temp_filename_length
);
5150 delete_this_arg
= 0;
5154 /* If the gcc_input_filename has the same suffix specified
5155 for the %g, %u, or %U, and -save-temps is specified,
5156 we could end up using that file as an intermediate
5157 thus clobbering the user's source file (.e.g.,
5158 gcc -save-temps foo.s would clobber foo.s with the
5159 output of cpp0). So check for this condition and
5160 generate a temp file as the intermediate. */
5162 if (save_temps_flag
)
5165 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5166 tmp
= (char *) alloca (temp_filename_length
);
5167 memcpy (tmp
, input_basename
, basename_length
);
5168 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5169 tmp
[basename_length
+ suffix_length
] = '\0';
5170 temp_filename
= tmp
;
5172 if (strcmp (temp_filename
, gcc_input_filename
) != 0)
5174 #ifndef HOST_LACKS_INODE_NUMBERS
5175 struct stat st_temp
;
5177 /* Note, set_input() resets input_stat_set to 0. */
5178 if (input_stat_set
== 0)
5180 input_stat_set
= stat (gcc_input_filename
,
5182 if (input_stat_set
>= 0)
5186 /* If we have the stat for the gcc_input_filename
5187 and we can do the stat for the temp_filename
5188 then the they could still refer to the same
5189 file if st_dev/st_ino's are the same. */
5190 if (input_stat_set
!= 1
5191 || stat (temp_filename
, &st_temp
) < 0
5192 || input_stat
.st_dev
!= st_temp
.st_dev
5193 || input_stat
.st_ino
!= st_temp
.st_ino
)
5195 /* Just compare canonical pathnames. */
5196 char* input_realname
= lrealpath (gcc_input_filename
);
5197 char* temp_realname
= lrealpath (temp_filename
);
5198 bool files_differ
= strcmp (input_realname
, temp_realname
);
5199 free (input_realname
);
5200 free (temp_realname
);
5204 temp_filename
= save_string (temp_filename
,
5205 temp_filename_length
+ 1);
5206 obstack_grow (&obstack
, temp_filename
,
5207 temp_filename_length
);
5209 delete_this_arg
= 0;
5215 /* See if we already have an association of %g/%u/%U and
5217 for (t
= temp_names
; t
; t
= t
->next
)
5218 if (t
->length
== suffix_length
5219 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5220 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5223 /* Make a new association if needed. %u and %j
5225 if (t
== 0 || c
== 'u' || c
== 'j')
5229 t
= XNEW (struct temp_name
);
5230 t
->next
= temp_names
;
5233 t
->length
= suffix_length
;
5236 t
->suffix
= saved_suffix
;
5237 saved_suffix
= NULL
;
5240 t
->suffix
= save_string (suffix
, suffix_length
);
5241 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5242 temp_filename
= make_temp_file (t
->suffix
);
5243 temp_filename_length
= strlen (temp_filename
);
5244 t
->filename
= temp_filename
;
5245 t
->filename_length
= temp_filename_length
;
5249 free (saved_suffix
);
5251 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5252 delete_this_arg
= 1;
5260 if (at_file_supplied
)
5262 /* We are going to expand `%i' to `@FILE', where FILE
5263 is a newly-created temporary filename. The filenames
5264 that would usually be expanded in place of %o will be
5265 written to the temporary file. */
5270 for (i
= 0; i
< n_infiles
; i
++)
5271 if (compile_input_file_p (&infiles
[i
]))
5274 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5276 /* Copy the strings over. */
5277 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5278 if (compile_input_file_p (&infiles
[i
]))
5280 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5281 infiles
[i
].compiled
= true;
5286 create_at_file (argv
);
5289 for (i
= 0; (int) i
< n_infiles
; i
++)
5290 if (compile_input_file_p (&infiles
[i
]))
5292 store_arg (infiles
[i
].name
, 0, 0);
5293 infiles
[i
].compiled
= true;
5298 obstack_grow (&obstack
, gcc_input_filename
,
5299 input_filename_length
);
5306 struct spec_path_info info
;
5310 do_spec_1 ("-imultilib", 1, NULL
);
5311 /* Make this a separate argument. */
5312 do_spec_1 (" ", 0, NULL
);
5313 do_spec_1 (multilib_dir
, 1, NULL
);
5314 do_spec_1 (" ", 0, NULL
);
5317 if (gcc_exec_prefix
)
5319 do_spec_1 ("-iprefix", 1, NULL
);
5320 /* Make this a separate argument. */
5321 do_spec_1 (" ", 0, NULL
);
5322 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5323 do_spec_1 (" ", 0, NULL
);
5326 if (target_system_root_changed
||
5327 (target_system_root
&& target_sysroot_hdrs_suffix
))
5329 do_spec_1 ("-isysroot", 1, NULL
);
5330 /* Make this a separate argument. */
5331 do_spec_1 (" ", 0, NULL
);
5332 do_spec_1 (target_system_root
, 1, NULL
);
5333 if (target_sysroot_hdrs_suffix
)
5334 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5335 do_spec_1 (" ", 0, NULL
);
5338 info
.option
= "-isystem";
5339 info
.append
= "include";
5340 info
.append_len
= strlen (info
.append
);
5341 info
.omit_relative
= false;
5342 info
.separate_options
= true;
5344 for_each_path (&include_prefixes
, false, info
.append_len
,
5347 info
.append
= "include-fixed";
5348 if (*sysroot_hdrs_suffix_spec
)
5349 info
.append
= concat (info
.append
, dir_separator_str
,
5350 multilib_dir
, NULL
);
5351 info
.append_len
= strlen (info
.append
);
5352 for_each_path (&include_prefixes
, false, info
.append_len
,
5359 int max
= n_infiles
;
5360 max
+= lang_specific_extra_outfiles
;
5362 if (HAVE_GNU_LD
&& at_file_supplied
)
5364 /* We are going to expand `%o' to `@FILE', where FILE
5365 is a newly-created temporary filename. The filenames
5366 that would usually be expanded in place of %o will be
5367 written to the temporary file. */
5372 /* Convert OUTFILES into a form suitable for writeargv. */
5374 /* Determine how many are non-NULL. */
5375 for (n_files
= 0, i
= 0; i
< max
; i
++)
5376 n_files
+= outfiles
[i
] != NULL
;
5378 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5380 /* Copy the strings over. */
5381 for (i
= 0, j
= 0; i
< max
; i
++)
5384 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5389 create_at_file (argv
);
5392 for (i
= 0; i
< max
; i
++)
5394 store_arg (outfiles
[i
], 0, 0);
5399 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5404 this_is_library_file
= 1;
5408 this_is_linker_script
= 1;
5412 outfiles
[input_file_number
] = NULL
;
5416 this_is_output_file
= 1;
5421 int cur_index
= argbuf_index
;
5422 /* Handle the {...} following the %W. */
5424 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5425 p
= handle_braces (p
+ 1);
5429 /* If any args were output, mark the last one for deletion
5431 if (argbuf_index
!= cur_index
)
5432 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
5436 /* %x{OPTION} records OPTION for %X to output. */
5442 /* Skip past the option value and make a copy. */
5444 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5447 string
= save_string (p1
+ 1, p
- p1
- 2);
5449 /* See if we already recorded this option. */
5450 for (i
= 0; i
< n_linker_options
; i
++)
5451 if (! strcmp (string
, linker_options
[i
]))
5457 /* This option is new; add it. */
5458 add_linker_option (string
, strlen (string
));
5462 /* Dump out the options accumulated previously using %x. */
5464 for (i
= 0; i
< n_linker_options
; i
++)
5466 do_spec_1 (linker_options
[i
], 1, NULL
);
5467 /* Make each accumulated option a separate argument. */
5468 do_spec_1 (" ", 0, NULL
);
5472 /* Dump out the options accumulated previously using -Wa,. */
5474 for (i
= 0; i
< n_assembler_options
; i
++)
5476 do_spec_1 (assembler_options
[i
], 1, NULL
);
5477 /* Make each accumulated option a separate argument. */
5478 do_spec_1 (" ", 0, NULL
);
5482 /* Dump out the options accumulated previously using -Wp,. */
5484 for (i
= 0; i
< n_preprocessor_options
; i
++)
5486 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5487 /* Make each accumulated option a separate argument. */
5488 do_spec_1 (" ", 0, NULL
);
5492 /* Here are digits and numbers that just process
5493 a certain constant string as a spec. */
5496 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5502 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5508 value
= do_spec_1 (asm_spec
, 0, NULL
);
5514 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5521 const char *const spec
5522 = (input_file_compiler
->cpp_spec
5523 ? input_file_compiler
->cpp_spec
5525 value
= do_spec_1 (spec
, 0, NULL
);
5532 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5538 value
= do_spec_1 (link_spec
, 0, NULL
);
5544 value
= do_spec_1 (lib_spec
, 0, NULL
);
5550 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5556 /* We assume there is a directory
5557 separator at the end of this string. */
5558 if (target_system_root
)
5560 obstack_grow (&obstack
, target_system_root
,
5561 strlen (target_system_root
));
5562 if (target_sysroot_suffix
)
5563 obstack_grow (&obstack
, target_sysroot_suffix
,
5564 strlen (target_sysroot_suffix
));
5569 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5574 /* Here we define characters other than letters and digits. */
5577 p
= handle_braces (p
);
5583 p
= handle_spec_function (p
);
5589 obstack_1grow (&obstack
, '%');
5596 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5598 suffix_subst
= save_string (p
- 1, len
+ 1);
5603 /* Henceforth ignore the option(s) matching the pattern
5608 int have_wildcard
= 0;
5611 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5614 if (p
[len
-1] == '*')
5617 for (i
= 0; i
< n_switches
; i
++)
5618 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5619 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5621 switches
[i
].live_cond
|= SWITCH_IGNORE
;
5622 switches
[i
].validated
= 1;
5630 if (soft_matched_part
)
5632 do_spec_1 (soft_matched_part
, 1, NULL
);
5633 do_spec_1 (" ", 0, NULL
);
5636 /* Catch the case where a spec string contains something like
5637 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5638 hand side of the :. */
5639 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5642 /* Process a string found as the value of a spec given by name.
5643 This feature allows individual machine descriptions
5644 to add and use their own specs.
5645 %[...] modifies -D options the way %P does;
5646 %(...) uses the spec unmodified. */
5648 warning (0, "use of obsolete %%[ operator in specs");
5651 const char *name
= p
;
5652 struct spec_list
*sl
;
5655 /* The string after the S/P is the name of a spec that is to be
5657 while (*p
&& *p
!= ')' && *p
!= ']')
5660 /* See if it's in the list. */
5661 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5662 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5664 name
= *(sl
->ptr_spec
);
5666 fnotice (stderr
, "Processing spec %c%s%c, which is '%s'\n",
5667 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5676 value
= do_spec_1 (name
, 0, NULL
);
5682 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5684 const char *y
= name
;
5687 /* Copy all of NAME into BUF, but put __ after
5688 every -D and at the end of each arg. */
5691 if (! strncmp (y
, "-D", 2))
5702 && (*y
== ' ' || *y
== '\t' || *y
== '='
5703 || *y
== '}' || *y
== 0))
5716 value
= do_spec_1 (buf
, 0, NULL
);
5722 /* Discard the closing paren or bracket. */
5729 error ("spec failure: unrecognized spec option %qc", c
);
5735 /* Backslash: treat next character as ordinary. */
5740 /* Ordinary character: put it into the current argument. */
5741 obstack_1grow (&obstack
, c
);
5745 /* End of string. If we are processing a spec function, we need to
5746 end any pending argument. */
5747 if (processing_spec_function
)
5753 /* Look up a spec function. */
5755 static const struct spec_function
*
5756 lookup_spec_function (const char *name
)
5758 const struct spec_function
*sf
;
5760 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5761 if (strcmp (sf
->name
, name
) == 0)
5767 /* Evaluate a spec function. */
5770 eval_spec_function (const char *func
, const char *args
)
5772 const struct spec_function
*sf
;
5773 const char *funcval
;
5775 /* Saved spec processing context. */
5776 int save_argbuf_index
;
5777 int save_argbuf_length
;
5778 const char **save_argbuf
;
5781 int save_delete_this_arg
;
5782 int save_this_is_output_file
;
5783 int save_this_is_library_file
;
5784 int save_input_from_pipe
;
5785 int save_this_is_linker_script
;
5786 const char *save_suffix_subst
;
5789 sf
= lookup_spec_function (func
);
5791 fatal_error ("unknown spec function %qs", func
);
5793 /* Push the spec processing context. */
5794 save_argbuf_index
= argbuf_index
;
5795 save_argbuf_length
= argbuf_length
;
5796 save_argbuf
= argbuf
;
5798 save_arg_going
= arg_going
;
5799 save_delete_this_arg
= delete_this_arg
;
5800 save_this_is_output_file
= this_is_output_file
;
5801 save_this_is_library_file
= this_is_library_file
;
5802 save_this_is_linker_script
= this_is_linker_script
;
5803 save_input_from_pipe
= input_from_pipe
;
5804 save_suffix_subst
= suffix_subst
;
5806 /* Create a new spec processing context, and build the function
5810 if (do_spec_2 (args
) < 0)
5811 fatal_error ("error in args to spec function %qs", func
);
5813 /* argbuf_index is an index for the next argument to be inserted, and
5814 so contains the count of the args already inserted. */
5816 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5818 /* Pop the spec processing context. */
5819 argbuf_index
= save_argbuf_index
;
5820 argbuf_length
= save_argbuf_length
;
5822 argbuf
= save_argbuf
;
5824 arg_going
= save_arg_going
;
5825 delete_this_arg
= save_delete_this_arg
;
5826 this_is_output_file
= save_this_is_output_file
;
5827 this_is_library_file
= save_this_is_library_file
;
5828 this_is_linker_script
= save_this_is_linker_script
;
5829 input_from_pipe
= save_input_from_pipe
;
5830 suffix_subst
= save_suffix_subst
;
5835 /* Handle a spec function call of the form:
5839 ARGS is processed as a spec in a separate context and split into an
5840 argument vector in the normal fashion. The function returns a string
5841 containing a spec which we then process in the caller's context, or
5842 NULL if no processing is required. */
5845 handle_spec_function (const char *p
)
5848 const char *endp
, *funcval
;
5851 processing_spec_function
++;
5853 /* Get the function name. */
5854 for (endp
= p
; *endp
!= '\0'; endp
++)
5856 if (*endp
== '(') /* ) */
5858 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5859 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5860 fatal_error ("malformed spec function name");
5862 if (*endp
!= '(') /* ) */
5863 fatal_error ("no arguments for spec function");
5864 func
= save_string (p
, endp
- p
);
5867 /* Get the arguments. */
5868 for (count
= 0; *endp
!= '\0'; endp
++)
5877 else if (*endp
== '(') /* ) */
5882 fatal_error ("malformed spec function arguments");
5883 args
= save_string (p
, endp
- p
);
5886 /* p now points to just past the end of the spec function expression. */
5888 funcval
= eval_spec_function (func
, args
);
5889 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5895 processing_spec_function
--;
5900 /* Inline subroutine of handle_braces. Returns true if the current
5901 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5903 input_suffix_matches (const char *atom
, const char *end_atom
)
5905 return (input_suffix
5906 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5907 && input_suffix
[end_atom
- atom
] == '\0');
5910 /* Subroutine of handle_braces. Returns true if the current
5911 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5913 input_spec_matches (const char *atom
, const char *end_atom
)
5915 return (input_file_compiler
5916 && input_file_compiler
->suffix
5917 && input_file_compiler
->suffix
[0] != '\0'
5918 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5920 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5923 /* Subroutine of handle_braces. Returns true if a switch
5924 matching the atom bracketed by ATOM and END_ATOM appeared on the
5927 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5930 int len
= end_atom
- atom
;
5931 int plen
= starred
? len
: -1;
5933 for (i
= 0; i
< n_switches
; i
++)
5934 if (!strncmp (switches
[i
].part1
, atom
, len
)
5935 && (starred
|| switches
[i
].part1
[len
] == '\0')
5936 && check_live_switch (i
, plen
))
5942 /* Inline subroutine of handle_braces. Mark all of the switches which
5943 match ATOM (extends to END_ATOM; STARRED indicates whether there
5944 was a star after the atom) for later processing. */
5946 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5949 int len
= end_atom
- atom
;
5950 int plen
= starred
? len
: -1;
5952 for (i
= 0; i
< n_switches
; i
++)
5953 if (!strncmp (switches
[i
].part1
, atom
, len
)
5954 && (starred
|| switches
[i
].part1
[len
] == '\0')
5955 && check_live_switch (i
, plen
))
5956 switches
[i
].ordering
= 1;
5959 /* Inline subroutine of handle_braces. Process all the currently
5960 marked switches through give_switch, and clear the marks. */
5962 process_marked_switches (void)
5966 for (i
= 0; i
< n_switches
; i
++)
5967 if (switches
[i
].ordering
== 1)
5969 switches
[i
].ordering
= 0;
5974 /* Handle a %{ ... } construct. P points just inside the leading {.
5975 Returns a pointer one past the end of the brace block, or 0
5976 if we call do_spec_1 and that returns -1. */
5979 handle_braces (const char *p
)
5981 const char *atom
, *end_atom
;
5982 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5983 const char *orig
= p
;
5991 bool a_must_be_last
= false;
5992 bool ordered_set
= false;
5993 bool disjunct_set
= false;
5994 bool disj_matched
= false;
5995 bool disj_starred
= true;
5996 bool n_way_choice
= false;
5997 bool n_way_matched
= false;
5999 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6006 /* Scan one "atom" (S in the description above of %{}, possibly
6007 with '!', '.', '@', ',', or '*' modifiers). */
6009 a_is_suffix
= false;
6010 a_is_starred
= false;
6011 a_is_negated
= false;
6012 a_is_spectype
= false;
6016 p
++, a_is_negated
= true;
6020 p
++, a_is_suffix
= true;
6022 p
++, a_is_spectype
= true;
6025 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
6026 || *p
== ',' || *p
== '.' || *p
== '@')
6031 p
++, a_is_starred
= 1;
6037 /* Substitute the switch(es) indicated by the current atom. */
6039 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
6040 || a_is_spectype
|| atom
== end_atom
)
6043 mark_matching_switches (atom
, end_atom
, a_is_starred
);
6046 process_marked_switches ();
6050 /* Substitute some text if the current atom appears as a switch
6052 disjunct_set
= true;
6056 if (atom
== end_atom
)
6058 if (!n_way_choice
|| disj_matched
|| *p
== '|'
6059 || a_is_negated
|| a_is_suffix
|| a_is_spectype
6063 /* An empty term may appear as the last choice of an
6064 N-way choice set; it means "otherwise". */
6065 a_must_be_last
= true;
6066 disj_matched
= !n_way_matched
;
6067 disj_starred
= false;
6071 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6075 disj_starred
= false;
6077 /* Don't bother testing this atom if we already have a
6079 if (!disj_matched
&& !n_way_matched
)
6082 a_matched
= input_suffix_matches (atom
, end_atom
);
6083 else if (a_is_spectype
)
6084 a_matched
= input_spec_matches (atom
, end_atom
);
6086 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6088 if (a_matched
!= a_is_negated
)
6090 disj_matched
= true;
6092 d_end_atom
= end_atom
;
6099 /* Found the body, that is, the text to substitute if the
6100 current disjunction matches. */
6101 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6102 disj_matched
&& !n_way_matched
);
6106 /* If we have an N-way choice, reset state for the next
6110 n_way_choice
= true;
6111 n_way_matched
|= disj_matched
;
6112 disj_matched
= false;
6113 disj_starred
= true;
6114 d_atom
= d_end_atom
= NULL
;
6123 while (*p
++ != '}');
6128 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
6133 /* Subroutine of handle_braces. Scan and process a brace substitution body
6134 (X in the description of %{} syntax). P points one past the colon;
6135 ATOM and END_ATOM bracket the first atom which was found to be true
6136 (present) in the current disjunction; STARRED indicates whether all
6137 the atoms in the current disjunction were starred (for syntax validation);
6138 MATCHED indicates whether the disjunction matched or not, and therefore
6139 whether or not the body is to be processed through do_spec_1 or just
6140 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6144 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6145 int starred
, int matched
)
6147 const char *body
, *end_body
;
6148 unsigned int nesting_level
;
6149 bool have_subst
= false;
6151 /* Locate the closing } or ;, honoring nested braces.
6152 Trim trailing whitespace. */
6161 if (!--nesting_level
)
6164 else if (*p
== ';' && nesting_level
== 1)
6166 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6168 else if (*p
== '\0')
6174 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6177 if (have_subst
&& !starred
)
6182 /* Copy the substitution body to permanent storage and execute it.
6183 If have_subst is false, this is a simple matter of running the
6184 body through do_spec_1... */
6185 char *string
= save_string (body
, end_body
- body
);
6188 if (do_spec_1 (string
, 0, NULL
) < 0)
6193 /* ... but if have_subst is true, we have to process the
6194 body once for each matching switch, with %* set to the
6195 variant part of the switch. */
6196 unsigned int hard_match_len
= end_atom
- atom
;
6199 for (i
= 0; i
< n_switches
; i
++)
6200 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6201 && check_live_switch (i
, hard_match_len
))
6203 if (do_spec_1 (string
, 0,
6204 &switches
[i
].part1
[hard_match_len
]) < 0)
6206 /* Pass any arguments this switch has. */
6208 suffix_subst
= NULL
;
6216 fatal_error ("braced spec body %qs is invalid", body
);
6219 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6220 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6221 spec, or -1 if either exact match or %* is used.
6223 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6224 whose value does not begin with "no-" is obsoleted by the same value
6225 with the "no-", similarly for a switch with the "no-" prefix. */
6228 check_live_switch (int switchnum
, int prefix_length
)
6230 const char *name
= switches
[switchnum
].part1
;
6233 /* If we already processed this switch and determined if it was
6234 live or not, return our past determination. */
6235 if (switches
[switchnum
].live_cond
!= 0)
6236 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6237 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6238 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6241 /* In the common case of {<at-most-one-letter>*}, a negating
6242 switch would always match, so ignore that case. We will just
6243 send the conflicting switches to the compiler phase. */
6244 if (prefix_length
>= 0 && prefix_length
<= 1)
6247 /* Now search for duplicate in a manner that depends on the name. */
6251 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6252 if (switches
[i
].part1
[0] == 'O')
6254 switches
[switchnum
].validated
= 1;
6255 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6260 case 'W': case 'f': case 'm':
6261 if (! strncmp (name
+ 1, "no-", 3))
6263 /* We have Xno-YYY, search for XYYY. */
6264 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6265 if (switches
[i
].part1
[0] == name
[0]
6266 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6268 switches
[switchnum
].validated
= 1;
6269 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6275 /* We have XYYY, search for Xno-YYY. */
6276 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6277 if (switches
[i
].part1
[0] == name
[0]
6278 && switches
[i
].part1
[1] == 'n'
6279 && switches
[i
].part1
[2] == 'o'
6280 && switches
[i
].part1
[3] == '-'
6281 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6283 switches
[switchnum
].validated
= 1;
6284 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6291 /* Otherwise the switch is live. */
6292 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6296 /* Pass a switch to the current accumulating command
6297 in the same form that we received it.
6298 SWITCHNUM identifies the switch; it is an index into
6299 the vector of switches gcc received, which is `switches'.
6300 This cannot fail since it never finishes a command line.
6302 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6305 give_switch (int switchnum
, int omit_first_word
)
6307 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6310 if (!omit_first_word
)
6312 do_spec_1 ("-", 0, NULL
);
6313 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6316 if (switches
[switchnum
].args
!= 0)
6319 for (p
= switches
[switchnum
].args
; *p
; p
++)
6321 const char *arg
= *p
;
6323 do_spec_1 (" ", 0, NULL
);
6326 unsigned length
= strlen (arg
);
6329 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6330 if (arg
[length
] == '.')
6332 (CONST_CAST(char *, arg
))[length
] = 0;
6336 do_spec_1 (arg
, 1, NULL
);
6338 (CONST_CAST(char *, arg
))[length
] = '.';
6339 do_spec_1 (suffix_subst
, 1, NULL
);
6342 do_spec_1 (arg
, 1, NULL
);
6346 do_spec_1 (" ", 0, NULL
);
6347 switches
[switchnum
].validated
= 1;
6350 /* Search for a file named NAME trying various prefixes including the
6351 user's -B prefix and some standard ones.
6352 Return the absolute file name found. If nothing is found, return NAME. */
6355 find_file (const char *name
)
6357 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6358 return newname
? newname
: name
;
6361 /* Determine whether a directory exists. If LINKER, return 0 for
6362 certain fixed names not needed by the linker. */
6365 is_directory (const char *path1
, bool linker
)
6372 /* Ensure the string ends with "/.". The resulting path will be a
6373 directory even if the given path is a symbolic link. */
6374 len1
= strlen (path1
);
6375 path
= (char *) alloca (3 + len1
);
6376 memcpy (path
, path1
, len1
);
6378 if (!IS_DIR_SEPARATOR (cp
[-1]))
6379 *cp
++ = DIR_SEPARATOR
;
6383 /* Exclude directories that the linker is known to search. */
6385 && IS_DIR_SEPARATOR (path
[0])
6387 && strncmp (path
+ 1, "lib", 3) == 0)
6389 && strncmp (path
+ 1, "usr", 3) == 0
6390 && IS_DIR_SEPARATOR (path
[4])
6391 && strncmp (path
+ 5, "lib", 3) == 0)))
6394 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6397 /* Set up the various global variables to indicate that we're processing
6398 the input file named FILENAME. */
6401 set_input (const char *filename
)
6405 gcc_input_filename
= filename
;
6406 input_filename_length
= strlen (gcc_input_filename
);
6407 input_basename
= lbasename (gcc_input_filename
);
6409 /* Find a suffix starting with the last period,
6410 and set basename_length to exclude that suffix. */
6411 basename_length
= strlen (input_basename
);
6412 suffixed_basename_length
= basename_length
;
6413 p
= input_basename
+ basename_length
;
6414 while (p
!= input_basename
&& *p
!= '.')
6416 if (*p
== '.' && p
!= input_basename
)
6418 basename_length
= p
- input_basename
;
6419 input_suffix
= p
+ 1;
6424 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6425 we will need to do a stat on the gcc_input_filename. The
6426 INPUT_STAT_SET signals that the stat is needed. */
6430 /* On fatal signals, delete all the temporary files. */
6433 fatal_signal (int signum
)
6435 signal (signum
, SIG_DFL
);
6436 delete_failure_queue ();
6437 delete_temp_files ();
6438 /* Get the same signal again, this time not handled,
6439 so its normal effect occurs. */
6440 kill (getpid (), signum
);
6443 /* Compare the contents of the two files named CMPFILE[0] and
6444 CMPFILE[1]. Return zero if they're identical, nonzero
6448 compare_files (char *cmpfile
[])
6451 FILE *temp
[2] = { NULL
, NULL
};
6457 void *map
[2] = { NULL
, NULL
};
6459 for (i
= 0; i
< 2; i
++)
6463 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6465 error ("%s: could not determine length of compare-debug file %s",
6466 gcc_input_filename
, cmpfile
[i
]);
6471 length
[i
] = st
.st_size
;
6474 if (!ret
&& length
[0] != length
[1])
6476 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6481 for (i
= 0; i
< 2; i
++)
6483 int fd
= open (cmpfile
[i
], O_RDONLY
);
6486 error ("%s: could not open compare-debug file %s",
6487 gcc_input_filename
, cmpfile
[i
]);
6492 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6495 if (map
[i
] == (void *) MAP_FAILED
)
6504 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6506 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6511 for (i
= 0; i
< 2; i
++)
6513 munmap ((caddr_t
) map
[i
], length
[i
]);
6522 for (i
= 0; i
< 2; i
++)
6524 temp
[i
] = fopen (cmpfile
[i
], "r");
6527 error ("%s: could not open compare-debug file %s",
6528 gcc_input_filename
, cmpfile
[i
]);
6534 if (!ret
&& temp
[0] && temp
[1])
6538 c0
= fgetc (temp
[0]);
6539 c1
= fgetc (temp
[1]);
6543 error ("%s: -fcompare-debug failure",
6544 gcc_input_filename
);
6553 for (i
= 1; i
>= 0; i
--)
6562 extern int main (int, char **);
6565 main (int argc
, char **argv
)
6569 int linker_was_run
= 0;
6570 int lang_n_infiles
= 0;
6571 int num_linker_inputs
= 0;
6572 char *explicit_link_files
;
6575 struct user_specs
*uptr
;
6576 char **old_argv
= argv
;
6578 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6579 on ?: in file-scope variable initializations. */
6580 asm_debug
= ASM_DEBUG_SPEC
;
6582 p
= argv
[0] + strlen (argv
[0]);
6583 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6587 xmalloc_set_program_name (progname
);
6589 expandargv (&argc
, &argv
);
6591 /* Determine if any expansions were made. */
6592 if (argv
!= old_argv
)
6593 at_file_supplied
= true;
6595 prune_options (&argc
, &argv
);
6597 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6598 /* Perform host dependent initialization when needed. */
6599 GCC_DRIVER_HOST_INITIALIZATION
;
6602 /* Unlock the stdio streams. */
6603 unlock_std_streams ();
6605 gcc_init_libintl ();
6607 diagnostic_initialize (global_dc
, 0);
6608 if (atexit (delete_temp_files
) != 0)
6609 fatal_error ("atexit failed");
6611 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6612 signal (SIGINT
, fatal_signal
);
6614 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6615 signal (SIGHUP
, fatal_signal
);
6617 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6618 signal (SIGTERM
, fatal_signal
);
6620 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6621 signal (SIGPIPE
, fatal_signal
);
6624 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6625 receive the signal. A different setting is inheritable */
6626 signal (SIGCHLD
, SIG_DFL
);
6629 /* Allocate the argument vector. */
6632 obstack_init (&obstack
);
6634 /* Build multilib_select, et. al from the separate lines that make up each
6635 multilib selection. */
6637 const char *const *q
= multilib_raw
;
6640 obstack_init (&multilib_obstack
);
6641 while ((p
= *q
++) != (char *) 0)
6642 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6644 obstack_1grow (&multilib_obstack
, 0);
6645 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6647 q
= multilib_matches_raw
;
6648 while ((p
= *q
++) != (char *) 0)
6649 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6651 obstack_1grow (&multilib_obstack
, 0);
6652 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6654 q
= multilib_exclusions_raw
;
6655 while ((p
= *q
++) != (char *) 0)
6656 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6658 obstack_1grow (&multilib_obstack
, 0);
6659 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6662 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6665 obstack_1grow (&multilib_obstack
, ' ');
6666 obstack_grow (&multilib_obstack
,
6667 multilib_defaults_raw
[i
],
6668 strlen (multilib_defaults_raw
[i
]));
6672 obstack_1grow (&multilib_obstack
, 0);
6673 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6676 #ifdef INIT_ENVIRONMENT
6677 /* Set up any other necessary machine specific environment variables. */
6678 xputenv (INIT_ENVIRONMENT
);
6681 /* Make a table of what switches there are (switches, n_switches).
6682 Make a table of specified input files (infiles, n_infiles).
6683 Decode switches that are handled locally. */
6685 process_command (argc
, CONST_CAST2 (const char **, char **, argv
));
6687 /* Initialize the vector of specs to just the default.
6688 This means one element containing 0s, as a terminator. */
6690 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6691 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6692 n_compilers
= n_default_compilers
;
6694 /* Read specs from a file if there is one. */
6696 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6697 spec_version
, dir_separator_str
, NULL
);
6698 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6700 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6701 /* Read the specs file unless it is a default one. */
6702 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6703 read_specs (specs_file
, TRUE
);
6707 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6708 for any override of as, ld and libraries. */
6709 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6710 + strlen (just_machine_suffix
) + sizeof ("specs"));
6712 strcpy (specs_file
, standard_exec_prefix
);
6713 strcat (specs_file
, just_machine_suffix
);
6714 strcat (specs_file
, "specs");
6715 if (access (specs_file
, R_OK
) == 0)
6716 read_specs (specs_file
, TRUE
);
6718 /* Process any configure-time defaults specified for the command line
6719 options, via OPTION_DEFAULT_SPECS. */
6720 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6721 do_option_spec (option_default_specs
[i
].name
,
6722 option_default_specs
[i
].spec
);
6724 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6725 of the command line. */
6727 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6728 do_self_spec (driver_self_specs
[i
]);
6732 enum save_temps save
;
6734 if (!compare_debug_second
)
6736 n_switches_debug_check
[1] = n_switches
;
6737 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
6740 do_self_spec ("%:compare-debug-self-opt()");
6741 n_switches_debug_check
[0] = n_switches
;
6742 switches_debug_check
[0] = switches
;
6744 n_switches
= n_switches_debug_check
[1];
6745 switches
= switches_debug_check
[1];
6748 /* Avoid crash when computing %j in this early. */
6749 save
= save_temps_flag
;
6750 save_temps_flag
= SAVE_TEMPS_NONE
;
6752 compare_debug
= -compare_debug
;
6753 do_self_spec ("%:compare-debug-self-opt()");
6755 save_temps_flag
= save
;
6757 if (!compare_debug_second
)
6759 n_switches_debug_check
[1] = n_switches
;
6760 switches_debug_check
[1] = switches
;
6761 compare_debug
= -compare_debug
;
6762 n_switches
= n_switches_debug_check
[0];
6763 switches
= switches_debug_check
[0];
6767 /* If not cross-compiling, look for executables in the standard
6769 if (*cross_compile
== '0')
6771 if (*md_exec_prefix
)
6773 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6774 PREFIX_PRIORITY_LAST
, 0, 0);
6778 /* Process sysroot_suffix_spec. */
6779 if (*sysroot_suffix_spec
!= 0
6780 && do_spec_2 (sysroot_suffix_spec
) == 0)
6782 if (argbuf_index
> 1)
6783 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6784 else if (argbuf_index
== 1)
6785 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6788 #ifdef HAVE_LD_SYSROOT
6789 /* Pass the --sysroot option to the linker, if it supports that. If
6790 there is a sysroot_suffix_spec, it has already been processed by
6791 this point, so target_system_root really is the system root we
6793 if (target_system_root
)
6795 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6796 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6797 set_spec ("link", XOBFINISH (&obstack
, const char *));
6801 /* Process sysroot_hdrs_suffix_spec. */
6802 if (*sysroot_hdrs_suffix_spec
!= 0
6803 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6805 if (argbuf_index
> 1)
6806 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6807 else if (argbuf_index
== 1)
6808 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6811 /* Look for startfiles in the standard places. */
6812 if (*startfile_prefix_spec
!= 0
6813 && do_spec_2 (startfile_prefix_spec
) == 0
6814 && do_spec_1 (" ", 0, NULL
) == 0)
6817 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6818 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6819 PREFIX_PRIORITY_LAST
, 0, 1);
6821 /* We should eventually get rid of all these and stick to
6822 startfile_prefix_spec exclusively. */
6823 else if (*cross_compile
== '0' || target_system_root
)
6825 if (*md_startfile_prefix
)
6826 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6827 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6829 if (*md_startfile_prefix_1
)
6830 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6831 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6833 /* If standard_startfile_prefix is relative, base it on
6834 standard_exec_prefix. This lets us move the installed tree
6835 as a unit. If GCC_EXEC_PREFIX is defined, base
6836 standard_startfile_prefix on that as well.
6838 If the prefix is relative, only search it for native compilers;
6839 otherwise we will search a directory containing host libraries. */
6840 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6841 add_sysrooted_prefix (&startfile_prefixes
,
6842 standard_startfile_prefix
, "BINUTILS",
6843 PREFIX_PRIORITY_LAST
, 0, 1);
6844 else if (*cross_compile
== '0')
6846 add_prefix (&startfile_prefixes
,
6847 concat (gcc_exec_prefix
6848 ? gcc_exec_prefix
: standard_exec_prefix
,
6850 standard_startfile_prefix
, NULL
),
6851 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6854 /* Sysrooted prefixes are relocated because target_system_root is
6855 also relocated by gcc_exec_prefix. */
6856 if (*standard_startfile_prefix_1
)
6857 add_sysrooted_prefix (&startfile_prefixes
,
6858 standard_startfile_prefix_1
, "BINUTILS",
6859 PREFIX_PRIORITY_LAST
, 0, 1);
6860 if (*standard_startfile_prefix_2
)
6861 add_sysrooted_prefix (&startfile_prefixes
,
6862 standard_startfile_prefix_2
, "BINUTILS",
6863 PREFIX_PRIORITY_LAST
, 0, 1);
6866 /* Process any user specified specs in the order given on the command
6868 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6870 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6872 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6875 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6876 if (gcc_exec_prefix
)
6877 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6878 spec_version
, dir_separator_str
, NULL
);
6880 /* Now we have the specs.
6881 Set the `valid' bits for switches that match anything in any spec. */
6883 validate_all_switches ();
6885 /* Now that we have the switches and the specs, set
6886 the subdirectory based on the options. */
6887 set_multilib_dir ();
6889 /* Set up to remember the pathname of gcc and any options
6890 needed for collect. We use argv[0] instead of progname because
6891 we need the complete pathname. */
6892 obstack_init (&collect_obstack
);
6893 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6894 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6895 xputenv (XOBFINISH (&collect_obstack
, char *));
6897 /* Set up to remember the pathname of the lto wrapper. */
6899 lto_wrapper_spec
= find_a_file (&exec_prefixes
, "lto-wrapper", X_OK
, false);
6900 if (lto_wrapper_spec
)
6902 obstack_init (&collect_obstack
);
6903 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
6904 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6905 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
6906 strlen (lto_wrapper_spec
) + 1);
6907 xputenv (XOBFINISH (&collect_obstack
, char *));
6910 /* Warn about any switches that no pass was interested in. */
6912 for (i
= 0; (int) i
< n_switches
; i
++)
6913 if (! switches
[i
].validated
)
6914 error ("unrecognized option %<-%s%>", switches
[i
].part1
);
6916 /* Obey some of the options. */
6918 if (print_search_dirs
)
6920 printf (_("install: %s%s\n"),
6921 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6922 gcc_exec_prefix
? "" : machine_suffix
);
6923 printf (_("programs: %s\n"),
6924 build_search_list (&exec_prefixes
, "", false, false));
6925 printf (_("libraries: %s\n"),
6926 build_search_list (&startfile_prefixes
, "", false, true));
6930 if (print_file_name
)
6932 printf ("%s\n", find_file (print_file_name
));
6936 if (print_prog_name
)
6938 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6939 printf ("%s\n", (newname
? newname
: print_prog_name
));
6943 if (print_multi_lib
)
6945 print_multilib_info ();
6949 if (print_multi_directory
)
6951 if (multilib_dir
== NULL
)
6954 printf ("%s\n", multilib_dir
);
6960 if (target_system_root
)
6962 if (target_sysroot_suffix
)
6963 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6965 printf ("%s\n", target_system_root
);
6970 if (print_multi_os_directory
)
6972 if (multilib_os_dir
== NULL
)
6975 printf ("%s\n", multilib_os_dir
);
6979 if (print_sysroot_headers_suffix
)
6981 if (*sysroot_hdrs_suffix_spec
)
6983 printf("%s\n", (target_sysroot_hdrs_suffix
6984 ? target_sysroot_hdrs_suffix
6989 /* The error status indicates that only one set of fixed
6990 headers should be built. */
6991 fatal_error ("not configured with sysroot headers suffix");
6994 if (print_help_list
)
7000 printf (_("\nFor bug reporting instructions, please see:\n"));
7001 printf ("%s.\n", bug_report_url
);
7006 /* We do not exit here. Instead we have created a fake input file
7007 called 'help-dummy' which needs to be compiled, and we pass this
7008 on the various sub-processes, along with the --help switch.
7009 Ensure their output appears after ours. */
7010 fputc ('\n', stdout
);
7016 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7018 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7020 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7021 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7026 /* We do not exit here. We use the same mechanism of --help to print
7027 the version of the sub-processes. */
7028 fputc ('\n', stdout
);
7037 fnotice (stderr
, "Target: %s\n", spec_machine
);
7038 fnotice (stderr
, "Configured with: %s\n", configuration_arguments
);
7040 #ifdef THREAD_MODEL_SPEC
7041 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7042 but there's no point in doing all this processing just to get
7043 thread_model back. */
7044 obstack_init (&obstack
);
7045 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7046 obstack_1grow (&obstack
, '\0');
7047 thrmod
= XOBFINISH (&obstack
, const char *);
7049 thrmod
= thread_model
;
7052 fnotice (stderr
, "Thread model: %s\n", thrmod
);
7054 /* compiler_version is truncated at the first space when initialized
7055 from version string, so truncate version_string at the first space
7056 before comparing. */
7057 for (n
= 0; version_string
[n
]; n
++)
7058 if (version_string
[n
] == ' ')
7061 if (! strncmp (version_string
, compiler_version
, n
)
7062 && compiler_version
[n
] == 0)
7063 fnotice (stderr
, "gcc version %s %s\n", version_string
,
7066 fnotice (stderr
, "gcc driver version %s %sexecuting gcc version %s\n",
7067 version_string
, pkgversion_string
, compiler_version
);
7073 if (n_infiles
== added_libraries
)
7074 fatal_error ("no input files");
7076 /* Make a place to record the compiler output file names
7077 that correspond to the input files. */
7080 i
+= lang_specific_extra_outfiles
;
7081 outfiles
= XCNEWVEC (const char *, i
);
7083 /* Record which files were specified explicitly as link input. */
7085 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7088 combine_inputs
= true;
7090 combine_inputs
= false;
7092 for (i
= 0; (int) i
< n_infiles
; i
++)
7094 const char *name
= infiles
[i
].name
;
7095 struct compiler
*compiler
= lookup_compiler (name
,
7097 infiles
[i
].language
);
7099 if (compiler
&& !(compiler
->combinable
))
7100 combine_inputs
= false;
7102 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7103 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7104 infiles
[i
].incompiler
= compiler
;
7108 input_file_compiler
= compiler
;
7109 infiles
[i
].incompiler
= compiler
;
7113 /* Since there is no compiler for this input file, assume it is a
7115 explicit_link_files
[i
] = 1;
7116 infiles
[i
].incompiler
= NULL
;
7118 infiles
[i
].compiled
= false;
7119 infiles
[i
].preprocessed
= false;
7122 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7123 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7125 if (combine_flag
&& save_temps_flag
)
7127 bool save_combine_inputs
= combine_inputs
;
7128 /* Must do a separate pre-processing pass for C & Objective-C files, to
7129 obtain individual .i files. */
7131 combine_inputs
= false;
7132 for (i
= 0; (int) i
< n_infiles
; i
++)
7134 int this_file_error
= 0;
7136 input_file_number
= i
;
7137 set_input (infiles
[i
].name
);
7138 if (infiles
[i
].incompiler
7139 && (infiles
[i
].incompiler
)->needs_preprocessing
)
7140 input_file_compiler
= infiles
[i
].incompiler
;
7144 if (input_file_compiler
)
7146 if (input_file_compiler
->spec
[0] == '#')
7148 error ("%s: %s compiler not installed on this system",
7149 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7150 this_file_error
= 1;
7154 value
= do_spec (input_file_compiler
->spec
);
7155 infiles
[i
].preprocessed
= true;
7156 if (!have_o_argbuf_index
)
7157 fatal_error ("spec %qs is invalid",
7158 input_file_compiler
->spec
);
7159 infiles
[i
].name
= argbuf
[have_o_argbuf_index
];
7160 infiles
[i
].incompiler
7161 = lookup_compiler (infiles
[i
].name
,
7162 strlen (infiles
[i
].name
),
7163 infiles
[i
].language
);
7166 this_file_error
= 1;
7170 if (this_file_error
)
7172 delete_failure_queue ();
7176 clear_failure_queue ();
7178 combine_inputs
= save_combine_inputs
;
7181 for (i
= 0; (int) i
< n_infiles
; i
++)
7183 int this_file_error
= 0;
7185 /* Tell do_spec what to substitute for %i. */
7187 input_file_number
= i
;
7188 set_input (infiles
[i
].name
);
7190 if (infiles
[i
].compiled
)
7193 /* Use the same thing in %o, unless cp->spec says otherwise. */
7195 outfiles
[i
] = gcc_input_filename
;
7197 /* Figure out which compiler from the file's suffix. */
7199 if (! combine_inputs
)
7201 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7202 infiles
[i
].language
);
7204 input_file_compiler
= infiles
[i
].incompiler
;
7206 if (input_file_compiler
)
7208 /* Ok, we found an applicable compiler. Run its spec. */
7210 if (input_file_compiler
->spec
[0] == '#')
7212 error ("%s: %s compiler not installed on this system",
7213 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7214 this_file_error
= 1;
7220 if (debug_check_temp_file
[0])
7221 free (debug_check_temp_file
[0]);
7222 debug_check_temp_file
[0] = NULL
;
7224 if (debug_check_temp_file
[1])
7225 free (debug_check_temp_file
[1]);
7226 debug_check_temp_file
[1] = NULL
;
7229 value
= do_spec (input_file_compiler
->spec
);
7230 infiles
[i
].compiled
= true;
7232 this_file_error
= 1;
7233 else if (compare_debug
&& debug_check_temp_file
[0])
7236 inform (0, "recompiling with -fcompare-debug");
7238 compare_debug
= -compare_debug
;
7239 n_switches
= n_switches_debug_check
[1];
7240 switches
= switches_debug_check
[1];
7242 value
= do_spec (input_file_compiler
->spec
);
7244 compare_debug
= -compare_debug
;
7245 n_switches
= n_switches_debug_check
[0];
7246 switches
= switches_debug_check
[0];
7250 error ("during -fcompare-debug recompilation");
7251 this_file_error
= 1;
7254 gcc_assert (debug_check_temp_file
[1]
7255 && strcmp (debug_check_temp_file
[0],
7256 debug_check_temp_file
[1]));
7259 inform (0, "comparing final insns dumps");
7261 if (compare_files (debug_check_temp_file
))
7262 this_file_error
= 1;
7267 if (debug_check_temp_file
[0])
7268 free (debug_check_temp_file
[0]);
7269 debug_check_temp_file
[0] = NULL
;
7271 if (debug_check_temp_file
[1])
7272 free (debug_check_temp_file
[1]);
7273 debug_check_temp_file
[1] = NULL
;
7278 /* If this file's name does not contain a recognized suffix,
7279 record it as explicit linker input. */
7282 explicit_link_files
[i
] = 1;
7284 /* Clear the delete-on-failure queue, deleting the files in it
7285 if this compilation failed. */
7287 if (this_file_error
)
7289 delete_failure_queue ();
7292 /* If this compilation succeeded, don't delete those files later. */
7293 clear_failure_queue ();
7296 /* Reset the input file name to the first compile/object file name, for use
7297 with %b in LINK_SPEC. We use the first input file that we can find
7298 a compiler to compile it instead of using infiles.language since for
7299 languages other than C we use aliases that we then lookup later. */
7304 for (i
= 0; i
< n_infiles
; i
++)
7305 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7307 set_input (infiles
[i
].name
);
7314 /* Make sure INPUT_FILE_NUMBER points to first available open
7316 input_file_number
= n_infiles
;
7317 if (lang_specific_pre_link ())
7321 /* Determine if there are any linker input files. */
7322 num_linker_inputs
= 0;
7323 for (i
= 0; (int) i
< n_infiles
; i
++)
7324 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
7325 num_linker_inputs
++;
7327 /* Run ld to link all the compiler output files. */
7329 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
7331 int tmp
= execution_count
;
7332 const char *fuse_linker_plugin
= "fuse-linker-plugin";
7334 /* We'll use ld if we can't find collect2. */
7335 if (! strcmp (linker_name_spec
, "collect2"))
7337 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7339 linker_name_spec
= "ld";
7342 if (switch_matches (fuse_linker_plugin
,
7343 fuse_linker_plugin
+ strlen (fuse_linker_plugin
), 0))
7345 linker_plugin_file_spec
= find_a_file (&exec_prefixes
,
7346 "liblto_plugin.so", R_OK
,
7348 if (!linker_plugin_file_spec
)
7349 fatal_error ("-fuse-linker-plugin, but liblto_plugin.so not found");
7351 lto_libgcc_spec
= find_a_file (&startfile_prefixes
, "libgcc.a",
7353 if (!lto_libgcc_spec
)
7354 fatal_error ("could not find libgcc.a");
7356 lto_gcc_spec
= argv
[0];
7358 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7360 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7361 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7363 if (print_subprocess_help
== 1)
7365 printf (_("\nLinker options\n==============\n\n"));
7366 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7367 " to the linker.\n\n"));
7370 value
= do_spec (link_command_spec
);
7373 linker_was_run
= (tmp
!= execution_count
);
7376 /* If options said don't run linker,
7377 complain about input files to be given to the linker. */
7379 if (! linker_was_run
&& !seen_error ())
7380 for (i
= 0; (int) i
< n_infiles
; i
++)
7381 if (explicit_link_files
[i
]
7382 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7383 warning (0, "%s: linker input file unused because linking not done",
7386 /* Delete some or all of the temporary files we made. */
7389 delete_failure_queue ();
7390 delete_temp_files ();
7392 if (print_help_list
)
7394 printf (("\nFor bug reporting instructions, please see:\n"));
7395 printf ("%s\n", bug_report_url
);
7398 return (signal_count
!= 0 ? 2
7399 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
7403 /* Find the proper compilation spec for the file name NAME,
7404 whose length is LENGTH. LANGUAGE is the specified language,
7405 or 0 if this file is to be passed to the linker. */
7407 static struct compiler
*
7408 lookup_compiler (const char *name
, size_t length
, const char *language
)
7410 struct compiler
*cp
;
7412 /* If this was specified by the user to be a linker input, indicate that. */
7413 if (language
!= 0 && language
[0] == '*')
7416 /* Otherwise, look for the language, if one is spec'd. */
7419 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7420 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7423 error ("language %s not recognized", language
);
7427 /* Look for a suffix. */
7428 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7430 if (/* The suffix `-' matches only the file name `-'. */
7431 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7432 || (strlen (cp
->suffix
) < length
7433 /* See if the suffix matches the end of NAME. */
7434 && !strcmp (cp
->suffix
,
7435 name
+ length
- strlen (cp
->suffix
))
7440 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7441 /* Look again, but case-insensitively this time. */
7443 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7445 if (/* The suffix `-' matches only the file name `-'. */
7446 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7447 || (strlen (cp
->suffix
) < length
7448 /* See if the suffix matches the end of NAME. */
7449 && ((!strcmp (cp
->suffix
,
7450 name
+ length
- strlen (cp
->suffix
))
7451 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7452 && !strcasecmp (cp
->suffix
,
7453 name
+ length
- strlen (cp
->suffix
)))
7459 if (cp
>= compilers
)
7461 if (cp
->spec
[0] != '@')
7462 /* A non-alias entry: return it. */
7465 /* An alias entry maps a suffix to a language.
7466 Search for the language; pass 0 for NAME and LENGTH
7467 to avoid infinite recursion if language not found. */
7468 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7474 save_string (const char *s
, int len
)
7476 char *result
= XNEWVEC (char, len
+ 1);
7478 memcpy (result
, s
, len
);
7484 pfatal_with_name (const char *name
)
7486 perror_with_name (name
);
7487 delete_temp_files ();
7492 perror_with_name (const char *name
)
7494 error ("%s: %m", name
);
7498 validate_switches_from_spec (const char *spec
)
7500 const char *p
= spec
;
7503 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7504 /* We have a switch spec. */
7505 p
= validate_switches (p
+ 1);
7509 validate_all_switches (void)
7511 struct compiler
*comp
;
7512 struct spec_list
*spec
;
7514 for (comp
= compilers
; comp
->spec
; comp
++)
7515 validate_switches_from_spec (comp
->spec
);
7517 /* Look through the linked list of specs read from the specs file. */
7518 for (spec
= specs
; spec
; spec
= spec
->next
)
7519 validate_switches_from_spec (*spec
->ptr_spec
);
7521 validate_switches_from_spec (link_command_spec
);
7524 /* Look at the switch-name that comes after START
7525 and mark as valid all supplied switches that match it. */
7528 validate_switches (const char *start
)
7530 const char *p
= start
;
7534 bool suffix
= false;
7535 bool starred
= false;
7537 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7546 if (*p
== '.' || *p
== ',')
7550 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7551 || *p
== ',' || *p
== '.' || *p
== '@')
7556 starred
= true, p
++;
7562 /* Mark all matching switches as valid. */
7563 for (i
= 0; i
< n_switches
; i
++)
7564 if (!strncmp (switches
[i
].part1
, atom
, len
)
7565 && (starred
|| switches
[i
].part1
[len
] == 0))
7566 switches
[i
].validated
= 1;
7570 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7573 if (*p
&& p
[-1] == ':')
7575 while (*p
&& *p
!= ';' && *p
!= '}')
7580 if (*p
== '{' || *p
== '<')
7581 p
= validate_switches (p
+1);
7582 else if (p
[0] == 'W' && p
[1] == '{')
7583 p
= validate_switches (p
+2);
7590 if (*p
&& p
[-1] == ';')
7604 static struct mdswitchstr
*mdswitches
;
7605 static int n_mdswitches
;
7607 /* Check whether a particular argument was used. The first time we
7608 canonicalize the switches to keep only the ones we care about. */
7611 used_arg (const char *p
, int len
)
7616 const char *replace
;
7621 static struct mswitchstr
*mswitches
;
7622 static int n_mswitches
;
7627 struct mswitchstr
*matches
;
7631 /* Break multilib_matches into the component strings of string
7632 and replacement string. */
7633 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7638 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7640 q
= multilib_matches
;
7649 fatal_error ("multilib spec %qs is invalid",
7654 matches
[i
].len
= q
- matches
[i
].str
;
7656 matches
[i
].replace
= ++q
;
7657 while (*q
!= ';' && *q
!= '\0')
7660 goto invalid_matches
;
7663 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7669 /* Now build a list of the replacement string for switches that we care
7670 about. Make sure we allocate at least one entry. This prevents
7671 xmalloc from calling fatal, and prevents us from re-executing this
7674 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7675 for (i
= 0; i
< n_switches
; i
++)
7676 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7678 int xlen
= strlen (switches
[i
].part1
);
7679 for (j
= 0; j
< cnt
; j
++)
7680 if (xlen
== matches
[j
].len
7681 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7683 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7684 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7685 mswitches
[n_mswitches
].replace
= (char *) 0;
7686 mswitches
[n_mswitches
].rep_len
= 0;
7692 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7693 on the command line nor any options mutually incompatible with
7695 for (i
= 0; i
< n_mdswitches
; i
++)
7699 for (q
= multilib_options
; *q
!= '\0'; q
++)
7705 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7706 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7708 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7715 if (*q
!= ' ' && *q
!= '\0')
7717 while (*r
!= ' ' && *r
!= '\0')
7720 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7723 if (used_arg (r
, q
- r
))
7728 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7729 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7730 mswitches
[n_mswitches
].replace
= (char *) 0;
7731 mswitches
[n_mswitches
].rep_len
= 0;
7744 for (i
= 0; i
< n_mswitches
; i
++)
7745 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7752 default_arg (const char *p
, int len
)
7756 for (i
= 0; i
< n_mdswitches
; i
++)
7757 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7763 /* Work out the subdirectory to use based on the options. The format of
7764 multilib_select is a list of elements. Each element is a subdirectory
7765 name followed by a list of options followed by a semicolon. The format
7766 of multilib_exclusions is the same, but without the preceding
7767 directory. First gcc will check the exclusions, if none of the options
7768 beginning with an exclamation point are present, and all of the other
7769 options are present, then we will ignore this completely. Passing
7770 that, gcc will consider each multilib_select in turn using the same
7771 rules for matching the options. If a match is found, that subdirectory
7775 set_multilib_dir (void)
7778 unsigned int this_path_len
;
7779 const char *this_path
, *this_arg
;
7780 const char *start
, *end
;
7782 int ok
, ndfltok
, first
;
7785 start
= multilib_defaults
;
7786 while (*start
== ' ' || *start
== '\t')
7788 while (*start
!= '\0')
7791 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7793 while (*start
== ' ' || *start
== '\t')
7801 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7802 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7804 while (*start
== ' ' || *start
== '\t')
7810 for (end
= start
+ 1;
7811 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7814 obstack_grow (&multilib_obstack
, start
, end
- start
);
7815 obstack_1grow (&multilib_obstack
, 0);
7816 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7817 mdswitches
[i
++].len
= end
- start
;
7824 p
= multilib_exclusions
;
7827 /* Ignore newlines. */
7834 /* Check the arguments. */
7841 fatal_error ("multilib exclusions %qs is invalid",
7842 multilib_exclusions
);
7852 while (*p
!= ' ' && *p
!= ';')
7855 goto invalid_exclusions
;
7859 if (*this_arg
!= '!')
7867 ok
= used_arg (this_arg
, p
- this_arg
);
7882 p
= multilib_select
;
7885 /* Ignore newlines. */
7892 /* Get the initial path. */
7899 fatal_error ("multilib select %qs is invalid",
7904 this_path_len
= p
- this_path
;
7906 /* Check the arguments. */
7913 goto invalid_select
;
7922 while (*p
!= ' ' && *p
!= ';')
7925 goto invalid_select
;
7929 if (*this_arg
!= '!')
7937 /* If this is a default argument, we can just ignore it.
7938 This is true even if this_arg begins with '!'. Beginning
7939 with '!' does not mean that this argument is necessarily
7940 inappropriate for this library: it merely means that
7941 there is a more specific library which uses this
7942 argument. If this argument is a default, we need not
7943 consider that more specific library. */
7944 ok
= used_arg (this_arg
, p
- this_arg
);
7951 if (default_arg (this_arg
, p
- this_arg
))
7960 if (this_path_len
!= 1
7961 || this_path
[0] != '.')
7963 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7966 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7967 new_multilib_dir
[this_path_len
] = '\0';
7968 q
= strchr (new_multilib_dir
, ':');
7971 multilib_dir
= new_multilib_dir
;
7978 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7980 while (q
< end
&& *q
!= ':')
7984 char *new_multilib_os_dir
= XNEWVEC (char, end
- q
);
7985 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7986 new_multilib_os_dir
[end
- q
- 1] = '\0';
7987 multilib_os_dir
= new_multilib_os_dir
;
7995 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7996 && strcmp (multilib_os_dir
, ".") == 0)
7998 free (CONST_CAST (char *, multilib_os_dir
));
7999 multilib_os_dir
= NULL
;
8001 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8002 multilib_os_dir
= multilib_dir
;
8005 /* Print out the multiple library subdirectory selection
8006 information. This prints out a series of lines. Each line looks
8007 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8008 required. Only the desired options are printed out, the negative
8009 matches. The options are print without a leading dash. There are
8010 no spaces to make it easy to use the information in the shell.
8011 Each subdirectory is printed only once. This assumes the ordering
8012 generated by the genmultilib script. Also, we leave out ones that match
8016 print_multilib_info (void)
8018 const char *p
= multilib_select
;
8019 const char *last_path
= 0, *this_path
;
8021 unsigned int last_path_len
= 0;
8026 /* Ignore newlines. */
8033 /* Get the initial path. */
8040 fatal_error ("multilib select %qs is invalid", multilib_select
);
8046 /* When --disable-multilib was used but target defines
8047 MULTILIB_OSDIRNAMES, entries starting with .: are there just
8048 to find multilib_os_dir, so skip them from output. */
8049 if (this_path
[0] == '.' && this_path
[1] == ':')
8052 /* Check for matches with the multilib_exclusions. We don't bother
8053 with the '!' in either list. If any of the exclusion rules match
8054 all of its options with the select rule, we skip it. */
8056 const char *e
= multilib_exclusions
;
8057 const char *this_arg
;
8062 /* Ignore newlines. */
8069 /* Check the arguments. */
8078 fatal_error ("multilib exclusion %qs is invalid",
8079 multilib_exclusions
);
8090 while (*e
!= ' ' && *e
!= ';')
8093 goto invalid_exclusion
;
8101 int len
= e
- this_arg
;
8104 goto invalid_select
;
8108 while (*q
!= ' ' && *q
!= ';')
8111 goto invalid_select
;
8115 if (! strncmp (arg
, this_arg
,
8116 (len
< q
- arg
) ? q
- arg
: len
)
8117 || default_arg (this_arg
, e
- this_arg
))
8147 /* If this is a duplicate, skip it. */
8148 skip
= (last_path
!= 0
8149 && (unsigned int) (p
- this_path
) == last_path_len
8150 && ! strncmp (last_path
, this_path
, last_path_len
));
8152 last_path
= this_path
;
8153 last_path_len
= p
- this_path
;
8156 /* If this directory requires any default arguments, we can skip
8157 it. We will already have printed a directory identical to
8158 this one which does not require that default argument. */
8169 goto invalid_select
;
8176 while (*q
!= ' ' && *q
!= ';')
8179 goto invalid_select
;
8184 && default_arg (arg
, q
- arg
))
8199 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8210 goto invalid_select
;
8218 use_arg
= *p
!= '!';
8223 while (*p
!= ' ' && *p
!= ';')
8226 goto invalid_select
;
8238 /* If there are extra options, print them now. */
8239 if (multilib_extra
&& *multilib_extra
)
8241 int print_at
= TRUE
;
8244 for (q
= multilib_extra
; *q
!= '\0'; q
++)
8265 /* getenv built-in spec function.
8267 Returns the value of the environment variable given by its first
8268 argument, concatenated with the second argument. If the
8269 environment variable is not defined, a fatal error is issued. */
8272 getenv_spec_function (int argc
, const char **argv
)
8282 value
= getenv (argv
[0]);
8284 fatal_error ("environment variable %qs not defined", argv
[0]);
8286 /* We have to escape every character of the environment variable so
8287 they are not interpreted as active spec characters. A
8288 particularly painful case is when we are reading a variable
8289 holding a windows path complete with \ separators. */
8290 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
8291 result
= XNEWVAR (char, len
);
8292 for (ptr
= result
; *value
; ptr
+= 2)
8298 strcpy (ptr
, argv
[1]);
8303 /* if-exists built-in spec function.
8305 Checks to see if the file specified by the absolute pathname in
8306 ARGS exists. Returns that pathname if found.
8308 The usual use for this function is to check for a library file
8309 (whose name has been expanded with %s). */
8312 if_exists_spec_function (int argc
, const char **argv
)
8314 /* Must have only one argument. */
8315 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8321 /* if-exists-else built-in spec function.
8323 This is like if-exists, but takes an additional argument which
8324 is returned if the first argument does not exist. */
8327 if_exists_else_spec_function (int argc
, const char **argv
)
8329 /* Must have exactly two arguments. */
8333 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8339 /* replace-outfile built-in spec function.
8341 This looks for the first argument in the outfiles array's name and
8342 replaces it with the second argument. */
8345 replace_outfile_spec_function (int argc
, const char **argv
)
8348 /* Must have exactly two arguments. */
8352 for (i
= 0; i
< n_infiles
; i
++)
8354 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
8355 outfiles
[i
] = xstrdup (argv
[1]);
8360 /* Given two version numbers, compares the two numbers.
8361 A version number must match the regular expression
8362 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8365 compare_version_strings (const char *v1
, const char *v2
)
8370 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8371 REG_EXTENDED
| REG_NOSUB
) != 0)
8373 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8374 if (rresult
== REG_NOMATCH
)
8375 fatal_error ("invalid version number %qs", v1
);
8376 else if (rresult
!= 0)
8378 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8379 if (rresult
== REG_NOMATCH
)
8380 fatal_error ("invalid version number %qs", v2
);
8381 else if (rresult
!= 0)
8384 return strverscmp (v1
, v2
);
8388 /* version_compare built-in spec function.
8390 This takes an argument of the following form:
8392 <comparison-op> <arg1> [<arg2>] <switch> <result>
8394 and produces "result" if the comparison evaluates to true,
8395 and nothing if it doesn't.
8397 The supported <comparison-op> values are:
8399 >= true if switch is a later (or same) version than arg1
8401 < true if switch is an earlier version than arg1
8403 >< true if switch is arg1 or later, and earlier than arg2
8404 <> true if switch is earlier than arg1 or is arg2 or later
8406 If the switch is not present, the condition is false unless
8407 the first character of the <comparison-op> is '!'.
8410 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8411 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8414 version_compare_spec_function (int argc
, const char **argv
)
8418 const char *switch_value
= NULL
;
8423 fatal_error ("too few arguments to %%:version-compare");
8424 if (argv
[0][0] == '\0')
8426 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8428 if (argc
!= nargs
+ 3)
8429 fatal_error ("too many arguments to %%:version-compare");
8431 switch_len
= strlen (argv
[nargs
+ 1]);
8432 for (i
= 0; i
< n_switches
; i
++)
8433 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8434 && check_live_switch (i
, switch_len
))
8435 switch_value
= switches
[i
].part1
+ switch_len
;
8437 if (switch_value
== NULL
)
8441 comp1
= compare_version_strings (switch_value
, argv
[1]);
8443 comp2
= compare_version_strings (switch_value
, argv
[2]);
8445 comp2
= -1; /* This value unused. */
8448 switch (argv
[0][0] << 8 | argv
[0][1])
8450 case '>' << 8 | '=':
8451 result
= comp1
>= 0;
8453 case '!' << 8 | '<':
8454 result
= comp1
>= 0 || switch_value
== NULL
;
8459 case '!' << 8 | '>':
8460 result
= comp1
< 0 || switch_value
== NULL
;
8462 case '>' << 8 | '<':
8463 result
= comp1
>= 0 && comp2
< 0;
8465 case '<' << 8 | '>':
8466 result
= comp1
< 0 || comp2
>= 0;
8470 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
8475 return argv
[nargs
+ 2];
8478 /* %:include builtin spec function. This differs from %include in that it
8479 can be nested inside a spec, and thus be conditionalized. It takes
8480 one argument, the filename, and looks for it in the startfile path.
8481 The result is always NULL, i.e. an empty expansion. */
8484 include_spec_function (int argc
, const char **argv
)
8491 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8492 read_specs (file
? file
: argv
[0], FALSE
);
8497 /* %:find-file spec function. This function replaces its argument by
8498 the file found thru find_file, that is the -print-file-name gcc
8501 find_file_spec_function (int argc
, const char **argv
)
8508 file
= find_file (argv
[0]);
8513 /* %:find-plugindir spec function. This function replaces its argument
8514 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
8515 is the -print-file-name gcc program option. */
8517 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8524 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8529 /* %:print-asm-header spec function. Print a banner to say that the
8530 following output is from the assembler. */
8533 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8534 const char **argv ATTRIBUTE_UNUSED
)
8536 printf (_("Assembler options\n=================\n\n"));
8537 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8542 /* Compute a timestamp to initialize flag_random_seed. */
8545 get_local_tick (void)
8549 /* Get some more or less random data. */
8550 #ifdef HAVE_GETTIMEOFDAY
8554 gettimeofday (&tv
, NULL
);
8555 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8559 time_t now
= time (NULL
);
8561 if (now
!= (time_t)-1)
8562 ret
= (unsigned) now
;
8569 /* %:compare-debug-dump-opt spec function. Save the last argument,
8570 expected to be the last -fdump-final-insns option, or generate a
8574 compare_debug_dump_opt_spec_function (int arg
,
8575 const char **argv ATTRIBUTE_UNUSED
)
8580 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
8583 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8585 do_spec_2 ("%{fdump-final-insns=*:%*}");
8586 do_spec_1 (" ", 0, NULL
);
8588 if (argbuf_index
> 0 && strcmp (argv
[argbuf_index
- 1], "."))
8593 name
= xstrdup (argv
[argbuf_index
- 1]);
8598 const char *ext
= NULL
;
8600 if (argbuf_index
> 0)
8602 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8605 else if (!compare_debug
)
8608 do_spec_2 ("%g.gkd");
8610 do_spec_1 (" ", 0, NULL
);
8612 gcc_assert (argbuf_index
> 0);
8614 name
= concat (argbuf
[argbuf_index
- 1], ext
, NULL
);
8616 ret
= concat ("-fdump-final-insns=", name
, NULL
);
8619 which
= compare_debug
< 0;
8620 debug_check_temp_file
[which
] = name
;
8624 unsigned HOST_WIDE_INT value
= get_local_tick () ^ getpid ();
8626 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
8630 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
8639 static const char *debug_auxbase_opt
;
8641 /* %:compare-debug-self-opt spec function. Expands to the options
8642 that are to be passed in the second compilation of
8646 compare_debug_self_opt_spec_function (int arg
,
8647 const char **argv ATTRIBUTE_UNUSED
)
8650 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8652 if (compare_debug
>= 0)
8655 do_spec_2 ("%{c|S:%{o*:%*}}");
8656 do_spec_1 (" ", 0, NULL
);
8658 if (argbuf_index
> 0)
8659 debug_auxbase_opt
= concat ("-auxbase-strip ",
8660 argbuf
[argbuf_index
- 1],
8663 debug_auxbase_opt
= NULL
;
8666 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8667 %<fdump-final-insns=* -w -S -o %j \
8668 %{!fcompare-debug-second:-fcompare-debug-second} \
8669 ", compare_debug_opt
, NULL
);
8672 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8673 options that are to be passed in the second compilation of
8674 compare-debug. It expects, as an argument, the basename of the
8675 current input file name, with the .gk suffix appended to it. */
8678 compare_debug_auxbase_opt_spec_function (int arg
,
8685 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8688 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8690 if (compare_debug
>= 0)
8693 len
= strlen (argv
[0]);
8694 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
8695 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8696 "does not end in .gk");
8698 if (debug_auxbase_opt
)
8699 return debug_auxbase_opt
;
8701 #define OPT "-auxbase "
8704 name
= (char*) xmalloc (sizeof (OPT
) + len
);
8705 memcpy (name
, OPT
, sizeof (OPT
) - 1);
8706 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
8707 name
[sizeof (OPT
) - 1 + len
] = '\0';