1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 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 #ifdef HAVE_SYS_RESOURCE_H
86 #include <sys/resource.h>
88 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
89 extern int getrusage PARAMS ((int, struct rusage *));
92 /* By default there is no special suffix for target executables. */
93 /* FIXME: when autoconf is fixed, remove the host check - dj */
94 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
95 #define HAVE_TARGET_EXECUTABLE_SUFFIX
97 #undef TARGET_EXECUTABLE_SUFFIX
98 #define TARGET_EXECUTABLE_SUFFIX ""
101 /* By default there is no special suffix for host executables. */
102 #ifdef HOST_EXECUTABLE_SUFFIX
103 #define HAVE_HOST_EXECUTABLE_SUFFIX
105 #define HOST_EXECUTABLE_SUFFIX ""
108 /* By default, the suffix for target object files is ".o". */
109 #ifdef TARGET_OBJECT_SUFFIX
110 #define HAVE_TARGET_OBJECT_SUFFIX
112 #define TARGET_OBJECT_SUFFIX ".o"
116 /* FIXME: the location independence code for VMS is hairier than this,
117 and hasn't been written. */
123 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
125 #define obstack_chunk_alloc xmalloc
126 #define obstack_chunk_free free
128 #ifndef GET_ENV_PATH_LIST
129 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
132 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
133 #ifndef LIBRARY_PATH_ENV
134 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
138 #define kill(p,s) raise(s)
141 /* If a stage of compilation returns an exit status >= 1,
142 compilation of that file ceases. */
144 #define MIN_FATAL_STATUS 1
146 /* Flag set by cppspec.c to 1. */
149 /* Flag saying to pass the greatest exit code returned by a sub-process
150 to the calling program. */
151 static int pass_exit_codes;
153 /* Definition of string containing the arguments given to configure. */
154 #include "configargs.h"
156 /* Flag saying to print the directories gcc will search through looking for
157 programs, libraries, etc. */
159 static int print_search_dirs;
161 /* Flag saying to print the full filename of this file
162 as found through our usual search mechanism. */
164 static const char *print_file_name = NULL;
166 /* As print_file_name, but search for executable file. */
168 static const char *print_prog_name = NULL;
170 /* Flag saying to print the relative path we'd use to
171 find libgcc.a given the current compiler flags. */
173 static int print_multi_directory;
175 /* Flag saying to print the list of subdirectories and
176 compiler flags used to select them in a standard form. */
178 static int print_multi_lib;
180 /* Flag saying to print the command line options understood by gcc and its
183 static int print_help_list;
185 /* Flag indicating whether we should print the command and arguments */
187 static int verbose_flag;
189 /* Flag indicating whether we should ONLY print the command and
190 arguments (like verbose_flag) without executing the command.
191 Displayed arguments are quoted so that the generated command
192 line is suitable for execution. This is intended for use in
193 shell scripts to capture the driver-generated command line. */
194 static int verbose_only_flag;
196 /* Flag indicating to print target specific command line options. */
198 static int target_help_flag;
200 /* Flag indicating whether we should report subprocess execution times
201 (if this is supported by the system - see pexecute.c). */
203 static int report_times;
205 /* Nonzero means write "temp" files in source directory
206 and use the source file's name in them, and don't delete them. */
208 static int save_temps_flag;
210 /* The compiler version. */
212 static const char *compiler_version;
214 /* The target version specified with -V */
216 static const char *const spec_version = DEFAULT_TARGET_VERSION;
218 /* The target machine specified with -b. */
220 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
222 /* Nonzero if cross-compiling.
223 When -b is used, the value comes from the `specs' file. */
226 static const char *cross_compile = "1";
228 static const char *cross_compile = "0";
231 #ifdef MODIFY_TARGET_NAME
233 /* Information on how to alter the target name based on a command-line
234 switch. The only case we support now is simply appending or deleting a
235 string to or from the end of the first part of the configuration name. */
237 static const struct modify_target
239 const char *const sw;
240 const enum add_del {ADD, DELETE} add_del;
241 const char *const str;
243 modify_target[] = MODIFY_TARGET_NAME;
246 /* The number of errors that have occurred; the link phase will not be
247 run if this is non-zero. */
248 static int error_count = 0;
250 /* Greatest exit code of sub-processes that has been encountered up to
252 static int greatest_status = 1;
254 /* This is the obstack which we use to allocate many strings. */
256 static struct obstack obstack;
258 /* This is the obstack to build an environment variable to pass to
259 collect2 that describes all of the relevant switches of what to
260 pass the compiler in building the list of pointers to constructors
263 static struct obstack collect_obstack;
265 /* These structs are used to collect resource usage information for
267 #ifdef HAVE_GETRUSAGE
268 static struct rusage rus, prus;
271 /* Forward declaration for prototypes. */
274 static void init_spec PARAMS ((void));
276 static char **split_directories PARAMS ((const char *, int *));
277 static void free_split_directories PARAMS ((char **));
278 static char *make_relative_prefix PARAMS ((const char *, const char *, const char *));
280 static void store_arg PARAMS ((const char *, int, int));
281 static char *load_specs PARAMS ((const char *));
282 static void read_specs PARAMS ((const char *, int));
283 static void set_spec PARAMS ((const char *, const char *));
284 static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
285 static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
286 static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
287 static int access_check PARAMS ((const char *, int));
288 static char *find_a_file PARAMS ((struct path_prefix *, const char *, int));
289 static void add_prefix PARAMS ((struct path_prefix *, const char *,
290 const char *, int, int, int *));
291 static void translate_options PARAMS ((int *, const char *const **));
292 static char *skip_whitespace PARAMS ((char *));
293 static void delete_if_ordinary PARAMS ((const char *));
294 static void delete_temp_files PARAMS ((void));
295 static void delete_failure_queue PARAMS ((void));
296 static void clear_failure_queue PARAMS ((void));
297 static int check_live_switch PARAMS ((int, int));
298 static const char *handle_braces PARAMS ((const char *));
299 static char *save_string PARAMS ((const char *, int));
300 static void set_collect_gcc_options PARAMS ((void));
301 static int do_spec_1 PARAMS ((const char *, int, const char *));
302 static int do_spec_2 PARAMS ((const char *));
303 static const char *find_file PARAMS ((const char *));
304 static int is_directory PARAMS ((const char *, const char *, int));
305 static void validate_switches PARAMS ((const char *));
306 static void validate_all_switches PARAMS ((void));
307 static void give_switch PARAMS ((int, int, int));
308 static int used_arg PARAMS ((const char *, int));
309 static int default_arg PARAMS ((const char *, int));
310 static void set_multilib_dir PARAMS ((void));
311 static void print_multilib_info PARAMS ((void));
312 static void perror_with_name PARAMS ((const char *));
313 static void pfatal_pexecute PARAMS ((const char *, const char *))
315 static void notice PARAMS ((const char *, ...))
317 static void display_help PARAMS ((void));
318 static void add_preprocessor_option PARAMS ((const char *, int));
319 static void add_assembler_option PARAMS ((const char *, int));
320 static void add_linker_option PARAMS ((const char *, int));
321 static void process_command PARAMS ((int, const char *const *));
322 static int execute PARAMS ((void));
323 static void clear_args PARAMS ((void));
324 static void fatal_error PARAMS ((int));
325 #ifdef ENABLE_SHARED_LIBGCC
326 static void init_gcc_specs PARAMS ((struct obstack *,
327 const char *, const char *,
330 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
331 static const char *convert_filename PARAMS ((const char *, int, int));
334 /* The Specs Language
336 Specs are strings containing lines, each of which (if not blank)
337 is made up of a program name, and arguments separated by spaces.
338 The program name must be exact and start from root, since no path
339 is searched and it is unreliable to depend on the current working directory.
340 Redirection of input or output is not supported; the subprograms must
341 accept filenames saying what files to read and write.
343 In addition, the specs can contain %-sequences to substitute variable text
344 or for conditional text. Here is a table of all defined %-sequences.
345 Note that spaces are not generated automatically around the results of
346 expanding these sequences; therefore, you can concatenate them together
347 or with constant text in a single argument.
349 %% substitute one % into the program name or argument.
350 %i substitute the name of the input file being processed.
351 %b substitute the basename of the input file being processed.
352 This is the substring up to (and not including) the last period
353 and not including the directory.
354 %B same as %b, but include the file suffix (text after the last period).
356 substitute a file name that has suffix SUFFIX and is chosen
357 once per compilation, and mark the argument a la %d. To reduce
358 exposure to denial-of-service attacks, the file name is now
359 chosen in a way that is hard to predict even when previously
360 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
361 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
362 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
363 had been pre-processed. Previously, %g was simply substituted
364 with a file name chosen once per compilation, without regard
365 to any appended suffix (which was therefore treated just like
366 ordinary text), making such attacks more likely to succeed.
368 like %g, but generates a new temporary file name even if %uSUFFIX
371 substitutes the last file name generated with %uSUFFIX, generating a
372 new one if there is no such last file name. In the absence of any
373 %uSUFFIX, this is just like %gSUFFIX, except they don't share
374 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
375 would involve the generation of two distinct file names, one
376 for each `%g.s' and another for each `%U.s'. Previously, %U was
377 simply substituted with a file name chosen for the previous %u,
378 without regard to any appended suffix.
380 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
381 writable, and if save-temps is off; otherwise, substitute the name
382 of a temporary file, just like %u. This temporary file is not
383 meant for communication between processes, but rather as a junk
386 substitutes .SUFFIX for the suffixes of a matched switch's args when
387 it is subsequently output with %*. SUFFIX is terminated by the next
389 %d marks the argument containing or following the %d as a
390 temporary file name, so that that file will be deleted if CC exits
391 successfully. Unlike %g, this contributes no text to the argument.
392 %w marks the argument containing or following the %w as the
393 "output file" of this compilation. This puts the argument
394 into the sequence of arguments that %o will substitute later.
396 like %{...} but mark last argument supplied within
397 as a file to be deleted on failure.
398 %o substitutes the names of all the output files, with spaces
399 automatically placed around them. You should write spaces
400 around the %o as well or the results are undefined.
401 %o is for use in the specs for running the linker.
402 Input files whose names have no recognized suffix are not compiled
403 at all, but they are included among the output files, so they will
405 %O substitutes the suffix for object files. Note that this is
406 handled specially when it immediately follows %g, %u, or %U
407 (with or without a suffix argument) because of the need for
408 those to form complete file names. The handling is such that
409 %O is treated exactly as if it had already been substituted,
410 except that %g, %u, and %U do not currently support additional
411 SUFFIX characters following %O as they would following, for
413 %p substitutes the standard macro predefinitions for the
414 current target machine. Use this when running cpp.
415 %P like %p, but puts `__' before and after the name of each macro.
416 (Except macros that already have __.)
418 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
419 %s current argument is the name of a library or startup file of some sort.
420 Search for that file in a standard list of directories
421 and substitute the full name found.
422 %eSTR Print STR as an error message. STR is terminated by a newline.
423 Use this when inconsistent options are detected.
424 %nSTR Print STR as an notice. STR is terminated by a newline.
425 %x{OPTION} Accumulate an option for %X.
426 %X Output the accumulated linker options specified by compilations.
427 %Y Output the accumulated assembler options specified by compilations.
428 %Z Output the accumulated preprocessor options specified by compilations.
429 %v1 Substitute the major version number of GCC.
430 (For version 2.5.3, this is 2.)
431 %v2 Substitute the minor version number of GCC.
432 (For version 2.5.3, this is 5.)
433 %v3 Substitute the patch level number of GCC.
434 (For version 2.5.3, this is 3.)
435 %a process ASM_SPEC as a spec.
436 This allows config.h to specify part of the spec for running as.
437 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
438 used here. This can be used to run a post-processor after the
439 assembler has done its job.
440 %D Dump out a -L option for each directory in startfile_prefixes.
441 If multilib_dir is set, extra entries are generated with it affixed.
442 %l process LINK_SPEC as a spec.
443 %L process LIB_SPEC as a spec.
444 %G process LIBGCC_SPEC as a spec.
445 %M output multilib_dir with directory separators replaced with "_";
446 if multilib_dir is not set or is ".", output "".
447 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
448 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
449 %C process CPP_SPEC as a spec.
450 %1 process CC1_SPEC as a spec.
451 %2 process CC1PLUS_SPEC as a spec.
452 %| output "-" if the input for the current command is coming from a pipe.
453 %* substitute the variable part of a matched option. (See below.)
454 Note that each comma in the substituted string is replaced by
456 %{S} substitutes the -S switch, if that switch was given to CC.
457 If that switch was not specified, this substitutes nothing.
458 Here S is a metasyntactic variable.
459 %{S*} substitutes all the switches specified to CC whose names start
460 with -S. This is used for -o, -I, etc; switches that take
461 arguments. CC considers `-o foo' as being one switch whose
462 name starts with `o'. %{o*} would substitute this text,
463 including the space; thus, two arguments would be generated.
464 %{^S*} likewise, but don't put a blank between a switch and any args.
465 %{S*&T*} likewise, but preserve order of S and T options (the order
466 of S and T in the spec is not significant). Can be any number
467 of ampersand-separated variables; for each the wild card is
468 optional. Useful for CPP as %{D*&U*&A*}.
469 %{S*:X} substitutes X if one or more switches whose names start with -S are
470 specified to CC. Note that the tail part of the -S option
471 (i.e. the part matched by the `*') will be substituted for each
472 occurrence of %* within X.
473 %{<S} remove all occurrences of -S from the command line.
474 Note - this option is position dependent. % commands in the
475 spec string before this option will see -S, % commands in the
476 spec string after this option will not.
477 %{S:X} substitutes X, but only if the -S switch was given to CC.
478 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
479 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
480 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
481 %{.S:X} substitutes X, but only if processing a file with suffix S.
482 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
483 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
484 combined with ! and . as above binding stronger than the OR.
485 %(Spec) processes a specification defined in a specs file as *Spec:
486 %[Spec] as above, but put __ around -D arguments
488 The conditional text X in a %{S:X} or %{!S:X} construct may contain
489 other nested % constructs or spaces, or even newlines. They are
490 processed as usual, as described above.
492 The -O, -f, -m, and -W switches are handled specifically in these
493 constructs. If another value of -O or the negated form of a -f, -m, or
494 -W switch is found later in the command line, the earlier switch
495 value is ignored, except with {S*} where S is just one letter; this
496 passes all matching options.
498 The character | at the beginning of the predicate text is used to indicate
499 that a command should be piped to the following command, but only if -pipe
502 Note that it is built into CC which switches take arguments and which
503 do not. You might think it would be useful to generalize this to
504 allow each compiler's spec to say which switches take arguments. But
505 this cannot be done in a consistent fashion. CC cannot even decide
506 which input files have been specified without knowing which switches
507 take arguments, and it must know which input files to compile in order
508 to tell which compilers to run.
510 CC also knows implicitly that arguments starting in `-l' are to be
511 treated as compiler output files, and passed to the linker in their
512 proper position among the other output files. */
514 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
516 /* config.h can define ASM_SPEC to provide extra args to the assembler
517 or extra switch-translations. */
522 /* config.h can define ASM_FINAL_SPEC to run a post processor after
523 the assembler has run. */
524 #ifndef ASM_FINAL_SPEC
525 #define ASM_FINAL_SPEC ""
528 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
529 or extra switch-translations. */
534 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
535 or extra switch-translations. */
540 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
541 or extra switch-translations. */
543 #define CC1PLUS_SPEC ""
546 /* config.h can define LINK_SPEC to provide extra args to the linker
547 or extra switch-translations. */
552 /* config.h can define LIB_SPEC to override the default libraries. */
554 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
557 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
560 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
561 /* Have gcc do the search for libgcc.a. */
562 #define LIBGCC_SPEC "libgcc.a%s"
564 #define LIBGCC_SPEC "-lgcc"
568 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
569 #ifndef STARTFILE_SPEC
570 #define STARTFILE_SPEC \
571 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
574 /* config.h can define SWITCHES_NEED_SPACES to control which options
575 require spaces between the option and the argument. */
576 #ifndef SWITCHES_NEED_SPACES
577 #define SWITCHES_NEED_SPACES ""
580 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
582 #define ENDFILE_SPEC ""
586 #define LINKER_NAME "collect2"
589 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
591 #ifndef ASM_DEBUG_SPEC
592 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
593 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
594 # define ASM_DEBUG_SPEC \
595 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
596 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
597 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
599 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
600 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
602 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
603 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
607 #ifndef ASM_DEBUG_SPEC
608 # define ASM_DEBUG_SPEC ""
611 /* Here is the spec for running the linker, after compiling all files. */
613 /* This is overridable by the target in case they need to specify the
614 -lgcc and -lc order specially, yet not require them to override all
615 of LINK_COMMAND_SPEC. */
616 #ifndef LINK_GCC_C_SEQUENCE_SPEC
617 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
620 /* -u* was put back because both BSD and SysV seem to support it. */
621 /* %{static:} simply prevents an error message if the target machine
622 doesn't handle -static. */
623 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
624 scripts which exist in user specified directories, or in standard
626 #ifndef LINK_COMMAND_SPEC
627 #define LINK_COMMAND_SPEC "\
628 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
629 %(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r} %{s} %{t}\
630 %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
631 %{static:} %{L*} %(link_libgcc) %o %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
632 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
635 #ifndef LINK_LIBGCC_SPEC
636 # ifdef LINK_LIBGCC_SPECIAL
637 /* Don't generate -L options for startfile prefix list. */
638 # define LINK_LIBGCC_SPEC ""
640 /* Do generate them. */
641 # define LINK_LIBGCC_SPEC "%D"
645 #ifndef STARTFILE_PREFIX_SPEC
646 # define STARTFILE_PREFIX_SPEC ""
649 static const char *asm_debug;
650 static const char *cpp_spec = CPP_SPEC;
651 static const char *cpp_predefines = CPP_PREDEFINES;
652 static const char *cc1_spec = CC1_SPEC;
653 static const char *cc1plus_spec = CC1PLUS_SPEC;
654 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
655 static const char *asm_spec = ASM_SPEC;
656 static const char *asm_final_spec = ASM_FINAL_SPEC;
657 static const char *link_spec = LINK_SPEC;
658 static const char *lib_spec = LIB_SPEC;
659 static const char *libgcc_spec = LIBGCC_SPEC;
660 static const char *endfile_spec = ENDFILE_SPEC;
661 static const char *startfile_spec = STARTFILE_SPEC;
662 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
663 static const char *linker_name_spec = LINKER_NAME;
664 static const char *link_command_spec = LINK_COMMAND_SPEC;
665 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
666 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
668 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
669 There should be no need to override these in target dependent files,
670 but we need to copy them to the specs file so that newer versions
671 of the GCC driver can correctly drive older tool chains with the
672 appropriate -B options. */
674 /* When cpplib handles traditional preprocessing, get rid of this, and
675 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
676 that we default the front end language better. */
677 static const char *trad_capable_cpp =
678 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
680 static const char *cpp_unique_options =
681 "%{C:%{!E:%eGNU C does not support -C without using -E}}\
682 %{CC:%{!E:%eGNU C does not support -CC without using -E}}\
683 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %{$} %I\
684 %{MD:-MD %W{!o: %b.d}%W{o*:%.d%*}}\
685 %{MMD:-MMD %W{!o: %b.d}%W{o*:%.d%*}}\
686 %{M} %{MM} %W{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
687 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
688 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
689 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
690 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
693 /* This contains cpp options which are common with cc1_options and are passed
694 only when preprocessing only to avoid duplication. We pass the cc1 spec
695 options to the preprocessor so that it the cc1 spec may manipulate
696 options used to set target flags. Those special target flags settings may
697 in turn cause preprocessor symbols to be defined specially. */
698 static const char *cpp_options =
699 "%(cpp_unique_options) %1 %{std*} %{W*&pedantic*} %{w} %{m*} %{f*}\
702 /* This contains cpp options which are not passed when the preprocessor
703 output will be used by another program. */
704 static const char *cpp_debug_options = "%{d*}";
706 /* NB: This is shared amongst all front-ends. */
707 static const char *cc1_options =
708 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
709 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
710 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
711 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
712 %{Qn:-fno-ident} %{--help:--help}\
713 %{--target-help:--target-help}\
714 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
715 %{fsyntax-only:-o %j} %{-param*}";
717 static const char *asm_options =
718 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
720 static const char *invoke_as =
721 "%{!S:-o %{|!pipe:%g.s} |\n as %(asm_options) %{!pipe:%g.s} %A }";
723 /* Some compilers have limits on line lengths, and the multilib_select
724 and/or multilib_matches strings can be very long, so we build them at
726 static struct obstack multilib_obstack;
727 static const char *multilib_select;
728 static const char *multilib_matches;
729 static const char *multilib_defaults;
730 static const char *multilib_exclusions;
731 #include "multilib.h"
733 /* Check whether a particular argument is a default argument. */
735 #ifndef MULTILIB_DEFAULTS
736 #define MULTILIB_DEFAULTS { "" }
739 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
743 struct user_specs *next;
744 const char *filename;
747 static struct user_specs *user_specs_head, *user_specs_tail;
749 /* This defines which switch letters take arguments. */
751 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
752 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
753 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
754 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
755 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'B' || (CHAR) == 'b')
757 #ifndef SWITCH_TAKES_ARG
758 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
761 /* This defines which multi-letter switches take arguments. */
763 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
764 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
765 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
766 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
767 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
768 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
769 || !strcmp (STR, "isystem") || !strcmp (STR, "-param") \
770 || !strcmp (STR, "specs") \
771 || !strcmp (STR, "MF") || !strcmp (STR, "MT") || !strcmp (STR, "MQ"))
773 #ifndef WORD_SWITCH_TAKES_ARG
774 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
777 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
778 /* This defines which switches stop a full compilation. */
779 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
780 ((CHAR) == 'c' || (CHAR) == 'S')
782 #ifndef SWITCH_CURTAILS_COMPILATION
783 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
784 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
788 /* Record the mapping from file suffixes for compilation specs. */
792 const char *suffix; /* Use this compiler for input files
793 whose names end in this suffix. */
795 const char *spec; /* To use this compiler, run this spec. */
797 const char *cpp_spec; /* If non-NULL, substitute this spec
798 for `%C', rather than the usual
802 /* Pointer to a vector of `struct compiler' that gives the spec for
803 compiling a file, based on its suffix.
804 A file that does not end in any of these suffixes will be passed
805 unchanged to the loader and nothing else will be done to it.
807 An entry containing two 0s is used to terminate the vector.
809 If multiple entries match a file, the last matching one is used. */
811 static struct compiler *compilers;
813 /* Number of entries in `compilers', not counting the null terminator. */
815 static int n_compilers;
817 /* The default list of file name suffixes and their compilation specs. */
819 static const struct compiler default_compilers[] =
821 /* Add lists of suffixes of known languages here. If those languages
822 were not present when we built the driver, we will hit these copies
823 and be given a more meaningful error than "file not used since
824 linking is not done". */
825 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
826 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
827 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
829 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
830 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
831 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
832 {".r", "#Ratfor", 0},
833 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
834 {".java", "#Java", 0}, {".class", "#Java", 0},
835 {".zip", "#Java", 0}, {".jar", "#Java", 0},
836 /* Next come the entries for C. */
839 /* cc1 has an integrated ISO C preprocessor. We should invoke the
840 external preprocessor if -save-temps is given. */
841 "%{E|M|MM:%(trad_capable_cpp) %{ansi:-std=c89} %(cpp_options)\
842 %(cpp_debug_options)}\
844 %{traditional|ftraditional:\
845 %eGNU C no longer supports -traditional without -E}\
846 %{save-temps|traditional-cpp:%(trad_capable_cpp) \
847 %{ansi:-std=c89} %(cpp_options) %b.i \n\
848 cc1 -fpreprocessed %b.i %(cc1_options)}\
849 %{!save-temps:%{!traditional-cpp:\
850 cc1 %{ansi:-std=c89} %(cpp_unique_options) %(cc1_options)}}\
851 %{!fsyntax-only:%(invoke_as)}}}}", 0},
853 "%{!E:%e-E required when input is from standard input}\
854 %(trad_capable_cpp) %{ansi:-std=c89} %(cpp_options)", 0},
855 {".h", "@c-header", 0},
857 "%{!E:%ecompilation of header file requested} \
858 %(trad_capable_cpp) %{ansi:-std=c89} %(cpp_options) %(cpp_debug_options)",
860 {".i", "@cpp-output", 0},
862 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
863 {".s", "@assembler", 0},
865 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
866 {".S", "@assembler-with-cpp", 0},
867 {"@assembler-with-cpp",
868 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
869 %{E|M|MM:%(cpp_debug_options)}\
870 %{!M:%{!MM:%{!E:%{!S:-o %{|!pipe:%g.s} |\n\
871 as %(asm_debug) %(asm_options) %{!pipe:%g.s} %A }}}}", 0},
873 /* Mark end of table */
877 /* Number of elements in default_compilers, not counting the terminator. */
879 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
881 /* A vector of options to give to the linker.
882 These options are accumulated by %x,
883 and substituted into the linker command with %X. */
884 static int n_linker_options;
885 static char **linker_options;
887 /* A vector of options to give to the assembler.
888 These options are accumulated by -Wa,
889 and substituted into the assembler command with %Y. */
890 static int n_assembler_options;
891 static char **assembler_options;
893 /* A vector of options to give to the preprocessor.
894 These options are accumulated by -Wp,
895 and substituted into the preprocessor command with %Z. */
896 static int n_preprocessor_options;
897 static char **preprocessor_options;
899 /* Define how to map long options into short ones. */
901 /* This structure describes one mapping. */
904 /* The long option's name. */
905 const char *const name;
906 /* The equivalent short option. */
907 const char *const equivalent;
908 /* Argument info. A string of flag chars; NULL equals no options.
909 a => argument required.
910 o => argument optional.
911 j => join argument to equivalent, making one word.
912 * => require other text after NAME as an argument. */
913 const char *const arg_info;
916 /* This is the table of mappings. Mappings are tried sequentially
917 for each option encountered; the first one that matches, wins. */
919 static const struct option_map option_map[] =
921 {"--all-warnings", "-Wall", 0},
922 {"--ansi", "-ansi", 0},
923 {"--assemble", "-S", 0},
924 {"--assert", "-A", "a"},
925 {"--classpath", "-fclasspath=", "aj"},
926 {"--bootclasspath", "-fbootclasspath=", "aj"},
927 {"--CLASSPATH", "-fclasspath=", "aj"},
928 {"--comments", "-C", 0},
929 {"--comments-in-macros", "-CC", 0},
930 {"--compile", "-c", 0},
931 {"--debug", "-g", "oj"},
932 {"--define-macro", "-D", "aj"},
933 {"--dependencies", "-M", 0},
934 {"--dump", "-d", "a"},
935 {"--dumpbase", "-dumpbase", "a"},
936 {"--entry", "-e", 0},
937 {"--extra-warnings", "-W", 0},
938 {"--for-assembler", "-Wa", "a"},
939 {"--for-linker", "-Xlinker", "a"},
940 {"--force-link", "-u", "a"},
941 {"--imacros", "-imacros", "a"},
942 {"--include", "-include", "a"},
943 {"--include-barrier", "-I-", 0},
944 {"--include-directory", "-I", "aj"},
945 {"--include-directory-after", "-idirafter", "a"},
946 {"--include-prefix", "-iprefix", "a"},
947 {"--include-with-prefix", "-iwithprefix", "a"},
948 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
949 {"--include-with-prefix-after", "-iwithprefix", "a"},
950 {"--language", "-x", "a"},
951 {"--library-directory", "-L", "a"},
952 {"--machine", "-m", "aj"},
953 {"--machine-", "-m", "*j"},
954 {"--no-line-commands", "-P", 0},
955 {"--no-precompiled-includes", "-noprecomp", 0},
956 {"--no-standard-includes", "-nostdinc", 0},
957 {"--no-standard-libraries", "-nostdlib", 0},
958 {"--no-warnings", "-w", 0},
959 {"--optimize", "-O", "oj"},
960 {"--output", "-o", "a"},
961 {"--output-class-directory", "-foutput-class-dir=", "ja"},
962 {"--param", "--param", "a"},
963 {"--pedantic", "-pedantic", 0},
964 {"--pedantic-errors", "-pedantic-errors", 0},
965 {"--pipe", "-pipe", 0},
966 {"--prefix", "-B", "a"},
967 {"--preprocess", "-E", 0},
968 {"--print-search-dirs", "-print-search-dirs", 0},
969 {"--print-file-name", "-print-file-name=", "aj"},
970 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
971 {"--print-missing-file-dependencies", "-MG", 0},
972 {"--print-multi-lib", "-print-multi-lib", 0},
973 {"--print-multi-directory", "-print-multi-directory", 0},
974 {"--print-prog-name", "-print-prog-name=", "aj"},
975 {"--profile", "-p", 0},
976 {"--profile-blocks", "-a", 0},
977 {"--quiet", "-q", 0},
978 {"--resource", "-fcompile-resource=", "aj"},
979 {"--save-temps", "-save-temps", 0},
980 {"--shared", "-shared", 0},
981 {"--silent", "-q", 0},
982 {"--specs", "-specs=", "aj"},
983 {"--static", "-static", 0},
984 {"--std", "-std=", "aj"},
985 {"--symbolic", "-symbolic", 0},
986 {"--target", "-b", "a"},
987 {"--time", "-time", 0},
988 {"--trace-includes", "-H", 0},
989 {"--traditional", "-traditional", 0},
990 {"--traditional-cpp", "-traditional-cpp", 0},
991 {"--trigraphs", "-trigraphs", 0},
992 {"--undefine-macro", "-U", "aj"},
993 {"--use-version", "-V", "a"},
994 {"--user-dependencies", "-MM", 0},
995 {"--verbose", "-v", 0},
996 {"--warn-", "-W", "*j"},
997 {"--write-dependencies", "-MD", 0},
998 {"--write-user-dependencies", "-MMD", 0},
1003 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1004 static const struct {
1005 const char *const option_found;
1006 const char *const replacements;
1007 } target_option_translations[] =
1009 TARGET_OPTION_TRANSLATE_TABLE,
1014 /* Translate the options described by *ARGCP and *ARGVP.
1015 Make a new vector and store it back in *ARGVP,
1016 and store its length in *ARGVC. */
1019 translate_options (argcp, argvp)
1021 const char *const **argvp;
1025 const char *const *argv = *argvp;
1026 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1028 (const char **) xmalloc (newvsize);
1032 newv[newindex++] = argv[i++];
1036 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1040 target_option_translations[tott_idx].option_found;
1043 if (strcmp (target_option_translations[tott_idx].option_found,
1050 for (sp = target_option_translations[tott_idx].replacements;
1057 newvsize += spaces * sizeof (const char *);
1058 newv = (const char **) xrealloc (newv, newvsize);
1060 sp = target_option_translations[tott_idx].replacements;
1069 newv[newindex++] = np;
1070 while (*np != ' ' && *np)
1081 if (target_option_translations[tott_idx].option_found)
1085 /* Translate -- options. */
1086 if (argv[i][0] == '-' && argv[i][1] == '-')
1089 /* Find a mapping that applies to this option. */
1090 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1092 size_t optlen = strlen (option_map[j].name);
1093 size_t arglen = strlen (argv[i]);
1094 size_t complen = arglen > optlen ? optlen : arglen;
1095 const char *arginfo = option_map[j].arg_info;
1100 if (!strncmp (argv[i], option_map[j].name, complen))
1102 const char *arg = 0;
1104 if (arglen < optlen)
1107 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1108 if (strlen (option_map[k].name) >= arglen
1109 && !strncmp (argv[i], option_map[k].name, arglen))
1111 error ("ambiguous abbreviation %s", argv[i]);
1115 if (k != ARRAY_SIZE (option_map))
1119 if (arglen > optlen)
1121 /* If the option has an argument, accept that. */
1122 if (argv[i][optlen] == '=')
1123 arg = argv[i] + optlen + 1;
1125 /* If this mapping requires extra text at end of name,
1126 accept that as "argument". */
1127 else if (strchr (arginfo, '*') != 0)
1128 arg = argv[i] + optlen;
1130 /* Otherwise, extra text at end means mismatch.
1131 Try other mappings. */
1136 else if (strchr (arginfo, '*') != 0)
1138 error ("incomplete `%s' option", option_map[j].name);
1142 /* Handle arguments. */
1143 if (strchr (arginfo, 'a') != 0)
1149 error ("missing argument to `%s' option",
1150 option_map[j].name);
1157 else if (strchr (arginfo, '*') != 0)
1159 else if (strchr (arginfo, 'o') == 0)
1162 error ("extraneous argument to `%s' option",
1163 option_map[j].name);
1167 /* Store the translation as one argv elt or as two. */
1168 if (arg != 0 && strchr (arginfo, 'j') != 0)
1169 newv[newindex++] = concat (option_map[j].equivalent, arg,
1173 newv[newindex++] = option_map[j].equivalent;
1174 newv[newindex++] = arg;
1177 newv[newindex++] = option_map[j].equivalent;
1185 /* Handle old-fashioned options--just copy them through,
1186 with their arguments. */
1187 else if (argv[i][0] == '-')
1189 const char *p = argv[i] + 1;
1193 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1194 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1195 else if (WORD_SWITCH_TAKES_ARG (p))
1196 nskip += WORD_SWITCH_TAKES_ARG (p);
1197 else if ((c == 'B' || c == 'b' || c == 'x')
1200 else if (! strcmp (p, "Xlinker"))
1203 /* Watch out for an option at the end of the command line that
1204 is missing arguments, and avoid skipping past the end of the
1206 if (nskip + i > argc)
1211 newv[newindex++] = argv[i++];
1216 /* Ordinary operands, or +e options. */
1217 newv[newindex++] = argv[i++];
1232 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1233 be considered whitespace. */
1234 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1236 else if (*p == '\n' || *p == ' ' || *p == '\t')
1250 /* Structures to keep track of prefixes to try when looking for files. */
1254 const char *prefix; /* String to prepend to the path. */
1255 struct prefix_list *next; /* Next in linked list. */
1256 int require_machine_suffix; /* Don't use without machine_suffix. */
1257 /* 2 means try both machine_suffix and just_machine_suffix. */
1258 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1259 int priority; /* Sort key - priority within list */
1264 struct prefix_list *plist; /* List of prefixes to try */
1265 int max_len; /* Max length of a prefix in PLIST */
1266 const char *name; /* Name of this list (used in config stuff) */
1269 /* List of prefixes to try when looking for executables. */
1271 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1273 /* List of prefixes to try when looking for startup (crt0) files. */
1275 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1277 /* List of prefixes to try when looking for include files. */
1279 static struct path_prefix include_prefixes = { 0, 0, "include" };
1281 /* Suffix to attach to directories searched for commands.
1282 This looks like `MACHINE/VERSION/'. */
1284 static const char *machine_suffix = 0;
1286 /* Suffix to attach to directories searched for commands.
1287 This is just `MACHINE/'. */
1289 static const char *just_machine_suffix = 0;
1291 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1293 static const char *gcc_exec_prefix;
1295 /* Default prefixes to attach to command names. */
1297 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1298 #undef MD_EXEC_PREFIX
1299 #undef MD_STARTFILE_PREFIX
1300 #undef MD_STARTFILE_PREFIX_1
1303 /* If no prefixes defined, use the null string, which will disable them. */
1304 #ifndef MD_EXEC_PREFIX
1305 #define MD_EXEC_PREFIX ""
1307 #ifndef MD_STARTFILE_PREFIX
1308 #define MD_STARTFILE_PREFIX ""
1310 #ifndef MD_STARTFILE_PREFIX_1
1311 #define MD_STARTFILE_PREFIX_1 ""
1314 /* Supply defaults for the standard prefixes. */
1316 #ifndef STANDARD_EXEC_PREFIX
1317 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1319 #ifndef STANDARD_STARTFILE_PREFIX
1320 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1322 #ifndef TOOLDIR_BASE_PREFIX
1323 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1325 #ifndef STANDARD_BINDIR_PREFIX
1326 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1329 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1330 static const char *const standard_exec_prefix_1 = "/usr/lib/gcc/";
1331 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1333 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1334 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1335 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1336 static const char *const standard_startfile_prefix_1 = "/lib/";
1337 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1339 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1340 static const char *tooldir_prefix;
1342 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1344 /* Subdirectory to use for locating libraries. Set by
1345 set_multilib_dir based on the compilation options. */
1347 static const char *multilib_dir;
1349 /* Structure to keep track of the specs that have been defined so far.
1350 These are accessed using %(specname) or %[specname] in a compiler
1355 /* The following 2 fields must be first */
1356 /* to allow EXTRA_SPECS to be initialized */
1357 const char *name; /* name of the spec. */
1358 const char *ptr; /* available ptr if no static pointer */
1360 /* The following fields are not initialized */
1361 /* by EXTRA_SPECS */
1362 const char **ptr_spec; /* pointer to the spec itself. */
1363 struct spec_list *next; /* Next spec in linked list. */
1364 int name_len; /* length of the name */
1365 int alloc_p; /* whether string was allocated */
1368 #define INIT_STATIC_SPEC(NAME,PTR) \
1369 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1371 /* List of statically defined specs. */
1372 static struct spec_list static_specs[] =
1374 INIT_STATIC_SPEC ("asm", &asm_spec),
1375 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1376 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1377 INIT_STATIC_SPEC ("asm_options", &asm_options),
1378 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1379 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1380 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1381 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1382 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1383 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1384 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1385 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1386 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1387 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1388 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1389 INIT_STATIC_SPEC ("link", &link_spec),
1390 INIT_STATIC_SPEC ("lib", &lib_spec),
1391 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1392 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1393 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1394 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1395 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1396 INIT_STATIC_SPEC ("version", &compiler_version),
1397 INIT_STATIC_SPEC ("multilib", &multilib_select),
1398 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1399 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1400 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1401 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1402 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1403 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1404 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1405 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1406 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1407 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1410 #ifdef EXTRA_SPECS /* additional specs needed */
1411 /* Structure to keep track of just the first two args of a spec_list.
1412 That is all that the EXTRA_SPECS macro gives us. */
1415 const char *const name;
1416 const char *const ptr;
1419 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1420 static struct spec_list *extra_specs = (struct spec_list *) 0;
1423 /* List of dynamically allocates specs that have been defined so far. */
1425 static struct spec_list *specs = (struct spec_list *) 0;
1427 /* Add appropriate libgcc specs to OBSTACK, taking into account
1428 various permutations of -shared-libgcc, -shared, and such. */
1430 #ifdef ENABLE_SHARED_LIBGCC
1432 init_gcc_specs (obstack, shared_name, static_name, eh_name)
1433 struct obstack *obstack;
1434 const char *shared_name;
1435 const char *static_name;
1436 const char *eh_name;
1440 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1441 "}%{!static:%{!static-libgcc:",
1442 "%{!shared:%{!shared-libgcc:", static_name, " ",
1443 eh_name, "}%{shared-libgcc:", shared_name, " ",
1444 static_name, "}}%{shared:",
1446 "%{shared-libgcc:", shared_name,
1447 "}%{!shared-libgcc:", static_name, "}",
1453 obstack_grow (obstack, buf, strlen (buf));
1456 #endif /* ENABLE_SHARED_LIBGCC */
1458 /* Initialize the specs lookup routines. */
1463 struct spec_list *next = (struct spec_list *) 0;
1464 struct spec_list *sl = (struct spec_list *) 0;
1468 return; /* Already initialized. */
1471 notice ("Using built-in specs.\n");
1474 extra_specs = (struct spec_list *)
1475 xcalloc (sizeof (struct spec_list), ARRAY_SIZE (extra_specs_1));
1477 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1479 sl = &extra_specs[i];
1480 sl->name = extra_specs_1[i].name;
1481 sl->ptr = extra_specs_1[i].ptr;
1483 sl->name_len = strlen (sl->name);
1484 sl->ptr_spec = &sl->ptr;
1489 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1490 on ?: in file-scope variable initializations. */
1491 asm_debug = ASM_DEBUG_SPEC;
1493 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1495 sl = &static_specs[i];
1500 #ifdef ENABLE_SHARED_LIBGCC
1501 /* ??? If neither -shared-libgcc nor --static-libgcc was
1502 seen, then we should be making an educated guess. Some proposed
1503 heuristics for ELF include:
1505 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1506 program will be doing dynamic loading, which will likely
1507 need the shared libgcc.
1509 (2) If "-ldl", then it's also a fair bet that we're doing
1512 (3) For each ET_DYN we're linking against (either through -lfoo
1513 or /some/path/foo.so), check to see whether it or one of
1514 its dependencies depends on a shared libgcc.
1518 If the runtime is fixed to look for program headers instead
1519 of calling __register_frame_info at all, for each object,
1520 use the shared libgcc if any EH symbol referenced.
1522 If crtstuff is fixed to not invoke __register_frame_info
1523 automatically, for each object, use the shared libgcc if
1524 any non-empty unwind section found.
1526 Doing any of this probably requires invoking an external program to
1527 do the actual object file scanning. */
1529 const char *p = libgcc_spec;
1532 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1533 when given the proper command line arguments. */
1536 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1538 init_gcc_specs (&obstack,
1539 #ifdef NO_SHARED_LIBGCC_MULTILIB
1550 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1552 /* Ug. We don't know shared library extensions. Hope that
1553 systems that use this form don't do shared libraries. */
1554 init_gcc_specs (&obstack,
1555 #ifdef NO_SHARED_LIBGCC_MULTILIB
1568 obstack_1grow (&obstack, *p);
1569 in_sep = (*p == ' ');
1574 obstack_1grow (&obstack, '\0');
1575 libgcc_spec = obstack_finish (&obstack);
1578 #ifdef USE_AS_TRADITIONAL_FORMAT
1579 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1581 static const char tf[] = "--traditional-format ";
1582 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1583 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1584 asm_spec = obstack_finish (&obstack);
1588 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1589 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1590 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1591 link_spec = obstack_finish (&obstack);
1597 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1598 removed; If the spec starts with a + then SPEC is added to the end of the
1602 set_spec (name, spec)
1606 struct spec_list *sl;
1607 const char *old_spec;
1608 int name_len = strlen (name);
1611 /* If this is the first call, initialize the statically allocated specs. */
1614 struct spec_list *next = (struct spec_list *) 0;
1615 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1617 sl = &static_specs[i];
1624 /* See if the spec already exists. */
1625 for (sl = specs; sl; sl = sl->next)
1626 if (name_len == sl->name_len && !strcmp (sl->name, name))
1631 /* Not found - make it. */
1632 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1633 sl->name = xstrdup (name);
1634 sl->name_len = name_len;
1635 sl->ptr_spec = &sl->ptr;
1637 *(sl->ptr_spec) = "";
1642 old_spec = *(sl->ptr_spec);
1643 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1644 ? concat (old_spec, spec + 1, NULL)
1649 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1652 /* Free the old spec. */
1653 if (old_spec && sl->alloc_p)
1654 free ((PTR) old_spec);
1659 /* Accumulate a command (program name and args), and run it. */
1661 /* Vector of pointers to arguments in the current line of specifications. */
1663 static const char **argbuf;
1665 /* Number of elements allocated in argbuf. */
1667 static int argbuf_length;
1669 /* Number of elements in argbuf currently in use (containing args). */
1671 static int argbuf_index;
1673 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1674 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1677 static struct temp_name {
1678 const char *suffix; /* suffix associated with the code. */
1679 int length; /* strlen (suffix). */
1680 int unique; /* Indicates whether %g or %u/%U was used. */
1681 const char *filename; /* associated filename. */
1682 int filename_length; /* strlen (filename). */
1683 struct temp_name *next;
1686 /* Number of commands executed so far. */
1688 static int execution_count;
1690 /* Number of commands that exited with a signal. */
1692 static int signal_count;
1694 /* Name with which this program was invoked. */
1696 static const char *programname;
1698 /* Clear out the vector of arguments (after a command is executed). */
1706 /* Add one argument to the vector at the end.
1707 This is done when a space is seen or at the end of the line.
1708 If DELETE_ALWAYS is nonzero, the arg is a filename
1709 and the file should be deleted eventually.
1710 If DELETE_FAILURE is nonzero, the arg is a filename
1711 and the file should be deleted if this compilation fails. */
1714 store_arg (arg, delete_always, delete_failure)
1716 int delete_always, delete_failure;
1718 if (argbuf_index + 1 == argbuf_length)
1720 = (const char **) xrealloc (argbuf,
1721 (argbuf_length *= 2) * sizeof (const char *));
1723 argbuf[argbuf_index++] = arg;
1724 argbuf[argbuf_index] = 0;
1726 if (delete_always || delete_failure)
1727 record_temp_file (arg, delete_always, delete_failure);
1730 /* Load specs from a file name named FILENAME, replacing occurrences of
1731 various different types of line-endings, \r\n, \n\r and just \r, with
1735 load_specs (filename)
1736 const char *filename;
1740 struct stat statbuf;
1747 notice ("Reading specs from %s\n", filename);
1749 /* Open and stat the file. */
1750 desc = open (filename, O_RDONLY, 0);
1752 pfatal_with_name (filename);
1753 if (stat (filename, &statbuf) < 0)
1754 pfatal_with_name (filename);
1756 /* Read contents of file into BUFFER. */
1757 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1758 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1760 pfatal_with_name (filename);
1761 buffer[readlen] = 0;
1764 specs = xmalloc (readlen + 1);
1766 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1772 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1774 else if (*(buffer_p + 1) == '\n') /* \r\n */
1788 /* Read compilation specs from a file named FILENAME,
1789 replacing the default ones.
1791 A suffix which starts with `*' is a definition for
1792 one of the machine-specific sub-specs. The "suffix" should be
1793 *asm, *cc1, *cpp, *link, *startfile, etc.
1794 The corresponding spec is stored in asm_spec, etc.,
1795 rather than in the `compilers' vector.
1797 Anything invalid in the file is a fatal error. */
1800 read_specs (filename, main_p)
1801 const char *filename;
1807 buffer = load_specs (filename);
1809 /* Scan BUFFER for specs, putting them in the vector. */
1815 char *in, *out, *p1, *p2, *p3;
1817 /* Advance P in BUFFER to the next nonblank nocomment line. */
1818 p = skip_whitespace (p);
1822 /* Is this a special command that starts with '%'? */
1823 /* Don't allow this for the main specs file, since it would
1824 encourage people to overwrite it. */
1825 if (*p == '%' && !main_p)
1828 while (*p && *p != '\n')
1834 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1835 && (p1[sizeof "%include" - 1] == ' '
1836 || p1[sizeof "%include" - 1] == '\t'))
1840 p1 += sizeof ("%include");
1841 while (*p1 == ' ' || *p1 == '\t')
1844 if (*p1++ != '<' || p[-2] != '>')
1845 fatal ("specs %%include syntax malformed after %ld characters",
1846 (long) (p1 - buffer + 1));
1849 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1850 read_specs (new_filename ? new_filename : p1, FALSE);
1853 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1854 && (p1[sizeof "%include_noerr" - 1] == ' '
1855 || p1[sizeof "%include_noerr" - 1] == '\t'))
1859 p1 += sizeof "%include_noerr";
1860 while (*p1 == ' ' || *p1 == '\t')
1863 if (*p1++ != '<' || p[-2] != '>')
1864 fatal ("specs %%include syntax malformed after %ld characters",
1865 (long) (p1 - buffer + 1));
1868 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1870 read_specs (new_filename, FALSE);
1871 else if (verbose_flag)
1872 notice ("could not find specs file %s\n", p1);
1875 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1876 && (p1[sizeof "%rename" - 1] == ' '
1877 || p1[sizeof "%rename" - 1] == '\t'))
1880 struct spec_list *sl;
1881 struct spec_list *newsl;
1883 /* Get original name. */
1884 p1 += sizeof "%rename";
1885 while (*p1 == ' ' || *p1 == '\t')
1888 if (! ISALPHA ((unsigned char) *p1))
1889 fatal ("specs %%rename syntax malformed after %ld characters",
1890 (long) (p1 - buffer));
1893 while (*p2 && !ISSPACE ((unsigned char) *p2))
1896 if (*p2 != ' ' && *p2 != '\t')
1897 fatal ("specs %%rename syntax malformed after %ld characters",
1898 (long) (p2 - buffer));
1902 while (*p2 == ' ' || *p2 == '\t')
1905 if (! ISALPHA ((unsigned char) *p2))
1906 fatal ("specs %%rename syntax malformed after %ld characters",
1907 (long) (p2 - buffer));
1909 /* Get new spec name. */
1911 while (*p3 && !ISSPACE ((unsigned char) *p3))
1915 fatal ("specs %%rename syntax malformed after %ld characters",
1916 (long) (p3 - buffer));
1919 for (sl = specs; sl; sl = sl->next)
1920 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1924 fatal ("specs %s spec was not found to be renamed", p1);
1926 if (strcmp (p1, p2) == 0)
1929 for (newsl = specs; newsl; newsl = newsl->next)
1930 if (strcmp (newsl->name, p2) == 0)
1931 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
1936 notice ("rename spec %s to %s\n", p1, p2);
1938 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
1942 set_spec (p2, *(sl->ptr_spec));
1944 free ((PTR) *(sl->ptr_spec));
1946 *(sl->ptr_spec) = "";
1951 fatal ("specs unknown %% command after %ld characters",
1952 (long) (p1 - buffer));
1955 /* Find the colon that should end the suffix. */
1957 while (*p1 && *p1 != ':' && *p1 != '\n')
1960 /* The colon shouldn't be missing. */
1962 fatal ("specs file malformed after %ld characters",
1963 (long) (p1 - buffer));
1965 /* Skip back over trailing whitespace. */
1967 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1970 /* Copy the suffix to a string. */
1971 suffix = save_string (p, p2 - p);
1972 /* Find the next line. */
1973 p = skip_whitespace (p1 + 1);
1975 fatal ("specs file malformed after %ld characters",
1976 (long) (p - buffer));
1979 /* Find next blank line or end of string. */
1980 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1983 /* Specs end at the blank line and do not include the newline. */
1984 spec = save_string (p, p1 - p);
1987 /* Delete backslash-newline sequences from the spec. */
1992 if (in[0] == '\\' && in[1] == '\n')
1994 else if (in[0] == '#')
1995 while (*in && *in != '\n')
2003 if (suffix[0] == '*')
2005 if (! strcmp (suffix, "*link_command"))
2006 link_command_spec = spec;
2008 set_spec (suffix + 1, spec);
2012 /* Add this pair to the vector. */
2014 = ((struct compiler *)
2015 xrealloc (compilers,
2016 (n_compilers + 2) * sizeof (struct compiler)));
2018 compilers[n_compilers].suffix = suffix;
2019 compilers[n_compilers].spec = spec;
2021 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2025 link_command_spec = spec;
2028 if (link_command_spec == 0)
2029 fatal ("spec file has no spec for linking");
2032 /* Record the names of temporary files we tell compilers to write,
2033 and delete them at the end of the run. */
2035 /* This is the common prefix we use to make temp file names.
2036 It is chosen once for each run of this program.
2037 It is substituted into a spec by %g or %j.
2038 Thus, all temp file names contain this prefix.
2039 In practice, all temp file names start with this prefix.
2041 This prefix comes from the envvar TMPDIR if it is defined;
2042 otherwise, from the P_tmpdir macro if that is defined;
2043 otherwise, in /usr/tmp or /tmp;
2044 or finally the current directory if all else fails. */
2046 static const char *temp_filename;
2048 /* Length of the prefix. */
2050 static int temp_filename_length;
2052 /* Define the list of temporary files to delete. */
2057 struct temp_file *next;
2060 /* Queue of files to delete on success or failure of compilation. */
2061 static struct temp_file *always_delete_queue;
2062 /* Queue of files to delete on failure of compilation. */
2063 static struct temp_file *failure_delete_queue;
2065 /* Record FILENAME as a file to be deleted automatically.
2066 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2067 otherwise delete it in any case.
2068 FAIL_DELETE nonzero means delete it if a compilation step fails;
2069 otherwise delete it in any case. */
2072 record_temp_file (filename, always_delete, fail_delete)
2073 const char *filename;
2077 char *const name = xstrdup (filename);
2081 struct temp_file *temp;
2082 for (temp = always_delete_queue; temp; temp = temp->next)
2083 if (! strcmp (name, temp->name))
2086 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2087 temp->next = always_delete_queue;
2089 always_delete_queue = temp;
2096 struct temp_file *temp;
2097 for (temp = failure_delete_queue; temp; temp = temp->next)
2098 if (! strcmp (name, temp->name))
2101 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2102 temp->next = failure_delete_queue;
2104 failure_delete_queue = temp;
2110 /* Delete all the temporary files whose names we previously recorded. */
2113 delete_if_ordinary (name)
2120 printf ("Delete %s? (y or n) ", name);
2124 while ((c = getchar ()) != '\n' && c != EOF)
2127 if (i == 'y' || i == 'Y')
2129 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
2130 if (unlink (name) < 0)
2132 perror_with_name (name);
2136 delete_temp_files ()
2138 struct temp_file *temp;
2140 for (temp = always_delete_queue; temp; temp = temp->next)
2141 delete_if_ordinary (temp->name);
2142 always_delete_queue = 0;
2145 /* Delete all the files to be deleted on error. */
2148 delete_failure_queue ()
2150 struct temp_file *temp;
2152 for (temp = failure_delete_queue; temp; temp = temp->next)
2153 delete_if_ordinary (temp->name);
2157 clear_failure_queue ()
2159 failure_delete_queue = 0;
2162 /* Build a list of search directories from PATHS.
2163 PREFIX is a string to prepend to the list.
2164 If CHECK_DIR_P is non-zero we ensure the directory exists.
2165 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2166 It is also used by the --print-search-dirs flag. */
2169 build_search_list (paths, prefix, check_dir_p)
2170 struct path_prefix *paths;
2174 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2176 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2177 int first_time = TRUE;
2178 struct prefix_list *pprefix;
2180 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2181 obstack_1grow (&collect_obstack, '=');
2183 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2185 int len = strlen (pprefix->prefix);
2189 || is_directory (pprefix->prefix, machine_suffix, 0)))
2192 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2195 obstack_grow (&collect_obstack, pprefix->prefix, len);
2196 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2199 if (just_machine_suffix
2200 && pprefix->require_machine_suffix == 2
2202 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2205 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2208 obstack_grow (&collect_obstack, pprefix->prefix, len);
2209 obstack_grow (&collect_obstack, just_machine_suffix,
2213 if (! pprefix->require_machine_suffix)
2216 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2219 obstack_grow (&collect_obstack, pprefix->prefix, len);
2223 obstack_1grow (&collect_obstack, '\0');
2224 return obstack_finish (&collect_obstack);
2227 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2231 putenv_from_prefixes (paths, env_var)
2232 struct path_prefix *paths;
2233 const char *env_var;
2235 putenv (build_search_list (paths, env_var, 1));
2240 /* FIXME: the location independence code for VMS is hairier than this,
2241 and hasn't been written. */
2243 /* Split a filename into component directories. */
2246 split_directories (name, ptr_num_dirs)
2255 /* Count the number of directories. Special case MSDOS disk names as part
2256 of the initial directory. */
2258 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2259 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2264 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2266 while ((ch = *p++) != '\0')
2268 if (IS_DIR_SEPARATOR (ch))
2271 while (IS_DIR_SEPARATOR (*p))
2276 dirs = (char **) xmalloc (sizeof (char *) * (num_dirs + 2));
2278 /* Now copy the directory parts. */
2281 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2282 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2284 dirs[num_dirs++] = save_string (p, 3);
2287 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2290 while ((ch = *p++) != '\0')
2292 if (IS_DIR_SEPARATOR (ch))
2294 while (IS_DIR_SEPARATOR (*p))
2297 dirs[num_dirs++] = save_string (q, p - q);
2303 dirs[num_dirs++] = save_string (q, p - 1 - q);
2305 dirs[num_dirs] = NULL;
2307 *ptr_num_dirs = num_dirs;
2312 /* Release storage held by split directories. */
2315 free_split_directories (dirs)
2320 while (dirs[i] != NULL)
2323 free ((char *) dirs);
2326 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
2327 to PREFIX starting with the directory portion of PROGNAME and a relative
2328 pathname of the difference between BIN_PREFIX and PREFIX.
2330 For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
2331 /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
2332 function will return /red/green/blue/../omega.
2334 If no relative prefix can be found, return NULL. */
2337 make_relative_prefix (progname, bin_prefix, prefix)
2338 const char *progname;
2339 const char *bin_prefix;
2342 char **prog_dirs, **bin_dirs, **prefix_dirs;
2343 int prog_num, bin_num, prefix_num, std_loc_p;
2346 prog_dirs = split_directories (progname, &prog_num);
2347 bin_dirs = split_directories (bin_prefix, &bin_num);
2349 /* If there is no full pathname, try to find the program by checking in each
2350 of the directories specified in the PATH environment variable. */
2355 GET_ENV_PATH_LIST (temp, "PATH");
2358 char *startp, *endp, *nstore;
2359 size_t prefixlen = strlen (temp) + 1;
2363 nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
2365 startp = endp = temp;
2368 if (*endp == PATH_SEPARATOR || *endp == 0)
2373 nstore[1] = DIR_SEPARATOR;
2378 strncpy (nstore, startp, endp - startp);
2379 if (! IS_DIR_SEPARATOR (endp[-1]))
2381 nstore[endp - startp] = DIR_SEPARATOR;
2382 nstore[endp - startp + 1] = 0;
2385 nstore[endp - startp] = 0;
2387 strcat (nstore, progname);
2388 if (! access (nstore, X_OK)
2389 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
2390 || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
2394 free_split_directories (prog_dirs);
2396 prog_dirs = split_directories (progname, &prog_num);
2402 endp = startp = endp + 1;
2410 /* Remove the program name from comparison of directory names. */
2413 /* Determine if the compiler is installed in the standard location, and if
2414 so, we don't need to specify relative directories. Also, if argv[0]
2415 doesn't contain any directory specifiers, there is not much we can do. */
2417 if (prog_num == bin_num)
2419 for (i = 0; i < bin_num; i++)
2421 if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
2425 if (prog_num <= 0 || i == bin_num)
2428 free_split_directories (prog_dirs);
2429 free_split_directories (bin_dirs);
2430 prog_dirs = bin_dirs = (char **) 0;
2435 prefix_dirs = split_directories (prefix, &prefix_num);
2437 /* Find how many directories are in common between bin_prefix & prefix. */
2438 n = (prefix_num < bin_num) ? prefix_num : bin_num;
2439 for (common = 0; common < n; common++)
2441 if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
2445 /* If there are no common directories, there can be no relative prefix. */
2448 free_split_directories (prog_dirs);
2449 free_split_directories (bin_dirs);
2450 free_split_directories (prefix_dirs);
2454 /* Build up the pathnames in argv[0]. */
2455 for (i = 0; i < prog_num; i++)
2456 obstack_grow (&obstack, prog_dirs[i], strlen (prog_dirs[i]));
2458 /* Now build up the ..'s. */
2459 for (i = common; i < n; i++)
2461 obstack_grow (&obstack, DIR_UP, sizeof (DIR_UP) - 1);
2462 obstack_1grow (&obstack, DIR_SEPARATOR);
2465 /* Put in directories to move over to prefix. */
2466 for (i = common; i < prefix_num; i++)
2467 obstack_grow (&obstack, prefix_dirs[i], strlen (prefix_dirs[i]));
2469 free_split_directories (prog_dirs);
2470 free_split_directories (bin_dirs);
2471 free_split_directories (prefix_dirs);
2473 obstack_1grow (&obstack, '\0');
2474 return obstack_finish (&obstack);
2478 /* Check whether NAME can be accessed in MODE. This is like access,
2479 except that it never considers directories to be executable. */
2482 access_check (name, mode)
2490 if (stat (name, &st) < 0
2491 || S_ISDIR (st.st_mode))
2495 return access (name, mode);
2498 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2499 access to check permissions.
2500 Return 0 if not found, otherwise return its name, allocated with malloc. */
2503 find_a_file (pprefix, name, mode)
2504 struct path_prefix *pprefix;
2509 const char *const file_suffix =
2510 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2511 struct prefix_list *pl;
2512 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2514 #ifdef DEFAULT_ASSEMBLER
2515 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2516 return xstrdup (DEFAULT_ASSEMBLER);
2519 #ifdef DEFAULT_LINKER
2520 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2521 return xstrdup (DEFAULT_LINKER);
2525 len += strlen (machine_suffix);
2527 temp = xmalloc (len);
2529 /* Determine the filename to execute (special case for absolute paths). */
2531 if (IS_ABSOLUTE_PATHNAME (name))
2533 if (access (name, mode) == 0)
2535 strcpy (temp, name);
2540 for (pl = pprefix->plist; pl; pl = pl->next)
2544 /* Some systems have a suffix for executable files.
2545 So try appending that first. */
2546 if (file_suffix[0] != 0)
2548 strcpy (temp, pl->prefix);
2549 strcat (temp, machine_suffix);
2550 strcat (temp, name);
2551 strcat (temp, file_suffix);
2552 if (access_check (temp, mode) == 0)
2554 if (pl->used_flag_ptr != 0)
2555 *pl->used_flag_ptr = 1;
2560 /* Now try just the name. */
2561 strcpy (temp, pl->prefix);
2562 strcat (temp, machine_suffix);
2563 strcat (temp, name);
2564 if (access_check (temp, mode) == 0)
2566 if (pl->used_flag_ptr != 0)
2567 *pl->used_flag_ptr = 1;
2572 /* Certain prefixes are tried with just the machine type,
2573 not the version. This is used for finding as, ld, etc. */
2574 if (just_machine_suffix && pl->require_machine_suffix == 2)
2576 /* Some systems have a suffix for executable files.
2577 So try appending that first. */
2578 if (file_suffix[0] != 0)
2580 strcpy (temp, pl->prefix);
2581 strcat (temp, just_machine_suffix);
2582 strcat (temp, name);
2583 strcat (temp, file_suffix);
2584 if (access_check (temp, mode) == 0)
2586 if (pl->used_flag_ptr != 0)
2587 *pl->used_flag_ptr = 1;
2592 strcpy (temp, pl->prefix);
2593 strcat (temp, just_machine_suffix);
2594 strcat (temp, name);
2595 if (access_check (temp, mode) == 0)
2597 if (pl->used_flag_ptr != 0)
2598 *pl->used_flag_ptr = 1;
2603 /* Certain prefixes can't be used without the machine suffix
2604 when the machine or version is explicitly specified. */
2605 if (! pl->require_machine_suffix)
2607 /* Some systems have a suffix for executable files.
2608 So try appending that first. */
2609 if (file_suffix[0] != 0)
2611 strcpy (temp, pl->prefix);
2612 strcat (temp, name);
2613 strcat (temp, file_suffix);
2614 if (access_check (temp, mode) == 0)
2616 if (pl->used_flag_ptr != 0)
2617 *pl->used_flag_ptr = 1;
2622 strcpy (temp, pl->prefix);
2623 strcat (temp, name);
2624 if (access_check (temp, mode) == 0)
2626 if (pl->used_flag_ptr != 0)
2627 *pl->used_flag_ptr = 1;
2637 /* Ranking of prefixes in the sort list. -B prefixes are put before
2640 enum path_prefix_priority
2642 PREFIX_PRIORITY_B_OPT,
2643 PREFIX_PRIORITY_LAST
2646 /* Add an entry for PREFIX in PLIST. The PLIST is kept in assending
2647 order according to PRIORITY. Within each PRIORITY, new entries are
2650 If WARN is nonzero, we will warn if no file is found
2651 through this prefix. WARN should point to an int
2652 which will be set to 1 if this entry is used.
2654 COMPONENT is the value to be passed to update_path.
2656 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2657 the complete value of machine_suffix.
2658 2 means try both machine_suffix and just_machine_suffix. */
2661 add_prefix (pprefix, prefix, component, priority, require_machine_suffix, warn)
2662 struct path_prefix *pprefix;
2664 const char *component;
2665 /* enum prefix_priority */ int priority;
2666 int require_machine_suffix;
2669 struct prefix_list *pl, **prev;
2672 for (prev = &pprefix->plist;
2673 (*prev) != NULL && (*prev)->priority <= priority;
2674 prev = &(*prev)->next)
2677 /* Keep track of the longest prefix */
2679 prefix = update_path (prefix, component);
2680 len = strlen (prefix);
2681 if (len > pprefix->max_len)
2682 pprefix->max_len = len;
2684 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2685 pl->prefix = prefix;
2686 pl->require_machine_suffix = require_machine_suffix;
2687 pl->used_flag_ptr = warn;
2688 pl->priority = priority;
2692 /* Insert after PREV */
2697 /* Execute the command specified by the arguments on the current line of spec.
2698 When using pipes, this includes several piped-together commands
2699 with `|' between them.
2701 Return 0 if successful, -1 if failed. */
2707 int n_commands; /* # of command. */
2711 const char *prog; /* program name. */
2712 const char **argv; /* vector of args. */
2713 int pid; /* pid of process for this command. */
2716 struct command *commands; /* each command buffer with above info. */
2718 /* Count # of piped commands. */
2719 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2720 if (strcmp (argbuf[i], "|") == 0)
2723 /* Get storage for each command. */
2724 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2726 /* Split argbuf into its separate piped processes,
2727 and record info about each one.
2728 Also search for the programs that are to be run. */
2730 commands[0].prog = argbuf[0]; /* first command. */
2731 commands[0].argv = &argbuf[0];
2732 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
2735 commands[0].argv[0] = string;
2737 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2738 if (strcmp (argbuf[i], "|") == 0)
2739 { /* each command. */
2740 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2741 fatal ("-pipe not supported");
2743 argbuf[i] = 0; /* termination of command args. */
2744 commands[n_commands].prog = argbuf[i + 1];
2745 commands[n_commands].argv = &argbuf[i + 1];
2746 string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
2748 commands[n_commands].argv[0] = string;
2752 argbuf[argbuf_index] = 0;
2754 /* If -v, print what we are about to do, and maybe query. */
2758 /* For help listings, put a blank line between sub-processes. */
2759 if (print_help_list)
2760 fputc ('\n', stderr);
2762 /* Print each piped command as a separate line. */
2763 for (i = 0; i < n_commands; i++)
2765 const char *const *j;
2767 if (verbose_only_flag)
2769 for (j = commands[i].argv; *j; j++)
2772 fprintf (stderr, " \"");
2773 for (p = *j; *p; ++p)
2775 if (*p == '"' || *p == '\\' || *p == '$')
2776 fputc ('\\', stderr);
2779 fputc ('"', stderr);
2783 for (j = commands[i].argv; *j; j++)
2784 fprintf (stderr, " %s", *j);
2786 /* Print a pipe symbol after all but the last command. */
2787 if (i + 1 != n_commands)
2788 fprintf (stderr, " |");
2789 fprintf (stderr, "\n");
2792 if (verbose_only_flag != 0)
2795 notice ("\nGo ahead? (y or n) ");
2799 while (getchar () != '\n')
2802 if (i != 'y' && i != 'Y')
2807 /* Run each piped subprocess. */
2809 for (i = 0; i < n_commands; i++)
2811 char *errmsg_fmt, *errmsg_arg;
2812 const char *string = commands[i].argv[0];
2814 /* For some bizarre reason, the second argument of execvp() is
2815 char *const *, not const char *const *. */
2816 commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2817 programname, temp_filename,
2818 &errmsg_fmt, &errmsg_arg,
2819 ((i == 0 ? PEXECUTE_FIRST : 0)
2820 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2821 | (string == commands[i].prog
2822 ? PEXECUTE_SEARCH : 0)
2823 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2825 if (commands[i].pid == -1)
2826 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2828 if (string != commands[i].prog)
2829 free ((PTR) string);
2834 /* Wait for all the subprocesses to finish.
2835 We don't care what order they finish in;
2836 we know that N_COMMANDS waits will get them all.
2837 Ignore subprocesses that we don't know about,
2838 since they can be spawned by the process that exec'ed us. */
2842 #ifdef HAVE_GETRUSAGE
2844 double ut = 0.0, st = 0.0;
2847 for (i = 0; i < n_commands;)
2853 pid = pwait (commands[i].pid, &status, 0);
2857 #ifdef HAVE_GETRUSAGE
2860 /* getrusage returns the total resource usage of all children
2861 up to now. Copy the previous values into prus, get the
2862 current statistics, then take the difference. */
2865 getrusage (RUSAGE_CHILDREN, &rus);
2866 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2867 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2868 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2870 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2871 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2872 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2876 for (j = 0; j < n_commands; j++)
2877 if (commands[j].pid == pid)
2880 if (WIFSIGNALED (status))
2883 /* SIGPIPE is a special case. It happens in -pipe mode
2884 when the compiler dies before the preprocessor is
2885 done, or the assembler dies before the compiler is
2886 done. There's generally been an error already, and
2887 this is just fallout. So don't generate another error
2888 unless we would otherwise have succeeded. */
2889 if (WTERMSIG (status) == SIGPIPE
2890 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2895 Internal error: %s (program %s)\n\
2896 Please submit a full bug report.\n\
2897 See %s for instructions.",
2898 strsignal (WTERMSIG (status)), commands[j].prog,
2903 else if (WIFEXITED (status)
2904 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2906 if (WEXITSTATUS (status) > greatest_status)
2907 greatest_status = WEXITSTATUS (status);
2910 #ifdef HAVE_GETRUSAGE
2911 if (report_times && ut + st != 0)
2912 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2921 /* Find all the switches given to us
2922 and make a vector describing them.
2923 The elements of the vector are strings, one per switch given.
2924 If a switch uses following arguments, then the `part1' field
2925 is the switch itself and the `args' field
2926 is a null-terminated vector containing the following arguments.
2927 The `live_cond' field is:
2929 1 if the switch is true in a conditional spec,
2930 -1 if false (overridden by a later switch)
2931 -2 if this switch should be ignored (used in %{<S})
2932 The `validated' field is nonzero if any spec has looked at this switch;
2933 if it remains zero at the end of the run, it must be meaningless. */
2936 #define SWITCH_FALSE -1
2937 #define SWITCH_IGNORE -2
2938 #define SWITCH_LIVE 1
2945 unsigned char validated;
2946 unsigned char ordering;
2949 static struct switchstr *switches;
2951 static int n_switches;
2956 const char *language;
2959 /* Also a vector of input files specified. */
2961 static struct infile *infiles;
2965 /* This counts the number of libraries added by lang_specific_driver, so that
2966 we can tell if there were any user supplied any files or libraries. */
2968 static int added_libraries;
2970 /* And a vector of corresponding output files is made up later. */
2972 const char **outfiles;
2974 /* Used to track if none of the -B paths are used. */
2977 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2978 static int *warn_std_ptr = 0;
2980 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2982 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2983 is true if we should look for an executable suffix. DO_OBJ
2984 is true if we should look for an object suffix. */
2987 convert_filename (name, do_exe, do_obj)
2989 int do_exe ATTRIBUTE_UNUSED;
2990 int do_obj ATTRIBUTE_UNUSED;
2992 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3000 len = strlen (name);
3002 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3003 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3004 if (do_obj && len > 2
3005 && name[len - 2] == '.'
3006 && name[len - 1] == 'o')
3008 obstack_grow (&obstack, name, len - 2);
3009 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3010 name = obstack_finish (&obstack);
3014 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3015 /* If there is no filetype, make it the executable suffix (which includes
3016 the "."). But don't get confused if we have just "-o". */
3017 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3020 for (i = len - 1; i >= 0; i--)
3021 if (IS_DIR_SEPARATOR (name[i]))
3024 for (i++; i < len; i++)
3028 obstack_grow (&obstack, name, len);
3029 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3030 strlen (TARGET_EXECUTABLE_SUFFIX));
3031 name = obstack_finish (&obstack);
3038 /* Display the command line switches accepted by gcc. */
3042 printf (_("Usage: %s [options] file...\n"), programname);
3043 fputs (_("Options:\n"), stdout);
3045 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3046 fputs (_(" --help Display this information\n"), stdout);
3047 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3049 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3050 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3051 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3052 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3053 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3054 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3055 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3056 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3057 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3059 -print-multi-lib Display the mapping between command line options and\n\
3060 multiple library search directories\n"), stdout);
3061 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3062 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3063 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3064 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3065 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3066 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3067 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3068 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3069 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3070 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3071 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
3072 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
3073 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3074 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3075 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3076 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3077 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3078 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3080 -x <language> Specify the language of the following input files\n\
3081 Permissable languages include: c c++ assembler none\n\
3082 'none' means revert to the default behavior of\n\
3083 guessing the language based on the file's extension\n\
3087 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3088 passed on to the various sub-processes invoked by %s. In order to pass\n\
3089 other options on to these processes the -W<letter> options must be used.\n\
3092 /* The rest of the options are displayed by invocations of the various
3097 add_preprocessor_option (option, len)
3101 n_preprocessor_options++;
3103 if (! preprocessor_options)
3104 preprocessor_options
3105 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
3107 preprocessor_options
3108 = (char **) xrealloc (preprocessor_options,
3109 n_preprocessor_options * sizeof (char *));
3111 preprocessor_options [n_preprocessor_options - 1] =
3112 save_string (option, len);
3116 add_assembler_option (option, len)
3120 n_assembler_options++;
3122 if (! assembler_options)
3124 = (char **) xmalloc (n_assembler_options * sizeof (char *));
3127 = (char **) xrealloc (assembler_options,
3128 n_assembler_options * sizeof (char *));
3130 assembler_options [n_assembler_options - 1] = save_string (option, len);
3134 add_linker_option (option, len)
3140 if (! linker_options)
3142 = (char **) xmalloc (n_linker_options * sizeof (char *));
3145 = (char **) xrealloc (linker_options,
3146 n_linker_options * sizeof (char *));
3148 linker_options [n_linker_options - 1] = save_string (option, len);
3151 /* Create the vector `switches' and its contents.
3152 Store its length in `n_switches'. */
3155 process_command (argc, argv)
3157 const char *const *argv;
3162 const char *spec_lang = 0;
3163 int last_language_n_infiles;
3166 int lang_n_infiles = 0;
3167 #ifdef MODIFY_TARGET_NAME
3168 int is_modify_target_name;
3172 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3176 added_libraries = 0;
3178 /* Figure compiler version from version string. */
3180 compiler_version = temp1 = xstrdup (version_string);
3182 for (; *temp1; ++temp1)
3191 /* If there is a -V or -b option (or both), process it now, before
3192 trying to interpret the rest of the command line. */
3193 if (argc > 1 && argv[1][0] == '-'
3194 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3196 const char *new_version = DEFAULT_TARGET_VERSION;
3197 const char *new_machine = DEFAULT_TARGET_MACHINE;
3198 const char *progname = argv[0];
3203 while (argc > 1 && argv[1][0] == '-'
3204 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3206 char opt = argv[1][1];
3208 if (argv[1][2] != '\0')
3221 fatal ("`-%c' option must have argument", opt);
3228 for (baselen = strlen (progname); baselen > 0; baselen--)
3229 if (IS_DIR_SEPARATOR (progname[baselen-1]))
3231 new_argv0 = xmemdup (progname, baselen,
3232 baselen + concat_length (new_version, new_machine,
3233 "-gcc-", NULL) + 1);
3234 strcpy (new_argv0 + baselen, new_machine);
3235 strcat (new_argv0, "-gcc-");
3236 strcat (new_argv0, new_version);
3238 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3239 (argc + 1) * sizeof (argv[0]));
3240 new_argv[0] = new_argv0;
3242 execvp (new_argv0, new_argv);
3243 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
3246 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3247 see if we can create it from the pathname specified in argv[0]. */
3250 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3251 if (!gcc_exec_prefix)
3253 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3254 standard_exec_prefix);
3255 if (gcc_exec_prefix)
3256 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3260 if (gcc_exec_prefix)
3262 int len = strlen (gcc_exec_prefix);
3264 if (len > (int) sizeof ("/lib/gcc-lib/") - 1
3265 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3267 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
3268 if (IS_DIR_SEPARATOR (*temp)
3269 && strncmp (temp + 1, "lib", 3) == 0
3270 && IS_DIR_SEPARATOR (temp[4])
3271 && strncmp (temp + 5, "gcc-lib", 7) == 0)
3272 len -= sizeof ("/lib/gcc-lib/") - 1;
3275 set_std_prefix (gcc_exec_prefix, len);
3276 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC",
3277 PREFIX_PRIORITY_LAST, 0, NULL);
3278 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3279 PREFIX_PRIORITY_LAST, 0, NULL);
3282 /* COMPILER_PATH and LIBRARY_PATH have values
3283 that are lists of directory names with colons. */
3285 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
3288 const char *startp, *endp;
3289 char *nstore = (char *) alloca (strlen (temp) + 3);
3291 startp = endp = temp;
3294 if (*endp == PATH_SEPARATOR || *endp == 0)
3296 strncpy (nstore, startp, endp - startp);
3298 strcpy (nstore, concat (".", dir_separator_str, NULL));
3299 else if (!IS_DIR_SEPARATOR (endp[-1]))
3301 nstore[endp - startp] = DIR_SEPARATOR;
3302 nstore[endp - startp + 1] = 0;
3305 nstore[endp - startp] = 0;
3306 add_prefix (&exec_prefixes, nstore, 0,
3307 PREFIX_PRIORITY_LAST, 0, NULL);
3308 add_prefix (&include_prefixes,
3309 concat (nstore, "include", NULL),
3310 0, PREFIX_PRIORITY_LAST, 0, NULL);
3313 endp = startp = endp + 1;
3320 GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
3321 if (temp && *cross_compile == '0')
3323 const char *startp, *endp;
3324 char *nstore = (char *) alloca (strlen (temp) + 3);
3326 startp = endp = temp;
3329 if (*endp == PATH_SEPARATOR || *endp == 0)
3331 strncpy (nstore, startp, endp - startp);
3333 strcpy (nstore, concat (".", dir_separator_str, NULL));
3334 else if (!IS_DIR_SEPARATOR (endp[-1]))
3336 nstore[endp - startp] = DIR_SEPARATOR;
3337 nstore[endp - startp + 1] = 0;
3340 nstore[endp - startp] = 0;
3341 add_prefix (&startfile_prefixes, nstore, NULL,
3342 PREFIX_PRIORITY_LAST, 0, NULL);
3345 endp = startp = endp + 1;
3352 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3353 GET_ENV_PATH_LIST (temp, "LPATH");
3354 if (temp && *cross_compile == '0')
3356 const char *startp, *endp;
3357 char *nstore = (char *) alloca (strlen (temp) + 3);
3359 startp = endp = temp;
3362 if (*endp == PATH_SEPARATOR || *endp == 0)
3364 strncpy (nstore, startp, endp - startp);
3366 strcpy (nstore, concat (".", dir_separator_str, NULL));
3367 else if (!IS_DIR_SEPARATOR (endp[-1]))
3369 nstore[endp - startp] = DIR_SEPARATOR;
3370 nstore[endp - startp + 1] = 0;
3373 nstore[endp - startp] = 0;
3374 add_prefix (&startfile_prefixes, nstore, NULL,
3375 PREFIX_PRIORITY_LAST, 0, NULL);
3378 endp = startp = endp + 1;
3385 /* Convert new-style -- options to old-style. */
3386 translate_options (&argc, &argv);
3388 /* Do language-specific adjustment/addition of flags. */
3389 lang_specific_driver (&argc, &argv, &added_libraries);
3391 /* Scan argv twice. Here, the first time, just count how many switches
3392 there will be in their vector, and how many input files in theirs.
3393 Here we also parse the switches that cc itself uses (e.g. -v). */
3395 for (i = 1; i < argc; i++)
3397 if (! strcmp (argv[i], "-dumpspecs"))
3399 struct spec_list *sl;
3401 for (sl = specs; sl; sl = sl->next)
3402 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3403 if (link_command_spec)
3404 printf ("*link_command:\n%s\n\n", link_command_spec);
3407 else if (! strcmp (argv[i], "-dumpversion"))
3409 printf ("%s\n", spec_version);
3412 else if (! strcmp (argv[i], "-dumpmachine"))
3414 printf ("%s\n", spec_machine);
3417 else if (strcmp (argv[i], "-fversion") == 0)
3419 /* translate_options () has turned --version into -fversion. */
3420 printf (_("%s (GCC) %s\n"), programname, version_string);
3421 fputs (_("Copyright (C) 2002 Free Software Foundation, Inc.\n"),
3423 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3424 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3428 else if (strcmp (argv[i], "-fhelp") == 0)
3430 /* translate_options () has turned --help into -fhelp. */
3431 print_help_list = 1;
3433 /* We will be passing a dummy file on to the sub-processes. */
3437 /* CPP driver cannot obtain switch from cc1_options. */
3439 add_preprocessor_option ("--help", 6);
3440 add_assembler_option ("--help", 6);
3441 add_linker_option ("--help", 6);
3443 else if (strcmp (argv[i], "-ftarget-help") == 0)
3445 /* translate_options() has turned --target-help into -ftarget-help. */
3446 target_help_flag = 1;
3448 /* We will be passing a dummy file on to the sub-processes. */
3452 /* CPP driver cannot obtain switch from cc1_options. */
3454 add_preprocessor_option ("--target-help", 13);
3455 add_assembler_option ("--target-help", 13);
3456 add_linker_option ("--target-help", 13);
3458 else if (! strcmp (argv[i], "-pass-exit-codes"))
3460 pass_exit_codes = 1;
3463 else if (! strcmp (argv[i], "-print-search-dirs"))
3464 print_search_dirs = 1;
3465 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3466 print_file_name = "libgcc.a";
3467 else if (! strncmp (argv[i], "-print-file-name=", 17))
3468 print_file_name = argv[i] + 17;
3469 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3470 print_prog_name = argv[i] + 17;
3471 else if (! strcmp (argv[i], "-print-multi-lib"))
3472 print_multi_lib = 1;
3473 else if (! strcmp (argv[i], "-print-multi-directory"))
3474 print_multi_directory = 1;
3475 else if (! strncmp (argv[i], "-Wa,", 4))
3478 /* Pass the rest of this option to the assembler. */
3480 /* Split the argument at commas. */
3482 for (j = 4; argv[i][j]; j++)
3483 if (argv[i][j] == ',')
3485 add_assembler_option (argv[i] + prev, j - prev);
3489 /* Record the part after the last comma. */
3490 add_assembler_option (argv[i] + prev, j - prev);
3492 else if (! strncmp (argv[i], "-Wp,", 4))
3495 /* Pass the rest of this option to the preprocessor. */
3497 /* Split the argument at commas. */
3499 for (j = 4; argv[i][j]; j++)
3500 if (argv[i][j] == ',')
3502 add_preprocessor_option (argv[i] + prev, j - prev);
3506 /* Record the part after the last comma. */
3507 add_preprocessor_option (argv[i] + prev, j - prev);
3509 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3510 /* The +e options to the C++ front-end. */
3512 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3515 /* Split the argument at commas. */
3516 for (j = 3; argv[i][j]; j++)
3517 n_infiles += (argv[i][j] == ',');
3519 else if (strcmp (argv[i], "-Xlinker") == 0)
3522 fatal ("argument to `-Xlinker' is missing");
3527 else if (strcmp (argv[i], "-l") == 0)
3530 fatal ("argument to `-l' is missing");
3535 else if (strncmp (argv[i], "-l", 2) == 0)
3537 else if (strcmp (argv[i], "-save-temps") == 0)
3539 save_temps_flag = 1;
3542 else if (strcmp (argv[i], "-specs") == 0)
3544 struct user_specs *user = (struct user_specs *)
3545 xmalloc (sizeof (struct user_specs));
3547 fatal ("argument to `-specs' is missing");
3549 user->next = (struct user_specs *) 0;
3550 user->filename = argv[i];
3551 if (user_specs_tail)
3552 user_specs_tail->next = user;
3554 user_specs_head = user;
3555 user_specs_tail = user;
3557 else if (strncmp (argv[i], "-specs=", 7) == 0)
3559 struct user_specs *user = (struct user_specs *)
3560 xmalloc (sizeof (struct user_specs));
3561 if (strlen (argv[i]) == 7)
3562 fatal ("argument to `-specs=' is missing");
3564 user->next = (struct user_specs *) 0;
3565 user->filename = argv[i] + 7;
3566 if (user_specs_tail)
3567 user_specs_tail->next = user;
3569 user_specs_head = user;
3570 user_specs_tail = user;
3572 else if (strcmp (argv[i], "-time") == 0)
3574 else if (strcmp (argv[i], "-###") == 0)
3576 /* This is similar to -v except that there is no execution
3577 of the commands and the echoed arguments are quoted. It
3578 is intended for use in shell scripts to capture the
3579 driver-generated command line. */
3580 verbose_only_flag++;
3583 else if (argv[i][0] == '-' && argv[i][1] != 0)
3585 const char *p = &argv[i][1];
3592 fatal ("`-%c' must come at the start of the command line", c);
3600 if (p[1] == 0 && i + 1 == argc)
3601 fatal ("argument to `-B' is missing");
3607 len = strlen (value);
3609 /* Catch the case where the user has forgotten to append a
3610 directory separator to the path. Note, they may be using
3611 -B to add an executable name prefix, eg "i386-elf-", in
3612 order to distinguish between multiple installations of
3613 GCC in the same directory. Hence we must check to see
3614 if appending a directory separator actually makes a
3615 valid directory name. */
3616 if (! IS_DIR_SEPARATOR (value [len - 1])
3617 && is_directory (value, "", 0))
3619 char *tmp = xmalloc (len + 2);
3620 strcpy (tmp, value);
3621 tmp[len] = DIR_SEPARATOR;
3626 /* As a kludge, if the arg is "[foo/]stageN/", just
3627 add "[foo/]include" to the include prefix. */
3630 && (IS_DIR_SEPARATOR (value[len - 8]))))
3631 && strncmp (value + len - 7, "stage", 5) == 0
3632 && ISDIGIT (value[len - 2])
3633 && (IS_DIR_SEPARATOR (value[len - 1])))
3636 add_prefix (&include_prefixes, "include", NULL,
3637 PREFIX_PRIORITY_B_OPT, 0, NULL);
3640 char * string = xmalloc (len + 1);
3642 strncpy (string, value, len - 7);
3643 strcpy (string + len - 7, "include");
3644 add_prefix (&include_prefixes, string, NULL,
3645 PREFIX_PRIORITY_B_OPT, 0, NULL);
3649 add_prefix (&exec_prefixes, value, NULL,
3650 PREFIX_PRIORITY_B_OPT, 0, &warn_B);
3651 add_prefix (&startfile_prefixes, value, NULL,
3652 PREFIX_PRIORITY_B_OPT, 0, &warn_B);
3653 add_prefix (&include_prefixes, concat (value, "include", NULL),
3654 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL);
3659 case 'v': /* Print our subcommands and print versions. */
3661 /* If they do anything other than exactly `-v', don't set
3662 verbose_flag; rather, continue on to give the error. */
3680 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3685 /* Forward scan, just in case -S or -c is specified
3692 if (argv[j][0] == '-')
3694 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3700 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3701 j += skip - (argv[j][2] != 0);
3702 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3709 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3711 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3713 argv[i] = convert_filename (argv[i], ! have_c, 0);
3720 #ifdef MODIFY_TARGET_NAME
3721 is_modify_target_name = 0;
3723 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3724 if (! strcmp (argv[i], modify_target[j].sw))
3727 = (char *) xmalloc (strlen (modify_target[j].str)
3728 + strlen (spec_machine));
3731 int made_addition = 0;
3733 is_modify_target_name = 1;
3734 for (p = spec_machine, q = new_name; *p != 0; )
3736 if (modify_target[j].add_del == DELETE
3737 && (! strncmp (q, modify_target[j].str,
3738 strlen (modify_target[j].str))))
3739 p += strlen (modify_target[j].str);
3740 else if (modify_target[j].add_del == ADD
3741 && ! made_addition && *p == '-')
3743 for (r = modify_target[j].str; *r != 0; )
3751 spec_machine = new_name;
3754 if (is_modify_target_name)
3760 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3761 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3762 else if (WORD_SWITCH_TAKES_ARG (p))
3763 i += WORD_SWITCH_TAKES_ARG (p);
3773 if (have_c && have_o && lang_n_infiles > 1)
3774 fatal ("cannot specify -o with -c or -S and multiple compilations");
3776 /* Set up the search paths before we go looking for config files. */
3778 /* These come before the md prefixes so that we will find gcc's subcommands
3779 (such as cpp) rather than those of the host system. */
3780 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3781 as well as trying the machine and the version. */
3783 add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
3784 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3785 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3786 PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
3787 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3788 PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
3791 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3792 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3793 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3794 PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
3796 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3797 dir_separator_str, NULL);
3799 /* If tooldir is relative, base it on exec_prefixes. A relative
3800 tooldir lets us move the installed tree as a unit.
3802 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3803 directories, so that we can search both the user specified directory
3804 and the standard place. */
3806 if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix))
3808 if (gcc_exec_prefix)
3810 char *gcc_exec_tooldir_prefix
3811 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3812 spec_version, dir_separator_str, tooldir_prefix, NULL);
3814 add_prefix (&exec_prefixes,
3815 concat (gcc_exec_tooldir_prefix, "bin",
3816 dir_separator_str, NULL),
3817 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
3818 add_prefix (&startfile_prefixes,
3819 concat (gcc_exec_tooldir_prefix, "lib",
3820 dir_separator_str, NULL),
3821 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
3824 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3825 dir_separator_str, spec_version,
3826 dir_separator_str, tooldir_prefix, NULL);
3829 add_prefix (&exec_prefixes,
3830 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3831 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
3832 add_prefix (&startfile_prefixes,
3833 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3834 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
3836 /* More prefixes are enabled in main, after we read the specs file
3837 and determine whether this is cross-compilation or not. */
3839 /* Then create the space for the vectors and scan again. */
3841 switches = ((struct switchstr *)
3842 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3843 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3846 last_language_n_infiles = -1;
3848 /* This, time, copy the text of each switch and store a pointer
3849 to the copy in the vector of switches.
3850 Store all the infiles in their vector. */
3852 for (i = 1; i < argc; i++)
3854 /* Just skip the switches that were handled by the preceding loop. */
3855 #ifdef MODIFY_TARGET_NAME
3856 is_modify_target_name = 0;
3858 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3859 if (! strcmp (argv[i], modify_target[j].sw))
3860 is_modify_target_name = 1;
3862 if (is_modify_target_name)
3866 if (! strncmp (argv[i], "-Wa,", 4))
3868 else if (! strncmp (argv[i], "-Wp,", 4))
3870 else if (! strcmp (argv[i], "-pass-exit-codes"))
3872 else if (! strcmp (argv[i], "-print-search-dirs"))
3874 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3876 else if (! strncmp (argv[i], "-print-file-name=", 17))
3878 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3880 else if (! strcmp (argv[i], "-print-multi-lib"))
3882 else if (! strcmp (argv[i], "-print-multi-directory"))
3884 else if (! strcmp (argv[i], "-ftarget-help"))
3886 else if (! strcmp (argv[i], "-fhelp"))
3888 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3890 /* Compensate for the +e options to the C++ front-end;
3891 they're there simply for cfront call-compatibility. We do
3892 some magic in default_compilers to pass them down properly.
3893 Note we deliberately start at the `+' here, to avoid passing
3894 -e0 or -e1 down into the linker. */
3895 switches[n_switches].part1 = &argv[i][0];
3896 switches[n_switches].args = 0;
3897 switches[n_switches].live_cond = SWITCH_OK;
3898 switches[n_switches].validated = 0;
3901 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3904 /* Split the argument at commas. */
3906 for (j = 4; argv[i][j]; j++)
3907 if (argv[i][j] == ',')
3909 infiles[n_infiles].language = "*";
3910 infiles[n_infiles++].name
3911 = save_string (argv[i] + prev, j - prev);
3914 /* Record the part after the last comma. */
3915 infiles[n_infiles].language = "*";
3916 infiles[n_infiles++].name = argv[i] + prev;
3918 else if (strcmp (argv[i], "-Xlinker") == 0)
3920 infiles[n_infiles].language = "*";
3921 infiles[n_infiles++].name = argv[++i];
3923 else if (strcmp (argv[i], "-l") == 0)
3924 { /* POSIX allows separation of -l and the lib arg;
3925 canonicalize by concatenating -l with its arg */
3926 infiles[n_infiles].language = "*";
3927 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3929 else if (strncmp (argv[i], "-l", 2) == 0)
3931 infiles[n_infiles].language = "*";
3932 infiles[n_infiles++].name = argv[i];
3934 else if (strcmp (argv[i], "-specs") == 0)
3936 else if (strncmp (argv[i], "-specs=", 7) == 0)
3938 else if (strcmp (argv[i], "-time") == 0)
3940 else if ((save_temps_flag || report_times)
3941 && strcmp (argv[i], "-pipe") == 0)
3943 /* -save-temps overrides -pipe, so that temp files are produced */
3944 if (save_temps_flag)
3945 error ("warning: -pipe ignored because -save-temps specified");
3946 /* -time overrides -pipe because we can't get correct stats when
3947 multiple children are running at once. */
3948 else if (report_times)
3949 error ("warning: -pipe ignored because -time specified");
3951 else if (strcmp (argv[i], "-###") == 0)
3953 else if (argv[i][0] == '-' && argv[i][1] != 0)
3955 const char *p = &argv[i][1];
3960 if (p[1] == 0 && i + 1 == argc)
3961 fatal ("argument to `-x' is missing");
3963 spec_lang = argv[++i];
3966 if (! strcmp (spec_lang, "none"))
3967 /* Suppress the warning if -xnone comes after the last input
3968 file, because alternate command interfaces like g++ might
3969 find it useful to place -xnone after each input file. */
3972 last_language_n_infiles = n_infiles;
3975 switches[n_switches].part1 = p;
3976 /* Deal with option arguments in separate argv elements. */
3977 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3978 || WORD_SWITCH_TAKES_ARG (p))
3981 int n_args = WORD_SWITCH_TAKES_ARG (p);
3985 /* Count only the option arguments in separate argv elements. */
3986 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3988 if (i + n_args >= argc)
3989 fatal ("argument to `-%s' is missing", p);
3990 switches[n_switches].args
3991 = (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
3993 switches[n_switches].args[j++] = argv[++i];
3994 /* Null-terminate the vector. */
3995 switches[n_switches].args[j] = 0;
3997 else if (strchr (switches_need_spaces, c))
3999 /* On some systems, ld cannot handle some options without
4000 a space. So split the option from its argument. */
4001 char *part1 = (char *) xmalloc (2);
4005 switches[n_switches].part1 = part1;
4006 switches[n_switches].args
4007 = (const char **) xmalloc (2 * sizeof (const char *));
4008 switches[n_switches].args[0] = xstrdup (p+1);
4009 switches[n_switches].args[1] = 0;
4012 switches[n_switches].args = 0;
4014 switches[n_switches].live_cond = SWITCH_OK;
4015 switches[n_switches].validated = 0;
4016 switches[n_switches].ordering = 0;
4017 /* These are always valid, since gcc.c itself understands it. */
4018 if (!strcmp (p, "save-temps")
4019 || !strcmp (p, "static-libgcc")
4020 || !strcmp (p, "shared-libgcc"))
4021 switches[n_switches].validated = 1;
4024 char ch = switches[n_switches].part1[0];
4026 switches[n_switches].validated = 1;
4032 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4033 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4036 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4038 perror_with_name (argv[i]);
4043 infiles[n_infiles].language = spec_lang;
4044 infiles[n_infiles++].name = argv[i];
4049 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4050 error ("warning: `-x %s' after last input file has no effect", spec_lang);
4052 /* Ensure we only invoke each subprocess once. */
4053 if (target_help_flag || print_help_list)
4057 /* Create a dummy input file, so that we can pass --target-help on to
4058 the various sub-processes. */
4059 infiles[0].language = "c";
4060 infiles[0].name = "help-dummy";
4062 if (target_help_flag)
4064 switches[n_switches].part1 = "--target-help";
4065 switches[n_switches].args = 0;
4066 switches[n_switches].live_cond = SWITCH_OK;
4067 switches[n_switches].validated = 0;
4072 if (print_help_list)
4074 switches[n_switches].part1 = "--help";
4075 switches[n_switches].args = 0;
4076 switches[n_switches].live_cond = SWITCH_OK;
4077 switches[n_switches].validated = 0;
4083 switches[n_switches].part1 = 0;
4084 infiles[n_infiles].name = 0;
4087 /* Store switches not filtered out by %{<S} in spec in COLLECT_GCC_OPTIONS
4088 and place that in the environment. */
4091 set_collect_gcc_options ()
4096 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4098 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4099 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4102 for (i = 0; (int) i < n_switches; i++)
4104 const char *const *args;
4107 obstack_grow (&collect_obstack, " ", 1);
4111 /* Ignore elided switches. */
4112 if (switches[i].live_cond == SWITCH_IGNORE)
4115 obstack_grow (&collect_obstack, "'-", 2);
4116 q = switches[i].part1;
4117 while ((p = strchr (q, '\'')))
4119 obstack_grow (&collect_obstack, q, p - q);
4120 obstack_grow (&collect_obstack, "'\\''", 4);
4123 obstack_grow (&collect_obstack, q, strlen (q));
4124 obstack_grow (&collect_obstack, "'", 1);
4126 for (args = switches[i].args; args && *args; args++)
4128 obstack_grow (&collect_obstack, " '", 2);
4130 while ((p = strchr (q, '\'')))
4132 obstack_grow (&collect_obstack, q, p - q);
4133 obstack_grow (&collect_obstack, "'\\''", 4);
4136 obstack_grow (&collect_obstack, q, strlen (q));
4137 obstack_grow (&collect_obstack, "'", 1);
4140 obstack_grow (&collect_obstack, "\0", 1);
4141 putenv (obstack_finish (&collect_obstack));
4144 /* Process a spec string, accumulating and running commands. */
4146 /* These variables describe the input file name.
4147 input_file_number is the index on outfiles of this file,
4148 so that the output file name can be stored for later use by %o.
4149 input_basename is the start of the part of the input file
4150 sans all directory names, and basename_length is the number
4151 of characters starting there excluding the suffix .c or whatever. */
4153 const char *input_filename;
4154 static int input_file_number;
4155 size_t input_filename_length;
4156 static int basename_length;
4157 static int suffixed_basename_length;
4158 static const char *input_basename;
4159 static const char *input_suffix;
4160 static struct stat input_stat;
4161 static int input_stat_set;
4163 /* The compiler used to process the current input file. */
4164 static struct compiler *input_file_compiler;
4166 /* These are variables used within do_spec and do_spec_1. */
4168 /* Nonzero if an arg has been started and not yet terminated
4169 (with space, tab or newline). */
4170 static int arg_going;
4172 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4173 is a temporary file name. */
4174 static int delete_this_arg;
4176 /* Nonzero means %w has been seen; the next arg to be terminated
4177 is the output file name of this compilation. */
4178 static int this_is_output_file;
4180 /* Nonzero means %s has been seen; the next arg to be terminated
4181 is the name of a library file and we should try the standard
4182 search dirs for it. */
4183 static int this_is_library_file;
4185 /* Nonzero means that the input of this command is coming from a pipe. */
4186 static int input_from_pipe;
4188 /* Nonnull means substitute this for any suffix when outputting a switches
4190 static const char *suffix_subst;
4192 /* Process the spec SPEC and run the commands specified therein.
4193 Returns 0 if the spec is successfully processed; -1 if failed. */
4201 value = do_spec_2 (spec);
4203 /* Force out any unfinished command.
4204 If -pipe, this forces out the last command if it ended in `|'. */
4207 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4210 set_collect_gcc_options ();
4212 if (argbuf_index > 0)
4225 delete_this_arg = 0;
4226 this_is_output_file = 0;
4227 this_is_library_file = 0;
4228 input_from_pipe = 0;
4229 suffix_subst = NULL;
4231 return do_spec_1 (spec, 0, NULL);
4234 /* Process the sub-spec SPEC as a portion of a larger spec.
4235 This is like processing a whole spec except that we do
4236 not initialize at the beginning and we do not supply a
4237 newline by default at the end.
4238 INSWITCH nonzero means don't process %-sequences in SPEC;
4239 in this case, % is treated as an ordinary character.
4240 This is used while substituting switches.
4241 INSWITCH nonzero also causes SPC not to terminate an argument.
4243 Value is zero unless a line was finished
4244 and the command on that line reported an error. */
4247 do_spec_1 (spec, inswitch, soft_matched_part)
4250 const char *soft_matched_part;
4252 const char *p = spec;
4259 /* If substituting a switch, treat all chars like letters.
4260 Otherwise, NL, SPC, TAB and % are special. */
4261 switch (inswitch ? 'a' : c)
4264 /* End of line: finish any pending argument,
4265 then run the pending command if one has been started. */
4268 obstack_1grow (&obstack, 0);
4269 string = obstack_finish (&obstack);
4270 if (this_is_library_file)
4271 string = find_file (string);
4272 store_arg (string, delete_this_arg, this_is_output_file);
4273 if (this_is_output_file)
4274 outfiles[input_file_number] = string;
4278 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4280 for (i = 0; i < n_switches; i++)
4281 if (!strcmp (switches[i].part1, "pipe"))
4284 /* A `|' before the newline means use a pipe here,
4285 but only if -pipe was specified.
4286 Otherwise, execute now and don't pass the `|' as an arg. */
4289 input_from_pipe = 1;
4290 switches[i].validated = 1;
4297 set_collect_gcc_options ();
4299 if (argbuf_index > 0)
4305 /* Reinitialize for a new command, and for a new argument. */
4308 delete_this_arg = 0;
4309 this_is_output_file = 0;
4310 this_is_library_file = 0;
4311 input_from_pipe = 0;
4315 /* End any pending argument. */
4318 obstack_1grow (&obstack, 0);
4319 string = obstack_finish (&obstack);
4320 if (this_is_library_file)
4321 string = find_file (string);
4322 store_arg (string, delete_this_arg, this_is_output_file);
4323 if (this_is_output_file)
4324 outfiles[input_file_number] = string;
4328 obstack_1grow (&obstack, c);
4334 /* Space or tab ends an argument if one is pending. */
4337 obstack_1grow (&obstack, 0);
4338 string = obstack_finish (&obstack);
4339 if (this_is_library_file)
4340 string = find_file (string);
4341 store_arg (string, delete_this_arg, this_is_output_file);
4342 if (this_is_output_file)
4343 outfiles[input_file_number] = string;
4345 /* Reinitialize for a new argument. */
4347 delete_this_arg = 0;
4348 this_is_output_file = 0;
4349 this_is_library_file = 0;
4356 fatal ("invalid specification! Bug in cc");
4359 obstack_grow (&obstack, input_basename, basename_length);
4364 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4369 delete_this_arg = 2;
4372 /* Dump out the directories specified with LIBRARY_PATH,
4373 followed by the absolute directories
4374 that we search for startfiles. */
4377 struct prefix_list *pl = startfile_prefixes.plist;
4378 size_t bufsize = 100;
4379 char *buffer = (char *) xmalloc (bufsize);
4382 for (; pl; pl = pl->next)
4384 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4385 /* Used on systems which record the specified -L dirs
4386 and use them to search for dynamic linking. */
4387 /* Relative directories always come from -B,
4388 and it is better not to use them for searching
4389 at run time. In particular, stage1 loses. */
4390 if (!IS_ABSOLUTE_PATHNAME (pl->prefix))
4393 /* Try subdirectory if there is one. */
4394 if (multilib_dir != NULL)
4398 if (strlen (pl->prefix) + strlen (machine_suffix)
4400 bufsize = (strlen (pl->prefix)
4401 + strlen (machine_suffix)) * 2 + 1;
4402 buffer = (char *) xrealloc (buffer, bufsize);
4403 strcpy (buffer, pl->prefix);
4404 strcat (buffer, machine_suffix);
4405 if (is_directory (buffer, multilib_dir, 1))
4407 do_spec_1 ("-L", 0, NULL);
4408 #ifdef SPACE_AFTER_L_OPTION
4409 do_spec_1 (" ", 0, NULL);
4411 do_spec_1 (buffer, 1, NULL);
4412 do_spec_1 (multilib_dir, 1, NULL);
4413 /* Make this a separate argument. */
4414 do_spec_1 (" ", 0, NULL);
4417 if (!pl->require_machine_suffix)
4419 if (is_directory (pl->prefix, multilib_dir, 1))
4421 do_spec_1 ("-L", 0, NULL);
4422 #ifdef SPACE_AFTER_L_OPTION
4423 do_spec_1 (" ", 0, NULL);
4425 do_spec_1 (pl->prefix, 1, NULL);
4426 do_spec_1 (multilib_dir, 1, NULL);
4427 /* Make this a separate argument. */
4428 do_spec_1 (" ", 0, NULL);
4434 if (is_directory (pl->prefix, machine_suffix, 1))
4436 do_spec_1 ("-L", 0, NULL);
4437 #ifdef SPACE_AFTER_L_OPTION
4438 do_spec_1 (" ", 0, NULL);
4440 do_spec_1 (pl->prefix, 1, NULL);
4441 /* Remove slash from machine_suffix. */
4442 if (strlen (machine_suffix) >= bufsize)
4443 bufsize = strlen (machine_suffix) * 2 + 1;
4444 buffer = (char *) xrealloc (buffer, bufsize);
4445 strcpy (buffer, machine_suffix);
4446 idx = strlen (buffer);
4447 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4448 buffer[idx - 1] = 0;
4449 do_spec_1 (buffer, 1, NULL);
4450 /* Make this a separate argument. */
4451 do_spec_1 (" ", 0, NULL);
4454 if (!pl->require_machine_suffix)
4456 if (is_directory (pl->prefix, "", 1))
4458 do_spec_1 ("-L", 0, NULL);
4459 #ifdef SPACE_AFTER_L_OPTION
4460 do_spec_1 (" ", 0, NULL);
4462 /* Remove slash from pl->prefix. */
4463 if (strlen (pl->prefix) >= bufsize)
4464 bufsize = strlen (pl->prefix) * 2 + 1;
4465 buffer = (char *) xrealloc (buffer, bufsize);
4466 strcpy (buffer, pl->prefix);
4467 idx = strlen (buffer);
4468 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4469 buffer[idx - 1] = 0;
4470 do_spec_1 (buffer, 1, NULL);
4471 /* Make this a separate argument. */
4472 do_spec_1 (" ", 0, NULL);
4481 /* %efoo means report an error with `foo' as error message
4482 and don't execute any more commands for this file. */
4486 while (*p != 0 && *p != '\n')
4488 buf = (char *) alloca (p - q + 1);
4489 strncpy (buf, q, p - q);
4496 /* %nfoo means report an notice with `foo' on stderr. */
4500 while (*p != 0 && *p != '\n')
4502 buf = (char *) alloca (p - q + 1);
4503 strncpy (buf, q, p - q);
4505 notice ("%s\n", buf);
4515 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is defined,
4516 and it is not a directory, and it is writable, use it.
4517 Otherwise, fall through and treat this like any other
4520 if ((!save_temps_flag)
4521 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4522 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4524 obstack_grow (&obstack, HOST_BIT_BUCKET,
4525 strlen (HOST_BIT_BUCKET));
4526 delete_this_arg = 0;
4535 struct temp_name *t;
4537 const char *suffix = p;
4538 char *saved_suffix = NULL;
4540 while (*p == '.' || ISALPHA ((unsigned char) *p))
4542 suffix_length = p - suffix;
4543 if (p[0] == '%' && p[1] == 'O')
4546 /* We don't support extra suffix characters after %O. */
4547 if (*p == '.' || ISALPHA ((unsigned char) *p))
4549 if (suffix_length == 0)
4550 suffix = TARGET_OBJECT_SUFFIX;
4554 = (char *) xmalloc (suffix_length
4555 + strlen (TARGET_OBJECT_SUFFIX));
4556 strncpy (saved_suffix, suffix, suffix_length);
4557 strcpy (saved_suffix + suffix_length,
4558 TARGET_OBJECT_SUFFIX);
4560 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4563 /* If the input_filename has the same suffix specified
4564 for the %g, %u, or %U, and -save-temps is specified,
4565 we could end up using that file as an intermediate
4566 thus clobbering the user's source file (.e.g.,
4567 gcc -save-temps foo.s would clobber foo.s with the
4568 output of cpp0). So check for this condition and
4569 generate a temp file as the intermediate. */
4571 if (save_temps_flag)
4573 temp_filename_length = basename_length + suffix_length;
4574 temp_filename = alloca (temp_filename_length + 1);
4575 strncpy ((char *) temp_filename, input_basename, basename_length);
4576 strncpy ((char *) temp_filename + basename_length, suffix,
4578 *((char *) temp_filename + temp_filename_length) = '\0';
4579 if (strcmp (temp_filename, input_filename) != 0)
4581 struct stat st_temp;
4583 /* Note, set_input() resets input_stat_set to 0. */
4584 if (input_stat_set == 0)
4586 input_stat_set = stat (input_filename, &input_stat);
4587 if (input_stat_set >= 0)
4591 /* If we have the stat for the input_filename
4592 and we can do the stat for the temp_filename
4593 then the they could still refer to the same
4594 file if st_dev/st_ino's are the same. */
4596 if (input_stat_set != 1
4597 || stat (temp_filename, &st_temp) < 0
4598 || input_stat.st_dev != st_temp.st_dev
4599 || input_stat.st_ino != st_temp.st_ino)
4601 temp_filename = save_string (temp_filename,
4602 temp_filename_length + 1);
4603 obstack_grow (&obstack, temp_filename,
4604 temp_filename_length);
4611 /* See if we already have an association of %g/%u/%U and
4613 for (t = temp_names; t; t = t->next)
4614 if (t->length == suffix_length
4615 && strncmp (t->suffix, suffix, suffix_length) == 0
4616 && t->unique == (c != 'g'))
4619 /* Make a new association if needed. %u and %j
4621 if (t == 0 || c == 'u' || c == 'j')
4625 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
4626 t->next = temp_names;
4629 t->length = suffix_length;
4632 t->suffix = saved_suffix;
4633 saved_suffix = NULL;
4636 t->suffix = save_string (suffix, suffix_length);
4637 t->unique = (c != 'g');
4638 temp_filename = make_temp_file (t->suffix);
4639 temp_filename_length = strlen (temp_filename);
4640 t->filename = temp_filename;
4641 t->filename_length = temp_filename_length;
4645 free (saved_suffix);
4647 obstack_grow (&obstack, t->filename, t->filename_length);
4648 delete_this_arg = 1;
4654 obstack_grow (&obstack, input_filename, input_filename_length);
4660 struct prefix_list *pl = include_prefixes.plist;
4662 if (gcc_exec_prefix)
4664 do_spec_1 ("-iprefix", 1, NULL);
4665 /* Make this a separate argument. */
4666 do_spec_1 (" ", 0, NULL);
4667 do_spec_1 (gcc_exec_prefix, 1, NULL);
4668 do_spec_1 (" ", 0, NULL);
4671 for (; pl; pl = pl->next)
4673 do_spec_1 ("-isystem", 1, NULL);
4674 /* Make this a separate argument. */
4675 do_spec_1 (" ", 0, NULL);
4676 do_spec_1 (pl->prefix, 1, NULL);
4677 do_spec_1 (" ", 0, NULL);
4684 int max = n_infiles;
4685 max += lang_specific_extra_outfiles;
4687 for (i = 0; i < max; i++)
4689 store_arg (outfiles[i], 0, 0);
4694 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4699 this_is_library_file = 1;
4703 this_is_output_file = 1;
4708 int cur_index = argbuf_index;
4709 /* Handle the {...} following the %W. */
4712 p = handle_braces (p + 1);
4715 /* If any args were output, mark the last one for deletion
4717 if (argbuf_index != cur_index)
4718 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4722 /* %x{OPTION} records OPTION for %X to output. */
4728 /* Skip past the option value and make a copy. */
4733 string = save_string (p1 + 1, p - p1 - 2);
4735 /* See if we already recorded this option. */
4736 for (i = 0; i < n_linker_options; i++)
4737 if (! strcmp (string, linker_options[i]))
4743 /* This option is new; add it. */
4744 add_linker_option (string, strlen (string));
4748 /* Dump out the options accumulated previously using %x. */
4750 for (i = 0; i < n_linker_options; i++)
4752 do_spec_1 (linker_options[i], 1, NULL);
4753 /* Make each accumulated option a separate argument. */
4754 do_spec_1 (" ", 0, NULL);
4758 /* Dump out the options accumulated previously using -Wa,. */
4760 for (i = 0; i < n_assembler_options; i++)
4762 do_spec_1 (assembler_options[i], 1, NULL);
4763 /* Make each accumulated option a separate argument. */
4764 do_spec_1 (" ", 0, NULL);
4768 /* Dump out the options accumulated previously using -Wp,. */
4770 for (i = 0; i < n_preprocessor_options; i++)
4772 do_spec_1 (preprocessor_options[i], 1, NULL);
4773 /* Make each accumulated option a separate argument. */
4774 do_spec_1 (" ", 0, NULL);
4778 /* Here are digits and numbers that just process
4779 a certain constant string as a spec. */
4782 value = do_spec_1 (cc1_spec, 0, NULL);
4788 value = do_spec_1 (cc1plus_spec, 0, NULL);
4794 value = do_spec_1 (asm_spec, 0, NULL);
4800 value = do_spec_1 (asm_final_spec, 0, NULL);
4807 const char *const spec
4808 = (input_file_compiler->cpp_spec
4809 ? input_file_compiler->cpp_spec
4811 value = do_spec_1 (spec, 0, NULL);
4818 value = do_spec_1 (endfile_spec, 0, NULL);
4824 value = do_spec_1 (link_spec, 0, NULL);
4830 value = do_spec_1 (lib_spec, 0, NULL);
4836 value = do_spec_1 (libgcc_spec, 0, NULL);
4842 if (multilib_dir && strcmp (multilib_dir, ".") != 0)
4848 len = strlen (multilib_dir);
4849 obstack_blank (&obstack, len + 1);
4850 p = obstack_next_free (&obstack) - (len + 1);
4853 for (q = multilib_dir; *q ; ++q, ++p)
4854 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
4860 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
4864 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4868 if (! strncmp (y, "-D", 2))
4869 /* Copy the whole option. */
4870 while (*y && *y != ' ' && *y != '\t')
4872 else if (*y == ' ' || *y == '\t')
4873 /* Copy whitespace to the result. */
4875 /* Don't copy other options. */
4882 value = do_spec_1 (buf, 0, NULL);
4890 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
4894 /* Copy all of CPP_PREDEFINES into BUF,
4895 but force them all into the reserved name space if they
4896 aren't already there. The reserved name space is all
4897 identifiers beginning with two underscores or with one
4898 underscore and a capital letter. We do the forcing by
4899 adding up to two underscores to the beginning and end
4900 of each symbol. e.g. mips, _mips, mips_, and _mips_ all
4905 if (! strncmp (y, "-D", 2))
4914 && ! ISUPPER ((unsigned char) *(y + 1))))
4916 /* Stick __ at front of macro name. */
4920 /* Arrange to stick __ at the end as well. */
4924 /* Copy the macro name. */
4925 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4938 /* Copy the value given, if any. */
4939 while (*y && *y != ' ' && *y != '\t')
4942 else if (*y == ' ' || *y == '\t')
4943 /* Copy whitespace to the result. */
4945 /* Don't copy -A options */
4951 /* Copy all of CPP_PREDEFINES into BUF,
4952 but put __ after every -D. */
4956 if (! strncmp (y, "-D", 2))
4962 && ! ISUPPER ((unsigned char) *(y + 1))))
4964 /* Stick -D__ at front of macro name. */
4971 /* Copy the macro name. */
4972 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4975 /* Copy the value given, if any. */
4976 while (*y && *y != ' ' && *y != '\t')
4981 /* Do not copy this macro - we have just done it before */
4982 while (*y && *y != ' ' && *y != '\t')
4986 else if (*y == ' ' || *y == '\t')
4987 /* Copy whitespace to the result. */
4989 /* Don't copy -A options. */
4995 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4999 if (! strncmp (y, "-A", 2))
5000 /* Copy the whole option. */
5001 while (*y && *y != ' ' && *y != '\t')
5003 else if (*y == ' ' || *y == '\t')
5004 /* Copy whitespace to the result. */
5006 /* Don't copy other options. */
5013 value = do_spec_1 (buf, 0, NULL);
5020 value = do_spec_1 (startfile_spec, 0, NULL);
5025 /* Here we define characters other than letters and digits. */
5028 p = handle_braces (p);
5034 obstack_1grow (&obstack, '%');
5041 while (p[len] && p[len] != ' ' && p[len] != '%')
5043 suffix_subst = save_string (p - 1, len + 1);
5049 if (soft_matched_part)
5051 do_spec_1 (soft_matched_part, 1, NULL);
5052 do_spec_1 (" ", 0, NULL);
5055 /* Catch the case where a spec string contains something like
5056 '%{foo:%*}'. ie there is no * in the pattern on the left
5057 hand side of the :. */
5058 error ("spec failure: '%%*' has not been initialized by pattern match");
5061 /* Process a string found as the value of a spec given by name.
5062 This feature allows individual machine descriptions
5063 to add and use their own specs.
5064 %[...] modifies -D options the way %P does;
5065 %(...) uses the spec unmodified. */
5067 error ("warning: use of obsolete %%[ operator in specs");
5070 const char *name = p;
5071 struct spec_list *sl;
5074 /* The string after the S/P is the name of a spec that is to be
5076 while (*p && *p != ')' && *p != ']')
5079 /* See if it's in the list. */
5080 for (len = p - name, sl = specs; sl; sl = sl->next)
5081 if (sl->name_len == len && !strncmp (sl->name, name, len))
5083 name = *(sl->ptr_spec);
5085 notice ("Processing spec %c%s%c, which is '%s'\n",
5086 c, sl->name, (c == '(') ? ')' : ']', name);
5095 value = do_spec_1 (name, 0, NULL);
5101 char *x = (char *) alloca (strlen (name) * 2 + 1);
5103 const char *y = name;
5106 /* Copy all of NAME into BUF, but put __ after
5107 every -D and at the end of each arg. */
5110 if (! strncmp (y, "-D", 2))
5121 && (*y == ' ' || *y == '\t' || *y == '='
5122 || *y == '}' || *y == 0))
5135 value = do_spec_1 (buf, 0, NULL);
5141 /* Discard the closing paren or bracket. */
5149 int c1 = *p++; /* Select first or second version number. */
5150 const char *v = compiler_version;
5152 static const char zeroc = '0';
5154 /* The format of the version string is
5155 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
5157 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
5158 while (! ISDIGIT (*v))
5160 if (v > compiler_version && v[-1] != '-')
5163 /* If desired, advance to second version number. */
5166 /* Set V after the first period. */
5167 while (ISDIGIT (*v))
5174 /* If desired, advance to third version number.
5175 But don't complain if it's not present */
5178 /* Set V after the second period. */
5179 while (ISDIGIT (*v))
5181 if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
5187 /* Set Q at the next period or at the end. */
5189 while (ISDIGIT (*q))
5191 if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
5195 /* Put that part into the command. */
5196 obstack_grow (&obstack, v, q - v);
5198 /* Default to "0" */
5199 obstack_grow (&obstack, &zeroc, 1);
5205 if (input_from_pipe)
5206 do_spec_1 ("-", 0, NULL);
5210 error ("spec failure: unrecognized spec option '%c'", c);
5216 /* Backslash: treat next character as ordinary. */
5221 /* Ordinary character: put it into the current argument. */
5222 obstack_1grow (&obstack, c);
5226 /* End of string. */
5230 /* Return 0 if we call do_spec_1 and that returns -1. */
5236 const char *filter, *body = NULL, *endbody = NULL;
5238 int true_once = 0; /* If, in %{a|b:d}, at least one of a,b was seen. */
5241 int include_blanks = 1;
5242 int elide_switch = 0;
5247 /* A '^' after the open-brace means to not give blanks before args. */
5254 /* A `|' after the open-brace means,
5255 if the test fails, output a single minus sign rather than nothing.
5256 This is used in %{|!pipe:...}. */
5263 /* A `<' after the open-brace means that the switch should be
5264 removed from the command-line. */
5270 negate = suffix = 0;
5273 /* A `!' after the open-brace negates the condition:
5274 succeed if the specified switch is not present. */
5278 /* A `.' after the open-brace means test against the current suffix. */
5287 if (elide_switch && (negate || pipe_p || suffix))
5289 /* It doesn't make sense to mix elision with other flags. We
5290 could fatal() here, but the standard seems to be to abort. */
5296 while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
5299 if (*p == '|' && (pipe_p || ordered))
5304 if (*p != '}' && *p != '&')
5320 fatal ("mismatched braces in specs");
5326 body = p, endbody = p + 1;
5331 int found = (input_suffix != 0
5332 && (long) strlen (input_suffix) == (long) (p - filter)
5333 && strncmp (input_suffix, filter, p - filter) == 0);
5339 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL) < 0)
5342 else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
5344 /* Substitute all matching switches as separate args. */
5347 for (i = 0; i < n_switches; i++)
5348 if (!strncmp (switches[i].part1, filter, p - 1 - filter)
5349 && check_live_switch (i, p - 1 - filter))
5353 switches[i].live_cond = SWITCH_IGNORE;
5354 switches[i].validated = 1;
5357 ordered = 1, switches[i].ordering = 1;
5362 /* Test for presence of the specified switch. */
5366 /* If name specified ends in *, as in {x*:...},
5367 check for %* and handle that case. */
5368 if (p[-1] == '*' && !negate)
5371 const char *r = body;
5373 /* First see whether we have %*. */
5377 if (*r == '%' && r[1] == '*')
5381 /* If we do, handle that case. */
5384 /* Substitute all matching switches as separate args.
5385 But do this by substituting for %*
5386 in the text that follows the colon. */
5388 unsigned hard_match_len = p - filter - 1;
5389 char *string = save_string (body, endbody - body - 1);
5391 for (i = 0; i < n_switches; i++)
5392 if (!strncmp (switches[i].part1, filter, hard_match_len)
5393 && check_live_switch (i, -1))
5395 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
5396 /* Pass any arguments this switch has. */
5397 give_switch (i, 1, 1);
5398 suffix_subst = NULL;
5401 /* We didn't match. Try again. */
5408 /* If name specified ends in *, as in {x*:...},
5409 check for presence of any switch name starting with x. */
5412 for (i = 0; i < n_switches; i++)
5414 unsigned hard_match_len = p - filter - 1;
5416 if (!strncmp (switches[i].part1, filter, hard_match_len)
5417 && check_live_switch (i, hard_match_len))
5424 /* Otherwise, check for presence of exact name specified. */
5427 for (i = 0; i < n_switches; i++)
5429 if (!strncmp (switches[i].part1, filter, p - filter)
5430 && switches[i].part1[p - filter] == 0
5431 && check_live_switch (i, -1))
5439 /* If it is as desired (present for %{s...}, absent for %{!s...})
5440 then substitute either the switch or the specified
5441 conditional text. */
5442 if (present != negate)
5446 switches[i].live_cond = SWITCH_IGNORE;
5447 switches[i].validated = 1;
5449 else if (ordered || *p == '&')
5450 ordered = 1, switches[i].ordering = 1;
5452 give_switch (i, 0, include_blanks);
5454 /* Even if many alternatives are matched, only output once. */
5459 /* Here if a %{|...} conditional fails: output a minus sign,
5460 which means "standard output" or "standard input". */
5461 do_spec_1 ("-", 0, NULL);
5466 /* We didn't match; try again. */
5473 goto next_ampersand;
5479 /* Doing this set of switches later preserves their command-line
5480 ordering. This is needed for e.g. -U, -D and -A. */
5481 for (i = 0; i < n_switches; i++)
5482 if (switches[i].ordering == 1)
5484 switches[i].ordering = 0;
5485 give_switch (i, 0, include_blanks);
5488 /* Process the spec just once, regardless of match count. */
5491 if (do_spec_1 (save_string (body, endbody - body - 1),
5499 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5500 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5501 spec, or -1 if either exact match or %* is used.
5503 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5504 whose value does not begin with "no-" is obsoleted by the same value
5505 with the "no-", similarly for a switch with the "no-" prefix. */
5508 check_live_switch (switchnum, prefix_length)
5512 const char *name = switches[switchnum].part1;
5515 /* In the common case of {<at-most-one-letter>*}, a negating
5516 switch would always match, so ignore that case. We will just
5517 send the conflicting switches to the compiler phase. */
5518 if (prefix_length >= 0 && prefix_length <= 1)
5521 /* If we already processed this switch and determined if it was
5522 live or not, return our past determination. */
5523 if (switches[switchnum].live_cond != 0)
5524 return switches[switchnum].live_cond > 0;
5526 /* Now search for duplicate in a manner that depends on the name. */
5530 for (i = switchnum + 1; i < n_switches; i++)
5531 if (switches[i].part1[0] == 'O')
5533 switches[switchnum].validated = 1;
5534 switches[switchnum].live_cond = SWITCH_FALSE;
5539 case 'W': case 'f': case 'm':
5540 if (! strncmp (name + 1, "no-", 3))
5542 /* We have Xno-YYY, search for XYYY. */
5543 for (i = switchnum + 1; i < n_switches; i++)
5544 if (switches[i].part1[0] == name[0]
5545 && ! strcmp (&switches[i].part1[1], &name[4]))
5547 switches[switchnum].validated = 1;
5548 switches[switchnum].live_cond = SWITCH_FALSE;
5554 /* We have XYYY, search for Xno-YYY. */
5555 for (i = switchnum + 1; i < n_switches; i++)
5556 if (switches[i].part1[0] == name[0]
5557 && switches[i].part1[1] == 'n'
5558 && switches[i].part1[2] == 'o'
5559 && switches[i].part1[3] == '-'
5560 && !strcmp (&switches[i].part1[4], &name[1]))
5562 switches[switchnum].validated = 1;
5563 switches[switchnum].live_cond = SWITCH_FALSE;
5570 /* Otherwise the switch is live. */
5571 switches[switchnum].live_cond = SWITCH_LIVE;
5575 /* Pass a switch to the current accumulating command
5576 in the same form that we received it.
5577 SWITCHNUM identifies the switch; it is an index into
5578 the vector of switches gcc received, which is `switches'.
5579 This cannot fail since it never finishes a command line.
5581 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
5583 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
5587 give_switch (switchnum, omit_first_word, include_blanks)
5589 int omit_first_word;
5592 if (switches[switchnum].live_cond == SWITCH_IGNORE)
5595 if (!omit_first_word)
5597 do_spec_1 ("-", 0, NULL);
5598 do_spec_1 (switches[switchnum].part1, 1, NULL);
5601 if (switches[switchnum].args != 0)
5604 for (p = switches[switchnum].args; *p; p++)
5606 const char *arg = *p;
5609 do_spec_1 (" ", 0, NULL);
5612 unsigned length = strlen (arg);
5615 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5616 if (arg[length] == '.')
5618 ((char *)arg)[length] = 0;
5622 do_spec_1 (arg, 1, NULL);
5624 ((char *)arg)[length] = '.';
5625 do_spec_1 (suffix_subst, 1, NULL);
5628 do_spec_1 (arg, 1, NULL);
5632 do_spec_1 (" ", 0, NULL);
5633 switches[switchnum].validated = 1;
5636 /* Search for a file named NAME trying various prefixes including the
5637 user's -B prefix and some standard ones.
5638 Return the absolute file name found. If nothing is found, return NAME. */
5646 /* Try multilib_dir if it is defined. */
5647 if (multilib_dir != NULL)
5649 const char *const try = ACONCAT ((multilib_dir, dir_separator_str, name, NULL));
5651 newname = find_a_file (&startfile_prefixes, try, R_OK);
5653 /* If we don't find it in the multi library dir, then fall
5654 through and look for it in the normal places. */
5655 if (newname != NULL)
5659 newname = find_a_file (&startfile_prefixes, name, R_OK);
5660 return newname ? newname : name;
5663 /* Determine whether a directory exists. If LINKER, return 0 for
5664 certain fixed names not needed by the linker. If not LINKER, it is
5665 only important to return 0 if the host machine has a small ARG_MAX
5669 is_directory (path1, path2, linker)
5674 int len1 = strlen (path1);
5675 int len2 = strlen (path2);
5676 char *path = (char *) alloca (3 + len1 + len2);
5680 #ifndef SMALL_ARG_MAX
5685 /* Construct the path from the two parts. Ensure the string ends with "/.".
5686 The resulting path will be a directory even if the given path is a
5688 memcpy (path, path1, len1);
5689 memcpy (path + len1, path2, len2);
5690 cp = path + len1 + len2;
5691 if (!IS_DIR_SEPARATOR (cp[-1]))
5692 *cp++ = DIR_SEPARATOR;
5696 /* Exclude directories that the linker is known to search. */
5699 && strcmp (path, concat (dir_separator_str, "lib",
5700 dir_separator_str, ".", NULL)) == 0)
5702 && strcmp (path, concat (dir_separator_str, "usr",
5703 dir_separator_str, "lib",
5704 dir_separator_str, ".", NULL)) == 0)))
5707 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5710 /* Set up the various global variables to indicate that we're processing
5711 the input file named FILENAME. */
5714 set_input (filename)
5715 const char *filename;
5719 input_filename = filename;
5720 input_filename_length = strlen (input_filename);
5722 input_basename = input_filename;
5723 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5724 /* Skip drive name so 'x:foo' is handled properly. */
5725 if (input_basename[1] == ':')
5726 input_basename += 2;
5728 for (p = input_basename; *p; p++)
5729 if (IS_DIR_SEPARATOR (*p))
5730 input_basename = p + 1;
5732 /* Find a suffix starting with the last period,
5733 and set basename_length to exclude that suffix. */
5734 basename_length = strlen (input_basename);
5735 suffixed_basename_length = basename_length;
5736 p = input_basename + basename_length;
5737 while (p != input_basename && *p != '.')
5739 if (*p == '.' && p != input_basename)
5741 basename_length = p - input_basename;
5742 input_suffix = p + 1;
5747 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5748 we will need to do a stat on the input_filename. The
5749 INPUT_STAT_SET signals that the stat is needed. */
5753 /* On fatal signals, delete all the temporary files. */
5756 fatal_error (signum)
5759 signal (signum, SIG_DFL);
5760 delete_failure_queue ();
5761 delete_temp_files ();
5762 /* Get the same signal again, this time not handled,
5763 so its normal effect occurs. */
5764 kill (getpid (), signum);
5767 extern int main PARAMS ((int, const char *const *));
5772 const char *const *argv;
5776 int linker_was_run = 0;
5777 char *explicit_link_files;
5780 struct user_specs *uptr;
5782 p = argv[0] + strlen (argv[0]);
5783 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
5787 xmalloc_set_program_name (programname);
5789 #ifdef GCC_DRIVER_HOST_INITIALIZATION
5790 /* Perform host dependent initialization when needed. */
5791 GCC_DRIVER_HOST_INITIALIZATION;
5794 gcc_init_libintl ();
5796 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
5797 signal (SIGINT, fatal_error);
5799 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
5800 signal (SIGHUP, fatal_error);
5802 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
5803 signal (SIGTERM, fatal_error);
5805 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
5806 signal (SIGPIPE, fatal_error);
5809 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
5810 receive the signal. A different setting is inheritable */
5811 signal (SIGCHLD, SIG_DFL);
5815 argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
5817 obstack_init (&obstack);
5819 /* Build multilib_select, et. al from the separate lines that make up each
5820 multilib selection. */
5822 const char *const *q = multilib_raw;
5825 obstack_init (&multilib_obstack);
5826 while ((p = *q++) != (char *) 0)
5827 obstack_grow (&multilib_obstack, p, strlen (p));
5829 obstack_1grow (&multilib_obstack, 0);
5830 multilib_select = obstack_finish (&multilib_obstack);
5832 q = multilib_matches_raw;
5833 while ((p = *q++) != (char *) 0)
5834 obstack_grow (&multilib_obstack, p, strlen (p));
5836 obstack_1grow (&multilib_obstack, 0);
5837 multilib_matches = obstack_finish (&multilib_obstack);
5839 q = multilib_exclusions_raw;
5840 while ((p = *q++) != (char *) 0)
5841 obstack_grow (&multilib_obstack, p, strlen (p));
5843 obstack_1grow (&multilib_obstack, 0);
5844 multilib_exclusions = obstack_finish (&multilib_obstack);
5847 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
5850 obstack_1grow (&multilib_obstack, ' ');
5851 obstack_grow (&multilib_obstack,
5852 multilib_defaults_raw[i],
5853 strlen (multilib_defaults_raw[i]));
5857 obstack_1grow (&multilib_obstack, 0);
5858 multilib_defaults = obstack_finish (&multilib_obstack);
5861 /* Set up to remember the pathname of gcc and any options
5862 needed for collect. We use argv[0] instead of programname because
5863 we need the complete pathname. */
5864 obstack_init (&collect_obstack);
5865 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
5866 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
5867 putenv (obstack_finish (&collect_obstack));
5869 #ifdef INIT_ENVIRONMENT
5870 /* Set up any other necessary machine specific environment variables. */
5871 putenv (INIT_ENVIRONMENT);
5874 /* Make a table of what switches there are (switches, n_switches).
5875 Make a table of specified input files (infiles, n_infiles).
5876 Decode switches that are handled locally. */
5878 process_command (argc, argv);
5880 /* Initialize the vector of specs to just the default.
5881 This means one element containing 0s, as a terminator. */
5883 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
5884 memcpy ((char *) compilers, (char *) default_compilers,
5885 sizeof default_compilers);
5886 n_compilers = n_default_compilers;
5888 /* Read specs from a file if there is one. */
5890 machine_suffix = concat (spec_machine, dir_separator_str,
5891 spec_version, dir_separator_str, NULL);
5892 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
5894 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
5895 /* Read the specs file unless it is a default one. */
5896 if (specs_file != 0 && strcmp (specs_file, "specs"))
5897 read_specs (specs_file, TRUE);
5901 /* We need to check standard_exec_prefix/just_machine_suffix/specs
5902 for any override of as, ld and libraries. */
5903 specs_file = (char *) alloca (strlen (standard_exec_prefix)
5904 + strlen (just_machine_suffix)
5905 + sizeof ("specs"));
5907 strcpy (specs_file, standard_exec_prefix);
5908 strcat (specs_file, just_machine_suffix);
5909 strcat (specs_file, "specs");
5910 if (access (specs_file, R_OK) == 0)
5911 read_specs (specs_file, TRUE);
5913 /* If not cross-compiling, look for startfiles in the standard places.
5914 Similarly, don't add the standard prefixes if startfile handling
5915 will be under control of startfile_prefix_spec. */
5916 if (*cross_compile == '0' && *startfile_prefix_spec == 0)
5918 if (*md_exec_prefix)
5920 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
5921 PREFIX_PRIORITY_LAST, 0, NULL);
5922 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
5923 PREFIX_PRIORITY_LAST, 0, NULL);
5926 if (*md_startfile_prefix)
5927 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
5928 PREFIX_PRIORITY_LAST, 0, NULL);
5930 if (*md_startfile_prefix_1)
5931 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
5932 PREFIX_PRIORITY_LAST, 0, NULL);
5934 /* If standard_startfile_prefix is relative, base it on
5935 standard_exec_prefix. This lets us move the installed tree
5936 as a unit. If GCC_EXEC_PREFIX is defined, base
5937 standard_startfile_prefix on that as well. */
5938 if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix))
5939 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
5940 PREFIX_PRIORITY_LAST, 0, NULL);
5943 if (gcc_exec_prefix)
5944 add_prefix (&startfile_prefixes,
5945 concat (gcc_exec_prefix, machine_suffix,
5946 standard_startfile_prefix, NULL),
5947 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
5948 add_prefix (&startfile_prefixes,
5949 concat (standard_exec_prefix,
5951 standard_startfile_prefix, NULL),
5952 NULL, PREFIX_PRIORITY_LAST, 0, NULL);
5955 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
5956 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5957 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
5958 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5959 #if 0 /* Can cause surprises, and one can use -B./ instead. */
5960 add_prefix (&startfile_prefixes, "./", NULL,
5961 PREFIX_PRIORITY_LAST, 1, NULL);
5966 if (!IS_ABSOLUTE_PATHNAME (standard_startfile_prefix)
5968 add_prefix (&startfile_prefixes,
5969 concat (gcc_exec_prefix, machine_suffix,
5970 standard_startfile_prefix, NULL),
5971 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
5974 if (*startfile_prefix_spec != 0
5975 && do_spec_2 (startfile_prefix_spec) == 0
5976 && do_spec_1 (" ", 0, NULL) == 0)
5979 for (ndx = 0; ndx < argbuf_index; ndx++)
5980 add_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
5981 PREFIX_PRIORITY_LAST, 0, NULL);
5984 /* Process any user specified specs in the order given on the command
5986 for (uptr = user_specs_head; uptr; uptr = uptr->next)
5988 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
5989 read_specs (filename ? filename : uptr->filename, FALSE);
5992 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
5993 if (gcc_exec_prefix)
5994 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
5995 spec_version, dir_separator_str, NULL);
5997 /* Now we have the specs.
5998 Set the `valid' bits for switches that match anything in any spec. */
6000 validate_all_switches ();
6002 /* Now that we have the switches and the specs, set
6003 the subdirectory based on the options. */
6004 set_multilib_dir ();
6006 /* Warn about any switches that no pass was interested in. */
6008 for (i = 0; (int) i < n_switches; i++)
6009 if (! switches[i].validated)
6010 error ("unrecognized option `-%s'", switches[i].part1);
6012 /* Obey some of the options. */
6014 if (print_search_dirs)
6016 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6017 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6018 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6022 if (print_file_name)
6024 printf ("%s\n", find_file (print_file_name));
6028 if (print_prog_name)
6030 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
6031 printf ("%s\n", (newname ? newname : print_prog_name));
6035 if (print_multi_lib)
6037 print_multilib_info ();
6041 if (print_multi_directory)
6043 if (multilib_dir == NULL)
6046 printf ("%s\n", multilib_dir);
6050 if (target_help_flag)
6052 /* Print if any target specific options. */
6054 /* We do not exit here. Instead we have created a fake input file
6055 called 'target-dummy' which needs to be compiled, and we pass this
6056 on to the various sub-processes, along with the --target-help
6060 if (print_help_list)
6066 printf (_("\nFor bug reporting instructions, please see:\n"));
6067 printf ("%s.\n", GCCBUGURL);
6072 /* We do not exit here. Instead we have created a fake input file
6073 called 'help-dummy' which needs to be compiled, and we pass this
6074 on the various sub-processes, along with the --help switch. */
6082 notice ("Configured with: %s\n", configuration_arguments);
6084 #ifdef THREAD_MODEL_SPEC
6085 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6086 but there's no point in doing all this processing just to get
6087 thread_model back. */
6088 obstack_init (&obstack);
6089 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6090 obstack_1grow (&obstack, '\0');
6091 thrmod = obstack_finish (&obstack);
6093 thrmod = thread_model;
6096 notice ("Thread model: %s\n", thrmod);
6098 /* compiler_version is truncated at the first space when initialized
6099 from version string, so truncate version_string at the first space
6100 before comparing. */
6101 for (n = 0; version_string[n]; n++)
6102 if (version_string[n] == ' ')
6105 if (! strncmp (version_string, compiler_version, n)
6106 && compiler_version[n] == 0)
6107 notice ("gcc version %s\n", version_string);
6109 notice ("gcc driver version %s executing gcc version %s\n",
6110 version_string, compiler_version);
6116 if (n_infiles == added_libraries)
6117 fatal ("no input files");
6119 /* Make a place to record the compiler output file names
6120 that correspond to the input files. */
6123 i += lang_specific_extra_outfiles;
6124 outfiles = (const char **) xcalloc (i, sizeof (char *));
6126 /* Record which files were specified explicitly as link input. */
6128 explicit_link_files = xcalloc (1, n_infiles);
6130 for (i = 0; (int) i < n_infiles; i++)
6132 int this_file_error = 0;
6134 /* Tell do_spec what to substitute for %i. */
6136 input_file_number = i;
6137 set_input (infiles[i].name);
6139 /* Use the same thing in %o, unless cp->spec says otherwise. */
6141 outfiles[i] = input_filename;
6143 /* Figure out which compiler from the file's suffix. */
6146 = lookup_compiler (infiles[i].name, input_filename_length,
6147 infiles[i].language);
6149 if (input_file_compiler)
6151 /* Ok, we found an applicable compiler. Run its spec. */
6153 if (input_file_compiler->spec[0] == '#')
6155 error ("%s: %s compiler not installed on this system",
6156 input_filename, &input_file_compiler->spec[1]);
6157 this_file_error = 1;
6161 value = do_spec (input_file_compiler->spec);
6163 this_file_error = 1;
6167 /* If this file's name does not contain a recognized suffix,
6168 record it as explicit linker input. */
6171 explicit_link_files[i] = 1;
6173 /* Clear the delete-on-failure queue, deleting the files in it
6174 if this compilation failed. */
6176 if (this_file_error)
6178 delete_failure_queue ();
6181 /* If this compilation succeeded, don't delete those files later. */
6182 clear_failure_queue ();
6185 /* Reset the output file name to the first input file name, for use
6186 with %b in LINK_SPEC on a target that prefers not to emit a.out
6189 set_input (infiles[0].name);
6191 if (error_count == 0)
6193 /* Make sure INPUT_FILE_NUMBER points to first available open
6195 input_file_number = n_infiles;
6196 if (lang_specific_pre_link ())
6200 /* Run ld to link all the compiler output files. */
6202 if (error_count == 0)
6204 int tmp = execution_count;
6206 /* We'll use ld if we can't find collect2. */
6207 if (! strcmp (linker_name_spec, "collect2"))
6209 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
6211 linker_name_spec = "ld";
6213 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6215 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6216 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6218 value = do_spec (link_command_spec);
6221 linker_was_run = (tmp != execution_count);
6224 /* If options said don't run linker,
6225 complain about input files to be given to the linker. */
6227 if (! linker_was_run && error_count == 0)
6228 for (i = 0; (int) i < n_infiles; i++)
6229 if (explicit_link_files[i])
6230 error ("%s: linker input file unused because linking not done",
6233 /* Delete some or all of the temporary files we made. */
6236 delete_failure_queue ();
6237 delete_temp_files ();
6239 if (print_help_list)
6241 printf (("\nFor bug reporting instructions, please see:\n"));
6242 printf ("%s\n", GCCBUGURL);
6245 return (signal_count != 0 ? 2
6246 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6250 /* Find the proper compilation spec for the file name NAME,
6251 whose length is LENGTH. LANGUAGE is the specified language,
6252 or 0 if this file is to be passed to the linker. */
6254 static struct compiler *
6255 lookup_compiler (name, length, language)
6258 const char *language;
6260 struct compiler *cp;
6262 /* If this was specified by the user to be a linker input, indicate that. */
6263 if (language != 0 && language[0] == '*')
6266 /* Otherwise, look for the language, if one is spec'd. */
6269 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6270 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6273 error ("language %s not recognized", language);
6277 /* Look for a suffix. */
6278 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6280 if (/* The suffix `-' matches only the file name `-'. */
6281 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6282 || (strlen (cp->suffix) < length
6283 /* See if the suffix matches the end of NAME. */
6284 && !strcmp (cp->suffix,
6285 name + length - strlen (cp->suffix))
6290 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6291 /* look again, but case-insensitively this time. */
6293 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6295 if (/* The suffix `-' matches only the file name `-'. */
6296 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6297 || (strlen (cp->suffix) < length
6298 /* See if the suffix matches the end of NAME. */
6299 && ((!strcmp (cp->suffix,
6300 name + length - strlen (cp->suffix))
6301 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6302 && !strcasecmp (cp->suffix,
6303 name + length - strlen (cp->suffix)))
6309 if (cp >= compilers)
6311 if (cp->spec[0] != '@')
6312 /* A non-alias entry: return it. */
6315 /* An alias entry maps a suffix to a language.
6316 Search for the language; pass 0 for NAME and LENGTH
6317 to avoid infinite recursion if language not found. */
6318 return lookup_compiler (NULL, 0, cp->spec + 1);
6324 save_string (s, len)
6328 char *result = xmalloc (len + 1);
6330 memcpy (result, s, len);
6336 pfatal_with_name (name)
6339 perror_with_name (name);
6340 delete_temp_files ();
6345 perror_with_name (name)
6348 error ("%s: %s", name, xstrerror (errno));
6352 pfatal_pexecute (errmsg_fmt, errmsg_arg)
6353 const char *errmsg_fmt;
6354 const char *errmsg_arg;
6358 int save_errno = errno;
6360 /* Space for trailing '\0' is in %s. */
6361 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
6362 sprintf (msg, errmsg_fmt, errmsg_arg);
6368 pfatal_with_name (errmsg_fmt);
6371 /* Output an error message and exit */
6376 fatal ("internal gcc abort");
6379 /* Output an error message and exit */
6382 fatal VPARAMS ((const char *msgid, ...))
6384 VA_OPEN (ap, msgid);
6385 VA_FIXEDARG (ap, const char *, msgid);
6387 fprintf (stderr, "%s: ", programname);
6388 vfprintf (stderr, _(msgid), ap);
6390 fprintf (stderr, "\n");
6391 delete_temp_files ();
6396 error VPARAMS ((const char *msgid, ...))
6398 VA_OPEN (ap, msgid);
6399 VA_FIXEDARG (ap, const char *, msgid);
6401 fprintf (stderr, "%s: ", programname);
6402 vfprintf (stderr, _(msgid), ap);
6405 fprintf (stderr, "\n");
6409 notice VPARAMS ((const char *msgid, ...))
6411 VA_OPEN (ap, msgid);
6412 VA_FIXEDARG (ap, const char *, msgid);
6414 vfprintf (stderr, _(msgid), ap);
6419 validate_all_switches ()
6421 struct compiler *comp;
6424 struct spec_list *spec;
6426 for (comp = compilers; comp->spec; comp++)
6430 if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
6431 /* We have a switch spec. */
6432 validate_switches (p + 1);
6435 /* Look through the linked list of specs read from the specs file. */
6436 for (spec = specs; spec; spec = spec->next)
6438 p = *(spec->ptr_spec);
6440 if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
6441 /* We have a switch spec. */
6442 validate_switches (p + 1);
6445 p = link_command_spec;
6447 if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
6448 /* We have a switch spec. */
6449 validate_switches (p + 1);
6452 /* Look at the switch-name that comes after START
6453 and mark as valid all supplied switches that match it. */
6456 validate_switches (start)
6459 const char *p = start;
6476 while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
6481 else if (p[-1] == '*')
6483 /* Mark all matching switches as valid. */
6484 for (i = 0; i < n_switches; i++)
6485 if (!strncmp (switches[i].part1, filter, p - filter - 1))
6486 switches[i].validated = 1;
6490 /* Mark an exact matching switch as valid. */
6491 for (i = 0; i < n_switches; i++)
6493 if (!strncmp (switches[i].part1, filter, p - filter)
6494 && switches[i].part1[p - filter] == 0)
6495 switches[i].validated = 1;
6499 if (*p++ == '|' || p[-1] == '&')
6503 /* Check whether a particular argument was used. The first time we
6504 canonicalize the switches to keep only the ones we care about. */
6514 const char *replace;
6519 static struct mswitchstr *mswitches;
6520 static int n_mswitches;
6525 struct mswitchstr *matches;
6529 /* Break multilib_matches into the component strings of string
6530 and replacement string. */
6531 for (q = multilib_matches; *q != '\0'; q++)
6536 (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
6538 q = multilib_matches;
6548 matches[i].len = q - matches[i].str;
6550 matches[i].replace = ++q;
6551 while (*q != ';' && *q != '\0')
6557 matches[i].rep_len = q - matches[i].replace;
6563 /* Now build a list of the replacement string for switches that we care
6564 about. Make sure we allocate at least one entry. This prevents
6565 xmalloc from calling fatal, and prevents us from re-executing this
6568 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
6569 * (n_switches ? n_switches : 1));
6570 for (i = 0; i < n_switches; i++)
6572 int xlen = strlen (switches[i].part1);
6573 for (j = 0; j < cnt; j++)
6574 if (xlen == matches[j].len
6575 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6577 mswitches[n_mswitches].str = matches[j].replace;
6578 mswitches[n_mswitches].len = matches[j].rep_len;
6579 mswitches[n_mswitches].replace = (char *) 0;
6580 mswitches[n_mswitches].rep_len = 0;
6587 for (i = 0; i < n_mswitches; i++)
6588 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6595 default_arg (p, len)
6599 const char *start, *end;
6601 for (start = multilib_defaults; *start != '\0'; start = end + 1)
6603 while (*start == ' ' || *start == '\t')
6609 for (end = start + 1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
6612 if ((end - start) == len && strncmp (p, start, len) == 0)
6622 /* Work out the subdirectory to use based on the options. The format of
6623 multilib_select is a list of elements. Each element is a subdirectory
6624 name followed by a list of options followed by a semicolon. The format
6625 of multilib_exclusions is the same, but without the preceding
6626 directory. First gcc will check the exclusions, if none of the options
6627 beginning with an exclamation point are present, and all of the other
6628 options are present, then we will ignore this completely. Passing
6629 that, gcc will consider each multilib_select in turn using the same
6630 rules for matching the options. If a match is found, that subdirectory
6637 unsigned int this_path_len;
6638 const char *this_path, *this_arg;
6642 p = multilib_exclusions;
6645 /* Ignore newlines. */
6652 /* Check the arguments. */
6666 while (*p != ' ' && *p != ';')
6673 if (*this_arg != '!')
6681 ok = used_arg (this_arg, p - this_arg);
6695 p = multilib_select;
6698 /* Ignore newlines. */
6705 /* Get the initial path. */
6713 this_path_len = p - this_path;
6715 /* Check the arguments. */
6730 while (*p != ' ' && *p != ';')
6737 if (*this_arg != '!')
6745 /* If this is a default argument, we can just ignore it.
6746 This is true even if this_arg begins with '!'. Beginning
6747 with '!' does not mean that this argument is necessarily
6748 inappropriate for this library: it merely means that
6749 there is a more specific library which uses this
6750 argument. If this argument is a default, we need not
6751 consider that more specific library. */
6752 if (! default_arg (this_arg, p - this_arg))
6754 ok = used_arg (this_arg, p - this_arg);
6765 if (this_path_len != 1
6766 || this_path[0] != '.')
6768 char *new_multilib_dir = xmalloc (this_path_len + 1);
6769 strncpy (new_multilib_dir, this_path, this_path_len);
6770 new_multilib_dir[this_path_len] = '\0';
6771 multilib_dir = new_multilib_dir;
6780 /* Print out the multiple library subdirectory selection
6781 information. This prints out a series of lines. Each line looks
6782 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
6783 required. Only the desired options are printed out, the negative
6784 matches. The options are print without a leading dash. There are
6785 no spaces to make it easy to use the information in the shell.
6786 Each subdirectory is printed only once. This assumes the ordering
6787 generated by the genmultilib script. Also, we leave out ones that match
6791 print_multilib_info ()
6793 const char *p = multilib_select;
6794 const char *last_path = 0, *this_path;
6796 unsigned int last_path_len = 0;
6801 /* Ignore newlines. */
6808 /* Get the initial path. */
6817 /* Check for matches with the multilib_exclusions. We don't bother
6818 with the '!' in either list. If any of the exclusion rules match
6819 all of its options with the select rule, we skip it. */
6821 const char *e = multilib_exclusions;
6822 const char *this_arg;
6827 /* Ignore newlines. */
6834 /* Check the arguments. */
6851 while (*e != ' ' && *e != ';')
6862 int len = e - this_arg;
6869 while (*q != ' ' && *q != ';')
6876 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
6877 default_arg (this_arg, e - this_arg))
6907 /* If this is a duplicate, skip it. */
6908 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len
6909 && ! strncmp (last_path, this_path, last_path_len));
6911 last_path = this_path;
6912 last_path_len = p - this_path;
6915 /* If this directory requires any default arguments, we can skip
6916 it. We will already have printed a directory identical to
6917 this one which does not require that default argument. */
6935 while (*q != ' ' && *q != ';')
6943 && default_arg (arg, q - arg))
6958 for (p1 = last_path; p1 < p; p1++)
6977 use_arg = *p != '!';
6982 while (*p != ' ' && *p != ';')
6997 /* If there are extra options, print them now. */
6998 if (multilib_extra && *multilib_extra)
7000 int print_at = TRUE;
7003 for (q = multilib_extra; *q != '\0'; q++)