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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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 this file. 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
88 #ifdef HAVE_SYS_RESOURCE_H
89 #include <sys/resource.h>
91 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
92 extern int getrusage (int, struct rusage *);
95 /* By default there is no special suffix for target executables. */
96 /* FIXME: when autoconf is fixed, remove the host check - dj */
97 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
98 #define HAVE_TARGET_EXECUTABLE_SUFFIX
101 /* By default there is no special suffix for host executables. */
102 #ifdef HOST_EXECUTABLE_SUFFIX
103 #define HAVE_HOST_EXECUTABLE_SUFFIX
105 #define HOST_EXECUTABLE_SUFFIX ""
108 /* By default, the suffix for target object files is ".o". */
109 #ifdef TARGET_OBJECT_SUFFIX
110 #define HAVE_TARGET_OBJECT_SUFFIX
112 #define TARGET_OBJECT_SUFFIX ".o"
115 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
117 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
118 #ifndef LIBRARY_PATH_ENV
119 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
123 #define kill(p,s) raise(s)
126 /* If a stage of compilation returns an exit status >= 1,
127 compilation of that file ceases. */
129 #define MIN_FATAL_STATUS 1
131 /* Flag set by cppspec.c to 1. */
134 /* Flag saying to pass the greatest exit code returned by a sub-process
135 to the calling program. */
136 static int pass_exit_codes;
138 /* Definition of string containing the arguments given to configure. */
139 #include "configargs.h"
141 /* Flag saying to print the directories gcc will search through looking for
142 programs, libraries, etc. */
144 static int print_search_dirs;
146 /* Flag saying to print the full filename of this file
147 as found through our usual search mechanism. */
149 static const char *print_file_name = NULL;
151 /* As print_file_name, but search for executable file. */
153 static const char *print_prog_name = NULL;
155 /* Flag saying to print the relative path we'd use to
156 find libgcc.a given the current compiler flags. */
158 static int print_multi_directory;
160 /* Flag saying to print the relative path we'd use to
161 find OS libraries given the current compiler flags. */
163 static int print_multi_os_directory;
165 /* Flag saying to print the list of subdirectories and
166 compiler flags used to select them in a standard form. */
168 static int print_multi_lib;
170 /* Flag saying to print the command line options understood by gcc and its
173 static int print_help_list;
175 /* Flag indicating whether we should print the command and arguments */
177 static int verbose_flag;
179 /* Flag indicating whether we should ONLY print the command and
180 arguments (like verbose_flag) without executing the command.
181 Displayed arguments are quoted so that the generated command
182 line is suitable for execution. This is intended for use in
183 shell scripts to capture the driver-generated command line. */
184 static int verbose_only_flag;
186 /* Flag indicating to print target specific command line options. */
188 static int target_help_flag;
190 /* Flag indicating whether we should report subprocess execution times
191 (if this is supported by the system - see pexecute.c). */
193 static int report_times;
195 /* Nonzero means place this string before uses of /, so that include
196 and library files can be found in an alternate location. */
198 #ifdef TARGET_SYSTEM_ROOT
199 static const char *target_system_root = TARGET_SYSTEM_ROOT;
201 static const char *target_system_root = 0;
204 /* Nonzero means pass the updated target_system_root to the compiler. */
206 static int target_system_root_changed;
208 /* Nonzero means append this string to target_system_root. */
210 static const char *target_sysroot_suffix = 0;
212 /* Nonzero means append this string to target_system_root for headers. */
214 static const char *target_sysroot_hdrs_suffix = 0;
216 /* Nonzero means write "temp" files in source directory
217 and use the source file's name in them, and don't delete them. */
219 static int save_temps_flag;
221 /* Nonzero means use pipes to communicate between subprocesses.
222 Overridden by either of the above two flags. */
224 static int use_pipes;
226 /* The compiler version. */
228 static const char *compiler_version;
230 /* The target version specified with -V */
232 static const char *const spec_version = DEFAULT_TARGET_VERSION;
234 /* The target machine specified with -b. */
236 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
238 /* Nonzero if cross-compiling.
239 When -b is used, the value comes from the `specs' file. */
242 static const char *cross_compile = "1";
244 static const char *cross_compile = "0";
247 #ifdef MODIFY_TARGET_NAME
249 /* Information on how to alter the target name based on a command-line
250 switch. The only case we support now is simply appending or deleting a
251 string to or from the end of the first part of the configuration name. */
253 static const struct modify_target
255 const char *const sw;
256 const enum add_del {ADD, DELETE} add_del;
257 const char *const str;
259 modify_target[] = MODIFY_TARGET_NAME;
262 /* The number of errors that have occurred; the link phase will not be
263 run if this is nonzero. */
264 static int error_count = 0;
266 /* Greatest exit code of sub-processes that has been encountered up to
268 static int greatest_status = 1;
270 /* This is the obstack which we use to allocate many strings. */
272 static struct obstack obstack;
274 /* This is the obstack to build an environment variable to pass to
275 collect2 that describes all of the relevant switches of what to
276 pass the compiler in building the list of pointers to constructors
279 static struct obstack collect_obstack;
281 /* These structs are used to collect resource usage information for
283 #ifdef HAVE_GETRUSAGE
284 static struct rusage rus, prus;
287 /* Forward declaration for prototypes. */
290 static void init_spec (void);
291 static void store_arg (const char *, int, int);
292 static char *load_specs (const char *);
293 static void read_specs (const char *, int);
294 static void set_spec (const char *, const char *);
295 static struct compiler *lookup_compiler (const char *, size_t, const char *);
296 static char *build_search_list (struct path_prefix *, const char *, int);
297 static void putenv_from_prefixes (struct path_prefix *, const char *);
298 static int access_check (const char *, int);
299 static char *find_a_file (struct path_prefix *, const char *, int, int);
300 static void add_prefix (struct path_prefix *, const char *, const char *,
301 int, int, int *, int);
302 static void add_sysrooted_prefix (struct path_prefix *, const char *,
303 const char *, int, int, int *, int);
304 static void translate_options (int *, const char *const **);
305 static char *skip_whitespace (char *);
306 static void delete_if_ordinary (const char *);
307 static void delete_temp_files (void);
308 static void delete_failure_queue (void);
309 static void clear_failure_queue (void);
310 static int check_live_switch (int, int);
311 static const char *handle_braces (const char *);
312 static inline bool input_suffix_matches (const char *, const char *);
313 static inline bool switch_matches (const char *, const char *, int);
314 static inline void mark_matching_switches (const char *, const char *, int);
315 static inline void process_marked_switches (void);
316 static const char *process_brace_body (const char *, const char *, const char *, int, int);
317 static const struct spec_function *lookup_spec_function (const char *);
318 static const char *eval_spec_function (const char *, const char *);
319 static const char *handle_spec_function (const char *);
320 static char *save_string (const char *, int);
321 static void set_collect_gcc_options (void);
322 static int do_spec_1 (const char *, int, const char *);
323 static int do_spec_2 (const char *);
324 static void do_option_spec (const char *, const char *);
325 static void do_self_spec (const char *);
326 static const char *find_file (const char *);
327 static int is_directory (const char *, const char *, int);
328 static const char *validate_switches (const char *);
329 static void validate_all_switches (void);
330 static inline void validate_switches_from_spec (const char *);
331 static void give_switch (int, int);
332 static int used_arg (const char *, int);
333 static int default_arg (const char *, int);
334 static void set_multilib_dir (void);
335 static void print_multilib_info (void);
336 static void perror_with_name (const char *);
337 static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN;
338 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
339 static void display_help (void);
340 static void add_preprocessor_option (const char *, int);
341 static void add_assembler_option (const char *, int);
342 static void add_linker_option (const char *, int);
343 static void process_command (int, const char **);
344 static int execute (void);
345 static void alloc_args (void);
346 static void clear_args (void);
347 static void fatal_error (int);
348 #ifdef ENABLE_SHARED_LIBGCC
349 static void init_gcc_specs (struct obstack *, const char *, const char *,
352 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
353 static const char *convert_filename (const char *, int, int);
356 static const char *if_exists_spec_function (int, const char **);
357 static const char *if_exists_else_spec_function (int, const char **);
359 /* The Specs Language
361 Specs are strings containing lines, each of which (if not blank)
362 is made up of a program name, and arguments separated by spaces.
363 The program name must be exact and start from root, since no path
364 is searched and it is unreliable to depend on the current working directory.
365 Redirection of input or output is not supported; the subprograms must
366 accept filenames saying what files to read and write.
368 In addition, the specs can contain %-sequences to substitute variable text
369 or for conditional text. Here is a table of all defined %-sequences.
370 Note that spaces are not generated automatically around the results of
371 expanding these sequences; therefore, you can concatenate them together
372 or with constant text in a single argument.
374 %% substitute one % into the program name or argument.
375 %i substitute the name of the input file being processed.
376 %b substitute the basename of the input file being processed.
377 This is the substring up to (and not including) the last period
378 and not including the directory.
379 %B same as %b, but include the file suffix (text after the last period).
381 substitute a file name that has suffix SUFFIX and is chosen
382 once per compilation, and mark the argument a la %d. To reduce
383 exposure to denial-of-service attacks, the file name is now
384 chosen in a way that is hard to predict even when previously
385 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
386 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
387 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
388 had been pre-processed. Previously, %g was simply substituted
389 with a file name chosen once per compilation, without regard
390 to any appended suffix (which was therefore treated just like
391 ordinary text), making such attacks more likely to succeed.
393 like %g, but if -pipe is in effect, expands simply to "-".
395 like %g, but if -pipe is in effect, expands to nothing. (We have both
396 %| and %m to accommodate differences between system assemblers; see
397 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
399 like %g, but generates a new temporary file name even if %uSUFFIX
402 substitutes the last file name generated with %uSUFFIX, generating a
403 new one if there is no such last file name. In the absence of any
404 %uSUFFIX, this is just like %gSUFFIX, except they don't share
405 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
406 would involve the generation of two distinct file names, one
407 for each `%g.s' and another for each `%U.s'. Previously, %U was
408 simply substituted with a file name chosen for the previous %u,
409 without regard to any appended suffix.
411 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
412 writable, and if save-temps is off; otherwise, substitute the name
413 of a temporary file, just like %u. This temporary file is not
414 meant for communication between processes, but rather as a junk
417 substitutes .SUFFIX for the suffixes of a matched switch's args when
418 it is subsequently output with %*. SUFFIX is terminated by the next
420 %d marks the argument containing or following the %d as a
421 temporary file name, so that that file will be deleted if CC exits
422 successfully. Unlike %g, this contributes no text to the argument.
423 %w marks the argument containing or following the %w as the
424 "output file" of this compilation. This puts the argument
425 into the sequence of arguments that %o will substitute later.
426 %V indicates that this compilation produces no "output file".
428 like %{...} but mark last argument supplied within
429 as a file to be deleted on failure.
430 %o substitutes the names of all the output files, with spaces
431 automatically placed around them. You should write spaces
432 around the %o as well or the results are undefined.
433 %o is for use in the specs for running the linker.
434 Input files whose names have no recognized suffix are not compiled
435 at all, but they are included among the output files, so they will
437 %O substitutes the suffix for object files. Note that this is
438 handled specially when it immediately follows %g, %u, or %U
439 (with or without a suffix argument) because of the need for
440 those to form complete file names. The handling is such that
441 %O is treated exactly as if it had already been substituted,
442 except that %g, %u, and %U do not currently support additional
443 SUFFIX characters following %O as they would following, for
445 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
446 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
447 and -B options) as necessary.
448 %s current argument is the name of a library or startup file of some sort.
449 Search for that file in a standard list of directories
450 and substitute the full name found.
451 %eSTR Print STR as an error message. STR is terminated by a newline.
452 Use this when inconsistent options are detected.
453 %nSTR Print STR as a notice. STR is terminated by a newline.
454 %x{OPTION} Accumulate an option for %X.
455 %X Output the accumulated linker options specified by compilations.
456 %Y Output the accumulated assembler options specified by compilations.
457 %Z Output the accumulated preprocessor options specified by compilations.
458 %a process ASM_SPEC as a spec.
459 This allows config.h to specify part of the spec for running as.
460 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
461 used here. This can be used to run a post-processor after the
462 assembler has done its job.
463 %D Dump out a -L option for each directory in startfile_prefixes.
464 If multilib_dir is set, extra entries are generated with it affixed.
465 %l process LINK_SPEC as a spec.
466 %L process LIB_SPEC as a spec.
467 %G process LIBGCC_SPEC as a spec.
468 %M output multilib_dir with directory separators replaced with "_";
469 if multilib_dir is not set or is ".", output "".
470 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
471 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
472 %C process CPP_SPEC as a spec.
473 %1 process CC1_SPEC as a spec.
474 %2 process CC1PLUS_SPEC as a spec.
475 %* substitute the variable part of a matched option. (See below.)
476 Note that each comma in the substituted string is replaced by
478 %<S remove all occurrences of -S from the command line.
479 Note - this command is position dependent. % commands in the
480 spec string before this one will see -S, % commands in the
481 spec string after this one will not.
482 %<S* remove all occurrences of all switches beginning with -S from the
485 Call the named function FUNCTION, passing it ARGS. ARGS is
486 first processed as a nested spec string, then split into an
487 argument vector in the usual fashion. The function returns
488 a string which is processed as if it had appeared literally
489 as part of the current spec.
490 %{S} substitutes the -S switch, if that switch was given to CC.
491 If that switch was not specified, this substitutes nothing.
492 Here S is a metasyntactic variable.
493 %{S*} substitutes all the switches specified to CC whose names start
494 with -S. This is used for -o, -I, etc; switches that take
495 arguments. CC considers `-o foo' as being one switch whose
496 name starts with `o'. %{o*} would substitute this text,
497 including the space; thus, two arguments would be generated.
498 %{S*&T*} likewise, but preserve order of S and T options (the order
499 of S and T in the spec is not significant). Can be any number
500 of ampersand-separated variables; for each the wild card is
501 optional. Useful for CPP as %{D*&U*&A*}.
503 %{S:X} substitutes X, if the -S switch was given to CC.
504 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
505 %{S*:X} substitutes X if one or more switches whose names start
506 with -S was given to CC. Normally X is substituted only
507 once, no matter how many such switches appeared. However,
508 if %* appears somewhere in X, then X will be substituted
509 once for each matching switch, with the %* replaced by the
510 part of that switch that matched the '*'.
511 %{.S:X} substitutes X, if processing a file with suffix S.
512 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
514 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
515 combined with !, ., and * as above binding stronger than the OR.
516 If %* appears in X, all of the alternatives must be starred, and
517 only the first matching alternative is substituted.
518 %{S:X; if S was given to CC, substitutes X;
519 T:Y; else if T was given to CC, substitutes Y;
520 :D} else substitutes D. There can be as many clauses as you need.
521 This may be combined with ., !, |, and * as above.
523 %(Spec) processes a specification defined in a specs file as *Spec:
524 %[Spec] as above, but put __ around -D arguments
526 The conditional text X in a %{S:X} or similar construct may contain
527 other nested % constructs or spaces, or even newlines. They are
528 processed as usual, as described above. Trailing white space in X is
529 ignored. White space may also appear anywhere on the left side of the
530 colon in these constructs, except between . or * and the corresponding
533 The -O, -f, -m, and -W switches are handled specifically in these
534 constructs. If another value of -O or the negated form of a -f, -m, or
535 -W switch is found later in the command line, the earlier switch
536 value is ignored, except with {S*} where S is just one letter; this
537 passes all matching options.
539 The character | at the beginning of the predicate text is used to indicate
540 that a command should be piped to the following command, but only if -pipe
543 Note that it is built into CC which switches take arguments and which
544 do not. You might think it would be useful to generalize this to
545 allow each compiler's spec to say which switches take arguments. But
546 this cannot be done in a consistent fashion. CC cannot even decide
547 which input files have been specified without knowing which switches
548 take arguments, and it must know which input files to compile in order
549 to tell which compilers to run.
551 CC also knows implicitly that arguments starting in `-l' are to be
552 treated as compiler output files, and passed to the linker in their
553 proper position among the other output files. */
555 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
557 /* config.h can define ASM_SPEC to provide extra args to the assembler
558 or extra switch-translations. */
563 /* config.h can define ASM_FINAL_SPEC to run a post processor after
564 the assembler has run. */
565 #ifndef ASM_FINAL_SPEC
566 #define ASM_FINAL_SPEC ""
569 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
570 or extra switch-translations. */
575 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
576 or extra switch-translations. */
581 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
582 or extra switch-translations. */
584 #define CC1PLUS_SPEC ""
587 /* config.h can define LINK_SPEC to provide extra args to the linker
588 or extra switch-translations. */
593 /* config.h can define LIB_SPEC to override the default libraries. */
595 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
598 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
601 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
602 /* Have gcc do the search for libgcc.a. */
603 #define LIBGCC_SPEC "libgcc.a%s"
605 #define LIBGCC_SPEC "-lgcc"
609 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
610 #ifndef STARTFILE_SPEC
611 #define STARTFILE_SPEC \
612 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
615 /* config.h can define SWITCHES_NEED_SPACES to control which options
616 require spaces between the option and the argument. */
617 #ifndef SWITCHES_NEED_SPACES
618 #define SWITCHES_NEED_SPACES ""
621 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
623 #define ENDFILE_SPEC ""
627 #define LINKER_NAME "collect2"
630 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
632 #ifndef ASM_DEBUG_SPEC
633 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
634 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
635 # define ASM_DEBUG_SPEC \
636 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
637 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
638 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
640 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
641 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
643 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
644 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
648 #ifndef ASM_DEBUG_SPEC
649 # define ASM_DEBUG_SPEC ""
652 /* Here is the spec for running the linker, after compiling all files. */
654 /* This is overridable by the target in case they need to specify the
655 -lgcc and -lc order specially, yet not require them to override all
656 of LINK_COMMAND_SPEC. */
657 #ifndef LINK_GCC_C_SEQUENCE_SPEC
658 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
661 #ifndef LINK_PIE_SPEC
663 #define LINK_PIE_SPEC "%{pie:-pie} "
665 #define LINK_PIE_SPEC "%{pie:} "
669 /* -u* was put back because both BSD and SysV seem to support it. */
670 /* %{static:} simply prevents an error message if the target machine
671 doesn't handle -static. */
672 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
673 scripts which exist in user specified directories, or in standard
675 #ifndef LINK_COMMAND_SPEC
676 #define LINK_COMMAND_SPEC "\
677 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
678 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
679 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
680 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs|fprofile-generate:-lgcov}\
681 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
682 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
685 #ifndef LINK_LIBGCC_SPEC
686 # ifdef LINK_LIBGCC_SPECIAL
687 /* Don't generate -L options for startfile prefix list. */
688 # define LINK_LIBGCC_SPEC ""
690 /* Do generate them. */
691 # define LINK_LIBGCC_SPEC "%D"
695 #ifndef STARTFILE_PREFIX_SPEC
696 # define STARTFILE_PREFIX_SPEC ""
699 #ifndef SYSROOT_SUFFIX_SPEC
700 # define SYSROOT_SUFFIX_SPEC ""
703 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
704 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
707 static const char *asm_debug;
708 static const char *cpp_spec = CPP_SPEC;
709 static const char *cc1_spec = CC1_SPEC;
710 static const char *cc1plus_spec = CC1PLUS_SPEC;
711 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
712 static const char *asm_spec = ASM_SPEC;
713 static const char *asm_final_spec = ASM_FINAL_SPEC;
714 static const char *link_spec = LINK_SPEC;
715 static const char *lib_spec = LIB_SPEC;
716 static const char *libgcc_spec = LIBGCC_SPEC;
717 static const char *endfile_spec = ENDFILE_SPEC;
718 static const char *startfile_spec = STARTFILE_SPEC;
719 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
720 static const char *linker_name_spec = LINKER_NAME;
721 static const char *link_command_spec = LINK_COMMAND_SPEC;
722 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
723 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
724 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
725 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
727 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
728 There should be no need to override these in target dependent files,
729 but we need to copy them to the specs file so that newer versions
730 of the GCC driver can correctly drive older tool chains with the
731 appropriate -B options. */
733 /* When cpplib handles traditional preprocessing, get rid of this, and
734 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
735 that we default the front end language better. */
736 static const char *trad_capable_cpp =
737 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
739 /* We don't wrap .d files in %W{} since a missing .d file, and
740 therefore no dependency entry, confuses make into thinking a .o
741 file that happens to exist is up-to-date. */
742 static const char *cpp_unique_options =
743 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
744 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
745 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
746 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
747 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
748 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
749 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
752 /* This contains cpp options which are common with cc1_options and are passed
753 only when preprocessing only to avoid duplication. We pass the cc1 spec
754 options to the preprocessor so that it the cc1 spec may manipulate
755 options used to set target flags. Those special target flags settings may
756 in turn cause preprocessor symbols to be defined specially. */
757 static const char *cpp_options =
758 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
759 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
762 /* This contains cpp options which are not passed when the preprocessor
763 output will be used by another program. */
764 static const char *cpp_debug_options = "%{d*}";
766 /* NB: This is shared amongst all front-ends. */
767 static const char *cc1_options =
768 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
769 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
770 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
771 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
772 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
773 %{Qn:-fno-ident} %{--help:--help}\
774 %{--target-help:--target-help}\
775 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
776 %{fsyntax-only:-o %j} %{-param*}";
778 static const char *asm_options =
779 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
781 static const char *invoke_as =
782 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
783 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
785 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
788 /* Some compilers have limits on line lengths, and the multilib_select
789 and/or multilib_matches strings can be very long, so we build them at
791 static struct obstack multilib_obstack;
792 static const char *multilib_select;
793 static const char *multilib_matches;
794 static const char *multilib_defaults;
795 static const char *multilib_exclusions;
797 /* Check whether a particular argument is a default argument. */
799 #ifndef MULTILIB_DEFAULTS
800 #define MULTILIB_DEFAULTS { "" }
803 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
805 #ifndef DRIVER_SELF_SPECS
806 #define DRIVER_SELF_SPECS ""
809 static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
811 #ifndef OPTION_DEFAULT_SPECS
812 #define OPTION_DEFAULT_SPECS { "", "" }
821 static const struct default_spec
822 option_default_specs[] = { OPTION_DEFAULT_SPECS };
826 struct user_specs *next;
827 const char *filename;
830 static struct user_specs *user_specs_head, *user_specs_tail;
832 #ifndef SWITCH_TAKES_ARG
833 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
836 #ifndef WORD_SWITCH_TAKES_ARG
837 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
840 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
841 /* This defines which switches stop a full compilation. */
842 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
843 ((CHAR) == 'c' || (CHAR) == 'S')
845 #ifndef SWITCH_CURTAILS_COMPILATION
846 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
847 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
851 /* Record the mapping from file suffixes for compilation specs. */
855 const char *suffix; /* Use this compiler for input files
856 whose names end in this suffix. */
858 const char *spec; /* To use this compiler, run this spec. */
860 const char *cpp_spec; /* If non-NULL, substitute this spec
861 for `%C', rather than the usual
865 /* Pointer to a vector of `struct compiler' that gives the spec for
866 compiling a file, based on its suffix.
867 A file that does not end in any of these suffixes will be passed
868 unchanged to the loader and nothing else will be done to it.
870 An entry containing two 0s is used to terminate the vector.
872 If multiple entries match a file, the last matching one is used. */
874 static struct compiler *compilers;
876 /* Number of entries in `compilers', not counting the null terminator. */
878 static int n_compilers;
880 /* The default list of file name suffixes and their compilation specs. */
882 static const struct compiler default_compilers[] =
884 /* Add lists of suffixes of known languages here. If those languages
885 were not present when we built the driver, we will hit these copies
886 and be given a more meaningful error than "file not used since
887 linking is not done". */
888 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
889 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
890 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
891 {".CPP", "#C++", 0}, {".ii", "#C++", 0},
892 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
893 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
894 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
895 {".r", "#Ratfor", 0},
896 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
897 {".java", "#Java", 0}, {".class", "#Java", 0},
898 {".zip", "#Java", 0}, {".jar", "#Java", 0},
899 /* Next come the entries for C. */
902 /* cc1 has an integrated ISO C preprocessor. We should invoke the
903 external preprocessor if -save-temps is given. */
904 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
906 %{traditional|ftraditional:\
907 %eGNU C no longer supports -traditional without -E}\
908 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
909 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
910 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
912 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
913 cc1 %(cpp_unique_options) %(cc1_options)}}}\
914 %{!fsyntax-only:%(invoke_as)}}}}", 0},
916 "%{!E:%e-E or -x required when input is from standard input}\
917 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0},
918 {".h", "@c-header", 0},
920 /* cc1 has an integrated ISO C preprocessor. We should invoke the
921 external preprocessor if -save-temps is given. */
922 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
924 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
925 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
926 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
928 -o %g.s %{!o*:--output-pch=%i.gch}\
929 %W{o*:--output-pch=%*}%V}\
930 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
931 cc1 %(cpp_unique_options) %(cc1_options)\
932 -o %g.s %{!o*:--output-pch=%i.gch}\
933 %W{o*:--output-pch=%*}%V}}}}}}", 0},
934 {".i", "@cpp-output", 0},
936 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
937 {".s", "@assembler", 0},
939 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
940 {".S", "@assembler-with-cpp", 0},
941 {"@assembler-with-cpp",
942 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
943 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
944 %{E|M|MM:%(cpp_debug_options)}\
945 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
946 as %(asm_debug) %(asm_options) %|.s %A }}}}"
948 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
949 %{E|M|MM:%(cpp_debug_options)}\
950 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
951 as %(asm_debug) %(asm_options) %m.s %A }}}}"
956 /* Mark end of table. */
960 /* Number of elements in default_compilers, not counting the terminator. */
962 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
964 /* A vector of options to give to the linker.
965 These options are accumulated by %x,
966 and substituted into the linker command with %X. */
967 static int n_linker_options;
968 static char **linker_options;
970 /* A vector of options to give to the assembler.
971 These options are accumulated by -Wa,
972 and substituted into the assembler command with %Y. */
973 static int n_assembler_options;
974 static char **assembler_options;
976 /* A vector of options to give to the preprocessor.
977 These options are accumulated by -Wp,
978 and substituted into the preprocessor command with %Z. */
979 static int n_preprocessor_options;
980 static char **preprocessor_options;
982 /* Define how to map long options into short ones. */
984 /* This structure describes one mapping. */
987 /* The long option's name. */
988 const char *const name;
989 /* The equivalent short option. */
990 const char *const equivalent;
991 /* Argument info. A string of flag chars; NULL equals no options.
992 a => argument required.
993 o => argument optional.
994 j => join argument to equivalent, making one word.
995 * => require other text after NAME as an argument. */
996 const char *const arg_info;
999 /* This is the table of mappings. Mappings are tried sequentially
1000 for each option encountered; the first one that matches, wins. */
1002 static const struct option_map option_map[] =
1004 {"--all-warnings", "-Wall", 0},
1005 {"--ansi", "-ansi", 0},
1006 {"--assemble", "-S", 0},
1007 {"--assert", "-A", "a"},
1008 {"--classpath", "-fclasspath=", "aj"},
1009 {"--bootclasspath", "-fbootclasspath=", "aj"},
1010 {"--CLASSPATH", "-fclasspath=", "aj"},
1011 {"--comments", "-C", 0},
1012 {"--comments-in-macros", "-CC", 0},
1013 {"--compile", "-c", 0},
1014 {"--debug", "-g", "oj"},
1015 {"--define-macro", "-D", "aj"},
1016 {"--dependencies", "-M", 0},
1017 {"--dump", "-d", "a"},
1018 {"--dumpbase", "-dumpbase", "a"},
1019 {"--entry", "-e", 0},
1020 {"--extra-warnings", "-W", 0},
1021 {"--for-assembler", "-Wa", "a"},
1022 {"--for-linker", "-Xlinker", "a"},
1023 {"--force-link", "-u", "a"},
1024 {"--imacros", "-imacros", "a"},
1025 {"--include", "-include", "a"},
1026 {"--include-barrier", "-I-", 0},
1027 {"--include-directory", "-I", "aj"},
1028 {"--include-directory-after", "-idirafter", "a"},
1029 {"--include-prefix", "-iprefix", "a"},
1030 {"--include-with-prefix", "-iwithprefix", "a"},
1031 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1032 {"--include-with-prefix-after", "-iwithprefix", "a"},
1033 {"--language", "-x", "a"},
1034 {"--library-directory", "-L", "a"},
1035 {"--machine", "-m", "aj"},
1036 {"--machine-", "-m", "*j"},
1037 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1038 {"--no-line-commands", "-P", 0},
1039 {"--no-precompiled-includes", "-noprecomp", 0},
1040 {"--no-standard-includes", "-nostdinc", 0},
1041 {"--no-standard-libraries", "-nostdlib", 0},
1042 {"--no-warnings", "-w", 0},
1043 {"--optimize", "-O", "oj"},
1044 {"--output", "-o", "a"},
1045 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1046 {"--param", "--param", "a"},
1047 {"--pedantic", "-pedantic", 0},
1048 {"--pedantic-errors", "-pedantic-errors", 0},
1049 {"--pie", "-pie", 0},
1050 {"--pipe", "-pipe", 0},
1051 {"--prefix", "-B", "a"},
1052 {"--preprocess", "-E", 0},
1053 {"--print-search-dirs", "-print-search-dirs", 0},
1054 {"--print-file-name", "-print-file-name=", "aj"},
1055 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1056 {"--print-missing-file-dependencies", "-MG", 0},
1057 {"--print-multi-lib", "-print-multi-lib", 0},
1058 {"--print-multi-directory", "-print-multi-directory", 0},
1059 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1060 {"--print-prog-name", "-print-prog-name=", "aj"},
1061 {"--profile", "-p", 0},
1062 {"--profile-blocks", "-a", 0},
1063 {"--quiet", "-q", 0},
1064 {"--resource", "-fcompile-resource=", "aj"},
1065 {"--save-temps", "-save-temps", 0},
1066 {"--shared", "-shared", 0},
1067 {"--silent", "-q", 0},
1068 {"--specs", "-specs=", "aj"},
1069 {"--static", "-static", 0},
1070 {"--std", "-std=", "aj"},
1071 {"--symbolic", "-symbolic", 0},
1072 {"--time", "-time", 0},
1073 {"--trace-includes", "-H", 0},
1074 {"--traditional", "-traditional", 0},
1075 {"--traditional-cpp", "-traditional-cpp", 0},
1076 {"--trigraphs", "-trigraphs", 0},
1077 {"--undefine-macro", "-U", "aj"},
1078 {"--user-dependencies", "-MM", 0},
1079 {"--verbose", "-v", 0},
1080 {"--warn-", "-W", "*j"},
1081 {"--write-dependencies", "-MD", 0},
1082 {"--write-user-dependencies", "-MMD", 0},
1087 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1088 static const struct {
1089 const char *const option_found;
1090 const char *const replacements;
1091 } target_option_translations[] =
1093 TARGET_OPTION_TRANSLATE_TABLE,
1098 /* Translate the options described by *ARGCP and *ARGVP.
1099 Make a new vector and store it back in *ARGVP,
1100 and store its length in *ARGVC. */
1103 translate_options (int *argcp, const char *const **argvp)
1107 const char *const *argv = *argvp;
1108 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1109 const char **newv = xmalloc (newvsize);
1113 newv[newindex++] = argv[i++];
1117 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1121 target_option_translations[tott_idx].option_found;
1124 if (strcmp (target_option_translations[tott_idx].option_found,
1131 for (sp = target_option_translations[tott_idx].replacements;
1138 newvsize += spaces * sizeof (const char *);
1139 newv = xrealloc (newv, newvsize);
1141 sp = target_option_translations[tott_idx].replacements;
1150 newv[newindex++] = np;
1151 while (*np != ' ' && *np)
1162 if (target_option_translations[tott_idx].option_found)
1166 /* Translate -- options. */
1167 if (argv[i][0] == '-' && argv[i][1] == '-')
1170 /* Find a mapping that applies to this option. */
1171 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1173 size_t optlen = strlen (option_map[j].name);
1174 size_t arglen = strlen (argv[i]);
1175 size_t complen = arglen > optlen ? optlen : arglen;
1176 const char *arginfo = option_map[j].arg_info;
1181 if (!strncmp (argv[i], option_map[j].name, complen))
1183 const char *arg = 0;
1185 if (arglen < optlen)
1188 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1189 if (strlen (option_map[k].name) >= arglen
1190 && !strncmp (argv[i], option_map[k].name, arglen))
1192 error ("ambiguous abbreviation %s", argv[i]);
1196 if (k != ARRAY_SIZE (option_map))
1200 if (arglen > optlen)
1202 /* If the option has an argument, accept that. */
1203 if (argv[i][optlen] == '=')
1204 arg = argv[i] + optlen + 1;
1206 /* If this mapping requires extra text at end of name,
1207 accept that as "argument". */
1208 else if (strchr (arginfo, '*') != 0)
1209 arg = argv[i] + optlen;
1211 /* Otherwise, extra text at end means mismatch.
1212 Try other mappings. */
1217 else if (strchr (arginfo, '*') != 0)
1219 error ("incomplete `%s' option", option_map[j].name);
1223 /* Handle arguments. */
1224 if (strchr (arginfo, 'a') != 0)
1230 error ("missing argument to `%s' option",
1231 option_map[j].name);
1238 else if (strchr (arginfo, '*') != 0)
1240 else if (strchr (arginfo, 'o') == 0)
1243 error ("extraneous argument to `%s' option",
1244 option_map[j].name);
1248 /* Store the translation as one argv elt or as two. */
1249 if (arg != 0 && strchr (arginfo, 'j') != 0)
1250 newv[newindex++] = concat (option_map[j].equivalent, arg,
1254 newv[newindex++] = option_map[j].equivalent;
1255 newv[newindex++] = arg;
1258 newv[newindex++] = option_map[j].equivalent;
1266 /* Handle old-fashioned options--just copy them through,
1267 with their arguments. */
1268 else if (argv[i][0] == '-')
1270 const char *p = argv[i] + 1;
1274 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1275 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1276 else if (WORD_SWITCH_TAKES_ARG (p))
1277 nskip += WORD_SWITCH_TAKES_ARG (p);
1278 else if ((c == 'B' || c == 'b' || c == 'x')
1281 else if (! strcmp (p, "Xlinker"))
1283 else if (! strcmp (p, "Xpreprocessor"))
1285 else if (! strcmp (p, "Xassembler"))
1288 /* Watch out for an option at the end of the command line that
1289 is missing arguments, and avoid skipping past the end of the
1291 if (nskip + i > argc)
1296 newv[newindex++] = argv[i++];
1301 /* Ordinary operands, or +e options. */
1302 newv[newindex++] = argv[i++];
1312 skip_whitespace (char *p)
1316 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1317 be considered whitespace. */
1318 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1320 else if (*p == '\n' || *p == ' ' || *p == '\t')
1334 /* Structures to keep track of prefixes to try when looking for files. */
1338 const char *prefix; /* String to prepend to the path. */
1339 struct prefix_list *next; /* Next in linked list. */
1340 int require_machine_suffix; /* Don't use without machine_suffix. */
1341 /* 2 means try both machine_suffix and just_machine_suffix. */
1342 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1343 int priority; /* Sort key - priority within list. */
1344 int os_multilib; /* 1 if OS multilib scheme should be used,
1345 0 for GCC multilib scheme. */
1350 struct prefix_list *plist; /* List of prefixes to try */
1351 int max_len; /* Max length of a prefix in PLIST */
1352 const char *name; /* Name of this list (used in config stuff) */
1355 /* List of prefixes to try when looking for executables. */
1357 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1359 /* List of prefixes to try when looking for startup (crt0) files. */
1361 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1363 /* List of prefixes to try when looking for include files. */
1365 static struct path_prefix include_prefixes = { 0, 0, "include" };
1367 /* Suffix to attach to directories searched for commands.
1368 This looks like `MACHINE/VERSION/'. */
1370 static const char *machine_suffix = 0;
1372 /* Suffix to attach to directories searched for commands.
1373 This is just `MACHINE/'. */
1375 static const char *just_machine_suffix = 0;
1377 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1379 static const char *gcc_exec_prefix;
1381 /* Adjusted value of standard_libexec_prefix. */
1383 static const char *gcc_libexec_prefix;
1385 /* Default prefixes to attach to command names. */
1387 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1388 #undef MD_EXEC_PREFIX
1389 #undef MD_STARTFILE_PREFIX
1390 #undef MD_STARTFILE_PREFIX_1
1393 /* If no prefixes defined, use the null string, which will disable them. */
1394 #ifndef MD_EXEC_PREFIX
1395 #define MD_EXEC_PREFIX ""
1397 #ifndef MD_STARTFILE_PREFIX
1398 #define MD_STARTFILE_PREFIX ""
1400 #ifndef MD_STARTFILE_PREFIX_1
1401 #define MD_STARTFILE_PREFIX_1 ""
1404 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1405 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1406 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
1407 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1409 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1410 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1411 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1412 static const char *const standard_startfile_prefix_1 = "/lib/";
1413 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1415 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1416 static const char *tooldir_prefix;
1418 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1420 static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1422 /* Subdirectory to use for locating libraries. Set by
1423 set_multilib_dir based on the compilation options. */
1425 static const char *multilib_dir;
1427 /* Subdirectory to use for locating libraries in OS conventions. Set by
1428 set_multilib_dir based on the compilation options. */
1430 static const char *multilib_os_dir;
1432 /* Structure to keep track of the specs that have been defined so far.
1433 These are accessed using %(specname) or %[specname] in a compiler
1438 /* The following 2 fields must be first */
1439 /* to allow EXTRA_SPECS to be initialized */
1440 const char *name; /* name of the spec. */
1441 const char *ptr; /* available ptr if no static pointer */
1443 /* The following fields are not initialized */
1444 /* by EXTRA_SPECS */
1445 const char **ptr_spec; /* pointer to the spec itself. */
1446 struct spec_list *next; /* Next spec in linked list. */
1447 int name_len; /* length of the name */
1448 int alloc_p; /* whether string was allocated */
1451 #define INIT_STATIC_SPEC(NAME,PTR) \
1452 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1454 /* List of statically defined specs. */
1455 static struct spec_list static_specs[] =
1457 INIT_STATIC_SPEC ("asm", &asm_spec),
1458 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1459 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1460 INIT_STATIC_SPEC ("asm_options", &asm_options),
1461 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1462 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1463 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1464 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1465 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1466 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1467 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1468 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1469 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1470 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1471 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1472 INIT_STATIC_SPEC ("link", &link_spec),
1473 INIT_STATIC_SPEC ("lib", &lib_spec),
1474 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1475 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1476 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1477 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1478 INIT_STATIC_SPEC ("version", &compiler_version),
1479 INIT_STATIC_SPEC ("multilib", &multilib_select),
1480 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1481 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1482 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1483 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1484 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1485 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1486 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1487 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1488 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1489 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1490 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1491 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1492 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1495 #ifdef EXTRA_SPECS /* additional specs needed */
1496 /* Structure to keep track of just the first two args of a spec_list.
1497 That is all that the EXTRA_SPECS macro gives us. */
1500 const char *const name;
1501 const char *const ptr;
1504 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1505 static struct spec_list *extra_specs = (struct spec_list *) 0;
1508 /* List of dynamically allocates specs that have been defined so far. */
1510 static struct spec_list *specs = (struct spec_list *) 0;
1512 /* List of static spec functions. */
1514 static const struct spec_function static_spec_functions[] =
1516 { "if-exists", if_exists_spec_function },
1517 { "if-exists-else", if_exists_else_spec_function },
1521 static int processing_spec_function;
1523 /* Add appropriate libgcc specs to OBSTACK, taking into account
1524 various permutations of -shared-libgcc, -shared, and such. */
1526 #ifdef ENABLE_SHARED_LIBGCC
1528 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1529 const char *static_name, const char *eh_name)
1533 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1534 "}%{!static:%{!static-libgcc:",
1535 #ifdef HAVE_LD_AS_NEEDED
1536 "%{!shared-libgcc:", static_name,
1537 " --as-needed ", shared_name, " --no-as-needed}"
1538 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
1541 "%{!shared:%{!shared-libgcc:", static_name, " ",
1542 eh_name, "}%{shared-libgcc:", shared_name, " ",
1543 static_name, "}}%{shared:",
1545 "%{shared-libgcc:", shared_name,
1546 "}%{!shared-libgcc:", static_name, "}",
1553 obstack_grow (obstack, buf, strlen (buf));
1556 #endif /* ENABLE_SHARED_LIBGCC */
1558 /* Initialize the specs lookup routines. */
1563 struct spec_list *next = (struct spec_list *) 0;
1564 struct spec_list *sl = (struct spec_list *) 0;
1568 return; /* Already initialized. */
1571 notice ("Using built-in specs.\n");
1574 extra_specs = xcalloc (sizeof (struct spec_list),
1575 ARRAY_SIZE (extra_specs_1));
1577 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1579 sl = &extra_specs[i];
1580 sl->name = extra_specs_1[i].name;
1581 sl->ptr = extra_specs_1[i].ptr;
1583 sl->name_len = strlen (sl->name);
1584 sl->ptr_spec = &sl->ptr;
1589 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1590 on ?: in file-scope variable initializations. */
1591 asm_debug = ASM_DEBUG_SPEC;
1593 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1595 sl = &static_specs[i];
1600 #ifdef ENABLE_SHARED_LIBGCC
1601 /* ??? If neither -shared-libgcc nor --static-libgcc was
1602 seen, then we should be making an educated guess. Some proposed
1603 heuristics for ELF include:
1605 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1606 program will be doing dynamic loading, which will likely
1607 need the shared libgcc.
1609 (2) If "-ldl", then it's also a fair bet that we're doing
1612 (3) For each ET_DYN we're linking against (either through -lfoo
1613 or /some/path/foo.so), check to see whether it or one of
1614 its dependencies depends on a shared libgcc.
1618 If the runtime is fixed to look for program headers instead
1619 of calling __register_frame_info at all, for each object,
1620 use the shared libgcc if any EH symbol referenced.
1622 If crtstuff is fixed to not invoke __register_frame_info
1623 automatically, for each object, use the shared libgcc if
1624 any non-empty unwind section found.
1626 Doing any of this probably requires invoking an external program to
1627 do the actual object file scanning. */
1629 const char *p = libgcc_spec;
1632 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1633 when given the proper command line arguments. */
1636 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1638 init_gcc_specs (&obstack,
1639 #ifdef NO_SHARED_LIBGCC_MULTILIB
1644 #ifdef USE_LIBUNWIND_EXCEPTIONS
1650 #ifdef USE_LIBUNWIND_EXCEPTIONS
1651 # ifdef HAVE_LD_STATIC_DYNAMIC
1652 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1662 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1664 /* Ug. We don't know shared library extensions. Hope that
1665 systems that use this form don't do shared libraries. */
1666 init_gcc_specs (&obstack,
1667 #ifdef NO_SHARED_LIBGCC_MULTILIB
1675 #ifdef USE_LIBUNWIND_EXCEPTIONS
1684 obstack_1grow (&obstack, *p);
1685 in_sep = (*p == ' ');
1690 obstack_1grow (&obstack, '\0');
1691 libgcc_spec = obstack_finish (&obstack);
1694 #ifdef USE_AS_TRADITIONAL_FORMAT
1695 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1697 static const char tf[] = "--traditional-format ";
1698 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1699 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1700 asm_spec = obstack_finish (&obstack);
1704 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1705 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1706 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1707 link_spec = obstack_finish (&obstack);
1713 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1714 removed; If the spec starts with a + then SPEC is added to the end of the
1718 set_spec (const char *name, const char *spec)
1720 struct spec_list *sl;
1721 const char *old_spec;
1722 int name_len = strlen (name);
1725 /* If this is the first call, initialize the statically allocated specs. */
1728 struct spec_list *next = (struct spec_list *) 0;
1729 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1731 sl = &static_specs[i];
1738 /* See if the spec already exists. */
1739 for (sl = specs; sl; sl = sl->next)
1740 if (name_len == sl->name_len && !strcmp (sl->name, name))
1745 /* Not found - make it. */
1746 sl = xmalloc (sizeof (struct spec_list));
1747 sl->name = xstrdup (name);
1748 sl->name_len = name_len;
1749 sl->ptr_spec = &sl->ptr;
1751 *(sl->ptr_spec) = "";
1756 old_spec = *(sl->ptr_spec);
1757 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1758 ? concat (old_spec, spec + 1, NULL)
1763 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1766 /* Free the old spec. */
1767 if (old_spec && sl->alloc_p)
1768 free ((void *) old_spec);
1773 /* Accumulate a command (program name and args), and run it. */
1775 /* Vector of pointers to arguments in the current line of specifications. */
1777 static const char **argbuf;
1779 /* Number of elements allocated in argbuf. */
1781 static int argbuf_length;
1783 /* Number of elements in argbuf currently in use (containing args). */
1785 static int argbuf_index;
1787 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1788 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1791 static struct temp_name {
1792 const char *suffix; /* suffix associated with the code. */
1793 int length; /* strlen (suffix). */
1794 int unique; /* Indicates whether %g or %u/%U was used. */
1795 const char *filename; /* associated filename. */
1796 int filename_length; /* strlen (filename). */
1797 struct temp_name *next;
1800 /* Number of commands executed so far. */
1802 static int execution_count;
1804 /* Number of commands that exited with a signal. */
1806 static int signal_count;
1808 /* Name with which this program was invoked. */
1810 static const char *programname;
1812 /* Allocate the argument vector. */
1818 argbuf = xmalloc (argbuf_length * sizeof (const char *));
1821 /* Clear out the vector of arguments (after a command is executed). */
1829 /* Add one argument to the vector at the end.
1830 This is done when a space is seen or at the end of the line.
1831 If DELETE_ALWAYS is nonzero, the arg is a filename
1832 and the file should be deleted eventually.
1833 If DELETE_FAILURE is nonzero, the arg is a filename
1834 and the file should be deleted if this compilation fails. */
1837 store_arg (const char *arg, int delete_always, int delete_failure)
1839 if (argbuf_index + 1 == argbuf_length)
1840 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1842 argbuf[argbuf_index++] = arg;
1843 argbuf[argbuf_index] = 0;
1845 if (delete_always || delete_failure)
1846 record_temp_file (arg, delete_always, delete_failure);
1849 /* Load specs from a file name named FILENAME, replacing occurrences of
1850 various different types of line-endings, \r\n, \n\r and just \r, with
1854 load_specs (const char *filename)
1858 struct stat statbuf;
1865 notice ("Reading specs from %s\n", filename);
1867 /* Open and stat the file. */
1868 desc = open (filename, O_RDONLY, 0);
1870 pfatal_with_name (filename);
1871 if (stat (filename, &statbuf) < 0)
1872 pfatal_with_name (filename);
1874 /* Read contents of file into BUFFER. */
1875 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1876 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1878 pfatal_with_name (filename);
1879 buffer[readlen] = 0;
1882 specs = xmalloc (readlen + 1);
1884 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1890 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1892 else if (*(buffer_p + 1) == '\n') /* \r\n */
1906 /* Read compilation specs from a file named FILENAME,
1907 replacing the default ones.
1909 A suffix which starts with `*' is a definition for
1910 one of the machine-specific sub-specs. The "suffix" should be
1911 *asm, *cc1, *cpp, *link, *startfile, etc.
1912 The corresponding spec is stored in asm_spec, etc.,
1913 rather than in the `compilers' vector.
1915 Anything invalid in the file is a fatal error. */
1918 read_specs (const char *filename, int main_p)
1923 buffer = load_specs (filename);
1925 /* Scan BUFFER for specs, putting them in the vector. */
1931 char *in, *out, *p1, *p2, *p3;
1933 /* Advance P in BUFFER to the next nonblank nocomment line. */
1934 p = skip_whitespace (p);
1938 /* Is this a special command that starts with '%'? */
1939 /* Don't allow this for the main specs file, since it would
1940 encourage people to overwrite it. */
1941 if (*p == '%' && !main_p)
1944 while (*p && *p != '\n')
1950 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1951 && (p1[sizeof "%include" - 1] == ' '
1952 || p1[sizeof "%include" - 1] == '\t'))
1956 p1 += sizeof ("%include");
1957 while (*p1 == ' ' || *p1 == '\t')
1960 if (*p1++ != '<' || p[-2] != '>')
1961 fatal ("specs %%include syntax malformed after %ld characters",
1962 (long) (p1 - buffer + 1));
1965 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
1966 read_specs (new_filename ? new_filename : p1, FALSE);
1969 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1970 && (p1[sizeof "%include_noerr" - 1] == ' '
1971 || p1[sizeof "%include_noerr" - 1] == '\t'))
1975 p1 += sizeof "%include_noerr";
1976 while (*p1 == ' ' || *p1 == '\t')
1979 if (*p1++ != '<' || p[-2] != '>')
1980 fatal ("specs %%include syntax malformed after %ld characters",
1981 (long) (p1 - buffer + 1));
1984 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
1986 read_specs (new_filename, FALSE);
1987 else if (verbose_flag)
1988 notice ("could not find specs file %s\n", p1);
1991 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1992 && (p1[sizeof "%rename" - 1] == ' '
1993 || p1[sizeof "%rename" - 1] == '\t'))
1996 struct spec_list *sl;
1997 struct spec_list *newsl;
1999 /* Get original name. */
2000 p1 += sizeof "%rename";
2001 while (*p1 == ' ' || *p1 == '\t')
2004 if (! ISALPHA ((unsigned char) *p1))
2005 fatal ("specs %%rename syntax malformed after %ld characters",
2006 (long) (p1 - buffer));
2009 while (*p2 && !ISSPACE ((unsigned char) *p2))
2012 if (*p2 != ' ' && *p2 != '\t')
2013 fatal ("specs %%rename syntax malformed after %ld characters",
2014 (long) (p2 - buffer));
2018 while (*p2 == ' ' || *p2 == '\t')
2021 if (! ISALPHA ((unsigned char) *p2))
2022 fatal ("specs %%rename syntax malformed after %ld characters",
2023 (long) (p2 - buffer));
2025 /* Get new spec name. */
2027 while (*p3 && !ISSPACE ((unsigned char) *p3))
2031 fatal ("specs %%rename syntax malformed after %ld characters",
2032 (long) (p3 - buffer));
2035 for (sl = specs; sl; sl = sl->next)
2036 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2040 fatal ("specs %s spec was not found to be renamed", p1);
2042 if (strcmp (p1, p2) == 0)
2045 for (newsl = specs; newsl; newsl = newsl->next)
2046 if (strcmp (newsl->name, p2) == 0)
2047 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2052 notice ("rename spec %s to %s\n", p1, p2);
2054 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2058 set_spec (p2, *(sl->ptr_spec));
2060 free ((void *) *(sl->ptr_spec));
2062 *(sl->ptr_spec) = "";
2067 fatal ("specs unknown %% command after %ld characters",
2068 (long) (p1 - buffer));
2071 /* Find the colon that should end the suffix. */
2073 while (*p1 && *p1 != ':' && *p1 != '\n')
2076 /* The colon shouldn't be missing. */
2078 fatal ("specs file malformed after %ld characters",
2079 (long) (p1 - buffer));
2081 /* Skip back over trailing whitespace. */
2083 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2086 /* Copy the suffix to a string. */
2087 suffix = save_string (p, p2 - p);
2088 /* Find the next line. */
2089 p = skip_whitespace (p1 + 1);
2091 fatal ("specs file malformed after %ld characters",
2092 (long) (p - buffer));
2095 /* Find next blank line or end of string. */
2096 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2099 /* Specs end at the blank line and do not include the newline. */
2100 spec = save_string (p, p1 - p);
2103 /* Delete backslash-newline sequences from the spec. */
2108 if (in[0] == '\\' && in[1] == '\n')
2110 else if (in[0] == '#')
2111 while (*in && *in != '\n')
2119 if (suffix[0] == '*')
2121 if (! strcmp (suffix, "*link_command"))
2122 link_command_spec = spec;
2124 set_spec (suffix + 1, spec);
2128 /* Add this pair to the vector. */
2130 = xrealloc (compilers,
2131 (n_compilers + 2) * sizeof (struct compiler));
2133 compilers[n_compilers].suffix = suffix;
2134 compilers[n_compilers].spec = spec;
2136 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2140 link_command_spec = spec;
2143 if (link_command_spec == 0)
2144 fatal ("spec file has no spec for linking");
2147 /* Record the names of temporary files we tell compilers to write,
2148 and delete them at the end of the run. */
2150 /* This is the common prefix we use to make temp file names.
2151 It is chosen once for each run of this program.
2152 It is substituted into a spec by %g or %j.
2153 Thus, all temp file names contain this prefix.
2154 In practice, all temp file names start with this prefix.
2156 This prefix comes from the envvar TMPDIR if it is defined;
2157 otherwise, from the P_tmpdir macro if that is defined;
2158 otherwise, in /usr/tmp or /tmp;
2159 or finally the current directory if all else fails. */
2161 static const char *temp_filename;
2163 /* Length of the prefix. */
2165 static int temp_filename_length;
2167 /* Define the list of temporary files to delete. */
2172 struct temp_file *next;
2175 /* Queue of files to delete on success or failure of compilation. */
2176 static struct temp_file *always_delete_queue;
2177 /* Queue of files to delete on failure of compilation. */
2178 static struct temp_file *failure_delete_queue;
2180 /* Record FILENAME as a file to be deleted automatically.
2181 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2182 otherwise delete it in any case.
2183 FAIL_DELETE nonzero means delete it if a compilation step fails;
2184 otherwise delete it in any case. */
2187 record_temp_file (const char *filename, int always_delete, int fail_delete)
2189 char *const name = xstrdup (filename);
2193 struct temp_file *temp;
2194 for (temp = always_delete_queue; temp; temp = temp->next)
2195 if (! strcmp (name, temp->name))
2198 temp = xmalloc (sizeof (struct temp_file));
2199 temp->next = always_delete_queue;
2201 always_delete_queue = temp;
2208 struct temp_file *temp;
2209 for (temp = failure_delete_queue; temp; temp = temp->next)
2210 if (! strcmp (name, temp->name))
2213 temp = xmalloc (sizeof (struct temp_file));
2214 temp->next = failure_delete_queue;
2216 failure_delete_queue = temp;
2222 /* Delete all the temporary files whose names we previously recorded. */
2225 delete_if_ordinary (const char *name)
2231 printf ("Delete %s? (y or n) ", name);
2235 while ((c = getchar ()) != '\n' && c != EOF)
2238 if (i == 'y' || i == 'Y')
2240 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
2241 if (unlink (name) < 0)
2243 perror_with_name (name);
2247 delete_temp_files (void)
2249 struct temp_file *temp;
2251 for (temp = always_delete_queue; temp; temp = temp->next)
2252 delete_if_ordinary (temp->name);
2253 always_delete_queue = 0;
2256 /* Delete all the files to be deleted on error. */
2259 delete_failure_queue (void)
2261 struct temp_file *temp;
2263 for (temp = failure_delete_queue; temp; temp = temp->next)
2264 delete_if_ordinary (temp->name);
2268 clear_failure_queue (void)
2270 failure_delete_queue = 0;
2273 /* Build a list of search directories from PATHS.
2274 PREFIX is a string to prepend to the list.
2275 If CHECK_DIR_P is nonzero we ensure the directory exists.
2276 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2277 It is also used by the --print-search-dirs flag. */
2280 build_search_list (struct path_prefix *paths, const char *prefix,
2283 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2285 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2286 int first_time = TRUE;
2287 struct prefix_list *pprefix;
2289 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2290 obstack_1grow (&collect_obstack, '=');
2292 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2294 int len = strlen (pprefix->prefix);
2298 || is_directory (pprefix->prefix, machine_suffix, 0)))
2301 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2304 obstack_grow (&collect_obstack, pprefix->prefix, len);
2305 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2308 if (just_machine_suffix
2309 && pprefix->require_machine_suffix == 2
2311 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2314 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2317 obstack_grow (&collect_obstack, pprefix->prefix, len);
2318 obstack_grow (&collect_obstack, just_machine_suffix,
2322 if (! pprefix->require_machine_suffix)
2325 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2328 obstack_grow (&collect_obstack, pprefix->prefix, len);
2332 obstack_1grow (&collect_obstack, '\0');
2333 return obstack_finish (&collect_obstack);
2336 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2340 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2342 putenv (build_search_list (paths, env_var, 1));
2345 /* Check whether NAME can be accessed in MODE. This is like access,
2346 except that it never considers directories to be executable. */
2349 access_check (const char *name, int mode)
2355 if (stat (name, &st) < 0
2356 || S_ISDIR (st.st_mode))
2360 return access (name, mode);
2363 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2364 access to check permissions.
2365 Return 0 if not found, otherwise return its name, allocated with malloc. */
2368 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2372 const char *const file_suffix =
2373 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2374 struct prefix_list *pl;
2375 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2376 const char *multilib_name, *multilib_os_name;
2378 #ifdef DEFAULT_ASSEMBLER
2379 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2380 return xstrdup (DEFAULT_ASSEMBLER);
2383 #ifdef DEFAULT_LINKER
2384 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2385 return xstrdup (DEFAULT_LINKER);
2389 len += strlen (machine_suffix);
2391 multilib_name = name;
2392 multilib_os_name = name;
2393 if (multilib && multilib_os_dir)
2395 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2396 int len2 = strlen (multilib_os_dir) + 1;
2398 len += len1 > len2 ? len1 : len2;
2400 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2402 if (strcmp (multilib_os_dir, ".") != 0)
2403 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2407 temp = xmalloc (len);
2409 /* Determine the filename to execute (special case for absolute paths). */
2411 if (IS_ABSOLUTE_PATH (name))
2413 if (access (name, mode) == 0)
2415 strcpy (temp, name);
2420 for (pl = pprefix->plist; pl; pl = pl->next)
2422 const char *this_name
2423 = pl->os_multilib ? multilib_os_name : multilib_name;
2427 /* Some systems have a suffix for executable files.
2428 So try appending that first. */
2429 if (file_suffix[0] != 0)
2431 strcpy (temp, pl->prefix);
2432 strcat (temp, machine_suffix);
2433 strcat (temp, multilib_name);
2434 strcat (temp, file_suffix);
2435 if (access_check (temp, mode) == 0)
2437 if (pl->used_flag_ptr != 0)
2438 *pl->used_flag_ptr = 1;
2443 /* Now try just the multilib_name. */
2444 strcpy (temp, pl->prefix);
2445 strcat (temp, machine_suffix);
2446 strcat (temp, multilib_name);
2447 if (access_check (temp, mode) == 0)
2449 if (pl->used_flag_ptr != 0)
2450 *pl->used_flag_ptr = 1;
2455 /* Certain prefixes are tried with just the machine type,
2456 not the version. This is used for finding as, ld, etc. */
2457 if (just_machine_suffix && pl->require_machine_suffix == 2)
2459 /* Some systems have a suffix for executable files.
2460 So try appending that first. */
2461 if (file_suffix[0] != 0)
2463 strcpy (temp, pl->prefix);
2464 strcat (temp, just_machine_suffix);
2465 strcat (temp, multilib_name);
2466 strcat (temp, file_suffix);
2467 if (access_check (temp, mode) == 0)
2469 if (pl->used_flag_ptr != 0)
2470 *pl->used_flag_ptr = 1;
2475 strcpy (temp, pl->prefix);
2476 strcat (temp, just_machine_suffix);
2477 strcat (temp, multilib_name);
2478 if (access_check (temp, mode) == 0)
2480 if (pl->used_flag_ptr != 0)
2481 *pl->used_flag_ptr = 1;
2486 /* Certain prefixes can't be used without the machine suffix
2487 when the machine or version is explicitly specified. */
2488 if (! pl->require_machine_suffix)
2490 /* Some systems have a suffix for executable files.
2491 So try appending that first. */
2492 if (file_suffix[0] != 0)
2494 strcpy (temp, pl->prefix);
2495 strcat (temp, this_name);
2496 strcat (temp, file_suffix);
2497 if (access_check (temp, mode) == 0)
2499 if (pl->used_flag_ptr != 0)
2500 *pl->used_flag_ptr = 1;
2505 strcpy (temp, pl->prefix);
2506 strcat (temp, this_name);
2507 if (access_check (temp, mode) == 0)
2509 if (pl->used_flag_ptr != 0)
2510 *pl->used_flag_ptr = 1;
2520 /* Ranking of prefixes in the sort list. -B prefixes are put before
2523 enum path_prefix_priority
2525 PREFIX_PRIORITY_B_OPT,
2526 PREFIX_PRIORITY_LAST
2529 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2530 order according to PRIORITY. Within each PRIORITY, new entries are
2533 If WARN is nonzero, we will warn if no file is found
2534 through this prefix. WARN should point to an int
2535 which will be set to 1 if this entry is used.
2537 COMPONENT is the value to be passed to update_path.
2539 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2540 the complete value of machine_suffix.
2541 2 means try both machine_suffix and just_machine_suffix. */
2544 add_prefix (struct path_prefix *pprefix, const char *prefix,
2545 const char *component, /* enum prefix_priority */ int priority,
2546 int require_machine_suffix, int *warn, int os_multilib)
2548 struct prefix_list *pl, **prev;
2551 for (prev = &pprefix->plist;
2552 (*prev) != NULL && (*prev)->priority <= priority;
2553 prev = &(*prev)->next)
2556 /* Keep track of the longest prefix. */
2558 prefix = update_path (prefix, component);
2559 len = strlen (prefix);
2560 if (len > pprefix->max_len)
2561 pprefix->max_len = len;
2563 pl = xmalloc (sizeof (struct prefix_list));
2564 pl->prefix = prefix;
2565 pl->require_machine_suffix = require_machine_suffix;
2566 pl->used_flag_ptr = warn;
2567 pl->priority = priority;
2568 pl->os_multilib = os_multilib;
2572 /* Insert after PREV. */
2577 /* Same as add_prefix, but prepending target_system_root to prefix. */
2579 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2580 const char *component,
2581 /* enum prefix_priority */ int priority,
2582 int require_machine_suffix, int *warn, int os_multilib)
2584 if (!IS_ABSOLUTE_PATH (prefix))
2587 if (target_system_root)
2589 if (target_sysroot_suffix)
2590 prefix = concat (target_sysroot_suffix, prefix, NULL);
2591 prefix = concat (target_system_root, prefix, NULL);
2593 /* We have to override this because GCC's notion of sysroot
2594 moves along with GCC. */
2598 add_prefix (pprefix, prefix, component, priority,
2599 require_machine_suffix, warn, os_multilib);
2602 /* Execute the command specified by the arguments on the current line of spec.
2603 When using pipes, this includes several piped-together commands
2604 with `|' between them.
2606 Return 0 if successful, -1 if failed. */
2612 int n_commands; /* # of command. */
2616 const char *prog; /* program name. */
2617 const char **argv; /* vector of args. */
2618 int pid; /* pid of process for this command. */
2621 struct command *commands; /* each command buffer with above info. */
2623 if (processing_spec_function)
2626 /* Count # of piped commands. */
2627 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2628 if (strcmp (argbuf[i], "|") == 0)
2631 /* Get storage for each command. */
2632 commands = alloca (n_commands * sizeof (struct command));
2634 /* Split argbuf into its separate piped processes,
2635 and record info about each one.
2636 Also search for the programs that are to be run. */
2638 commands[0].prog = argbuf[0]; /* first command. */
2639 commands[0].argv = &argbuf[0];
2640 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2643 commands[0].argv[0] = string;
2645 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2646 if (strcmp (argbuf[i], "|") == 0)
2647 { /* each command. */
2648 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2649 fatal ("-pipe not supported");
2651 argbuf[i] = 0; /* termination of command args. */
2652 commands[n_commands].prog = argbuf[i + 1];
2653 commands[n_commands].argv = &argbuf[i + 1];
2654 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2657 commands[n_commands].argv[0] = string;
2661 argbuf[argbuf_index] = 0;
2663 /* If -v, print what we are about to do, and maybe query. */
2667 /* For help listings, put a blank line between sub-processes. */
2668 if (print_help_list)
2669 fputc ('\n', stderr);
2671 /* Print each piped command as a separate line. */
2672 for (i = 0; i < n_commands; i++)
2674 const char *const *j;
2676 if (verbose_only_flag)
2678 for (j = commands[i].argv; *j; j++)
2681 fprintf (stderr, " \"");
2682 for (p = *j; *p; ++p)
2684 if (*p == '"' || *p == '\\' || *p == '$')
2685 fputc ('\\', stderr);
2688 fputc ('"', stderr);
2692 for (j = commands[i].argv; *j; j++)
2693 fprintf (stderr, " %s", *j);
2695 /* Print a pipe symbol after all but the last command. */
2696 if (i + 1 != n_commands)
2697 fprintf (stderr, " |");
2698 fprintf (stderr, "\n");
2701 if (verbose_only_flag != 0)
2703 /* verbose_only_flag should act as if the spec was
2704 executed, so increment execution_count before
2705 returning. This prevents spurious warnings about
2706 unused linker input files, etc. */
2711 notice ("\nGo ahead? (y or n) ");
2715 while (getchar () != '\n')
2718 if (i != 'y' && i != 'Y')
2723 #ifdef ENABLE_VALGRIND_CHECKING
2724 /* Run the each command through valgrind. To simplify prepending the
2725 path to valgrind and the option "-q" (for quiet operation unless
2726 something triggers), we allocate a separate argv array. */
2728 for (i = 0; i < n_commands; i++)
2734 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2737 argv = alloca ((argc + 3) * sizeof (char *));
2739 argv[0] = VALGRIND_PATH;
2741 for (j = 2; j < argc + 2; j++)
2742 argv[j] = commands[i].argv[j - 2];
2745 commands[i].argv = argv;
2746 commands[i].prog = argv[0];
2750 /* Run each piped subprocess. */
2752 for (i = 0; i < n_commands; i++)
2754 char *errmsg_fmt, *errmsg_arg;
2755 const char *string = commands[i].argv[0];
2757 /* For some bizarre reason, the second argument of execvp() is
2758 char *const *, not const char *const *. */
2759 commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2760 programname, temp_filename,
2761 &errmsg_fmt, &errmsg_arg,
2762 ((i == 0 ? PEXECUTE_FIRST : 0)
2763 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2764 | (string == commands[i].prog
2765 ? PEXECUTE_SEARCH : 0)
2766 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2768 if (commands[i].pid == -1)
2769 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2771 if (string != commands[i].prog)
2772 free ((void *) string);
2777 /* Wait for all the subprocesses to finish.
2778 We don't care what order they finish in;
2779 we know that N_COMMANDS waits will get them all.
2780 Ignore subprocesses that we don't know about,
2781 since they can be spawned by the process that exec'ed us. */
2785 #ifdef HAVE_GETRUSAGE
2787 double ut = 0.0, st = 0.0;
2790 for (i = 0; i < n_commands;)
2796 pid = pwait (commands[i].pid, &status, 0);
2800 #ifdef HAVE_GETRUSAGE
2803 /* getrusage returns the total resource usage of all children
2804 up to now. Copy the previous values into prus, get the
2805 current statistics, then take the difference. */
2808 getrusage (RUSAGE_CHILDREN, &rus);
2809 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2810 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2811 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2813 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2814 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2815 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2819 for (j = 0; j < n_commands; j++)
2820 if (commands[j].pid == pid)
2823 if (WIFSIGNALED (status))
2826 /* SIGPIPE is a special case. It happens in -pipe mode
2827 when the compiler dies before the preprocessor is
2828 done, or the assembler dies before the compiler is
2829 done. There's generally been an error already, and
2830 this is just fallout. So don't generate another error
2831 unless we would otherwise have succeeded. */
2832 if (WTERMSIG (status) == SIGPIPE
2833 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2838 Internal error: %s (program %s)\n\
2839 Please submit a full bug report.\n\
2840 See %s for instructions.",
2841 strsignal (WTERMSIG (status)), commands[j].prog,
2846 else if (WIFEXITED (status)
2847 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2849 if (WEXITSTATUS (status) > greatest_status)
2850 greatest_status = WEXITSTATUS (status);
2853 #ifdef HAVE_GETRUSAGE
2854 if (report_times && ut + st != 0)
2855 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2864 /* Find all the switches given to us
2865 and make a vector describing them.
2866 The elements of the vector are strings, one per switch given.
2867 If a switch uses following arguments, then the `part1' field
2868 is the switch itself and the `args' field
2869 is a null-terminated vector containing the following arguments.
2870 The `live_cond' field is:
2872 1 if the switch is true in a conditional spec,
2873 -1 if false (overridden by a later switch)
2874 -2 if this switch should be ignored (used in %<S)
2875 The `validated' field is nonzero if any spec has looked at this switch;
2876 if it remains zero at the end of the run, it must be meaningless. */
2879 #define SWITCH_FALSE -1
2880 #define SWITCH_IGNORE -2
2881 #define SWITCH_LIVE 1
2888 unsigned char validated;
2889 unsigned char ordering;
2892 static struct switchstr *switches;
2894 static int n_switches;
2899 const char *language;
2902 /* Also a vector of input files specified. */
2904 static struct infile *infiles;
2908 /* True if multiple input files are being compiled to a single
2911 static bool combine_inputs;
2913 /* This counts the number of libraries added by lang_specific_driver, so that
2914 we can tell if there were any user supplied any files or libraries. */
2916 static int added_libraries;
2918 /* And a vector of corresponding output files is made up later. */
2920 const char **outfiles;
2922 /* Used to track if none of the -B paths are used. */
2925 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2926 static int *warn_std_ptr = 0;
2928 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2930 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2931 is true if we should look for an executable suffix. DO_OBJ
2932 is true if we should look for an object suffix. */
2935 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2936 int do_obj ATTRIBUTE_UNUSED)
2938 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2946 len = strlen (name);
2948 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2949 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2950 if (do_obj && len > 2
2951 && name[len - 2] == '.'
2952 && name[len - 1] == 'o')
2954 obstack_grow (&obstack, name, len - 2);
2955 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2956 name = obstack_finish (&obstack);
2960 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2961 /* If there is no filetype, make it the executable suffix (which includes
2962 the "."). But don't get confused if we have just "-o". */
2963 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2966 for (i = len - 1; i >= 0; i--)
2967 if (IS_DIR_SEPARATOR (name[i]))
2970 for (i++; i < len; i++)
2974 obstack_grow (&obstack, name, len);
2975 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2976 strlen (TARGET_EXECUTABLE_SUFFIX));
2977 name = obstack_finish (&obstack);
2984 /* Display the command line switches accepted by gcc. */
2988 printf (_("Usage: %s [options] file...\n"), programname);
2989 fputs (_("Options:\n"), stdout);
2991 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
2992 fputs (_(" --help Display this information\n"), stdout);
2993 fputs (_(" --target-help Display target specific command line options\n"), stdout);
2995 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2996 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
2997 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
2998 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
2999 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3000 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3001 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3002 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3003 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3005 -print-multi-lib Display the mapping between command line options and\n\
3006 multiple library search directories\n"), stdout);
3007 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3008 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3009 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3010 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3011 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3012 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3013 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3014 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3015 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3016 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3017 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3018 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3019 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3020 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
3021 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
3022 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3023 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3024 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3025 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3026 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3027 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3029 -x <language> Specify the language of the following input files\n\
3030 Permissible languages include: c c++ assembler none\n\
3031 'none' means revert to the default behavior of\n\
3032 guessing the language based on the file's extension\n\
3036 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3037 passed on to the various sub-processes invoked by %s. In order to pass\n\
3038 other options on to these processes the -W<letter> options must be used.\n\
3041 /* The rest of the options are displayed by invocations of the various
3046 add_preprocessor_option (const char *option, int len)
3048 n_preprocessor_options++;
3050 if (! preprocessor_options)
3051 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3053 preprocessor_options = xrealloc (preprocessor_options,
3054 n_preprocessor_options * sizeof (char *));
3056 preprocessor_options [n_preprocessor_options - 1] =
3057 save_string (option, len);
3061 add_assembler_option (const char *option, int len)
3063 n_assembler_options++;
3065 if (! assembler_options)
3066 assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3068 assembler_options = xrealloc (assembler_options,
3069 n_assembler_options * sizeof (char *));
3071 assembler_options [n_assembler_options - 1] = save_string (option, len);
3075 add_linker_option (const char *option, int len)
3079 if (! linker_options)
3080 linker_options = xmalloc (n_linker_options * sizeof (char *));
3082 linker_options = xrealloc (linker_options,
3083 n_linker_options * sizeof (char *));
3085 linker_options [n_linker_options - 1] = save_string (option, len);
3088 /* Create the vector `switches' and its contents.
3089 Store its length in `n_switches'. */
3092 process_command (int argc, const char **argv)
3097 const char *spec_lang = 0;
3098 int last_language_n_infiles;
3101 int lang_n_infiles = 0;
3102 #ifdef MODIFY_TARGET_NAME
3103 int is_modify_target_name;
3107 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3111 added_libraries = 0;
3113 /* Figure compiler version from version string. */
3115 compiler_version = temp1 = xstrdup (version_string);
3117 for (; *temp1; ++temp1)
3126 /* If there is a -V or -b option (or both), process it now, before
3127 trying to interpret the rest of the command line. */
3128 if (argc > 1 && argv[1][0] == '-'
3129 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3131 const char *new_version = DEFAULT_TARGET_VERSION;
3132 const char *new_machine = DEFAULT_TARGET_MACHINE;
3133 const char *progname = argv[0];
3138 while (argc > 1 && argv[1][0] == '-'
3139 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3141 char opt = argv[1][1];
3143 if (argv[1][2] != '\0')
3156 fatal ("`-%c' option must have argument", opt);
3163 for (baselen = strlen (progname); baselen > 0; baselen--)
3164 if (IS_DIR_SEPARATOR (progname[baselen-1]))
3166 new_argv0 = xmemdup (progname, baselen,
3167 baselen + concat_length (new_version, new_machine,
3168 "-gcc-", NULL) + 1);
3169 strcpy (new_argv0 + baselen, new_machine);
3170 strcat (new_argv0, "-gcc-");
3171 strcat (new_argv0, new_version);
3173 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3174 (argc + 1) * sizeof (argv[0]));
3175 new_argv[0] = new_argv0;
3177 execvp (new_argv0, new_argv);
3178 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
3181 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3182 see if we can create it from the pathname specified in argv[0]. */
3184 gcc_libexec_prefix = standard_libexec_prefix;
3186 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3187 if (!gcc_exec_prefix)
3189 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3190 standard_exec_prefix);
3191 gcc_libexec_prefix = make_relative_prefix (argv[0],
3192 standard_bindir_prefix,
3193 standard_libexec_prefix);
3194 if (gcc_exec_prefix)
3195 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3198 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3199 standard_exec_prefix,
3200 standard_libexec_prefix);
3204 if (gcc_exec_prefix)
3206 int len = strlen (gcc_exec_prefix);
3208 if (len > (int) sizeof ("/lib/gcc/") - 1
3209 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3211 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3212 if (IS_DIR_SEPARATOR (*temp)
3213 && strncmp (temp + 1, "lib", 3) == 0
3214 && IS_DIR_SEPARATOR (temp[4])
3215 && strncmp (temp + 5, "gcc", 3) == 0)
3216 len -= sizeof ("/lib/gcc/") - 1;
3219 set_std_prefix (gcc_exec_prefix, len);
3220 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3221 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3222 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3223 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3226 /* COMPILER_PATH and LIBRARY_PATH have values
3227 that are lists of directory names with colons. */
3229 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3232 const char *startp, *endp;
3233 char *nstore = alloca (strlen (temp) + 3);
3235 startp = endp = temp;
3238 if (*endp == PATH_SEPARATOR || *endp == 0)
3240 strncpy (nstore, startp, endp - startp);
3242 strcpy (nstore, concat (".", dir_separator_str, NULL));
3243 else if (!IS_DIR_SEPARATOR (endp[-1]))
3245 nstore[endp - startp] = DIR_SEPARATOR;
3246 nstore[endp - startp + 1] = 0;
3249 nstore[endp - startp] = 0;
3250 add_prefix (&exec_prefixes, nstore, 0,
3251 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3252 add_prefix (&include_prefixes,
3253 concat (nstore, "include", NULL),
3254 0, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3257 endp = startp = endp + 1;
3264 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3265 if (temp && *cross_compile == '0')
3267 const char *startp, *endp;
3268 char *nstore = alloca (strlen (temp) + 3);
3270 startp = endp = temp;
3273 if (*endp == PATH_SEPARATOR || *endp == 0)
3275 strncpy (nstore, startp, endp - startp);
3277 strcpy (nstore, concat (".", dir_separator_str, NULL));
3278 else if (!IS_DIR_SEPARATOR (endp[-1]))
3280 nstore[endp - startp] = DIR_SEPARATOR;
3281 nstore[endp - startp + 1] = 0;
3284 nstore[endp - startp] = 0;
3285 add_prefix (&startfile_prefixes, nstore, NULL,
3286 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3289 endp = startp = endp + 1;
3296 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3297 GET_ENVIRONMENT (temp, "LPATH");
3298 if (temp && *cross_compile == '0')
3300 const char *startp, *endp;
3301 char *nstore = alloca (strlen (temp) + 3);
3303 startp = endp = temp;
3306 if (*endp == PATH_SEPARATOR || *endp == 0)
3308 strncpy (nstore, startp, endp - startp);
3310 strcpy (nstore, concat (".", dir_separator_str, NULL));
3311 else if (!IS_DIR_SEPARATOR (endp[-1]))
3313 nstore[endp - startp] = DIR_SEPARATOR;
3314 nstore[endp - startp + 1] = 0;
3317 nstore[endp - startp] = 0;
3318 add_prefix (&startfile_prefixes, nstore, NULL,
3319 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3322 endp = startp = endp + 1;
3329 /* Convert new-style -- options to old-style. */
3330 translate_options (&argc, (const char *const **) &argv);
3332 /* Do language-specific adjustment/addition of flags. */
3333 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3335 /* Scan argv twice. Here, the first time, just count how many switches
3336 there will be in their vector, and how many input files in theirs.
3337 Here we also parse the switches that cc itself uses (e.g. -v). */
3339 for (i = 1; i < argc; i++)
3341 if (! strcmp (argv[i], "-dumpspecs"))
3343 struct spec_list *sl;
3345 for (sl = specs; sl; sl = sl->next)
3346 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3347 if (link_command_spec)
3348 printf ("*link_command:\n%s\n\n", link_command_spec);
3351 else if (! strcmp (argv[i], "-dumpversion"))
3353 printf ("%s\n", spec_version);
3356 else if (! strcmp (argv[i], "-dumpmachine"))
3358 printf ("%s\n", spec_machine);
3361 else if (strcmp (argv[i], "-fversion") == 0)
3363 /* translate_options () has turned --version into -fversion. */
3364 printf (_("%s (GCC) %s\n"), programname, version_string);
3365 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n",
3367 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3368 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3372 else if (strcmp (argv[i], "-fhelp") == 0)
3374 /* translate_options () has turned --help into -fhelp. */
3375 print_help_list = 1;
3377 /* We will be passing a dummy file on to the sub-processes. */
3381 /* CPP driver cannot obtain switch from cc1_options. */
3383 add_preprocessor_option ("--help", 6);
3384 add_assembler_option ("--help", 6);
3385 add_linker_option ("--help", 6);
3387 else if (strcmp (argv[i], "-ftarget-help") == 0)
3389 /* translate_options() has turned --target-help into -ftarget-help. */
3390 target_help_flag = 1;
3392 /* We will be passing a dummy file on to the sub-processes. */
3396 /* CPP driver cannot obtain switch from cc1_options. */
3398 add_preprocessor_option ("--target-help", 13);
3399 add_assembler_option ("--target-help", 13);
3400 add_linker_option ("--target-help", 13);
3402 else if (! strcmp (argv[i], "-pass-exit-codes"))
3404 pass_exit_codes = 1;
3407 else if (! strcmp (argv[i], "-print-search-dirs"))
3408 print_search_dirs = 1;
3409 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3410 print_file_name = "libgcc.a";
3411 else if (! strncmp (argv[i], "-print-file-name=", 17))
3412 print_file_name = argv[i] + 17;
3413 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3414 print_prog_name = argv[i] + 17;
3415 else if (! strcmp (argv[i], "-print-multi-lib"))
3416 print_multi_lib = 1;
3417 else if (! strcmp (argv[i], "-print-multi-directory"))
3418 print_multi_directory = 1;
3419 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3420 print_multi_os_directory = 1;
3421 else if (! strncmp (argv[i], "-Wa,", 4))
3424 /* Pass the rest of this option to the assembler. */
3426 /* Split the argument at commas. */
3428 for (j = 4; argv[i][j]; j++)
3429 if (argv[i][j] == ',')
3431 add_assembler_option (argv[i] + prev, j - prev);
3435 /* Record the part after the last comma. */
3436 add_assembler_option (argv[i] + prev, j - prev);
3438 else if (! strncmp (argv[i], "-Wp,", 4))
3441 /* Pass the rest of this option to the preprocessor. */
3443 /* Split the argument at commas. */
3445 for (j = 4; argv[i][j]; j++)
3446 if (argv[i][j] == ',')
3448 add_preprocessor_option (argv[i] + prev, j - prev);
3452 /* Record the part after the last comma. */
3453 add_preprocessor_option (argv[i] + prev, j - prev);
3455 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3456 /* The +e options to the C++ front-end. */
3458 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3461 /* Split the argument at commas. */
3462 for (j = 3; argv[i][j]; j++)
3463 n_infiles += (argv[i][j] == ',');
3465 else if (strcmp (argv[i], "-Xlinker") == 0)
3468 fatal ("argument to `-Xlinker' is missing");
3473 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3476 fatal ("argument to `-Xpreprocessor' is missing");
3478 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3480 else if (strcmp (argv[i], "-Xassembler") == 0)
3483 fatal ("argument to `-Xassembler' is missing");
3485 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3487 else if (strcmp (argv[i], "-l") == 0)
3490 fatal ("argument to `-l' is missing");
3495 else if (strncmp (argv[i], "-l", 2) == 0)
3497 else if (strcmp (argv[i], "-save-temps") == 0)
3499 save_temps_flag = 1;
3502 else if (strcmp (argv[i], "-specs") == 0)
3504 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3506 fatal ("argument to `-specs' is missing");
3508 user->next = (struct user_specs *) 0;
3509 user->filename = argv[i];
3510 if (user_specs_tail)
3511 user_specs_tail->next = user;
3513 user_specs_head = user;
3514 user_specs_tail = user;
3516 else if (strncmp (argv[i], "-specs=", 7) == 0)
3518 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3519 if (strlen (argv[i]) == 7)
3520 fatal ("argument to `-specs=' is missing");
3522 user->next = (struct user_specs *) 0;
3523 user->filename = argv[i] + 7;
3524 if (user_specs_tail)
3525 user_specs_tail->next = user;
3527 user_specs_head = user;
3528 user_specs_tail = user;
3530 else if (strcmp (argv[i], "-time") == 0)
3532 else if (strcmp (argv[i], "-pipe") == 0)
3534 /* -pipe has to go into the switches array as well as
3539 else if (strcmp (argv[i], "-###") == 0)
3541 /* This is similar to -v except that there is no execution
3542 of the commands and the echoed arguments are quoted. It
3543 is intended for use in shell scripts to capture the
3544 driver-generated command line. */
3545 verbose_only_flag++;
3548 else if (argv[i][0] == '-' && argv[i][1] != 0)
3550 const char *p = &argv[i][1];
3557 fatal ("`-%c' must come at the start of the command line", c);
3565 if (p[1] == 0 && i + 1 == argc)
3566 fatal ("argument to `-B' is missing");
3572 len = strlen (value);
3574 /* Catch the case where the user has forgotten to append a
3575 directory separator to the path. Note, they may be using
3576 -B to add an executable name prefix, eg "i386-elf-", in
3577 order to distinguish between multiple installations of
3578 GCC in the same directory. Hence we must check to see
3579 if appending a directory separator actually makes a
3580 valid directory name. */
3581 if (! IS_DIR_SEPARATOR (value [len - 1])
3582 && is_directory (value, "", 0))
3584 char *tmp = xmalloc (len + 2);
3585 strcpy (tmp, value);
3586 tmp[len] = DIR_SEPARATOR;
3591 /* As a kludge, if the arg is "[foo/]stageN/", just
3592 add "[foo/]include" to the include prefix. */
3595 && (IS_DIR_SEPARATOR (value[len - 8]))))
3596 && strncmp (value + len - 7, "stage", 5) == 0
3597 && ISDIGIT (value[len - 2])
3598 && (IS_DIR_SEPARATOR (value[len - 1])))
3601 add_prefix (&include_prefixes, "include", NULL,
3602 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3605 char * string = xmalloc (len + 1);
3607 strncpy (string, value, len - 7);
3608 strcpy (string + len - 7, "include");
3609 add_prefix (&include_prefixes, string, NULL,
3610 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3614 add_prefix (&exec_prefixes, value, NULL,
3615 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3616 add_prefix (&startfile_prefixes, value, NULL,
3617 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3618 add_prefix (&include_prefixes, concat (value, "include", NULL),
3619 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3624 case 'v': /* Print our subcommands and print versions. */
3626 /* If they do anything other than exactly `-v', don't set
3627 verbose_flag; rather, continue on to give the error. */
3645 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3650 /* Forward scan, just in case -S or -c is specified
3657 if (argv[j][0] == '-')
3659 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3665 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3666 j += skip - (argv[j][2] != 0);
3667 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3674 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3676 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3678 argv[i] = convert_filename (argv[i], ! have_c, 0);
3685 #ifdef MODIFY_TARGET_NAME
3686 is_modify_target_name = 0;
3688 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3689 if (! strcmp (argv[i], modify_target[j].sw))
3691 char *new_name = xmalloc (strlen (modify_target[j].str)
3692 + strlen (spec_machine));
3695 int made_addition = 0;
3697 is_modify_target_name = 1;
3698 for (p = spec_machine, q = new_name; *p != 0; )
3700 if (modify_target[j].add_del == DELETE
3701 && (! strncmp (q, modify_target[j].str,
3702 strlen (modify_target[j].str))))
3703 p += strlen (modify_target[j].str);
3704 else if (modify_target[j].add_del == ADD
3705 && ! made_addition && *p == '-')
3707 for (r = modify_target[j].str; *r != 0; )
3715 spec_machine = new_name;
3718 if (is_modify_target_name)
3724 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3725 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3726 else if (WORD_SWITCH_TAKES_ARG (p))
3727 i += WORD_SWITCH_TAKES_ARG (p);
3737 combine_inputs = (have_c && have_o && lang_n_infiles > 1);
3739 if ((save_temps_flag || report_times) && use_pipes)
3741 /* -save-temps overrides -pipe, so that temp files are produced */
3742 if (save_temps_flag)
3743 error ("warning: -pipe ignored because -save-temps specified");
3744 /* -time overrides -pipe because we can't get correct stats when
3745 multiple children are running at once. */
3746 else if (report_times)
3747 error ("warning: -pipe ignored because -time specified");
3752 /* Set up the search paths before we go looking for config files. */
3754 /* These come before the md prefixes so that we will find gcc's subcommands
3755 (such as cpp) rather than those of the host system. */
3756 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3757 as well as trying the machine and the version. */
3759 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3760 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3761 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3762 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3763 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3764 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3765 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3766 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3767 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3768 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3771 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3772 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3773 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
3774 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3776 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3777 dir_separator_str, NULL);
3779 /* If tooldir is relative, base it on exec_prefixes. A relative
3780 tooldir lets us move the installed tree as a unit.
3782 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3783 directories, so that we can search both the user specified directory
3784 and the standard place. */
3786 if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3788 if (gcc_exec_prefix)
3790 char *gcc_exec_tooldir_prefix
3791 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3792 spec_version, dir_separator_str, tooldir_prefix, NULL);
3794 add_prefix (&exec_prefixes,
3795 concat (gcc_exec_tooldir_prefix, "bin",
3796 dir_separator_str, NULL),
3797 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3798 add_prefix (&startfile_prefixes,
3799 concat (gcc_exec_tooldir_prefix, "lib",
3800 dir_separator_str, NULL),
3801 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
3804 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3805 dir_separator_str, spec_version,
3806 dir_separator_str, tooldir_prefix, NULL);
3809 add_prefix (&exec_prefixes,
3810 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3811 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0);
3812 add_prefix (&startfile_prefixes,
3813 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3814 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
3816 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3817 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3818 then consider it to relocate with the rest of the GCC installation
3819 if GCC_EXEC_PREFIX is set.
3820 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3821 if (target_system_root && gcc_exec_prefix)
3823 char *tmp_prefix = make_relative_prefix (argv[0],
3824 standard_bindir_prefix,
3825 target_system_root);
3826 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3828 target_system_root = tmp_prefix;
3829 target_system_root_changed = 1;
3834 /* More prefixes are enabled in main, after we read the specs file
3835 and determine whether this is cross-compilation or not. */
3837 /* Then create the space for the vectors and scan again. */
3839 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3840 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3843 last_language_n_infiles = -1;
3845 /* This, time, copy the text of each switch and store a pointer
3846 to the copy in the vector of switches.
3847 Store all the infiles in their vector. */
3849 for (i = 1; i < argc; i++)
3851 /* Just skip the switches that were handled by the preceding loop. */
3852 #ifdef MODIFY_TARGET_NAME
3853 is_modify_target_name = 0;
3855 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3856 if (! strcmp (argv[i], modify_target[j].sw))
3857 is_modify_target_name = 1;
3859 if (is_modify_target_name)
3863 if (! strncmp (argv[i], "-Wa,", 4))
3865 else if (! strncmp (argv[i], "-Wp,", 4))
3867 else if (! strcmp (argv[i], "-pass-exit-codes"))
3869 else if (! strcmp (argv[i], "-print-search-dirs"))
3871 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3873 else if (! strncmp (argv[i], "-print-file-name=", 17))
3875 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3877 else if (! strcmp (argv[i], "-print-multi-lib"))
3879 else if (! strcmp (argv[i], "-print-multi-directory"))
3881 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3883 else if (! strcmp (argv[i], "-ftarget-help"))
3885 else if (! strcmp (argv[i], "-fhelp"))
3887 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3889 /* Compensate for the +e options to the C++ front-end;
3890 they're there simply for cfront call-compatibility. We do
3891 some magic in default_compilers to pass them down properly.
3892 Note we deliberately start at the `+' here, to avoid passing
3893 -e0 or -e1 down into the linker. */
3894 switches[n_switches].part1 = &argv[i][0];
3895 switches[n_switches].args = 0;
3896 switches[n_switches].live_cond = SWITCH_OK;
3897 switches[n_switches].validated = 0;
3900 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3903 /* Split the argument at commas. */
3905 for (j = 4; argv[i][j]; j++)
3906 if (argv[i][j] == ',')
3908 infiles[n_infiles].language = "*";
3909 infiles[n_infiles++].name
3910 = save_string (argv[i] + prev, j - prev);
3913 /* Record the part after the last comma. */
3914 infiles[n_infiles].language = "*";
3915 infiles[n_infiles++].name = argv[i] + prev;
3917 else if (strcmp (argv[i], "-Xlinker") == 0)
3919 infiles[n_infiles].language = "*";
3920 infiles[n_infiles++].name = argv[++i];
3922 else if (strcmp (argv[i], "-Xassembler") == 0)
3924 infiles[n_infiles].language = "*";
3925 infiles[n_infiles++].name = argv[++i];
3927 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3929 infiles[n_infiles].language = "*";
3930 infiles[n_infiles++].name = argv[++i];
3932 else if (strcmp (argv[i], "-l") == 0)
3933 { /* POSIX allows separation of -l and the lib arg;
3934 canonicalize by concatenating -l with its arg */
3935 infiles[n_infiles].language = "*";
3936 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3938 else if (strncmp (argv[i], "-l", 2) == 0)
3940 infiles[n_infiles].language = "*";
3941 infiles[n_infiles++].name = argv[i];
3943 else if (strcmp (argv[i], "-specs") == 0)
3945 else if (strncmp (argv[i], "-specs=", 7) == 0)
3947 else if (strcmp (argv[i], "-time") == 0)
3949 else if (strcmp (argv[i], "-###") == 0)
3951 else if (argv[i][0] == '-' && argv[i][1] != 0)
3953 const char *p = &argv[i][1];
3958 if (p[1] == 0 && i + 1 == argc)
3959 fatal ("argument to `-x' is missing");
3961 spec_lang = argv[++i];
3964 if (! strcmp (spec_lang, "none"))
3965 /* Suppress the warning if -xnone comes after the last input
3966 file, because alternate command interfaces like g++ might
3967 find it useful to place -xnone after each input file. */
3970 last_language_n_infiles = n_infiles;
3973 switches[n_switches].part1 = p;
3974 /* Deal with option arguments in separate argv elements. */
3975 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3976 || WORD_SWITCH_TAKES_ARG (p))
3979 int n_args = WORD_SWITCH_TAKES_ARG (p);
3983 /* Count only the option arguments in separate argv elements. */
3984 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3986 if (i + n_args >= argc)
3987 fatal ("argument to `-%s' is missing", p);
3988 switches[n_switches].args
3989 = xmalloc ((n_args + 1) * sizeof(const char *));
3991 switches[n_switches].args[j++] = argv[++i];
3992 /* Null-terminate the vector. */
3993 switches[n_switches].args[j] = 0;
3995 else if (strchr (switches_need_spaces, c))
3997 /* On some systems, ld cannot handle some options without
3998 a space. So split the option from its argument. */
3999 char *part1 = xmalloc (2);
4003 switches[n_switches].part1 = part1;
4004 switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4005 switches[n_switches].args[0] = xstrdup (p+1);
4006 switches[n_switches].args[1] = 0;
4009 switches[n_switches].args = 0;
4011 switches[n_switches].live_cond = SWITCH_OK;
4012 switches[n_switches].validated = 0;
4013 switches[n_switches].ordering = 0;
4014 /* These are always valid, since gcc.c itself understands them. */
4015 if (!strcmp (p, "save-temps")
4016 || !strcmp (p, "static-libgcc")
4017 || !strcmp (p, "shared-libgcc")
4018 || !strcmp (p, "pipe"))
4019 switches[n_switches].validated = 1;
4022 char ch = switches[n_switches].part1[0];
4024 switches[n_switches].validated = 1;
4030 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4031 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4034 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4036 perror_with_name (argv[i]);
4041 infiles[n_infiles].language = spec_lang;
4042 infiles[n_infiles++].name = argv[i];
4047 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4048 error ("warning: `-x %s' after last input file has no effect", spec_lang);
4050 /* Ensure we only invoke each subprocess once. */
4051 if (target_help_flag || print_help_list)
4055 /* Create a dummy input file, so that we can pass --target-help on to
4056 the various sub-processes. */
4057 infiles[0].language = "c";
4058 infiles[0].name = "help-dummy";
4060 if (target_help_flag)
4062 switches[n_switches].part1 = "--target-help";
4063 switches[n_switches].args = 0;
4064 switches[n_switches].live_cond = SWITCH_OK;
4065 switches[n_switches].validated = 0;
4070 if (print_help_list)
4072 switches[n_switches].part1 = "--help";
4073 switches[n_switches].args = 0;
4074 switches[n_switches].live_cond = SWITCH_OK;
4075 switches[n_switches].validated = 0;
4081 switches[n_switches].part1 = 0;
4082 infiles[n_infiles].name = 0;
4085 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4086 and place that in the environment. */
4089 set_collect_gcc_options (void)
4094 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4096 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4097 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4100 for (i = 0; (int) i < n_switches; i++)
4102 const char *const *args;
4105 obstack_grow (&collect_obstack, " ", 1);
4109 /* Ignore elided switches. */
4110 if (switches[i].live_cond == SWITCH_IGNORE)
4113 obstack_grow (&collect_obstack, "'-", 2);
4114 q = switches[i].part1;
4115 while ((p = strchr (q, '\'')))
4117 obstack_grow (&collect_obstack, q, p - q);
4118 obstack_grow (&collect_obstack, "'\\''", 4);
4121 obstack_grow (&collect_obstack, q, strlen (q));
4122 obstack_grow (&collect_obstack, "'", 1);
4124 for (args = switches[i].args; args && *args; args++)
4126 obstack_grow (&collect_obstack, " '", 2);
4128 while ((p = strchr (q, '\'')))
4130 obstack_grow (&collect_obstack, q, p - q);
4131 obstack_grow (&collect_obstack, "'\\''", 4);
4134 obstack_grow (&collect_obstack, q, strlen (q));
4135 obstack_grow (&collect_obstack, "'", 1);
4138 obstack_grow (&collect_obstack, "\0", 1);
4139 putenv (obstack_finish (&collect_obstack));
4142 /* Process a spec string, accumulating and running commands. */
4144 /* These variables describe the input file name.
4145 input_file_number is the index on outfiles of this file,
4146 so that the output file name can be stored for later use by %o.
4147 input_basename is the start of the part of the input file
4148 sans all directory names, and basename_length is the number
4149 of characters starting there excluding the suffix .c or whatever. */
4151 static const char *input_filename;
4152 static int input_file_number;
4153 size_t input_filename_length;
4154 static int basename_length;
4155 static int suffixed_basename_length;
4156 static const char *input_basename;
4157 static const char *input_suffix;
4158 static struct stat input_stat;
4159 static int input_stat_set;
4161 /* The compiler used to process the current input file. */
4162 static struct compiler *input_file_compiler;
4164 /* These are variables used within do_spec and do_spec_1. */
4166 /* Nonzero if an arg has been started and not yet terminated
4167 (with space, tab or newline). */
4168 static int arg_going;
4170 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4171 is a temporary file name. */
4172 static int delete_this_arg;
4174 /* Nonzero means %w has been seen; the next arg to be terminated
4175 is the output file name of this compilation. */
4176 static int this_is_output_file;
4178 /* Nonzero means %s has been seen; the next arg to be terminated
4179 is the name of a library file and we should try the standard
4180 search dirs for it. */
4181 static int this_is_library_file;
4183 /* Nonzero means that the input of this command is coming from a pipe. */
4184 static int input_from_pipe;
4186 /* Nonnull means substitute this for any suffix when outputting a switches
4188 static const char *suffix_subst;
4190 /* Process the spec SPEC and run the commands specified therein.
4191 Returns 0 if the spec is successfully processed; -1 if failed. */
4194 do_spec (const char *spec)
4198 value = do_spec_2 (spec);
4200 /* Force out any unfinished command.
4201 If -pipe, this forces out the last command if it ended in `|'. */
4204 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4207 set_collect_gcc_options ();
4209 if (argbuf_index > 0)
4217 do_spec_2 (const char *spec)
4224 delete_this_arg = 0;
4225 this_is_output_file = 0;
4226 this_is_library_file = 0;
4227 input_from_pipe = 0;
4228 suffix_subst = NULL;
4230 result = do_spec_1 (spec, 0, NULL);
4232 /* End any pending argument. */
4235 obstack_1grow (&obstack, 0);
4236 string = obstack_finish (&obstack);
4237 if (this_is_library_file)
4238 string = find_file (string);
4239 store_arg (string, delete_this_arg, this_is_output_file);
4240 if (this_is_output_file)
4241 outfiles[input_file_number] = string;
4249 /* Process the given spec string and add any new options to the end
4250 of the switches/n_switches array. */
4253 do_option_spec (const char *name, const char *spec)
4255 unsigned int i, value_count, value_len;
4256 const char *p, *q, *value;
4257 char *tmp_spec, *tmp_spec_p;
4259 if (configure_default_options[0].name == NULL)
4262 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4263 if (strcmp (configure_default_options[i].name, name) == 0)
4265 if (i == ARRAY_SIZE (configure_default_options))
4268 value = configure_default_options[i].value;
4269 value_len = strlen (value);
4271 /* Compute the size of the final spec. */
4274 while ((p = strstr (p, "%(VALUE)")) != NULL)
4280 /* Replace each %(VALUE) by the specified value. */
4281 tmp_spec = alloca (strlen (spec) + 1
4282 + value_count * (value_len - strlen ("%(VALUE)")));
4283 tmp_spec_p = tmp_spec;
4285 while ((p = strstr (q, "%(VALUE)")) != NULL)
4287 memcpy (tmp_spec_p, q, p - q);
4288 tmp_spec_p = tmp_spec_p + (p - q);
4289 memcpy (tmp_spec_p, value, value_len);
4290 tmp_spec_p += value_len;
4291 q = p + strlen ("%(VALUE)");
4293 strcpy (tmp_spec_p, q);
4295 do_self_spec (tmp_spec);
4298 /* Process the given spec string and add any new options to the end
4299 of the switches/n_switches array. */
4302 do_self_spec (const char *spec)
4305 do_spec_1 (" ", 0, NULL);
4307 if (argbuf_index > 0)
4312 n_switches += argbuf_index;
4313 switches = xrealloc (switches,
4314 sizeof (struct switchstr) * (n_switches + 1));
4316 switches[n_switches] = switches[first];
4317 for (i = 0; i < argbuf_index; i++)
4319 struct switchstr *sw;
4321 /* Each switch should start with '-'. */
4322 if (argbuf[i][0] != '-')
4325 sw = &switches[i + first];
4326 sw->part1 = &argbuf[i][1];
4328 sw->live_cond = SWITCH_OK;
4335 /* Process the sub-spec SPEC as a portion of a larger spec.
4336 This is like processing a whole spec except that we do
4337 not initialize at the beginning and we do not supply a
4338 newline by default at the end.
4339 INSWITCH nonzero means don't process %-sequences in SPEC;
4340 in this case, % is treated as an ordinary character.
4341 This is used while substituting switches.
4342 INSWITCH nonzero also causes SPC not to terminate an argument.
4344 Value is zero unless a line was finished
4345 and the command on that line reported an error. */
4348 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4350 const char *p = spec;
4357 /* If substituting a switch, treat all chars like letters.
4358 Otherwise, NL, SPC, TAB and % are special. */
4359 switch (inswitch ? 'a' : c)
4362 /* End of line: finish any pending argument,
4363 then run the pending command if one has been started. */
4366 obstack_1grow (&obstack, 0);
4367 string = obstack_finish (&obstack);
4368 if (this_is_library_file)
4369 string = find_file (string);
4370 store_arg (string, delete_this_arg, this_is_output_file);
4371 if (this_is_output_file)
4372 outfiles[input_file_number] = string;
4376 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4378 /* A `|' before the newline means use a pipe here,
4379 but only if -pipe was specified.
4380 Otherwise, execute now and don't pass the `|' as an arg. */
4383 input_from_pipe = 1;
4390 set_collect_gcc_options ();
4392 if (argbuf_index > 0)
4398 /* Reinitialize for a new command, and for a new argument. */
4401 delete_this_arg = 0;
4402 this_is_output_file = 0;
4403 this_is_library_file = 0;
4404 input_from_pipe = 0;
4408 /* End any pending argument. */
4411 obstack_1grow (&obstack, 0);
4412 string = obstack_finish (&obstack);
4413 if (this_is_library_file)
4414 string = find_file (string);
4415 store_arg (string, delete_this_arg, this_is_output_file);
4416 if (this_is_output_file)
4417 outfiles[input_file_number] = string;
4421 obstack_1grow (&obstack, c);
4427 /* Space or tab ends an argument if one is pending. */
4430 obstack_1grow (&obstack, 0);
4431 string = obstack_finish (&obstack);
4432 if (this_is_library_file)
4433 string = find_file (string);
4434 store_arg (string, delete_this_arg, this_is_output_file);
4435 if (this_is_output_file)
4436 outfiles[input_file_number] = string;
4438 /* Reinitialize for a new argument. */
4440 delete_this_arg = 0;
4441 this_is_output_file = 0;
4442 this_is_library_file = 0;
4449 fatal ("invalid specification! Bug in cc");
4452 obstack_grow (&obstack, input_basename, basename_length);
4457 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4462 delete_this_arg = 2;
4465 /* Dump out the directories specified with LIBRARY_PATH,
4466 followed by the absolute directories
4467 that we search for startfiles. */
4470 struct prefix_list *pl = startfile_prefixes.plist;
4471 size_t bufsize = 100;
4472 char *buffer = xmalloc (bufsize);
4475 for (; pl; pl = pl->next)
4477 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4478 /* Used on systems which record the specified -L dirs
4479 and use them to search for dynamic linking. */
4480 /* Relative directories always come from -B,
4481 and it is better not to use them for searching
4482 at run time. In particular, stage1 loses. */
4483 if (!IS_ABSOLUTE_PATH (pl->prefix))
4486 /* Try subdirectory if there is one. */
4487 if (multilib_dir != NULL
4488 || (pl->os_multilib && multilib_os_dir != NULL))
4490 const char *multi_dir;
4492 multi_dir = pl->os_multilib ? multilib_os_dir
4494 if (machine_suffix && multilib_dir)
4496 if (strlen (pl->prefix) + strlen (machine_suffix)
4498 bufsize = (strlen (pl->prefix)
4499 + strlen (machine_suffix)) * 2 + 1;
4500 buffer = xrealloc (buffer, bufsize);
4501 strcpy (buffer, pl->prefix);
4502 strcat (buffer, machine_suffix);
4503 if (is_directory (buffer, multilib_dir, 1))
4505 do_spec_1 ("-L", 0, NULL);
4506 #ifdef SPACE_AFTER_L_OPTION
4507 do_spec_1 (" ", 0, NULL);
4509 do_spec_1 (buffer, 1, NULL);
4510 do_spec_1 (multilib_dir, 1, NULL);
4511 /* Make this a separate argument. */
4512 do_spec_1 (" ", 0, NULL);
4515 if (!pl->require_machine_suffix)
4517 if (is_directory (pl->prefix, multi_dir, 1))
4519 do_spec_1 ("-L", 0, NULL);
4520 #ifdef SPACE_AFTER_L_OPTION
4521 do_spec_1 (" ", 0, NULL);
4523 do_spec_1 (pl->prefix, 1, NULL);
4524 do_spec_1 (multi_dir, 1, NULL);
4525 /* Make this a separate argument. */
4526 do_spec_1 (" ", 0, NULL);
4532 if (is_directory (pl->prefix, machine_suffix, 1))
4534 do_spec_1 ("-L", 0, NULL);
4535 #ifdef SPACE_AFTER_L_OPTION
4536 do_spec_1 (" ", 0, NULL);
4538 do_spec_1 (pl->prefix, 1, NULL);
4539 /* Remove slash from machine_suffix. */
4540 if (strlen (machine_suffix) >= bufsize)
4541 bufsize = strlen (machine_suffix) * 2 + 1;
4542 buffer = xrealloc (buffer, bufsize);
4543 strcpy (buffer, machine_suffix);
4544 idx = strlen (buffer);
4545 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4546 buffer[idx - 1] = 0;
4547 do_spec_1 (buffer, 1, NULL);
4548 /* Make this a separate argument. */
4549 do_spec_1 (" ", 0, NULL);
4552 if (!pl->require_machine_suffix)
4554 if (is_directory (pl->prefix, "", 1))
4556 do_spec_1 ("-L", 0, NULL);
4557 #ifdef SPACE_AFTER_L_OPTION
4558 do_spec_1 (" ", 0, NULL);
4560 /* Remove slash from pl->prefix. */
4561 if (strlen (pl->prefix) >= bufsize)
4562 bufsize = strlen (pl->prefix) * 2 + 1;
4563 buffer = xrealloc (buffer, bufsize);
4564 strcpy (buffer, pl->prefix);
4565 idx = strlen (buffer);
4566 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4567 buffer[idx - 1] = 0;
4568 do_spec_1 (buffer, 1, NULL);
4569 /* Make this a separate argument. */
4570 do_spec_1 (" ", 0, NULL);
4579 /* %efoo means report an error with `foo' as error message
4580 and don't execute any more commands for this file. */
4584 while (*p != 0 && *p != '\n')
4586 buf = alloca (p - q + 1);
4587 strncpy (buf, q, p - q);
4594 /* %nfoo means report a notice with `foo' on stderr. */
4598 while (*p != 0 && *p != '\n')
4600 buf = alloca (p - q + 1);
4601 strncpy (buf, q, p - q);
4603 notice ("%s\n", buf);
4613 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4614 defined, and it is not a directory, and it is
4615 writable, use it. Otherwise, treat this like any
4616 other temporary file. */
4618 if ((!save_temps_flag)
4619 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4620 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4622 obstack_grow (&obstack, HOST_BIT_BUCKET,
4623 strlen (HOST_BIT_BUCKET));
4624 delete_this_arg = 0;
4629 goto create_temp_file;
4633 obstack_1grow (&obstack, '-');
4634 delete_this_arg = 0;
4637 /* consume suffix */
4638 while (*p == '.' || ISALPHA ((unsigned char) *p))
4640 if (p[0] == '%' && p[1] == 'O')
4645 goto create_temp_file;
4649 /* consume suffix */
4650 while (*p == '.' || ISALPHA ((unsigned char) *p))
4652 if (p[0] == '%' && p[1] == 'O')
4657 goto create_temp_file;
4663 struct temp_name *t;
4665 const char *suffix = p;
4666 char *saved_suffix = NULL;
4668 while (*p == '.' || ISALPHA ((unsigned char) *p))
4670 suffix_length = p - suffix;
4671 if (p[0] == '%' && p[1] == 'O')
4674 /* We don't support extra suffix characters after %O. */
4675 if (*p == '.' || ISALPHA ((unsigned char) *p))
4677 if (suffix_length == 0)
4678 suffix = TARGET_OBJECT_SUFFIX;
4682 = xmalloc (suffix_length
4683 + strlen (TARGET_OBJECT_SUFFIX));
4684 strncpy (saved_suffix, suffix, suffix_length);
4685 strcpy (saved_suffix + suffix_length,
4686 TARGET_OBJECT_SUFFIX);
4688 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4691 /* If the input_filename has the same suffix specified
4692 for the %g, %u, or %U, and -save-temps is specified,
4693 we could end up using that file as an intermediate
4694 thus clobbering the user's source file (.e.g.,
4695 gcc -save-temps foo.s would clobber foo.s with the
4696 output of cpp0). So check for this condition and
4697 generate a temp file as the intermediate. */
4699 if (save_temps_flag)
4701 temp_filename_length = basename_length + suffix_length;
4702 temp_filename = alloca (temp_filename_length + 1);
4703 strncpy ((char *) temp_filename, input_basename, basename_length);
4704 strncpy ((char *) temp_filename + basename_length, suffix,
4706 *((char *) temp_filename + temp_filename_length) = '\0';
4707 if (strcmp (temp_filename, input_filename) != 0)
4709 struct stat st_temp;
4711 /* Note, set_input() resets input_stat_set to 0. */
4712 if (input_stat_set == 0)
4714 input_stat_set = stat (input_filename, &input_stat);
4715 if (input_stat_set >= 0)
4719 /* If we have the stat for the input_filename
4720 and we can do the stat for the temp_filename
4721 then the they could still refer to the same
4722 file if st_dev/st_ino's are the same. */
4724 if (input_stat_set != 1
4725 || stat (temp_filename, &st_temp) < 0
4726 || input_stat.st_dev != st_temp.st_dev
4727 || input_stat.st_ino != st_temp.st_ino)
4729 temp_filename = save_string (temp_filename,
4730 temp_filename_length + 1);
4731 obstack_grow (&obstack, temp_filename,
4732 temp_filename_length);
4734 delete_this_arg = 0;
4740 /* See if we already have an association of %g/%u/%U and
4742 for (t = temp_names; t; t = t->next)
4743 if (t->length == suffix_length
4744 && strncmp (t->suffix, suffix, suffix_length) == 0
4745 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4748 /* Make a new association if needed. %u and %j
4750 if (t == 0 || c == 'u' || c == 'j')
4754 t = xmalloc (sizeof (struct temp_name));
4755 t->next = temp_names;
4758 t->length = suffix_length;
4761 t->suffix = saved_suffix;
4762 saved_suffix = NULL;
4765 t->suffix = save_string (suffix, suffix_length);
4766 t->unique = (c == 'u' || c == 'U' || c == 'j');
4767 temp_filename = make_temp_file (t->suffix);
4768 temp_filename_length = strlen (temp_filename);
4769 t->filename = temp_filename;
4770 t->filename_length = temp_filename_length;
4774 free (saved_suffix);
4776 obstack_grow (&obstack, t->filename, t->filename_length);
4777 delete_this_arg = 1;
4785 for (i = 0; (int) i < n_infiles; i++)
4786 store_arg (infiles[i].name, 0, 0);
4790 obstack_grow (&obstack, input_filename, input_filename_length);
4797 struct prefix_list *pl = include_prefixes.plist;
4799 if (gcc_exec_prefix)
4801 do_spec_1 ("-iprefix", 1, NULL);
4802 /* Make this a separate argument. */
4803 do_spec_1 (" ", 0, NULL);
4804 do_spec_1 (gcc_exec_prefix, 1, NULL);
4805 do_spec_1 (" ", 0, NULL);
4808 if (target_system_root_changed ||
4809 (target_system_root && target_sysroot_hdrs_suffix))
4811 do_spec_1 ("-isysroot", 1, NULL);
4812 /* Make this a separate argument. */
4813 do_spec_1 (" ", 0, NULL);
4814 do_spec_1 (target_system_root, 1, NULL);
4815 if (target_sysroot_hdrs_suffix)
4816 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4817 do_spec_1 (" ", 0, NULL);
4820 for (; pl; pl = pl->next)
4822 do_spec_1 ("-isystem", 1, NULL);
4823 /* Make this a separate argument. */
4824 do_spec_1 (" ", 0, NULL);
4825 do_spec_1 (pl->prefix, 1, NULL);
4826 do_spec_1 (" ", 0, NULL);
4833 int max = n_infiles;
4834 max += lang_specific_extra_outfiles;
4836 for (i = 0; i < max; i++)
4838 store_arg (outfiles[i], 0, 0);
4843 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4848 this_is_library_file = 1;
4852 outfiles[input_file_number] = NULL;
4856 this_is_output_file = 1;
4861 int cur_index = argbuf_index;
4862 /* Handle the {...} following the %W. */
4865 p = handle_braces (p + 1);
4868 /* End any pending argument. */
4871 obstack_1grow (&obstack, 0);
4872 string = obstack_finish (&obstack);
4873 if (this_is_library_file)
4874 string = find_file (string);
4875 store_arg (string, delete_this_arg, this_is_output_file);
4876 if (this_is_output_file)
4877 outfiles[input_file_number] = string;
4880 /* If any args were output, mark the last one for deletion
4882 if (argbuf_index != cur_index)
4883 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4887 /* %x{OPTION} records OPTION for %X to output. */
4893 /* Skip past the option value and make a copy. */
4898 string = save_string (p1 + 1, p - p1 - 2);
4900 /* See if we already recorded this option. */
4901 for (i = 0; i < n_linker_options; i++)
4902 if (! strcmp (string, linker_options[i]))
4908 /* This option is new; add it. */
4909 add_linker_option (string, strlen (string));
4913 /* Dump out the options accumulated previously using %x. */
4915 for (i = 0; i < n_linker_options; i++)
4917 do_spec_1 (linker_options[i], 1, NULL);
4918 /* Make each accumulated option a separate argument. */
4919 do_spec_1 (" ", 0, NULL);
4923 /* Dump out the options accumulated previously using -Wa,. */
4925 for (i = 0; i < n_assembler_options; i++)
4927 do_spec_1 (assembler_options[i], 1, NULL);
4928 /* Make each accumulated option a separate argument. */
4929 do_spec_1 (" ", 0, NULL);
4933 /* Dump out the options accumulated previously using -Wp,. */
4935 for (i = 0; i < n_preprocessor_options; i++)
4937 do_spec_1 (preprocessor_options[i], 1, NULL);
4938 /* Make each accumulated option a separate argument. */
4939 do_spec_1 (" ", 0, NULL);
4943 /* Here are digits and numbers that just process
4944 a certain constant string as a spec. */
4947 value = do_spec_1 (cc1_spec, 0, NULL);
4953 value = do_spec_1 (cc1plus_spec, 0, NULL);
4959 value = do_spec_1 (asm_spec, 0, NULL);
4965 value = do_spec_1 (asm_final_spec, 0, NULL);
4972 const char *const spec
4973 = (input_file_compiler->cpp_spec
4974 ? input_file_compiler->cpp_spec
4976 value = do_spec_1 (spec, 0, NULL);
4983 value = do_spec_1 (endfile_spec, 0, NULL);
4989 value = do_spec_1 (link_spec, 0, NULL);
4995 value = do_spec_1 (lib_spec, 0, NULL);
5001 value = do_spec_1 (libgcc_spec, 0, NULL);
5007 if (multilib_dir && strcmp (multilib_dir, ".") != 0)
5013 len = strlen (multilib_dir);
5014 obstack_blank (&obstack, len + 1);
5015 p = obstack_next_free (&obstack) - (len + 1);
5018 for (q = multilib_dir; *q ; ++q, ++p)
5019 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
5024 /* We assume there is a directory
5025 separator at the end of this string. */
5026 if (target_system_root)
5028 obstack_grow (&obstack, target_system_root,
5029 strlen (target_system_root));
5030 if (target_sysroot_suffix)
5031 obstack_grow (&obstack, target_sysroot_suffix,
5032 strlen (target_sysroot_suffix));
5037 value = do_spec_1 (startfile_spec, 0, NULL);
5042 /* Here we define characters other than letters and digits. */
5045 p = handle_braces (p);
5051 p = handle_spec_function (p);
5057 obstack_1grow (&obstack, '%');
5064 while (p[len] && p[len] != ' ' && p[len] != '%')
5066 suffix_subst = save_string (p - 1, len + 1);
5071 /* Henceforth ignore the option(s) matching the pattern
5076 int have_wildcard = 0;
5079 while (p[len] && p[len] != ' ' && p[len] != '\t')
5082 if (p[len-1] == '*')
5085 for (i = 0; i < n_switches; i++)
5086 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5087 && (have_wildcard || switches[i].part1[len] == '\0'))
5089 switches[i].live_cond = SWITCH_IGNORE;
5090 switches[i].validated = 1;
5098 if (soft_matched_part)
5100 do_spec_1 (soft_matched_part, 1, NULL);
5101 do_spec_1 (" ", 0, NULL);
5104 /* Catch the case where a spec string contains something like
5105 '%{foo:%*}'. ie there is no * in the pattern on the left
5106 hand side of the :. */
5107 error ("spec failure: '%%*' has not been initialized by pattern match");
5110 /* Process a string found as the value of a spec given by name.
5111 This feature allows individual machine descriptions
5112 to add and use their own specs.
5113 %[...] modifies -D options the way %P does;
5114 %(...) uses the spec unmodified. */
5116 error ("warning: use of obsolete %%[ operator in specs");
5119 const char *name = p;
5120 struct spec_list *sl;
5123 /* The string after the S/P is the name of a spec that is to be
5125 while (*p && *p != ')' && *p != ']')
5128 /* See if it's in the list. */
5129 for (len = p - name, sl = specs; sl; sl = sl->next)
5130 if (sl->name_len == len && !strncmp (sl->name, name, len))
5132 name = *(sl->ptr_spec);
5134 notice ("Processing spec %c%s%c, which is '%s'\n",
5135 c, sl->name, (c == '(') ? ')' : ']', name);
5144 value = do_spec_1 (name, 0, NULL);
5150 char *x = alloca (strlen (name) * 2 + 1);
5152 const char *y = name;
5155 /* Copy all of NAME into BUF, but put __ after
5156 every -D and at the end of each arg. */
5159 if (! strncmp (y, "-D", 2))
5170 && (*y == ' ' || *y == '\t' || *y == '='
5171 || *y == '}' || *y == 0))
5184 value = do_spec_1 (buf, 0, NULL);
5190 /* Discard the closing paren or bracket. */
5197 error ("spec failure: unrecognized spec option '%c'", c);
5203 /* Backslash: treat next character as ordinary. */
5208 /* Ordinary character: put it into the current argument. */
5209 obstack_1grow (&obstack, c);
5213 /* End of string. If we are processing a spec function, we need to
5214 end any pending argument. */
5215 if (processing_spec_function && arg_going)
5217 obstack_1grow (&obstack, 0);
5218 string = obstack_finish (&obstack);
5219 if (this_is_library_file)
5220 string = find_file (string);
5221 store_arg (string, delete_this_arg, this_is_output_file);
5222 if (this_is_output_file)
5223 outfiles[input_file_number] = string;
5230 /* Look up a spec function. */
5232 static const struct spec_function *
5233 lookup_spec_function (const char *name)
5235 static const struct spec_function * const spec_function_tables[] =
5237 static_spec_functions,
5238 lang_specific_spec_functions,
5240 const struct spec_function *sf;
5243 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
5245 for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
5246 if (strcmp (sf->name, name) == 0)
5253 /* Evaluate a spec function. */
5256 eval_spec_function (const char *func, const char *args)
5258 const struct spec_function *sf;
5259 const char *funcval;
5261 /* Saved spec processing context. */
5262 int save_argbuf_index;
5263 int save_argbuf_length;
5264 const char **save_argbuf;
5267 int save_delete_this_arg;
5268 int save_this_is_output_file;
5269 int save_this_is_library_file;
5270 int save_input_from_pipe;
5271 const char *save_suffix_subst;
5274 sf = lookup_spec_function (func);
5276 fatal ("unknown spec function `%s'", func);
5278 /* Push the spec processing context. */
5279 save_argbuf_index = argbuf_index;
5280 save_argbuf_length = argbuf_length;
5281 save_argbuf = argbuf;
5283 save_arg_going = arg_going;
5284 save_delete_this_arg = delete_this_arg;
5285 save_this_is_output_file = this_is_output_file;
5286 save_this_is_library_file = this_is_library_file;
5287 save_input_from_pipe = input_from_pipe;
5288 save_suffix_subst = suffix_subst;
5290 /* Create a new spec processing context, and build the function
5294 if (do_spec_2 (args) < 0)
5295 fatal ("error in args to spec function `%s'", func);
5297 /* argbuf_index is an index for the next argument to be inserted, and
5298 so contains the count of the args already inserted. */
5300 funcval = (*sf->func) (argbuf_index, argbuf);
5302 /* Pop the spec processing context. */
5303 argbuf_index = save_argbuf_index;
5304 argbuf_length = save_argbuf_length;
5306 argbuf = save_argbuf;
5308 arg_going = save_arg_going;
5309 delete_this_arg = save_delete_this_arg;
5310 this_is_output_file = save_this_is_output_file;
5311 this_is_library_file = save_this_is_library_file;
5312 input_from_pipe = save_input_from_pipe;
5313 suffix_subst = save_suffix_subst;
5318 /* Handle a spec function call of the form:
5322 ARGS is processed as a spec in a separate context and split into an
5323 argument vector in the normal fashion. The function returns a string
5324 containing a spec which we then process in the caller's context, or
5325 NULL if no processing is required. */
5328 handle_spec_function (const char *p)
5331 const char *endp, *funcval;
5334 processing_spec_function++;
5336 /* Get the function name. */
5337 for (endp = p; *endp != '\0'; endp++)
5339 if (*endp == '(') /* ) */
5341 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5342 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5343 fatal ("malformed spec function name");
5345 if (*endp != '(') /* ) */
5346 fatal ("no arguments for spec function");
5347 func = save_string (p, endp - p);
5350 /* Get the arguments. */
5351 for (count = 0; *endp != '\0'; endp++)
5360 else if (*endp == '(') /* ) */
5365 fatal ("malformed spec function arguments");
5366 args = save_string (p, endp - p);
5369 /* p now points to just past the end of the spec function expression. */
5371 funcval = eval_spec_function (func, args);
5372 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5378 processing_spec_function--;
5383 /* Inline subroutine of handle_braces. Returns true if the current
5384 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5386 input_suffix_matches (const char *atom, const char *end_atom)
5388 return (input_suffix
5389 && !strncmp (input_suffix, atom, end_atom - atom)
5390 && input_suffix[end_atom - atom] == '\0');
5393 /* Inline subroutine of handle_braces. Returns true if a switch
5394 matching the atom bracketed by ATOM and END_ATOM appeared on the
5397 switch_matches (const char *atom, const char *end_atom, int starred)
5400 int len = end_atom - atom;
5401 int plen = starred ? len : -1;
5403 for (i = 0; i < n_switches; i++)
5404 if (!strncmp (switches[i].part1, atom, len)
5405 && (starred || switches[i].part1[len] == '\0')
5406 && check_live_switch (i, plen))
5412 /* Inline subroutine of handle_braces. Mark all of the switches which
5413 match ATOM (extends to END_ATOM; STARRED indicates whether there
5414 was a star after the atom) for later processing. */
5416 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5419 int len = end_atom - atom;
5420 int plen = starred ? len : -1;
5422 for (i = 0; i < n_switches; i++)
5423 if (!strncmp (switches[i].part1, atom, len)
5424 && (starred || switches[i].part1[len] == '\0')
5425 && check_live_switch (i, plen))
5426 switches[i].ordering = 1;
5429 /* Inline subroutine of handle_braces. Process all the currently
5430 marked switches through give_switch, and clear the marks. */
5432 process_marked_switches (void)
5436 for (i = 0; i < n_switches; i++)
5437 if (switches[i].ordering == 1)
5439 switches[i].ordering = 0;
5444 /* Handle a %{ ... } construct. P points just inside the leading {.
5445 Returns a pointer one past the end of the brace block, or 0
5446 if we call do_spec_1 and that returns -1. */
5449 handle_braces (const char *p)
5451 const char *atom, *end_atom;
5452 const char *d_atom = NULL, *d_end_atom = NULL;
5459 bool a_must_be_last = false;
5460 bool ordered_set = false;
5461 bool disjunct_set = false;
5462 bool disj_matched = false;
5463 bool disj_starred = true;
5464 bool n_way_choice = false;
5465 bool n_way_matched = false;
5467 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5474 /* Scan one "atom" (S in the description above of %{}, possibly
5475 with !, ., or * modifiers). */
5476 a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5480 p++, a_is_negated = true;
5484 p++, a_is_suffix = true;
5487 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5488 || *p == ',' || *p == '.' || *p == '@')
5493 p++, a_is_starred = 1;
5496 if (*p == '&' || *p == '}')
5498 /* Substitute the switch(es) indicated by the current atom. */
5500 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5501 || atom == end_atom)
5504 mark_matching_switches (atom, end_atom, a_is_starred);
5507 process_marked_switches ();
5509 else if (*p == '|' || *p == ':')
5511 /* Substitute some text if the current atom appears as a switch
5513 disjunct_set = true;
5517 if (atom == end_atom)
5519 if (!n_way_choice || disj_matched || *p == '|'
5520 || a_is_negated || a_is_suffix || a_is_starred)
5523 /* An empty term may appear as the last choice of an
5524 N-way choice set; it means "otherwise". */
5525 a_must_be_last = true;
5526 disj_matched = !n_way_matched;
5527 disj_starred = false;
5531 if (a_is_suffix && a_is_starred)
5535 disj_starred = false;
5537 /* Don't bother testing this atom if we already have a
5539 if (!disj_matched && !n_way_matched)
5542 a_matched = input_suffix_matches (atom, end_atom);
5544 a_matched = switch_matches (atom, end_atom, a_is_starred);
5546 if (a_matched != a_is_negated)
5548 disj_matched = true;
5550 d_end_atom = end_atom;
5557 /* Found the body, that is, the text to substitute if the
5558 current disjunction matches. */
5559 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5560 disj_matched && !n_way_matched);
5564 /* If we have an N-way choice, reset state for the next
5568 n_way_choice = true;
5569 n_way_matched |= disj_matched;
5570 disj_matched = false;
5571 disj_starred = true;
5572 d_atom = d_end_atom = NULL;
5579 while (*p++ != '}');
5586 /* Subroutine of handle_braces. Scan and process a brace substitution body
5587 (X in the description of %{} syntax). P points one past the colon;
5588 ATOM and END_ATOM bracket the first atom which was found to be true
5589 (present) in the current disjunction; STARRED indicates whether all
5590 the atoms in the current disjunction were starred (for syntax validation);
5591 MATCHED indicates whether the disjunction matched or not, and therefore
5592 whether or not the body is to be processed through do_spec_1 or just
5593 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5597 process_brace_body (const char *p, const char *atom, const char *end_atom,
5598 int starred, int matched)
5600 const char *body, *end_body;
5601 unsigned int nesting_level;
5602 bool have_subst = false;
5604 /* Locate the closing } or ;, honoring nested braces.
5605 Trim trailing whitespace. */
5614 if (!--nesting_level)
5617 else if (*p == ';' && nesting_level == 1)
5619 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5621 else if (*p == '\0')
5627 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5630 if (have_subst && !starred)
5635 /* Copy the substitution body to permanent storage and execute it.
5636 If have_subst is false, this is a simple matter of running the
5637 body through do_spec_1... */
5638 char *string = save_string (body, end_body - body);
5641 if (do_spec_1 (string, 0, NULL) < 0)
5646 /* ... but if have_subst is true, we have to process the
5647 body once for each matching switch, with %* set to the
5648 variant part of the switch. */
5649 unsigned int hard_match_len = end_atom - atom;
5652 for (i = 0; i < n_switches; i++)
5653 if (!strncmp (switches[i].part1, atom, hard_match_len)
5654 && check_live_switch (i, hard_match_len))
5656 if (do_spec_1 (string, 0,
5657 &switches[i].part1[hard_match_len]) < 0)
5659 /* Pass any arguments this switch has. */
5661 suffix_subst = NULL;
5669 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5670 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5671 spec, or -1 if either exact match or %* is used.
5673 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5674 whose value does not begin with "no-" is obsoleted by the same value
5675 with the "no-", similarly for a switch with the "no-" prefix. */
5678 check_live_switch (int switchnum, int prefix_length)
5680 const char *name = switches[switchnum].part1;
5683 /* In the common case of {<at-most-one-letter>*}, a negating
5684 switch would always match, so ignore that case. We will just
5685 send the conflicting switches to the compiler phase. */
5686 if (prefix_length >= 0 && prefix_length <= 1)
5689 /* If we already processed this switch and determined if it was
5690 live or not, return our past determination. */
5691 if (switches[switchnum].live_cond != 0)
5692 return switches[switchnum].live_cond > 0;
5694 /* Now search for duplicate in a manner that depends on the name. */
5698 for (i = switchnum + 1; i < n_switches; i++)
5699 if (switches[i].part1[0] == 'O')
5701 switches[switchnum].validated = 1;
5702 switches[switchnum].live_cond = SWITCH_FALSE;
5707 case 'W': case 'f': case 'm':
5708 if (! strncmp (name + 1, "no-", 3))
5710 /* We have Xno-YYY, search for XYYY. */
5711 for (i = switchnum + 1; i < n_switches; i++)
5712 if (switches[i].part1[0] == name[0]
5713 && ! strcmp (&switches[i].part1[1], &name[4]))
5715 switches[switchnum].validated = 1;
5716 switches[switchnum].live_cond = SWITCH_FALSE;
5722 /* We have XYYY, search for Xno-YYY. */
5723 for (i = switchnum + 1; i < n_switches; i++)
5724 if (switches[i].part1[0] == name[0]
5725 && switches[i].part1[1] == 'n'
5726 && switches[i].part1[2] == 'o'
5727 && switches[i].part1[3] == '-'
5728 && !strcmp (&switches[i].part1[4], &name[1]))
5730 switches[switchnum].validated = 1;
5731 switches[switchnum].live_cond = SWITCH_FALSE;
5738 /* Otherwise the switch is live. */
5739 switches[switchnum].live_cond = SWITCH_LIVE;
5743 /* Pass a switch to the current accumulating command
5744 in the same form that we received it.
5745 SWITCHNUM identifies the switch; it is an index into
5746 the vector of switches gcc received, which is `switches'.
5747 This cannot fail since it never finishes a command line.
5749 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5752 give_switch (int switchnum, int omit_first_word)
5754 if (switches[switchnum].live_cond == SWITCH_IGNORE)
5757 if (!omit_first_word)
5759 do_spec_1 ("-", 0, NULL);
5760 do_spec_1 (switches[switchnum].part1, 1, NULL);
5763 if (switches[switchnum].args != 0)
5766 for (p = switches[switchnum].args; *p; p++)
5768 const char *arg = *p;
5770 do_spec_1 (" ", 0, NULL);
5773 unsigned length = strlen (arg);
5776 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5777 if (arg[length] == '.')
5779 ((char *)arg)[length] = 0;
5783 do_spec_1 (arg, 1, NULL);
5785 ((char *)arg)[length] = '.';
5786 do_spec_1 (suffix_subst, 1, NULL);
5789 do_spec_1 (arg, 1, NULL);
5793 do_spec_1 (" ", 0, NULL);
5794 switches[switchnum].validated = 1;
5797 /* Search for a file named NAME trying various prefixes including the
5798 user's -B prefix and some standard ones.
5799 Return the absolute file name found. If nothing is found, return NAME. */
5802 find_file (const char *name)
5806 /* Try multilib_dir if it is defined. */
5807 if (multilib_os_dir != NULL)
5809 newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
5811 /* If we don't find it in the multi library dir, then fall
5812 through and look for it in the normal places. */
5813 if (newname != NULL)
5817 newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
5818 return newname ? newname : name;
5821 /* Determine whether a directory exists. If LINKER, return 0 for
5822 certain fixed names not needed by the linker. If not LINKER, it is
5823 only important to return 0 if the host machine has a small ARG_MAX
5827 is_directory (const char *path1, const char *path2, int linker)
5829 int len1 = strlen (path1);
5830 int len2 = strlen (path2);
5831 char *path = alloca (3 + len1 + len2);
5835 #ifndef SMALL_ARG_MAX
5840 /* Construct the path from the two parts. Ensure the string ends with "/.".
5841 The resulting path will be a directory even if the given path is a
5843 memcpy (path, path1, len1);
5844 memcpy (path + len1, path2, len2);
5845 cp = path + len1 + len2;
5846 if (!IS_DIR_SEPARATOR (cp[-1]))
5847 *cp++ = DIR_SEPARATOR;
5851 /* Exclude directories that the linker is known to search. */
5854 && strcmp (path, concat (dir_separator_str, "lib",
5855 dir_separator_str, ".", NULL)) == 0)
5857 && strcmp (path, concat (dir_separator_str, "usr",
5858 dir_separator_str, "lib",
5859 dir_separator_str, ".", NULL)) == 0)))
5862 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5865 /* Set up the various global variables to indicate that we're processing
5866 the input file named FILENAME. */
5869 set_input (const char *filename)
5873 input_filename = filename;
5874 input_filename_length = strlen (input_filename);
5876 input_basename = input_filename;
5877 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5878 /* Skip drive name so 'x:foo' is handled properly. */
5879 if (input_basename[1] == ':')
5880 input_basename += 2;
5882 for (p = input_basename; *p; p++)
5883 if (IS_DIR_SEPARATOR (*p))
5884 input_basename = p + 1;
5886 /* Find a suffix starting with the last period,
5887 and set basename_length to exclude that suffix. */
5888 basename_length = strlen (input_basename);
5889 suffixed_basename_length = basename_length;
5890 p = input_basename + basename_length;
5891 while (p != input_basename && *p != '.')
5893 if (*p == '.' && p != input_basename)
5895 basename_length = p - input_basename;
5896 input_suffix = p + 1;
5901 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5902 we will need to do a stat on the input_filename. The
5903 INPUT_STAT_SET signals that the stat is needed. */
5907 /* On fatal signals, delete all the temporary files. */
5910 fatal_error (int signum)
5912 signal (signum, SIG_DFL);
5913 delete_failure_queue ();
5914 delete_temp_files ();
5915 /* Get the same signal again, this time not handled,
5916 so its normal effect occurs. */
5917 kill (getpid (), signum);
5920 extern int main (int, const char **);
5923 main (int argc, const char **argv)
5927 int linker_was_run = 0;
5928 int num_linker_inputs = 0;
5929 char *explicit_link_files;
5932 struct user_specs *uptr;
5934 p = argv[0] + strlen (argv[0]);
5935 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
5939 xmalloc_set_program_name (programname);
5941 #ifdef GCC_DRIVER_HOST_INITIALIZATION
5942 /* Perform host dependent initialization when needed. */
5943 GCC_DRIVER_HOST_INITIALIZATION;
5946 gcc_init_libintl ();
5948 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
5949 signal (SIGINT, fatal_error);
5951 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
5952 signal (SIGHUP, fatal_error);
5954 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
5955 signal (SIGTERM, fatal_error);
5957 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
5958 signal (SIGPIPE, fatal_error);
5961 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
5962 receive the signal. A different setting is inheritable */
5963 signal (SIGCHLD, SIG_DFL);
5966 /* Allocate the argument vector. */
5969 obstack_init (&obstack);
5971 /* Build multilib_select, et. al from the separate lines that make up each
5972 multilib selection. */
5974 const char *const *q = multilib_raw;
5977 obstack_init (&multilib_obstack);
5978 while ((p = *q++) != (char *) 0)
5979 obstack_grow (&multilib_obstack, p, strlen (p));
5981 obstack_1grow (&multilib_obstack, 0);
5982 multilib_select = obstack_finish (&multilib_obstack);
5984 q = multilib_matches_raw;
5985 while ((p = *q++) != (char *) 0)
5986 obstack_grow (&multilib_obstack, p, strlen (p));
5988 obstack_1grow (&multilib_obstack, 0);
5989 multilib_matches = obstack_finish (&multilib_obstack);
5991 q = multilib_exclusions_raw;
5992 while ((p = *q++) != (char *) 0)
5993 obstack_grow (&multilib_obstack, p, strlen (p));
5995 obstack_1grow (&multilib_obstack, 0);
5996 multilib_exclusions = obstack_finish (&multilib_obstack);
5999 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6002 obstack_1grow (&multilib_obstack, ' ');
6003 obstack_grow (&multilib_obstack,
6004 multilib_defaults_raw[i],
6005 strlen (multilib_defaults_raw[i]));
6009 obstack_1grow (&multilib_obstack, 0);
6010 multilib_defaults = obstack_finish (&multilib_obstack);
6013 /* Set up to remember the pathname of gcc and any options
6014 needed for collect. We use argv[0] instead of programname because
6015 we need the complete pathname. */
6016 obstack_init (&collect_obstack);
6017 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6018 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6019 putenv (obstack_finish (&collect_obstack));
6021 #ifdef INIT_ENVIRONMENT
6022 /* Set up any other necessary machine specific environment variables. */
6023 putenv (INIT_ENVIRONMENT);
6026 /* Make a table of what switches there are (switches, n_switches).
6027 Make a table of specified input files (infiles, n_infiles).
6028 Decode switches that are handled locally. */
6030 process_command (argc, argv);
6032 /* Initialize the vector of specs to just the default.
6033 This means one element containing 0s, as a terminator. */
6035 compilers = xmalloc (sizeof default_compilers);
6036 memcpy (compilers, default_compilers, sizeof default_compilers);
6037 n_compilers = n_default_compilers;
6039 /* Read specs from a file if there is one. */
6041 machine_suffix = concat (spec_machine, dir_separator_str,
6042 spec_version, dir_separator_str, NULL);
6043 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6045 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
6046 /* Read the specs file unless it is a default one. */
6047 if (specs_file != 0 && strcmp (specs_file, "specs"))
6048 read_specs (specs_file, TRUE);
6052 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6053 for any override of as, ld and libraries. */
6054 specs_file = alloca (strlen (standard_exec_prefix)
6055 + strlen (just_machine_suffix) + sizeof ("specs"));
6057 strcpy (specs_file, standard_exec_prefix);
6058 strcat (specs_file, just_machine_suffix);
6059 strcat (specs_file, "specs");
6060 if (access (specs_file, R_OK) == 0)
6061 read_specs (specs_file, TRUE);
6063 /* Process any configure-time defaults specified for the command line
6064 options, via OPTION_DEFAULT_SPECS. */
6065 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6066 do_option_spec (option_default_specs[i].name,
6067 option_default_specs[i].spec);
6069 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6070 of the command line. */
6072 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6073 do_self_spec (driver_self_specs[i]);
6075 /* If not cross-compiling, look for executables in the standard
6077 if (*cross_compile == '0')
6079 if (*md_exec_prefix)
6081 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6082 PREFIX_PRIORITY_LAST, 0, NULL, 0);
6086 /* Process sysroot_suffix_spec. */
6087 if (*sysroot_suffix_spec != 0
6088 && do_spec_2 (sysroot_suffix_spec) == 0)
6090 if (argbuf_index > 1)
6091 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC.");
6092 else if (argbuf_index == 1)
6093 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6096 /* Process sysroot_hdrs_suffix_spec. */
6097 if (*sysroot_hdrs_suffix_spec != 0
6098 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6100 if (argbuf_index > 1)
6101 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC.");
6102 else if (argbuf_index == 1)
6103 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6106 /* Look for startfiles in the standard places. */
6107 if (*startfile_prefix_spec != 0
6108 && do_spec_2 (startfile_prefix_spec) == 0
6109 && do_spec_1 (" ", 0, NULL) == 0)
6112 for (ndx = 0; ndx < argbuf_index; ndx++)
6113 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6114 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6116 /* We should eventually get rid of all these and stick to
6117 startfile_prefix_spec exclusively. */
6118 else if (*cross_compile == '0' || target_system_root)
6120 if (*md_exec_prefix)
6121 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
6122 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6124 if (*md_startfile_prefix)
6125 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6126 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6128 if (*md_startfile_prefix_1)
6129 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6130 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6132 /* If standard_startfile_prefix is relative, base it on
6133 standard_exec_prefix. This lets us move the installed tree
6134 as a unit. If GCC_EXEC_PREFIX is defined, base
6135 standard_startfile_prefix on that as well.
6137 If the prefix is relative, only search it for native compilers;
6138 otherwise we will search a directory containing host libraries. */
6139 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6140 add_sysrooted_prefix (&startfile_prefixes,
6141 standard_startfile_prefix, "BINUTILS",
6142 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6143 else if (*cross_compile == '0')
6145 if (gcc_exec_prefix)
6146 add_prefix (&startfile_prefixes,
6147 concat (gcc_exec_prefix, machine_suffix,
6148 standard_startfile_prefix, NULL),
6149 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6150 add_prefix (&startfile_prefixes,
6151 concat (standard_exec_prefix,
6153 standard_startfile_prefix, NULL),
6154 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6157 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1,
6158 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6159 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2,
6160 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6161 #if 0 /* Can cause surprises, and one can use -B./ instead. */
6162 add_prefix (&startfile_prefixes, "./", NULL,
6163 PREFIX_PRIORITY_LAST, 1, NULL, 0);
6167 /* Process any user specified specs in the order given on the command
6169 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6171 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6173 read_specs (filename ? filename : uptr->filename, FALSE);
6176 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6177 if (gcc_exec_prefix)
6178 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6179 spec_version, dir_separator_str, NULL);
6181 /* Now we have the specs.
6182 Set the `valid' bits for switches that match anything in any spec. */
6184 validate_all_switches ();
6186 /* Now that we have the switches and the specs, set
6187 the subdirectory based on the options. */
6188 set_multilib_dir ();
6190 /* Warn about any switches that no pass was interested in. */
6192 for (i = 0; (int) i < n_switches; i++)
6193 if (! switches[i].validated)
6194 error ("unrecognized option `-%s'", switches[i].part1);
6196 /* Obey some of the options. */
6198 if (print_search_dirs)
6200 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6201 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6202 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6206 if (print_file_name)
6208 printf ("%s\n", find_file (print_file_name));
6212 if (print_prog_name)
6214 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6215 printf ("%s\n", (newname ? newname : print_prog_name));
6219 if (print_multi_lib)
6221 print_multilib_info ();
6225 if (print_multi_directory)
6227 if (multilib_dir == NULL)
6230 printf ("%s\n", multilib_dir);
6234 if (print_multi_os_directory)
6236 if (multilib_os_dir == NULL)
6239 printf ("%s\n", multilib_os_dir);
6243 if (target_help_flag)
6245 /* Print if any target specific options. */
6247 /* We do not exit here. Instead we have created a fake input file
6248 called 'target-dummy' which needs to be compiled, and we pass this
6249 on to the various sub-processes, along with the --target-help
6253 if (print_help_list)
6259 printf (_("\nFor bug reporting instructions, please see:\n"));
6260 printf ("%s.\n", bug_report_url);
6265 /* We do not exit here. Instead we have created a fake input file
6266 called 'help-dummy' which needs to be compiled, and we pass this
6267 on the various sub-processes, along with the --help switch. */
6275 notice ("Configured with: %s\n", configuration_arguments);
6277 #ifdef THREAD_MODEL_SPEC
6278 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6279 but there's no point in doing all this processing just to get
6280 thread_model back. */
6281 obstack_init (&obstack);
6282 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6283 obstack_1grow (&obstack, '\0');
6284 thrmod = obstack_finish (&obstack);
6286 thrmod = thread_model;
6289 notice ("Thread model: %s\n", thrmod);
6291 /* compiler_version is truncated at the first space when initialized
6292 from version string, so truncate version_string at the first space
6293 before comparing. */
6294 for (n = 0; version_string[n]; n++)
6295 if (version_string[n] == ' ')
6298 if (! strncmp (version_string, compiler_version, n)
6299 && compiler_version[n] == 0)
6300 notice ("gcc version %s\n", version_string);
6302 notice ("gcc driver version %s executing gcc version %s\n",
6303 version_string, compiler_version);
6309 if (n_infiles == added_libraries)
6310 fatal ("no input files");
6312 /* Make a place to record the compiler output file names
6313 that correspond to the input files. */
6316 i += lang_specific_extra_outfiles;
6317 outfiles = xcalloc (i, sizeof (char *));
6319 /* Record which files were specified explicitly as link input. */
6321 explicit_link_files = xcalloc (1, n_infiles);
6325 int lang_n_infiles = 0;
6326 for (i = 0; (int) i < n_infiles; i++)
6328 const char *name = infiles[i].name;
6329 struct compiler *compiler
6330 = lookup_compiler (name, strlen (name), infiles[i].language);
6331 if (compiler == NULL)
6332 error ("%s: linker input file unused because linking not done",
6334 else if (lang_n_infiles > 0 && compiler != input_file_compiler)
6335 fatal ("cannot specify -o with -c or -S and multiple languages");
6339 input_file_compiler = compiler;
6344 for (i = 0; (int) i < (combine_inputs ? 1 : n_infiles); i++)
6346 int this_file_error = 0;
6348 /* Tell do_spec what to substitute for %i. */
6350 input_file_number = i;
6351 set_input (infiles[i].name);
6353 /* Use the same thing in %o, unless cp->spec says otherwise. */
6355 outfiles[i] = input_filename;
6357 /* Figure out which compiler from the file's suffix. */
6359 if (! combine_inputs)
6361 = lookup_compiler (infiles[i].name, input_filename_length,
6362 infiles[i].language);
6364 if (input_file_compiler)
6366 /* Ok, we found an applicable compiler. Run its spec. */
6368 if (input_file_compiler->spec[0] == '#')
6370 error ("%s: %s compiler not installed on this system",
6371 input_filename, &input_file_compiler->spec[1]);
6372 this_file_error = 1;
6376 value = do_spec (input_file_compiler->spec);
6378 this_file_error = 1;
6382 /* If this file's name does not contain a recognized suffix,
6383 record it as explicit linker input. */
6386 explicit_link_files[i] = 1;
6388 /* Clear the delete-on-failure queue, deleting the files in it
6389 if this compilation failed. */
6391 if (this_file_error)
6393 delete_failure_queue ();
6396 /* If this compilation succeeded, don't delete those files later. */
6397 clear_failure_queue ();
6400 /* Reset the output file name to the first input file name, for use
6401 with %b in LINK_SPEC on a target that prefers not to emit a.out
6404 set_input (infiles[0].name);
6406 if (error_count == 0)
6408 /* Make sure INPUT_FILE_NUMBER points to first available open
6410 input_file_number = n_infiles;
6411 if (lang_specific_pre_link ())
6415 /* Determine if there are any linker input files. */
6416 num_linker_inputs = 0;
6417 for (i = 0; (int) i < n_infiles; i++)
6418 if (explicit_link_files[i] || outfiles[i] != NULL)
6419 num_linker_inputs++;
6421 /* Run ld to link all the compiler output files. */
6423 if (num_linker_inputs > 0 && error_count == 0)
6425 int tmp = execution_count;
6427 /* We'll use ld if we can't find collect2. */
6428 if (! strcmp (linker_name_spec, "collect2"))
6430 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0);
6432 linker_name_spec = "ld";
6434 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6436 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6437 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6439 value = do_spec (link_command_spec);
6442 linker_was_run = (tmp != execution_count);
6445 /* If options said don't run linker,
6446 complain about input files to be given to the linker. */
6448 if (! linker_was_run && error_count == 0)
6449 for (i = 0; (int) i < n_infiles; i++)
6450 if (explicit_link_files[i])
6451 error ("%s: linker input file unused because linking not done",
6454 /* Delete some or all of the temporary files we made. */
6457 delete_failure_queue ();
6458 delete_temp_files ();
6460 if (print_help_list)
6462 printf (("\nFor bug reporting instructions, please see:\n"));
6463 printf ("%s\n", bug_report_url);
6466 return (signal_count != 0 ? 2
6467 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6471 /* Find the proper compilation spec for the file name NAME,
6472 whose length is LENGTH. LANGUAGE is the specified language,
6473 or 0 if this file is to be passed to the linker. */
6475 static struct compiler *
6476 lookup_compiler (const char *name, size_t length, const char *language)
6478 struct compiler *cp;
6480 /* If this was specified by the user to be a linker input, indicate that. */
6481 if (language != 0 && language[0] == '*')
6484 /* Otherwise, look for the language, if one is spec'd. */
6487 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6488 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6491 error ("language %s not recognized", language);
6495 /* Look for a suffix. */
6496 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6498 if (/* The suffix `-' matches only the file name `-'. */
6499 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6500 || (strlen (cp->suffix) < length
6501 /* See if the suffix matches the end of NAME. */
6502 && !strcmp (cp->suffix,
6503 name + length - strlen (cp->suffix))
6508 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6509 /* look again, but case-insensitively this time. */
6511 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6513 if (/* The suffix `-' matches only the file name `-'. */
6514 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6515 || (strlen (cp->suffix) < length
6516 /* See if the suffix matches the end of NAME. */
6517 && ((!strcmp (cp->suffix,
6518 name + length - strlen (cp->suffix))
6519 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6520 && !strcasecmp (cp->suffix,
6521 name + length - strlen (cp->suffix)))
6527 if (cp >= compilers)
6529 if (cp->spec[0] != '@')
6530 /* A non-alias entry: return it. */
6533 /* An alias entry maps a suffix to a language.
6534 Search for the language; pass 0 for NAME and LENGTH
6535 to avoid infinite recursion if language not found. */
6536 return lookup_compiler (NULL, 0, cp->spec + 1);
6542 save_string (const char *s, int len)
6544 char *result = xmalloc (len + 1);
6546 memcpy (result, s, len);
6552 pfatal_with_name (const char *name)
6554 perror_with_name (name);
6555 delete_temp_files ();
6560 perror_with_name (const char *name)
6562 error ("%s: %s", name, xstrerror (errno));
6566 pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg)
6570 int save_errno = errno;
6572 /* Space for trailing '\0' is in %s. */
6573 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
6574 sprintf (msg, errmsg_fmt, errmsg_arg);
6580 pfatal_with_name (errmsg_fmt);
6583 /* Output an error message and exit. */
6588 fatal ("internal gcc abort");
6591 /* Output an error message and exit. */
6594 fatal (const char *msgid, ...)
6598 va_start (ap, msgid);
6600 fprintf (stderr, "%s: ", programname);
6601 vfprintf (stderr, _(msgid), ap);
6603 fprintf (stderr, "\n");
6604 delete_temp_files ();
6609 error (const char *msgid, ...)
6613 va_start (ap, msgid);
6614 fprintf (stderr, "%s: ", programname);
6615 vfprintf (stderr, _(msgid), ap);
6618 fprintf (stderr, "\n");
6622 notice (const char *msgid, ...)
6626 va_start (ap, msgid);
6627 vfprintf (stderr, _(msgid), ap);
6632 validate_switches_from_spec (const char *spec)
6634 const char *p = spec;
6637 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6638 /* We have a switch spec. */
6639 p = validate_switches (p + 1);
6643 validate_all_switches (void)
6645 struct compiler *comp;
6646 struct spec_list *spec;
6648 for (comp = compilers; comp->spec; comp++)
6649 validate_switches_from_spec (comp->spec);
6651 /* Look through the linked list of specs read from the specs file. */
6652 for (spec = specs; spec; spec = spec->next)
6653 validate_switches_from_spec (*spec->ptr_spec);
6655 validate_switches_from_spec (link_command_spec);
6658 /* Look at the switch-name that comes after START
6659 and mark as valid all supplied switches that match it. */
6662 validate_switches (const char *start)
6664 const char *p = start;
6668 bool suffix = false;
6669 bool starred = false;
6671 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6684 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
6685 || *p == ',' || *p == '.' || *p == '@')
6690 starred = true, p++;
6696 /* Mark all matching switches as valid. */
6697 for (i = 0; i < n_switches; i++)
6698 if (!strncmp (switches[i].part1, atom, len)
6699 && (starred || switches[i].part1[len] == 0))
6700 switches[i].validated = 1;
6704 if (*p && (p[-1] == '|' || p[-1] == '&'))
6707 if (*p && p[-1] == ':')
6709 while (*p && *p != ';' && *p != '}')
6714 if (*p == '{' || *p == '<')
6715 p = validate_switches (p+1);
6716 else if (p[0] == 'W' && p[1] == '{')
6717 p = validate_switches (p+2);
6724 if (*p && p[-1] == ';')
6738 static struct mdswitchstr *mdswitches;
6739 static int n_mdswitches;
6741 /* Check whether a particular argument was used. The first time we
6742 canonicalize the switches to keep only the ones we care about. */
6745 used_arg (const char *p, int len)
6750 const char *replace;
6755 static struct mswitchstr *mswitches;
6756 static int n_mswitches;
6761 struct mswitchstr *matches;
6765 /* Break multilib_matches into the component strings of string
6766 and replacement string. */
6767 for (q = multilib_matches; *q != '\0'; q++)
6771 matches = alloca ((sizeof (struct mswitchstr)) * cnt);
6773 q = multilib_matches;
6783 matches[i].len = q - matches[i].str;
6785 matches[i].replace = ++q;
6786 while (*q != ';' && *q != '\0')
6792 matches[i].rep_len = q - matches[i].replace;
6798 /* Now build a list of the replacement string for switches that we care
6799 about. Make sure we allocate at least one entry. This prevents
6800 xmalloc from calling fatal, and prevents us from re-executing this
6803 = xmalloc (sizeof (struct mswitchstr)
6804 * (n_mdswitches + (n_switches ? n_switches : 1)));
6805 for (i = 0; i < n_switches; i++)
6807 int xlen = strlen (switches[i].part1);
6808 for (j = 0; j < cnt; j++)
6809 if (xlen == matches[j].len
6810 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6812 mswitches[n_mswitches].str = matches[j].replace;
6813 mswitches[n_mswitches].len = matches[j].rep_len;
6814 mswitches[n_mswitches].replace = (char *) 0;
6815 mswitches[n_mswitches].rep_len = 0;
6821 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
6822 on the command line nor any options mutually incompatible with
6824 for (i = 0; i < n_mdswitches; i++)
6828 for (q = multilib_options; *q != '\0'; q++)
6834 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
6835 || strchr (" /", q[mdswitches[i].len]) == NULL)
6837 while (*q != ' ' && *q != '/' && *q != '\0')
6844 if (*q != ' ' && *q != '\0')
6846 while (*r != ' ' && *r != '\0')
6849 while (*q != ' ' && *q != '/' && *q != '\0')
6852 if (used_arg (r, q - r))
6857 mswitches[n_mswitches].str = mdswitches[i].str;
6858 mswitches[n_mswitches].len = mdswitches[i].len;
6859 mswitches[n_mswitches].replace = (char *) 0;
6860 mswitches[n_mswitches].rep_len = 0;
6873 for (i = 0; i < n_mswitches; i++)
6874 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6881 default_arg (const char *p, int len)
6885 for (i = 0; i < n_mdswitches; i++)
6886 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
6892 /* Work out the subdirectory to use based on the options. The format of
6893 multilib_select is a list of elements. Each element is a subdirectory
6894 name followed by a list of options followed by a semicolon. The format
6895 of multilib_exclusions is the same, but without the preceding
6896 directory. First gcc will check the exclusions, if none of the options
6897 beginning with an exclamation point are present, and all of the other
6898 options are present, then we will ignore this completely. Passing
6899 that, gcc will consider each multilib_select in turn using the same
6900 rules for matching the options. If a match is found, that subdirectory
6904 set_multilib_dir (void)
6907 unsigned int this_path_len;
6908 const char *this_path, *this_arg;
6909 const char *start, *end;
6911 int ok, ndfltok, first;
6914 start = multilib_defaults;
6915 while (*start == ' ' || *start == '\t')
6917 while (*start != '\0')
6920 while (*start != ' ' && *start != '\t' && *start != '\0')
6922 while (*start == ' ' || *start == '\t')
6930 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches);
6931 for (start = multilib_defaults; *start != '\0'; start = end + 1)
6933 while (*start == ' ' || *start == '\t')
6939 for (end = start + 1;
6940 *end != ' ' && *end != '\t' && *end != '\0'; end++)
6943 obstack_grow (&multilib_obstack, start, end - start);
6944 obstack_1grow (&multilib_obstack, 0);
6945 mdswitches[i].str = obstack_finish (&multilib_obstack);
6946 mdswitches[i++].len = end - start;
6953 p = multilib_exclusions;
6956 /* Ignore newlines. */
6963 /* Check the arguments. */
6977 while (*p != ' ' && *p != ';')
6984 if (*this_arg != '!')
6992 ok = used_arg (this_arg, p - this_arg);
7007 p = multilib_select;
7010 /* Ignore newlines. */
7017 /* Get the initial path. */
7025 this_path_len = p - this_path;
7027 /* Check the arguments. */
7043 while (*p != ' ' && *p != ';')
7050 if (*this_arg != '!')
7058 /* If this is a default argument, we can just ignore it.
7059 This is true even if this_arg begins with '!'. Beginning
7060 with '!' does not mean that this argument is necessarily
7061 inappropriate for this library: it merely means that
7062 there is a more specific library which uses this
7063 argument. If this argument is a default, we need not
7064 consider that more specific library. */
7065 ok = used_arg (this_arg, p - this_arg);
7072 if (default_arg (this_arg, p - this_arg))
7081 if (this_path_len != 1
7082 || this_path[0] != '.')
7084 char *new_multilib_dir = xmalloc (this_path_len + 1);
7087 strncpy (new_multilib_dir, this_path, this_path_len);
7088 new_multilib_dir[this_path_len] = '\0';
7089 q = strchr (new_multilib_dir, ':');
7092 multilib_dir = new_multilib_dir;
7099 const char *q = this_path, *end = this_path + this_path_len;
7101 while (q < end && *q != ':')
7105 char *new_multilib_os_dir = xmalloc (end - q);
7106 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7107 new_multilib_os_dir[end - q - 1] = '\0';
7108 multilib_os_dir = new_multilib_os_dir;
7116 if (multilib_dir == NULL && multilib_os_dir != NULL
7117 && strcmp (multilib_os_dir, ".") == 0)
7119 free ((char *) multilib_os_dir);
7120 multilib_os_dir = NULL;
7122 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7123 multilib_os_dir = multilib_dir;
7126 /* Print out the multiple library subdirectory selection
7127 information. This prints out a series of lines. Each line looks
7128 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7129 required. Only the desired options are printed out, the negative
7130 matches. The options are print without a leading dash. There are
7131 no spaces to make it easy to use the information in the shell.
7132 Each subdirectory is printed only once. This assumes the ordering
7133 generated by the genmultilib script. Also, we leave out ones that match
7137 print_multilib_info (void)
7139 const char *p = multilib_select;
7140 const char *last_path = 0, *this_path;
7142 unsigned int last_path_len = 0;
7147 /* Ignore newlines. */
7154 /* Get the initial path. */
7163 /* When --disable-multilib was used but target defines
7164 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7165 to find multilib_os_dir, so skip them from output. */
7166 if (this_path[0] == '.' && this_path[1] == ':')
7169 /* Check for matches with the multilib_exclusions. We don't bother
7170 with the '!' in either list. If any of the exclusion rules match
7171 all of its options with the select rule, we skip it. */
7173 const char *e = multilib_exclusions;
7174 const char *this_arg;
7179 /* Ignore newlines. */
7186 /* Check the arguments. */
7203 while (*e != ' ' && *e != ';')
7214 int len = e - this_arg;
7221 while (*q != ' ' && *q != ';')
7228 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
7229 default_arg (this_arg, e - this_arg))
7259 /* If this is a duplicate, skip it. */
7260 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len
7261 && ! strncmp (last_path, this_path, last_path_len));
7263 last_path = this_path;
7264 last_path_len = p - this_path;
7267 /* If this directory requires any default arguments, we can skip
7268 it. We will already have printed a directory identical to
7269 this one which does not require that default argument. */
7287 while (*q != ' ' && *q != ';')
7295 && default_arg (arg, q - arg))
7310 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7329 use_arg = *p != '!';
7334 while (*p != ' ' && *p != ';')
7349 /* If there are extra options, print them now. */
7350 if (multilib_extra && *multilib_extra)
7352 int print_at = TRUE;
7355 for (q = multilib_extra; *q != '\0'; q++)
7376 /* if-exists built-in spec function.
7378 Checks to see if the file specified by the absolute pathname in
7379 ARGS exists. Returns that pathname if found.
7381 The usual use for this function is to check for a library file
7382 (whose name has been expanded with %s). */
7385 if_exists_spec_function (int argc, const char **argv)
7387 /* Must have only one argument. */
7388 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7394 /* if-exists-else built-in spec function.
7396 This is like if-exists, but takes an additional argument which
7397 is returned if the first argument does not exist. */
7400 if_exists_else_spec_function (int argc, const char **argv)
7402 /* Must have exactly two arguments. */
7406 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))