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 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(). */
76 #if ! defined( SIGCHLD ) && defined( SIGCLD )
77 # define SIGCHLD SIGCLD
85 #define exit __posix_exit
88 #ifdef HAVE_SYS_RESOURCE_H
89 #include <sys/resource.h>
91 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
92 extern int getrusage PARAMS ((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
100 #define TARGET_EXECUTABLE_SUFFIX ""
103 /* By default there is no special suffix for host executables. */
104 #ifdef HOST_EXECUTABLE_SUFFIX
105 #define HAVE_HOST_EXECUTABLE_SUFFIX
107 #define HOST_EXECUTABLE_SUFFIX ""
110 /* By default, the suffix for target object files is ".o". */
111 #ifdef TARGET_OBJECT_SUFFIX
112 #define HAVE_TARGET_OBJECT_SUFFIX
114 #define TARGET_OBJECT_SUFFIX ".o"
118 /* FIXME: the location independence code for VMS is hairier than this,
119 and hasn't been written. */
125 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
127 #define obstack_chunk_alloc xmalloc
128 #define obstack_chunk_free free
130 #ifndef GET_ENV_PATH_LIST
131 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
134 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
135 #ifndef LIBRARY_PATH_ENV
136 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
140 #define kill(p,s) raise(s)
143 /* If a stage of compilation returns an exit status >= 1,
144 compilation of that file ceases. */
146 #define MIN_FATAL_STATUS 1
148 /* Flag saying to pass the greatest exit code returned by a sub-process
149 to the calling program. */
150 static int pass_exit_codes;
152 /* Definition of string containing the arguments given to configure. */
153 #include "configargs.h"
155 /* Flag saying to print the directories gcc will search through looking for
156 programs, libraries, etc. */
158 static int print_search_dirs;
160 /* Flag saying to print the full filename of this file
161 as found through our usual search mechanism. */
163 static const char *print_file_name = NULL;
165 /* As print_file_name, but search for executable file. */
167 static const char *print_prog_name = NULL;
169 /* Flag saying to print the relative path we'd use to
170 find libgcc.a given the current compiler flags. */
172 static int print_multi_directory;
174 /* Flag saying to print the list of subdirectories and
175 compiler flags used to select them in a standard form. */
177 static int print_multi_lib;
179 /* Flag saying to print the command line options understood by gcc and its
182 static int print_help_list;
184 /* Flag indicating whether we should print the command and arguments */
186 static int verbose_flag;
188 /* Flag indicating to print target specific command line options. */
190 static int target_help_flag;
192 /* Flag indicating whether we should report subprocess execution times
193 (if this is supported by the system - see pexecute.c). */
195 static int report_times;
197 /* Nonzero means write "temp" files in source directory
198 and use the source file's name in them, and don't delete them. */
200 static int save_temps_flag;
202 /* The compiler version. */
204 static const char *compiler_version;
206 /* The target version specified with -V */
208 static const char *spec_version = DEFAULT_TARGET_VERSION;
210 /* The target machine specified with -b. */
212 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
214 /* Nonzero if cross-compiling.
215 When -b is used, the value comes from the `specs' file. */
218 static const char *cross_compile = "1";
220 static const char *cross_compile = "0";
223 #ifdef MODIFY_TARGET_NAME
225 /* Information on how to alter the target name based on a command-line
226 switch. The only case we support now is simply appending or deleting a
227 string to or from the end of the first part of the configuration name. */
229 const struct modify_target
231 const char *const sw;
232 const enum add_del {ADD, DELETE} add_del;
233 const char *const str;
235 modify_target[] = MODIFY_TARGET_NAME;
238 /* The number of errors that have occurred; the link phase will not be
239 run if this is non-zero. */
240 static int error_count = 0;
242 /* Greatest exit code of sub-processes that has been encountered up to
244 static int greatest_status = 1;
246 /* This is the obstack which we use to allocate many strings. */
248 static struct obstack obstack;
250 /* This is the obstack to build an environment variable to pass to
251 collect2 that describes all of the relevant switches of what to
252 pass the compiler in building the list of pointers to constructors
255 static struct obstack collect_obstack;
257 /* These structs are used to collect resource usage information for
259 #ifdef HAVE_GETRUSAGE
260 static struct rusage rus, prus;
263 /* Forward declaration for prototypes. */
266 static void init_spec PARAMS ((void));
268 static char **split_directories PARAMS ((const char *, int *));
269 static void free_split_directories PARAMS ((char **));
270 static char *make_relative_prefix PARAMS ((const char *, const char *, const char *));
272 static void store_arg PARAMS ((const char *, int, int));
273 static char *load_specs PARAMS ((const char *));
274 static void read_specs PARAMS ((const char *, int));
275 static void set_spec PARAMS ((const char *, const char *));
276 static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
277 static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
278 static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
279 static int access_check PARAMS ((const char *, int));
280 static char *find_a_file PARAMS ((struct path_prefix *, const char *, int));
281 static void add_prefix PARAMS ((struct path_prefix *, const char *,
282 const char *, int, int, int *));
283 static void translate_options PARAMS ((int *, const char *const **));
284 static char *skip_whitespace PARAMS ((char *));
285 static void delete_if_ordinary PARAMS ((const char *));
286 static void delete_temp_files PARAMS ((void));
287 static void delete_failure_queue PARAMS ((void));
288 static void clear_failure_queue PARAMS ((void));
289 static int check_live_switch PARAMS ((int, int));
290 static const char *handle_braces PARAMS ((const char *));
291 static char *save_string PARAMS ((const char *, int));
292 static int do_spec_1 PARAMS ((const char *, int, const char *));
293 static const char *find_file PARAMS ((const char *));
294 static int is_directory PARAMS ((const char *, const char *, int));
295 static void validate_switches PARAMS ((const char *));
296 static void validate_all_switches PARAMS ((void));
297 static void give_switch PARAMS ((int, int, int));
298 static int used_arg PARAMS ((const char *, int));
299 static int default_arg PARAMS ((const char *, int));
300 static void set_multilib_dir PARAMS ((void));
301 static void print_multilib_info PARAMS ((void));
302 static void perror_with_name PARAMS ((const char *));
303 static void pfatal_pexecute PARAMS ((const char *, const char *))
305 static void notice PARAMS ((const char *, ...))
307 static void display_help PARAMS ((void));
308 static void add_preprocessor_option PARAMS ((const char *, int));
309 static void add_assembler_option PARAMS ((const char *, int));
310 static void add_linker_option PARAMS ((const char *, int));
311 static void process_command PARAMS ((int, const char *const *));
312 static int execute PARAMS ((void));
313 static void clear_args PARAMS ((void));
314 static void fatal_error PARAMS ((int));
315 static void set_input PARAMS ((const char *));
316 #ifdef ENABLE_SHARED_LIBGCC
317 static void init_gcc_specs PARAMS ((struct obstack *,
321 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
322 static const char *convert_filename PARAMS ((const char *, int));
325 /* The Specs Language
327 Specs are strings containing lines, each of which (if not blank)
328 is made up of a program name, and arguments separated by spaces.
329 The program name must be exact and start from root, since no path
330 is searched and it is unreliable to depend on the current working directory.
331 Redirection of input or output is not supported; the subprograms must
332 accept filenames saying what files to read and write.
334 In addition, the specs can contain %-sequences to substitute variable text
335 or for conditional text. Here is a table of all defined %-sequences.
336 Note that spaces are not generated automatically around the results of
337 expanding these sequences; therefore, you can concatenate them together
338 or with constant text in a single argument.
340 %% substitute one % into the program name or argument.
341 %i substitute the name of the input file being processed.
342 %b substitute the basename of the input file being processed.
343 This is the substring up to (and not including) the last period
344 and not including the directory.
345 %B same as %b, but include the file suffix (text after the last period).
347 substitute a file name that has suffix SUFFIX and is chosen
348 once per compilation, and mark the argument a la %d. To reduce
349 exposure to denial-of-service attacks, the file name is now
350 chosen in a way that is hard to predict even when previously
351 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
352 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
353 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
354 had been pre-processed. Previously, %g was simply substituted
355 with a file name chosen once per compilation, without regard
356 to any appended suffix (which was therefore treated just like
357 ordinary text), making such attacks more likely to succeed.
359 like %g, but generates a new temporary file name even if %uSUFFIX
362 substitutes the last file name generated with %uSUFFIX, generating a
363 new one if there is no such last file name. In the absence of any
364 %uSUFFIX, this is just like %gSUFFIX, except they don't share
365 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
366 would involve the generation of two distinct file names, one
367 for each `%g.s' and another for each `%U.s'. Previously, %U was
368 simply substituted with a file name chosen for the previous %u,
369 without regard to any appended suffix.
371 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
372 writable, and if save-temps is off; otherwise, substitute the name
373 of a temporary file, just like %u. This temporary file is not
374 meant for communication between processes, but rather as a junk
377 substitutes .SUFFIX for the suffixes of a matched switch's args when
378 it is subsequently output with %*. SUFFIX is terminated by the next
380 %d marks the argument containing or following the %d as a
381 temporary file name, so that that file will be deleted if CC exits
382 successfully. Unlike %g, this contributes no text to the argument.
383 %w marks the argument containing or following the %w as the
384 "output file" of this compilation. This puts the argument
385 into the sequence of arguments that %o will substitute later.
387 like %{...} but mark last argument supplied within
388 as a file to be deleted on failure.
389 %o substitutes the names of all the output files, with spaces
390 automatically placed around them. You should write spaces
391 around the %o as well or the results are undefined.
392 %o is for use in the specs for running the linker.
393 Input files whose names have no recognized suffix are not compiled
394 at all, but they are included among the output files, so they will
396 %O substitutes the suffix for object files. Note that this is
397 handled specially when it immediately follows %g, %u, or %U
398 (with or without a suffix argument) because of the need for
399 those to form complete file names. The handling is such that
400 %O is treated exactly as if it had already been substituted,
401 except that %g, %u, and %U do not currently support additional
402 SUFFIX characters following %O as they would following, for
404 %p substitutes the standard macro predefinitions for the
405 current target machine. Use this when running cpp.
406 %P like %p, but puts `__' before and after the name of each macro.
407 (Except macros that already have __.)
409 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
410 %s current argument is the name of a library or startup file of some sort.
411 Search for that file in a standard list of directories
412 and substitute the full name found.
413 %eSTR Print STR as an error message. STR is terminated by a newline.
414 Use this when inconsistent options are detected.
415 %nSTR Print STR as an notice. STR is terminated by a newline.
416 %x{OPTION} Accumulate an option for %X.
417 %X Output the accumulated linker options specified by compilations.
418 %Y Output the accumulated assembler options specified by compilations.
419 %Z Output the accumulated preprocessor options specified by compilations.
420 %v1 Substitute the major version number of GCC.
421 (For version 2.5.3, this is 2.)
422 %v2 Substitute the minor version number of GCC.
423 (For version 2.5.3, this is 5.)
424 %v3 Substitute the patch level number of GCC.
425 (For version 2.5.3, this is 3.)
426 %a process ASM_SPEC as a spec.
427 This allows config.h to specify part of the spec for running as.
428 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
429 used here. This can be used to run a post-processor after the
430 assembler has done its job.
431 %D Dump out a -L option for each directory in startfile_prefixes.
432 If multilib_dir is set, extra entries are generated with it affixed.
433 %l process LINK_SPEC as a spec.
434 %L process LIB_SPEC as a spec.
435 %G process LIBGCC_SPEC as a spec.
436 %M output multilib_dir with directory separators replaced with "_";
437 if multilib_dir is not set or is ".", output "".
438 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
439 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
440 %c process SIGNED_CHAR_SPEC as a spec.
441 %C process CPP_SPEC as a spec.
442 %1 process CC1_SPEC as a spec.
443 %2 process CC1PLUS_SPEC as a spec.
444 %| output "-" if the input for the current command is coming from a pipe.
445 %* substitute the variable part of a matched option. (See below.)
446 Note that each comma in the substituted string is replaced by
448 %{S} substitutes the -S switch, if that switch was given to CC.
449 If that switch was not specified, this substitutes nothing.
450 Here S is a metasyntactic variable.
451 %{S*} substitutes all the switches specified to CC whose names start
452 with -S. This is used for -o, -I, etc; switches that take
453 arguments. CC considers `-o foo' as being one switch whose
454 name starts with `o'. %{o*} would substitute this text,
455 including the space; thus, two arguments would be generated.
456 %{^S*} likewise, but don't put a blank between a switch and any args.
457 %{S*&T*} likewise, but preserve order of S and T options (the order
458 of S and T in the spec is not significant). Can be any number
459 of ampersand-separated variables; for each the wild card is
460 optional. Useful for CPP as %{D*&U*&A*}.
461 %{S*:X} substitutes X if one or more switches whose names start with -S are
462 specified to CC. Note that the tail part of the -S option
463 (i.e. the part matched by the `*') will be substituted for each
464 occurrence of %* within X.
465 %{<S} remove all occurrences of -S from the command line.
466 Note - this option is position dependent. % commands in the
467 spec string before this option will see -S, % commands in the
468 spec string after this option will not.
469 %{S:X} substitutes X, but only if the -S switch was given to CC.
470 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
471 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
472 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
473 %{.S:X} substitutes X, but only if processing a file with suffix S.
474 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
475 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
476 combined with ! and . as above binding stronger than the OR.
477 %(Spec) processes a specification defined in a specs file as *Spec:
478 %[Spec] as above, but put __ around -D arguments
480 The conditional text X in a %{S:X} or %{!S:X} construct may contain
481 other nested % constructs or spaces, or even newlines. They are
482 processed as usual, as described above.
484 The -O, -f, -m, and -W switches are handled specifically in these
485 constructs. If another value of -O or the negated form of a -f, -m, or
486 -W switch is found later in the command line, the earlier switch
487 value is ignored, except with {S*} where S is just one letter; this
488 passes all matching options.
490 The character | at the beginning of the predicate text is used to indicate
491 that a command should be piped to the following command, but only if -pipe
494 Note that it is built into CC which switches take arguments and which
495 do not. You might think it would be useful to generalize this to
496 allow each compiler's spec to say which switches take arguments. But
497 this cannot be done in a consistent fashion. CC cannot even decide
498 which input files have been specified without knowing which switches
499 take arguments, and it must know which input files to compile in order
500 to tell which compilers to run.
502 CC also knows implicitly that arguments starting in `-l' are to be
503 treated as compiler output files, and passed to the linker in their
504 proper position among the other output files. */
506 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
508 /* config.h can define ASM_SPEC to provide extra args to the assembler
509 or extra switch-translations. */
514 /* config.h can define ASM_FINAL_SPEC to run a post processor after
515 the assembler has run. */
516 #ifndef ASM_FINAL_SPEC
517 #define ASM_FINAL_SPEC ""
520 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
521 or extra switch-translations. */
526 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
527 or extra switch-translations. */
532 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
533 or extra switch-translations. */
535 #define CC1PLUS_SPEC ""
538 /* config.h can define LINK_SPEC to provide extra args to the linker
539 or extra switch-translations. */
544 /* config.h can define LIB_SPEC to override the default libraries. */
546 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
549 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
552 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
553 /* Have gcc do the search for libgcc.a. */
554 #define LIBGCC_SPEC "libgcc.a%s"
556 #define LIBGCC_SPEC "-lgcc"
560 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
561 #ifndef STARTFILE_SPEC
562 #define STARTFILE_SPEC \
563 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
566 /* config.h can define SWITCHES_NEED_SPACES to control which options
567 require spaces between the option and the argument. */
568 #ifndef SWITCHES_NEED_SPACES
569 #define SWITCHES_NEED_SPACES ""
572 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
574 #define ENDFILE_SPEC ""
577 /* This spec is used for telling cpp whether char is signed or not. */
578 #ifndef SIGNED_CHAR_SPEC
579 /* Use #if rather than ?:
580 because MIPS C compiler rejects like ?: in initializers. */
581 #if DEFAULT_SIGNED_CHAR
582 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
584 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
589 #define LINKER_NAME "collect2"
592 /* Here is the spec for running the linker, after compiling all files. */
594 /* -u* was put back because both BSD and SysV seem to support it. */
595 /* %{static:} simply prevents an error message if the target machine
596 doesn't handle -static. */
597 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
598 scripts which exist in user specified directories, or in standard
600 #ifndef LINK_COMMAND_SPEC
601 #define LINK_COMMAND_SPEC "\
602 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
603 %(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r} %{s} %{t}\
604 %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
605 %{static:} %{L*} %(link_libgcc) %o %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
606 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
609 #ifndef LINK_LIBGCC_SPEC
610 # ifdef LINK_LIBGCC_SPECIAL
611 /* Don't generate -L options for startfile prefix list. */
612 # define LINK_LIBGCC_SPEC ""
614 /* Do generate them. */
615 # define LINK_LIBGCC_SPEC "%D"
619 static const char *cpp_spec = CPP_SPEC;
620 static const char *cpp_predefines = CPP_PREDEFINES;
621 static const char *cc1_spec = CC1_SPEC;
622 static const char *cc1plus_spec = CC1PLUS_SPEC;
623 static const char *signed_char_spec = SIGNED_CHAR_SPEC;
624 static const char *asm_spec = ASM_SPEC;
625 static const char *asm_final_spec = ASM_FINAL_SPEC;
626 static const char *link_spec = LINK_SPEC;
627 static const char *lib_spec = LIB_SPEC;
628 static const char *libgcc_spec = LIBGCC_SPEC;
629 static const char *endfile_spec = ENDFILE_SPEC;
630 static const char *startfile_spec = STARTFILE_SPEC;
631 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
632 static const char *linker_name_spec = LINKER_NAME;
633 static const char *link_command_spec = LINK_COMMAND_SPEC;
634 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
636 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
637 There should be no need to override these in target dependent files,
638 but we need to copy them to the specs file so that newer versions
639 of the GCC driver can correctly drive older tool chains with the
640 appropriate -B options. */
642 static const char *trad_capable_cpp =
643 "%{traditional|ftraditional|traditional-cpp:trad}cpp0";
645 static const char *cpp_options =
646 "%{C:%{!E:%eGNU C does not support -C without using -E}}\
647 %{std*} %{nostdinc*}\
648 %{C} %{v} %{I*} %{P} %{$} %I\
649 %{MD:-M -MF %W{!o: %b.d}%W{o*:%.d%*}}\
650 %{MMD:-MM -MF %W{!o: %b.d}%W{o*:%.d%*}}\
651 %{M} %{MM} %W{MF*} %{MG} %{MP} %{MQ*} %{MT*} %{M|MD|MM|MMD:%{o*:-MQ %*}}\
652 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
653 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
654 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
655 %{fno-inline|O0|!O*:-D__NO_INLINE__} %{ffast-math:-D__FAST_MATH__}\
656 %{fshort-wchar:-U__WCHAR_TYPE__ -D__WCHAR_TYPE__=short\\ unsigned\\ int}\
657 %{ffreestanding:-D__STDC_HOSTED__=0} %{fno-hosted:-D__STDC_HOSTED__=0}\
658 %{!ffreestanding:%{!fno-hosted:-D__STDC_HOSTED__=1}}\
659 %{fshow-column} %{fno-show-column}\
660 %{fleading-underscore} %{fno-leading-underscore}\
661 %{fno-operator-names} %{ftabstop=*} %{remap}\
662 %{g3:-dD} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*&U*&A*} %{i*} %Z %i\
665 /* NB: This is shared amongst all front-ends. */
666 static const char *cc1_options =
667 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
668 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
669 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*} %{ansi}\
670 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
671 %{Qn:-fno-ident} %{--help:--help}\
672 %{--target-help:--target-help}\
673 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
674 %{fsyntax-only:-o %j} %{-param*}";
676 static const char *asm_options =
677 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
679 static const char *invoke_as =
680 "%{!S:-o %{|!pipe:%g.s} |\n as %(asm_options) %{!pipe:%g.s} %A }";
682 /* Some compilers have limits on line lengths, and the multilib_select
683 and/or multilib_matches strings can be very long, so we build them at
685 static struct obstack multilib_obstack;
686 static const char *multilib_select;
687 static const char *multilib_matches;
688 static const char *multilib_defaults;
689 static const char *multilib_exclusions;
690 #include "multilib.h"
692 /* Check whether a particular argument is a default argument. */
694 #ifndef MULTILIB_DEFAULTS
695 #define MULTILIB_DEFAULTS { "" }
698 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
702 struct user_specs *next;
703 const char *filename;
706 static struct user_specs *user_specs_head, *user_specs_tail;
708 /* This defines which switch letters take arguments. */
710 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
711 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
712 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
713 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
714 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
715 || (CHAR) == 'B' || (CHAR) == 'b')
717 #ifndef SWITCH_TAKES_ARG
718 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
721 /* This defines which multi-letter switches take arguments. */
723 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
724 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
725 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
726 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
727 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
728 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
729 || !strcmp (STR, "isystem") || !strcmp (STR, "-param") \
730 || !strcmp (STR, "specs") \
731 || !strcmp (STR, "MF") || !strcmp (STR, "MT") || !strcmp (STR, "MQ"))
733 #ifndef WORD_SWITCH_TAKES_ARG
734 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
737 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
738 /* This defines which switches stop a full compilation. */
739 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
740 ((CHAR) == 'c' || (CHAR) == 'S')
742 #ifndef SWITCH_CURTAILS_COMPILATION
743 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
744 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
748 /* Record the mapping from file suffixes for compilation specs. */
752 const char *suffix; /* Use this compiler for input files
753 whose names end in this suffix. */
755 const char *spec; /* To use this compiler, run this spec. */
757 const char *cpp_spec; /* If non-NULL, substitute this spec
758 for `%C', rather than the usual
762 /* Pointer to a vector of `struct compiler' that gives the spec for
763 compiling a file, based on its suffix.
764 A file that does not end in any of these suffixes will be passed
765 unchanged to the loader and nothing else will be done to it.
767 An entry containing two 0s is used to terminate the vector.
769 If multiple entries match a file, the last matching one is used. */
771 static struct compiler *compilers;
773 /* Number of entries in `compilers', not counting the null terminator. */
775 static int n_compilers;
777 /* The default list of file name suffixes and their compilation specs. */
779 static struct compiler default_compilers[] =
781 /* Add lists of suffixes of known languages here. If those languages
782 were not present when we built the driver, we will hit these copies
783 and be given a more meaningful error than "file not used since
784 linking is not done". */
785 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
786 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
787 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
789 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
790 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
791 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
792 {".r", "#Ratfor", 0},
793 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
794 {".ch", "#Chill", 0}, {".chi", "#Chill", 0},
795 {".java", "#Java", 0}, {".class", "#Java", 0},
796 {".zip", "#Java", 0}, {".jar", "#Java", 0},
797 /* Next come the entries for C. */
800 /* cc1 has an integrated ISO C preprocessor. We should invoke the
801 external preprocessor if -save-temps or -traditional is given. */
802 "%{E|M|MM:%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)}\
804 %{save-temps:%(trad_capable_cpp) -lang-c %{ansi:-std=c89}\
805 %(cpp_options) %b.i \n\
806 cc1 -fpreprocessed %b.i %(cc1_options)}\
808 %{traditional|ftraditional|traditional-cpp:\
809 tradcpp0 -lang-c %{ansi:-std=c89} %(cpp_options) %{!pipe:%g.i} |\n\
810 cc1 -fpreprocessed %{!pipe:%g.i} %(cc1_options)}\
811 %{!traditional:%{!ftraditional:%{!traditional-cpp:\
812 cc1 -lang-c %{ansi:-std=c89} %(cpp_options) %(cc1_options)}}}}\
813 %{!fsyntax-only:%(invoke_as)}}}}", 0},
815 "%{!E:%e-E required when input is from standard input}\
816 %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
817 {".h", "@c-header", 0},
819 "%{!E:%eCompilation of header file requested} \
820 %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
821 {".i", "@cpp-output", 0},
823 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
824 {".s", "@assembler", 0},
826 "%{!M:%{!MM:%{!E:%{!S:as %(asm_options) %i %A }}}}", 0},
827 {".S", "@assembler-with-cpp", 0},
828 {"@assembler-with-cpp",
829 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
830 %{!M:%{!MM:%{!E:%(invoke_as)}}}", 0},
832 /* Mark end of table */
836 /* Number of elements in default_compilers, not counting the terminator. */
838 static int n_default_compilers
839 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
841 /* A vector of options to give to the linker.
842 These options are accumulated by %x,
843 and substituted into the linker command with %X. */
844 static int n_linker_options;
845 static char **linker_options;
847 /* A vector of options to give to the assembler.
848 These options are accumulated by -Wa,
849 and substituted into the assembler command with %Y. */
850 static int n_assembler_options;
851 static char **assembler_options;
853 /* A vector of options to give to the preprocessor.
854 These options are accumulated by -Wp,
855 and substituted into the preprocessor command with %Z. */
856 static int n_preprocessor_options;
857 static char **preprocessor_options;
859 /* Define how to map long options into short ones. */
861 /* This structure describes one mapping. */
864 /* The long option's name. */
865 const char *const name;
866 /* The equivalent short option. */
867 const char *const equivalent;
868 /* Argument info. A string of flag chars; NULL equals no options.
869 a => argument required.
870 o => argument optional.
871 j => join argument to equivalent, making one word.
872 * => require other text after NAME as an argument. */
873 const char *const arg_info;
876 /* This is the table of mappings. Mappings are tried sequentially
877 for each option encountered; the first one that matches, wins. */
879 static const struct option_map option_map[] =
881 {"--all-warnings", "-Wall", 0},
882 {"--ansi", "-ansi", 0},
883 {"--assemble", "-S", 0},
884 {"--assert", "-A", "a"},
885 {"--classpath", "-fclasspath=", "aj"},
886 {"--CLASSPATH", "-fCLASSPATH=", "aj"},
887 {"--comments", "-C", 0},
888 {"--compile", "-c", 0},
889 {"--debug", "-g", "oj"},
890 {"--define-macro", "-D", "aj"},
891 {"--dependencies", "-M", 0},
892 {"--dump", "-d", "a"},
893 {"--dumpbase", "-dumpbase", "a"},
894 {"--entry", "-e", 0},
895 {"--extra-warnings", "-W", 0},
896 {"--for-assembler", "-Wa", "a"},
897 {"--for-linker", "-Xlinker", "a"},
898 {"--force-link", "-u", "a"},
899 {"--imacros", "-imacros", "a"},
900 {"--include", "-include", "a"},
901 {"--include-barrier", "-I-", 0},
902 {"--include-directory", "-I", "aj"},
903 {"--include-directory-after", "-idirafter", "a"},
904 {"--include-prefix", "-iprefix", "a"},
905 {"--include-with-prefix", "-iwithprefix", "a"},
906 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
907 {"--include-with-prefix-after", "-iwithprefix", "a"},
908 {"--language", "-x", "a"},
909 {"--library-directory", "-L", "a"},
910 {"--machine", "-m", "aj"},
911 {"--machine-", "-m", "*j"},
912 {"--no-line-commands", "-P", 0},
913 {"--no-precompiled-includes", "-noprecomp", 0},
914 {"--no-standard-includes", "-nostdinc", 0},
915 {"--no-standard-libraries", "-nostdlib", 0},
916 {"--no-warnings", "-w", 0},
917 {"--optimize", "-O", "oj"},
918 {"--output", "-o", "a"},
919 {"--output-class-directory", "-foutput-class-dir=", "ja"},
920 {"--param", "--param", "a"},
921 {"--pedantic", "-pedantic", 0},
922 {"--pedantic-errors", "-pedantic-errors", 0},
923 {"--pipe", "-pipe", 0},
924 {"--prefix", "-B", "a"},
925 {"--preprocess", "-E", 0},
926 {"--print-search-dirs", "-print-search-dirs", 0},
927 {"--print-file-name", "-print-file-name=", "aj"},
928 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
929 {"--print-missing-file-dependencies", "-MG", 0},
930 {"--print-multi-lib", "-print-multi-lib", 0},
931 {"--print-multi-directory", "-print-multi-directory", 0},
932 {"--print-prog-name", "-print-prog-name=", "aj"},
933 {"--profile", "-p", 0},
934 {"--profile-blocks", "-a", 0},
935 {"--quiet", "-q", 0},
936 {"--save-temps", "-save-temps", 0},
937 {"--shared", "-shared", 0},
938 {"--silent", "-q", 0},
939 {"--specs", "-specs=", "aj"},
940 {"--static", "-static", 0},
941 {"--std", "-std=", "aj"},
942 {"--symbolic", "-symbolic", 0},
943 {"--target", "-b", "a"},
944 {"--time", "-time", 0},
945 {"--trace-includes", "-H", 0},
946 {"--traditional", "-traditional", 0},
947 {"--traditional-cpp", "-traditional-cpp", 0},
948 {"--trigraphs", "-trigraphs", 0},
949 {"--undefine-macro", "-U", "aj"},
950 {"--use-version", "-V", "a"},
951 {"--user-dependencies", "-MM", 0},
952 {"--verbose", "-v", 0},
953 {"--version", "-dumpversion", 0},
954 {"--warn-", "-W", "*j"},
955 {"--write-dependencies", "-MD", 0},
956 {"--write-user-dependencies", "-MMD", 0},
961 #ifdef TARGET_OPTION_TRANSLATE_TABLE
962 static const struct {
963 const char *const option_found;
964 const char *const replacements;
965 } target_option_translations[] =
967 TARGET_OPTION_TRANSLATE_TABLE,
972 /* Translate the options described by *ARGCP and *ARGVP.
973 Make a new vector and store it back in *ARGVP,
974 and store its length in *ARGVC. */
977 translate_options (argcp, argvp)
979 const char *const **argvp;
983 const char *const *argv = *argvp;
984 int newvsize = (argc + 2) * 2 * sizeof (const char *);
986 (const char **) xmalloc (newvsize);
990 newv[newindex++] = argv[i++];
994 #ifdef TARGET_OPTION_TRANSLATE_TABLE
998 target_option_translations[tott_idx].option_found;
1001 if (strcmp (target_option_translations[tott_idx].option_found,
1008 for (sp = target_option_translations[tott_idx].replacements;
1015 newvsize += spaces * sizeof (const char *);
1016 newv = (const char **) xrealloc (newv, newvsize);
1018 sp = target_option_translations[tott_idx].replacements;
1027 newv[newindex++] = np;
1028 while (*np != ' ' && *np)
1039 if (target_option_translations[tott_idx].option_found)
1043 /* Translate -- options. */
1044 if (argv[i][0] == '-' && argv[i][1] == '-')
1047 /* Find a mapping that applies to this option. */
1048 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1050 size_t optlen = strlen (option_map[j].name);
1051 size_t arglen = strlen (argv[i]);
1052 size_t complen = arglen > optlen ? optlen : arglen;
1053 const char *arginfo = option_map[j].arg_info;
1058 if (!strncmp (argv[i], option_map[j].name, complen))
1060 const char *arg = 0;
1062 if (arglen < optlen)
1065 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1066 if (strlen (option_map[k].name) >= arglen
1067 && !strncmp (argv[i], option_map[k].name, arglen))
1069 error ("Ambiguous abbreviation %s", argv[i]);
1073 if (k != ARRAY_SIZE (option_map))
1077 if (arglen > optlen)
1079 /* If the option has an argument, accept that. */
1080 if (argv[i][optlen] == '=')
1081 arg = argv[i] + optlen + 1;
1083 /* If this mapping requires extra text at end of name,
1084 accept that as "argument". */
1085 else if (strchr (arginfo, '*') != 0)
1086 arg = argv[i] + optlen;
1088 /* Otherwise, extra text at end means mismatch.
1089 Try other mappings. */
1094 else if (strchr (arginfo, '*') != 0)
1096 error ("Incomplete `%s' option", option_map[j].name);
1100 /* Handle arguments. */
1101 if (strchr (arginfo, 'a') != 0)
1107 error ("Missing argument to `%s' option",
1108 option_map[j].name);
1115 else if (strchr (arginfo, '*') != 0)
1117 else if (strchr (arginfo, 'o') == 0)
1120 error ("Extraneous argument to `%s' option",
1121 option_map[j].name);
1125 /* Store the translation as one argv elt or as two. */
1126 if (arg != 0 && strchr (arginfo, 'j') != 0)
1127 newv[newindex++] = concat (option_map[j].equivalent, arg,
1131 newv[newindex++] = option_map[j].equivalent;
1132 newv[newindex++] = arg;
1135 newv[newindex++] = option_map[j].equivalent;
1143 /* Handle old-fashioned options--just copy them through,
1144 with their arguments. */
1145 else if (argv[i][0] == '-')
1147 const char *p = argv[i] + 1;
1151 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1152 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1153 else if (WORD_SWITCH_TAKES_ARG (p))
1154 nskip += WORD_SWITCH_TAKES_ARG (p);
1155 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
1158 else if (! strcmp (p, "Xlinker"))
1161 /* Watch out for an option at the end of the command line that
1162 is missing arguments, and avoid skipping past the end of the
1164 if (nskip + i > argc)
1169 newv[newindex++] = argv[i++];
1174 /* Ordinary operands, or +e options. */
1175 newv[newindex++] = argv[i++];
1190 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1191 be considered whitespace. */
1192 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1194 else if (*p == '\n' || *p == ' ' || *p == '\t')
1208 /* Structures to keep track of prefixes to try when looking for files. */
1212 const char *prefix; /* String to prepend to the path. */
1213 struct prefix_list *next; /* Next in linked list. */
1214 int require_machine_suffix; /* Don't use without machine_suffix. */
1215 /* 2 means try both machine_suffix and just_machine_suffix. */
1216 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1217 int priority; /* Sort key - priority within list */
1222 struct prefix_list *plist; /* List of prefixes to try */
1223 int max_len; /* Max length of a prefix in PLIST */
1224 const char *name; /* Name of this list (used in config stuff) */
1227 /* List of prefixes to try when looking for executables. */
1229 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1231 /* List of prefixes to try when looking for startup (crt0) files. */
1233 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1235 /* List of prefixes to try when looking for include files. */
1237 static struct path_prefix include_prefixes = { 0, 0, "include" };
1239 /* Suffix to attach to directories searched for commands.
1240 This looks like `MACHINE/VERSION/'. */
1242 static const char *machine_suffix = 0;
1244 /* Suffix to attach to directories searched for commands.
1245 This is just `MACHINE/'. */
1247 static const char *just_machine_suffix = 0;
1249 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1251 static const char *gcc_exec_prefix;
1253 /* Default prefixes to attach to command names. */
1255 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1256 #undef MD_EXEC_PREFIX
1257 #undef MD_STARTFILE_PREFIX
1258 #undef MD_STARTFILE_PREFIX_1
1261 /* If no prefixes defined, use the null string, which will disable them. */
1262 #ifndef MD_EXEC_PREFIX
1263 #define MD_EXEC_PREFIX ""
1265 #ifndef MD_STARTFILE_PREFIX
1266 #define MD_STARTFILE_PREFIX ""
1268 #ifndef MD_STARTFILE_PREFIX_1
1269 #define MD_STARTFILE_PREFIX_1 ""
1272 /* Supply defaults for the standard prefixes. */
1274 #ifndef STANDARD_EXEC_PREFIX
1275 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1277 #ifndef STANDARD_STARTFILE_PREFIX
1278 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1280 #ifndef TOOLDIR_BASE_PREFIX
1281 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1283 #ifndef STANDARD_BINDIR_PREFIX
1284 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1287 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1288 static const char *const standard_exec_prefix_1 = "/usr/lib/gcc/";
1289 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1291 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1292 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1293 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1294 static const char *const standard_startfile_prefix_1 = "/lib/";
1295 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1297 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1298 static const char *tooldir_prefix;
1300 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1302 /* Subdirectory to use for locating libraries. Set by
1303 set_multilib_dir based on the compilation options. */
1305 static const char *multilib_dir;
1307 /* Structure to keep track of the specs that have been defined so far.
1308 These are accessed using %(specname) or %[specname] in a compiler
1313 /* The following 2 fields must be first */
1314 /* to allow EXTRA_SPECS to be initialized */
1315 const char *name; /* name of the spec. */
1316 const char *ptr; /* available ptr if no static pointer */
1318 /* The following fields are not initialized */
1319 /* by EXTRA_SPECS */
1320 const char **ptr_spec; /* pointer to the spec itself. */
1321 struct spec_list *next; /* Next spec in linked list. */
1322 int name_len; /* length of the name */
1323 int alloc_p; /* whether string was allocated */
1326 #define INIT_STATIC_SPEC(NAME,PTR) \
1327 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1329 /* List of statically defined specs. */
1330 static struct spec_list static_specs[] =
1332 INIT_STATIC_SPEC ("asm", &asm_spec),
1333 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1334 INIT_STATIC_SPEC ("asm_options", &asm_options),
1335 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1336 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1337 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1338 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1339 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1340 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1341 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1342 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1343 INIT_STATIC_SPEC ("link", &link_spec),
1344 INIT_STATIC_SPEC ("lib", &lib_spec),
1345 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1346 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1347 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1348 INIT_STATIC_SPEC ("signed_char", &signed_char_spec),
1349 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1350 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1351 INIT_STATIC_SPEC ("version", &compiler_version),
1352 INIT_STATIC_SPEC ("multilib", &multilib_select),
1353 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1354 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1355 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1356 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1357 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1358 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1359 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1360 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1361 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1364 #ifdef EXTRA_SPECS /* additional specs needed */
1365 /* Structure to keep track of just the first two args of a spec_list.
1366 That is all that the EXTRA_SPECS macro gives us. */
1369 const char *const name;
1370 const char *const ptr;
1373 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1374 static struct spec_list *extra_specs = (struct spec_list *) 0;
1377 /* List of dynamically allocates specs that have been defined so far. */
1379 static struct spec_list *specs = (struct spec_list *) 0;
1381 /* Add appropriate libgcc specs to OBSTACK, taking into account
1382 various permutations of -shared-libgcc, -shared, and such. */
1384 #ifdef ENABLE_SHARED_LIBGCC
1386 init_gcc_specs (obstack, shared_name, static_name)
1387 struct obstack *obstack;
1388 const char *shared_name;
1389 const char *static_name;
1393 /* If we see -shared-libgcc, then use the shared version. */
1394 sprintf (buffer, "%%{shared-libgcc:%s %s}", shared_name, static_name);
1395 obstack_grow (obstack, buffer, strlen (buffer));
1396 /* If we see -static-libgcc, then use the static version. */
1397 sprintf (buffer, "%%{static-libgcc:%s}", static_name);
1398 obstack_grow (obstack, buffer, strlen (buffer));
1399 /* Otherwise, if we see -shared, then use the shared version. */
1401 "%%{!shared-libgcc:%%{!static-libgcc:%%{shared:%s %s}}}",
1402 shared_name, static_name);
1403 obstack_grow (obstack, buffer, strlen (buffer));
1404 /* Otherwise, use the static version. */
1406 "%%{!shared-libgcc:%%{!static-libgcc:%%{!shared:%s}}}",
1408 obstack_grow (obstack, buffer, strlen (buffer));
1410 #endif /* ENABLE_SHARED_LIBGCC */
1412 /* Initialize the specs lookup routines. */
1417 struct spec_list *next = (struct spec_list *) 0;
1418 struct spec_list *sl = (struct spec_list *) 0;
1422 return; /* Already initialized. */
1425 notice ("Using builtin specs.\n");
1428 extra_specs = (struct spec_list *)
1429 xcalloc (sizeof (struct spec_list), ARRAY_SIZE (extra_specs_1));
1431 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1433 sl = &extra_specs[i];
1434 sl->name = extra_specs_1[i].name;
1435 sl->ptr = extra_specs_1[i].ptr;
1437 sl->name_len = strlen (sl->name);
1438 sl->ptr_spec = &sl->ptr;
1443 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1445 sl = &static_specs[i];
1450 #ifdef ENABLE_SHARED_LIBGCC
1451 /* ??? If neither -shared-libgcc nor --static-libgcc was
1452 seen, then we should be making an educated guess. Some proposed
1453 heuristics for ELF include:
1455 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1456 program will be doing dynamic loading, which will likely
1457 need the shared libgcc.
1459 (2) If "-ldl", then it's also a fair bet that we're doing
1462 (3) For each ET_DYN we're linking against (either through -lfoo
1463 or /some/path/foo.so), check to see whether it or one of
1464 its dependencies depends on a shared libgcc.
1468 If the runtime is fixed to look for program headers instead
1469 of calling __register_frame_info at all, for each object,
1470 use the shared libgcc if any EH symbol referenced.
1472 If crtstuff is fixed to not invoke __register_frame_info
1473 automatically, for each object, use the shared libgcc if
1474 any non-empty unwind section found.
1476 Doing any of this probably requires invoking an external program to
1477 do the actual object file scanning. */
1479 const char *p = libgcc_spec;
1482 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1483 when given the proper command line arguments. */
1486 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1488 init_gcc_specs (&obstack,
1489 #ifdef NO_SHARED_LIBGCC_MULTILIB
1499 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1501 /* Ug. We don't know shared library extensions. Hope that
1502 systems that use this form don't do shared libraries. */
1503 init_gcc_specs (&obstack,
1504 #ifdef NO_SHARED_LIBGCC_MULTILIB
1516 obstack_1grow (&obstack, *p);
1517 in_sep = (*p == ' ');
1522 obstack_1grow (&obstack, '\0');
1523 libgcc_spec = obstack_finish (&obstack);
1526 #ifdef USE_AS_TRADITIONAL_FORMAT
1527 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1529 static const char tf[] = "--traditional-format ";
1530 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1531 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1532 asm_spec = obstack_finish (&obstack);
1539 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1540 removed; If the spec starts with a + then SPEC is added to the end of the
1544 set_spec (name, spec)
1548 struct spec_list *sl;
1549 const char *old_spec;
1550 int name_len = strlen (name);
1553 /* If this is the first call, initialize the statically allocated specs. */
1556 struct spec_list *next = (struct spec_list *) 0;
1557 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1559 sl = &static_specs[i];
1566 /* See if the spec already exists. */
1567 for (sl = specs; sl; sl = sl->next)
1568 if (name_len == sl->name_len && !strcmp (sl->name, name))
1573 /* Not found - make it. */
1574 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1575 sl->name = xstrdup (name);
1576 sl->name_len = name_len;
1577 sl->ptr_spec = &sl->ptr;
1579 *(sl->ptr_spec) = "";
1584 old_spec = *(sl->ptr_spec);
1585 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1586 ? concat (old_spec, spec + 1, NULL)
1591 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1594 /* Free the old spec. */
1595 if (old_spec && sl->alloc_p)
1596 free ((PTR) old_spec);
1601 /* Accumulate a command (program name and args), and run it. */
1603 /* Vector of pointers to arguments in the current line of specifications. */
1605 static const char **argbuf;
1607 /* Number of elements allocated in argbuf. */
1609 static int argbuf_length;
1611 /* Number of elements in argbuf currently in use (containing args). */
1613 static int argbuf_index;
1615 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1616 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1619 static struct temp_name {
1620 const char *suffix; /* suffix associated with the code. */
1621 int length; /* strlen (suffix). */
1622 int unique; /* Indicates whether %g or %u/%U was used. */
1623 const char *filename; /* associated filename. */
1624 int filename_length; /* strlen (filename). */
1625 struct temp_name *next;
1628 /* Number of commands executed so far. */
1630 static int execution_count;
1632 /* Number of commands that exited with a signal. */
1634 static int signal_count;
1636 /* Name with which this program was invoked. */
1638 static const char *programname;
1640 /* Clear out the vector of arguments (after a command is executed). */
1648 /* Add one argument to the vector at the end.
1649 This is done when a space is seen or at the end of the line.
1650 If DELETE_ALWAYS is nonzero, the arg is a filename
1651 and the file should be deleted eventually.
1652 If DELETE_FAILURE is nonzero, the arg is a filename
1653 and the file should be deleted if this compilation fails. */
1656 store_arg (arg, delete_always, delete_failure)
1658 int delete_always, delete_failure;
1660 if (argbuf_index + 1 == argbuf_length)
1662 = (const char **) xrealloc (argbuf,
1663 (argbuf_length *= 2) * sizeof (const char *));
1665 argbuf[argbuf_index++] = arg;
1666 argbuf[argbuf_index] = 0;
1668 if (delete_always || delete_failure)
1669 record_temp_file (arg, delete_always, delete_failure);
1672 /* Load specs from a file name named FILENAME, replacing occurrences of
1673 various different types of line-endings, \r\n, \n\r and just \r, with
1677 load_specs (filename)
1678 const char *filename;
1682 struct stat statbuf;
1689 notice ("Reading specs from %s\n", filename);
1691 /* Open and stat the file. */
1692 desc = open (filename, O_RDONLY, 0);
1694 pfatal_with_name (filename);
1695 if (stat (filename, &statbuf) < 0)
1696 pfatal_with_name (filename);
1698 /* Read contents of file into BUFFER. */
1699 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1700 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1702 pfatal_with_name (filename);
1703 buffer[readlen] = 0;
1706 specs = xmalloc (readlen + 1);
1708 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1714 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1716 else if (*(buffer_p + 1) == '\n') /* \r\n */
1730 /* Read compilation specs from a file named FILENAME,
1731 replacing the default ones.
1733 A suffix which starts with `*' is a definition for
1734 one of the machine-specific sub-specs. The "suffix" should be
1735 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
1736 The corresponding spec is stored in asm_spec, etc.,
1737 rather than in the `compilers' vector.
1739 Anything invalid in the file is a fatal error. */
1742 read_specs (filename, main_p)
1743 const char *filename;
1749 buffer = load_specs (filename);
1751 /* Scan BUFFER for specs, putting them in the vector. */
1757 char *in, *out, *p1, *p2, *p3;
1759 /* Advance P in BUFFER to the next nonblank nocomment line. */
1760 p = skip_whitespace (p);
1764 /* Is this a special command that starts with '%'? */
1765 /* Don't allow this for the main specs file, since it would
1766 encourage people to overwrite it. */
1767 if (*p == '%' && !main_p)
1770 while (*p && *p != '\n')
1776 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1777 && (p1[sizeof "%include" - 1] == ' '
1778 || p1[sizeof "%include" - 1] == '\t'))
1782 p1 += sizeof ("%include");
1783 while (*p1 == ' ' || *p1 == '\t')
1786 if (*p1++ != '<' || p[-2] != '>')
1787 fatal ("specs %%include syntax malformed after %ld characters",
1788 (long) (p1 - buffer + 1));
1791 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1792 read_specs (new_filename ? new_filename : p1, FALSE);
1795 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1796 && (p1[sizeof "%include_noerr" - 1] == ' '
1797 || p1[sizeof "%include_noerr" - 1] == '\t'))
1801 p1 += sizeof "%include_noerr";
1802 while (*p1 == ' ' || *p1 == '\t')
1805 if (*p1++ != '<' || p[-2] != '>')
1806 fatal ("specs %%include syntax malformed after %ld characters",
1807 (long) (p1 - buffer + 1));
1810 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1812 read_specs (new_filename, FALSE);
1813 else if (verbose_flag)
1814 notice ("Could not find specs file %s\n", p1);
1817 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1818 && (p1[sizeof "%rename" - 1] == ' '
1819 || p1[sizeof "%rename" - 1] == '\t'))
1822 struct spec_list *sl;
1824 /* Get original name */
1825 p1 += sizeof "%rename";
1826 while (*p1 == ' ' || *p1 == '\t')
1829 if (! ISALPHA ((unsigned char) *p1))
1830 fatal ("specs %%rename syntax malformed after %ld characters",
1831 (long) (p1 - buffer));
1834 while (*p2 && !ISSPACE ((unsigned char) *p2))
1837 if (*p2 != ' ' && *p2 != '\t')
1838 fatal ("specs %%rename syntax malformed after %ld characters",
1839 (long) (p2 - buffer));
1843 while (*p2 == ' ' || *p2 == '\t')
1846 if (! ISALPHA ((unsigned char) *p2))
1847 fatal ("specs %%rename syntax malformed after %ld characters",
1848 (long) (p2 - buffer));
1850 /* Get new spec name. */
1852 while (*p3 && !ISSPACE ((unsigned char) *p3))
1856 fatal ("specs %%rename syntax malformed after %ld characters",
1857 (long) (p3 - buffer));
1860 for (sl = specs; sl; sl = sl->next)
1861 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1865 fatal ("specs %s spec was not found to be renamed", p1);
1867 if (strcmp (p1, p2) == 0)
1872 notice ("rename spec %s to %s\n", p1, p2);
1874 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
1878 set_spec (p2, *(sl->ptr_spec));
1880 free ((PTR) *(sl->ptr_spec));
1882 *(sl->ptr_spec) = "";
1887 fatal ("specs unknown %% command after %ld characters",
1888 (long) (p1 - buffer));
1891 /* Find the colon that should end the suffix. */
1893 while (*p1 && *p1 != ':' && *p1 != '\n')
1896 /* The colon shouldn't be missing. */
1898 fatal ("specs file malformed after %ld characters",
1899 (long) (p1 - buffer));
1901 /* Skip back over trailing whitespace. */
1903 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1906 /* Copy the suffix to a string. */
1907 suffix = save_string (p, p2 - p);
1908 /* Find the next line. */
1909 p = skip_whitespace (p1 + 1);
1911 fatal ("specs file malformed after %ld characters",
1912 (long) (p - buffer));
1915 /* Find next blank line or end of string. */
1916 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1919 /* Specs end at the blank line and do not include the newline. */
1920 spec = save_string (p, p1 - p);
1923 /* Delete backslash-newline sequences from the spec. */
1928 if (in[0] == '\\' && in[1] == '\n')
1930 else if (in[0] == '#')
1931 while (*in && *in != '\n')
1939 if (suffix[0] == '*')
1941 if (! strcmp (suffix, "*link_command"))
1942 link_command_spec = spec;
1944 set_spec (suffix + 1, spec);
1948 /* Add this pair to the vector. */
1950 = ((struct compiler *)
1951 xrealloc (compilers,
1952 (n_compilers + 2) * sizeof (struct compiler)));
1954 compilers[n_compilers].suffix = suffix;
1955 compilers[n_compilers].spec = spec;
1957 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1961 link_command_spec = spec;
1964 if (link_command_spec == 0)
1965 fatal ("spec file has no spec for linking");
1968 /* Record the names of temporary files we tell compilers to write,
1969 and delete them at the end of the run. */
1971 /* This is the common prefix we use to make temp file names.
1972 It is chosen once for each run of this program.
1973 It is substituted into a spec by %g or %j.
1974 Thus, all temp file names contain this prefix.
1975 In practice, all temp file names start with this prefix.
1977 This prefix comes from the envvar TMPDIR if it is defined;
1978 otherwise, from the P_tmpdir macro if that is defined;
1979 otherwise, in /usr/tmp or /tmp;
1980 or finally the current directory if all else fails. */
1982 static const char *temp_filename;
1984 /* Length of the prefix. */
1986 static int temp_filename_length;
1988 /* Define the list of temporary files to delete. */
1993 struct temp_file *next;
1996 /* Queue of files to delete on success or failure of compilation. */
1997 static struct temp_file *always_delete_queue;
1998 /* Queue of files to delete on failure of compilation. */
1999 static struct temp_file *failure_delete_queue;
2001 /* Record FILENAME as a file to be deleted automatically.
2002 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2003 otherwise delete it in any case.
2004 FAIL_DELETE nonzero means delete it if a compilation step fails;
2005 otherwise delete it in any case. */
2008 record_temp_file (filename, always_delete, fail_delete)
2009 const char *filename;
2013 char *const name = xstrdup (filename);
2017 struct temp_file *temp;
2018 for (temp = always_delete_queue; temp; temp = temp->next)
2019 if (! strcmp (name, temp->name))
2022 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2023 temp->next = always_delete_queue;
2025 always_delete_queue = temp;
2032 struct temp_file *temp;
2033 for (temp = failure_delete_queue; temp; temp = temp->next)
2034 if (! strcmp (name, temp->name))
2037 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2038 temp->next = failure_delete_queue;
2040 failure_delete_queue = temp;
2046 /* Delete all the temporary files whose names we previously recorded. */
2049 delete_if_ordinary (name)
2056 printf ("Delete %s? (y or n) ", name);
2060 while ((c = getchar ()) != '\n' && c != EOF)
2063 if (i == 'y' || i == 'Y')
2065 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
2066 if (unlink (name) < 0)
2068 perror_with_name (name);
2072 delete_temp_files ()
2074 struct temp_file *temp;
2076 for (temp = always_delete_queue; temp; temp = temp->next)
2077 delete_if_ordinary (temp->name);
2078 always_delete_queue = 0;
2081 /* Delete all the files to be deleted on error. */
2084 delete_failure_queue ()
2086 struct temp_file *temp;
2088 for (temp = failure_delete_queue; temp; temp = temp->next)
2089 delete_if_ordinary (temp->name);
2093 clear_failure_queue ()
2095 failure_delete_queue = 0;
2098 /* Build a list of search directories from PATHS.
2099 PREFIX is a string to prepend to the list.
2100 If CHECK_DIR_P is non-zero we ensure the directory exists.
2101 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2102 It is also used by the --print-search-dirs flag. */
2105 build_search_list (paths, prefix, check_dir_p)
2106 struct path_prefix *paths;
2110 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2112 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2113 int first_time = TRUE;
2114 struct prefix_list *pprefix;
2116 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2117 obstack_1grow (&collect_obstack, '=');
2119 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2121 int len = strlen (pprefix->prefix);
2125 || is_directory (pprefix->prefix, machine_suffix, 0)))
2128 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2131 obstack_grow (&collect_obstack, pprefix->prefix, len);
2132 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2135 if (just_machine_suffix
2136 && pprefix->require_machine_suffix == 2
2138 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2141 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2144 obstack_grow (&collect_obstack, pprefix->prefix, len);
2145 obstack_grow (&collect_obstack, just_machine_suffix,
2149 if (! pprefix->require_machine_suffix)
2152 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2155 obstack_grow (&collect_obstack, pprefix->prefix, len);
2159 obstack_1grow (&collect_obstack, '\0');
2160 return obstack_finish (&collect_obstack);
2163 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2167 putenv_from_prefixes (paths, env_var)
2168 struct path_prefix *paths;
2169 const char *env_var;
2171 putenv (build_search_list (paths, env_var, 1));
2176 /* FIXME: the location independence code for VMS is hairier than this,
2177 and hasn't been written. */
2179 /* Split a filename into component directories. */
2182 split_directories (name, ptr_num_dirs)
2191 /* Count the number of directories. Special case MSDOS disk names as part
2192 of the initial directory. */
2194 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2195 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2200 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2202 while ((ch = *p++) != '\0')
2204 if (IS_DIR_SEPARATOR (ch))
2207 while (IS_DIR_SEPARATOR (*p))
2212 dirs = (char **) xmalloc (sizeof (char *) * (num_dirs + 2));
2214 /* Now copy the directory parts. */
2217 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2218 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2220 dirs[num_dirs++] = save_string (p, 3);
2223 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2226 while ((ch = *p++) != '\0')
2228 if (IS_DIR_SEPARATOR (ch))
2230 while (IS_DIR_SEPARATOR (*p))
2233 dirs[num_dirs++] = save_string (q, p - q);
2239 dirs[num_dirs++] = save_string (q, p - 1 - q);
2241 dirs[num_dirs] = NULL;
2243 *ptr_num_dirs = num_dirs;
2248 /* Release storage held by split directories. */
2251 free_split_directories (dirs)
2256 while (dirs[i] != NULL)
2259 free ((char *) dirs);
2262 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
2263 to PREFIX starting with the directory portion of PROGNAME and a relative
2264 pathname of the difference between BIN_PREFIX and PREFIX.
2266 For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
2267 /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
2268 function will return /red/green/blue/../omega.
2270 If no relative prefix can be found, return NULL. */
2273 make_relative_prefix (progname, bin_prefix, prefix)
2274 const char *progname;
2275 const char *bin_prefix;
2278 char **prog_dirs, **bin_dirs, **prefix_dirs;
2279 int prog_num, bin_num, prefix_num, std_loc_p;
2282 prog_dirs = split_directories (progname, &prog_num);
2283 bin_dirs = split_directories (bin_prefix, &bin_num);
2285 /* If there is no full pathname, try to find the program by checking in each
2286 of the directories specified in the PATH environment variable. */
2291 GET_ENV_PATH_LIST (temp, "PATH");
2294 char *startp, *endp, *nstore;
2295 size_t prefixlen = strlen (temp) + 1;
2299 nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
2301 startp = endp = temp;
2304 if (*endp == PATH_SEPARATOR || *endp == 0)
2309 nstore[1] = DIR_SEPARATOR;
2314 strncpy (nstore, startp, endp - startp);
2315 if (! IS_DIR_SEPARATOR (endp[-1]))
2317 nstore[endp - startp] = DIR_SEPARATOR;
2318 nstore[endp - startp + 1] = 0;
2321 nstore[endp - startp] = 0;
2323 strcat (nstore, progname);
2324 if (! access (nstore, X_OK)
2325 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
2326 || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
2330 free_split_directories (prog_dirs);
2332 prog_dirs = split_directories (progname, &prog_num);
2338 endp = startp = endp + 1;
2346 /* Remove the program name from comparison of directory names. */
2349 /* Determine if the compiler is installed in the standard location, and if
2350 so, we don't need to specify relative directories. Also, if argv[0]
2351 doesn't contain any directory specifiers, there is not much we can do. */
2353 if (prog_num == bin_num)
2355 for (i = 0; i < bin_num; i++)
2357 if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
2361 if (prog_num <= 0 || i == bin_num)
2364 free_split_directories (prog_dirs);
2365 free_split_directories (bin_dirs);
2366 prog_dirs = bin_dirs = (char **) 0;
2371 prefix_dirs = split_directories (prefix, &prefix_num);
2373 /* Find how many directories are in common between bin_prefix & prefix. */
2374 n = (prefix_num < bin_num) ? prefix_num : bin_num;
2375 for (common = 0; common < n; common++)
2377 if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
2381 /* If there are no common directories, there can be no relative prefix. */
2384 free_split_directories (prog_dirs);
2385 free_split_directories (bin_dirs);
2386 free_split_directories (prefix_dirs);
2390 /* Build up the pathnames in argv[0]. */
2391 for (i = 0; i < prog_num; i++)
2392 obstack_grow (&obstack, prog_dirs[i], strlen (prog_dirs[i]));
2394 /* Now build up the ..'s. */
2395 for (i = common; i < n; i++)
2397 obstack_grow (&obstack, DIR_UP, sizeof (DIR_UP) - 1);
2398 obstack_1grow (&obstack, DIR_SEPARATOR);
2401 /* Put in directories to move over to prefix. */
2402 for (i = common; i < prefix_num; i++)
2403 obstack_grow (&obstack, prefix_dirs[i], strlen (prefix_dirs[i]));
2405 free_split_directories (prog_dirs);
2406 free_split_directories (bin_dirs);
2407 free_split_directories (prefix_dirs);
2409 obstack_1grow (&obstack, '\0');
2410 return obstack_finish (&obstack);
2414 /* Check whether NAME can be accessed in MODE. This is like access,
2415 except that it never considers directories to be executable. */
2418 access_check (name, mode)
2426 if (stat (name, &st) < 0
2427 || S_ISDIR (st.st_mode))
2431 return access (name, mode);
2434 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2435 access to check permissions.
2436 Return 0 if not found, otherwise return its name, allocated with malloc. */
2439 find_a_file (pprefix, name, mode)
2440 struct path_prefix *pprefix;
2445 const char *const file_suffix =
2446 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2447 struct prefix_list *pl;
2448 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2450 #ifdef DEFAULT_ASSEMBLER
2451 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2452 return xstrdup (DEFAULT_ASSEMBLER);
2455 #ifdef DEFAULT_LINKER
2456 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2457 return xstrdup (DEFAULT_LINKER);
2461 len += strlen (machine_suffix);
2463 temp = xmalloc (len);
2465 /* Determine the filename to execute (special case for absolute paths). */
2467 if (IS_ABSOLUTE_PATHNAME (name))
2469 if (access (name, mode) == 0)
2471 strcpy (temp, name);
2476 for (pl = pprefix->plist; pl; pl = pl->next)
2480 /* Some systems have a suffix for executable files.
2481 So try appending that first. */
2482 if (file_suffix[0] != 0)
2484 strcpy (temp, pl->prefix);
2485 strcat (temp, machine_suffix);
2486 strcat (temp, name);
2487 strcat (temp, file_suffix);
2488 if (access_check (temp, mode) == 0)
2490 if (pl->used_flag_ptr != 0)
2491 *pl->used_flag_ptr = 1;
2496 /* Now try just the name. */
2497 strcpy (temp, pl->prefix);
2498 strcat (temp, machine_suffix);
2499 strcat (temp, name);
2500 if (access_check (temp, mode) == 0)
2502 if (pl->used_flag_ptr != 0)
2503 *pl->used_flag_ptr = 1;
2508 /* Certain prefixes are tried with just the machine type,
2509 not the version. This is used for finding as, ld, etc. */
2510 if (just_machine_suffix && pl->require_machine_suffix == 2)
2512 /* Some systems have a suffix for executable files.
2513 So try appending that first. */
2514 if (file_suffix[0] != 0)
2516 strcpy (temp, pl->prefix);
2517 strcat (temp, just_machine_suffix);
2518 strcat (temp, name);
2519 strcat (temp, file_suffix);
2520 if (access_check (temp, mode) == 0)
2522 if (pl->used_flag_ptr != 0)
2523 *pl->used_flag_ptr = 1;
2528 strcpy (temp, pl->prefix);
2529 strcat (temp, just_machine_suffix);
2530 strcat (temp, name);
2531 if (access_check (temp, mode) == 0)
2533 if (pl->used_flag_ptr != 0)
2534 *pl->used_flag_ptr = 1;
2539 /* Certain prefixes can't be used without the machine suffix
2540 when the machine or version is explicitly specified. */
2541 if (! pl->require_machine_suffix)
2543 /* Some systems have a suffix for executable files.
2544 So try appending that first. */
2545 if (file_suffix[0] != 0)
2547 strcpy (temp, pl->prefix);
2548 strcat (temp, name);
2549 strcat (temp, file_suffix);
2550 if (access_check (temp, mode) == 0)
2552 if (pl->used_flag_ptr != 0)
2553 *pl->used_flag_ptr = 1;
2558 strcpy (temp, pl->prefix);
2559 strcat (temp, name);
2560 if (access_check (temp, mode) == 0)
2562 if (pl->used_flag_ptr != 0)
2563 *pl->used_flag_ptr = 1;
2573 /* Ranking of prefixes in the sort list. -B prefixes are put before
2576 enum path_prefix_priority
2578 PREFIX_PRIORITY_B_OPT,
2579 PREFIX_PRIORITY_LAST
2582 /* Add an entry for PREFIX in PLIST. The PLIST is kept in assending
2583 order according to PRIORITY. Within each PRIORITY, new entries are
2586 If WARN is nonzero, we will warn if no file is found
2587 through this prefix. WARN should point to an int
2588 which will be set to 1 if this entry is used.
2590 COMPONENT is the value to be passed to update_path.
2592 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2593 the complete value of machine_suffix.
2594 2 means try both machine_suffix and just_machine_suffix. */
2597 add_prefix (pprefix, prefix, component, priority, require_machine_suffix, warn)
2598 struct path_prefix *pprefix;
2600 const char *component;
2601 /* enum prefix_priority */ int priority;
2602 int require_machine_suffix;
2605 struct prefix_list *pl, **prev;
2608 for (prev = &pprefix->plist;
2609 (*prev) != NULL && (*prev)->priority <= priority;
2610 prev = &(*prev)->next)
2613 /* Keep track of the longest prefix */
2615 prefix = update_path (prefix, component);
2616 len = strlen (prefix);
2617 if (len > pprefix->max_len)
2618 pprefix->max_len = len;
2620 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2621 pl->prefix = prefix;
2622 pl->require_machine_suffix = require_machine_suffix;
2623 pl->used_flag_ptr = warn;
2624 pl->priority = priority;
2628 /* Insert after PREV */
2633 /* Execute the command specified by the arguments on the current line of spec.
2634 When using pipes, this includes several piped-together commands
2635 with `|' between them.
2637 Return 0 if successful, -1 if failed. */
2643 int n_commands; /* # of command. */
2647 const char *prog; /* program name. */
2648 const char **argv; /* vector of args. */
2649 int pid; /* pid of process for this command. */
2652 struct command *commands; /* each command buffer with above info. */
2654 /* Count # of piped commands. */
2655 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2656 if (strcmp (argbuf[i], "|") == 0)
2659 /* Get storage for each command. */
2660 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2662 /* Split argbuf into its separate piped processes,
2663 and record info about each one.
2664 Also search for the programs that are to be run. */
2666 commands[0].prog = argbuf[0]; /* first command. */
2667 commands[0].argv = &argbuf[0];
2668 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
2671 commands[0].argv[0] = string;
2673 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2674 if (strcmp (argbuf[i], "|") == 0)
2675 { /* each command. */
2676 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2677 fatal ("-pipe not supported");
2679 argbuf[i] = 0; /* termination of command args. */
2680 commands[n_commands].prog = argbuf[i + 1];
2681 commands[n_commands].argv = &argbuf[i + 1];
2682 string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
2684 commands[n_commands].argv[0] = string;
2688 argbuf[argbuf_index] = 0;
2690 /* If -v, print what we are about to do, and maybe query. */
2694 /* For help listings, put a blank line between sub-processes. */
2695 if (print_help_list)
2696 fputc ('\n', stderr);
2698 /* Print each piped command as a separate line. */
2699 for (i = 0; i < n_commands; i++)
2701 const char *const *j;
2703 for (j = commands[i].argv; *j; j++)
2704 fprintf (stderr, " %s", *j);
2706 /* Print a pipe symbol after all but the last command. */
2707 if (i + 1 != n_commands)
2708 fprintf (stderr, " |");
2709 fprintf (stderr, "\n");
2713 notice ("\nGo ahead? (y or n) ");
2717 while (getchar () != '\n')
2720 if (i != 'y' && i != 'Y')
2725 /* Run each piped subprocess. */
2727 for (i = 0; i < n_commands; i++)
2729 char *errmsg_fmt, *errmsg_arg;
2730 const char *string = commands[i].argv[0];
2732 /* For some bizarre reason, the second argument of execvp() is
2733 char *const *, not const char *const *. */
2734 commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2735 programname, temp_filename,
2736 &errmsg_fmt, &errmsg_arg,
2737 ((i == 0 ? PEXECUTE_FIRST : 0)
2738 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2739 | (string == commands[i].prog
2740 ? PEXECUTE_SEARCH : 0)
2741 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2743 if (commands[i].pid == -1)
2744 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2746 if (string != commands[i].prog)
2747 free ((PTR) string);
2752 /* Wait for all the subprocesses to finish.
2753 We don't care what order they finish in;
2754 we know that N_COMMANDS waits will get them all.
2755 Ignore subprocesses that we don't know about,
2756 since they can be spawned by the process that exec'ed us. */
2760 #ifdef HAVE_GETRUSAGE
2762 double ut = 0.0, st = 0.0;
2765 for (i = 0; i < n_commands;)
2771 pid = pwait (commands[i].pid, &status, 0);
2775 #ifdef HAVE_GETRUSAGE
2778 /* getrusage returns the total resource usage of all children
2779 up to now. Copy the previous values into prus, get the
2780 current statistics, then take the difference. */
2783 getrusage (RUSAGE_CHILDREN, &rus);
2784 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2785 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2786 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2788 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2789 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2790 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2794 for (j = 0; j < n_commands; j++)
2795 if (commands[j].pid == pid)
2798 if (WIFSIGNALED (status))
2801 /* SIGPIPE is a special case. It happens in -pipe mode
2802 when the compiler dies before the preprocessor is
2803 done, or the assembler dies before the compiler is
2804 done. There's generally been an error already, and
2805 this is just fallout. So don't generate another error
2806 unless we would otherwise have succeeded. */
2807 if (WTERMSIG (status) == SIGPIPE
2808 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2813 Internal error: %s (program %s)\n\
2814 Please submit a full bug report.\n\
2815 See %s for instructions.",
2816 strsignal (WTERMSIG (status)), commands[j].prog,
2821 else if (WIFEXITED (status)
2822 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2824 if (WEXITSTATUS (status) > greatest_status)
2825 greatest_status = WEXITSTATUS (status);
2828 #ifdef HAVE_GETRUSAGE
2829 if (report_times && ut + st != 0)
2830 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2839 /* Find all the switches given to us
2840 and make a vector describing them.
2841 The elements of the vector are strings, one per switch given.
2842 If a switch uses following arguments, then the `part1' field
2843 is the switch itself and the `args' field
2844 is a null-terminated vector containing the following arguments.
2845 The `live_cond' field is:
2847 1 if the switch is true in a conditional spec,
2848 -1 if false (overridden by a later switch)
2849 -2 if this switch should be ignored (used in %{<S})
2850 The `validated' field is nonzero if any spec has looked at this switch;
2851 if it remains zero at the end of the run, it must be meaningless. */
2854 #define SWITCH_FALSE -1
2855 #define SWITCH_IGNORE -2
2856 #define SWITCH_LIVE 1
2863 unsigned char validated;
2864 unsigned char ordering;
2867 static struct switchstr *switches;
2869 static int n_switches;
2874 const char *language;
2877 /* Also a vector of input files specified. */
2879 static struct infile *infiles;
2883 /* This counts the number of libraries added by lang_specific_driver, so that
2884 we can tell if there were any user supplied any files or libraries. */
2886 static int added_libraries;
2888 /* And a vector of corresponding output files is made up later. */
2890 const char **outfiles;
2892 /* Used to track if none of the -B paths are used. */
2895 /* Used to track if standard path isn't used and -b or -V is specified. */
2896 static int warn_std;
2898 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2899 static int *warn_std_ptr = 0;
2901 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2903 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2904 is true if we should look for an executable suffix as well. */
2907 convert_filename (name, do_exe)
2909 int do_exe ATTRIBUTE_UNUSED;
2911 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2919 len = strlen (name);
2921 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2922 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2924 && name[len - 2] == '.'
2925 && name[len - 1] == 'o')
2927 obstack_grow (&obstack, name, len - 2);
2928 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2929 name = obstack_finish (&obstack);
2933 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2934 /* If there is no filetype, make it the executable suffix (which includes
2935 the "."). But don't get confused if we have just "-o". */
2936 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2939 for (i = len - 1; i >= 0; i--)
2940 if (IS_DIR_SEPARATOR (name[i]))
2943 for (i++; i < len; i++)
2947 obstack_grow (&obstack, name, len);
2948 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2949 strlen (TARGET_EXECUTABLE_SUFFIX));
2950 name = obstack_finish (&obstack);
2957 /* Display the command line switches accepted by gcc. */
2961 printf (_("Usage: %s [options] file...\n"), programname);
2962 fputs (_("Options:\n"), stdout);
2964 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
2965 fputs (_(" --help Display this information\n"), stdout);
2966 fputs (_(" --target-help Display target specific command line options\n"), stdout);
2968 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2969 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
2970 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
2971 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
2972 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
2973 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
2974 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
2975 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
2976 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
2978 -print-multi-lib Display the mapping between command line options and\n\
2979 multiple library search directories\n"), stdout);
2980 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
2981 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
2982 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
2983 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
2984 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
2985 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
2986 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
2987 fputs (_(" -specs=<file> Override builtin specs with the contents of <file>\n"), stdout);
2988 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
2989 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
2990 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
2991 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
2992 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
2993 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
2994 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
2995 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
2996 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
2998 -x <language> Specify the language of the following input files\n\
2999 Permissable languages include: c c++ assembler none\n\
3000 'none' means revert to the default behaviour of\n\
3001 guessing the language based on the file's extension\n\
3005 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3006 passed on to the various sub-processes invoked by %s. In order to pass\n\
3007 other options on to these processes the -W<letter> options must be used.\n\
3010 /* The rest of the options are displayed by invocations of the various
3015 add_preprocessor_option (option, len)
3019 n_preprocessor_options++;
3021 if (! preprocessor_options)
3022 preprocessor_options
3023 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
3025 preprocessor_options
3026 = (char **) xrealloc (preprocessor_options,
3027 n_preprocessor_options * sizeof (char *));
3029 preprocessor_options [n_preprocessor_options - 1] =
3030 save_string (option, len);
3034 add_assembler_option (option, len)
3038 n_assembler_options++;
3040 if (! assembler_options)
3042 = (char **) xmalloc (n_assembler_options * sizeof (char *));
3045 = (char **) xrealloc (assembler_options,
3046 n_assembler_options * sizeof (char *));
3048 assembler_options [n_assembler_options - 1] = save_string (option, len);
3052 add_linker_option (option, len)
3058 if (! linker_options)
3060 = (char **) xmalloc (n_linker_options * sizeof (char *));
3063 = (char **) xrealloc (linker_options,
3064 n_linker_options * sizeof (char *));
3066 linker_options [n_linker_options - 1] = save_string (option, len);
3069 /* Create the vector `switches' and its contents.
3070 Store its length in `n_switches'. */
3073 process_command (argc, argv)
3075 const char *const *argv;
3080 const char *spec_lang = 0;
3081 int last_language_n_infiles;
3084 int lang_n_infiles = 0;
3085 #ifdef MODIFY_TARGET_NAME
3086 int is_modify_target_name;
3090 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3094 added_libraries = 0;
3096 /* Figure compiler version from version string. */
3098 compiler_version = temp1 = xstrdup (version_string);
3100 for (; *temp1; ++temp1)
3109 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3110 see if we can create it from the pathname specified in argv[0]. */
3113 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3114 if (!gcc_exec_prefix)
3116 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3117 standard_exec_prefix);
3118 if (gcc_exec_prefix)
3119 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3123 if (gcc_exec_prefix)
3125 int len = strlen (gcc_exec_prefix);
3127 if (len > (int) sizeof ("/lib/gcc-lib/") - 1
3128 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3130 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
3131 if (IS_DIR_SEPARATOR (*temp)
3132 && strncmp (temp + 1, "lib", 3) == 0
3133 && IS_DIR_SEPARATOR (temp[4])
3134 && strncmp (temp + 5, "gcc-lib", 7) == 0)
3135 len -= sizeof ("/lib/gcc-lib/") - 1;
3138 set_std_prefix (gcc_exec_prefix, len);
3139 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC",
3140 PREFIX_PRIORITY_LAST, 0, NULL);
3141 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3142 PREFIX_PRIORITY_LAST, 0, NULL);
3145 /* COMPILER_PATH and LIBRARY_PATH have values
3146 that are lists of directory names with colons. */
3148 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
3151 const char *startp, *endp;
3152 char *nstore = (char *) alloca (strlen (temp) + 3);
3154 startp = endp = temp;
3157 if (*endp == PATH_SEPARATOR || *endp == 0)
3159 strncpy (nstore, startp, endp - startp);
3161 strcpy (nstore, concat (".", dir_separator_str, NULL));
3162 else if (!IS_DIR_SEPARATOR (endp[-1]))
3164 nstore[endp - startp] = DIR_SEPARATOR;
3165 nstore[endp - startp + 1] = 0;
3168 nstore[endp - startp] = 0;
3169 add_prefix (&exec_prefixes, nstore, 0,
3170 PREFIX_PRIORITY_LAST, 0, NULL);
3171 add_prefix (&include_prefixes,
3172 concat (nstore, "include", NULL),
3173 0, PREFIX_PRIORITY_LAST, 0, NULL);
3176 endp = startp = endp + 1;
3183 GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
3184 if (temp && *cross_compile == '0')
3186 const char *startp, *endp;
3187 char *nstore = (char *) alloca (strlen (temp) + 3);
3189 startp = endp = temp;
3192 if (*endp == PATH_SEPARATOR || *endp == 0)
3194 strncpy (nstore, startp, endp - startp);
3196 strcpy (nstore, concat (".", dir_separator_str, NULL));
3197 else if (!IS_DIR_SEPARATOR (endp[-1]))
3199 nstore[endp - startp] = DIR_SEPARATOR;
3200 nstore[endp - startp + 1] = 0;
3203 nstore[endp - startp] = 0;
3204 add_prefix (&startfile_prefixes, nstore, NULL,
3205 PREFIX_PRIORITY_LAST, 0, NULL);
3208 endp = startp = endp + 1;
3215 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3216 GET_ENV_PATH_LIST (temp, "LPATH");
3217 if (temp && *cross_compile == '0')
3219 const char *startp, *endp;
3220 char *nstore = (char *) alloca (strlen (temp) + 3);
3222 startp = endp = temp;
3225 if (*endp == PATH_SEPARATOR || *endp == 0)
3227 strncpy (nstore, startp, endp - startp);
3229 strcpy (nstore, concat (".", dir_separator_str, NULL));
3230 else if (!IS_DIR_SEPARATOR (endp[-1]))
3232 nstore[endp - startp] = DIR_SEPARATOR;
3233 nstore[endp - startp + 1] = 0;
3236 nstore[endp - startp] = 0;
3237 add_prefix (&startfile_prefixes, nstore, NULL,
3238 PREFIX_PRIORITY_LAST, 0, NULL);
3241 endp = startp = endp + 1;
3248 /* Convert new-style -- options to old-style. */
3249 translate_options (&argc, &argv);
3251 /* Do language-specific adjustment/addition of flags. */
3252 lang_specific_driver (&argc, &argv, &added_libraries);
3254 /* Scan argv twice. Here, the first time, just count how many switches
3255 there will be in their vector, and how many input files in theirs.
3256 Also parse any switches that determine the configuration name, such as -b.
3257 Here we also parse the switches that cc itself uses (e.g. -v). */
3259 for (i = 1; i < argc; i++)
3261 if (! strcmp (argv[i], "-dumpspecs"))
3263 struct spec_list *sl;
3265 for (sl = specs; sl; sl = sl->next)
3266 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3267 if (link_command_spec)
3268 printf ("*link_command:\n%s\n\n", link_command_spec);
3271 else if (! strcmp (argv[i], "-dumpversion"))
3273 printf ("%s\n", spec_version);
3276 else if (! strcmp (argv[i], "-dumpmachine"))
3278 printf ("%s\n", spec_machine);
3281 else if (strcmp (argv[i], "-fhelp") == 0)
3283 /* translate_options () has turned --help into -fhelp. */
3284 print_help_list = 1;
3286 /* We will be passing a dummy file on to the sub-processes. */
3290 add_preprocessor_option ("--help", 6);
3291 add_assembler_option ("--help", 6);
3292 add_linker_option ("--help", 6);
3294 else if (strcmp (argv[i], "-ftarget-help") == 0)
3296 /* translate_options() has turned --target-help into -ftarget-help. */
3297 target_help_flag = 1;
3299 /* We will be passing a dummy file on to the sub-processes. */
3303 add_preprocessor_option ("--target-help", 13);
3304 add_assembler_option ("--target-help", 13);
3305 add_linker_option ("--target-help", 13);
3307 else if (! strcmp (argv[i], "-pass-exit-codes"))
3309 pass_exit_codes = 1;
3312 else if (! strcmp (argv[i], "-print-search-dirs"))
3313 print_search_dirs = 1;
3314 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3315 print_file_name = "libgcc.a";
3316 else if (! strncmp (argv[i], "-print-file-name=", 17))
3317 print_file_name = argv[i] + 17;
3318 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3319 print_prog_name = argv[i] + 17;
3320 else if (! strcmp (argv[i], "-print-multi-lib"))
3321 print_multi_lib = 1;
3322 else if (! strcmp (argv[i], "-print-multi-directory"))
3323 print_multi_directory = 1;
3324 else if (! strncmp (argv[i], "-Wa,", 4))
3327 /* Pass the rest of this option to the assembler. */
3329 /* Split the argument at commas. */
3331 for (j = 4; argv[i][j]; j++)
3332 if (argv[i][j] == ',')
3334 add_assembler_option (argv[i] + prev, j - prev);
3338 /* Record the part after the last comma. */
3339 add_assembler_option (argv[i] + prev, j - prev);
3341 else if (! strncmp (argv[i], "-Wp,", 4))
3344 /* Pass the rest of this option to the preprocessor. */
3346 /* Split the argument at commas. */
3348 for (j = 4; argv[i][j]; j++)
3349 if (argv[i][j] == ',')
3351 add_preprocessor_option (argv[i] + prev, j - prev);
3355 /* Record the part after the last comma. */
3356 add_preprocessor_option (argv[i] + prev, j - prev);
3358 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3359 /* The +e options to the C++ front-end. */
3361 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3364 /* Split the argument at commas. */
3365 for (j = 3; argv[i][j]; j++)
3366 n_infiles += (argv[i][j] == ',');
3368 else if (strcmp (argv[i], "-Xlinker") == 0)
3371 fatal ("argument to `-Xlinker' is missing");
3376 else if (strcmp (argv[i], "-l") == 0)
3379 fatal ("argument to `-l' is missing");
3384 else if (strncmp (argv[i], "-l", 2) == 0)
3386 else if (strcmp (argv[i], "-save-temps") == 0)
3388 save_temps_flag = 1;
3391 else if (strcmp (argv[i], "-specs") == 0)
3393 struct user_specs *user = (struct user_specs *)
3394 xmalloc (sizeof (struct user_specs));
3396 fatal ("argument to `-specs' is missing");
3398 user->next = (struct user_specs *) 0;
3399 user->filename = argv[i];
3400 if (user_specs_tail)
3401 user_specs_tail->next = user;
3403 user_specs_head = user;
3404 user_specs_tail = user;
3406 else if (strncmp (argv[i], "-specs=", 7) == 0)
3408 struct user_specs *user = (struct user_specs *)
3409 xmalloc (sizeof (struct user_specs));
3410 if (strlen (argv[i]) == 7)
3411 fatal ("argument to `-specs=' is missing");
3413 user->next = (struct user_specs *) 0;
3414 user->filename = argv[i] + 7;
3415 if (user_specs_tail)
3416 user_specs_tail->next = user;
3418 user_specs_head = user;
3419 user_specs_tail = user;
3421 else if (strcmp (argv[i], "-time") == 0)
3423 else if (argv[i][0] == '-' && argv[i][1] != 0)
3425 const char *p = &argv[i][1];
3432 if (p[1] == 0 && i + 1 == argc)
3433 fatal ("argument to `-b' is missing");
3435 spec_machine = argv[++i];
3437 spec_machine = p + 1;
3439 warn_std_ptr = &warn_std;
3447 if (p[1] == 0 && i + 1 == argc)
3448 fatal ("argument to `-B' is missing");
3454 len = strlen (value);
3456 /* Catch the case where the user has forgotten to append a
3457 directory separator to the path. Note, they may be using
3458 -B to add an executable name prefix, eg "i386-elf-", in
3459 order to distinguish between multiple installations of
3460 GCC in the same directory. Hence we must check to see
3461 if appending a directory separator actually makes a
3462 valid directory name. */
3463 if (! IS_DIR_SEPARATOR (value [len - 1])
3464 && is_directory (value, "", 0))
3466 char *tmp = xmalloc (len + 2);
3467 strcpy (tmp, value);
3468 tmp[len] = DIR_SEPARATOR;
3473 /* As a kludge, if the arg is "[foo/]stageN/", just
3474 add "[foo/]include" to the include prefix. */
3477 && (IS_DIR_SEPARATOR (value[len - 8]))))
3478 && strncmp (value + len - 7, "stage", 5) == 0
3479 && ISDIGIT (value[len - 2])
3480 && (IS_DIR_SEPARATOR (value[len - 1])))
3483 add_prefix (&include_prefixes, "include", NULL,
3484 PREFIX_PRIORITY_B_OPT, 0, NULL);
3487 char * string = xmalloc (len + 1);
3489 strncpy (string, value, len - 7);
3490 strcpy (string + len - 7, "include");
3491 add_prefix (&include_prefixes, string, NULL,
3492 PREFIX_PRIORITY_B_OPT, 0, NULL);
3496 add_prefix (&exec_prefixes, value, NULL,
3497 PREFIX_PRIORITY_B_OPT, 0, &warn_B);
3498 add_prefix (&startfile_prefixes, value, NULL,
3499 PREFIX_PRIORITY_B_OPT, 0, &warn_B);
3500 add_prefix (&include_prefixes, concat (value, "include", NULL),
3501 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL);
3506 case 'v': /* Print our subcommands and print versions. */
3508 /* If they do anything other than exactly `-v', don't set
3509 verbose_flag; rather, continue on to give the error. */
3517 if (p[1] == 0 && i + 1 == argc)
3518 fatal ("argument to `-V' is missing");
3520 spec_version = argv[++i];
3522 spec_version = p + 1;
3523 compiler_version = spec_version;
3524 warn_std_ptr = &warn_std;
3526 /* Validate the version number. Use the same checks
3527 done when inserting it into a spec.
3529 The format of the version string is
3530 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
3532 const char *v = compiler_version;
3534 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
3535 while (! ISDIGIT (*v))
3538 if (v > compiler_version && v[-1] != '-')
3539 fatal ("invalid version number format");
3541 /* Set V after the first period. */
3542 while (ISDIGIT (*v))
3546 fatal ("invalid version number format");
3549 while (ISDIGIT (*v))
3552 if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
3553 fatal ("invalid version number format");
3569 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3574 /* Forward scan, just in case -S or -c is specified
3581 if (argv[j][0] == '-')
3583 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3589 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3590 j += skip - (argv[j][2] != 0);
3591 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3598 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3600 argv[i + 1] = convert_filename (argv[i + 1], ! have_c);
3602 argv[i] = convert_filename (argv[i], ! have_c);
3609 #ifdef MODIFY_TARGET_NAME
3610 is_modify_target_name = 0;
3613 j < sizeof modify_target / sizeof modify_target[0]; j++)
3614 if (! strcmp (argv[i], modify_target[j].sw))
3617 = (char *) xmalloc (strlen (modify_target[j].str)
3618 + strlen (spec_machine));
3621 int made_addition = 0;
3623 is_modify_target_name = 1;
3624 for (p = spec_machine, q = new_name; *p != 0; )
3626 if (modify_target[j].add_del == DELETE
3627 && (! strncmp (q, modify_target[j].str,
3628 strlen (modify_target[j].str))))
3629 p += strlen (modify_target[j].str);
3630 else if (modify_target[j].add_del == ADD
3631 && ! made_addition && *p == '-')
3633 for (r = modify_target[j].str; *r != 0; )
3641 spec_machine = new_name;
3644 if (is_modify_target_name)
3650 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3651 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3652 else if (WORD_SWITCH_TAKES_ARG (p))
3653 i += WORD_SWITCH_TAKES_ARG (p);
3663 if (have_c && have_o && lang_n_infiles > 1)
3664 fatal ("cannot specify -o with -c or -S and multiple compilations");
3666 /* Set up the search paths before we go looking for config files. */
3668 /* These come before the md prefixes so that we will find gcc's subcommands
3669 (such as cpp) rather than those of the host system. */
3670 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3671 as well as trying the machine and the version. */
3673 add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
3674 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3675 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3676 PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
3677 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3678 PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
3681 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3682 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3683 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3684 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3686 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3687 dir_separator_str, NULL);
3689 /* If tooldir is relative, base it on exec_prefixes. A relative
3690 tooldir lets us move the installed tree as a unit.
3692 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3693 directories, so that we can search both the user specified directory
3694 and the standard place. */
3696 if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix))
3698 if (gcc_exec_prefix)
3700 char *gcc_exec_tooldir_prefix
3701 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3702 spec_version, dir_separator_str, tooldir_prefix, NULL);
3704 add_prefix (&exec_prefixes,
3705 concat (gcc_exec_tooldir_prefix, "bin",
3706 dir_separator_str, NULL),
3707 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
3708 add_prefix (&startfile_prefixes,
3709 concat (gcc_exec_tooldir_prefix, "lib",
3710 dir_separator_str, NULL),
3711 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
3714 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3715 dir_separator_str, spec_version,
3716 dir_separator_str, tooldir_prefix, NULL);
3719 add_prefix (&exec_prefixes,
3720 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3721 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
3722 add_prefix (&startfile_prefixes,
3723 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3724 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
3726 /* More prefixes are enabled in main, after we read the specs file
3727 and determine whether this is cross-compilation or not. */
3729 /* Then create the space for the vectors and scan again. */
3731 switches = ((struct switchstr *)
3732 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3733 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3736 last_language_n_infiles = -1;
3738 /* This, time, copy the text of each switch and store a pointer
3739 to the copy in the vector of switches.
3740 Store all the infiles in their vector. */
3742 for (i = 1; i < argc; i++)
3744 /* Just skip the switches that were handled by the preceding loop. */
3745 #ifdef MODIFY_TARGET_NAME
3746 is_modify_target_name = 0;
3748 for (j = 0; j < sizeof modify_target / sizeof modify_target[0]; j++)
3749 if (! strcmp (argv[i], modify_target[j].sw))
3750 is_modify_target_name = 1;
3752 if (is_modify_target_name)
3756 if (! strncmp (argv[i], "-Wa,", 4))
3758 else if (! strncmp (argv[i], "-Wp,", 4))
3760 else if (! strcmp (argv[i], "-pass-exit-codes"))
3762 else if (! strcmp (argv[i], "-print-search-dirs"))
3764 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3766 else if (! strncmp (argv[i], "-print-file-name=", 17))
3768 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3770 else if (! strcmp (argv[i], "-print-multi-lib"))
3772 else if (! strcmp (argv[i], "-print-multi-directory"))
3774 else if (strcmp (argv[i], "-ftarget-help") == 0)
3776 /* Create a dummy input file, so that we can pass --target-help on to
3777 the various sub-processes. */
3778 infiles[n_infiles].language = "c";
3779 infiles[n_infiles++].name = "target-dummy";
3781 /* Preserve the --target-help switch so that it can be caught by
3782 the cc1 spec string. */
3783 switches[n_switches].part1 = "--target-help";
3784 switches[n_switches].args = 0;
3785 switches[n_switches].live_cond = SWITCH_OK;
3786 switches[n_switches].validated = 0;
3790 else if (strcmp (argv[i], "-fhelp") == 0)
3794 /* Create a dummy input file, so that we can pass --help on to
3795 the various sub-processes. */
3796 infiles[n_infiles].language = "c";
3797 infiles[n_infiles++].name = "help-dummy";
3799 /* Preserve the --help switch so that it can be caught by the
3801 switches[n_switches].part1 = "--help";
3802 switches[n_switches].args = 0;
3803 switches[n_switches].live_cond = SWITCH_OK;
3804 switches[n_switches].validated = 0;
3809 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3811 /* Compensate for the +e options to the C++ front-end;
3812 they're there simply for cfront call-compatibility. We do
3813 some magic in default_compilers to pass them down properly.
3814 Note we deliberately start at the `+' here, to avoid passing
3815 -e0 or -e1 down into the linker. */
3816 switches[n_switches].part1 = &argv[i][0];
3817 switches[n_switches].args = 0;
3818 switches[n_switches].live_cond = SWITCH_OK;
3819 switches[n_switches].validated = 0;
3822 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3825 /* Split the argument at commas. */
3827 for (j = 4; argv[i][j]; j++)
3828 if (argv[i][j] == ',')
3830 infiles[n_infiles].language = "*";
3831 infiles[n_infiles++].name
3832 = save_string (argv[i] + prev, j - prev);
3835 /* Record the part after the last comma. */
3836 infiles[n_infiles].language = "*";
3837 infiles[n_infiles++].name = argv[i] + prev;
3839 else if (strcmp (argv[i], "-Xlinker") == 0)
3841 infiles[n_infiles].language = "*";
3842 infiles[n_infiles++].name = argv[++i];
3844 else if (strcmp (argv[i], "-l") == 0)
3845 { /* POSIX allows separation of -l and the lib arg;
3846 canonicalize by concatenating -l with its arg */
3847 infiles[n_infiles].language = "*";
3848 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3850 else if (strncmp (argv[i], "-l", 2) == 0)
3852 infiles[n_infiles].language = "*";
3853 infiles[n_infiles++].name = argv[i];
3855 else if (strcmp (argv[i], "-specs") == 0)
3857 else if (strncmp (argv[i], "-specs=", 7) == 0)
3859 else if (strcmp (argv[i], "-time") == 0)
3861 else if ((save_temps_flag || report_times)
3862 && strcmp (argv[i], "-pipe") == 0)
3864 /* -save-temps overrides -pipe, so that temp files are produced */
3865 if (save_temps_flag)
3866 error ("Warning: -pipe ignored because -save-temps specified");
3867 /* -time overrides -pipe because we can't get correct stats when
3868 multiple children are running at once. */
3869 else if (report_times)
3870 error ("Warning: -pipe ignored because -time specified");
3872 else if (argv[i][0] == '-' && argv[i][1] != 0)
3874 const char *p = &argv[i][1];
3879 if (p[1] == 0 && i + 1 == argc)
3880 fatal ("argument to `-x' is missing");
3882 spec_lang = argv[++i];
3885 if (! strcmp (spec_lang, "none"))
3886 /* Suppress the warning if -xnone comes after the last input
3887 file, because alternate command interfaces like g++ might
3888 find it useful to place -xnone after each input file. */
3891 last_language_n_infiles = n_infiles;
3894 switches[n_switches].part1 = p;
3895 /* Deal with option arguments in separate argv elements. */
3896 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3897 || WORD_SWITCH_TAKES_ARG (p))
3900 int n_args = WORD_SWITCH_TAKES_ARG (p);
3904 /* Count only the option arguments in separate argv elements. */
3905 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3907 if (i + n_args >= argc)
3908 fatal ("argument to `-%s' is missing", p);
3909 switches[n_switches].args
3910 = (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
3912 switches[n_switches].args[j++] = argv[++i];
3913 /* Null-terminate the vector. */
3914 switches[n_switches].args[j] = 0;
3916 else if (strchr (switches_need_spaces, c))
3918 /* On some systems, ld cannot handle some options without
3919 a space. So split the option from its argument. */
3920 char *part1 = (char *) xmalloc (2);
3924 switches[n_switches].part1 = part1;
3925 switches[n_switches].args
3926 = (const char **) xmalloc (2 * sizeof (const char *));
3927 switches[n_switches].args[0] = xstrdup (p+1);
3928 switches[n_switches].args[1] = 0;
3931 switches[n_switches].args = 0;
3933 switches[n_switches].live_cond = SWITCH_OK;
3934 switches[n_switches].validated = 0;
3935 switches[n_switches].ordering = 0;
3936 /* These are always valid, since gcc.c itself understands it. */
3937 if (!strcmp (p, "save-temps")
3938 || !strcmp (p, "static-libgcc")
3939 || !strcmp (p, "shared-libgcc"))
3940 switches[n_switches].validated = 1;
3943 char ch = switches[n_switches].part1[0];
3944 if (ch == 'V' || ch == 'b' || ch == 'B')
3945 switches[n_switches].validated = 1;
3951 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3952 argv[i] = convert_filename (argv[i], 0);
3955 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
3957 perror_with_name (argv[i]);
3962 infiles[n_infiles].language = spec_lang;
3963 infiles[n_infiles++].name = argv[i];
3968 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3969 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
3971 switches[n_switches].part1 = 0;
3972 infiles[n_infiles].name = 0;
3975 /* Process a spec string, accumulating and running commands. */
3977 /* These variables describe the input file name.
3978 input_file_number is the index on outfiles of this file,
3979 so that the output file name can be stored for later use by %o.
3980 input_basename is the start of the part of the input file
3981 sans all directory names, and basename_length is the number
3982 of characters starting there excluding the suffix .c or whatever. */
3984 const char *input_filename;
3985 static int input_file_number;
3986 size_t input_filename_length;
3987 static int basename_length;
3988 static int suffixed_basename_length;
3989 static const char *input_basename;
3990 static const char *input_suffix;
3992 /* The compiler used to process the current input file. */
3993 static struct compiler *input_file_compiler;
3995 /* These are variables used within do_spec and do_spec_1. */
3997 /* Nonzero if an arg has been started and not yet terminated
3998 (with space, tab or newline). */
3999 static int arg_going;
4001 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4002 is a temporary file name. */
4003 static int delete_this_arg;
4005 /* Nonzero means %w has been seen; the next arg to be terminated
4006 is the output file name of this compilation. */
4007 static int this_is_output_file;
4009 /* Nonzero means %s has been seen; the next arg to be terminated
4010 is the name of a library file and we should try the standard
4011 search dirs for it. */
4012 static int this_is_library_file;
4014 /* Nonzero means that the input of this command is coming from a pipe. */
4015 static int input_from_pipe;
4017 /* Nonnull means substitute this for any suffix when outputting a switches
4019 static const char *suffix_subst;
4021 /* Process the spec SPEC and run the commands specified therein.
4022 Returns 0 if the spec is successfully processed; -1 if failed. */
4032 delete_this_arg = 0;
4033 this_is_output_file = 0;
4034 this_is_library_file = 0;
4035 input_from_pipe = 0;
4036 suffix_subst = NULL;
4038 value = do_spec_1 (spec, 0, NULL);
4040 /* Force out any unfinished command.
4041 If -pipe, this forces out the last command if it ended in `|'. */
4044 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4047 if (argbuf_index > 0)
4054 /* Process the sub-spec SPEC as a portion of a larger spec.
4055 This is like processing a whole spec except that we do
4056 not initialize at the beginning and we do not supply a
4057 newline by default at the end.
4058 INSWITCH nonzero means don't process %-sequences in SPEC;
4059 in this case, % is treated as an ordinary character.
4060 This is used while substituting switches.
4061 INSWITCH nonzero also causes SPC not to terminate an argument.
4063 Value is zero unless a line was finished
4064 and the command on that line reported an error. */
4067 do_spec_1 (spec, inswitch, soft_matched_part)
4070 const char *soft_matched_part;
4072 const char *p = spec;
4079 /* If substituting a switch, treat all chars like letters.
4080 Otherwise, NL, SPC, TAB and % are special. */
4081 switch (inswitch ? 'a' : c)
4084 /* End of line: finish any pending argument,
4085 then run the pending command if one has been started. */
4088 obstack_1grow (&obstack, 0);
4089 string = obstack_finish (&obstack);
4090 if (this_is_library_file)
4091 string = find_file (string);
4092 store_arg (string, delete_this_arg, this_is_output_file);
4093 if (this_is_output_file)
4094 outfiles[input_file_number] = string;
4098 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4100 for (i = 0; i < n_switches; i++)
4101 if (!strcmp (switches[i].part1, "pipe"))
4104 /* A `|' before the newline means use a pipe here,
4105 but only if -pipe was specified.
4106 Otherwise, execute now and don't pass the `|' as an arg. */
4109 input_from_pipe = 1;
4110 switches[i].validated = 1;
4117 if (argbuf_index > 0)
4123 /* Reinitialize for a new command, and for a new argument. */
4126 delete_this_arg = 0;
4127 this_is_output_file = 0;
4128 this_is_library_file = 0;
4129 input_from_pipe = 0;
4133 /* End any pending argument. */
4136 obstack_1grow (&obstack, 0);
4137 string = obstack_finish (&obstack);
4138 if (this_is_library_file)
4139 string = find_file (string);
4140 store_arg (string, delete_this_arg, this_is_output_file);
4141 if (this_is_output_file)
4142 outfiles[input_file_number] = string;
4146 obstack_1grow (&obstack, c);
4152 /* Space or tab ends an argument if one is pending. */
4155 obstack_1grow (&obstack, 0);
4156 string = obstack_finish (&obstack);
4157 if (this_is_library_file)
4158 string = find_file (string);
4159 store_arg (string, delete_this_arg, this_is_output_file);
4160 if (this_is_output_file)
4161 outfiles[input_file_number] = string;
4163 /* Reinitialize for a new argument. */
4165 delete_this_arg = 0;
4166 this_is_output_file = 0;
4167 this_is_library_file = 0;
4174 fatal ("Invalid specification! Bug in cc.");
4177 obstack_grow (&obstack, input_basename, basename_length);
4182 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4187 delete_this_arg = 2;
4190 /* Dump out the directories specified with LIBRARY_PATH,
4191 followed by the absolute directories
4192 that we search for startfiles. */
4195 struct prefix_list *pl = startfile_prefixes.plist;
4196 size_t bufsize = 100;
4197 char *buffer = (char *) xmalloc (bufsize);
4200 for (; pl; pl = pl->next)
4202 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4203 /* Used on systems which record the specified -L dirs
4204 and use them to search for dynamic linking. */
4205 /* Relative directories always come from -B,
4206 and it is better not to use them for searching
4207 at run time. In particular, stage1 loses. */
4208 if (!IS_ABSOLUTE_PATHNAME (pl->prefix))
4211 /* Try subdirectory if there is one. */
4212 if (multilib_dir != NULL)
4216 if (strlen (pl->prefix) + strlen (machine_suffix)
4218 bufsize = (strlen (pl->prefix)
4219 + strlen (machine_suffix)) * 2 + 1;
4220 buffer = (char *) xrealloc (buffer, bufsize);
4221 strcpy (buffer, pl->prefix);
4222 strcat (buffer, machine_suffix);
4223 if (is_directory (buffer, multilib_dir, 1))
4225 do_spec_1 ("-L", 0, NULL);
4226 #ifdef SPACE_AFTER_L_OPTION
4227 do_spec_1 (" ", 0, NULL);
4229 do_spec_1 (buffer, 1, NULL);
4230 do_spec_1 (multilib_dir, 1, NULL);
4231 /* Make this a separate argument. */
4232 do_spec_1 (" ", 0, NULL);
4235 if (!pl->require_machine_suffix)
4237 if (is_directory (pl->prefix, multilib_dir, 1))
4239 do_spec_1 ("-L", 0, NULL);
4240 #ifdef SPACE_AFTER_L_OPTION
4241 do_spec_1 (" ", 0, NULL);
4243 do_spec_1 (pl->prefix, 1, NULL);
4244 do_spec_1 (multilib_dir, 1, NULL);
4245 /* Make this a separate argument. */
4246 do_spec_1 (" ", 0, NULL);
4252 if (is_directory (pl->prefix, machine_suffix, 1))
4254 do_spec_1 ("-L", 0, NULL);
4255 #ifdef SPACE_AFTER_L_OPTION
4256 do_spec_1 (" ", 0, NULL);
4258 do_spec_1 (pl->prefix, 1, NULL);
4259 /* Remove slash from machine_suffix. */
4260 if (strlen (machine_suffix) >= bufsize)
4261 bufsize = strlen (machine_suffix) * 2 + 1;
4262 buffer = (char *) xrealloc (buffer, bufsize);
4263 strcpy (buffer, machine_suffix);
4264 idx = strlen (buffer);
4265 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4266 buffer[idx - 1] = 0;
4267 do_spec_1 (buffer, 1, NULL);
4268 /* Make this a separate argument. */
4269 do_spec_1 (" ", 0, NULL);
4272 if (!pl->require_machine_suffix)
4274 if (is_directory (pl->prefix, "", 1))
4276 do_spec_1 ("-L", 0, NULL);
4277 #ifdef SPACE_AFTER_L_OPTION
4278 do_spec_1 (" ", 0, NULL);
4280 /* Remove slash from pl->prefix. */
4281 if (strlen (pl->prefix) >= bufsize)
4282 bufsize = strlen (pl->prefix) * 2 + 1;
4283 buffer = (char *) xrealloc (buffer, bufsize);
4284 strcpy (buffer, pl->prefix);
4285 idx = strlen (buffer);
4286 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4287 buffer[idx - 1] = 0;
4288 do_spec_1 (buffer, 1, NULL);
4289 /* Make this a separate argument. */
4290 do_spec_1 (" ", 0, NULL);
4299 /* %efoo means report an error with `foo' as error message
4300 and don't execute any more commands for this file. */
4304 while (*p != 0 && *p != '\n')
4306 buf = (char *) alloca (p - q + 1);
4307 strncpy (buf, q, p - q);
4314 /* %nfoo means report an notice with `foo' on stderr. */
4318 while (*p != 0 && *p != '\n')
4320 buf = (char *) alloca (p - q + 1);
4321 strncpy (buf, q, p - q);
4323 notice ("%s\n", buf);
4333 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is defined,
4334 and it is not a directory, and it is writable, use it.
4335 Otherwise, fall through and treat this like any other
4338 if ((!save_temps_flag)
4339 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4340 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4342 obstack_grow (&obstack, HOST_BIT_BUCKET,
4343 strlen (HOST_BIT_BUCKET));
4344 delete_this_arg = 0;
4352 if (save_temps_flag)
4354 obstack_grow (&obstack, input_basename, basename_length);
4355 delete_this_arg = 0;
4359 struct temp_name *t;
4361 const char *suffix = p;
4362 char *saved_suffix = NULL;
4364 while (*p == '.' || ISALPHA ((unsigned char) *p))
4366 suffix_length = p - suffix;
4367 if (p[0] == '%' && p[1] == 'O')
4370 /* We don't support extra suffix characters after %O. */
4371 if (*p == '.' || ISALPHA ((unsigned char) *p))
4373 if (suffix_length == 0)
4374 suffix = TARGET_OBJECT_SUFFIX;
4378 = (char *) xmalloc (suffix_length
4379 + strlen (TARGET_OBJECT_SUFFIX));
4380 strncpy (saved_suffix, suffix, suffix_length);
4381 strcpy (saved_suffix + suffix_length,
4382 TARGET_OBJECT_SUFFIX);
4384 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4387 /* See if we already have an association of %g/%u/%U and
4389 for (t = temp_names; t; t = t->next)
4390 if (t->length == suffix_length
4391 && strncmp (t->suffix, suffix, suffix_length) == 0
4392 && t->unique == (c != 'g'))
4395 /* Make a new association if needed. %u and %j
4397 if (t == 0 || c == 'u' || c == 'j')
4401 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
4402 t->next = temp_names;
4405 t->length = suffix_length;
4408 t->suffix = saved_suffix;
4409 saved_suffix = NULL;
4412 t->suffix = save_string (suffix, suffix_length);
4413 t->unique = (c != 'g');
4414 temp_filename = make_temp_file (t->suffix);
4415 temp_filename_length = strlen (temp_filename);
4416 t->filename = temp_filename;
4417 t->filename_length = temp_filename_length;
4421 free (saved_suffix);
4423 obstack_grow (&obstack, t->filename, t->filename_length);
4424 delete_this_arg = 1;
4430 obstack_grow (&obstack, input_filename, input_filename_length);
4436 struct prefix_list *pl = include_prefixes.plist;
4438 if (gcc_exec_prefix)
4440 do_spec_1 ("-iprefix", 1, NULL);
4441 /* Make this a separate argument. */
4442 do_spec_1 (" ", 0, NULL);
4443 do_spec_1 (gcc_exec_prefix, 1, NULL);
4444 do_spec_1 (" ", 0, NULL);
4447 for (; pl; pl = pl->next)
4449 do_spec_1 ("-isystem", 1, NULL);
4450 /* Make this a separate argument. */
4451 do_spec_1 (" ", 0, NULL);
4452 do_spec_1 (pl->prefix, 1, NULL);
4453 do_spec_1 (" ", 0, NULL);
4460 int max = n_infiles;
4461 max += lang_specific_extra_outfiles;
4463 for (i = 0; i < max; i++)
4465 store_arg (outfiles[i], 0, 0);
4470 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4475 this_is_library_file = 1;
4479 this_is_output_file = 1;
4484 int cur_index = argbuf_index;
4485 /* Handle the {...} following the %W. */
4488 p = handle_braces (p + 1);
4491 /* If any args were output, mark the last one for deletion
4493 if (argbuf_index != cur_index)
4494 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4498 /* %x{OPTION} records OPTION for %X to output. */
4504 /* Skip past the option value and make a copy. */
4509 string = save_string (p1 + 1, p - p1 - 2);
4511 /* See if we already recorded this option. */
4512 for (i = 0; i < n_linker_options; i++)
4513 if (! strcmp (string, linker_options[i]))
4519 /* This option is new; add it. */
4520 add_linker_option (string, strlen (string));
4524 /* Dump out the options accumulated previously using %x. */
4526 for (i = 0; i < n_linker_options; i++)
4528 do_spec_1 (linker_options[i], 1, NULL);
4529 /* Make each accumulated option a separate argument. */
4530 do_spec_1 (" ", 0, NULL);
4534 /* Dump out the options accumulated previously using -Wa,. */
4536 for (i = 0; i < n_assembler_options; i++)
4538 do_spec_1 (assembler_options[i], 1, NULL);
4539 /* Make each accumulated option a separate argument. */
4540 do_spec_1 (" ", 0, NULL);
4544 /* Dump out the options accumulated previously using -Wp,. */
4546 for (i = 0; i < n_preprocessor_options; i++)
4548 do_spec_1 (preprocessor_options[i], 1, NULL);
4549 /* Make each accumulated option a separate argument. */
4550 do_spec_1 (" ", 0, NULL);
4554 /* Here are digits and numbers that just process
4555 a certain constant string as a spec. */
4558 value = do_spec_1 (cc1_spec, 0, NULL);
4564 value = do_spec_1 (cc1plus_spec, 0, NULL);
4570 value = do_spec_1 (asm_spec, 0, NULL);
4576 value = do_spec_1 (asm_final_spec, 0, NULL);
4582 value = do_spec_1 (signed_char_spec, 0, NULL);
4589 const char *const spec
4590 = (input_file_compiler->cpp_spec
4591 ? input_file_compiler->cpp_spec
4593 value = do_spec_1 (spec, 0, NULL);
4600 value = do_spec_1 (endfile_spec, 0, NULL);
4606 value = do_spec_1 (link_spec, 0, NULL);
4612 value = do_spec_1 (lib_spec, 0, NULL);
4618 value = do_spec_1 (libgcc_spec, 0, NULL);
4624 if (multilib_dir && strcmp (multilib_dir, ".") != 0)
4630 len = strlen (multilib_dir);
4631 obstack_blank (&obstack, len + 1);
4632 p = obstack_next_free (&obstack) - (len + 1);
4635 for (q = multilib_dir; *q ; ++q, ++p)
4636 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
4642 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
4646 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4650 if (! strncmp (y, "-D", 2))
4651 /* Copy the whole option. */
4652 while (*y && *y != ' ' && *y != '\t')
4654 else if (*y == ' ' || *y == '\t')
4655 /* Copy whitespace to the result. */
4657 /* Don't copy other options. */
4664 value = do_spec_1 (buf, 0, NULL);
4672 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
4676 /* Copy all of CPP_PREDEFINES into BUF,
4677 but force them all into the reserved name space if they
4678 aren't already there. The reserved name space is all
4679 identifiers beginning with two underscores or with one
4680 underscore and a capital letter. We do the forcing by
4681 adding up to two underscores to the beginning and end
4682 of each symbol. e.g. mips, _mips, mips_, and _mips_ all
4687 if (! strncmp (y, "-D", 2))
4696 && ! ISUPPER ((unsigned char) *(y + 1))))
4698 /* Stick __ at front of macro name. */
4702 /* Arrange to stick __ at the end as well. */
4706 /* Copy the macro name. */
4707 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4720 /* Copy the value given, if any. */
4721 while (*y && *y != ' ' && *y != '\t')
4724 else if (*y == ' ' || *y == '\t')
4725 /* Copy whitespace to the result. */
4727 /* Don't copy -A options */
4733 /* Copy all of CPP_PREDEFINES into BUF,
4734 but put __ after every -D. */
4738 if (! strncmp (y, "-D", 2))
4744 && ! ISUPPER ((unsigned char) *(y + 1))))
4746 /* Stick -D__ at front of macro name. */
4753 /* Copy the macro name. */
4754 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4757 /* Copy the value given, if any. */
4758 while (*y && *y != ' ' && *y != '\t')
4763 /* Do not copy this macro - we have just done it before */
4764 while (*y && *y != ' ' && *y != '\t')
4768 else if (*y == ' ' || *y == '\t')
4769 /* Copy whitespace to the result. */
4771 /* Don't copy -A options. */
4777 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4781 if (! strncmp (y, "-A", 2))
4782 /* Copy the whole option. */
4783 while (*y && *y != ' ' && *y != '\t')
4785 else if (*y == ' ' || *y == '\t')
4786 /* Copy whitespace to the result. */
4788 /* Don't copy other options. */
4795 value = do_spec_1 (buf, 0, NULL);
4802 value = do_spec_1 (startfile_spec, 0, NULL);
4807 /* Here we define characters other than letters and digits. */
4810 p = handle_braces (p);
4816 obstack_1grow (&obstack, '%');
4823 while (p[len] && p[len] != ' ' && p[len] != '%')
4825 suffix_subst = save_string (p - 1, len + 1);
4831 if (soft_matched_part)
4833 do_spec_1 (soft_matched_part, 1, NULL);
4834 do_spec_1 (" ", 0, NULL);
4837 /* Catch the case where a spec string contains something like
4838 '%{foo:%*}'. ie there is no * in the pattern on the left
4839 hand side of the :. */
4840 error ("Spec failure: '%%*' has not been initialised by pattern match");
4843 /* Process a string found as the value of a spec given by name.
4844 This feature allows individual machine descriptions
4845 to add and use their own specs.
4846 %[...] modifies -D options the way %P does;
4847 %(...) uses the spec unmodified. */
4849 error ("Warning: use of obsolete %%[ operator in specs");
4852 const char *name = p;
4853 struct spec_list *sl;
4856 /* The string after the S/P is the name of a spec that is to be
4858 while (*p && *p != ')' && *p != ']')
4861 /* See if it's in the list. */
4862 for (len = p - name, sl = specs; sl; sl = sl->next)
4863 if (sl->name_len == len && !strncmp (sl->name, name, len))
4865 name = *(sl->ptr_spec);
4867 notice ("Processing spec %c%s%c, which is '%s'\n",
4868 c, sl->name, (c == '(') ? ')' : ']', name);
4877 value = do_spec_1 (name, 0, NULL);
4883 char *x = (char *) alloca (strlen (name) * 2 + 1);
4885 const char *y = name;
4888 /* Copy all of NAME into BUF, but put __ after
4889 every -D and at the end of each arg. */
4892 if (! strncmp (y, "-D", 2))
4903 && (*y == ' ' || *y == '\t' || *y == '='
4904 || *y == '}' || *y == 0))
4917 value = do_spec_1 (buf, 0, NULL);
4923 /* Discard the closing paren or bracket. */
4931 int c1 = *p++; /* Select first or second version number. */
4932 const char *v = compiler_version;
4934 static const char zeroc = '0';
4936 /* The format of the version string is
4937 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
4939 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
4940 while (! ISDIGIT (*v))
4942 if (v > compiler_version && v[-1] != '-')
4945 /* If desired, advance to second version number. */
4948 /* Set V after the first period. */
4949 while (ISDIGIT (*v))
4956 /* If desired, advance to third version number.
4957 But don't complain if it's not present */
4960 /* Set V after the second period. */
4961 while (ISDIGIT (*v))
4963 if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
4969 /* Set Q at the next period or at the end. */
4971 while (ISDIGIT (*q))
4973 if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
4977 /* Put that part into the command. */
4978 obstack_grow (&obstack, v, q - v);
4980 /* Default to "0" */
4981 obstack_grow (&obstack, &zeroc, 1);
4987 if (input_from_pipe)
4988 do_spec_1 ("-", 0, NULL);
4992 error ("Spec failure: Unrecognised spec option '%c'", c);
4998 /* Backslash: treat next character as ordinary. */
5003 /* Ordinary character: put it into the current argument. */
5004 obstack_1grow (&obstack, c);
5008 /* End of string. */
5012 /* Return 0 if we call do_spec_1 and that returns -1. */
5018 const char *filter, *body = NULL, *endbody = NULL;
5020 int true_once = 0; /* If, in %{a|b:d}, at least one of a,b was seen. */
5023 int include_blanks = 1;
5024 int elide_switch = 0;
5029 /* A '^' after the open-brace means to not give blanks before args. */
5036 /* A `|' after the open-brace means,
5037 if the test fails, output a single minus sign rather than nothing.
5038 This is used in %{|!pipe:...}. */
5045 /* A `<' after the open-brace means that the switch should be
5046 removed from the command-line. */
5052 negate = suffix = 0;
5055 /* A `!' after the open-brace negates the condition:
5056 succeed if the specified switch is not present. */
5060 /* A `.' after the open-brace means test against the current suffix. */
5069 if (elide_switch && (negate || pipe_p || suffix))
5071 /* It doesn't make sense to mix elision with other flags. We
5072 could fatal() here, but the standard seems to be to abort. */
5078 while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
5081 if (*p == '|' && (pipe_p || ordered))
5086 if (*p != '}' && *p != '&')
5102 fatal ("Mismatched braces in specs");
5108 body = p, endbody = p + 1;
5113 int found = (input_suffix != 0
5114 && (long) strlen (input_suffix) == (long) (p - filter)
5115 && strncmp (input_suffix, filter, p - filter) == 0);
5121 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL) < 0)
5124 else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
5126 /* Substitute all matching switches as separate args. */
5129 for (i = 0; i < n_switches; i++)
5130 if (!strncmp (switches[i].part1, filter, p - 1 - filter)
5131 && check_live_switch (i, p - 1 - filter))
5135 switches[i].live_cond = SWITCH_IGNORE;
5136 switches[i].validated = 1;
5139 ordered = 1, switches[i].ordering = 1;
5144 /* Test for presence of the specified switch. */
5148 /* If name specified ends in *, as in {x*:...},
5149 check for %* and handle that case. */
5150 if (p[-1] == '*' && !negate)
5153 const char *r = body;
5155 /* First see whether we have %*. */
5159 if (*r == '%' && r[1] == '*')
5163 /* If we do, handle that case. */
5166 /* Substitute all matching switches as separate args.
5167 But do this by substituting for %*
5168 in the text that follows the colon. */
5170 unsigned hard_match_len = p - filter - 1;
5171 char *string = save_string (body, endbody - body - 1);
5173 for (i = 0; i < n_switches; i++)
5174 if (!strncmp (switches[i].part1, filter, hard_match_len)
5175 && check_live_switch (i, -1))
5177 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
5178 /* Pass any arguments this switch has. */
5179 give_switch (i, 1, 1);
5180 suffix_subst = NULL;
5183 /* We didn't match. Try again. */
5190 /* If name specified ends in *, as in {x*:...},
5191 check for presence of any switch name starting with x. */
5194 for (i = 0; i < n_switches; i++)
5196 unsigned hard_match_len = p - filter - 1;
5198 if (!strncmp (switches[i].part1, filter, hard_match_len)
5199 && check_live_switch (i, hard_match_len))
5206 /* Otherwise, check for presence of exact name specified. */
5209 for (i = 0; i < n_switches; i++)
5211 if (!strncmp (switches[i].part1, filter, p - filter)
5212 && switches[i].part1[p - filter] == 0
5213 && check_live_switch (i, -1))
5221 /* If it is as desired (present for %{s...}, absent for %{!s...})
5222 then substitute either the switch or the specified
5223 conditional text. */
5224 if (present != negate)
5228 switches[i].live_cond = SWITCH_IGNORE;
5229 switches[i].validated = 1;
5231 else if (ordered || *p == '&')
5232 ordered = 1, switches[i].ordering = 1;
5234 give_switch (i, 0, include_blanks);
5236 /* Even if many alternatives are matched, only output once. */
5241 /* Here if a %{|...} conditional fails: output a minus sign,
5242 which means "standard output" or "standard input". */
5243 do_spec_1 ("-", 0, NULL);
5248 /* We didn't match; try again. */
5255 goto next_ampersand;
5261 /* Doing this set of switches later preserves their command-line
5262 ordering. This is needed for e.g. -U, -D and -A. */
5263 for (i = 0; i < n_switches; i++)
5264 if (switches[i].ordering == 1)
5266 switches[i].ordering = 0;
5267 give_switch (i, 0, include_blanks);
5270 /* Process the spec just once, regardless of match count. */
5273 if (do_spec_1 (save_string (body, endbody - body - 1),
5281 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5282 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5283 spec, or -1 if either exact match or %* is used.
5285 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5286 whose value does not begin with "no-" is obsoleted by the same value
5287 with the "no-", similarly for a switch with the "no-" prefix. */
5290 check_live_switch (switchnum, prefix_length)
5294 const char *name = switches[switchnum].part1;
5297 /* In the common case of {<at-most-one-letter>*}, a negating
5298 switch would always match, so ignore that case. We will just
5299 send the conflicting switches to the compiler phase. */
5300 if (prefix_length >= 0 && prefix_length <= 1)
5303 /* If we already processed this switch and determined if it was
5304 live or not, return our past determination. */
5305 if (switches[switchnum].live_cond != 0)
5306 return switches[switchnum].live_cond > 0;
5308 /* Now search for duplicate in a manner that depends on the name. */
5312 for (i = switchnum + 1; i < n_switches; i++)
5313 if (switches[i].part1[0] == 'O')
5315 switches[switchnum].validated = 1;
5316 switches[switchnum].live_cond = SWITCH_FALSE;
5321 case 'W': case 'f': case 'm':
5322 if (! strncmp (name + 1, "no-", 3))
5324 /* We have Xno-YYY, search for XYYY. */
5325 for (i = switchnum + 1; i < n_switches; i++)
5326 if (switches[i].part1[0] == name[0]
5327 && ! strcmp (&switches[i].part1[1], &name[4]))
5329 switches[switchnum].validated = 1;
5330 switches[switchnum].live_cond = SWITCH_FALSE;
5336 /* We have XYYY, search for Xno-YYY. */
5337 for (i = switchnum + 1; i < n_switches; i++)
5338 if (switches[i].part1[0] == name[0]
5339 && switches[i].part1[1] == 'n'
5340 && switches[i].part1[2] == 'o'
5341 && switches[i].part1[3] == '-'
5342 && !strcmp (&switches[i].part1[4], &name[1]))
5344 switches[switchnum].validated = 1;
5345 switches[switchnum].live_cond = SWITCH_FALSE;
5352 /* Otherwise the switch is live. */
5353 switches[switchnum].live_cond = SWITCH_LIVE;
5357 /* Pass a switch to the current accumulating command
5358 in the same form that we received it.
5359 SWITCHNUM identifies the switch; it is an index into
5360 the vector of switches gcc received, which is `switches'.
5361 This cannot fail since it never finishes a command line.
5363 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
5365 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
5369 give_switch (switchnum, omit_first_word, include_blanks)
5371 int omit_first_word;
5374 if (switches[switchnum].live_cond == SWITCH_IGNORE)
5377 if (!omit_first_word)
5379 do_spec_1 ("-", 0, NULL);
5380 do_spec_1 (switches[switchnum].part1, 1, NULL);
5383 if (switches[switchnum].args != 0)
5386 for (p = switches[switchnum].args; *p; p++)
5388 const char *arg = *p;
5391 do_spec_1 (" ", 0, NULL);
5394 unsigned length = strlen (arg);
5397 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5398 if (arg[length] == '.')
5400 ((char *)arg)[length] = 0;
5404 do_spec_1 (arg, 1, NULL);
5406 ((char *)arg)[length] = '.';
5407 do_spec_1 (suffix_subst, 1, NULL);
5410 do_spec_1 (arg, 1, NULL);
5414 do_spec_1 (" ", 0, NULL);
5415 switches[switchnum].validated = 1;
5418 /* Search for a file named NAME trying various prefixes including the
5419 user's -B prefix and some standard ones.
5420 Return the absolute file name found. If nothing is found, return NAME. */
5428 /* Try multilib_dir if it is defined. */
5429 if (multilib_dir != NULL)
5431 const char *const try = ACONCAT ((multilib_dir, dir_separator_str, name, NULL));
5433 newname = find_a_file (&startfile_prefixes, try, R_OK);
5435 /* If we don't find it in the multi library dir, then fall
5436 through and look for it in the normal places. */
5437 if (newname != NULL)
5441 newname = find_a_file (&startfile_prefixes, name, R_OK);
5442 return newname ? newname : name;
5445 /* Determine whether a directory exists. If LINKER, return 0 for
5446 certain fixed names not needed by the linker. If not LINKER, it is
5447 only important to return 0 if the host machine has a small ARG_MAX
5451 is_directory (path1, path2, linker)
5456 int len1 = strlen (path1);
5457 int len2 = strlen (path2);
5458 char *path = (char *) alloca (3 + len1 + len2);
5462 #ifndef SMALL_ARG_MAX
5467 /* Construct the path from the two parts. Ensure the string ends with "/.".
5468 The resulting path will be a directory even if the given path is a
5470 memcpy (path, path1, len1);
5471 memcpy (path + len1, path2, len2);
5472 cp = path + len1 + len2;
5473 if (!IS_DIR_SEPARATOR (cp[-1]))
5474 *cp++ = DIR_SEPARATOR;
5478 /* Exclude directories that the linker is known to search. */
5481 && strcmp (path, concat (dir_separator_str, "lib",
5482 dir_separator_str, ".", NULL)) == 0)
5484 && strcmp (path, concat (dir_separator_str, "usr",
5485 dir_separator_str, "lib",
5486 dir_separator_str, ".", NULL)) == 0)))
5489 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5492 /* Set up the various global variables to indicate that we're processing
5493 the input file named FILENAME. */
5496 set_input (filename)
5497 const char *filename;
5501 input_filename = filename;
5502 input_filename_length = strlen (input_filename);
5504 input_basename = input_filename;
5505 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5506 /* Skip drive name so 'x:foo' is handled properly. */
5507 if (input_basename[1] == ':')
5508 input_basename += 2;
5510 for (p = input_basename; *p; p++)
5511 if (IS_DIR_SEPARATOR (*p))
5512 input_basename = p + 1;
5514 /* Find a suffix starting with the last period,
5515 and set basename_length to exclude that suffix. */
5516 basename_length = strlen (input_basename);
5517 suffixed_basename_length = basename_length;
5518 p = input_basename + basename_length;
5519 while (p != input_basename && *p != '.')
5521 if (*p == '.' && p != input_basename)
5523 basename_length = p - input_basename;
5524 input_suffix = p + 1;
5530 /* On fatal signals, delete all the temporary files. */
5533 fatal_error (signum)
5536 signal (signum, SIG_DFL);
5537 delete_failure_queue ();
5538 delete_temp_files ();
5539 /* Get the same signal again, this time not handled,
5540 so its normal effect occurs. */
5541 kill (getpid (), signum);
5544 extern int main PARAMS ((int, const char *const *));
5549 const char *const *argv;
5553 int linker_was_run = 0;
5554 char *explicit_link_files;
5557 struct user_specs *uptr;
5559 p = argv[0] + strlen (argv[0]);
5560 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
5564 xmalloc_set_program_name (programname);
5566 #ifdef GCC_DRIVER_HOST_INITIALIZATION
5567 /* Perform host dependent initialization when needed. */
5568 GCC_DRIVER_HOST_INITIALIZATION;
5571 gcc_init_libintl ();
5573 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
5574 signal (SIGINT, fatal_error);
5576 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
5577 signal (SIGHUP, fatal_error);
5579 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
5580 signal (SIGTERM, fatal_error);
5582 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
5583 signal (SIGPIPE, fatal_error);
5586 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
5587 receive the signal. A different setting is inheritable */
5588 signal (SIGCHLD, SIG_DFL);
5592 argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
5594 obstack_init (&obstack);
5596 /* Build multilib_select, et. al from the separate lines that make up each
5597 multilib selection. */
5599 const char *const *q = multilib_raw;
5602 obstack_init (&multilib_obstack);
5603 while ((p = *q++) != (char *) 0)
5604 obstack_grow (&multilib_obstack, p, strlen (p));
5606 obstack_1grow (&multilib_obstack, 0);
5607 multilib_select = obstack_finish (&multilib_obstack);
5609 q = multilib_matches_raw;
5610 while ((p = *q++) != (char *) 0)
5611 obstack_grow (&multilib_obstack, p, strlen (p));
5613 obstack_1grow (&multilib_obstack, 0);
5614 multilib_matches = obstack_finish (&multilib_obstack);
5616 q = multilib_exclusions_raw;
5617 while ((p = *q++) != (char *) 0)
5618 obstack_grow (&multilib_obstack, p, strlen (p));
5620 obstack_1grow (&multilib_obstack, 0);
5621 multilib_exclusions = obstack_finish (&multilib_obstack);
5624 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
5627 obstack_1grow (&multilib_obstack, ' ');
5628 obstack_grow (&multilib_obstack,
5629 multilib_defaults_raw[i],
5630 strlen (multilib_defaults_raw[i]));
5634 obstack_1grow (&multilib_obstack, 0);
5635 multilib_defaults = obstack_finish (&multilib_obstack);
5638 /* Set up to remember the pathname of gcc and any options
5639 needed for collect. We use argv[0] instead of programname because
5640 we need the complete pathname. */
5641 obstack_init (&collect_obstack);
5642 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
5643 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
5644 putenv (obstack_finish (&collect_obstack));
5646 #ifdef INIT_ENVIRONMENT
5647 /* Set up any other necessary machine specific environment variables. */
5648 putenv (INIT_ENVIRONMENT);
5651 /* Make a table of what switches there are (switches, n_switches).
5652 Make a table of specified input files (infiles, n_infiles).
5653 Decode switches that are handled locally. */
5655 process_command (argc, argv);
5660 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5662 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5663 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5666 for (i = 0; (int) i < n_switches; i++)
5668 const char *const *args;
5671 obstack_grow (&collect_obstack, " ", 1);
5674 obstack_grow (&collect_obstack, "'-", 2);
5675 q = switches[i].part1;
5676 while ((p = strchr (q, '\'')))
5678 obstack_grow (&collect_obstack, q, p - q);
5679 obstack_grow (&collect_obstack, "'\\''", 4);
5682 obstack_grow (&collect_obstack, q, strlen (q));
5683 obstack_grow (&collect_obstack, "'", 1);
5685 for (args = switches[i].args; args && *args; args++)
5687 obstack_grow (&collect_obstack, " '", 2);
5689 while ((p = strchr (q, '\'')))
5691 obstack_grow (&collect_obstack, q, p - q);
5692 obstack_grow (&collect_obstack, "'\\''", 4);
5695 obstack_grow (&collect_obstack, q, strlen (q));
5696 obstack_grow (&collect_obstack, "'", 1);
5699 obstack_grow (&collect_obstack, "\0", 1);
5700 putenv (obstack_finish (&collect_obstack));
5703 /* Initialize the vector of specs to just the default.
5704 This means one element containing 0s, as a terminator. */
5706 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
5707 memcpy ((char *) compilers, (char *) default_compilers,
5708 sizeof default_compilers);
5709 n_compilers = n_default_compilers;
5711 /* Read specs from a file if there is one. */
5713 machine_suffix = concat (spec_machine, dir_separator_str,
5714 spec_version, dir_separator_str, NULL);
5715 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
5717 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
5718 /* Read the specs file unless it is a default one. */
5719 if (specs_file != 0 && strcmp (specs_file, "specs"))
5720 read_specs (specs_file, TRUE);
5724 /* We need to check standard_exec_prefix/just_machine_suffix/specs
5725 for any override of as, ld and libraries. */
5726 specs_file = (char *) alloca (strlen (standard_exec_prefix)
5727 + strlen (just_machine_suffix)
5728 + sizeof ("specs"));
5730 strcpy (specs_file, standard_exec_prefix);
5731 strcat (specs_file, just_machine_suffix);
5732 strcat (specs_file, "specs");
5733 if (access (specs_file, R_OK) == 0)
5734 read_specs (specs_file, TRUE);
5736 /* If not cross-compiling, look for startfiles in the standard places. */
5737 if (*cross_compile == '0')
5739 if (*md_exec_prefix)
5741 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
5742 PREFIX_PRIORITY_LAST, 0, NULL);
5743 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
5744 PREFIX_PRIORITY_LAST, 0, NULL);
5747 if (*md_startfile_prefix)
5748 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
5749 PREFIX_PRIORITY_LAST, 0, NULL);
5751 if (*md_startfile_prefix_1)
5752 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
5753 PREFIX_PRIORITY_LAST, 0, NULL);
5755 /* If standard_startfile_prefix is relative, base it on
5756 standard_exec_prefix. This lets us move the installed tree
5757 as a unit. If GCC_EXEC_PREFIX is defined, base
5758 standard_startfile_prefix on that as well. */
5759 if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix))
5760 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
5761 PREFIX_PRIORITY_LAST, 0, NULL);
5764 if (gcc_exec_prefix)
5765 add_prefix (&startfile_prefixes,
5766 concat (gcc_exec_prefix, machine_suffix,
5767 standard_startfile_prefix, NULL),
5768 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
5769 add_prefix (&startfile_prefixes,
5770 concat (standard_exec_prefix,
5772 standard_startfile_prefix, NULL),
5773 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
5776 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
5777 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5778 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
5779 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5780 #if 0 /* Can cause surprises, and one can use -B./ instead. */
5781 add_prefix (&startfile_prefixes, "./", NULL,
5782 PREFIX_PRIORITY_LAST, 1, NULL);
5787 if (!IS_ABSOLUTE_PATHNAME (standard_startfile_prefix)
5789 add_prefix (&startfile_prefixes,
5790 concat (gcc_exec_prefix, machine_suffix,
5791 standard_startfile_prefix, NULL),
5792 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5795 /* Process any user specified specs in the order given on the command
5797 for (uptr = user_specs_head; uptr; uptr = uptr->next)
5799 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
5800 read_specs (filename ? filename : uptr->filename, FALSE);
5803 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
5804 if (gcc_exec_prefix)
5805 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
5806 spec_version, dir_separator_str, NULL);
5808 /* Now we have the specs.
5809 Set the `valid' bits for switches that match anything in any spec. */
5811 validate_all_switches ();
5813 /* Now that we have the switches and the specs, set
5814 the subdirectory based on the options. */
5815 set_multilib_dir ();
5817 /* Warn about any switches that no pass was interested in. */
5819 for (i = 0; (int) i < n_switches; i++)
5820 if (! switches[i].validated)
5821 error ("unrecognized option `-%s'", switches[i].part1);
5823 /* Obey some of the options. */
5825 if (print_search_dirs)
5827 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
5828 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
5829 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
5833 if (print_file_name)
5835 printf ("%s\n", find_file (print_file_name));
5839 if (print_prog_name)
5841 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
5842 printf ("%s\n", (newname ? newname : print_prog_name));
5846 if (print_multi_lib)
5848 print_multilib_info ();
5852 if (print_multi_directory)
5854 if (multilib_dir == NULL)
5857 printf ("%s\n", multilib_dir);
5861 if (target_help_flag)
5863 /* Print if any target specific options.*/
5865 /* We do not exit here. Instead we have created a fake input file
5866 called 'target-dummy' which needs to be compiled, and we pass this
5867 on to the various sub-processes, along with the --target-help
5871 if (print_help_list)
5877 printf (_("\nFor bug reporting instructions, please see:\n"));
5878 printf ("%s.\n", GCCBUGURL);
5883 /* We do not exit here. Instead we have created a fake input file
5884 called 'help-dummy' which needs to be compiled, and we pass this
5885 on the various sub-processes, along with the --help switch. */
5893 notice ("Configured with: %s\n", configuration_arguments);
5895 #ifdef THREAD_MODEL_SPEC
5896 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
5897 but there's no point in doing all this processing just to get
5898 thread_model back. */
5899 obstack_init (&obstack);
5900 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
5901 obstack_1grow (&obstack, '\0');
5902 thrmod = obstack_finish (&obstack);
5904 thrmod = thread_model;
5907 notice ("Thread model: %s\n", thrmod);
5909 /* compiler_version is truncated at the first space when initialized
5910 from version string, so truncate version_string at the first space
5911 before comparing. */
5912 for (n = 0; version_string[n]; n++)
5913 if (version_string[n] == ' ')
5916 if (! strncmp (version_string, compiler_version, n)
5917 && compiler_version[n] == 0)
5918 notice ("gcc version %s\n", version_string);
5920 notice ("gcc driver version %s executing gcc version %s\n",
5921 version_string, compiler_version);
5927 if (n_infiles == added_libraries)
5928 fatal ("No input files");
5930 /* Make a place to record the compiler output file names
5931 that correspond to the input files. */
5934 i += lang_specific_extra_outfiles;
5935 outfiles = (const char **) xcalloc (i, sizeof (char *));
5937 /* Record which files were specified explicitly as link input. */
5939 explicit_link_files = xcalloc (1, n_infiles);
5941 for (i = 0; (int) i < n_infiles; i++)
5943 int this_file_error = 0;
5945 /* Tell do_spec what to substitute for %i. */
5947 input_file_number = i;
5948 set_input (infiles[i].name);
5950 /* Use the same thing in %o, unless cp->spec says otherwise. */
5952 outfiles[i] = input_filename;
5954 /* Figure out which compiler from the file's suffix. */
5957 = lookup_compiler (infiles[i].name, input_filename_length,
5958 infiles[i].language);
5960 if (input_file_compiler)
5962 /* Ok, we found an applicable compiler. Run its spec. */
5964 if (input_file_compiler->spec[0] == '#')
5966 error ("%s: %s compiler not installed on this system",
5967 input_filename, &input_file_compiler->spec[1]);
5968 this_file_error = 1;
5972 value = do_spec (input_file_compiler->spec);
5974 this_file_error = 1;
5978 /* If this file's name does not contain a recognized suffix,
5979 record it as explicit linker input. */
5982 explicit_link_files[i] = 1;
5984 /* Clear the delete-on-failure queue, deleting the files in it
5985 if this compilation failed. */
5987 if (this_file_error)
5989 delete_failure_queue ();
5992 /* If this compilation succeeded, don't delete those files later. */
5993 clear_failure_queue ();
5996 /* Reset the output file name to the first input file name, for use
5997 with %b in LINK_SPEC on a target that prefers not to emit a.out
6000 set_input (infiles[0].name);
6002 if (error_count == 0)
6004 /* Make sure INPUT_FILE_NUMBER points to first available open
6006 input_file_number = n_infiles;
6007 if (lang_specific_pre_link ())
6011 /* Run ld to link all the compiler output files. */
6013 if (error_count == 0)
6015 int tmp = execution_count;
6017 /* We'll use ld if we can't find collect2. */
6018 if (! strcmp (linker_name_spec, "collect2"))
6020 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
6022 linker_name_spec = "ld";
6024 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6026 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6027 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6029 value = do_spec (link_command_spec);
6032 linker_was_run = (tmp != execution_count);
6035 /* If options said don't run linker,
6036 complain about input files to be given to the linker. */
6038 if (! linker_was_run && error_count == 0)
6039 for (i = 0; (int) i < n_infiles; i++)
6040 if (explicit_link_files[i])
6041 error ("%s: linker input file unused because linking not done",
6044 /* Delete some or all of the temporary files we made. */
6047 delete_failure_queue ();
6048 delete_temp_files ();
6050 if (print_help_list)
6052 printf (("\nFor bug reporting instructions, please see:\n"));
6053 printf ("%s\n", GCCBUGURL);
6056 return (signal_count != 0 ? 2
6057 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6061 /* Find the proper compilation spec for the file name NAME,
6062 whose length is LENGTH. LANGUAGE is the specified language,
6063 or 0 if this file is to be passed to the linker. */
6065 static struct compiler *
6066 lookup_compiler (name, length, language)
6069 const char *language;
6071 struct compiler *cp;
6073 /* If this was specified by the user to be a linker input, indicate that. */
6074 if (language != 0 && language[0] == '*')
6077 /* Otherwise, look for the language, if one is spec'd. */
6080 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6081 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6084 error ("language %s not recognized", language);
6088 /* Look for a suffix. */
6089 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6091 if (/* The suffix `-' matches only the file name `-'. */
6092 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6093 || (strlen (cp->suffix) < length
6094 /* See if the suffix matches the end of NAME. */
6095 && !strcmp (cp->suffix,
6096 name + length - strlen (cp->suffix))
6101 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6102 /* look again, but case-insensitively this time. */
6104 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6106 if (/* The suffix `-' matches only the file name `-'. */
6107 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6108 || (strlen (cp->suffix) < length
6109 /* See if the suffix matches the end of NAME. */
6110 && ((!strcmp (cp->suffix,
6111 name + length - strlen (cp->suffix))
6112 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6113 && !strcasecmp (cp->suffix,
6114 name + length - strlen (cp->suffix)))
6120 if (cp >= compilers)
6122 if (cp->spec[0] != '@')
6123 /* A non-alias entry: return it. */
6126 /* An alias entry maps a suffix to a language.
6127 Search for the language; pass 0 for NAME and LENGTH
6128 to avoid infinite recursion if language not found. */
6129 return lookup_compiler (NULL, 0, cp->spec + 1);
6135 save_string (s, len)
6139 char *result = xmalloc (len + 1);
6141 memcpy (result, s, len);
6147 pfatal_with_name (name)
6150 perror_with_name (name);
6151 delete_temp_files ();
6156 perror_with_name (name)
6159 error ("%s: %s", name, xstrerror (errno));
6163 pfatal_pexecute (errmsg_fmt, errmsg_arg)
6164 const char *errmsg_fmt;
6165 const char *errmsg_arg;
6169 int save_errno = errno;
6171 /* Space for trailing '\0' is in %s. */
6172 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
6173 sprintf (msg, errmsg_fmt, errmsg_arg);
6179 pfatal_with_name (errmsg_fmt);
6182 /* Output an error message and exit */
6187 fatal ("Internal gcc abort.");
6190 /* Output an error message and exit */
6193 fatal VPARAMS ((const char *msgid, ...))
6195 VA_OPEN (ap, msgid);
6196 VA_FIXEDARG (ap, const char *, msgid);
6198 fprintf (stderr, "%s: ", programname);
6199 vfprintf (stderr, _(msgid), ap);
6201 fprintf (stderr, "\n");
6202 delete_temp_files ();
6207 error VPARAMS ((const char *msgid, ...))
6209 VA_OPEN (ap, msgid);
6210 VA_FIXEDARG (ap, const char *, msgid);
6212 fprintf (stderr, "%s: ", programname);
6213 vfprintf (stderr, _(msgid), ap);
6216 fprintf (stderr, "\n");
6220 notice VPARAMS ((const char *msgid, ...))
6222 VA_OPEN (ap, msgid);
6223 VA_FIXEDARG (ap, const char *, msgid);
6225 vfprintf (stderr, _(msgid), ap);
6230 validate_all_switches ()
6232 struct compiler *comp;
6235 struct spec_list *spec;
6237 for (comp = compilers; comp->spec; comp++)
6241 if (c == '%' && *p == '{')
6242 /* We have a switch spec. */
6243 validate_switches (p + 1);
6246 /* Look through the linked list of specs read from the specs file. */
6247 for (spec = specs; spec; spec = spec->next)
6249 p = *(spec->ptr_spec);
6251 if (c == '%' && *p == '{')
6252 /* We have a switch spec. */
6253 validate_switches (p + 1);
6256 p = link_command_spec;
6258 if (c == '%' && *p == '{')
6259 /* We have a switch spec. */
6260 validate_switches (p + 1);
6263 /* Look at the switch-name that comes after START
6264 and mark as valid all supplied switches that match it. */
6267 validate_switches (start)
6270 const char *p = start;
6287 while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
6292 else if (p[-1] == '*')
6294 /* Mark all matching switches as valid. */
6295 for (i = 0; i < n_switches; i++)
6296 if (!strncmp (switches[i].part1, filter, p - filter - 1))
6297 switches[i].validated = 1;
6301 /* Mark an exact matching switch as valid. */
6302 for (i = 0; i < n_switches; i++)
6304 if (!strncmp (switches[i].part1, filter, p - filter)
6305 && switches[i].part1[p - filter] == 0)
6306 switches[i].validated = 1;
6310 if (*p++ == '|' || p[-1] == '&')
6314 /* Check whether a particular argument was used. The first time we
6315 canonicalize the switches to keep only the ones we care about. */
6325 const char *replace;
6330 static struct mswitchstr *mswitches;
6331 static int n_mswitches;
6336 struct mswitchstr *matches;
6340 /* Break multilib_matches into the component strings of string
6341 and replacement string. */
6342 for (q = multilib_matches; *q != '\0'; q++)
6347 (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
6349 q = multilib_matches;
6359 matches[i].len = q - matches[i].str;
6361 matches[i].replace = ++q;
6362 while (*q != ';' && *q != '\0')
6368 matches[i].rep_len = q - matches[i].replace;
6374 /* Now build a list of the replacement string for switches that we care
6375 about. Make sure we allocate at least one entry. This prevents
6376 xmalloc from calling fatal, and prevents us from re-executing this
6379 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
6380 * (n_switches ? n_switches : 1));
6381 for (i = 0; i < n_switches; i++)
6383 int xlen = strlen (switches[i].part1);
6384 for (j = 0; j < cnt; j++)
6385 if (xlen == matches[j].len
6386 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6388 mswitches[n_mswitches].str = matches[j].replace;
6389 mswitches[n_mswitches].len = matches[j].rep_len;
6390 mswitches[n_mswitches].replace = (char *) 0;
6391 mswitches[n_mswitches].rep_len = 0;
6398 for (i = 0; i < n_mswitches; i++)
6399 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6406 default_arg (p, len)
6410 const char *start, *end;
6412 for (start = multilib_defaults; *start != '\0'; start = end + 1)
6414 while (*start == ' ' || *start == '\t')
6420 for (end = start + 1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
6423 if ((end - start) == len && strncmp (p, start, len) == 0)
6433 /* Work out the subdirectory to use based on the options. The format of
6434 multilib_select is a list of elements. Each element is a subdirectory
6435 name followed by a list of options followed by a semicolon. The format
6436 of multilib_exclusions is the same, but without the preceding
6437 directory. First gcc will check the exclusions, if none of the options
6438 beginning with an exclamation point are present, and all of the other
6439 options are present, then we will ignore this completely. Passing
6440 that, gcc will consider each multilib_select in turn using the same
6441 rules for matching the options. If a match is found, that subdirectory
6448 unsigned int this_path_len;
6449 const char *this_path, *this_arg;
6453 p = multilib_exclusions;
6456 /* Ignore newlines. */
6463 /* Check the arguments. */
6477 while (*p != ' ' && *p != ';')
6484 if (*this_arg != '!')
6492 ok = used_arg (this_arg, p - this_arg);
6506 p = multilib_select;
6509 /* Ignore newlines. */
6516 /* Get the initial path. */
6524 this_path_len = p - this_path;
6526 /* Check the arguments. */
6541 while (*p != ' ' && *p != ';')
6548 if (*this_arg != '!')
6556 /* If this is a default argument, we can just ignore it.
6557 This is true even if this_arg begins with '!'. Beginning
6558 with '!' does not mean that this argument is necessarily
6559 inappropriate for this library: it merely means that
6560 there is a more specific library which uses this
6561 argument. If this argument is a default, we need not
6562 consider that more specific library. */
6563 if (! default_arg (this_arg, p - this_arg))
6565 ok = used_arg (this_arg, p - this_arg);
6576 if (this_path_len != 1
6577 || this_path[0] != '.')
6579 char *new_multilib_dir = xmalloc (this_path_len + 1);
6580 strncpy (new_multilib_dir, this_path, this_path_len);
6581 new_multilib_dir[this_path_len] = '\0';
6582 multilib_dir = new_multilib_dir;
6591 /* Print out the multiple library subdirectory selection
6592 information. This prints out a series of lines. Each line looks
6593 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
6594 required. Only the desired options are printed out, the negative
6595 matches. The options are print without a leading dash. There are
6596 no spaces to make it easy to use the information in the shell.
6597 Each subdirectory is printed only once. This assumes the ordering
6598 generated by the genmultilib script. Also, we leave out ones that match
6602 print_multilib_info ()
6604 const char *p = multilib_select;
6605 const char *last_path = 0, *this_path;
6607 unsigned int last_path_len = 0;
6612 /* Ignore newlines. */
6619 /* Get the initial path. */
6628 /* Check for matches with the multilib_exclusions. We don't bother
6629 with the '!' in either list. If any of the exclusion rules match
6630 all of its options with the select rule, we skip it. */
6632 const char *e = multilib_exclusions;
6633 const char *this_arg;
6638 /* Ignore newlines. */
6645 /* Check the arguments. */
6662 while (*e != ' ' && *e != ';')
6673 int len = e - this_arg;
6680 while (*q != ' ' && *q != ';')
6687 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
6688 default_arg (this_arg, e - this_arg))
6718 /* If this is a duplicate, skip it. */
6719 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len
6720 && ! strncmp (last_path, this_path, last_path_len));
6722 last_path = this_path;
6723 last_path_len = p - this_path;
6726 /* If this directory requires any default arguments, we can skip
6727 it. We will already have printed a directory identical to
6728 this one which does not require that default argument. */
6746 while (*q != ' ' && *q != ';')
6754 && default_arg (arg, q - arg))
6769 for (p1 = last_path; p1 < p; p1++)
6788 use_arg = *p != '!';
6793 while (*p != ' ' && *p != ';')
6808 /* If there are extra options, print them now. */
6809 if (multilib_extra && *multilib_extra)
6811 int print_at = TRUE;
6814 for (q = multilib_extra; *q != '\0'; q++)