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
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>.
22 This paragraph is here to try to keep Sun CC from dying.
23 The number of chars here seems crucial!!!! */
25 /* This program is the user interface to the C compiler and possibly to
26 other compilers. It is used because compilation is a complicated procedure
27 which involves running several programs and passing temporary files between
28 them, forwarding the users switches to those programs selectively,
29 and deleting the temporary files at the end.
31 CC recognizes how to compile each input file by suffixes in the file names.
32 Once it knows which kind of compilation to perform, the procedure for
33 compilation is specified by a string called a "spec". */
35 /* A Short Introduction to Adding a Command-Line Option.
37 Before adding a command-line option, consider if it is really
38 necessary. Each additional command-line option adds complexity and
39 is difficult to remove in subsequent versions.
41 In the following, consider adding the command-line argument
44 1. Each command-line option is specified in the specs file. The
45 notation is described below in the comment entitled "The Specs
48 2. In this file, add an entry to "option_map" equating the long
49 `--' argument version and any shorter, single letter version. Read
50 the comments in the declaration of "struct option_map" for an
51 explanation. Do not omit the first `-'.
53 3. Look in the "specs" file to determine which program or option
54 list should be given the argument, e.g., "cc1_options". Add the
55 appropriate syntax for the shorter option version to the
56 corresponding "const char *" entry in this file. Omit the first
57 `-' from the option. For example, use `-bar', rather than `--bar'.
59 4. If the argument takes an argument, e.g., `--baz argument1',
60 modify either DEFAULT_SWITCH_TAKES_ARG or
61 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
64 5. Document the option in this file's display_help(). If the
65 option is passed to a subprogram, modify its corresponding
66 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
69 6. Compile and test. Make sure that your new specs file is being
70 read. For example, use a debugger to investigate the value of
71 "specs_file" in main(). */
75 #include "coretypes.h"
76 #include "multilib.h" /* before tm.h */
79 #if ! defined( SIGCHLD ) && defined( SIGCLD )
80 # define SIGCHLD SIGCLD
91 /* By default there is no special suffix for target executables. */
92 /* FIXME: when autoconf is fixed, remove the host check - dj */
93 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
94 #define HAVE_TARGET_EXECUTABLE_SUFFIX
97 /* By default there is no special suffix for host executables. */
98 #ifdef HOST_EXECUTABLE_SUFFIX
99 #define HAVE_HOST_EXECUTABLE_SUFFIX
101 #define HOST_EXECUTABLE_SUFFIX ""
104 /* By default, the suffix for target object files is ".o". */
105 #ifdef TARGET_OBJECT_SUFFIX
106 #define HAVE_TARGET_OBJECT_SUFFIX
108 #define TARGET_OBJECT_SUFFIX ".o"
111 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
113 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
114 #ifndef LIBRARY_PATH_ENV
115 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
119 #define kill(p,s) raise(s)
122 /* If a stage of compilation returns an exit status >= 1,
123 compilation of that file ceases. */
125 #define MIN_FATAL_STATUS 1
127 /* Flag set by cppspec.c to 1. */
130 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
131 static bool at_file_supplied
;
133 /* Flag saying to pass the greatest exit code returned by a sub-process
134 to the calling program. */
135 static int pass_exit_codes
;
137 /* Definition of string containing the arguments given to configure. */
138 #include "configargs.h"
140 /* Flag saying to print the directories gcc will search through looking for
141 programs, libraries, etc. */
143 static int print_search_dirs
;
145 /* Flag saying to print the full filename of this file
146 as found through our usual search mechanism. */
148 static const char *print_file_name
= NULL
;
150 /* As print_file_name, but search for executable file. */
152 static const char *print_prog_name
= NULL
;
154 /* Flag saying to print the relative path we'd use to
155 find libgcc.a given the current compiler flags. */
157 static int print_multi_directory
;
159 /* Flag saying to print the relative path we'd use to
160 find OS libraries given the current compiler flags. */
162 static int print_multi_os_directory
;
164 /* Flag saying to print the list of subdirectories and
165 compiler flags used to select them in a standard form. */
167 static int print_multi_lib
;
169 /* Flag saying to print the command line options understood by gcc and its
172 static int print_help_list
;
174 /* Flag saying to print the sysroot suffix used for searching for
177 static int print_sysroot_headers_suffix
;
179 /* Flag indicating whether we should print the command and arguments */
181 static int verbose_flag
;
183 /* Flag indicating whether we should ONLY print the command and
184 arguments (like verbose_flag) without executing the command.
185 Displayed arguments are quoted so that the generated command
186 line is suitable for execution. This is intended for use in
187 shell scripts to capture the driver-generated command line. */
188 static int verbose_only_flag
;
190 /* Flag indicating how to print command line options of sub-processes. */
192 static int print_subprocess_help
;
194 /* Flag indicating whether we should report subprocess execution times
195 (if this is supported by the system - see pexecute.c). */
197 static int report_times
;
199 /* Flag indicating that we should start a server process. */
203 /* The number of server processes to start. Only meaningful if
206 static int server_count
= 1;
208 /* Flag indicating that we should kill a running server process. */
210 static int kill_server
;
212 /* Flag indicating that we should attempt to connect to a server
215 static int use_server
;
217 /* Nonzero means place this string before uses of /, so that include
218 and library files can be found in an alternate location. */
220 #ifdef TARGET_SYSTEM_ROOT
221 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
223 static const char *target_system_root
= 0;
226 /* Nonzero means pass the updated target_system_root to the compiler. */
228 static int target_system_root_changed
;
230 /* Nonzero means append this string to target_system_root. */
232 static const char *target_sysroot_suffix
= 0;
234 /* Nonzero means append this string to target_system_root for headers. */
236 static const char *target_sysroot_hdrs_suffix
= 0;
238 /* Nonzero means write "temp" files in source directory
239 and use the source file's name in them, and don't delete them. */
241 static int save_temps_flag
;
243 /* Nonzero means pass multiple source files to the compiler at one time. */
245 static int combine_flag
= 0;
247 /* Nonzero means use pipes to communicate between subprocesses.
248 Overridden by either of the above two flags. */
250 static int use_pipes
;
252 /* The compiler version. */
254 static const char *compiler_version
;
256 /* The target version specified with -V */
258 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
260 /* The target machine specified with -b. */
262 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
264 /* Nonzero if cross-compiling.
265 When -b is used, the value comes from the `specs' file. */
267 #ifdef CROSS_DIRECTORY_STRUCTURE
268 static const char *cross_compile
= "1";
270 static const char *cross_compile
= "0";
273 #ifdef MODIFY_TARGET_NAME
275 /* Information on how to alter the target name based on a command-line
276 switch. The only case we support now is simply appending or deleting a
277 string to or from the end of the first part of the configuration name. */
279 static const struct modify_target
281 const char *const sw
;
282 const enum add_del
{ADD
, DELETE
} add_del
;
283 const char *const str
;
285 modify_target
[] = MODIFY_TARGET_NAME
;
288 /* The number of errors that have occurred; the link phase will not be
289 run if this is nonzero. */
290 static int error_count
= 0;
292 /* Greatest exit code of sub-processes that has been encountered up to
294 static int greatest_status
= 1;
296 /* This is the obstack which we use to allocate many strings. */
298 static struct obstack obstack
;
300 /* This is the obstack to build an environment variable to pass to
301 collect2 that describes all of the relevant switches of what to
302 pass the compiler in building the list of pointers to constructors
305 static struct obstack collect_obstack
;
307 /* Forward declaration for prototypes. */
311 static void init_spec (void);
312 static void store_arg (const char *, int, int);
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 fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN
;
362 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1
;
363 static void display_help (void);
364 static void add_preprocessor_option (const char *, int);
365 static void add_assembler_option (const char *, int);
366 static void add_linker_option (const char *, int);
367 static void process_command (int, const char **);
368 static int execute (void);
369 static void alloc_args (void);
370 static void clear_args (void);
371 static void fatal_error (int);
372 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
373 static void init_gcc_specs (struct obstack
*, const char *, const char *,
376 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
377 static const char *convert_filename (const char *, int, int);
380 static const char *getenv_spec_function (int, const char **);
381 static const char *if_exists_spec_function (int, const char **);
382 static const char *if_exists_else_spec_function (int, const char **);
383 static const char *replace_outfile_spec_function (int, const char **);
384 static const char *version_compare_spec_function (int, const char **);
385 static const char *include_spec_function (int, const char **);
386 static const char *print_asm_header_spec_function (int, const char **);
388 /* The Specs Language
390 Specs are strings containing lines, each of which (if not blank)
391 is made up of a program name, and arguments separated by spaces.
392 The program name must be exact and start from root, since no path
393 is searched and it is unreliable to depend on the current working directory.
394 Redirection of input or output is not supported; the subprograms must
395 accept filenames saying what files to read and write.
397 In addition, the specs can contain %-sequences to substitute variable text
398 or for conditional text. Here is a table of all defined %-sequences.
399 Note that spaces are not generated automatically around the results of
400 expanding these sequences; therefore, you can concatenate them together
401 or with constant text in a single argument.
403 %% substitute one % into the program name or argument.
404 %i substitute the name of the input file being processed.
405 %b substitute the basename of the input file being processed.
406 This is the substring up to (and not including) the last period
407 and not including the directory.
408 %B same as %b, but include the file suffix (text after the last period).
410 substitute a file name that has suffix SUFFIX and is chosen
411 once per compilation, and mark the argument a la %d. To reduce
412 exposure to denial-of-service attacks, the file name is now
413 chosen in a way that is hard to predict even when previously
414 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
415 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
416 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
417 had been pre-processed. Previously, %g was simply substituted
418 with a file name chosen once per compilation, without regard
419 to any appended suffix (which was therefore treated just like
420 ordinary text), making such attacks more likely to succeed.
422 like %g, but if -pipe is in effect, expands simply to "-".
424 like %g, but if -pipe is in effect, expands to nothing. (We have both
425 %| and %m to accommodate differences between system assemblers; see
426 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
428 like %g, but generates a new temporary file name even if %uSUFFIX
431 substitutes the last file name generated with %uSUFFIX, generating a
432 new one if there is no such last file name. In the absence of any
433 %uSUFFIX, this is just like %gSUFFIX, except they don't share
434 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
435 would involve the generation of two distinct file names, one
436 for each `%g.s' and another for each `%U.s'. Previously, %U was
437 simply substituted with a file name chosen for the previous %u,
438 without regard to any appended suffix.
440 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
441 writable, and if save-temps is off; otherwise, substitute the name
442 of a temporary file, just like %u. This temporary file is not
443 meant for communication between processes, but rather as a junk
446 substitutes .SUFFIX for the suffixes of a matched switch's args when
447 it is subsequently output with %*. SUFFIX is terminated by the next
449 %d marks the argument containing or following the %d as a
450 temporary file name, so that that file will be deleted if CC exits
451 successfully. Unlike %g, this contributes no text to the argument.
452 %w marks the argument containing or following the %w as the
453 "output file" of this compilation. This puts the argument
454 into the sequence of arguments that %o will substitute later.
455 %V indicates that this compilation produces no "output file".
457 like %{...} but mark last argument supplied within
458 as a file to be deleted on failure.
459 %o substitutes the names of all the output files, with spaces
460 automatically placed around them. You should write spaces
461 around the %o as well or the results are undefined.
462 %o is for use in the specs for running the linker.
463 Input files whose names have no recognized suffix are not compiled
464 at all, but they are included among the output files, so they will
466 %O substitutes the suffix for object files. Note that this is
467 handled specially when it immediately follows %g, %u, or %U
468 (with or without a suffix argument) because of the need for
469 those to form complete file names. The handling is such that
470 %O is treated exactly as if it had already been substituted,
471 except that %g, %u, and %U do not currently support additional
472 SUFFIX characters following %O as they would following, for
474 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
475 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
476 and -B options) and -imultilib as necessary.
477 %s current argument is the name of a library or startup file of some sort.
478 Search for that file in a standard list of directories
479 and substitute the full name found.
480 %eSTR Print STR as an error message. STR is terminated by a newline.
481 Use this when inconsistent options are detected.
482 %nSTR Print STR as a notice. STR is terminated by a newline.
483 %x{OPTION} Accumulate an option for %X.
484 %X Output the accumulated linker options specified by compilations.
485 %Y Output the accumulated assembler options specified by compilations.
486 %Z Output the accumulated preprocessor options specified by compilations.
487 %a process ASM_SPEC as a spec.
488 This allows config.h to specify part of the spec for running as.
489 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
490 used here. This can be used to run a post-processor after the
491 assembler has done its job.
492 %D Dump out a -L option for each directory in startfile_prefixes.
493 If multilib_dir is set, extra entries are generated with it affixed.
494 %l process LINK_SPEC as a spec.
495 %L process LIB_SPEC as a spec.
496 %G process LIBGCC_SPEC as a spec.
497 %R Output the concatenation of target_system_root and
498 target_sysroot_suffix.
499 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
500 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
501 %C process CPP_SPEC as a spec.
502 %1 process CC1_SPEC as a spec.
503 %2 process CC1PLUS_SPEC as a spec.
504 %* substitute the variable part of a matched option. (See below.)
505 Note that each comma in the substituted string is replaced by
507 %<S remove all occurrences of -S from the command line.
508 Note - this command is position dependent. % commands in the
509 spec string before this one will see -S, % commands in the
510 spec string after this one will not.
511 %<S* remove all occurrences of all switches beginning with -S from the
514 Call the named function FUNCTION, passing it ARGS. ARGS is
515 first processed as a nested spec string, then split into an
516 argument vector in the usual fashion. The function returns
517 a string which is processed as if it had appeared literally
518 as part of the current spec.
519 %{S} substitutes the -S switch, if that switch was given to CC.
520 If that switch was not specified, this substitutes nothing.
521 Here S is a metasyntactic variable.
522 %{S*} substitutes all the switches specified to CC whose names start
523 with -S. This is used for -o, -I, etc; switches that take
524 arguments. CC considers `-o foo' as being one switch whose
525 name starts with `o'. %{o*} would substitute this text,
526 including the space; thus, two arguments would be generated.
527 %{S*&T*} likewise, but preserve order of S and T options (the order
528 of S and T in the spec is not significant). Can be any number
529 of ampersand-separated variables; for each the wild card is
530 optional. Useful for CPP as %{D*&U*&A*}.
532 %{S:X} substitutes X, if the -S switch was given to CC.
533 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
534 %{S*:X} substitutes X if one or more switches whose names start
535 with -S was given to CC. Normally X is substituted only
536 once, no matter how many such switches appeared. However,
537 if %* appears somewhere in X, then X will be substituted
538 once for each matching switch, with the %* replaced by the
539 part of that switch that matched the '*'.
540 %{.S:X} substitutes X, if processing a file with suffix S.
541 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
542 %{,S:X} substitutes X, if processing a file which will use spec S.
543 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
545 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
546 combined with '!', '.', ',', and '*' as above binding stronger
548 If %* appears in X, all of the alternatives must be starred, and
549 only the first matching alternative is substituted.
550 %{S:X; if S was given to CC, substitutes X;
551 T:Y; else if T was given to CC, substitutes Y;
552 :D} else substitutes D. There can be as many clauses as you need.
553 This may be combined with '.', '!', ',', '|', and '*' as above.
555 %(Spec) processes a specification defined in a specs file as *Spec:
556 %[Spec] as above, but put __ around -D arguments
558 The conditional text X in a %{S:X} or similar construct may contain
559 other nested % constructs or spaces, or even newlines. They are
560 processed as usual, as described above. Trailing white space in X is
561 ignored. White space may also appear anywhere on the left side of the
562 colon in these constructs, except between . or * and the corresponding
565 The -O, -f, -m, and -W switches are handled specifically in these
566 constructs. If another value of -O or the negated form of a -f, -m, or
567 -W switch is found later in the command line, the earlier switch
568 value is ignored, except with {S*} where S is just one letter; this
569 passes all matching options.
571 The character | at the beginning of the predicate text is used to indicate
572 that a command should be piped to the following command, but only if -pipe
575 Note that it is built into CC which switches take arguments and which
576 do not. You might think it would be useful to generalize this to
577 allow each compiler's spec to say which switches take arguments. But
578 this cannot be done in a consistent fashion. CC cannot even decide
579 which input files have been specified without knowing which switches
580 take arguments, and it must know which input files to compile in order
581 to tell which compilers to run.
583 CC also knows implicitly that arguments starting in `-l' are to be
584 treated as compiler output files, and passed to the linker in their
585 proper position among the other output files. */
587 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
589 /* config.h can define ASM_SPEC to provide extra args to the assembler
590 or extra switch-translations. */
595 /* config.h can define ASM_FINAL_SPEC to run a post processor after
596 the assembler has run. */
597 #ifndef ASM_FINAL_SPEC
598 #define ASM_FINAL_SPEC ""
601 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
602 or extra switch-translations. */
607 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
608 or extra switch-translations. */
613 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
614 or extra switch-translations. */
616 #define CC1PLUS_SPEC ""
619 /* config.h can define LINK_SPEC to provide extra args to the linker
620 or extra switch-translations. */
625 /* config.h can define LIB_SPEC to override the default libraries. */
627 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
632 /* XXX: valid only for GNU ld */
633 /* XXX: should exactly match hooks provided by libmudflap.a */
634 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
635 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
636 --wrap=mmap --wrap=munmap --wrap=alloca\
637 } %{fmudflapth: --wrap=pthread_create\
638 }} %{fmudflap|fmudflapth: --wrap=main}"
641 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
644 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
647 #if defined(REAL_LIBGCC_SPEC)
648 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
649 #elif defined(LINK_LIBGCC_SPECIAL_1)
650 /* Have gcc do the search for libgcc.a. */
651 #define LIBGCC_SPEC "libgcc.a%s"
653 #define LIBGCC_SPEC "-lgcc"
657 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
658 #ifndef STARTFILE_SPEC
659 #define STARTFILE_SPEC \
660 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
663 /* config.h can define SWITCHES_NEED_SPACES to control which options
664 require spaces between the option and the argument. */
665 #ifndef SWITCHES_NEED_SPACES
666 #define SWITCHES_NEED_SPACES ""
669 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
671 #define ENDFILE_SPEC ""
675 #define LINKER_NAME "collect2"
678 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
679 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
684 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
686 #ifndef ASM_DEBUG_SPEC
687 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
688 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
689 # define ASM_DEBUG_SPEC \
690 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
691 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" ASM_MAP \
692 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}" ASM_MAP)
694 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
695 # define ASM_DEBUG_SPEC "%{g*:--gstabs}" ASM_MAP
697 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
698 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}" ASM_MAP
702 #ifndef ASM_DEBUG_SPEC
703 # define ASM_DEBUG_SPEC ""
706 /* Here is the spec for running the linker, after compiling all files. */
708 /* This is overridable by the target in case they need to specify the
709 -lgcc and -lc order specially, yet not require them to override all
710 of LINK_COMMAND_SPEC. */
711 #ifndef LINK_GCC_C_SEQUENCE_SPEC
712 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
715 #ifndef LINK_SSP_SPEC
716 #ifdef TARGET_LIBC_PROVIDES_SSP
717 #define LINK_SSP_SPEC "%{fstack-protector:}"
719 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
723 #ifndef LINK_PIE_SPEC
725 #define LINK_PIE_SPEC "%{pie:-pie} "
727 #define LINK_PIE_SPEC "%{pie:} "
731 /* -u* was put back because both BSD and SysV seem to support it. */
732 /* %{static:} simply prevents an error message if the target machine
733 doesn't handle -static. */
734 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
735 scripts which exist in user specified directories, or in standard
737 #ifndef LINK_COMMAND_SPEC
738 #define LINK_COMMAND_SPEC "\
739 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
740 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
741 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
742 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
743 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
744 %{fprofile-arcs|fprofile-generate|coverage:-lgcov}\
745 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
746 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
749 #ifndef LINK_LIBGCC_SPEC
750 /* Generate -L options for startfile prefix list. */
751 # define LINK_LIBGCC_SPEC "%D"
754 #ifndef STARTFILE_PREFIX_SPEC
755 # define STARTFILE_PREFIX_SPEC ""
759 # define SYSROOT_SPEC "--sysroot=%R"
762 #ifndef SYSROOT_SUFFIX_SPEC
763 # define SYSROOT_SUFFIX_SPEC ""
766 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
767 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
770 static const char *asm_debug
;
771 static const char *cpp_spec
= CPP_SPEC
;
772 static const char *cc1_spec
= CC1_SPEC
;
773 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
774 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
775 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
776 static const char *asm_spec
= ASM_SPEC
;
777 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
778 static const char *link_spec
= LINK_SPEC
;
779 static const char *lib_spec
= LIB_SPEC
;
780 static const char *mfwrap_spec
= MFWRAP_SPEC
;
781 static const char *mflib_spec
= MFLIB_SPEC
;
782 static const char *link_gomp_spec
= "";
783 static const char *libgcc_spec
= LIBGCC_SPEC
;
784 static const char *endfile_spec
= ENDFILE_SPEC
;
785 static const char *startfile_spec
= STARTFILE_SPEC
;
786 static const char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
787 static const char *linker_name_spec
= LINKER_NAME
;
788 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
789 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
790 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
791 static const char *sysroot_spec
= SYSROOT_SPEC
;
792 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
793 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
795 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
796 There should be no need to override these in target dependent files,
797 but we need to copy them to the specs file so that newer versions
798 of the GCC driver can correctly drive older tool chains with the
799 appropriate -B options. */
801 /* When cpplib handles traditional preprocessing, get rid of this, and
802 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
803 that we default the front end language better. */
804 static const char *trad_capable_cpp
=
805 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
807 /* We don't wrap .d files in %W{} since a missing .d file, and
808 therefore no dependency entry, confuses make into thinking a .o
809 file that happens to exist is up-to-date. */
810 static const char *cpp_unique_options
=
811 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
812 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
813 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
814 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
815 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
816 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
817 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
818 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
819 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
820 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
823 /* This contains cpp options which are common with cc1_options and are passed
824 only when preprocessing only to avoid duplication. We pass the cc1 spec
825 options to the preprocessor so that it the cc1 spec may manipulate
826 options used to set target flags. Those special target flags settings may
827 in turn cause preprocessor symbols to be defined specially. */
828 static const char *cpp_options
=
829 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
830 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
831 %{undef} %{save-temps:-fpch-preprocess}";
833 /* This contains cpp options which are not passed when the preprocessor
834 output will be used by another program. */
835 static const char *cpp_debug_options
= "%{d*}";
837 /* NB: This is shared amongst all front-ends. */
838 static const char *cc1_options
=
839 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
840 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
841 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
842 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
843 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
844 %{Qn:-fno-ident} %{--help:--help}\
845 %{--target-help:--target-help}\
846 %{--help=*:--help=%(VALUE)}\
847 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
848 %{fsyntax-only:-o %j} %{-param*}\
849 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
850 %{coverage:-fprofile-arcs -ftest-coverage}";
852 static const char *asm_options
=
853 "%{--target-help:%:print-asm-header()} "
855 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
856 to the assembler equivalents. */
857 "%{v} %{w:-W} %{I*} "
859 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
861 static const char *invoke_as
=
862 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
863 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
865 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
868 /* Some compilers have limits on line lengths, and the multilib_select
869 and/or multilib_matches strings can be very long, so we build them at
871 static struct obstack multilib_obstack
;
872 static const char *multilib_select
;
873 static const char *multilib_matches
;
874 static const char *multilib_defaults
;
875 static const char *multilib_exclusions
;
877 /* Check whether a particular argument is a default argument. */
879 #ifndef MULTILIB_DEFAULTS
880 #define MULTILIB_DEFAULTS { "" }
883 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
885 #ifndef DRIVER_SELF_SPECS
886 #define DRIVER_SELF_SPECS ""
889 /* Adding -fopenmp should imply pthreads. This is particularly important
890 for targets that use different start files and suchlike. */
891 #ifndef GOMP_SELF_SPECS
892 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
895 static const char *const driver_self_specs
[] = {
896 DRIVER_SELF_SPECS
, GOMP_SELF_SPECS
899 #ifndef OPTION_DEFAULT_SPECS
900 #define OPTION_DEFAULT_SPECS { "", "" }
909 static const struct default_spec
910 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
914 struct user_specs
*next
;
915 const char *filename
;
918 static struct user_specs
*user_specs_head
, *user_specs_tail
;
920 #ifndef SWITCH_TAKES_ARG
921 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
924 #ifndef WORD_SWITCH_TAKES_ARG
925 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
928 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
929 /* This defines which switches stop a full compilation. */
930 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
931 ((CHAR) == 'c' || (CHAR) == 'S')
933 #ifndef SWITCH_CURTAILS_COMPILATION
934 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
935 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
939 /* Record the mapping from file suffixes for compilation specs. */
943 const char *suffix
; /* Use this compiler for input files
944 whose names end in this suffix. */
946 const char *spec
; /* To use this compiler, run this spec. */
948 const char *cpp_spec
; /* If non-NULL, substitute this spec
949 for `%C', rather than the usual
951 const int combinable
; /* If nonzero, compiler can deal with
952 multiple source files at once (IMA). */
953 const int needs_preprocessing
; /* If nonzero, source files need to
954 be run through a preprocessor. */
957 /* Pointer to a vector of `struct compiler' that gives the spec for
958 compiling a file, based on its suffix.
959 A file that does not end in any of these suffixes will be passed
960 unchanged to the loader and nothing else will be done to it.
962 An entry containing two 0s is used to terminate the vector.
964 If multiple entries match a file, the last matching one is used. */
966 static struct compiler
*compilers
;
968 /* Number of entries in `compilers', not counting the null terminator. */
970 static int n_compilers
;
972 /* The default list of file name suffixes and their compilation specs. */
974 static const struct compiler default_compilers
[] =
976 /* Add lists of suffixes of known languages here. If those languages
977 were not present when we built the driver, we will hit these copies
978 and be given a more meaningful error than "file not used since
979 linking is not done". */
980 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
981 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
982 {".mii", "#Objective-C++", 0, 0, 0},
983 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
984 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
985 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
986 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
987 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
988 {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0},
989 {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
990 {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
991 {".f90", "#Fortran", 0, 0, 0}, {".f95", "#Fortran", 0, 0, 0},
992 {".F90", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
993 {".r", "#Ratfor", 0, 0, 0},
994 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
995 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
996 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
997 /* Next come the entries for C. */
998 {".c", "@c", 0, 1, 1},
1000 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1001 external preprocessor if -save-temps is given. */
1002 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1004 %{traditional|ftraditional:\
1005 %eGNU C no longer supports -traditional without -E}\
1007 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1008 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
1009 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
1011 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
1012 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1013 %{!fsyntax-only:%(invoke_as)}} \
1015 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1016 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i}}\
1017 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
1018 cc1 %(cpp_unique_options) %(cc1_options)}}\
1019 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1021 "%{!E:%e-E or -x required when input is from standard input}\
1022 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1023 {".h", "@c-header", 0, 0, 0},
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 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1030 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
1031 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
1033 -o %g.s %{!o*:--output-pch=%i.gch}\
1034 %W{o*:--output-pch=%*}%V}\
1035 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
1036 cc1 %(cpp_unique_options) %(cc1_options)\
1037 -o %g.s %{!o*:--output-pch=%i.gch}\
1038 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1039 {".i", "@cpp-output", 0, 1, 0},
1041 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1042 {".s", "@assembler", 0, 1, 0},
1044 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1045 {".sx", "@assembler-with-cpp", 0, 1, 0},
1046 {".S", "@assembler-with-cpp", 0, 1, 0},
1047 {"@assembler-with-cpp",
1048 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1049 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1050 %{E|M|MM:%(cpp_debug_options)}\
1051 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1052 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1054 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1055 %{E|M|MM:%(cpp_debug_options)}\
1056 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1057 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1062 /* Mark end of table. */
1066 /* Number of elements in default_compilers, not counting the terminator. */
1068 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1070 /* A vector of options to give to the linker.
1071 These options are accumulated by %x,
1072 and substituted into the linker command with %X. */
1073 static int n_linker_options
;
1074 static char **linker_options
;
1076 /* A vector of options to give to the assembler.
1077 These options are accumulated by -Wa,
1078 and substituted into the assembler command with %Y. */
1079 static int n_assembler_options
;
1080 static char **assembler_options
;
1082 /* A vector of options to give to the preprocessor.
1083 These options are accumulated by -Wp,
1084 and substituted into the preprocessor command with %Z. */
1085 static int n_preprocessor_options
;
1086 static char **preprocessor_options
;
1088 /* Define how to map long options into short ones. */
1090 /* This structure describes one mapping. */
1093 /* The long option's name. */
1094 const char *const name
;
1095 /* The equivalent short option. */
1096 const char *const equivalent
;
1097 /* Argument info. A string of flag chars; NULL equals no options.
1098 a => argument required.
1099 o => argument optional.
1100 j => join argument to equivalent, making one word.
1101 * => require other text after NAME as an argument. */
1102 const char *const arg_info
;
1105 /* This is the table of mappings. Mappings are tried sequentially
1106 for each option encountered; the first one that matches, wins. */
1108 static const struct option_map option_map
[] =
1110 {"--all-warnings", "-Wall", 0},
1111 {"--ansi", "-ansi", 0},
1112 {"--assemble", "-S", 0},
1113 {"--assert", "-A", "a"},
1114 {"--classpath", "-fclasspath=", "aj"},
1115 {"--bootclasspath", "-fbootclasspath=", "aj"},
1116 {"--CLASSPATH", "-fclasspath=", "aj"},
1117 {"--combine", "-combine", 0},
1118 {"--comments", "-C", 0},
1119 {"--comments-in-macros", "-CC", 0},
1120 {"--compile", "-c", 0},
1121 {"--debug", "-g", "oj"},
1122 {"--define-macro", "-D", "aj"},
1123 {"--dependencies", "-M", 0},
1124 {"--dump", "-d", "a"},
1125 {"--dumpbase", "-dumpbase", "a"},
1126 {"--encoding", "-fencoding=", "aj"},
1127 {"--entry", "-e", 0},
1128 {"--extra-warnings", "-W", 0},
1129 {"--extdirs", "-fextdirs=", "aj"},
1130 {"--for-assembler", "-Wa", "a"},
1131 {"--for-linker", "-Xlinker", "a"},
1132 {"--force-link", "-u", "a"},
1133 {"--coverage", "-coverage", 0},
1134 {"--imacros", "-imacros", "a"},
1135 {"--include", "-include", "a"},
1136 {"--include-barrier", "-I-", 0},
1137 {"--include-directory", "-I", "aj"},
1138 {"--include-directory-after", "-idirafter", "a"},
1139 {"--include-prefix", "-iprefix", "a"},
1140 {"--include-with-prefix", "-iwithprefix", "a"},
1141 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1142 {"--include-with-prefix-after", "-iwithprefix", "a"},
1143 {"--kill-server", "-kill-server", 0},
1144 {"--language", "-x", "a"},
1145 {"--library-directory", "-L", "a"},
1146 {"--machine", "-m", "aj"},
1147 {"--machine-", "-m", "*j"},
1148 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1149 {"--no-line-commands", "-P", 0},
1150 {"--no-precompiled-includes", "-noprecomp", 0},
1151 {"--no-standard-includes", "-nostdinc", 0},
1152 {"--no-standard-libraries", "-nostdlib", 0},
1153 {"--no-warnings", "-w", 0},
1154 {"--optimize", "-O", "oj"},
1155 {"--output", "-o", "a"},
1156 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1157 {"--param", "--param", "a"},
1158 {"--pass-exit-codes", "-pass-exit-codes", 0},
1159 {"--pedantic", "-pedantic", 0},
1160 {"--pedantic-errors", "-pedantic-errors", 0},
1161 {"--pie", "-pie", 0},
1162 {"--pipe", "-pipe", 0},
1163 {"--prefix", "-B", "a"},
1164 {"--preprocess", "-E", 0},
1165 {"--print-search-dirs", "-print-search-dirs", 0},
1166 {"--print-file-name", "-print-file-name=", "aj"},
1167 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1168 {"--print-missing-file-dependencies", "-MG", 0},
1169 {"--print-multi-lib", "-print-multi-lib", 0},
1170 {"--print-multi-directory", "-print-multi-directory", 0},
1171 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1172 {"--print-prog-name", "-print-prog-name=", "aj"},
1173 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1174 {"--profile", "-p", 0},
1175 {"--profile-blocks", "-a", 0},
1176 {"--quiet", "-q", 0},
1177 {"--resource", "-fcompile-resource=", "aj"},
1178 {"--save-temps", "-save-temps", 0},
1179 {"--server", "-server", 0},
1180 {"--shared", "-shared", 0},
1181 {"--silent", "-q", 0},
1182 {"--specs", "-specs=", "aj"},
1183 {"--static", "-static", 0},
1184 {"--std", "-std=", "aj"},
1185 {"--symbolic", "-symbolic", 0},
1186 {"--sysroot", "--sysroot=", "aj"},
1187 {"--time", "-time", 0},
1188 {"--trace-includes", "-H", 0},
1189 {"--traditional", "-traditional", 0},
1190 {"--traditional-cpp", "-traditional-cpp", 0},
1191 {"--trigraphs", "-trigraphs", 0},
1192 {"--undefine-macro", "-U", "aj"},
1193 {"--user-dependencies", "-MM", 0},
1194 {"--verbose", "-v", 0},
1195 {"--warn-", "-W", "*j"},
1196 {"--write-dependencies", "-MD", 0},
1197 {"--write-user-dependencies", "-MMD", 0},
1202 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1203 static const struct {
1204 const char *const option_found
;
1205 const char *const replacements
;
1206 } target_option_translations
[] =
1208 TARGET_OPTION_TRANSLATE_TABLE
,
1213 /* Translate the options described by *ARGCP and *ARGVP.
1214 Make a new vector and store it back in *ARGVP,
1215 and store its length in *ARGVC. */
1218 translate_options (int *argcp
, const char *const **argvp
)
1222 const char *const *argv
= *argvp
;
1223 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1224 const char **newv
= xmalloc (newvsize
);
1228 newv
[newindex
++] = argv
[i
++];
1232 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1236 target_option_translations
[tott_idx
].option_found
;
1239 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1246 for (sp
= target_option_translations
[tott_idx
].replacements
;
1253 newvsize
+= spaces
* sizeof (const char *);
1254 newv
= xrealloc (newv
, newvsize
);
1256 sp
= target_option_translations
[tott_idx
].replacements
;
1265 newv
[newindex
++] = np
;
1266 while (*np
!= ' ' && *np
)
1277 if (target_option_translations
[tott_idx
].option_found
)
1281 /* Translate -- options. */
1282 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1285 /* Find a mapping that applies to this option. */
1286 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1288 size_t optlen
= strlen (option_map
[j
].name
);
1289 size_t arglen
= strlen (argv
[i
]);
1290 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1291 const char *arginfo
= option_map
[j
].arg_info
;
1296 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1298 const char *arg
= 0;
1300 if (arglen
< optlen
)
1303 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1304 if (strlen (option_map
[k
].name
) >= arglen
1305 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1307 error ("ambiguous abbreviation %s", argv
[i
]);
1311 if (k
!= ARRAY_SIZE (option_map
))
1315 if (arglen
> optlen
)
1317 /* If the option has an argument, accept that. */
1318 if (argv
[i
][optlen
] == '=')
1319 arg
= argv
[i
] + optlen
+ 1;
1321 /* If this mapping requires extra text at end of name,
1322 accept that as "argument". */
1323 else if (strchr (arginfo
, '*') != 0)
1324 arg
= argv
[i
] + optlen
;
1326 /* Otherwise, extra text at end means mismatch.
1327 Try other mappings. */
1332 else if (strchr (arginfo
, '*') != 0)
1334 error ("incomplete '%s' option", option_map
[j
].name
);
1338 /* Handle arguments. */
1339 if (strchr (arginfo
, 'a') != 0)
1345 error ("missing argument to '%s' option",
1346 option_map
[j
].name
);
1353 else if (strchr (arginfo
, '*') != 0)
1355 else if (strchr (arginfo
, 'o') == 0)
1358 error ("extraneous argument to '%s' option",
1359 option_map
[j
].name
);
1363 /* Store the translation as one argv elt or as two. */
1364 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1365 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1369 newv
[newindex
++] = option_map
[j
].equivalent
;
1370 newv
[newindex
++] = arg
;
1373 newv
[newindex
++] = option_map
[j
].equivalent
;
1381 /* Handle old-fashioned options--just copy them through,
1382 with their arguments. */
1383 else if (argv
[i
][0] == '-')
1385 const char *p
= argv
[i
] + 1;
1389 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1390 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1391 else if (WORD_SWITCH_TAKES_ARG (p
))
1392 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1393 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1396 else if (! strcmp (p
, "Xlinker"))
1398 else if (! strcmp (p
, "Xpreprocessor"))
1400 else if (! strcmp (p
, "Xassembler"))
1403 /* Watch out for an option at the end of the command line that
1404 is missing arguments, and avoid skipping past the end of the
1406 if (nskip
+ i
> argc
)
1411 newv
[newindex
++] = argv
[i
++];
1416 /* Ordinary operands, or +e options. */
1417 newv
[newindex
++] = argv
[i
++];
1427 skip_whitespace (char *p
)
1431 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1432 be considered whitespace. */
1433 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1435 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1449 /* Structures to keep track of prefixes to try when looking for files. */
1453 const char *prefix
; /* String to prepend to the path. */
1454 struct prefix_list
*next
; /* Next in linked list. */
1455 int require_machine_suffix
; /* Don't use without machine_suffix. */
1456 /* 2 means try both machine_suffix and just_machine_suffix. */
1457 int priority
; /* Sort key - priority within list. */
1458 int os_multilib
; /* 1 if OS multilib scheme should be used,
1459 0 for GCC multilib scheme. */
1464 struct prefix_list
*plist
; /* List of prefixes to try */
1465 int max_len
; /* Max length of a prefix in PLIST */
1466 const char *name
; /* Name of this list (used in config stuff) */
1469 /* List of prefixes to try when looking for executables. */
1471 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1473 /* List of prefixes to try when looking for startup (crt0) files. */
1475 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1477 /* List of prefixes to try when looking for include files. */
1479 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1481 /* Suffix to attach to directories searched for commands.
1482 This looks like `MACHINE/VERSION/'. */
1484 static const char *machine_suffix
= 0;
1486 /* Suffix to attach to directories searched for commands.
1487 This is just `MACHINE/'. */
1489 static const char *just_machine_suffix
= 0;
1491 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1493 static const char *gcc_exec_prefix
;
1495 /* Adjusted value of standard_libexec_prefix. */
1497 static const char *gcc_libexec_prefix
;
1499 /* Default prefixes to attach to command names. */
1501 #ifndef STANDARD_STARTFILE_PREFIX_1
1502 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1504 #ifndef STANDARD_STARTFILE_PREFIX_2
1505 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1508 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1509 #undef MD_EXEC_PREFIX
1510 #undef MD_STARTFILE_PREFIX
1511 #undef MD_STARTFILE_PREFIX_1
1514 /* If no prefixes defined, use the null string, which will disable them. */
1515 #ifndef MD_EXEC_PREFIX
1516 #define MD_EXEC_PREFIX ""
1518 #ifndef MD_STARTFILE_PREFIX
1519 #define MD_STARTFILE_PREFIX ""
1521 #ifndef MD_STARTFILE_PREFIX_1
1522 #define MD_STARTFILE_PREFIX_1 ""
1525 /* These directories are locations set at configure-time based on the
1526 --prefix option provided to configure. Their initializers are
1527 defined in Makefile.in. These paths are not *directly* used when
1528 gcc_exec_prefix is set because, in that case, we know where the
1529 compiler has been installed, and use paths relative to that
1530 location instead. */
1531 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1532 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1533 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1534 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1536 /* For native compilers, these are well-known paths containing
1537 components that may be provided by the system. For cross
1538 compilers, these paths are not used. */
1539 static const char *const standard_exec_prefix_1
= "/usr/libexec/gcc/";
1540 static const char *const standard_exec_prefix_2
= "/usr/lib/gcc/";
1541 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1542 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1543 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1544 static const char *const standard_startfile_prefix_1
1545 = STANDARD_STARTFILE_PREFIX_1
;
1546 static const char *const standard_startfile_prefix_2
1547 = STANDARD_STARTFILE_PREFIX_2
;
1549 /* A relative path to be used in finding the location of tools
1550 relative to the driver. */
1551 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1553 /* Subdirectory to use for locating libraries. Set by
1554 set_multilib_dir based on the compilation options. */
1556 static const char *multilib_dir
;
1558 /* Subdirectory to use for locating libraries in OS conventions. Set by
1559 set_multilib_dir based on the compilation options. */
1561 static const char *multilib_os_dir
;
1563 /* Structure to keep track of the specs that have been defined so far.
1564 These are accessed using %(specname) or %[specname] in a compiler
1569 /* The following 2 fields must be first */
1570 /* to allow EXTRA_SPECS to be initialized */
1571 const char *name
; /* name of the spec. */
1572 const char *ptr
; /* available ptr if no static pointer */
1574 /* The following fields are not initialized */
1575 /* by EXTRA_SPECS */
1576 const char **ptr_spec
; /* pointer to the spec itself. */
1577 struct spec_list
*next
; /* Next spec in linked list. */
1578 int name_len
; /* length of the name */
1579 int alloc_p
; /* whether string was allocated */
1582 #define INIT_STATIC_SPEC(NAME,PTR) \
1583 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1585 /* List of statically defined specs. */
1586 static struct spec_list static_specs
[] =
1588 INIT_STATIC_SPEC ("asm", &asm_spec
),
1589 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1590 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1591 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1592 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1593 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1594 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1595 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1596 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1597 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1598 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1599 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1600 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1601 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1602 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1603 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1604 INIT_STATIC_SPEC ("link", &link_spec
),
1605 INIT_STATIC_SPEC ("lib", &lib_spec
),
1606 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1607 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1608 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1609 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1610 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1611 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces
),
1612 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1613 INIT_STATIC_SPEC ("version", &compiler_version
),
1614 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1615 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1616 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1617 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1618 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1619 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1620 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1621 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1622 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1623 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1624 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1625 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1626 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1627 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1628 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1631 #ifdef EXTRA_SPECS /* additional specs needed */
1632 /* Structure to keep track of just the first two args of a spec_list.
1633 That is all that the EXTRA_SPECS macro gives us. */
1636 const char *const name
;
1637 const char *const ptr
;
1640 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1641 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1644 /* List of dynamically allocates specs that have been defined so far. */
1646 static struct spec_list
*specs
= (struct spec_list
*) 0;
1648 /* List of static spec functions. */
1650 static const struct spec_function static_spec_functions
[] =
1652 { "getenv", getenv_spec_function
},
1653 { "if-exists", if_exists_spec_function
},
1654 { "if-exists-else", if_exists_else_spec_function
},
1655 { "replace-outfile", replace_outfile_spec_function
},
1656 { "version-compare", version_compare_spec_function
},
1657 { "include", include_spec_function
},
1658 { "print-asm-header", print_asm_header_spec_function
},
1659 #ifdef EXTRA_SPEC_FUNCTIONS
1660 EXTRA_SPEC_FUNCTIONS
1665 static int processing_spec_function
;
1667 /* Add appropriate libgcc specs to OBSTACK, taking into account
1668 various permutations of -shared-libgcc, -shared, and such. */
1670 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1672 #ifndef USE_LD_AS_NEEDED
1673 #define USE_LD_AS_NEEDED 0
1677 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1678 const char *static_name
, const char *eh_name
)
1682 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1683 "%{!static:%{!static-libgcc:"
1684 #if USE_LD_AS_NEEDED
1685 "%{!shared-libgcc:",
1686 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1689 shared_name
, "%{!shared: ", static_name
, "}"
1693 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1694 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1698 "%{shared-libgcc:", shared_name
, "}"
1699 "%{!shared-libgcc:", static_name
, "}"
1702 "%{shared:", shared_name
, "}"
1707 obstack_grow (obstack
, buf
, strlen (buf
));
1710 #endif /* ENABLE_SHARED_LIBGCC */
1712 /* Initialize the specs lookup routines. */
1717 struct spec_list
*next
= (struct spec_list
*) 0;
1718 struct spec_list
*sl
= (struct spec_list
*) 0;
1722 return; /* Already initialized. */
1725 notice ("Using built-in specs.\n");
1728 extra_specs
= xcalloc (sizeof (struct spec_list
),
1729 ARRAY_SIZE (extra_specs_1
));
1731 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1733 sl
= &extra_specs
[i
];
1734 sl
->name
= extra_specs_1
[i
].name
;
1735 sl
->ptr
= extra_specs_1
[i
].ptr
;
1737 sl
->name_len
= strlen (sl
->name
);
1738 sl
->ptr_spec
= &sl
->ptr
;
1743 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1745 sl
= &static_specs
[i
];
1750 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1751 /* ??? If neither -shared-libgcc nor --static-libgcc was
1752 seen, then we should be making an educated guess. Some proposed
1753 heuristics for ELF include:
1755 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1756 program will be doing dynamic loading, which will likely
1757 need the shared libgcc.
1759 (2) If "-ldl", then it's also a fair bet that we're doing
1762 (3) For each ET_DYN we're linking against (either through -lfoo
1763 or /some/path/foo.so), check to see whether it or one of
1764 its dependencies depends on a shared libgcc.
1768 If the runtime is fixed to look for program headers instead
1769 of calling __register_frame_info at all, for each object,
1770 use the shared libgcc if any EH symbol referenced.
1772 If crtstuff is fixed to not invoke __register_frame_info
1773 automatically, for each object, use the shared libgcc if
1774 any non-empty unwind section found.
1776 Doing any of this probably requires invoking an external program to
1777 do the actual object file scanning. */
1779 const char *p
= libgcc_spec
;
1782 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1783 when given the proper command line arguments. */
1786 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1788 init_gcc_specs (&obstack
,
1790 #ifdef USE_LIBUNWIND_EXCEPTIONS
1796 #ifdef USE_LIBUNWIND_EXCEPTIONS
1797 # ifdef HAVE_LD_STATIC_DYNAMIC
1798 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1808 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1810 /* Ug. We don't know shared library extensions. Hope that
1811 systems that use this form don't do shared libraries. */
1812 init_gcc_specs (&obstack
,
1816 #ifdef USE_LIBUNWIND_EXCEPTIONS
1825 obstack_1grow (&obstack
, *p
);
1826 in_sep
= (*p
== ' ');
1831 obstack_1grow (&obstack
, '\0');
1832 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1835 #ifdef USE_AS_TRADITIONAL_FORMAT
1836 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1838 static const char tf
[] = "--traditional-format ";
1839 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1840 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1841 asm_spec
= XOBFINISH (&obstack
, const char *);
1845 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1846 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1847 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1848 link_spec
= XOBFINISH (&obstack
, const char *);
1854 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1855 removed; If the spec starts with a + then SPEC is added to the end of the
1859 set_spec (const char *name
, const char *spec
)
1861 struct spec_list
*sl
;
1862 const char *old_spec
;
1863 int name_len
= strlen (name
);
1866 /* If this is the first call, initialize the statically allocated specs. */
1869 struct spec_list
*next
= (struct spec_list
*) 0;
1870 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1872 sl
= &static_specs
[i
];
1879 /* See if the spec already exists. */
1880 for (sl
= specs
; sl
; sl
= sl
->next
)
1881 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1886 /* Not found - make it. */
1887 sl
= XNEW (struct spec_list
);
1888 sl
->name
= xstrdup (name
);
1889 sl
->name_len
= name_len
;
1890 sl
->ptr_spec
= &sl
->ptr
;
1892 *(sl
->ptr_spec
) = "";
1897 old_spec
= *(sl
->ptr_spec
);
1898 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1899 ? concat (old_spec
, spec
+ 1, NULL
)
1904 notice ("Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1907 /* Free the old spec. */
1908 if (old_spec
&& sl
->alloc_p
)
1909 free (CONST_CAST(char *, old_spec
));
1914 /* Accumulate a command (program name and args), and run it. */
1916 /* Vector of pointers to arguments in the current line of specifications. */
1918 static const char **argbuf
;
1920 /* Number of elements allocated in argbuf. */
1922 static int argbuf_length
;
1924 /* Number of elements in argbuf currently in use (containing args). */
1926 static int argbuf_index
;
1928 /* Position in the argbuf array containing the name of the output file
1929 (the value associated with the "-o" flag). */
1931 static int have_o_argbuf_index
= 0;
1933 /* Were the options -c or -S passed. */
1934 static int have_c
= 0;
1936 /* Was the option -o passed. */
1937 static int have_o
= 0;
1939 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1940 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1943 static struct temp_name
{
1944 const char *suffix
; /* suffix associated with the code. */
1945 int length
; /* strlen (suffix). */
1946 int unique
; /* Indicates whether %g or %u/%U was used. */
1947 const char *filename
; /* associated filename. */
1948 int filename_length
; /* strlen (filename). */
1949 struct temp_name
*next
;
1952 /* Number of commands executed so far. */
1954 static int execution_count
;
1956 /* Number of commands that exited with a signal. */
1958 static int signal_count
;
1960 /* Name with which this program was invoked. */
1962 static const char *programname
;
1964 /* Allocate the argument vector. */
1970 argbuf
= XNEWVEC (const char *, argbuf_length
);
1973 /* Clear out the vector of arguments (after a command is executed). */
1981 /* Add one argument to the vector at the end.
1982 This is done when a space is seen or at the end of the line.
1983 If DELETE_ALWAYS is nonzero, the arg is a filename
1984 and the file should be deleted eventually.
1985 If DELETE_FAILURE is nonzero, the arg is a filename
1986 and the file should be deleted if this compilation fails. */
1989 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1991 if (argbuf_index
+ 1 == argbuf_length
)
1992 argbuf
= xrealloc (argbuf
, (argbuf_length
*= 2) * sizeof (const char *));
1994 argbuf
[argbuf_index
++] = arg
;
1995 argbuf
[argbuf_index
] = 0;
1997 if (strcmp (arg
, "-o") == 0)
1998 have_o_argbuf_index
= argbuf_index
;
1999 if (delete_always
|| delete_failure
)
2000 record_temp_file (arg
, delete_always
, delete_failure
);
2003 /* Load specs from a file name named FILENAME, replacing occurrences of
2004 various different types of line-endings, \r\n, \n\r and just \r, with
2008 load_specs (const char *filename
)
2012 struct stat statbuf
;
2019 notice ("Reading specs from %s\n", filename
);
2021 /* Open and stat the file. */
2022 desc
= open (filename
, O_RDONLY
, 0);
2024 pfatal_with_name (filename
);
2025 if (stat (filename
, &statbuf
) < 0)
2026 pfatal_with_name (filename
);
2028 /* Read contents of file into BUFFER. */
2029 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2030 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2032 pfatal_with_name (filename
);
2033 buffer
[readlen
] = 0;
2036 specs
= XNEWVEC (char, readlen
+ 1);
2038 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2044 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2046 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2060 /* Read compilation specs from a file named FILENAME,
2061 replacing the default ones.
2063 A suffix which starts with `*' is a definition for
2064 one of the machine-specific sub-specs. The "suffix" should be
2065 *asm, *cc1, *cpp, *link, *startfile, etc.
2066 The corresponding spec is stored in asm_spec, etc.,
2067 rather than in the `compilers' vector.
2069 Anything invalid in the file is a fatal error. */
2072 read_specs (const char *filename
, int main_p
)
2077 buffer
= load_specs (filename
);
2079 /* Scan BUFFER for specs, putting them in the vector. */
2085 char *in
, *out
, *p1
, *p2
, *p3
;
2087 /* Advance P in BUFFER to the next nonblank nocomment line. */
2088 p
= skip_whitespace (p
);
2092 /* Is this a special command that starts with '%'? */
2093 /* Don't allow this for the main specs file, since it would
2094 encourage people to overwrite it. */
2095 if (*p
== '%' && !main_p
)
2098 while (*p
&& *p
!= '\n')
2104 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2105 && (p1
[sizeof "%include" - 1] == ' '
2106 || p1
[sizeof "%include" - 1] == '\t'))
2110 p1
+= sizeof ("%include");
2111 while (*p1
== ' ' || *p1
== '\t')
2114 if (*p1
++ != '<' || p
[-2] != '>')
2115 fatal ("specs %%include syntax malformed after %ld characters",
2116 (long) (p1
- buffer
+ 1));
2119 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2120 read_specs (new_filename
? new_filename
: p1
, FALSE
);
2123 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2124 && (p1
[sizeof "%include_noerr" - 1] == ' '
2125 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2129 p1
+= sizeof "%include_noerr";
2130 while (*p1
== ' ' || *p1
== '\t')
2133 if (*p1
++ != '<' || p
[-2] != '>')
2134 fatal ("specs %%include syntax malformed after %ld characters",
2135 (long) (p1
- buffer
+ 1));
2138 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2140 read_specs (new_filename
, FALSE
);
2141 else if (verbose_flag
)
2142 notice ("could not find specs file %s\n", p1
);
2145 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2146 && (p1
[sizeof "%rename" - 1] == ' '
2147 || p1
[sizeof "%rename" - 1] == '\t'))
2150 struct spec_list
*sl
;
2151 struct spec_list
*newsl
;
2153 /* Get original name. */
2154 p1
+= sizeof "%rename";
2155 while (*p1
== ' ' || *p1
== '\t')
2158 if (! ISALPHA ((unsigned char) *p1
))
2159 fatal ("specs %%rename syntax malformed after %ld characters",
2160 (long) (p1
- buffer
));
2163 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2166 if (*p2
!= ' ' && *p2
!= '\t')
2167 fatal ("specs %%rename syntax malformed after %ld characters",
2168 (long) (p2
- buffer
));
2172 while (*p2
== ' ' || *p2
== '\t')
2175 if (! ISALPHA ((unsigned char) *p2
))
2176 fatal ("specs %%rename syntax malformed after %ld characters",
2177 (long) (p2
- buffer
));
2179 /* Get new spec name. */
2181 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2185 fatal ("specs %%rename syntax malformed after %ld characters",
2186 (long) (p3
- buffer
));
2189 for (sl
= specs
; sl
; sl
= sl
->next
)
2190 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2194 fatal ("specs %s spec was not found to be renamed", p1
);
2196 if (strcmp (p1
, p2
) == 0)
2199 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2200 if (strcmp (newsl
->name
, p2
) == 0)
2201 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2206 notice ("rename spec %s to %s\n", p1
, p2
);
2208 notice ("spec is '%s'\n\n", *(sl
->ptr_spec
));
2212 set_spec (p2
, *(sl
->ptr_spec
));
2214 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2216 *(sl
->ptr_spec
) = "";
2221 fatal ("specs unknown %% command after %ld characters",
2222 (long) (p1
- buffer
));
2225 /* Find the colon that should end the suffix. */
2227 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2230 /* The colon shouldn't be missing. */
2232 fatal ("specs file malformed after %ld characters",
2233 (long) (p1
- buffer
));
2235 /* Skip back over trailing whitespace. */
2237 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2240 /* Copy the suffix to a string. */
2241 suffix
= save_string (p
, p2
- p
);
2242 /* Find the next line. */
2243 p
= skip_whitespace (p1
+ 1);
2245 fatal ("specs file malformed after %ld characters",
2246 (long) (p
- buffer
));
2249 /* Find next blank line or end of string. */
2250 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2253 /* Specs end at the blank line and do not include the newline. */
2254 spec
= save_string (p
, p1
- p
);
2257 /* Delete backslash-newline sequences from the spec. */
2262 if (in
[0] == '\\' && in
[1] == '\n')
2264 else if (in
[0] == '#')
2265 while (*in
&& *in
!= '\n')
2273 if (suffix
[0] == '*')
2275 if (! strcmp (suffix
, "*link_command"))
2276 link_command_spec
= spec
;
2278 set_spec (suffix
+ 1, spec
);
2282 /* Add this pair to the vector. */
2284 = xrealloc (compilers
,
2285 (n_compilers
+ 2) * sizeof (struct compiler
));
2287 compilers
[n_compilers
].suffix
= suffix
;
2288 compilers
[n_compilers
].spec
= spec
;
2290 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2294 link_command_spec
= spec
;
2297 if (link_command_spec
== 0)
2298 fatal ("spec file has no spec for linking");
2301 /* Record the names of temporary files we tell compilers to write,
2302 and delete them at the end of the run. */
2304 /* This is the common prefix we use to make temp file names.
2305 It is chosen once for each run of this program.
2306 It is substituted into a spec by %g or %j.
2307 Thus, all temp file names contain this prefix.
2308 In practice, all temp file names start with this prefix.
2310 This prefix comes from the envvar TMPDIR if it is defined;
2311 otherwise, from the P_tmpdir macro if that is defined;
2312 otherwise, in /usr/tmp or /tmp;
2313 or finally the current directory if all else fails. */
2315 static const char *temp_filename
;
2317 /* Length of the prefix. */
2319 static int temp_filename_length
;
2321 /* Define the list of temporary files to delete. */
2326 struct temp_file
*next
;
2329 /* Queue of files to delete on success or failure of compilation. */
2330 static struct temp_file
*always_delete_queue
;
2331 /* Queue of files to delete on failure of compilation. */
2332 static struct temp_file
*failure_delete_queue
;
2334 /* Record FILENAME as a file to be deleted automatically.
2335 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2336 otherwise delete it in any case.
2337 FAIL_DELETE nonzero means delete it if a compilation step fails;
2338 otherwise delete it in any case. */
2341 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2343 char *const name
= xstrdup (filename
);
2347 struct temp_file
*temp
;
2348 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2349 if (! strcmp (name
, temp
->name
))
2352 temp
= XNEW (struct temp_file
);
2353 temp
->next
= always_delete_queue
;
2355 always_delete_queue
= temp
;
2362 struct temp_file
*temp
;
2363 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2364 if (! strcmp (name
, temp
->name
))
2367 temp
= XNEW (struct temp_file
);
2368 temp
->next
= failure_delete_queue
;
2370 failure_delete_queue
= temp
;
2376 /* Delete all the temporary files whose names we previously recorded. */
2378 #ifndef DELETE_IF_ORDINARY
2379 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2382 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2383 if (unlink (NAME) < 0) \
2385 perror_with_name (NAME); \
2390 delete_if_ordinary (const char *name
)
2396 printf ("Delete %s? (y or n) ", name
);
2400 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2403 if (i
== 'y' || i
== 'Y')
2405 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2409 delete_temp_files (void)
2411 struct temp_file
*temp
;
2413 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2414 delete_if_ordinary (temp
->name
);
2415 always_delete_queue
= 0;
2418 /* Delete all the files to be deleted on error. */
2421 delete_failure_queue (void)
2423 struct temp_file
*temp
;
2425 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2426 delete_if_ordinary (temp
->name
);
2430 clear_failure_queue (void)
2432 failure_delete_queue
= 0;
2435 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2437 If DO_MULTI is true iterate over the paths twice, first with multilib
2438 suffix then without, otherwise iterate over the paths once without
2439 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2440 to avoid visiting the same path twice, but we could do better. For
2441 instance, /usr/lib/../lib is considered different from /usr/lib.
2442 At least EXTRA_SPACE chars past the end of the path passed to
2443 CALLBACK are available for use by the callback.
2444 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2446 Returns the value returned by CALLBACK. */
2449 for_each_path (const struct path_prefix
*paths
,
2452 void *(*callback
) (char *, void *),
2453 void *callback_info
)
2455 struct prefix_list
*pl
;
2456 const char *multi_dir
= NULL
;
2457 const char *multi_os_dir
= NULL
;
2458 const char *multi_suffix
;
2459 const char *just_multi_suffix
;
2462 bool skip_multi_dir
= false;
2463 bool skip_multi_os_dir
= false;
2465 multi_suffix
= machine_suffix
;
2466 just_multi_suffix
= just_machine_suffix
;
2467 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2469 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2470 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2471 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2473 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2474 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2478 size_t multi_dir_len
= 0;
2479 size_t multi_os_dir_len
= 0;
2481 size_t just_suffix_len
;
2485 multi_dir_len
= strlen (multi_dir
);
2487 multi_os_dir_len
= strlen (multi_os_dir
);
2488 suffix_len
= strlen (multi_suffix
);
2489 just_suffix_len
= strlen (just_multi_suffix
);
2493 len
= paths
->max_len
+ extra_space
+ 1;
2494 if (suffix_len
> multi_os_dir_len
)
2497 len
+= multi_os_dir_len
;
2498 path
= XNEWVEC (char, len
);
2501 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2503 len
= strlen (pl
->prefix
);
2504 memcpy (path
, pl
->prefix
, len
);
2506 /* Look first in MACHINE/VERSION subdirectory. */
2507 if (!skip_multi_dir
)
2509 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2510 ret
= callback (path
, callback_info
);
2515 /* Some paths are tried with just the machine (ie. target)
2516 subdir. This is used for finding as, ld, etc. */
2518 && pl
->require_machine_suffix
== 2)
2520 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2521 ret
= callback (path
, callback_info
);
2526 /* Now try the base path. */
2527 if (!pl
->require_machine_suffix
2528 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2530 const char *this_multi
;
2531 size_t this_multi_len
;
2533 if (pl
->os_multilib
)
2535 this_multi
= multi_os_dir
;
2536 this_multi_len
= multi_os_dir_len
;
2540 this_multi
= multi_dir
;
2541 this_multi_len
= multi_dir_len
;
2545 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2549 ret
= callback (path
, callback_info
);
2557 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2560 /* Run through the paths again, this time without multilibs.
2561 Don't repeat any we have already seen. */
2564 free (CONST_CAST (char *, multi_dir
));
2566 free (CONST_CAST (char *, multi_suffix
));
2567 multi_suffix
= machine_suffix
;
2568 free (CONST_CAST (char *, just_multi_suffix
));
2569 just_multi_suffix
= just_machine_suffix
;
2572 skip_multi_dir
= true;
2575 free (CONST_CAST (char *, multi_os_dir
));
2576 multi_os_dir
= NULL
;
2579 skip_multi_os_dir
= true;
2584 free (CONST_CAST (char *, multi_dir
));
2585 free (CONST_CAST (char *, multi_suffix
));
2586 free (CONST_CAST (char *, just_multi_suffix
));
2589 free (CONST_CAST (char *, multi_os_dir
));
2595 /* Callback for build_search_list. Adds path to obstack being built. */
2597 struct add_to_obstack_info
{
2604 add_to_obstack (char *path
, void *data
)
2606 struct add_to_obstack_info
*info
= data
;
2608 if (info
->check_dir
&& !is_directory (path
, false))
2611 if (!info
->first_time
)
2612 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2614 obstack_grow (info
->ob
, path
, strlen (path
));
2616 info
->first_time
= false;
2620 /* Add or change the value of an environment variable, outputting the
2621 change to standard error if in verbose mode. */
2623 xputenv (const char *string
)
2626 notice ("%s\n", string
);
2627 putenv (CONST_CAST (char *, string
));
2630 /* Build a list of search directories from PATHS.
2631 PREFIX is a string to prepend to the list.
2632 If CHECK_DIR_P is true we ensure the directory exists.
2633 If DO_MULTI is true, multilib paths are output first, then
2635 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2636 It is also used by the --print-search-dirs flag. */
2639 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2640 bool check_dir
, bool do_multi
)
2642 struct add_to_obstack_info info
;
2644 info
.ob
= &collect_obstack
;
2645 info
.check_dir
= check_dir
;
2646 info
.first_time
= true;
2648 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2649 obstack_1grow (&collect_obstack
, '=');
2651 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2653 obstack_1grow (&collect_obstack
, '\0');
2654 return XOBFINISH (&collect_obstack
, char *);
2657 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2661 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2664 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2667 /* Check whether NAME can be accessed in MODE. This is like access,
2668 except that it never considers directories to be executable. */
2671 access_check (const char *name
, int mode
)
2677 if (stat (name
, &st
) < 0
2678 || S_ISDIR (st
.st_mode
))
2682 return access (name
, mode
);
2685 /* Callback for find_a_file. Appends the file name to the directory
2686 path. If the resulting file exists in the right mode, return the
2687 full pathname to the file. */
2689 struct file_at_path_info
{
2698 file_at_path (char *path
, void *data
)
2700 struct file_at_path_info
*info
= data
;
2701 size_t len
= strlen (path
);
2703 memcpy (path
+ len
, info
->name
, info
->name_len
);
2704 len
+= info
->name_len
;
2706 /* Some systems have a suffix for executable files.
2707 So try appending that first. */
2708 if (info
->suffix_len
)
2710 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2711 if (access_check (path
, info
->mode
) == 0)
2716 if (access_check (path
, info
->mode
) == 0)
2722 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2723 access to check permissions. If DO_MULTI is true, search multilib
2724 paths then non-multilib paths, otherwise do not search multilib paths.
2725 Return 0 if not found, otherwise return its name, allocated with malloc. */
2728 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2731 struct file_at_path_info info
;
2733 #ifdef DEFAULT_ASSEMBLER
2734 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2735 return xstrdup (DEFAULT_ASSEMBLER
);
2738 #ifdef DEFAULT_LINKER
2739 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2740 return xstrdup (DEFAULT_LINKER
);
2743 /* Determine the filename to execute (special case for absolute paths). */
2745 if (IS_ABSOLUTE_PATH (name
))
2747 if (access (name
, mode
) == 0)
2748 return xstrdup (name
);
2754 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2755 info
.name_len
= strlen (info
.name
);
2756 info
.suffix_len
= strlen (info
.suffix
);
2759 return for_each_path (pprefix
, do_multi
, info
.name_len
+ info
.suffix_len
,
2760 file_at_path
, &info
);
2763 /* Ranking of prefixes in the sort list. -B prefixes are put before
2766 enum path_prefix_priority
2768 PREFIX_PRIORITY_B_OPT
,
2769 PREFIX_PRIORITY_LAST
2772 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2773 order according to PRIORITY. Within each PRIORITY, new entries are
2776 If WARN is nonzero, we will warn if no file is found
2777 through this prefix. WARN should point to an int
2778 which will be set to 1 if this entry is used.
2780 COMPONENT is the value to be passed to update_path.
2782 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2783 the complete value of machine_suffix.
2784 2 means try both machine_suffix and just_machine_suffix. */
2787 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2788 const char *component
, /* enum prefix_priority */ int priority
,
2789 int require_machine_suffix
, int os_multilib
)
2791 struct prefix_list
*pl
, **prev
;
2794 for (prev
= &pprefix
->plist
;
2795 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2796 prev
= &(*prev
)->next
)
2799 /* Keep track of the longest prefix. */
2801 prefix
= update_path (prefix
, component
);
2802 len
= strlen (prefix
);
2803 if (len
> pprefix
->max_len
)
2804 pprefix
->max_len
= len
;
2806 pl
= XNEW (struct prefix_list
);
2807 pl
->prefix
= prefix
;
2808 pl
->require_machine_suffix
= require_machine_suffix
;
2809 pl
->priority
= priority
;
2810 pl
->os_multilib
= os_multilib
;
2812 /* Insert after PREV. */
2817 /* Same as add_prefix, but prepending target_system_root to prefix. */
2818 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2820 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2821 const char *component
,
2822 /* enum prefix_priority */ int priority
,
2823 int require_machine_suffix
, int os_multilib
)
2825 if (!IS_ABSOLUTE_PATH (prefix
))
2826 fatal ("system path '%s' is not absolute", prefix
);
2828 if (target_system_root
)
2830 if (target_sysroot_suffix
)
2831 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2832 prefix
= concat (target_system_root
, prefix
, NULL
);
2834 /* We have to override this because GCC's notion of sysroot
2835 moves along with GCC. */
2839 add_prefix (pprefix
, prefix
, component
, priority
,
2840 require_machine_suffix
, os_multilib
);
2843 /* Execute the command specified by the arguments on the current line of spec.
2844 When using pipes, this includes several piped-together commands
2845 with `|' between them.
2847 Return 0 if successful, -1 if failed. */
2853 int n_commands
; /* # of command. */
2855 struct pex_obj
*pex
;
2858 const char *prog
; /* program name. */
2859 const char **argv
; /* vector of args. */
2862 struct command
*commands
; /* each command buffer with above info. */
2864 gcc_assert (!processing_spec_function
);
2866 /* Count # of piped commands. */
2867 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2868 if (strcmp (argbuf
[i
], "|") == 0)
2871 /* Get storage for each command. */
2872 commands
= alloca (n_commands
* sizeof (struct command
));
2874 /* Split argbuf into its separate piped processes,
2875 and record info about each one.
2876 Also search for the programs that are to be run. */
2878 commands
[0].prog
= argbuf
[0]; /* first command. */
2879 commands
[0].argv
= &argbuf
[0];
2880 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2883 commands
[0].argv
[0] = string
;
2885 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2886 if (strcmp (argbuf
[i
], "|") == 0)
2887 { /* each command. */
2888 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2889 fatal ("-pipe not supported");
2891 argbuf
[i
] = 0; /* termination of command args. */
2892 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2893 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2894 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2897 commands
[n_commands
].argv
[0] = string
;
2901 argbuf
[argbuf_index
] = 0;
2903 /* If -v, print what we are about to do, and maybe query. */
2907 /* For help listings, put a blank line between sub-processes. */
2908 if (print_help_list
)
2909 fputc ('\n', stderr
);
2911 /* Print each piped command as a separate line. */
2912 for (i
= 0; i
< n_commands
; i
++)
2914 const char *const *j
;
2916 if (verbose_only_flag
)
2918 for (j
= commands
[i
].argv
; *j
; j
++)
2921 fprintf (stderr
, " \"");
2922 for (p
= *j
; *p
; ++p
)
2924 if (*p
== '"' || *p
== '\\' || *p
== '$')
2925 fputc ('\\', stderr
);
2928 fputc ('"', stderr
);
2932 for (j
= commands
[i
].argv
; *j
; j
++)
2933 fprintf (stderr
, " %s", *j
);
2935 /* Print a pipe symbol after all but the last command. */
2936 if (i
+ 1 != n_commands
)
2937 fprintf (stderr
, " |");
2938 fprintf (stderr
, "\n");
2941 if (verbose_only_flag
!= 0)
2943 /* verbose_only_flag should act as if the spec was
2944 executed, so increment execution_count before
2945 returning. This prevents spurious warnings about
2946 unused linker input files, etc. */
2951 notice ("\nGo ahead? (y or n) ");
2955 while (getchar () != '\n')
2958 if (i
!= 'y' && i
!= 'Y')
2963 /* Maybe we should warn the user if the connection fails? */
2964 if (use_server
&& client_connect (commands
[0].argv
[0]))
2967 if (!client_send_directory ())
2968 fatal ("couldn't send working directory to server");
2969 for (i
= 0; i
< n_commands
; ++i
)
2971 if (!client_send_command (commands
[i
].argv
))
2972 fatal ("couldn't send command to server: %s", commands
[i
].argv
[0]);
2974 result
= client_wait ();
2976 return result
? 0 : -1;
2979 #ifdef ENABLE_VALGRIND_CHECKING
2980 /* Run the each command through valgrind. To simplify prepending the
2981 path to valgrind and the option "-q" (for quiet operation unless
2982 something triggers), we allocate a separate argv array. */
2984 for (i
= 0; i
< n_commands
; i
++)
2990 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2993 argv
= alloca ((argc
+ 3) * sizeof (char *));
2995 argv
[0] = VALGRIND_PATH
;
2997 for (j
= 2; j
< argc
+ 2; j
++)
2998 argv
[j
] = commands
[i
].argv
[j
- 2];
3001 commands
[i
].argv
= argv
;
3002 commands
[i
].prog
= argv
[0];
3006 /* Run each piped subprocess. */
3008 pex
= pex_init (PEX_USE_PIPES
| (report_times
? PEX_RECORD_TIMES
: 0),
3009 programname
, temp_filename
);
3011 pfatal_with_name (_("pex_init failed"));
3013 for (i
= 0; i
< n_commands
; i
++)
3017 const char *string
= commands
[i
].argv
[0];
3019 errmsg
= pex_run (pex
,
3020 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3021 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3022 string
, CONST_CAST (char **, commands
[i
].argv
),
3031 pfatal_with_name (errmsg
);
3035 if (string
!= commands
[i
].prog
)
3036 free (CONST_CAST (char *, string
));
3041 /* Wait for all the subprocesses to finish. */
3045 struct pex_time
*times
= NULL
;
3048 statuses
= alloca (n_commands
* sizeof (int));
3049 if (!pex_get_status (pex
, n_commands
, statuses
))
3050 pfatal_with_name (_("failed to get exit status"));
3054 times
= alloca (n_commands
* sizeof (struct pex_time
));
3055 if (!pex_get_times (pex
, n_commands
, times
))
3056 pfatal_with_name (_("failed to get process times"));
3061 for (i
= 0; i
< n_commands
; ++i
)
3063 int status
= statuses
[i
];
3065 if (WIFSIGNALED (status
))
3068 /* SIGPIPE is a special case. It happens in -pipe mode
3069 when the compiler dies before the preprocessor is done,
3070 or the assembler dies before the compiler is done.
3071 There's generally been an error already, and this is
3072 just fallout. So don't generate another error unless
3073 we would otherwise have succeeded. */
3074 if (WTERMSIG (status
) == SIGPIPE
3075 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3083 Internal error: %s (program %s)\n\
3084 Please submit a full bug report.\n\
3085 See %s for instructions.",
3086 strsignal (WTERMSIG (status
)), commands
[i
].prog
,
3089 else if (WIFEXITED (status
)
3090 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3092 if (WEXITSTATUS (status
) > greatest_status
)
3093 greatest_status
= WEXITSTATUS (status
);
3099 struct pex_time
*pt
= ×
[i
];
3102 ut
= ((double) pt
->user_seconds
3103 + (double) pt
->user_microseconds
/ 1.0e6
);
3104 st
= ((double) pt
->system_seconds
3105 + (double) pt
->system_microseconds
/ 1.0e6
);
3108 notice ("# %s %.2f %.2f\n", commands
[i
].prog
, ut
, st
);
3116 /* Find all the switches given to us
3117 and make a vector describing them.
3118 The elements of the vector are strings, one per switch given.
3119 If a switch uses following arguments, then the `part1' field
3120 is the switch itself and the `args' field
3121 is a null-terminated vector containing the following arguments.
3122 Bits in the `live_cond' field are:
3123 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3124 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3125 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3126 The `validated' field is nonzero if any spec has looked at this switch;
3127 if it remains zero at the end of the run, it must be meaningless. */
3129 #define SWITCH_LIVE 0x1
3130 #define SWITCH_FALSE 0x2
3131 #define SWITCH_IGNORE 0x4
3137 unsigned int live_cond
;
3138 unsigned char validated
;
3139 unsigned char ordering
;
3142 static struct switchstr
*switches
;
3144 static int n_switches
;
3146 /* Language is one of three things:
3148 1) The name of a real programming language.
3149 2) NULL, indicating that no one has figured out
3151 3) '*', indicating that the file should be passed
3156 const char *language
;
3157 struct compiler
*incompiler
;
3162 /* Also a vector of input files specified. */
3164 static struct infile
*infiles
;
3168 /* True if multiple input files are being compiled to a single
3171 static bool combine_inputs
;
3173 /* This counts the number of libraries added by lang_specific_driver, so that
3174 we can tell if there were any user supplied any files or libraries. */
3176 static int added_libraries
;
3178 /* And a vector of corresponding output files is made up later. */
3180 const char **outfiles
;
3182 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3184 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3185 is true if we should look for an executable suffix. DO_OBJ
3186 is true if we should look for an object suffix. */
3189 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3190 int do_obj ATTRIBUTE_UNUSED
)
3192 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3200 len
= strlen (name
);
3202 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3203 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3204 if (do_obj
&& len
> 2
3205 && name
[len
- 2] == '.'
3206 && name
[len
- 1] == 'o')
3208 obstack_grow (&obstack
, name
, len
- 2);
3209 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3210 name
= XOBFINISH (&obstack
, const char *);
3214 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3215 /* If there is no filetype, make it the executable suffix (which includes
3216 the "."). But don't get confused if we have just "-o". */
3217 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3220 for (i
= len
- 1; i
>= 0; i
--)
3221 if (IS_DIR_SEPARATOR (name
[i
]))
3224 for (i
++; i
< len
; i
++)
3228 obstack_grow (&obstack
, name
, len
);
3229 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3230 strlen (TARGET_EXECUTABLE_SUFFIX
));
3231 name
= XOBFINISH (&obstack
, const char *);
3238 /* Display the command line switches accepted by gcc. */
3242 printf (_("Usage: %s [options] file...\n"), programname
);
3243 fputs (_("Options:\n"), stdout
);
3245 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3246 fputs (_(" --help Display this information\n"), stdout
);
3247 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3248 fputs (_(" --help={target|optimizers|warnings|undocumented|params}[,{[^]joined|[^]separate}]\n"), stdout
);
3249 fputs (_(" Display specific types of command line options\n"), stdout
);
3251 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3252 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3253 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3254 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3255 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3256 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3257 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3258 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3259 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3261 -print-multi-lib Display the mapping between command line options and\n\
3262 multiple library search directories\n"), stdout
);
3263 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3264 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3265 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3266 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3267 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3268 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3269 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3270 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3271 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout
);
3272 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3273 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3274 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3275 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3276 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3278 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3279 and libraries\n"), stdout
);
3280 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3281 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout
);
3282 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout
);
3283 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3284 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3285 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3286 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3287 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3288 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3290 -x <language> Specify the language of the following input files\n\
3291 Permissible languages include: c c++ assembler none\n\
3292 'none' means revert to the default behavior of\n\
3293 guessing the language based on the file's extension\n\
3297 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3298 passed on to the various sub-processes invoked by %s. In order to pass\n\
3299 other options on to these processes the -W<letter> options must be used.\n\
3302 /* The rest of the options are displayed by invocations of the various
3307 add_preprocessor_option (const char *option
, int len
)
3309 n_preprocessor_options
++;
3311 if (! preprocessor_options
)
3312 preprocessor_options
= XNEWVEC (char *, n_preprocessor_options
);
3314 preprocessor_options
= xrealloc (preprocessor_options
,
3315 n_preprocessor_options
* sizeof (char *));
3317 preprocessor_options
[n_preprocessor_options
- 1] =
3318 save_string (option
, len
);
3322 add_assembler_option (const char *option
, int len
)
3324 n_assembler_options
++;
3326 if (! assembler_options
)
3327 assembler_options
= XNEWVEC (char *, n_assembler_options
);
3329 assembler_options
= xrealloc (assembler_options
,
3330 n_assembler_options
* sizeof (char *));
3332 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3336 add_linker_option (const char *option
, int len
)
3340 if (! linker_options
)
3341 linker_options
= XNEWVEC (char *, n_linker_options
);
3343 linker_options
= xrealloc (linker_options
,
3344 n_linker_options
* sizeof (char *));
3346 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3349 /* Create the vector `switches' and its contents.
3350 Store its length in `n_switches'. */
3353 process_command (int argc
, const char **argv
)
3358 const char *spec_lang
= 0;
3359 int last_language_n_infiles
;
3360 int lang_n_infiles
= 0;
3361 #ifdef MODIFY_TARGET_NAME
3362 int is_modify_target_name
;
3365 const char *tooldir_prefix
;
3367 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3371 added_libraries
= 0;
3373 /* Figure compiler version from version string. */
3375 compiler_version
= temp1
= xstrdup (version_string
);
3377 for (; *temp1
; ++temp1
)
3386 /* If there is a -V or -b option (or both), process it now, before
3387 trying to interpret the rest of the command line.
3388 Use heuristic that all configuration names must have at least
3389 one dash '-'. This allows us to pass options starting with -b. */
3390 if (argc
> 1 && argv
[1][0] == '-'
3391 && (argv
[1][1] == 'V' ||
3392 ((argv
[1][1] == 'b') && (NULL
!= strchr(argv
[1] + 2,'-')))))
3394 const char *new_version
= DEFAULT_TARGET_VERSION
;
3395 const char *new_machine
= DEFAULT_TARGET_MACHINE
;
3396 const char *progname
= argv
[0];
3401 while (argc
> 1 && argv
[1][0] == '-'
3402 && (argv
[1][1] == 'V' ||
3403 ((argv
[1][1] == 'b') && ( NULL
!= strchr(argv
[1] + 2,'-')))))
3405 char opt
= argv
[1][1];
3407 if (argv
[1][2] != '\0')
3420 fatal ("'-%c' option must have argument", opt
);
3427 for (baselen
= strlen (progname
); baselen
> 0; baselen
--)
3428 if (IS_DIR_SEPARATOR (progname
[baselen
-1]))
3430 new_argv0
= xmemdup (progname
, baselen
,
3431 baselen
+ concat_length (new_version
, new_machine
,
3432 "-gcc-", NULL
) + 1);
3433 strcpy (new_argv0
+ baselen
, new_machine
);
3434 strcat (new_argv0
, "-gcc-");
3435 strcat (new_argv0
, new_version
);
3437 new_argv
= xmemdup (argv
, (argc
+ 1) * sizeof (argv
[0]),
3438 (argc
+ 1) * sizeof (argv
[0]));
3439 new_argv
[0] = new_argv0
;
3441 execvp (new_argv0
, new_argv
);
3442 fatal ("couldn't run '%s': %s", new_argv0
, xstrerror (errno
));
3445 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3446 see if we can create it from the pathname specified in argv[0]. */
3448 gcc_libexec_prefix
= standard_libexec_prefix
;
3450 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3451 if (!gcc_exec_prefix
)
3453 gcc_exec_prefix
= make_relative_prefix (argv
[0], standard_bindir_prefix
,
3454 standard_exec_prefix
);
3455 gcc_libexec_prefix
= make_relative_prefix (argv
[0],
3456 standard_bindir_prefix
,
3457 standard_libexec_prefix
);
3458 if (gcc_exec_prefix
)
3459 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3463 /* make_relative_prefix requires a program name, but
3464 GCC_EXEC_PREFIX is typically a directory name with a trailing
3465 / (which is ignored by make_relative_prefix), so append a
3467 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3468 gcc_libexec_prefix
= make_relative_prefix (tmp_prefix
,
3469 standard_exec_prefix
,
3470 standard_libexec_prefix
);
3472 /* The path is unrelocated, so fallback to the original setting. */
3473 if (!gcc_libexec_prefix
)
3474 gcc_libexec_prefix
= standard_libexec_prefix
;
3480 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3481 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3482 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3484 if (gcc_exec_prefix
)
3486 int len
= strlen (gcc_exec_prefix
);
3488 if (len
> (int) sizeof ("/lib/gcc/") - 1
3489 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3491 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3492 if (IS_DIR_SEPARATOR (*temp
)
3493 && strncmp (temp
+ 1, "lib", 3) == 0
3494 && IS_DIR_SEPARATOR (temp
[4])
3495 && strncmp (temp
+ 5, "gcc", 3) == 0)
3496 len
-= sizeof ("/lib/gcc/") - 1;
3499 set_std_prefix (gcc_exec_prefix
, len
);
3500 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3501 PREFIX_PRIORITY_LAST
, 0, 0);
3502 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3503 PREFIX_PRIORITY_LAST
, 0, 0);
3506 /* COMPILER_PATH and LIBRARY_PATH have values
3507 that are lists of directory names with colons. */
3509 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3512 const char *startp
, *endp
;
3513 char *nstore
= alloca (strlen (temp
) + 3);
3515 startp
= endp
= temp
;
3518 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3520 strncpy (nstore
, startp
, endp
- startp
);
3522 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3523 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3525 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3526 nstore
[endp
- startp
+ 1] = 0;
3529 nstore
[endp
- startp
] = 0;
3530 add_prefix (&exec_prefixes
, nstore
, 0,
3531 PREFIX_PRIORITY_LAST
, 0, 0);
3532 add_prefix (&include_prefixes
, nstore
, 0,
3533 PREFIX_PRIORITY_LAST
, 0, 0);
3536 endp
= startp
= endp
+ 1;
3543 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3544 if (temp
&& *cross_compile
== '0')
3546 const char *startp
, *endp
;
3547 char *nstore
= alloca (strlen (temp
) + 3);
3549 startp
= endp
= temp
;
3552 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3554 strncpy (nstore
, startp
, endp
- startp
);
3556 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3557 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3559 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3560 nstore
[endp
- startp
+ 1] = 0;
3563 nstore
[endp
- startp
] = 0;
3564 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3565 PREFIX_PRIORITY_LAST
, 0, 1);
3568 endp
= startp
= endp
+ 1;
3575 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3576 GET_ENVIRONMENT (temp
, "LPATH");
3577 if (temp
&& *cross_compile
== '0')
3579 const char *startp
, *endp
;
3580 char *nstore
= alloca (strlen (temp
) + 3);
3582 startp
= endp
= temp
;
3585 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3587 strncpy (nstore
, startp
, endp
- startp
);
3589 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3590 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3592 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3593 nstore
[endp
- startp
+ 1] = 0;
3596 nstore
[endp
- startp
] = 0;
3597 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3598 PREFIX_PRIORITY_LAST
, 0, 1);
3601 endp
= startp
= endp
+ 1;
3608 /* Convert new-style -- options to old-style. */
3609 translate_options (&argc
, (const char *const **) &argv
);
3611 /* Do language-specific adjustment/addition of flags. */
3612 lang_specific_driver (&argc
, (const char *const **) &argv
, &added_libraries
);
3614 /* Scan argv twice. Here, the first time, just count how many switches
3615 there will be in their vector, and how many input files in theirs.
3616 Here we also parse the switches that cc itself uses (e.g. -v). */
3618 for (i
= 1; i
< argc
; i
++)
3620 if (! strcmp (argv
[i
], "-dumpspecs"))
3622 struct spec_list
*sl
;
3624 for (sl
= specs
; sl
; sl
= sl
->next
)
3625 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3626 if (link_command_spec
)
3627 printf ("*link_command:\n%s\n\n", link_command_spec
);
3630 else if (! strcmp (argv
[i
], "-dumpversion"))
3632 printf ("%s\n", spec_version
);
3635 else if (! strcmp (argv
[i
], "-dumpmachine"))
3637 printf ("%s\n", spec_machine
);
3640 else if (strcmp (argv
[i
], "-fversion") == 0)
3642 /* translate_options () has turned --version into -fversion. */
3643 printf (_("%s %s%s\n"), programname
, pkgversion_string
,
3645 printf ("Copyright %s 2007 Free Software Foundation, Inc.\n",
3647 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3648 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3652 else if (strcmp (argv
[i
], "-fhelp") == 0)
3654 /* translate_options () has turned --help into -fhelp. */
3655 print_help_list
= 1;
3657 /* We will be passing a dummy file on to the sub-processes. */
3661 /* CPP driver cannot obtain switch from cc1_options. */
3663 add_preprocessor_option ("--help", 6);
3664 add_assembler_option ("--help", 6);
3665 add_linker_option ("--help", 6);
3667 else if (strncmp (argv
[i
], "-fhelp=", 7) == 0)
3669 /* translate_options () has turned --help into -fhelp. */
3670 print_subprocess_help
= 2;
3672 /* We will be passing a dummy file on to the sub-processes. */
3676 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3678 /* translate_options() has turned --target-help into -ftarget-help. */
3679 print_subprocess_help
= 1;
3681 /* We will be passing a dummy file on to the sub-processes. */
3685 /* CPP driver cannot obtain switch from cc1_options. */
3687 add_preprocessor_option ("--target-help", 13);
3688 add_assembler_option ("--target-help", 13);
3689 add_linker_option ("--target-help", 13);
3691 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3693 pass_exit_codes
= 1;
3696 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3697 print_search_dirs
= 1;
3698 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3699 print_file_name
= "libgcc.a";
3700 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3701 print_file_name
= argv
[i
] + 17;
3702 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3703 print_prog_name
= argv
[i
] + 17;
3704 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3705 print_multi_lib
= 1;
3706 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3707 print_multi_directory
= 1;
3708 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3709 print_multi_os_directory
= 1;
3710 else if (! strcmp (argv
[i
], "-print-sysroot-headers-suffix"))
3711 print_sysroot_headers_suffix
= 1;
3712 else if (! strncmp (argv
[i
], "-Wa,", 4))
3715 /* Pass the rest of this option to the assembler. */
3717 /* Split the argument at commas. */
3719 for (j
= 4; argv
[i
][j
]; j
++)
3720 if (argv
[i
][j
] == ',')
3722 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3726 /* Record the part after the last comma. */
3727 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3729 else if (! strncmp (argv
[i
], "-Wp,", 4))
3732 /* Pass the rest of this option to the preprocessor. */
3734 /* Split the argument at commas. */
3736 for (j
= 4; argv
[i
][j
]; j
++)
3737 if (argv
[i
][j
] == ',')
3739 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3743 /* Record the part after the last comma. */
3744 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3746 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3747 /* The +e options to the C++ front-end. */
3749 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3752 /* Split the argument at commas. */
3753 for (j
= 3; argv
[i
][j
]; j
++)
3754 n_infiles
+= (argv
[i
][j
] == ',');
3756 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3759 fatal ("argument to '-Xlinker' is missing");
3764 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3767 fatal ("argument to '-Xpreprocessor' is missing");
3769 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3771 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3774 fatal ("argument to '-Xassembler' is missing");
3776 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3778 else if (strcmp (argv
[i
], "-l") == 0)
3781 fatal ("argument to '-l' is missing");
3786 else if (strncmp (argv
[i
], "-l", 2) == 0)
3788 else if (strcmp (argv
[i
], "-save-temps") == 0)
3790 save_temps_flag
= 1;
3793 else if (strcmp (argv
[i
], "-combine") == 0)
3798 else if (strcmp (argv
[i
], "-specs") == 0)
3800 struct user_specs
*user
= XNEW (struct user_specs
);
3802 fatal ("argument to '-specs' is missing");
3804 user
->next
= (struct user_specs
*) 0;
3805 user
->filename
= argv
[i
];
3806 if (user_specs_tail
)
3807 user_specs_tail
->next
= user
;
3809 user_specs_head
= user
;
3810 user_specs_tail
= user
;
3812 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3814 struct user_specs
*user
= XNEW (struct user_specs
);
3815 if (strlen (argv
[i
]) == 7)
3816 fatal ("argument to '-specs=' is missing");
3818 user
->next
= (struct user_specs
*) 0;
3819 user
->filename
= argv
[i
] + 7;
3820 if (user_specs_tail
)
3821 user_specs_tail
->next
= user
;
3823 user_specs_head
= user
;
3824 user_specs_tail
= user
;
3826 else if (strcmp (argv
[i
], "-time") == 0)
3828 else if (strcmp (argv
[i
], "-pipe") == 0)
3830 /* -pipe has to go into the switches array as well as
3835 else if (strcmp (argv
[i
], "-server") == 0)
3840 else if (strcmp (argv
[i
], "-kill-server") == 0)
3845 else if (strcmp (argv
[i
], "-###") == 0)
3847 /* This is similar to -v except that there is no execution
3848 of the commands and the echoed arguments are quoted. It
3849 is intended for use in shell scripts to capture the
3850 driver-generated command line. */
3851 verbose_only_flag
++;
3854 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3856 const char *p
= &argv
[i
][1];
3862 if (NULL
== strchr(argv
[i
] + 2, '-'))
3867 fatal ("'-%c' must come at the start of the command line", c
);
3875 if (p
[1] == 0 && i
+ 1 == argc
)
3876 fatal ("argument to '-B' is missing");
3882 len
= strlen (value
);
3884 /* Catch the case where the user has forgotten to append a
3885 directory separator to the path. Note, they may be using
3886 -B to add an executable name prefix, eg "i386-elf-", in
3887 order to distinguish between multiple installations of
3888 GCC in the same directory. Hence we must check to see
3889 if appending a directory separator actually makes a
3890 valid directory name. */
3891 if (! IS_DIR_SEPARATOR (value
[len
- 1])
3892 && is_directory (value
, false))
3894 char *tmp
= XNEWVEC (char, len
+ 2);
3895 strcpy (tmp
, value
);
3896 tmp
[len
] = DIR_SEPARATOR
;
3901 add_prefix (&exec_prefixes
, value
, NULL
,
3902 PREFIX_PRIORITY_B_OPT
, 0, 0);
3903 add_prefix (&startfile_prefixes
, value
, NULL
,
3904 PREFIX_PRIORITY_B_OPT
, 0, 0);
3905 add_prefix (&include_prefixes
, value
, NULL
,
3906 PREFIX_PRIORITY_B_OPT
, 0, 0);
3916 else if (i
+ 1 < argc
)
3919 error ("argument to '-j' is missing");
3920 server_count
= atoi (arg
);
3921 if (server_count
<= 0)
3922 error ("argument to '-j' must be positive");
3926 case 'v': /* Print our subcommands and print versions. */
3928 /* If they do anything other than exactly `-v', don't set
3929 verbose_flag; rather, continue on to give the error. */
3947 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3952 /* Forward scan, just in case -S or -c is specified
3959 if (argv
[j
][0] == '-')
3961 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
3967 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
3968 j
+= skip
- (argv
[j
][2] != 0);
3969 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
3976 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3978 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
3980 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
3987 #ifdef MODIFY_TARGET_NAME
3988 is_modify_target_name
= 0;
3990 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3991 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3993 char *new_name
= xmalloc (strlen (modify_target
[j
].str
)
3994 + strlen (spec_machine
));
3997 int made_addition
= 0;
3999 is_modify_target_name
= 1;
4000 for (p
= spec_machine
, q
= new_name
; *p
!= 0; )
4002 if (modify_target
[j
].add_del
== DELETE
4003 && (! strncmp (q
, modify_target
[j
].str
,
4004 strlen (modify_target
[j
].str
))))
4005 p
+= strlen (modify_target
[j
].str
);
4006 else if (modify_target
[j
].add_del
== ADD
4007 && ! made_addition
&& *p
== '-')
4009 for (r
= modify_target
[j
].str
; *r
!= 0; )
4017 spec_machine
= new_name
;
4020 if (is_modify_target_name
)
4026 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4027 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4028 else if (WORD_SWITCH_TAKES_ARG (p
))
4029 i
+= WORD_SWITCH_TAKES_ARG (p
);
4039 if (save_temps_flag
&& use_pipes
)
4041 /* -save-temps overrides -pipe, so that temp files are produced */
4042 if (save_temps_flag
)
4043 error ("warning: -pipe ignored because -save-temps specified");
4047 /* Set up the search paths. We add directories that we expect to
4048 contain GNU Toolchain components before directories specified by
4049 the machine description so that we will find GNU components (like
4050 the GNU assembler) before those of the host system. */
4052 /* If we don't know where the toolchain has been installed, use the
4053 configured-in locations. */
4054 if (!gcc_exec_prefix
)
4057 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4058 PREFIX_PRIORITY_LAST
, 1, 0);
4059 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4060 PREFIX_PRIORITY_LAST
, 2, 0);
4061 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4062 PREFIX_PRIORITY_LAST
, 2, 0);
4064 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4065 PREFIX_PRIORITY_LAST
, 1, 0);
4068 /* If not cross-compiling, search well-known system locations. */
4069 if (*cross_compile
== '0')
4072 add_prefix (&exec_prefixes
, standard_exec_prefix_1
, "BINUTILS",
4073 PREFIX_PRIORITY_LAST
, 2, 0);
4074 add_prefix (&exec_prefixes
, standard_exec_prefix_2
, "BINUTILS",
4075 PREFIX_PRIORITY_LAST
, 2, 0);
4077 add_prefix (&startfile_prefixes
, standard_exec_prefix_2
, "BINUTILS",
4078 PREFIX_PRIORITY_LAST
, 1, 0);
4081 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4082 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
4083 dir_separator_str
, NULL
);
4085 /* Look for tools relative to the location from which the driver is
4086 running, or, if that is not available, the configured prefix. */
4088 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4089 spec_machine
, dir_separator_str
,
4090 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
4092 add_prefix (&exec_prefixes
,
4093 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4094 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4095 add_prefix (&startfile_prefixes
,
4096 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4097 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4099 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4100 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4101 then consider it to relocate with the rest of the GCC installation
4102 if GCC_EXEC_PREFIX is set.
4103 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4104 if (target_system_root
&& gcc_exec_prefix
)
4106 char *tmp_prefix
= make_relative_prefix (argv
[0],
4107 standard_bindir_prefix
,
4108 target_system_root
);
4109 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4111 target_system_root
= tmp_prefix
;
4112 target_system_root_changed
= 1;
4117 /* More prefixes are enabled in main, after we read the specs file
4118 and determine whether this is cross-compilation or not. */
4120 /* Then create the space for the vectors and scan again. */
4122 switches
= XNEWVEC (struct switchstr
, n_switches
+ 1);
4123 infiles
= XNEWVEC (struct infile
, n_infiles
+ 1);
4126 last_language_n_infiles
= -1;
4128 /* This, time, copy the text of each switch and store a pointer
4129 to the copy in the vector of switches.
4130 Store all the infiles in their vector. */
4132 for (i
= 1; i
< argc
; i
++)
4134 /* Just skip the switches that were handled by the preceding loop. */
4135 #ifdef MODIFY_TARGET_NAME
4136 is_modify_target_name
= 0;
4138 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
4139 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
4140 is_modify_target_name
= 1;
4142 if (is_modify_target_name
)
4146 if (! strncmp (argv
[i
], "-Wa,", 4))
4148 else if (! strncmp (argv
[i
], "-Wp,", 4))
4150 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
4152 else if (! strcmp (argv
[i
], "-print-search-dirs"))
4154 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
4156 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
4158 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
4160 else if (! strcmp (argv
[i
], "-print-multi-lib"))
4162 else if (! strcmp (argv
[i
], "-print-multi-directory"))
4164 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
4166 else if (! strcmp (argv
[i
], "-print-sysroot-headers-suffix"))
4168 else if (! strncmp (argv
[i
], "--sysroot=", strlen ("--sysroot=")))
4170 target_system_root
= argv
[i
] + strlen ("--sysroot=");
4171 target_system_root_changed
= 1;
4173 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
4175 /* Compensate for the +e options to the C++ front-end;
4176 they're there simply for cfront call-compatibility. We do
4177 some magic in default_compilers to pass them down properly.
4178 Note we deliberately start at the `+' here, to avoid passing
4179 -e0 or -e1 down into the linker. */
4180 switches
[n_switches
].part1
= &argv
[i
][0];
4181 switches
[n_switches
].args
= 0;
4182 switches
[n_switches
].live_cond
= 0;
4183 switches
[n_switches
].validated
= 0;
4186 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
4189 /* Split the argument at commas. */
4191 for (j
= 4; argv
[i
][j
]; j
++)
4192 if (argv
[i
][j
] == ',')
4194 infiles
[n_infiles
].language
= "*";
4195 infiles
[n_infiles
++].name
4196 = save_string (argv
[i
] + prev
, j
- prev
);
4199 /* Record the part after the last comma. */
4200 infiles
[n_infiles
].language
= "*";
4201 infiles
[n_infiles
++].name
= argv
[i
] + prev
;
4203 else if (strcmp (argv
[i
], "-Xlinker") == 0)
4205 infiles
[n_infiles
].language
= "*";
4206 infiles
[n_infiles
++].name
= argv
[++i
];
4208 /* Xassembler and Xpreprocessor were already handled in the first argv
4209 scan, so all we need to do here is ignore them and their argument. */
4210 else if (strcmp (argv
[i
], "-Xassembler") == 0)
4212 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
4214 else if (strcmp (argv
[i
], "-l") == 0)
4215 { /* POSIX allows separation of -l and the lib arg;
4216 canonicalize by concatenating -l with its arg */
4217 infiles
[n_infiles
].language
= "*";
4218 infiles
[n_infiles
++].name
= concat ("-l", argv
[++i
], NULL
);
4220 else if (strncmp (argv
[i
], "-l", 2) == 0)
4222 infiles
[n_infiles
].language
= "*";
4223 infiles
[n_infiles
++].name
= argv
[i
];
4225 else if (strcmp (argv
[i
], "-specs") == 0)
4227 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
4229 else if (strcmp (argv
[i
], "-time") == 0)
4231 else if (strcmp (argv
[i
], "-server") == 0)
4233 else if (strcmp (argv
[i
], "-kill-server") == 0)
4235 else if (strcmp (argv
[i
], "-###") == 0)
4237 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
4239 const char *p
= &argv
[i
][1];
4244 if (p
[1] == 0 && i
+ 1 == argc
)
4245 fatal ("argument to '-x' is missing");
4247 spec_lang
= argv
[++i
];
4250 if (! strcmp (spec_lang
, "none"))
4251 /* Suppress the warning if -xnone comes after the last input
4252 file, because alternate command interfaces like g++ might
4253 find it useful to place -xnone after each input file. */
4256 last_language_n_infiles
= n_infiles
;
4261 /* Don't pass the -j option down. */
4266 switches
[n_switches
].part1
= p
;
4267 /* Deal with option arguments in separate argv elements. */
4268 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4269 || WORD_SWITCH_TAKES_ARG (p
))
4272 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4276 /* Count only the option arguments in separate argv elements. */
4277 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4279 if (i
+ n_args
>= argc
)
4280 fatal ("argument to '-%s' is missing", p
);
4281 switches
[n_switches
].args
4282 = XNEWVEC (const char *, n_args
+ 1);
4284 switches
[n_switches
].args
[j
++] = argv
[++i
];
4285 /* Null-terminate the vector. */
4286 switches
[n_switches
].args
[j
] = 0;
4288 else if (strchr (switches_need_spaces
, c
))
4290 /* On some systems, ld cannot handle some options without
4291 a space. So split the option from its argument. */
4292 char *part1
= XNEWVEC (char, 2);
4296 switches
[n_switches
].part1
= part1
;
4297 switches
[n_switches
].args
= XNEWVEC (const char *, 2);
4298 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4299 switches
[n_switches
].args
[1] = 0;
4302 switches
[n_switches
].args
= 0;
4304 switches
[n_switches
].live_cond
= 0;
4305 switches
[n_switches
].validated
= 0;
4306 switches
[n_switches
].ordering
= 0;
4307 /* These are always valid, since gcc.c itself understands the
4308 first four and gfortranspec.c understands -static-libgfortran. */
4309 if (!strcmp (p
, "save-temps")
4310 || !strcmp (p
, "static-libgcc")
4311 || !strcmp (p
, "shared-libgcc")
4312 || !strcmp (p
, "pipe")
4313 || !strcmp (p
, "static-libgfortran"))
4314 switches
[n_switches
].validated
= 1;
4317 char ch
= switches
[n_switches
].part1
[0];
4319 switches
[n_switches
].validated
= 1;
4325 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4326 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4329 if (strcmp (argv
[i
], "-") != 0 && access (argv
[i
], F_OK
) < 0)
4331 perror_with_name (argv
[i
]);
4336 infiles
[n_infiles
].language
= spec_lang
;
4337 infiles
[n_infiles
++].name
= argv
[i
];
4342 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4343 error ("warning: '-x %s' after last input file has no effect", spec_lang
);
4345 /* Ensure we only invoke each subprocess once. */
4346 if (print_subprocess_help
|| print_help_list
)
4350 /* Create a dummy input file, so that we can pass
4351 the help option on to the various sub-processes. */
4352 infiles
[0].language
= "c";
4353 infiles
[0].name
= "help-dummy";
4356 switches
[n_switches
].part1
= 0;
4357 infiles
[n_infiles
].name
= 0;
4360 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4361 and place that in the environment. */
4364 set_collect_gcc_options (void)
4369 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4371 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4372 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4375 for (i
= 0; (int) i
< n_switches
; i
++)
4377 const char *const *args
;
4380 obstack_grow (&collect_obstack
, " ", 1);
4384 /* Ignore elided switches. */
4385 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) != 0)
4388 obstack_grow (&collect_obstack
, "'-", 2);
4389 q
= switches
[i
].part1
;
4390 while ((p
= strchr (q
, '\'')))
4392 obstack_grow (&collect_obstack
, q
, p
- q
);
4393 obstack_grow (&collect_obstack
, "'\\''", 4);
4396 obstack_grow (&collect_obstack
, q
, strlen (q
));
4397 obstack_grow (&collect_obstack
, "'", 1);
4399 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4401 obstack_grow (&collect_obstack
, " '", 2);
4403 while ((p
= strchr (q
, '\'')))
4405 obstack_grow (&collect_obstack
, q
, p
- q
);
4406 obstack_grow (&collect_obstack
, "'\\''", 4);
4409 obstack_grow (&collect_obstack
, q
, strlen (q
));
4410 obstack_grow (&collect_obstack
, "'", 1);
4413 obstack_grow (&collect_obstack
, "\0", 1);
4414 xputenv (XOBFINISH (&collect_obstack
, char *));
4417 /* Process a spec string, accumulating and running commands. */
4419 /* These variables describe the input file name.
4420 input_file_number is the index on outfiles of this file,
4421 so that the output file name can be stored for later use by %o.
4422 input_basename is the start of the part of the input file
4423 sans all directory names, and basename_length is the number
4424 of characters starting there excluding the suffix .c or whatever. */
4426 static const char *input_filename
;
4427 static int input_file_number
;
4428 size_t input_filename_length
;
4429 static int basename_length
;
4430 static int suffixed_basename_length
;
4431 static const char *input_basename
;
4432 static const char *input_suffix
;
4433 #ifndef HOST_LACKS_INODE_NUMBERS
4434 static struct stat input_stat
;
4436 static int input_stat_set
;
4438 /* The compiler used to process the current input file. */
4439 static struct compiler
*input_file_compiler
;
4441 /* These are variables used within do_spec and do_spec_1. */
4443 /* Nonzero if an arg has been started and not yet terminated
4444 (with space, tab or newline). */
4445 static int arg_going
;
4447 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4448 is a temporary file name. */
4449 static int delete_this_arg
;
4451 /* Nonzero means %w has been seen; the next arg to be terminated
4452 is the output file name of this compilation. */
4453 static int this_is_output_file
;
4455 /* Nonzero means %s has been seen; the next arg to be terminated
4456 is the name of a library file and we should try the standard
4457 search dirs for it. */
4458 static int this_is_library_file
;
4460 /* Nonzero means that the input of this command is coming from a pipe. */
4461 static int input_from_pipe
;
4463 /* Nonnull means substitute this for any suffix when outputting a switches
4465 static const char *suffix_subst
;
4467 /* If there is an argument being accumulated, terminate it and store it. */
4470 end_going_arg (void)
4476 obstack_1grow (&obstack
, 0);
4477 string
= XOBFINISH (&obstack
, const char *);
4478 if (this_is_library_file
)
4479 string
= find_file (string
);
4480 store_arg (string
, delete_this_arg
, this_is_output_file
);
4481 if (this_is_output_file
)
4482 outfiles
[input_file_number
] = string
;
4487 /* Process the spec SPEC and run the commands specified therein.
4488 Returns 0 if the spec is successfully processed; -1 if failed. */
4491 do_spec (const char *spec
)
4495 value
= do_spec_2 (spec
);
4497 /* Force out any unfinished command.
4498 If -pipe, this forces out the last command if it ended in `|'. */
4501 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4504 set_collect_gcc_options ();
4506 if (argbuf_index
> 0)
4514 do_spec_2 (const char *spec
)
4520 delete_this_arg
= 0;
4521 this_is_output_file
= 0;
4522 this_is_library_file
= 0;
4523 input_from_pipe
= 0;
4524 suffix_subst
= NULL
;
4526 result
= do_spec_1 (spec
, 0, NULL
);
4534 /* Process the given spec string and add any new options to the end
4535 of the switches/n_switches array. */
4538 do_option_spec (const char *name
, const char *spec
)
4540 unsigned int i
, value_count
, value_len
;
4541 const char *p
, *q
, *value
;
4542 char *tmp_spec
, *tmp_spec_p
;
4544 if (configure_default_options
[0].name
== NULL
)
4547 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4548 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4550 if (i
== ARRAY_SIZE (configure_default_options
))
4553 value
= configure_default_options
[i
].value
;
4554 value_len
= strlen (value
);
4556 /* Compute the size of the final spec. */
4559 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4565 /* Replace each %(VALUE) by the specified value. */
4566 tmp_spec
= alloca (strlen (spec
) + 1
4567 + value_count
* (value_len
- strlen ("%(VALUE)")));
4568 tmp_spec_p
= tmp_spec
;
4570 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4572 memcpy (tmp_spec_p
, q
, p
- q
);
4573 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4574 memcpy (tmp_spec_p
, value
, value_len
);
4575 tmp_spec_p
+= value_len
;
4576 q
= p
+ strlen ("%(VALUE)");
4578 strcpy (tmp_spec_p
, q
);
4580 do_self_spec (tmp_spec
);
4583 /* Process the given spec string and add any new options to the end
4584 of the switches/n_switches array. */
4587 do_self_spec (const char *spec
)
4590 do_spec_1 (" ", 0, NULL
);
4592 if (argbuf_index
> 0)
4597 n_switches
+= argbuf_index
;
4598 switches
= xrealloc (switches
,
4599 sizeof (struct switchstr
) * (n_switches
+ 1));
4601 switches
[n_switches
] = switches
[first
];
4602 for (i
= 0; i
< argbuf_index
; i
++)
4604 struct switchstr
*sw
;
4606 /* Each switch should start with '-'. */
4607 if (argbuf
[i
][0] != '-')
4608 fatal ("switch '%s' does not start with '-'", argbuf
[i
]);
4610 sw
= &switches
[i
+ first
];
4611 sw
->part1
= &argbuf
[i
][1];
4620 /* Callback for processing %D and %I specs. */
4622 struct spec_path_info
{
4627 bool separate_options
;
4631 spec_path (char *path
, void *data
)
4633 struct spec_path_info
*info
= data
;
4637 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4640 if (info
->append_len
!= 0)
4642 len
= strlen (path
);
4643 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4646 if (!is_directory (path
, true))
4649 do_spec_1 (info
->option
, 1, NULL
);
4650 if (info
->separate_options
)
4651 do_spec_1 (" ", 0, NULL
);
4653 if (info
->append_len
== 0)
4655 len
= strlen (path
);
4656 save
= path
[len
- 1];
4657 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4658 path
[len
- 1] = '\0';
4661 do_spec_1 (path
, 1, NULL
);
4662 do_spec_1 (" ", 0, NULL
);
4664 /* Must not damage the original path. */
4665 if (info
->append_len
== 0)
4666 path
[len
- 1] = save
;
4671 /* Process the sub-spec SPEC as a portion of a larger spec.
4672 This is like processing a whole spec except that we do
4673 not initialize at the beginning and we do not supply a
4674 newline by default at the end.
4675 INSWITCH nonzero means don't process %-sequences in SPEC;
4676 in this case, % is treated as an ordinary character.
4677 This is used while substituting switches.
4678 INSWITCH nonzero also causes SPC not to terminate an argument.
4680 Value is zero unless a line was finished
4681 and the command on that line reported an error. */
4684 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4686 const char *p
= spec
;
4692 /* If substituting a switch, treat all chars like letters.
4693 Otherwise, NL, SPC, TAB and % are special. */
4694 switch (inswitch
? 'a' : c
)
4699 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4701 /* A `|' before the newline means use a pipe here,
4702 but only if -pipe was specified.
4703 Otherwise, execute now and don't pass the `|' as an arg. */
4706 input_from_pipe
= 1;
4713 set_collect_gcc_options ();
4715 if (argbuf_index
> 0)
4721 /* Reinitialize for a new command, and for a new argument. */
4724 delete_this_arg
= 0;
4725 this_is_output_file
= 0;
4726 this_is_library_file
= 0;
4727 input_from_pipe
= 0;
4734 obstack_1grow (&obstack
, c
);
4742 /* Reinitialize for a new argument. */
4743 delete_this_arg
= 0;
4744 this_is_output_file
= 0;
4745 this_is_library_file
= 0;
4752 fatal ("spec '%s' invalid", spec
);
4755 obstack_grow (&obstack
, input_basename
, basename_length
);
4760 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4765 delete_this_arg
= 2;
4768 /* Dump out the directories specified with LIBRARY_PATH,
4769 followed by the absolute directories
4770 that we search for startfiles. */
4773 struct spec_path_info info
;
4776 info
.append_len
= 0;
4777 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4778 /* Used on systems which record the specified -L dirs
4779 and use them to search for dynamic linking.
4780 Relative directories always come from -B,
4781 and it is better not to use them for searching
4782 at run time. In particular, stage1 loses. */
4783 info
.omit_relative
= true;
4785 info
.omit_relative
= false;
4787 info
.separate_options
= false;
4789 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4794 /* %efoo means report an error with `foo' as error message
4795 and don't execute any more commands for this file. */
4799 while (*p
!= 0 && *p
!= '\n')
4801 buf
= alloca (p
- q
+ 1);
4802 strncpy (buf
, q
, p
- q
);
4809 /* %nfoo means report a notice with `foo' on stderr. */
4813 while (*p
!= 0 && *p
!= '\n')
4815 buf
= alloca (p
- q
+ 1);
4816 strncpy (buf
, q
, p
- q
);
4818 notice ("%s\n", buf
);
4828 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4829 defined, and it is not a directory, and it is
4830 writable, use it. Otherwise, treat this like any
4831 other temporary file. */
4833 if ((!save_temps_flag
)
4834 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4835 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4837 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4838 strlen (HOST_BIT_BUCKET
));
4839 delete_this_arg
= 0;
4844 goto create_temp_file
;
4848 obstack_1grow (&obstack
, '-');
4849 delete_this_arg
= 0;
4852 /* consume suffix */
4853 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4855 if (p
[0] == '%' && p
[1] == 'O')
4860 goto create_temp_file
;
4864 /* consume suffix */
4865 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4867 if (p
[0] == '%' && p
[1] == 'O')
4872 goto create_temp_file
;
4878 struct temp_name
*t
;
4880 const char *suffix
= p
;
4881 char *saved_suffix
= NULL
;
4883 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4885 suffix_length
= p
- suffix
;
4886 if (p
[0] == '%' && p
[1] == 'O')
4889 /* We don't support extra suffix characters after %O. */
4890 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4891 fatal ("spec '%s' has invalid '%%0%c'", spec
, *p
);
4892 if (suffix_length
== 0)
4893 suffix
= TARGET_OBJECT_SUFFIX
;
4897 = XNEWVEC (char, suffix_length
4898 + strlen (TARGET_OBJECT_SUFFIX
));
4899 strncpy (saved_suffix
, suffix
, suffix_length
);
4900 strcpy (saved_suffix
+ suffix_length
,
4901 TARGET_OBJECT_SUFFIX
);
4903 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4906 /* If the input_filename has the same suffix specified
4907 for the %g, %u, or %U, and -save-temps is specified,
4908 we could end up using that file as an intermediate
4909 thus clobbering the user's source file (.e.g.,
4910 gcc -save-temps foo.s would clobber foo.s with the
4911 output of cpp0). So check for this condition and
4912 generate a temp file as the intermediate. */
4914 if (save_temps_flag
)
4918 temp_filename_length
= basename_length
+ suffix_length
;
4919 tmp
= alloca (temp_filename_length
+ 1);
4920 strncpy (tmp
, input_basename
, basename_length
);
4921 strncpy (tmp
+ basename_length
, suffix
, suffix_length
);
4922 tmp
[temp_filename_length
] = '\0';
4923 temp_filename
= tmp
;
4924 if (strcmp (temp_filename
, input_filename
) != 0)
4926 #ifndef HOST_LACKS_INODE_NUMBERS
4927 struct stat st_temp
;
4929 /* Note, set_input() resets input_stat_set to 0. */
4930 if (input_stat_set
== 0)
4932 input_stat_set
= stat (input_filename
, &input_stat
);
4933 if (input_stat_set
>= 0)
4937 /* If we have the stat for the input_filename
4938 and we can do the stat for the temp_filename
4939 then the they could still refer to the same
4940 file if st_dev/st_ino's are the same. */
4941 if (input_stat_set
!= 1
4942 || stat (temp_filename
, &st_temp
) < 0
4943 || input_stat
.st_dev
!= st_temp
.st_dev
4944 || input_stat
.st_ino
!= st_temp
.st_ino
)
4946 /* Just compare canonical pathnames. */
4947 char* input_realname
= lrealpath (input_filename
);
4948 char* temp_realname
= lrealpath (temp_filename
);
4949 bool files_differ
= strcmp (input_realname
, temp_realname
);
4950 free (input_realname
);
4951 free (temp_realname
);
4955 temp_filename
= save_string (temp_filename
,
4956 temp_filename_length
+ 1);
4957 obstack_grow (&obstack
, temp_filename
,
4958 temp_filename_length
);
4960 delete_this_arg
= 0;
4966 /* See if we already have an association of %g/%u/%U and
4968 for (t
= temp_names
; t
; t
= t
->next
)
4969 if (t
->length
== suffix_length
4970 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4971 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4974 /* Make a new association if needed. %u and %j
4976 if (t
== 0 || c
== 'u' || c
== 'j')
4980 t
= xmalloc (sizeof (struct temp_name
));
4981 t
->next
= temp_names
;
4984 t
->length
= suffix_length
;
4987 t
->suffix
= saved_suffix
;
4988 saved_suffix
= NULL
;
4991 t
->suffix
= save_string (suffix
, suffix_length
);
4992 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4993 temp_filename
= make_temp_file (t
->suffix
);
4994 temp_filename_length
= strlen (temp_filename
);
4995 t
->filename
= temp_filename
;
4996 t
->filename_length
= temp_filename_length
;
5000 free (saved_suffix
);
5002 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5003 delete_this_arg
= 1;
5011 for (i
= 0; (int) i
< n_infiles
; i
++)
5012 if ((!infiles
[i
].language
) || (infiles
[i
].language
[0] != '*'))
5013 if (infiles
[i
].incompiler
== input_file_compiler
)
5015 store_arg (infiles
[i
].name
, 0, 0);
5016 infiles
[i
].compiled
= true;
5021 obstack_grow (&obstack
, input_filename
, input_filename_length
);
5028 struct spec_path_info info
;
5032 do_spec_1 ("-imultilib", 1, NULL
);
5033 /* Make this a separate argument. */
5034 do_spec_1 (" ", 0, NULL
);
5035 do_spec_1 (multilib_dir
, 1, NULL
);
5036 do_spec_1 (" ", 0, NULL
);
5039 if (gcc_exec_prefix
)
5041 do_spec_1 ("-iprefix", 1, NULL
);
5042 /* Make this a separate argument. */
5043 do_spec_1 (" ", 0, NULL
);
5044 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5045 do_spec_1 (" ", 0, NULL
);
5048 if (target_system_root_changed
||
5049 (target_system_root
&& target_sysroot_hdrs_suffix
))
5051 do_spec_1 ("-isysroot", 1, NULL
);
5052 /* Make this a separate argument. */
5053 do_spec_1 (" ", 0, NULL
);
5054 do_spec_1 (target_system_root
, 1, NULL
);
5055 if (target_sysroot_hdrs_suffix
)
5056 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5057 do_spec_1 (" ", 0, NULL
);
5060 info
.option
= "-isystem";
5061 info
.append
= "include";
5062 info
.append_len
= strlen (info
.append
);
5063 info
.omit_relative
= false;
5064 info
.separate_options
= true;
5066 for_each_path (&include_prefixes
, false, info
.append_len
,
5069 info
.append
= "include-fixed";
5070 if (*sysroot_hdrs_suffix_spec
)
5071 info
.append
= concat (info
.append
, dir_separator_str
,
5072 multilib_dir
, NULL
);
5073 info
.append_len
= strlen (info
.append
);
5074 for_each_path (&include_prefixes
, false, info
.append_len
,
5081 int max
= n_infiles
;
5082 max
+= lang_specific_extra_outfiles
;
5084 if (HAVE_GNU_LD
&& at_file_supplied
)
5086 /* We are going to expand `%o' to `@FILE', where FILE
5087 is a newly-created temporary filename. The filenames
5088 that would usually be expanded in place of %o will be
5089 written to the temporary file. */
5091 char *temp_file
= make_temp_file ("");
5094 int n_files
, j
, status
;
5097 at_argument
= concat ("@", temp_file
, NULL
);
5098 store_arg (at_argument
, 0, 0);
5100 /* Convert OUTFILES into a form suitable for writeargv. */
5102 /* Determine how many are non-NULL. */
5103 for (n_files
= 0, i
= 0; i
< max
; i
++)
5104 n_files
+= outfiles
[i
] != NULL
;
5106 argv
= alloca (sizeof (char *) * (n_files
+ 1));
5108 /* Copy the strings over. */
5109 for (i
= 0, j
= 0; i
< max
; i
++)
5112 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5117 f
= fopen (temp_file
, "w");
5120 fatal ("could not open temporary response file %s",
5123 status
= writeargv (argv
, f
);
5126 fatal ("could not write to temporary response file %s",
5129 status
= fclose (f
);
5132 fatal ("could not close temporary response file %s",
5135 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
5138 for (i
= 0; i
< max
; i
++)
5140 store_arg (outfiles
[i
], 0, 0);
5145 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5150 this_is_library_file
= 1;
5154 outfiles
[input_file_number
] = NULL
;
5158 this_is_output_file
= 1;
5163 int cur_index
= argbuf_index
;
5164 /* Handle the {...} following the %W. */
5166 fatal ("spec '%s' has invalid '%%W%c", spec
, *p
);
5167 p
= handle_braces (p
+ 1);
5171 /* If any args were output, mark the last one for deletion
5173 if (argbuf_index
!= cur_index
)
5174 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
5178 /* %x{OPTION} records OPTION for %X to output. */
5184 /* Skip past the option value and make a copy. */
5186 fatal ("spec '%s' has invalid '%%x%c'", spec
, *p
);
5189 string
= save_string (p1
+ 1, p
- p1
- 2);
5191 /* See if we already recorded this option. */
5192 for (i
= 0; i
< n_linker_options
; i
++)
5193 if (! strcmp (string
, linker_options
[i
]))
5199 /* This option is new; add it. */
5200 add_linker_option (string
, strlen (string
));
5204 /* Dump out the options accumulated previously using %x. */
5206 for (i
= 0; i
< n_linker_options
; i
++)
5208 do_spec_1 (linker_options
[i
], 1, NULL
);
5209 /* Make each accumulated option a separate argument. */
5210 do_spec_1 (" ", 0, NULL
);
5214 /* Dump out the options accumulated previously using -Wa,. */
5216 for (i
= 0; i
< n_assembler_options
; i
++)
5218 do_spec_1 (assembler_options
[i
], 1, NULL
);
5219 /* Make each accumulated option a separate argument. */
5220 do_spec_1 (" ", 0, NULL
);
5224 /* Dump out the options accumulated previously using -Wp,. */
5226 for (i
= 0; i
< n_preprocessor_options
; i
++)
5228 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5229 /* Make each accumulated option a separate argument. */
5230 do_spec_1 (" ", 0, NULL
);
5234 /* Here are digits and numbers that just process
5235 a certain constant string as a spec. */
5238 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5244 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5250 value
= do_spec_1 (asm_spec
, 0, NULL
);
5256 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5263 const char *const spec
5264 = (input_file_compiler
->cpp_spec
5265 ? input_file_compiler
->cpp_spec
5267 value
= do_spec_1 (spec
, 0, NULL
);
5274 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5280 value
= do_spec_1 (link_spec
, 0, NULL
);
5286 value
= do_spec_1 (lib_spec
, 0, NULL
);
5292 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5298 /* We assume there is a directory
5299 separator at the end of this string. */
5300 if (target_system_root
)
5302 obstack_grow (&obstack
, target_system_root
,
5303 strlen (target_system_root
));
5304 if (target_sysroot_suffix
)
5305 obstack_grow (&obstack
, target_sysroot_suffix
,
5306 strlen (target_sysroot_suffix
));
5311 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5316 /* Here we define characters other than letters and digits. */
5319 p
= handle_braces (p
);
5325 p
= handle_spec_function (p
);
5331 obstack_1grow (&obstack
, '%');
5338 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5340 suffix_subst
= save_string (p
- 1, len
+ 1);
5345 /* Henceforth ignore the option(s) matching the pattern
5350 int have_wildcard
= 0;
5353 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5356 if (p
[len
-1] == '*')
5359 for (i
= 0; i
< n_switches
; i
++)
5360 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5361 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5363 switches
[i
].live_cond
|= SWITCH_IGNORE
;
5364 switches
[i
].validated
= 1;
5372 if (soft_matched_part
)
5374 do_spec_1 (soft_matched_part
, 1, NULL
);
5375 do_spec_1 (" ", 0, NULL
);
5378 /* Catch the case where a spec string contains something like
5379 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5380 hand side of the :. */
5381 error ("spec failure: '%%*' has not been initialized by pattern match");
5384 /* Process a string found as the value of a spec given by name.
5385 This feature allows individual machine descriptions
5386 to add and use their own specs.
5387 %[...] modifies -D options the way %P does;
5388 %(...) uses the spec unmodified. */
5390 error ("warning: use of obsolete %%[ operator in specs");
5393 const char *name
= p
;
5394 struct spec_list
*sl
;
5397 /* The string after the S/P is the name of a spec that is to be
5399 while (*p
&& *p
!= ')' && *p
!= ']')
5402 /* See if it's in the list. */
5403 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5404 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5406 name
= *(sl
->ptr_spec
);
5408 notice ("Processing spec %c%s%c, which is '%s'\n",
5409 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5418 value
= do_spec_1 (name
, 0, NULL
);
5424 char *x
= alloca (strlen (name
) * 2 + 1);
5426 const char *y
= name
;
5429 /* Copy all of NAME into BUF, but put __ after
5430 every -D and at the end of each arg. */
5433 if (! strncmp (y
, "-D", 2))
5444 && (*y
== ' ' || *y
== '\t' || *y
== '='
5445 || *y
== '}' || *y
== 0))
5458 value
= do_spec_1 (buf
, 0, NULL
);
5464 /* Discard the closing paren or bracket. */
5471 error ("spec failure: unrecognized spec option '%c'", c
);
5477 /* Backslash: treat next character as ordinary. */
5482 /* Ordinary character: put it into the current argument. */
5483 obstack_1grow (&obstack
, c
);
5487 /* End of string. If we are processing a spec function, we need to
5488 end any pending argument. */
5489 if (processing_spec_function
)
5495 /* Look up a spec function. */
5497 static const struct spec_function
*
5498 lookup_spec_function (const char *name
)
5500 const struct spec_function
*sf
;
5502 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5503 if (strcmp (sf
->name
, name
) == 0)
5509 /* Evaluate a spec function. */
5512 eval_spec_function (const char *func
, const char *args
)
5514 const struct spec_function
*sf
;
5515 const char *funcval
;
5517 /* Saved spec processing context. */
5518 int save_argbuf_index
;
5519 int save_argbuf_length
;
5520 const char **save_argbuf
;
5523 int save_delete_this_arg
;
5524 int save_this_is_output_file
;
5525 int save_this_is_library_file
;
5526 int save_input_from_pipe
;
5527 const char *save_suffix_subst
;
5530 sf
= lookup_spec_function (func
);
5532 fatal ("unknown spec function '%s'", func
);
5534 /* Push the spec processing context. */
5535 save_argbuf_index
= argbuf_index
;
5536 save_argbuf_length
= argbuf_length
;
5537 save_argbuf
= argbuf
;
5539 save_arg_going
= arg_going
;
5540 save_delete_this_arg
= delete_this_arg
;
5541 save_this_is_output_file
= this_is_output_file
;
5542 save_this_is_library_file
= this_is_library_file
;
5543 save_input_from_pipe
= input_from_pipe
;
5544 save_suffix_subst
= suffix_subst
;
5546 /* Create a new spec processing context, and build the function
5550 if (do_spec_2 (args
) < 0)
5551 fatal ("error in args to spec function '%s'", func
);
5553 /* argbuf_index is an index for the next argument to be inserted, and
5554 so contains the count of the args already inserted. */
5556 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5558 /* Pop the spec processing context. */
5559 argbuf_index
= save_argbuf_index
;
5560 argbuf_length
= save_argbuf_length
;
5562 argbuf
= save_argbuf
;
5564 arg_going
= save_arg_going
;
5565 delete_this_arg
= save_delete_this_arg
;
5566 this_is_output_file
= save_this_is_output_file
;
5567 this_is_library_file
= save_this_is_library_file
;
5568 input_from_pipe
= save_input_from_pipe
;
5569 suffix_subst
= save_suffix_subst
;
5574 /* Handle a spec function call of the form:
5578 ARGS is processed as a spec in a separate context and split into an
5579 argument vector in the normal fashion. The function returns a string
5580 containing a spec which we then process in the caller's context, or
5581 NULL if no processing is required. */
5584 handle_spec_function (const char *p
)
5587 const char *endp
, *funcval
;
5590 processing_spec_function
++;
5592 /* Get the function name. */
5593 for (endp
= p
; *endp
!= '\0'; endp
++)
5595 if (*endp
== '(') /* ) */
5597 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5598 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5599 fatal ("malformed spec function name");
5601 if (*endp
!= '(') /* ) */
5602 fatal ("no arguments for spec function");
5603 func
= save_string (p
, endp
- p
);
5606 /* Get the arguments. */
5607 for (count
= 0; *endp
!= '\0'; endp
++)
5616 else if (*endp
== '(') /* ) */
5621 fatal ("malformed spec function arguments");
5622 args
= save_string (p
, endp
- p
);
5625 /* p now points to just past the end of the spec function expression. */
5627 funcval
= eval_spec_function (func
, args
);
5628 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5634 processing_spec_function
--;
5639 /* Inline subroutine of handle_braces. Returns true if the current
5640 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5642 input_suffix_matches (const char *atom
, const char *end_atom
)
5644 return (input_suffix
5645 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5646 && input_suffix
[end_atom
- atom
] == '\0');
5649 /* Subroutine of handle_braces. Returns true if the current
5650 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5652 input_spec_matches (const char *atom
, const char *end_atom
)
5654 return (input_file_compiler
5655 && input_file_compiler
->suffix
5656 && input_file_compiler
->suffix
[0] != '\0'
5657 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5659 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5662 /* Subroutine of handle_braces. Returns true if a switch
5663 matching the atom bracketed by ATOM and END_ATOM appeared on the
5666 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5669 int len
= end_atom
- atom
;
5670 int plen
= starred
? len
: -1;
5672 for (i
= 0; i
< n_switches
; i
++)
5673 if (!strncmp (switches
[i
].part1
, atom
, len
)
5674 && (starred
|| switches
[i
].part1
[len
] == '\0')
5675 && check_live_switch (i
, plen
))
5681 /* Inline subroutine of handle_braces. Mark all of the switches which
5682 match ATOM (extends to END_ATOM; STARRED indicates whether there
5683 was a star after the atom) for later processing. */
5685 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5688 int len
= end_atom
- atom
;
5689 int plen
= starred
? len
: -1;
5691 for (i
= 0; i
< n_switches
; i
++)
5692 if (!strncmp (switches
[i
].part1
, atom
, len
)
5693 && (starred
|| switches
[i
].part1
[len
] == '\0')
5694 && check_live_switch (i
, plen
))
5695 switches
[i
].ordering
= 1;
5698 /* Inline subroutine of handle_braces. Process all the currently
5699 marked switches through give_switch, and clear the marks. */
5701 process_marked_switches (void)
5705 for (i
= 0; i
< n_switches
; i
++)
5706 if (switches
[i
].ordering
== 1)
5708 switches
[i
].ordering
= 0;
5713 /* Handle a %{ ... } construct. P points just inside the leading {.
5714 Returns a pointer one past the end of the brace block, or 0
5715 if we call do_spec_1 and that returns -1. */
5718 handle_braces (const char *p
)
5720 const char *atom
, *end_atom
;
5721 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5722 const char *orig
= p
;
5730 bool a_must_be_last
= false;
5731 bool ordered_set
= false;
5732 bool disjunct_set
= false;
5733 bool disj_matched
= false;
5734 bool disj_starred
= true;
5735 bool n_way_choice
= false;
5736 bool n_way_matched
= false;
5738 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5745 /* Scan one "atom" (S in the description above of %{}, possibly
5746 with '!', '.', '@', ',', or '*' modifiers). */
5748 a_is_suffix
= false;
5749 a_is_starred
= false;
5750 a_is_negated
= false;
5751 a_is_spectype
= false;
5755 p
++, a_is_negated
= true;
5759 p
++, a_is_suffix
= true;
5761 p
++, a_is_spectype
= true;
5764 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5765 || *p
== ',' || *p
== '.' || *p
== '@')
5770 p
++, a_is_starred
= 1;
5776 /* Substitute the switch(es) indicated by the current atom. */
5778 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5779 || a_is_spectype
|| atom
== end_atom
)
5782 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5785 process_marked_switches ();
5789 /* Substitute some text if the current atom appears as a switch
5791 disjunct_set
= true;
5795 if (atom
== end_atom
)
5797 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5798 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5802 /* An empty term may appear as the last choice of an
5803 N-way choice set; it means "otherwise". */
5804 a_must_be_last
= true;
5805 disj_matched
= !n_way_matched
;
5806 disj_starred
= false;
5810 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5814 disj_starred
= false;
5816 /* Don't bother testing this atom if we already have a
5818 if (!disj_matched
&& !n_way_matched
)
5821 a_matched
= input_suffix_matches (atom
, end_atom
);
5822 else if (a_is_spectype
)
5823 a_matched
= input_spec_matches (atom
, end_atom
);
5825 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5827 if (a_matched
!= a_is_negated
)
5829 disj_matched
= true;
5831 d_end_atom
= end_atom
;
5838 /* Found the body, that is, the text to substitute if the
5839 current disjunction matches. */
5840 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5841 disj_matched
&& !n_way_matched
);
5845 /* If we have an N-way choice, reset state for the next
5849 n_way_choice
= true;
5850 n_way_matched
|= disj_matched
;
5851 disj_matched
= false;
5852 disj_starred
= true;
5853 d_atom
= d_end_atom
= NULL
;
5862 while (*p
++ != '}');
5867 fatal ("braced spec '%s' is invalid at '%c'", orig
, *p
);
5872 /* Subroutine of handle_braces. Scan and process a brace substitution body
5873 (X in the description of %{} syntax). P points one past the colon;
5874 ATOM and END_ATOM bracket the first atom which was found to be true
5875 (present) in the current disjunction; STARRED indicates whether all
5876 the atoms in the current disjunction were starred (for syntax validation);
5877 MATCHED indicates whether the disjunction matched or not, and therefore
5878 whether or not the body is to be processed through do_spec_1 or just
5879 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5883 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5884 int starred
, int matched
)
5886 const char *body
, *end_body
;
5887 unsigned int nesting_level
;
5888 bool have_subst
= false;
5890 /* Locate the closing } or ;, honoring nested braces.
5891 Trim trailing whitespace. */
5900 if (!--nesting_level
)
5903 else if (*p
== ';' && nesting_level
== 1)
5905 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5907 else if (*p
== '\0')
5913 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5916 if (have_subst
&& !starred
)
5921 /* Copy the substitution body to permanent storage and execute it.
5922 If have_subst is false, this is a simple matter of running the
5923 body through do_spec_1... */
5924 char *string
= save_string (body
, end_body
- body
);
5927 if (do_spec_1 (string
, 0, NULL
) < 0)
5932 /* ... but if have_subst is true, we have to process the
5933 body once for each matching switch, with %* set to the
5934 variant part of the switch. */
5935 unsigned int hard_match_len
= end_atom
- atom
;
5938 for (i
= 0; i
< n_switches
; i
++)
5939 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5940 && check_live_switch (i
, hard_match_len
))
5942 if (do_spec_1 (string
, 0,
5943 &switches
[i
].part1
[hard_match_len
]) < 0)
5945 /* Pass any arguments this switch has. */
5947 suffix_subst
= NULL
;
5955 fatal ("braced spec body '%s' is invalid", body
);
5958 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5959 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5960 spec, or -1 if either exact match or %* is used.
5962 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5963 whose value does not begin with "no-" is obsoleted by the same value
5964 with the "no-", similarly for a switch with the "no-" prefix. */
5967 check_live_switch (int switchnum
, int prefix_length
)
5969 const char *name
= switches
[switchnum
].part1
;
5972 /* In the common case of {<at-most-one-letter>*}, a negating
5973 switch would always match, so ignore that case. We will just
5974 send the conflicting switches to the compiler phase. */
5975 if (prefix_length
>= 0 && prefix_length
<= 1)
5978 /* If we already processed this switch and determined if it was
5979 live or not, return our past determination. */
5980 if (switches
[switchnum
].live_cond
!= 0)
5981 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
5982 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0);
5984 /* Now search for duplicate in a manner that depends on the name. */
5988 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5989 if (switches
[i
].part1
[0] == 'O')
5991 switches
[switchnum
].validated
= 1;
5992 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5997 case 'W': case 'f': case 'm':
5998 if (! strncmp (name
+ 1, "no-", 3))
6000 /* We have Xno-YYY, search for XYYY. */
6001 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6002 if (switches
[i
].part1
[0] == name
[0]
6003 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6005 switches
[switchnum
].validated
= 1;
6006 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6012 /* We have XYYY, search for Xno-YYY. */
6013 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6014 if (switches
[i
].part1
[0] == name
[0]
6015 && switches
[i
].part1
[1] == 'n'
6016 && switches
[i
].part1
[2] == 'o'
6017 && switches
[i
].part1
[3] == '-'
6018 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6020 switches
[switchnum
].validated
= 1;
6021 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6028 /* Otherwise the switch is live. */
6029 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6033 /* Pass a switch to the current accumulating command
6034 in the same form that we received it.
6035 SWITCHNUM identifies the switch; it is an index into
6036 the vector of switches gcc received, which is `switches'.
6037 This cannot fail since it never finishes a command line.
6039 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6042 give_switch (int switchnum
, int omit_first_word
)
6044 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6047 if (!omit_first_word
)
6049 do_spec_1 ("-", 0, NULL
);
6050 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6053 if (switches
[switchnum
].args
!= 0)
6056 for (p
= switches
[switchnum
].args
; *p
; p
++)
6058 const char *arg
= *p
;
6060 do_spec_1 (" ", 0, NULL
);
6063 unsigned length
= strlen (arg
);
6066 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6067 if (arg
[length
] == '.')
6069 (CONST_CAST(char *, arg
))[length
] = 0;
6073 do_spec_1 (arg
, 1, NULL
);
6075 (CONST_CAST(char *, arg
))[length
] = '.';
6076 do_spec_1 (suffix_subst
, 1, NULL
);
6079 do_spec_1 (arg
, 1, NULL
);
6083 do_spec_1 (" ", 0, NULL
);
6084 switches
[switchnum
].validated
= 1;
6087 /* Search for a file named NAME trying various prefixes including the
6088 user's -B prefix and some standard ones.
6089 Return the absolute file name found. If nothing is found, return NAME. */
6092 find_file (const char *name
)
6094 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6095 return newname
? newname
: name
;
6098 /* Determine whether a directory exists. If LINKER, return 0 for
6099 certain fixed names not needed by the linker. */
6102 is_directory (const char *path1
, bool linker
)
6109 /* Ensure the string ends with "/.". The resulting path will be a
6110 directory even if the given path is a symbolic link. */
6111 len1
= strlen (path1
);
6112 path
= alloca (3 + len1
);
6113 memcpy (path
, path1
, len1
);
6115 if (!IS_DIR_SEPARATOR (cp
[-1]))
6116 *cp
++ = DIR_SEPARATOR
;
6120 /* Exclude directories that the linker is known to search. */
6122 && IS_DIR_SEPARATOR (path
[0])
6124 && strncmp (path
+ 1, "lib", 3) == 0)
6126 && strncmp (path
+ 1, "usr", 3) == 0
6127 && IS_DIR_SEPARATOR (path
[4])
6128 && strncmp (path
+ 5, "lib", 3) == 0)))
6131 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6134 /* Set up the various global variables to indicate that we're processing
6135 the input file named FILENAME. */
6138 set_input (const char *filename
)
6142 input_filename
= filename
;
6143 input_filename_length
= strlen (input_filename
);
6145 input_basename
= input_filename
;
6146 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
6147 /* Skip drive name so 'x:foo' is handled properly. */
6148 if (input_basename
[1] == ':')
6149 input_basename
+= 2;
6151 for (p
= input_basename
; *p
; p
++)
6152 if (IS_DIR_SEPARATOR (*p
))
6153 input_basename
= p
+ 1;
6155 /* Find a suffix starting with the last period,
6156 and set basename_length to exclude that suffix. */
6157 basename_length
= strlen (input_basename
);
6158 suffixed_basename_length
= basename_length
;
6159 p
= input_basename
+ basename_length
;
6160 while (p
!= input_basename
&& *p
!= '.')
6162 if (*p
== '.' && p
!= input_basename
)
6164 basename_length
= p
- input_basename
;
6165 input_suffix
= p
+ 1;
6170 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6171 we will need to do a stat on the input_filename. The
6172 INPUT_STAT_SET signals that the stat is needed. */
6176 /* On fatal signals, delete all the temporary files. */
6179 fatal_error (int signum
)
6181 signal (signum
, SIG_DFL
);
6182 delete_failure_queue ();
6183 delete_temp_files ();
6184 /* Get the same signal again, this time not handled,
6185 so its normal effect occurs. */
6186 kill (getpid (), signum
);
6189 extern int main (int, char **);
6192 main (int argc
, char **argv
)
6196 int linker_was_run
= 0;
6197 int lang_n_infiles
= 0;
6198 int num_linker_inputs
= 0;
6199 char *explicit_link_files
;
6202 struct user_specs
*uptr
;
6203 char **old_argv
= argv
;
6205 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6206 on ?: in file-scope variable initializations. */
6207 asm_debug
= ASM_DEBUG_SPEC
;
6209 p
= argv
[0] + strlen (argv
[0]);
6210 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6214 xmalloc_set_program_name (programname
);
6216 if (getenv ("GCCSERVER") != NULL
)
6219 use_pipes
= 1; /* FIXME... need better processing */
6222 expandargv (&argc
, &argv
);
6224 /* Determine if any expansions were made. */
6225 if (argv
!= old_argv
)
6226 at_file_supplied
= true;
6228 prune_options (&argc
, &argv
);
6230 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6231 /* Perform host dependent initialization when needed. */
6232 GCC_DRIVER_HOST_INITIALIZATION
;
6235 /* Unlock the stdio streams. */
6236 unlock_std_streams ();
6238 gcc_init_libintl ();
6240 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6241 signal (SIGINT
, fatal_error
);
6243 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6244 signal (SIGHUP
, fatal_error
);
6246 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6247 signal (SIGTERM
, fatal_error
);
6249 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6250 signal (SIGPIPE
, fatal_error
);
6253 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6254 receive the signal. A different setting is inheritable */
6255 signal (SIGCHLD
, SIG_DFL
);
6258 /* Allocate the argument vector. */
6261 obstack_init (&obstack
);
6263 /* Build multilib_select, et. al from the separate lines that make up each
6264 multilib selection. */
6266 const char *const *q
= multilib_raw
;
6269 obstack_init (&multilib_obstack
);
6270 while ((p
= *q
++) != (char *) 0)
6271 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6273 obstack_1grow (&multilib_obstack
, 0);
6274 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6276 q
= multilib_matches_raw
;
6277 while ((p
= *q
++) != (char *) 0)
6278 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6280 obstack_1grow (&multilib_obstack
, 0);
6281 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6283 q
= multilib_exclusions_raw
;
6284 while ((p
= *q
++) != (char *) 0)
6285 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6287 obstack_1grow (&multilib_obstack
, 0);
6288 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6291 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6294 obstack_1grow (&multilib_obstack
, ' ');
6295 obstack_grow (&multilib_obstack
,
6296 multilib_defaults_raw
[i
],
6297 strlen (multilib_defaults_raw
[i
]));
6301 obstack_1grow (&multilib_obstack
, 0);
6302 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6305 /* Set up to remember the pathname of gcc and any options
6306 needed for collect. We use argv[0] instead of programname because
6307 we need the complete pathname. */
6308 obstack_init (&collect_obstack
);
6309 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6310 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6311 xputenv (XOBFINISH (&collect_obstack
, char *));
6313 #ifdef INIT_ENVIRONMENT
6314 /* Set up any other necessary machine specific environment variables. */
6315 xputenv (INIT_ENVIRONMENT
);
6318 /* Make a table of what switches there are (switches, n_switches).
6319 Make a table of specified input files (infiles, n_infiles).
6320 Decode switches that are handled locally. */
6322 process_command (argc
, (const char **) argv
);
6324 /* Initialize the vector of specs to just the default.
6325 This means one element containing 0s, as a terminator. */
6327 compilers
= xmalloc (sizeof default_compilers
);
6328 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6329 n_compilers
= n_default_compilers
;
6331 /* Read specs from a file if there is one. */
6333 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6334 spec_version
, dir_separator_str
, NULL
);
6335 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6337 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6338 /* Read the specs file unless it is a default one. */
6339 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6340 read_specs (specs_file
, TRUE
);
6344 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6345 for any override of as, ld and libraries. */
6346 specs_file
= alloca (strlen (standard_exec_prefix
)
6347 + strlen (just_machine_suffix
) + sizeof ("specs"));
6349 strcpy (specs_file
, standard_exec_prefix
);
6350 strcat (specs_file
, just_machine_suffix
);
6351 strcat (specs_file
, "specs");
6352 if (access (specs_file
, R_OK
) == 0)
6353 read_specs (specs_file
, TRUE
);
6355 /* Process any configure-time defaults specified for the command line
6356 options, via OPTION_DEFAULT_SPECS. */
6357 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6358 do_option_spec (option_default_specs
[i
].name
,
6359 option_default_specs
[i
].spec
);
6361 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6362 of the command line. */
6364 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6365 do_self_spec (driver_self_specs
[i
]);
6367 /* If not cross-compiling, look for executables in the standard
6369 if (*cross_compile
== '0')
6371 if (*md_exec_prefix
)
6373 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6374 PREFIX_PRIORITY_LAST
, 0, 0);
6378 /* Process sysroot_suffix_spec. */
6379 if (*sysroot_suffix_spec
!= 0
6380 && do_spec_2 (sysroot_suffix_spec
) == 0)
6382 if (argbuf_index
> 1)
6383 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6384 else if (argbuf_index
== 1)
6385 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6388 #ifdef HAVE_LD_SYSROOT
6389 /* Pass the --sysroot option to the linker, if it supports that. If
6390 there is a sysroot_suffix_spec, it has already been processed by
6391 this point, so target_system_root really is the system root we
6393 if (target_system_root
)
6395 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6396 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6397 set_spec ("link", XOBFINISH (&obstack
, const char *));
6401 /* Process sysroot_hdrs_suffix_spec. */
6402 if (*sysroot_hdrs_suffix_spec
!= 0
6403 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6405 if (argbuf_index
> 1)
6406 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6407 else if (argbuf_index
== 1)
6408 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6411 /* Look for startfiles in the standard places. */
6412 if (*startfile_prefix_spec
!= 0
6413 && do_spec_2 (startfile_prefix_spec
) == 0
6414 && do_spec_1 (" ", 0, NULL
) == 0)
6417 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6418 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6419 PREFIX_PRIORITY_LAST
, 0, 1);
6421 /* We should eventually get rid of all these and stick to
6422 startfile_prefix_spec exclusively. */
6423 else if (*cross_compile
== '0' || target_system_root
)
6425 if (*md_startfile_prefix
)
6426 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6427 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6429 if (*md_startfile_prefix_1
)
6430 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6431 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6433 /* If standard_startfile_prefix is relative, base it on
6434 standard_exec_prefix. This lets us move the installed tree
6435 as a unit. If GCC_EXEC_PREFIX is defined, base
6436 standard_startfile_prefix on that as well.
6438 If the prefix is relative, only search it for native compilers;
6439 otherwise we will search a directory containing host libraries. */
6440 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6441 add_sysrooted_prefix (&startfile_prefixes
,
6442 standard_startfile_prefix
, "BINUTILS",
6443 PREFIX_PRIORITY_LAST
, 0, 1);
6444 else if (*cross_compile
== '0')
6446 add_prefix (&startfile_prefixes
,
6447 concat (gcc_exec_prefix
6448 ? gcc_exec_prefix
: standard_exec_prefix
,
6450 standard_startfile_prefix
, NULL
),
6451 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6454 /* Sysrooted prefixes are relocated because target_system_root is
6455 also relocated by gcc_exec_prefix. */
6456 if (*standard_startfile_prefix_1
)
6457 add_sysrooted_prefix (&startfile_prefixes
,
6458 standard_startfile_prefix_1
, "BINUTILS",
6459 PREFIX_PRIORITY_LAST
, 0, 1);
6460 if (*standard_startfile_prefix_2
)
6461 add_sysrooted_prefix (&startfile_prefixes
,
6462 standard_startfile_prefix_2
, "BINUTILS",
6463 PREFIX_PRIORITY_LAST
, 0, 1);
6466 /* Process any user specified specs in the order given on the command
6468 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6470 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6472 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6475 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6476 if (gcc_exec_prefix
)
6477 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6478 spec_version
, dir_separator_str
, NULL
);
6480 /* Now we have the specs.
6481 Set the `valid' bits for switches that match anything in any spec. */
6483 validate_all_switches ();
6485 /* Now that we have the switches and the specs, set
6486 the subdirectory based on the options. */
6487 set_multilib_dir ();
6489 /* Warn about any switches that no pass was interested in. */
6491 for (i
= 0; (int) i
< n_switches
; i
++)
6492 if (! switches
[i
].validated
)
6493 error ("unrecognized option '-%s'", switches
[i
].part1
);
6495 /* Obey some of the options. */
6497 if (print_search_dirs
)
6499 printf (_("install: %s%s\n"),
6500 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6501 gcc_exec_prefix
? "" : machine_suffix
);
6502 printf (_("programs: %s\n"),
6503 build_search_list (&exec_prefixes
, "", false, false));
6504 printf (_("libraries: %s\n"),
6505 build_search_list (&startfile_prefixes
, "", false, true));
6509 if (print_file_name
)
6511 printf ("%s\n", find_file (print_file_name
));
6515 if (print_prog_name
)
6517 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6518 printf ("%s\n", (newname
? newname
: print_prog_name
));
6522 if (print_multi_lib
)
6524 print_multilib_info ();
6528 if (print_multi_directory
)
6530 if (multilib_dir
== NULL
)
6533 printf ("%s\n", multilib_dir
);
6537 if (print_multi_os_directory
)
6539 if (multilib_os_dir
== NULL
)
6542 printf ("%s\n", multilib_os_dir
);
6546 if (print_sysroot_headers_suffix
)
6548 if (*sysroot_hdrs_suffix_spec
)
6550 printf("%s\n", (target_sysroot_hdrs_suffix
6551 ? target_sysroot_hdrs_suffix
6556 /* The error status indicates that only one set of fixed
6557 headers should be built. */
6558 fatal ("not configured with sysroot headers suffix");
6561 if (print_help_list
)
6567 printf (_("\nFor bug reporting instructions, please see:\n"));
6568 printf ("%s.\n", bug_report_url
);
6573 /* We do not exit here. Instead we have created a fake input file
6574 called 'help-dummy' which needs to be compiled, and we pass this
6575 on the various sub-processes, along with the --help switch. */
6580 /* FIXME: allow more than cc1... */
6581 server_start (find_a_file (&exec_prefixes
, "cc1", X_OK
, 0),
6588 /* FIXME: allow more than cc1... */
6589 client_kill_server (find_a_file (&exec_prefixes
, "cc1", X_OK
, 0));
6598 notice ("Target: %s\n", spec_machine
);
6599 notice ("Configured with: %s\n", configuration_arguments
);
6601 #ifdef THREAD_MODEL_SPEC
6602 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6603 but there's no point in doing all this processing just to get
6604 thread_model back. */
6605 obstack_init (&obstack
);
6606 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6607 obstack_1grow (&obstack
, '\0');
6608 thrmod
= XOBFINISH (&obstack
, const char *);
6610 thrmod
= thread_model
;
6613 notice ("Thread model: %s\n", thrmod
);
6615 /* compiler_version is truncated at the first space when initialized
6616 from version string, so truncate version_string at the first space
6617 before comparing. */
6618 for (n
= 0; version_string
[n
]; n
++)
6619 if (version_string
[n
] == ' ')
6622 if (! strncmp (version_string
, compiler_version
, n
)
6623 && compiler_version
[n
] == 0)
6624 notice ("gcc version %s %s\n", version_string
, pkgversion_string
);
6626 notice ("gcc driver version %s %sexecuting gcc version %s\n",
6627 version_string
, pkgversion_string
, compiler_version
);
6633 if (n_infiles
== added_libraries
)
6634 fatal ("no input files");
6636 /* Make a place to record the compiler output file names
6637 that correspond to the input files. */
6640 i
+= lang_specific_extra_outfiles
;
6641 outfiles
= XCNEWVEC (const char *, i
);
6643 /* Record which files were specified explicitly as link input. */
6645 explicit_link_files
= XCNEWVEC (char, n_infiles
);
6648 combine_inputs
= true;
6650 combine_inputs
= false;
6652 for (i
= 0; (int) i
< n_infiles
; i
++)
6654 const char *name
= infiles
[i
].name
;
6655 struct compiler
*compiler
= lookup_compiler (name
,
6657 infiles
[i
].language
);
6659 /* Can't use the server when compiling stdin. We could write to
6660 a temporary file, but it isn't worth the effort -- ordinarily
6661 stdin is only used for scratch compilations. */
6662 if (use_server
&& !strcmp (name
, "-"))
6665 if (compiler
&& !(compiler
->combinable
))
6666 combine_inputs
= false;
6668 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6669 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6670 infiles
[i
].incompiler
= compiler
;
6674 input_file_compiler
= compiler
;
6675 infiles
[i
].incompiler
= compiler
;
6679 /* Since there is no compiler for this input file, assume it is a
6681 explicit_link_files
[i
] = 1;
6682 infiles
[i
].incompiler
= NULL
;
6684 infiles
[i
].compiled
= false;
6685 infiles
[i
].preprocessed
= false;
6688 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6689 fatal ("cannot specify -o with -c or -S with multiple files");
6691 if (combine_flag
&& save_temps_flag
)
6693 bool save_combine_inputs
= combine_inputs
;
6694 /* Must do a separate pre-processing pass for C & Objective-C files, to
6695 obtain individual .i files. */
6697 combine_inputs
= false;
6698 for (i
= 0; (int) i
< n_infiles
; i
++)
6700 int this_file_error
= 0;
6702 input_file_number
= i
;
6703 set_input (infiles
[i
].name
);
6704 if (infiles
[i
].incompiler
6705 && (infiles
[i
].incompiler
)->needs_preprocessing
)
6706 input_file_compiler
= infiles
[i
].incompiler
;
6710 if (input_file_compiler
)
6712 if (input_file_compiler
->spec
[0] == '#')
6714 error ("%s: %s compiler not installed on this system",
6715 input_filename
, &input_file_compiler
->spec
[1]);
6716 this_file_error
= 1;
6720 value
= do_spec (input_file_compiler
->spec
);
6721 infiles
[i
].preprocessed
= true;
6722 if (!have_o_argbuf_index
)
6723 fatal ("spec '%s' is invalid", input_file_compiler
->spec
);
6724 infiles
[i
].name
= argbuf
[have_o_argbuf_index
];
6725 infiles
[i
].incompiler
6726 = lookup_compiler (infiles
[i
].name
,
6727 strlen (infiles
[i
].name
),
6728 infiles
[i
].language
);
6731 this_file_error
= 1;
6735 if (this_file_error
)
6737 delete_failure_queue ();
6741 clear_failure_queue ();
6743 combine_inputs
= save_combine_inputs
;
6746 for (i
= 0; (int) i
< n_infiles
; i
++)
6748 int this_file_error
= 0;
6750 /* Tell do_spec what to substitute for %i. */
6752 input_file_number
= i
;
6753 set_input (infiles
[i
].name
);
6755 if (infiles
[i
].compiled
)
6758 /* Use the same thing in %o, unless cp->spec says otherwise. */
6760 outfiles
[i
] = input_filename
;
6762 /* Figure out which compiler from the file's suffix. */
6764 if (! combine_inputs
)
6766 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6767 infiles
[i
].language
);
6769 input_file_compiler
= infiles
[i
].incompiler
;
6771 if (input_file_compiler
)
6773 /* Ok, we found an applicable compiler. Run its spec. */
6775 if (input_file_compiler
->spec
[0] == '#')
6777 error ("%s: %s compiler not installed on this system",
6778 input_filename
, &input_file_compiler
->spec
[1]);
6779 this_file_error
= 1;
6783 value
= do_spec (input_file_compiler
->spec
);
6784 infiles
[i
].compiled
= true;
6786 this_file_error
= 1;
6790 /* If this file's name does not contain a recognized suffix,
6791 record it as explicit linker input. */
6794 explicit_link_files
[i
] = 1;
6796 /* Clear the delete-on-failure queue, deleting the files in it
6797 if this compilation failed. */
6799 if (this_file_error
)
6801 delete_failure_queue ();
6804 /* If this compilation succeeded, don't delete those files later. */
6805 clear_failure_queue ();
6808 /* Reset the input file name to the first compile/object file name, for use
6809 with %b in LINK_SPEC. We use the first input file that we can find
6810 a compiler to compile it instead of using infiles.language since for
6811 languages other than C we use aliases that we then lookup later. */
6816 for (i
= 0; i
< n_infiles
; i
++)
6817 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6819 set_input (infiles
[i
].name
);
6824 if (error_count
== 0)
6826 /* Make sure INPUT_FILE_NUMBER points to first available open
6828 input_file_number
= n_infiles
;
6829 if (lang_specific_pre_link ())
6833 /* Determine if there are any linker input files. */
6834 num_linker_inputs
= 0;
6835 for (i
= 0; (int) i
< n_infiles
; i
++)
6836 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6837 num_linker_inputs
++;
6839 /* Run ld to link all the compiler output files. */
6841 if (num_linker_inputs
> 0 && error_count
== 0 && print_subprocess_help
< 2)
6843 int tmp
= execution_count
;
6845 /* We'll use ld if we can't find collect2. */
6846 if (! strcmp (linker_name_spec
, "collect2"))
6848 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
6850 linker_name_spec
= "ld";
6852 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6854 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
6855 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
6857 if (print_subprocess_help
== 1)
6859 printf (_("\nLinker options\n==============\n\n"));
6860 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6861 " to the linker.\n\n"));
6864 value
= do_spec (link_command_spec
);
6867 linker_was_run
= (tmp
!= execution_count
);
6870 /* If options said don't run linker,
6871 complain about input files to be given to the linker. */
6873 if (! linker_was_run
&& error_count
== 0)
6874 for (i
= 0; (int) i
< n_infiles
; i
++)
6875 if (explicit_link_files
[i
]
6876 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
6877 error ("%s: linker input file unused because linking not done",
6880 /* Delete some or all of the temporary files we made. */
6883 delete_failure_queue ();
6884 delete_temp_files ();
6886 if (print_help_list
)
6888 printf (("\nFor bug reporting instructions, please see:\n"));
6889 printf ("%s\n", bug_report_url
);
6892 return (signal_count
!= 0 ? 2
6893 : error_count
> 0 ? (pass_exit_codes
? greatest_status
: 1)
6897 /* Find the proper compilation spec for the file name NAME,
6898 whose length is LENGTH. LANGUAGE is the specified language,
6899 or 0 if this file is to be passed to the linker. */
6901 static struct compiler
*
6902 lookup_compiler (const char *name
, size_t length
, const char *language
)
6904 struct compiler
*cp
;
6906 /* If this was specified by the user to be a linker input, indicate that. */
6907 if (language
!= 0 && language
[0] == '*')
6910 /* Otherwise, look for the language, if one is spec'd. */
6913 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6914 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
6917 error ("language %s not recognized", language
);
6921 /* Look for a suffix. */
6922 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6924 if (/* The suffix `-' matches only the file name `-'. */
6925 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6926 || (strlen (cp
->suffix
) < length
6927 /* See if the suffix matches the end of NAME. */
6928 && !strcmp (cp
->suffix
,
6929 name
+ length
- strlen (cp
->suffix
))
6934 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6935 /* Look again, but case-insensitively this time. */
6937 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6939 if (/* The suffix `-' matches only the file name `-'. */
6940 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6941 || (strlen (cp
->suffix
) < length
6942 /* See if the suffix matches the end of NAME. */
6943 && ((!strcmp (cp
->suffix
,
6944 name
+ length
- strlen (cp
->suffix
))
6945 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6946 && !strcasecmp (cp
->suffix
,
6947 name
+ length
- strlen (cp
->suffix
)))
6953 if (cp
>= compilers
)
6955 if (cp
->spec
[0] != '@')
6956 /* A non-alias entry: return it. */
6959 /* An alias entry maps a suffix to a language.
6960 Search for the language; pass 0 for NAME and LENGTH
6961 to avoid infinite recursion if language not found. */
6962 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
6968 save_string (const char *s
, int len
)
6970 char *result
= XNEWVEC (char, len
+ 1);
6972 memcpy (result
, s
, len
);
6978 pfatal_with_name (const char *name
)
6980 perror_with_name (name
);
6981 delete_temp_files ();
6986 perror_with_name (const char *name
)
6988 error ("%s: %s", name
, xstrerror (errno
));
6991 /* Output an error message and exit. */
6994 fancy_abort (const char *file
, int line
, const char *func
)
6996 fatal_ice ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
6999 /* Output an error message and exit. */
7002 fatal_ice (const char *cmsgid
, ...)
7006 va_start (ap
, cmsgid
);
7008 fprintf (stderr
, "%s: ", programname
);
7009 vfprintf (stderr
, _(cmsgid
), ap
);
7011 fprintf (stderr
, "\n");
7012 delete_temp_files ();
7013 exit (pass_exit_codes
? ICE_EXIT_CODE
: 1);
7017 fatal (const char *cmsgid
, ...)
7021 va_start (ap
, cmsgid
);
7023 fprintf (stderr
, "%s: ", programname
);
7024 vfprintf (stderr
, _(cmsgid
), ap
);
7026 fprintf (stderr
, "\n");
7027 delete_temp_files ();
7031 /* The argument is actually c-format, not gcc-internal-format,
7032 but because functions with identical names are used through
7033 the rest of the compiler with gcc-internal-format, we just
7034 need to hope all users of these functions use the common
7035 subset between c-format and gcc-internal-format. */
7038 error (const char *gmsgid
, ...)
7042 va_start (ap
, gmsgid
);
7043 fprintf (stderr
, "%s: ", programname
);
7044 vfprintf (stderr
, _(gmsgid
), ap
);
7047 fprintf (stderr
, "\n");
7051 notice (const char *cmsgid
, ...)
7055 va_start (ap
, cmsgid
);
7056 vfprintf (stderr
, _(cmsgid
), ap
);
7061 validate_switches_from_spec (const char *spec
)
7063 const char *p
= spec
;
7066 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7067 /* We have a switch spec. */
7068 p
= validate_switches (p
+ 1);
7072 validate_all_switches (void)
7074 struct compiler
*comp
;
7075 struct spec_list
*spec
;
7077 for (comp
= compilers
; comp
->spec
; comp
++)
7078 validate_switches_from_spec (comp
->spec
);
7080 /* Look through the linked list of specs read from the specs file. */
7081 for (spec
= specs
; spec
; spec
= spec
->next
)
7082 validate_switches_from_spec (*spec
->ptr_spec
);
7084 validate_switches_from_spec (link_command_spec
);
7087 /* Look at the switch-name that comes after START
7088 and mark as valid all supplied switches that match it. */
7091 validate_switches (const char *start
)
7093 const char *p
= start
;
7097 bool suffix
= false;
7098 bool starred
= false;
7100 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7109 if (*p
== '.' || *p
== ',')
7113 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7114 || *p
== ',' || *p
== '.' || *p
== '@')
7119 starred
= true, p
++;
7125 /* Mark all matching switches as valid. */
7126 for (i
= 0; i
< n_switches
; i
++)
7127 if (!strncmp (switches
[i
].part1
, atom
, len
)
7128 && (starred
|| switches
[i
].part1
[len
] == 0))
7129 switches
[i
].validated
= 1;
7133 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7136 if (*p
&& p
[-1] == ':')
7138 while (*p
&& *p
!= ';' && *p
!= '}')
7143 if (*p
== '{' || *p
== '<')
7144 p
= validate_switches (p
+1);
7145 else if (p
[0] == 'W' && p
[1] == '{')
7146 p
= validate_switches (p
+2);
7153 if (*p
&& p
[-1] == ';')
7167 static struct mdswitchstr
*mdswitches
;
7168 static int n_mdswitches
;
7170 /* Check whether a particular argument was used. The first time we
7171 canonicalize the switches to keep only the ones we care about. */
7174 used_arg (const char *p
, int len
)
7179 const char *replace
;
7184 static struct mswitchstr
*mswitches
;
7185 static int n_mswitches
;
7190 struct mswitchstr
*matches
;
7194 /* Break multilib_matches into the component strings of string
7195 and replacement string. */
7196 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7200 matches
= alloca ((sizeof (struct mswitchstr
)) * cnt
);
7202 q
= multilib_matches
;
7211 fatal ("multilib spec '%s' is invalid", multilib_matches
);
7215 matches
[i
].len
= q
- matches
[i
].str
;
7217 matches
[i
].replace
= ++q
;
7218 while (*q
!= ';' && *q
!= '\0')
7221 goto invalid_matches
;
7224 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7230 /* Now build a list of the replacement string for switches that we care
7231 about. Make sure we allocate at least one entry. This prevents
7232 xmalloc from calling fatal, and prevents us from re-executing this
7235 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7236 for (i
= 0; i
< n_switches
; i
++)
7237 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7239 int xlen
= strlen (switches
[i
].part1
);
7240 for (j
= 0; j
< cnt
; j
++)
7241 if (xlen
== matches
[j
].len
7242 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7244 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7245 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7246 mswitches
[n_mswitches
].replace
= (char *) 0;
7247 mswitches
[n_mswitches
].rep_len
= 0;
7253 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7254 on the command line nor any options mutually incompatible with
7256 for (i
= 0; i
< n_mdswitches
; i
++)
7260 for (q
= multilib_options
; *q
!= '\0'; q
++)
7266 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7267 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7269 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7276 if (*q
!= ' ' && *q
!= '\0')
7278 while (*r
!= ' ' && *r
!= '\0')
7281 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7284 if (used_arg (r
, q
- r
))
7289 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7290 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7291 mswitches
[n_mswitches
].replace
= (char *) 0;
7292 mswitches
[n_mswitches
].rep_len
= 0;
7305 for (i
= 0; i
< n_mswitches
; i
++)
7306 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7313 default_arg (const char *p
, int len
)
7317 for (i
= 0; i
< n_mdswitches
; i
++)
7318 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7324 /* Work out the subdirectory to use based on the options. The format of
7325 multilib_select is a list of elements. Each element is a subdirectory
7326 name followed by a list of options followed by a semicolon. The format
7327 of multilib_exclusions is the same, but without the preceding
7328 directory. First gcc will check the exclusions, if none of the options
7329 beginning with an exclamation point are present, and all of the other
7330 options are present, then we will ignore this completely. Passing
7331 that, gcc will consider each multilib_select in turn using the same
7332 rules for matching the options. If a match is found, that subdirectory
7336 set_multilib_dir (void)
7339 unsigned int this_path_len
;
7340 const char *this_path
, *this_arg
;
7341 const char *start
, *end
;
7343 int ok
, ndfltok
, first
;
7346 start
= multilib_defaults
;
7347 while (*start
== ' ' || *start
== '\t')
7349 while (*start
!= '\0')
7352 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7354 while (*start
== ' ' || *start
== '\t')
7362 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7363 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7365 while (*start
== ' ' || *start
== '\t')
7371 for (end
= start
+ 1;
7372 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7375 obstack_grow (&multilib_obstack
, start
, end
- start
);
7376 obstack_1grow (&multilib_obstack
, 0);
7377 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7378 mdswitches
[i
++].len
= end
- start
;
7385 p
= multilib_exclusions
;
7388 /* Ignore newlines. */
7395 /* Check the arguments. */
7402 fatal ("multilib exclusions '%s' is invalid",
7403 multilib_exclusions
);
7413 while (*p
!= ' ' && *p
!= ';')
7416 goto invalid_exclusions
;
7420 if (*this_arg
!= '!')
7428 ok
= used_arg (this_arg
, p
- this_arg
);
7443 p
= multilib_select
;
7446 /* Ignore newlines. */
7453 /* Get the initial path. */
7460 fatal ("multilib select '%s' is invalid",
7465 this_path_len
= p
- this_path
;
7467 /* Check the arguments. */
7474 goto invalid_select
;
7483 while (*p
!= ' ' && *p
!= ';')
7486 goto invalid_select
;
7490 if (*this_arg
!= '!')
7498 /* If this is a default argument, we can just ignore it.
7499 This is true even if this_arg begins with '!'. Beginning
7500 with '!' does not mean that this argument is necessarily
7501 inappropriate for this library: it merely means that
7502 there is a more specific library which uses this
7503 argument. If this argument is a default, we need not
7504 consider that more specific library. */
7505 ok
= used_arg (this_arg
, p
- this_arg
);
7512 if (default_arg (this_arg
, p
- this_arg
))
7521 if (this_path_len
!= 1
7522 || this_path
[0] != '.')
7524 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7527 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7528 new_multilib_dir
[this_path_len
] = '\0';
7529 q
= strchr (new_multilib_dir
, ':');
7532 multilib_dir
= new_multilib_dir
;
7539 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7541 while (q
< end
&& *q
!= ':')
7545 char *new_multilib_os_dir
= XNEWVEC (char, end
- q
);
7546 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7547 new_multilib_os_dir
[end
- q
- 1] = '\0';
7548 multilib_os_dir
= new_multilib_os_dir
;
7556 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7557 && strcmp (multilib_os_dir
, ".") == 0)
7559 free (CONST_CAST (char *, multilib_os_dir
));
7560 multilib_os_dir
= NULL
;
7562 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7563 multilib_os_dir
= multilib_dir
;
7566 /* Print out the multiple library subdirectory selection
7567 information. This prints out a series of lines. Each line looks
7568 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7569 required. Only the desired options are printed out, the negative
7570 matches. The options are print without a leading dash. There are
7571 no spaces to make it easy to use the information in the shell.
7572 Each subdirectory is printed only once. This assumes the ordering
7573 generated by the genmultilib script. Also, we leave out ones that match
7577 print_multilib_info (void)
7579 const char *p
= multilib_select
;
7580 const char *last_path
= 0, *this_path
;
7582 unsigned int last_path_len
= 0;
7587 /* Ignore newlines. */
7594 /* Get the initial path. */
7601 fatal ("multilib select '%s' is invalid", multilib_select
);
7607 /* When --disable-multilib was used but target defines
7608 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7609 to find multilib_os_dir, so skip them from output. */
7610 if (this_path
[0] == '.' && this_path
[1] == ':')
7613 /* Check for matches with the multilib_exclusions. We don't bother
7614 with the '!' in either list. If any of the exclusion rules match
7615 all of its options with the select rule, we skip it. */
7617 const char *e
= multilib_exclusions
;
7618 const char *this_arg
;
7623 /* Ignore newlines. */
7630 /* Check the arguments. */
7639 fatal ("multilib exclusion '%s' is invalid",
7640 multilib_exclusions
);
7651 while (*e
!= ' ' && *e
!= ';')
7654 goto invalid_exclusion
;
7662 int len
= e
- this_arg
;
7665 goto invalid_select
;
7669 while (*q
!= ' ' && *q
!= ';')
7672 goto invalid_select
;
7676 if (! strncmp (arg
, this_arg
,
7677 (len
< q
- arg
) ? q
- arg
: len
)
7678 || default_arg (this_arg
, e
- this_arg
))
7708 /* If this is a duplicate, skip it. */
7709 skip
= (last_path
!= 0
7710 && (unsigned int) (p
- this_path
) == last_path_len
7711 && ! strncmp (last_path
, this_path
, last_path_len
));
7713 last_path
= this_path
;
7714 last_path_len
= p
- this_path
;
7717 /* If this directory requires any default arguments, we can skip
7718 it. We will already have printed a directory identical to
7719 this one which does not require that default argument. */
7730 goto invalid_select
;
7737 while (*q
!= ' ' && *q
!= ';')
7740 goto invalid_select
;
7745 && default_arg (arg
, q
- arg
))
7760 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7771 goto invalid_select
;
7779 use_arg
= *p
!= '!';
7784 while (*p
!= ' ' && *p
!= ';')
7787 goto invalid_select
;
7799 /* If there are extra options, print them now. */
7800 if (multilib_extra
&& *multilib_extra
)
7802 int print_at
= TRUE
;
7805 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7826 /* getenv built-in spec function.
7828 Returns the value of the environment variable given by its first
7829 argument, concatenated with the second argument. If the
7830 environment variable is not defined, a fatal error is issued. */
7833 getenv_spec_function (int argc
, const char **argv
)
7843 value
= getenv (argv
[0]);
7845 fatal ("environment variable \"%s\" not defined", argv
[0]);
7847 /* We have to escape every character of the environment variable so
7848 they are not interpretted as active spec characters. A
7849 particulaly painful case is when we are reading a variable
7850 holding a windows path complete with \ separators. */
7851 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
7852 result
= xmalloc (len
);
7853 for (ptr
= result
; *value
; ptr
+= 2)
7859 strcpy (ptr
, argv
[1]);
7864 /* if-exists built-in spec function.
7866 Checks to see if the file specified by the absolute pathname in
7867 ARGS exists. Returns that pathname if found.
7869 The usual use for this function is to check for a library file
7870 (whose name has been expanded with %s). */
7873 if_exists_spec_function (int argc
, const char **argv
)
7875 /* Must have only one argument. */
7876 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7882 /* if-exists-else built-in spec function.
7884 This is like if-exists, but takes an additional argument which
7885 is returned if the first argument does not exist. */
7888 if_exists_else_spec_function (int argc
, const char **argv
)
7890 /* Must have exactly two arguments. */
7894 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7900 /* replace-outfile built-in spec function.
7902 This looks for the first argument in the outfiles array's name and
7903 replaces it with the second argument. */
7906 replace_outfile_spec_function (int argc
, const char **argv
)
7909 /* Must have exactly two arguments. */
7913 for (i
= 0; i
< n_infiles
; i
++)
7915 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
7916 outfiles
[i
] = xstrdup (argv
[1]);
7921 /* Given two version numbers, compares the two numbers.
7922 A version number must match the regular expression
7923 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7926 compare_version_strings (const char *v1
, const char *v2
)
7931 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7932 REG_EXTENDED
| REG_NOSUB
) != 0)
7934 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
7935 if (rresult
== REG_NOMATCH
)
7936 fatal ("invalid version number `%s'", v1
);
7937 else if (rresult
!= 0)
7939 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
7940 if (rresult
== REG_NOMATCH
)
7941 fatal ("invalid version number `%s'", v2
);
7942 else if (rresult
!= 0)
7945 return strverscmp (v1
, v2
);
7949 /* version_compare built-in spec function.
7951 This takes an argument of the following form:
7953 <comparison-op> <arg1> [<arg2>] <switch> <result>
7955 and produces "result" if the comparison evaluates to true,
7956 and nothing if it doesn't.
7958 The supported <comparison-op> values are:
7960 >= true if switch is a later (or same) version than arg1
7962 < true if switch is an earlier version than arg1
7964 >< true if switch is arg1 or later, and earlier than arg2
7965 <> true if switch is earlier than arg1 or is arg2 or later
7967 If the switch is not present, the condition is false unless
7968 the first character of the <comparison-op> is '!'.
7971 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7972 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
7975 version_compare_spec_function (int argc
, const char **argv
)
7979 const char *switch_value
= NULL
;
7984 fatal ("too few arguments to %%:version-compare");
7985 if (argv
[0][0] == '\0')
7987 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
7989 if (argc
!= nargs
+ 3)
7990 fatal ("too many arguments to %%:version-compare");
7992 switch_len
= strlen (argv
[nargs
+ 1]);
7993 for (i
= 0; i
< n_switches
; i
++)
7994 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
7995 && check_live_switch (i
, switch_len
))
7996 switch_value
= switches
[i
].part1
+ switch_len
;
7998 if (switch_value
== NULL
)
8002 comp1
= compare_version_strings (switch_value
, argv
[1]);
8004 comp2
= compare_version_strings (switch_value
, argv
[2]);
8006 comp2
= -1; /* This value unused. */
8009 switch (argv
[0][0] << 8 | argv
[0][1])
8011 case '>' << 8 | '=':
8012 result
= comp1
>= 0;
8014 case '!' << 8 | '<':
8015 result
= comp1
>= 0 || switch_value
== NULL
;
8020 case '!' << 8 | '>':
8021 result
= comp1
< 0 || switch_value
== NULL
;
8023 case '>' << 8 | '<':
8024 result
= comp1
>= 0 && comp2
< 0;
8026 case '<' << 8 | '>':
8027 result
= comp1
< 0 || comp2
>= 0;
8031 fatal ("unknown operator '%s' in %%:version-compare", argv
[0]);
8036 return argv
[nargs
+ 2];
8039 /* %:include builtin spec function. This differs from %include in that it
8040 can be nested inside a spec, and thus be conditionalized. It takes
8041 one argument, the filename, and looks for it in the startfile path.
8042 The result is always NULL, i.e. an empty expansion. */
8045 include_spec_function (int argc
, const char **argv
)
8052 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, 0);
8053 read_specs (file
? file
: argv
[0], FALSE
);
8058 /* %:print-asm-header spec function. Print a banner to say that the
8059 following output is from the assembler. */
8062 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8063 const char **argv ATTRIBUTE_UNUSED
)
8065 printf (_("Assembler options\n=================\n\n"));
8066 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8074 server_callback (int ARG_UNUSED (fd
),
8075 char * ARG_UNUSED (dir
),
8076 char ** ARG_UNUSED (cc1_argv
),
8077 char ** ARG_UNUSED (as_argv
))