1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 This paragraph is here to try to keep Sun CC from dying.
23 The number of chars here seems crucial!!!! */
25 /* This program is the user interface to the C compiler and possibly to
26 other compilers. It is used because compilation is a complicated procedure
27 which involves running several programs and passing temporary files between
28 them, forwarding the users switches to those programs selectively,
29 and deleting the temporary files at the end.
31 CC recognizes how to compile each input file by suffixes in the file names.
32 Once it knows which kind of compilation to perform, the procedure for
33 compilation is specified by a string called a "spec". */
35 /* A Short Introduction to Adding a Command-Line Option.
37 Before adding a command-line option, consider if it is really
38 necessary. Each additional command-line option adds complexity and
39 is difficult to remove in subsequent versions.
41 In the following, consider adding the command-line argument
44 1. Each command-line option is specified in the specs file. The
45 notation is described below in the comment entitled "The Specs
48 2. In this file, add an entry to "option_map" equating the long
49 `--' argument version and any shorter, single letter version. Read
50 the comments in the declaration of "struct option_map" for an
51 explanation. Do not omit the first `-'.
53 3. Look in the "specs" file to determine which program or option
54 list should be given the argument, e.g., "cc1_options". Add the
55 appropriate syntax for the shorter option version to the
56 corresponding "const char *" entry in this file. Omit the first
57 `-' from the option. For example, use `-bar', rather than `--bar'.
59 4. If the argument takes an argument, e.g., `--baz argument1',
60 modify either DEFAULT_SWITCH_TAKES_ARG or
61 DEFAULT_WORD_SWITCH_TAKES_ARG in this file. Omit the first `-'
64 5. Document the option in this file's display_help(). If the
65 option is passed to a subprogram, modify its corresponding
66 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
69 6. Compile and test. Make sure that your new specs file is being
70 read. For example, use a debugger to investigate the value of
71 "specs_file" in main(). */
75 #include "coretypes.h"
78 #if ! defined( SIGCHLD ) && defined( SIGCLD )
79 # define SIGCHLD SIGCLD
87 #ifdef HAVE_SYS_RESOURCE_H
88 #include <sys/resource.h>
90 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
91 extern int getrusage PARAMS ((int, struct rusage *));
94 /* By default there is no special suffix for target executables. */
95 /* FIXME: when autoconf is fixed, remove the host check - dj */
96 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
97 #define HAVE_TARGET_EXECUTABLE_SUFFIX
100 /* By default there is no special suffix for host executables. */
101 #ifdef HOST_EXECUTABLE_SUFFIX
102 #define HAVE_HOST_EXECUTABLE_SUFFIX
104 #define HOST_EXECUTABLE_SUFFIX ""
107 /* By default, the suffix for target object files is ".o". */
108 #ifdef TARGET_OBJECT_SUFFIX
109 #define HAVE_TARGET_OBJECT_SUFFIX
111 #define TARGET_OBJECT_SUFFIX ".o"
115 /* FIXME: the location independence code for VMS is hairier than this,
116 and hasn't been written. */
122 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
124 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
125 #ifndef LIBRARY_PATH_ENV
126 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
130 #define kill(p,s) raise(s)
133 /* If a stage of compilation returns an exit status >= 1,
134 compilation of that file ceases. */
136 #define MIN_FATAL_STATUS 1
138 /* Flag set by cppspec.c to 1. */
141 /* Flag saying to pass the greatest exit code returned by a sub-process
142 to the calling program. */
143 static int pass_exit_codes;
145 /* Definition of string containing the arguments given to configure. */
146 #include "configargs.h"
148 /* Flag saying to print the directories gcc will search through looking for
149 programs, libraries, etc. */
151 static int print_search_dirs;
153 /* Flag saying to print the full filename of this file
154 as found through our usual search mechanism. */
156 static const char *print_file_name = NULL;
158 /* As print_file_name, but search for executable file. */
160 static const char *print_prog_name = NULL;
162 /* Flag saying to print the relative path we'd use to
163 find libgcc.a given the current compiler flags. */
165 static int print_multi_directory;
167 /* Flag saying to print the relative path we'd use to
168 find OS libraries given the current compiler flags. */
170 static int print_multi_os_directory;
172 /* Flag saying to print the list of subdirectories and
173 compiler flags used to select them in a standard form. */
175 static int print_multi_lib;
177 /* Flag saying to print the command line options understood by gcc and its
180 static int print_help_list;
182 /* Flag indicating whether we should print the command and arguments */
184 static int verbose_flag;
186 /* Flag indicating whether we should ONLY print the command and
187 arguments (like verbose_flag) without executing the command.
188 Displayed arguments are quoted so that the generated command
189 line is suitable for execution. This is intended for use in
190 shell scripts to capture the driver-generated command line. */
191 static int verbose_only_flag;
193 /* Flag indicating to print target specific command line options. */
195 static int target_help_flag;
197 /* Flag indicating whether we should report subprocess execution times
198 (if this is supported by the system - see pexecute.c). */
200 static int report_times;
202 /* Nonzero means place this string before uses of /, so that include
203 and library files can be found in an alternate location. */
205 #ifdef TARGET_SYSTEM_ROOT
206 static const char *target_system_root = TARGET_SYSTEM_ROOT;
208 static const char *target_system_root = 0;
211 /* Nonzero means pass the updated target_system_root to the compiler. */
213 static int target_system_root_changed;
215 /* Nonzero means append this string to target_system_root. */
217 static const char *target_sysroot_suffix = 0;
219 /* Nonzero means append this string to target_system_root for headers. */
221 static const char *target_sysroot_hdrs_suffix = 0;
223 /* Nonzero means write "temp" files in source directory
224 and use the source file's name in them, and don't delete them. */
226 static int save_temps_flag;
228 /* Nonzero means use pipes to communicate between subprocesses.
229 Overridden by either of the above two flags. */
231 static int use_pipes;
233 /* The compiler version. */
235 static const char *compiler_version;
237 /* The target version specified with -V */
239 static const char *const spec_version = DEFAULT_TARGET_VERSION;
241 /* The target machine specified with -b. */
243 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
245 /* Nonzero if cross-compiling.
246 When -b is used, the value comes from the `specs' file. */
249 static const char *cross_compile = "1";
251 static const char *cross_compile = "0";
254 #ifdef MODIFY_TARGET_NAME
256 /* Information on how to alter the target name based on a command-line
257 switch. The only case we support now is simply appending or deleting a
258 string to or from the end of the first part of the configuration name. */
260 static const struct modify_target
262 const char *const sw;
263 const enum add_del {ADD, DELETE} add_del;
264 const char *const str;
266 modify_target[] = MODIFY_TARGET_NAME;
269 /* The number of errors that have occurred; the link phase will not be
270 run if this is nonzero. */
271 static int error_count = 0;
273 /* Greatest exit code of sub-processes that has been encountered up to
275 static int greatest_status = 1;
277 /* This is the obstack which we use to allocate many strings. */
279 static struct obstack obstack;
281 /* This is the obstack to build an environment variable to pass to
282 collect2 that describes all of the relevant switches of what to
283 pass the compiler in building the list of pointers to constructors
286 static struct obstack collect_obstack;
288 /* These structs are used to collect resource usage information for
290 #ifdef HAVE_GETRUSAGE
291 static struct rusage rus, prus;
294 /* Forward declaration for prototypes. */
297 static void init_spec PARAMS ((void));
298 static void store_arg PARAMS ((const char *, int, int));
299 static char *load_specs PARAMS ((const char *));
300 static void read_specs PARAMS ((const char *, int));
301 static void set_spec PARAMS ((const char *, const char *));
302 static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
303 static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
304 static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
305 static int access_check PARAMS ((const char *, int));
306 static char *find_a_file PARAMS ((struct path_prefix *, const char *,
308 static void add_prefix PARAMS ((struct path_prefix *, const char *,
309 const char *, int, int, int *, int));
310 static void add_sysrooted_prefix PARAMS ((struct path_prefix *, const char *,
311 const char *, int, int, int *, int));
312 static void translate_options PARAMS ((int *, const char *const **));
313 static char *skip_whitespace PARAMS ((char *));
314 static void delete_if_ordinary PARAMS ((const char *));
315 static void delete_temp_files PARAMS ((void));
316 static void delete_failure_queue PARAMS ((void));
317 static void clear_failure_queue PARAMS ((void));
318 static int check_live_switch PARAMS ((int, int));
319 static const char *handle_braces PARAMS ((const char *));
320 static inline bool input_suffix_matches PARAMS ((const char *,
322 static inline bool switch_matches PARAMS ((const char *,
324 static inline void mark_matching_switches PARAMS ((const char *,
326 static inline void process_marked_switches PARAMS ((void));
327 static const char *process_brace_body PARAMS ((const char *, const char *,
328 const char *, int, int));
329 static const struct spec_function *lookup_spec_function PARAMS ((const char *));
330 static const char *eval_spec_function PARAMS ((const char *, const char *));
331 static const char *handle_spec_function PARAMS ((const char *));
332 static char *save_string PARAMS ((const char *, int));
333 static void set_collect_gcc_options PARAMS ((void));
334 static int do_spec_1 PARAMS ((const char *, int, const char *));
335 static int do_spec_2 PARAMS ((const char *));
336 static void do_option_spec PARAMS ((const char *, const char *));
337 static void do_self_spec PARAMS ((const char *));
338 static const char *find_file PARAMS ((const char *));
339 static int is_directory PARAMS ((const char *, const char *, int));
340 static const char *validate_switches PARAMS ((const char *));
341 static void validate_all_switches PARAMS ((void));
342 static inline void validate_switches_from_spec PARAMS ((const char *));
343 static void give_switch PARAMS ((int, int));
344 static int used_arg PARAMS ((const char *, int));
345 static int default_arg PARAMS ((const char *, int));
346 static void set_multilib_dir PARAMS ((void));
347 static void print_multilib_info PARAMS ((void));
348 static void perror_with_name PARAMS ((const char *));
349 static void pfatal_pexecute PARAMS ((const char *, const char *))
351 static void notice PARAMS ((const char *, ...))
353 static void display_help PARAMS ((void));
354 static void add_preprocessor_option PARAMS ((const char *, int));
355 static void add_assembler_option PARAMS ((const char *, int));
356 static void add_linker_option PARAMS ((const char *, int));
357 static void process_command PARAMS ((int, const char *const *));
358 static int execute PARAMS ((void));
359 static void alloc_args PARAMS ((void));
360 static void clear_args PARAMS ((void));
361 static void fatal_error PARAMS ((int));
362 #ifdef ENABLE_SHARED_LIBGCC
363 static void init_gcc_specs PARAMS ((struct obstack *,
364 const char *, const char *,
367 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
368 static const char *convert_filename PARAMS ((const char *, int, int));
371 static const char *if_exists_spec_function PARAMS ((int, const char **));
372 static const char *if_exists_else_spec_function PARAMS ((int, const char **));
374 /* The Specs Language
376 Specs are strings containing lines, each of which (if not blank)
377 is made up of a program name, and arguments separated by spaces.
378 The program name must be exact and start from root, since no path
379 is searched and it is unreliable to depend on the current working directory.
380 Redirection of input or output is not supported; the subprograms must
381 accept filenames saying what files to read and write.
383 In addition, the specs can contain %-sequences to substitute variable text
384 or for conditional text. Here is a table of all defined %-sequences.
385 Note that spaces are not generated automatically around the results of
386 expanding these sequences; therefore, you can concatenate them together
387 or with constant text in a single argument.
389 %% substitute one % into the program name or argument.
390 %i substitute the name of the input file being processed.
391 %b substitute the basename of the input file being processed.
392 This is the substring up to (and not including) the last period
393 and not including the directory.
394 %B same as %b, but include the file suffix (text after the last period).
396 substitute a file name that has suffix SUFFIX and is chosen
397 once per compilation, and mark the argument a la %d. To reduce
398 exposure to denial-of-service attacks, the file name is now
399 chosen in a way that is hard to predict even when previously
400 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
401 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
402 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
403 had been pre-processed. Previously, %g was simply substituted
404 with a file name chosen once per compilation, without regard
405 to any appended suffix (which was therefore treated just like
406 ordinary text), making such attacks more likely to succeed.
408 like %g, but if -pipe is in effect, expands simply to "-".
410 like %g, but if -pipe is in effect, expands to nothing. (We have both
411 %| and %m to accommodate differences between system assemblers; see
412 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
414 like %g, but generates a new temporary file name even if %uSUFFIX
417 substitutes the last file name generated with %uSUFFIX, generating a
418 new one if there is no such last file name. In the absence of any
419 %uSUFFIX, this is just like %gSUFFIX, except they don't share
420 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
421 would involve the generation of two distinct file names, one
422 for each `%g.s' and another for each `%U.s'. Previously, %U was
423 simply substituted with a file name chosen for the previous %u,
424 without regard to any appended suffix.
426 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
427 writable, and if save-temps is off; otherwise, substitute the name
428 of a temporary file, just like %u. This temporary file is not
429 meant for communication between processes, but rather as a junk
432 substitutes .SUFFIX for the suffixes of a matched switch's args when
433 it is subsequently output with %*. SUFFIX is terminated by the next
435 %d marks the argument containing or following the %d as a
436 temporary file name, so that that file will be deleted if CC exits
437 successfully. Unlike %g, this contributes no text to the argument.
438 %w marks the argument containing or following the %w as the
439 "output file" of this compilation. This puts the argument
440 into the sequence of arguments that %o will substitute later.
441 %V indicates that this compilation produces no "output file".
443 like %{...} but mark last argument supplied within
444 as a file to be deleted on failure.
445 %o substitutes the names of all the output files, with spaces
446 automatically placed around them. You should write spaces
447 around the %o as well or the results are undefined.
448 %o is for use in the specs for running the linker.
449 Input files whose names have no recognized suffix are not compiled
450 at all, but they are included among the output files, so they will
452 %O substitutes the suffix for object files. Note that this is
453 handled specially when it immediately follows %g, %u, or %U
454 (with or without a suffix argument) because of the need for
455 those to form complete file names. The handling is such that
456 %O is treated exactly as if it had already been substituted,
457 except that %g, %u, and %U do not currently support additional
458 SUFFIX characters following %O as they would following, for
460 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
461 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
462 and -B options) as necessary.
463 %s current argument is the name of a library or startup file of some sort.
464 Search for that file in a standard list of directories
465 and substitute the full name found.
466 %eSTR Print STR as an error message. STR is terminated by a newline.
467 Use this when inconsistent options are detected.
468 %nSTR Print STR as a notice. STR is terminated by a newline.
469 %x{OPTION} Accumulate an option for %X.
470 %X Output the accumulated linker options specified by compilations.
471 %Y Output the accumulated assembler options specified by compilations.
472 %Z Output the accumulated preprocessor options specified by compilations.
473 %a process ASM_SPEC as a spec.
474 This allows config.h to specify part of the spec for running as.
475 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
476 used here. This can be used to run a post-processor after the
477 assembler has done its job.
478 %D Dump out a -L option for each directory in startfile_prefixes.
479 If multilib_dir is set, extra entries are generated with it affixed.
480 %l process LINK_SPEC as a spec.
481 %L process LIB_SPEC as a spec.
482 %G process LIBGCC_SPEC as a spec.
483 %M output multilib_dir with directory separators replaced with "_";
484 if multilib_dir is not set or is ".", output "".
485 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
486 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
487 %C process CPP_SPEC as a spec.
488 %1 process CC1_SPEC as a spec.
489 %2 process CC1PLUS_SPEC as a spec.
490 %* substitute the variable part of a matched option. (See below.)
491 Note that each comma in the substituted string is replaced by
493 %<S remove all occurrences of -S from the command line.
494 Note - this command is position dependent. % commands in the
495 spec string before this one will see -S, % commands in the
496 spec string after this one will not.
497 %<S* remove all occurrences of all switches beginning with -S from the
500 Call the named function FUNCTION, passing it ARGS. ARGS is
501 first processed as a nested spec string, then split into an
502 argument vector in the usual fashion. The function returns
503 a string which is processed as if it had appeared literally
504 as part of the current spec.
505 %{S} substitutes the -S switch, if that switch was given to CC.
506 If that switch was not specified, this substitutes nothing.
507 Here S is a metasyntactic variable.
508 %{S*} substitutes all the switches specified to CC whose names start
509 with -S. This is used for -o, -I, etc; switches that take
510 arguments. CC considers `-o foo' as being one switch whose
511 name starts with `o'. %{o*} would substitute this text,
512 including the space; thus, two arguments would be generated.
513 %{S*&T*} likewise, but preserve order of S and T options (the order
514 of S and T in the spec is not significant). Can be any number
515 of ampersand-separated variables; for each the wild card is
516 optional. Useful for CPP as %{D*&U*&A*}.
518 %{S:X} substitutes X, if the -S switch was given to CC.
519 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
520 %{S*:X} substitutes X if one or more switches whose names start
521 with -S was given to CC. Normally X is substituted only
522 once, no matter how many such switches appeared. However,
523 if %* appears somewhere in X, then X will be substituted
524 once for each matching switch, with the %* replaced by the
525 part of that switch that matched the '*'.
526 %{.S:X} substitutes X, if processing a file with suffix S.
527 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
529 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
530 combined with !, ., and * as above binding stronger than the OR.
531 If %* appears in X, all of the alternatives must be starred, and
532 only the first matching alternative is substituted.
533 %{S:X; if S was given to CC, substitutes X;
534 T:Y; else if T was given to CC, substitutes Y;
535 :D} else substitutes D. There can be as many clauses as you need.
536 This may be combined with ., !, |, and * as above.
538 %(Spec) processes a specification defined in a specs file as *Spec:
539 %[Spec] as above, but put __ around -D arguments
541 The conditional text X in a %{S:X} or similar construct may contain
542 other nested % constructs or spaces, or even newlines. They are
543 processed as usual, as described above. Trailing white space in X is
544 ignored. White space may also appear anywhere on the left side of the
545 colon in these constructs, except between . or * and the corresponding
548 The -O, -f, -m, and -W switches are handled specifically in these
549 constructs. If another value of -O or the negated form of a -f, -m, or
550 -W switch is found later in the command line, the earlier switch
551 value is ignored, except with {S*} where S is just one letter; this
552 passes all matching options.
554 The character | at the beginning of the predicate text is used to indicate
555 that a command should be piped to the following command, but only if -pipe
558 Note that it is built into CC which switches take arguments and which
559 do not. You might think it would be useful to generalize this to
560 allow each compiler's spec to say which switches take arguments. But
561 this cannot be done in a consistent fashion. CC cannot even decide
562 which input files have been specified without knowing which switches
563 take arguments, and it must know which input files to compile in order
564 to tell which compilers to run.
566 CC also knows implicitly that arguments starting in `-l' are to be
567 treated as compiler output files, and passed to the linker in their
568 proper position among the other output files. */
570 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
572 /* config.h can define ASM_SPEC to provide extra args to the assembler
573 or extra switch-translations. */
578 /* config.h can define ASM_FINAL_SPEC to run a post processor after
579 the assembler has run. */
580 #ifndef ASM_FINAL_SPEC
581 #define ASM_FINAL_SPEC ""
584 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
585 or extra switch-translations. */
590 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
591 or extra switch-translations. */
596 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
597 or extra switch-translations. */
599 #define CC1PLUS_SPEC ""
602 /* config.h can define LINK_SPEC to provide extra args to the linker
603 or extra switch-translations. */
608 /* config.h can define LIB_SPEC to override the default libraries. */
610 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
613 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
616 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
617 /* Have gcc do the search for libgcc.a. */
618 #define LIBGCC_SPEC "libgcc.a%s"
620 #define LIBGCC_SPEC "-lgcc"
624 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
625 #ifndef STARTFILE_SPEC
626 #define STARTFILE_SPEC \
627 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
630 /* config.h can define SWITCHES_NEED_SPACES to control which options
631 require spaces between the option and the argument. */
632 #ifndef SWITCHES_NEED_SPACES
633 #define SWITCHES_NEED_SPACES ""
636 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
638 #define ENDFILE_SPEC ""
642 #define LINKER_NAME "collect2"
645 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
647 #ifndef ASM_DEBUG_SPEC
648 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
649 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
650 # define ASM_DEBUG_SPEC \
651 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
652 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
653 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
655 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
656 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
658 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
659 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
663 #ifndef ASM_DEBUG_SPEC
664 # define ASM_DEBUG_SPEC ""
667 /* Here is the spec for running the linker, after compiling all files. */
669 /* This is overridable by the target in case they need to specify the
670 -lgcc and -lc order specially, yet not require them to override all
671 of LINK_COMMAND_SPEC. */
672 #ifndef LINK_GCC_C_SEQUENCE_SPEC
673 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
676 #ifndef LINK_PIE_SPEC
678 #define LINK_PIE_SPEC "%{pie:-pie} "
680 #define LINK_PIE_SPEC "%{pie:} "
684 /* -u* was put back because both BSD and SysV seem to support it. */
685 /* %{static:} simply prevents an error message if the target machine
686 doesn't handle -static. */
687 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
688 scripts which exist in user specified directories, or in standard
690 #ifndef LINK_COMMAND_SPEC
691 #define LINK_COMMAND_SPEC "\
692 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
693 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
694 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
695 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs:-lgcov}\
696 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
697 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
700 #ifndef LINK_LIBGCC_SPEC
701 # ifdef LINK_LIBGCC_SPECIAL
702 /* Don't generate -L options for startfile prefix list. */
703 # define LINK_LIBGCC_SPEC ""
705 /* Do generate them. */
706 # define LINK_LIBGCC_SPEC "%D"
710 #ifndef STARTFILE_PREFIX_SPEC
711 # define STARTFILE_PREFIX_SPEC ""
714 #ifndef SYSROOT_SUFFIX_SPEC
715 # define SYSROOT_SUFFIX_SPEC ""
718 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
719 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
722 static const char *asm_debug;
723 static const char *cpp_spec = CPP_SPEC;
724 static const char *cc1_spec = CC1_SPEC;
725 static const char *cc1plus_spec = CC1PLUS_SPEC;
726 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
727 static const char *asm_spec = ASM_SPEC;
728 static const char *asm_final_spec = ASM_FINAL_SPEC;
729 static const char *link_spec = LINK_SPEC;
730 static const char *lib_spec = LIB_SPEC;
731 static const char *libgcc_spec = LIBGCC_SPEC;
732 static const char *endfile_spec = ENDFILE_SPEC;
733 static const char *startfile_spec = STARTFILE_SPEC;
734 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
735 static const char *linker_name_spec = LINKER_NAME;
736 static const char *link_command_spec = LINK_COMMAND_SPEC;
737 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
738 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
739 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
740 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
742 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
743 There should be no need to override these in target dependent files,
744 but we need to copy them to the specs file so that newer versions
745 of the GCC driver can correctly drive older tool chains with the
746 appropriate -B options. */
748 /* When cpplib handles traditional preprocessing, get rid of this, and
749 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
750 that we default the front end language better. */
751 static const char *trad_capable_cpp =
752 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
754 /* We don't wrap .d files in %W{} since a missing .d file, and
755 therefore no dependency entry, confuses make into thinking a .o
756 file that happens to exist is up-to-date. */
757 static const char *cpp_unique_options =
758 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
759 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
760 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
761 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
762 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
763 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
764 %{trigraphs} %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
767 /* This contains cpp options which are common with cc1_options and are passed
768 only when preprocessing only to avoid duplication. We pass the cc1 spec
769 options to the preprocessor so that it the cc1 spec may manipulate
770 options used to set target flags. Those special target flags settings may
771 in turn cause preprocessor symbols to be defined specially. */
772 static const char *cpp_options =
773 "%(cpp_unique_options) %1 %{m*} %{std*} %{ansi} %{W*&pedantic*} %{w} %{f*}\
776 /* This contains cpp options which are not passed when the preprocessor
777 output will be used by another program. */
778 static const char *cpp_debug_options = "%{d*}";
780 /* NB: This is shared amongst all front-ends. */
781 static const char *cc1_options =
782 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
783 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
784 -auxbase%{c|S:%{o*:-strip %*}%{!o*: %b}}%{!c:%{!S: %b}}\
785 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
786 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
787 %{Qn:-fno-ident} %{--help:--help}\
788 %{--target-help:--target-help}\
789 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
790 %{fsyntax-only:-o %j} %{-param*}";
792 static const char *asm_options =
793 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
795 static const char *invoke_as =
796 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
797 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
799 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
802 /* Some compilers have limits on line lengths, and the multilib_select
803 and/or multilib_matches strings can be very long, so we build them at
805 static struct obstack multilib_obstack;
806 static const char *multilib_select;
807 static const char *multilib_matches;
808 static const char *multilib_defaults;
809 static const char *multilib_exclusions;
810 #include "multilib.h"
812 /* Check whether a particular argument is a default argument. */
814 #ifndef MULTILIB_DEFAULTS
815 #define MULTILIB_DEFAULTS { "" }
818 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
820 #ifndef DRIVER_SELF_SPECS
821 #define DRIVER_SELF_SPECS ""
824 static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
826 #ifndef OPTION_DEFAULT_SPECS
827 #define OPTION_DEFAULT_SPECS { "", "" }
836 static const struct default_spec
837 option_default_specs[] = { OPTION_DEFAULT_SPECS };
841 struct user_specs *next;
842 const char *filename;
845 static struct user_specs *user_specs_head, *user_specs_tail;
847 #ifndef SWITCH_TAKES_ARG
848 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
851 #ifndef WORD_SWITCH_TAKES_ARG
852 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
855 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
856 /* This defines which switches stop a full compilation. */
857 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
858 ((CHAR) == 'c' || (CHAR) == 'S')
860 #ifndef SWITCH_CURTAILS_COMPILATION
861 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
862 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
866 /* Record the mapping from file suffixes for compilation specs. */
870 const char *suffix; /* Use this compiler for input files
871 whose names end in this suffix. */
873 const char *spec; /* To use this compiler, run this spec. */
875 const char *cpp_spec; /* If non-NULL, substitute this spec
876 for `%C', rather than the usual
880 /* Pointer to a vector of `struct compiler' that gives the spec for
881 compiling a file, based on its suffix.
882 A file that does not end in any of these suffixes will be passed
883 unchanged to the loader and nothing else will be done to it.
885 An entry containing two 0s is used to terminate the vector.
887 If multiple entries match a file, the last matching one is used. */
889 static struct compiler *compilers;
891 /* Number of entries in `compilers', not counting the null terminator. */
893 static int n_compilers;
895 /* The default list of file name suffixes and their compilation specs. */
897 static const struct compiler default_compilers[] =
899 /* Add lists of suffixes of known languages here. If those languages
900 were not present when we built the driver, we will hit these copies
901 and be given a more meaningful error than "file not used since
902 linking is not done". */
903 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
904 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
905 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
906 {".CPP", "#C++", 0}, {".ii", "#C++", 0},
907 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
908 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
909 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
910 {".r", "#Ratfor", 0},
911 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
912 {".java", "#Java", 0}, {".class", "#Java", 0},
913 {".zip", "#Java", 0}, {".jar", "#Java", 0},
914 /* Next come the entries for C. */
917 /* cc1 has an integrated ISO C preprocessor. We should invoke the
918 external preprocessor if -save-temps is given. */
919 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
921 %{traditional|ftraditional:\
922 %eGNU C no longer supports -traditional without -E}\
923 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
924 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
925 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
927 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
928 cc1 %(cpp_unique_options) %(cc1_options)}}}\
929 %{!fsyntax-only:%(invoke_as)}}}}", 0},
931 "%{!E:%e-E required when input is from standard input}\
932 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0},
933 {".h", "@c-header", 0},
935 /* cc1 has an integrated ISO C preprocessor. We should invoke the
936 external preprocessor if -save-temps is given. */
937 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
939 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
940 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
941 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
943 -o %g.s %{!o*:--output-pch=%i.gch}\
944 %W{o*:--output-pch=%*}%V}\
945 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
946 cc1 %(cpp_unique_options) %(cc1_options)\
947 -o %g.s %{!o*:--output-pch=%i.gch}\
948 %W{o*:--output-pch=%*}%V}}}}}}", 0},
949 {".i", "@cpp-output", 0},
951 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
952 {".s", "@assembler", 0},
954 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
955 {".S", "@assembler-with-cpp", 0},
956 {"@assembler-with-cpp",
957 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
958 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
959 %{E|M|MM:%(cpp_debug_options)}\
960 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
961 as %(asm_debug) %(asm_options) %|.s %A }}}}"
963 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
964 %{E|M|MM:%(cpp_debug_options)}\
965 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
966 as %(asm_debug) %(asm_options) %m.s %A }}}}"
971 /* Mark end of table */
975 /* Number of elements in default_compilers, not counting the terminator. */
977 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
979 /* A vector of options to give to the linker.
980 These options are accumulated by %x,
981 and substituted into the linker command with %X. */
982 static int n_linker_options;
983 static char **linker_options;
985 /* A vector of options to give to the assembler.
986 These options are accumulated by -Wa,
987 and substituted into the assembler command with %Y. */
988 static int n_assembler_options;
989 static char **assembler_options;
991 /* A vector of options to give to the preprocessor.
992 These options are accumulated by -Wp,
993 and substituted into the preprocessor command with %Z. */
994 static int n_preprocessor_options;
995 static char **preprocessor_options;
997 /* Define how to map long options into short ones. */
999 /* This structure describes one mapping. */
1002 /* The long option's name. */
1003 const char *const name;
1004 /* The equivalent short option. */
1005 const char *const equivalent;
1006 /* Argument info. A string of flag chars; NULL equals no options.
1007 a => argument required.
1008 o => argument optional.
1009 j => join argument to equivalent, making one word.
1010 * => require other text after NAME as an argument. */
1011 const char *const arg_info;
1014 /* This is the table of mappings. Mappings are tried sequentially
1015 for each option encountered; the first one that matches, wins. */
1017 static const struct option_map option_map[] =
1019 {"--all-warnings", "-Wall", 0},
1020 {"--ansi", "-ansi", 0},
1021 {"--assemble", "-S", 0},
1022 {"--assert", "-A", "a"},
1023 {"--classpath", "-fclasspath=", "aj"},
1024 {"--bootclasspath", "-fbootclasspath=", "aj"},
1025 {"--CLASSPATH", "-fclasspath=", "aj"},
1026 {"--comments", "-C", 0},
1027 {"--comments-in-macros", "-CC", 0},
1028 {"--compile", "-c", 0},
1029 {"--debug", "-g", "oj"},
1030 {"--define-macro", "-D", "aj"},
1031 {"--dependencies", "-M", 0},
1032 {"--dump", "-d", "a"},
1033 {"--dumpbase", "-dumpbase", "a"},
1034 {"--entry", "-e", 0},
1035 {"--extra-warnings", "-W", 0},
1036 {"--for-assembler", "-Wa", "a"},
1037 {"--for-linker", "-Xlinker", "a"},
1038 {"--force-link", "-u", "a"},
1039 {"--imacros", "-imacros", "a"},
1040 {"--include", "-include", "a"},
1041 {"--include-barrier", "-I-", 0},
1042 {"--include-directory", "-I", "aj"},
1043 {"--include-directory-after", "-idirafter", "a"},
1044 {"--include-prefix", "-iprefix", "a"},
1045 {"--include-with-prefix", "-iwithprefix", "a"},
1046 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1047 {"--include-with-prefix-after", "-iwithprefix", "a"},
1048 {"--language", "-x", "a"},
1049 {"--library-directory", "-L", "a"},
1050 {"--machine", "-m", "aj"},
1051 {"--machine-", "-m", "*j"},
1052 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1053 {"--no-line-commands", "-P", 0},
1054 {"--no-precompiled-includes", "-noprecomp", 0},
1055 {"--no-standard-includes", "-nostdinc", 0},
1056 {"--no-standard-libraries", "-nostdlib", 0},
1057 {"--no-warnings", "-w", 0},
1058 {"--optimize", "-O", "oj"},
1059 {"--output", "-o", "a"},
1060 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1061 {"--param", "--param", "a"},
1062 {"--pedantic", "-pedantic", 0},
1063 {"--pedantic-errors", "-pedantic-errors", 0},
1064 {"--pie", "-pie", 0},
1065 {"--pipe", "-pipe", 0},
1066 {"--prefix", "-B", "a"},
1067 {"--preprocess", "-E", 0},
1068 {"--print-search-dirs", "-print-search-dirs", 0},
1069 {"--print-file-name", "-print-file-name=", "aj"},
1070 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1071 {"--print-missing-file-dependencies", "-MG", 0},
1072 {"--print-multi-lib", "-print-multi-lib", 0},
1073 {"--print-multi-directory", "-print-multi-directory", 0},
1074 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1075 {"--print-prog-name", "-print-prog-name=", "aj"},
1076 {"--profile", "-p", 0},
1077 {"--profile-blocks", "-a", 0},
1078 {"--quiet", "-q", 0},
1079 {"--resource", "-fcompile-resource=", "aj"},
1080 {"--save-temps", "-save-temps", 0},
1081 {"--shared", "-shared", 0},
1082 {"--silent", "-q", 0},
1083 {"--specs", "-specs=", "aj"},
1084 {"--static", "-static", 0},
1085 {"--std", "-std=", "aj"},
1086 {"--symbolic", "-symbolic", 0},
1087 {"--target", "-b", "a"},
1088 {"--time", "-time", 0},
1089 {"--trace-includes", "-H", 0},
1090 {"--traditional", "-traditional", 0},
1091 {"--traditional-cpp", "-traditional-cpp", 0},
1092 {"--trigraphs", "-trigraphs", 0},
1093 {"--undefine-macro", "-U", "aj"},
1094 {"--use-version", "-V", "a"},
1095 {"--user-dependencies", "-MM", 0},
1096 {"--verbose", "-v", 0},
1097 {"--warn-", "-W", "*j"},
1098 {"--write-dependencies", "-MD", 0},
1099 {"--write-user-dependencies", "-MMD", 0},
1104 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1105 static const struct {
1106 const char *const option_found;
1107 const char *const replacements;
1108 } target_option_translations[] =
1110 TARGET_OPTION_TRANSLATE_TABLE,
1115 /* Translate the options described by *ARGCP and *ARGVP.
1116 Make a new vector and store it back in *ARGVP,
1117 and store its length in *ARGVC. */
1120 translate_options (argcp, argvp)
1122 const char *const **argvp;
1126 const char *const *argv = *argvp;
1127 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1129 (const char **) xmalloc (newvsize);
1133 newv[newindex++] = argv[i++];
1137 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1141 target_option_translations[tott_idx].option_found;
1144 if (strcmp (target_option_translations[tott_idx].option_found,
1151 for (sp = target_option_translations[tott_idx].replacements;
1158 newvsize += spaces * sizeof (const char *);
1159 newv = (const char **) xrealloc (newv, newvsize);
1161 sp = target_option_translations[tott_idx].replacements;
1170 newv[newindex++] = np;
1171 while (*np != ' ' && *np)
1182 if (target_option_translations[tott_idx].option_found)
1186 /* Translate -- options. */
1187 if (argv[i][0] == '-' && argv[i][1] == '-')
1190 /* Find a mapping that applies to this option. */
1191 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1193 size_t optlen = strlen (option_map[j].name);
1194 size_t arglen = strlen (argv[i]);
1195 size_t complen = arglen > optlen ? optlen : arglen;
1196 const char *arginfo = option_map[j].arg_info;
1201 if (!strncmp (argv[i], option_map[j].name, complen))
1203 const char *arg = 0;
1205 if (arglen < optlen)
1208 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1209 if (strlen (option_map[k].name) >= arglen
1210 && !strncmp (argv[i], option_map[k].name, arglen))
1212 error ("ambiguous abbreviation %s", argv[i]);
1216 if (k != ARRAY_SIZE (option_map))
1220 if (arglen > optlen)
1222 /* If the option has an argument, accept that. */
1223 if (argv[i][optlen] == '=')
1224 arg = argv[i] + optlen + 1;
1226 /* If this mapping requires extra text at end of name,
1227 accept that as "argument". */
1228 else if (strchr (arginfo, '*') != 0)
1229 arg = argv[i] + optlen;
1231 /* Otherwise, extra text at end means mismatch.
1232 Try other mappings. */
1237 else if (strchr (arginfo, '*') != 0)
1239 error ("incomplete `%s' option", option_map[j].name);
1243 /* Handle arguments. */
1244 if (strchr (arginfo, 'a') != 0)
1250 error ("missing argument to `%s' option",
1251 option_map[j].name);
1258 else if (strchr (arginfo, '*') != 0)
1260 else if (strchr (arginfo, 'o') == 0)
1263 error ("extraneous argument to `%s' option",
1264 option_map[j].name);
1268 /* Store the translation as one argv elt or as two. */
1269 if (arg != 0 && strchr (arginfo, 'j') != 0)
1270 newv[newindex++] = concat (option_map[j].equivalent, arg,
1274 newv[newindex++] = option_map[j].equivalent;
1275 newv[newindex++] = arg;
1278 newv[newindex++] = option_map[j].equivalent;
1286 /* Handle old-fashioned options--just copy them through,
1287 with their arguments. */
1288 else if (argv[i][0] == '-')
1290 const char *p = argv[i] + 1;
1294 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1295 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1296 else if (WORD_SWITCH_TAKES_ARG (p))
1297 nskip += WORD_SWITCH_TAKES_ARG (p);
1298 else if ((c == 'B' || c == 'b' || c == 'x')
1301 else if (! strcmp (p, "Xlinker"))
1303 else if (! strcmp (p, "Xpreprocessor"))
1305 else if (! strcmp (p, "Xassembler"))
1308 /* Watch out for an option at the end of the command line that
1309 is missing arguments, and avoid skipping past the end of the
1311 if (nskip + i > argc)
1316 newv[newindex++] = argv[i++];
1321 /* Ordinary operands, or +e options. */
1322 newv[newindex++] = argv[i++];
1337 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1338 be considered whitespace. */
1339 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1341 else if (*p == '\n' || *p == ' ' || *p == '\t')
1355 /* Structures to keep track of prefixes to try when looking for files. */
1359 const char *prefix; /* String to prepend to the path. */
1360 struct prefix_list *next; /* Next in linked list. */
1361 int require_machine_suffix; /* Don't use without machine_suffix. */
1362 /* 2 means try both machine_suffix and just_machine_suffix. */
1363 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1364 int priority; /* Sort key - priority within list. */
1365 int os_multilib; /* 1 if OS multilib scheme should be used,
1366 0 for GCC multilib scheme. */
1371 struct prefix_list *plist; /* List of prefixes to try */
1372 int max_len; /* Max length of a prefix in PLIST */
1373 const char *name; /* Name of this list (used in config stuff) */
1376 /* List of prefixes to try when looking for executables. */
1378 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1380 /* List of prefixes to try when looking for startup (crt0) files. */
1382 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1384 /* List of prefixes to try when looking for include files. */
1386 static struct path_prefix include_prefixes = { 0, 0, "include" };
1388 /* Suffix to attach to directories searched for commands.
1389 This looks like `MACHINE/VERSION/'. */
1391 static const char *machine_suffix = 0;
1393 /* Suffix to attach to directories searched for commands.
1394 This is just `MACHINE/'. */
1396 static const char *just_machine_suffix = 0;
1398 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1400 static const char *gcc_exec_prefix;
1402 /* Default prefixes to attach to command names. */
1404 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1405 #undef MD_EXEC_PREFIX
1406 #undef MD_STARTFILE_PREFIX
1407 #undef MD_STARTFILE_PREFIX_1
1410 /* If no prefixes defined, use the null string, which will disable them. */
1411 #ifndef MD_EXEC_PREFIX
1412 #define MD_EXEC_PREFIX ""
1414 #ifndef MD_STARTFILE_PREFIX
1415 #define MD_STARTFILE_PREFIX ""
1417 #ifndef MD_STARTFILE_PREFIX_1
1418 #define MD_STARTFILE_PREFIX_1 ""
1421 /* Supply defaults for the standard prefixes. */
1423 #ifndef STANDARD_EXEC_PREFIX
1424 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1426 #ifndef STANDARD_STARTFILE_PREFIX
1427 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1429 #ifndef TOOLDIR_BASE_PREFIX
1430 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1432 #ifndef STANDARD_BINDIR_PREFIX
1433 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1436 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1437 static const char *const standard_exec_prefix_1 = "/usr/lib/gcc/";
1438 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1440 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1441 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1442 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1443 static const char *const standard_startfile_prefix_1 = "/lib/";
1444 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1446 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1447 static const char *tooldir_prefix;
1449 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1451 /* Subdirectory to use for locating libraries. Set by
1452 set_multilib_dir based on the compilation options. */
1454 static const char *multilib_dir;
1456 /* Subdirectory to use for locating libraries in OS conventions. Set by
1457 set_multilib_dir based on the compilation options. */
1459 static const char *multilib_os_dir;
1461 /* Structure to keep track of the specs that have been defined so far.
1462 These are accessed using %(specname) or %[specname] in a compiler
1467 /* The following 2 fields must be first */
1468 /* to allow EXTRA_SPECS to be initialized */
1469 const char *name; /* name of the spec. */
1470 const char *ptr; /* available ptr if no static pointer */
1472 /* The following fields are not initialized */
1473 /* by EXTRA_SPECS */
1474 const char **ptr_spec; /* pointer to the spec itself. */
1475 struct spec_list *next; /* Next spec in linked list. */
1476 int name_len; /* length of the name */
1477 int alloc_p; /* whether string was allocated */
1480 #define INIT_STATIC_SPEC(NAME,PTR) \
1481 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1483 /* List of statically defined specs. */
1484 static struct spec_list static_specs[] =
1486 INIT_STATIC_SPEC ("asm", &asm_spec),
1487 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1488 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1489 INIT_STATIC_SPEC ("asm_options", &asm_options),
1490 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1491 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1492 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1493 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1494 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1495 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1496 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1497 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1498 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1499 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1500 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1501 INIT_STATIC_SPEC ("link", &link_spec),
1502 INIT_STATIC_SPEC ("lib", &lib_spec),
1503 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1504 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1505 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1506 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1507 INIT_STATIC_SPEC ("version", &compiler_version),
1508 INIT_STATIC_SPEC ("multilib", &multilib_select),
1509 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1510 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1511 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1512 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1513 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1514 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1515 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1516 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1517 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1518 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1519 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1520 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1521 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1524 #ifdef EXTRA_SPECS /* additional specs needed */
1525 /* Structure to keep track of just the first two args of a spec_list.
1526 That is all that the EXTRA_SPECS macro gives us. */
1529 const char *const name;
1530 const char *const ptr;
1533 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1534 static struct spec_list *extra_specs = (struct spec_list *) 0;
1537 /* List of dynamically allocates specs that have been defined so far. */
1539 static struct spec_list *specs = (struct spec_list *) 0;
1541 /* List of static spec functions. */
1543 static const struct spec_function static_spec_functions[] =
1545 { "if-exists", if_exists_spec_function },
1546 { "if-exists-else", if_exists_else_spec_function },
1550 static int processing_spec_function;
1552 /* Add appropriate libgcc specs to OBSTACK, taking into account
1553 various permutations of -shared-libgcc, -shared, and such. */
1555 #ifdef ENABLE_SHARED_LIBGCC
1557 init_gcc_specs (obstack, shared_name, static_name, eh_name)
1558 struct obstack *obstack;
1559 const char *shared_name;
1560 const char *static_name;
1561 const char *eh_name;
1565 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1566 "}%{!static:%{!static-libgcc:",
1567 "%{!shared:%{!shared-libgcc:", static_name, " ",
1568 eh_name, "}%{shared-libgcc:", shared_name, " ",
1569 static_name, "}}%{shared:",
1571 "%{shared-libgcc:", shared_name,
1572 "}%{!shared-libgcc:", static_name, "}",
1578 obstack_grow (obstack, buf, strlen (buf));
1581 #endif /* ENABLE_SHARED_LIBGCC */
1583 /* Initialize the specs lookup routines. */
1588 struct spec_list *next = (struct spec_list *) 0;
1589 struct spec_list *sl = (struct spec_list *) 0;
1593 return; /* Already initialized. */
1596 notice ("Using built-in specs.\n");
1599 extra_specs = (struct spec_list *)
1600 xcalloc (sizeof (struct spec_list), ARRAY_SIZE (extra_specs_1));
1602 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1604 sl = &extra_specs[i];
1605 sl->name = extra_specs_1[i].name;
1606 sl->ptr = extra_specs_1[i].ptr;
1608 sl->name_len = strlen (sl->name);
1609 sl->ptr_spec = &sl->ptr;
1614 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1615 on ?: in file-scope variable initializations. */
1616 asm_debug = ASM_DEBUG_SPEC;
1618 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1620 sl = &static_specs[i];
1625 #ifdef ENABLE_SHARED_LIBGCC
1626 /* ??? If neither -shared-libgcc nor --static-libgcc was
1627 seen, then we should be making an educated guess. Some proposed
1628 heuristics for ELF include:
1630 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1631 program will be doing dynamic loading, which will likely
1632 need the shared libgcc.
1634 (2) If "-ldl", then it's also a fair bet that we're doing
1637 (3) For each ET_DYN we're linking against (either through -lfoo
1638 or /some/path/foo.so), check to see whether it or one of
1639 its dependencies depends on a shared libgcc.
1643 If the runtime is fixed to look for program headers instead
1644 of calling __register_frame_info at all, for each object,
1645 use the shared libgcc if any EH symbol referenced.
1647 If crtstuff is fixed to not invoke __register_frame_info
1648 automatically, for each object, use the shared libgcc if
1649 any non-empty unwind section found.
1651 Doing any of this probably requires invoking an external program to
1652 do the actual object file scanning. */
1654 const char *p = libgcc_spec;
1657 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1658 when given the proper command line arguments. */
1661 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1663 init_gcc_specs (&obstack,
1664 #ifdef NO_SHARED_LIBGCC_MULTILIB
1669 #ifdef USE_LIBUNWIND_EXCEPTIONS
1678 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1680 /* Ug. We don't know shared library extensions. Hope that
1681 systems that use this form don't do shared libraries. */
1682 init_gcc_specs (&obstack,
1683 #ifdef NO_SHARED_LIBGCC_MULTILIB
1696 obstack_1grow (&obstack, *p);
1697 in_sep = (*p == ' ');
1702 obstack_1grow (&obstack, '\0');
1703 libgcc_spec = obstack_finish (&obstack);
1706 #ifdef USE_AS_TRADITIONAL_FORMAT
1707 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1709 static const char tf[] = "--traditional-format ";
1710 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1711 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1712 asm_spec = obstack_finish (&obstack);
1716 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1717 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1718 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1719 link_spec = obstack_finish (&obstack);
1725 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1726 removed; If the spec starts with a + then SPEC is added to the end of the
1730 set_spec (name, spec)
1734 struct spec_list *sl;
1735 const char *old_spec;
1736 int name_len = strlen (name);
1739 /* If this is the first call, initialize the statically allocated specs. */
1742 struct spec_list *next = (struct spec_list *) 0;
1743 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1745 sl = &static_specs[i];
1752 /* See if the spec already exists. */
1753 for (sl = specs; sl; sl = sl->next)
1754 if (name_len == sl->name_len && !strcmp (sl->name, name))
1759 /* Not found - make it. */
1760 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1761 sl->name = xstrdup (name);
1762 sl->name_len = name_len;
1763 sl->ptr_spec = &sl->ptr;
1765 *(sl->ptr_spec) = "";
1770 old_spec = *(sl->ptr_spec);
1771 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1772 ? concat (old_spec, spec + 1, NULL)
1777 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1780 /* Free the old spec. */
1781 if (old_spec && sl->alloc_p)
1782 free ((void *) old_spec);
1787 /* Accumulate a command (program name and args), and run it. */
1789 /* Vector of pointers to arguments in the current line of specifications. */
1791 static const char **argbuf;
1793 /* Number of elements allocated in argbuf. */
1795 static int argbuf_length;
1797 /* Number of elements in argbuf currently in use (containing args). */
1799 static int argbuf_index;
1801 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1802 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1805 static struct temp_name {
1806 const char *suffix; /* suffix associated with the code. */
1807 int length; /* strlen (suffix). */
1808 int unique; /* Indicates whether %g or %u/%U was used. */
1809 const char *filename; /* associated filename. */
1810 int filename_length; /* strlen (filename). */
1811 struct temp_name *next;
1814 /* Number of commands executed so far. */
1816 static int execution_count;
1818 /* Number of commands that exited with a signal. */
1820 static int signal_count;
1822 /* Name with which this program was invoked. */
1824 static const char *programname;
1826 /* Allocate the argument vector. */
1832 argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
1835 /* Clear out the vector of arguments (after a command is executed). */
1843 /* Add one argument to the vector at the end.
1844 This is done when a space is seen or at the end of the line.
1845 If DELETE_ALWAYS is nonzero, the arg is a filename
1846 and the file should be deleted eventually.
1847 If DELETE_FAILURE is nonzero, the arg is a filename
1848 and the file should be deleted if this compilation fails. */
1851 store_arg (arg, delete_always, delete_failure)
1853 int delete_always, delete_failure;
1855 if (argbuf_index + 1 == argbuf_length)
1857 = (const char **) xrealloc (argbuf,
1858 (argbuf_length *= 2) * sizeof (const char *));
1860 argbuf[argbuf_index++] = arg;
1861 argbuf[argbuf_index] = 0;
1863 if (delete_always || delete_failure)
1864 record_temp_file (arg, delete_always, delete_failure);
1867 /* Load specs from a file name named FILENAME, replacing occurrences of
1868 various different types of line-endings, \r\n, \n\r and just \r, with
1872 load_specs (filename)
1873 const char *filename;
1877 struct stat statbuf;
1884 notice ("Reading specs from %s\n", filename);
1886 /* Open and stat the file. */
1887 desc = open (filename, O_RDONLY, 0);
1889 pfatal_with_name (filename);
1890 if (stat (filename, &statbuf) < 0)
1891 pfatal_with_name (filename);
1893 /* Read contents of file into BUFFER. */
1894 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1895 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1897 pfatal_with_name (filename);
1898 buffer[readlen] = 0;
1901 specs = xmalloc (readlen + 1);
1903 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1909 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1911 else if (*(buffer_p + 1) == '\n') /* \r\n */
1925 /* Read compilation specs from a file named FILENAME,
1926 replacing the default ones.
1928 A suffix which starts with `*' is a definition for
1929 one of the machine-specific sub-specs. The "suffix" should be
1930 *asm, *cc1, *cpp, *link, *startfile, etc.
1931 The corresponding spec is stored in asm_spec, etc.,
1932 rather than in the `compilers' vector.
1934 Anything invalid in the file is a fatal error. */
1937 read_specs (filename, main_p)
1938 const char *filename;
1944 buffer = load_specs (filename);
1946 /* Scan BUFFER for specs, putting them in the vector. */
1952 char *in, *out, *p1, *p2, *p3;
1954 /* Advance P in BUFFER to the next nonblank nocomment line. */
1955 p = skip_whitespace (p);
1959 /* Is this a special command that starts with '%'? */
1960 /* Don't allow this for the main specs file, since it would
1961 encourage people to overwrite it. */
1962 if (*p == '%' && !main_p)
1965 while (*p && *p != '\n')
1971 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1972 && (p1[sizeof "%include" - 1] == ' '
1973 || p1[sizeof "%include" - 1] == '\t'))
1977 p1 += sizeof ("%include");
1978 while (*p1 == ' ' || *p1 == '\t')
1981 if (*p1++ != '<' || p[-2] != '>')
1982 fatal ("specs %%include syntax malformed after %ld characters",
1983 (long) (p1 - buffer + 1));
1986 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
1987 read_specs (new_filename ? new_filename : p1, FALSE);
1990 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1991 && (p1[sizeof "%include_noerr" - 1] == ' '
1992 || p1[sizeof "%include_noerr" - 1] == '\t'))
1996 p1 += sizeof "%include_noerr";
1997 while (*p1 == ' ' || *p1 == '\t')
2000 if (*p1++ != '<' || p[-2] != '>')
2001 fatal ("specs %%include syntax malformed after %ld characters",
2002 (long) (p1 - buffer + 1));
2005 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2007 read_specs (new_filename, FALSE);
2008 else if (verbose_flag)
2009 notice ("could not find specs file %s\n", p1);
2012 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2013 && (p1[sizeof "%rename" - 1] == ' '
2014 || p1[sizeof "%rename" - 1] == '\t'))
2017 struct spec_list *sl;
2018 struct spec_list *newsl;
2020 /* Get original name. */
2021 p1 += sizeof "%rename";
2022 while (*p1 == ' ' || *p1 == '\t')
2025 if (! ISALPHA ((unsigned char) *p1))
2026 fatal ("specs %%rename syntax malformed after %ld characters",
2027 (long) (p1 - buffer));
2030 while (*p2 && !ISSPACE ((unsigned char) *p2))
2033 if (*p2 != ' ' && *p2 != '\t')
2034 fatal ("specs %%rename syntax malformed after %ld characters",
2035 (long) (p2 - buffer));
2039 while (*p2 == ' ' || *p2 == '\t')
2042 if (! ISALPHA ((unsigned char) *p2))
2043 fatal ("specs %%rename syntax malformed after %ld characters",
2044 (long) (p2 - buffer));
2046 /* Get new spec name. */
2048 while (*p3 && !ISSPACE ((unsigned char) *p3))
2052 fatal ("specs %%rename syntax malformed after %ld characters",
2053 (long) (p3 - buffer));
2056 for (sl = specs; sl; sl = sl->next)
2057 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2061 fatal ("specs %s spec was not found to be renamed", p1);
2063 if (strcmp (p1, p2) == 0)
2066 for (newsl = specs; newsl; newsl = newsl->next)
2067 if (strcmp (newsl->name, p2) == 0)
2068 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2073 notice ("rename spec %s to %s\n", p1, p2);
2075 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2079 set_spec (p2, *(sl->ptr_spec));
2081 free ((void *) *(sl->ptr_spec));
2083 *(sl->ptr_spec) = "";
2088 fatal ("specs unknown %% command after %ld characters",
2089 (long) (p1 - buffer));
2092 /* Find the colon that should end the suffix. */
2094 while (*p1 && *p1 != ':' && *p1 != '\n')
2097 /* The colon shouldn't be missing. */
2099 fatal ("specs file malformed after %ld characters",
2100 (long) (p1 - buffer));
2102 /* Skip back over trailing whitespace. */
2104 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2107 /* Copy the suffix to a string. */
2108 suffix = save_string (p, p2 - p);
2109 /* Find the next line. */
2110 p = skip_whitespace (p1 + 1);
2112 fatal ("specs file malformed after %ld characters",
2113 (long) (p - buffer));
2116 /* Find next blank line or end of string. */
2117 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2120 /* Specs end at the blank line and do not include the newline. */
2121 spec = save_string (p, p1 - p);
2124 /* Delete backslash-newline sequences from the spec. */
2129 if (in[0] == '\\' && in[1] == '\n')
2131 else if (in[0] == '#')
2132 while (*in && *in != '\n')
2140 if (suffix[0] == '*')
2142 if (! strcmp (suffix, "*link_command"))
2143 link_command_spec = spec;
2145 set_spec (suffix + 1, spec);
2149 /* Add this pair to the vector. */
2151 = ((struct compiler *)
2152 xrealloc (compilers,
2153 (n_compilers + 2) * sizeof (struct compiler)));
2155 compilers[n_compilers].suffix = suffix;
2156 compilers[n_compilers].spec = spec;
2158 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2162 link_command_spec = spec;
2165 if (link_command_spec == 0)
2166 fatal ("spec file has no spec for linking");
2169 /* Record the names of temporary files we tell compilers to write,
2170 and delete them at the end of the run. */
2172 /* This is the common prefix we use to make temp file names.
2173 It is chosen once for each run of this program.
2174 It is substituted into a spec by %g or %j.
2175 Thus, all temp file names contain this prefix.
2176 In practice, all temp file names start with this prefix.
2178 This prefix comes from the envvar TMPDIR if it is defined;
2179 otherwise, from the P_tmpdir macro if that is defined;
2180 otherwise, in /usr/tmp or /tmp;
2181 or finally the current directory if all else fails. */
2183 static const char *temp_filename;
2185 /* Length of the prefix. */
2187 static int temp_filename_length;
2189 /* Define the list of temporary files to delete. */
2194 struct temp_file *next;
2197 /* Queue of files to delete on success or failure of compilation. */
2198 static struct temp_file *always_delete_queue;
2199 /* Queue of files to delete on failure of compilation. */
2200 static struct temp_file *failure_delete_queue;
2202 /* Record FILENAME as a file to be deleted automatically.
2203 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2204 otherwise delete it in any case.
2205 FAIL_DELETE nonzero means delete it if a compilation step fails;
2206 otherwise delete it in any case. */
2209 record_temp_file (filename, always_delete, fail_delete)
2210 const char *filename;
2214 char *const name = xstrdup (filename);
2218 struct temp_file *temp;
2219 for (temp = always_delete_queue; temp; temp = temp->next)
2220 if (! strcmp (name, temp->name))
2223 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2224 temp->next = always_delete_queue;
2226 always_delete_queue = temp;
2233 struct temp_file *temp;
2234 for (temp = failure_delete_queue; temp; temp = temp->next)
2235 if (! strcmp (name, temp->name))
2238 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
2239 temp->next = failure_delete_queue;
2241 failure_delete_queue = temp;
2247 /* Delete all the temporary files whose names we previously recorded. */
2250 delete_if_ordinary (name)
2257 printf ("Delete %s? (y or n) ", name);
2261 while ((c = getchar ()) != '\n' && c != EOF)
2264 if (i == 'y' || i == 'Y')
2266 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
2267 if (unlink (name) < 0)
2269 perror_with_name (name);
2273 delete_temp_files ()
2275 struct temp_file *temp;
2277 for (temp = always_delete_queue; temp; temp = temp->next)
2278 delete_if_ordinary (temp->name);
2279 always_delete_queue = 0;
2282 /* Delete all the files to be deleted on error. */
2285 delete_failure_queue ()
2287 struct temp_file *temp;
2289 for (temp = failure_delete_queue; temp; temp = temp->next)
2290 delete_if_ordinary (temp->name);
2294 clear_failure_queue ()
2296 failure_delete_queue = 0;
2299 /* Build a list of search directories from PATHS.
2300 PREFIX is a string to prepend to the list.
2301 If CHECK_DIR_P is nonzero we ensure the directory exists.
2302 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2303 It is also used by the --print-search-dirs flag. */
2306 build_search_list (paths, prefix, check_dir_p)
2307 struct path_prefix *paths;
2311 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2313 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2314 int first_time = TRUE;
2315 struct prefix_list *pprefix;
2317 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2318 obstack_1grow (&collect_obstack, '=');
2320 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2322 int len = strlen (pprefix->prefix);
2326 || is_directory (pprefix->prefix, machine_suffix, 0)))
2329 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2332 obstack_grow (&collect_obstack, pprefix->prefix, len);
2333 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2336 if (just_machine_suffix
2337 && pprefix->require_machine_suffix == 2
2339 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2342 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2345 obstack_grow (&collect_obstack, pprefix->prefix, len);
2346 obstack_grow (&collect_obstack, just_machine_suffix,
2350 if (! pprefix->require_machine_suffix)
2353 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2356 obstack_grow (&collect_obstack, pprefix->prefix, len);
2360 obstack_1grow (&collect_obstack, '\0');
2361 return obstack_finish (&collect_obstack);
2364 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2368 putenv_from_prefixes (paths, env_var)
2369 struct path_prefix *paths;
2370 const char *env_var;
2372 putenv (build_search_list (paths, env_var, 1));
2375 /* Check whether NAME can be accessed in MODE. This is like access,
2376 except that it never considers directories to be executable. */
2379 access_check (name, mode)
2387 if (stat (name, &st) < 0
2388 || S_ISDIR (st.st_mode))
2392 return access (name, mode);
2395 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2396 access to check permissions.
2397 Return 0 if not found, otherwise return its name, allocated with malloc. */
2400 find_a_file (pprefix, name, mode, multilib)
2401 struct path_prefix *pprefix;
2406 const char *const file_suffix =
2407 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2408 struct prefix_list *pl;
2409 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2410 const char *multilib_name, *multilib_os_name;
2412 #ifdef DEFAULT_ASSEMBLER
2413 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2414 return xstrdup (DEFAULT_ASSEMBLER);
2417 #ifdef DEFAULT_LINKER
2418 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2419 return xstrdup (DEFAULT_LINKER);
2423 len += strlen (machine_suffix);
2425 multilib_name = name;
2426 multilib_os_name = name;
2427 if (multilib && multilib_os_dir)
2429 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2430 int len2 = strlen (multilib_os_dir) + 1;
2432 len += len1 > len2 ? len1 : len2;
2434 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2436 if (strcmp (multilib_os_dir, ".") != 0)
2437 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2441 temp = xmalloc (len);
2443 /* Determine the filename to execute (special case for absolute paths). */
2445 if (IS_ABSOLUTE_PATHNAME (name))
2447 if (access (name, mode) == 0)
2449 strcpy (temp, name);
2454 for (pl = pprefix->plist; pl; pl = pl->next)
2456 const char *this_name
2457 = pl->os_multilib ? multilib_os_name : multilib_name;
2461 /* Some systems have a suffix for executable files.
2462 So try appending that first. */
2463 if (file_suffix[0] != 0)
2465 strcpy (temp, pl->prefix);
2466 strcat (temp, machine_suffix);
2467 strcat (temp, multilib_name);
2468 strcat (temp, file_suffix);
2469 if (access_check (temp, mode) == 0)
2471 if (pl->used_flag_ptr != 0)
2472 *pl->used_flag_ptr = 1;
2477 /* Now try just the multilib_name. */
2478 strcpy (temp, pl->prefix);
2479 strcat (temp, machine_suffix);
2480 strcat (temp, multilib_name);
2481 if (access_check (temp, mode) == 0)
2483 if (pl->used_flag_ptr != 0)
2484 *pl->used_flag_ptr = 1;
2489 /* Certain prefixes are tried with just the machine type,
2490 not the version. This is used for finding as, ld, etc. */
2491 if (just_machine_suffix && pl->require_machine_suffix == 2)
2493 /* Some systems have a suffix for executable files.
2494 So try appending that first. */
2495 if (file_suffix[0] != 0)
2497 strcpy (temp, pl->prefix);
2498 strcat (temp, just_machine_suffix);
2499 strcat (temp, multilib_name);
2500 strcat (temp, file_suffix);
2501 if (access_check (temp, mode) == 0)
2503 if (pl->used_flag_ptr != 0)
2504 *pl->used_flag_ptr = 1;
2509 strcpy (temp, pl->prefix);
2510 strcat (temp, just_machine_suffix);
2511 strcat (temp, multilib_name);
2512 if (access_check (temp, mode) == 0)
2514 if (pl->used_flag_ptr != 0)
2515 *pl->used_flag_ptr = 1;
2520 /* Certain prefixes can't be used without the machine suffix
2521 when the machine or version is explicitly specified. */
2522 if (! pl->require_machine_suffix)
2524 /* Some systems have a suffix for executable files.
2525 So try appending that first. */
2526 if (file_suffix[0] != 0)
2528 strcpy (temp, pl->prefix);
2529 strcat (temp, this_name);
2530 strcat (temp, file_suffix);
2531 if (access_check (temp, mode) == 0)
2533 if (pl->used_flag_ptr != 0)
2534 *pl->used_flag_ptr = 1;
2539 strcpy (temp, pl->prefix);
2540 strcat (temp, this_name);
2541 if (access_check (temp, mode) == 0)
2543 if (pl->used_flag_ptr != 0)
2544 *pl->used_flag_ptr = 1;
2554 /* Ranking of prefixes in the sort list. -B prefixes are put before
2557 enum path_prefix_priority
2559 PREFIX_PRIORITY_B_OPT,
2560 PREFIX_PRIORITY_LAST
2563 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2564 order according to PRIORITY. Within each PRIORITY, new entries are
2567 If WARN is nonzero, we will warn if no file is found
2568 through this prefix. WARN should point to an int
2569 which will be set to 1 if this entry is used.
2571 COMPONENT is the value to be passed to update_path.
2573 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2574 the complete value of machine_suffix.
2575 2 means try both machine_suffix and just_machine_suffix. */
2578 add_prefix (pprefix, prefix, component, priority, require_machine_suffix,
2580 struct path_prefix *pprefix;
2582 const char *component;
2583 /* enum prefix_priority */ int priority;
2584 int require_machine_suffix;
2588 struct prefix_list *pl, **prev;
2591 for (prev = &pprefix->plist;
2592 (*prev) != NULL && (*prev)->priority <= priority;
2593 prev = &(*prev)->next)
2596 /* Keep track of the longest prefix */
2598 prefix = update_path (prefix, component);
2599 len = strlen (prefix);
2600 if (len > pprefix->max_len)
2601 pprefix->max_len = len;
2603 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2604 pl->prefix = prefix;
2605 pl->require_machine_suffix = require_machine_suffix;
2606 pl->used_flag_ptr = warn;
2607 pl->priority = priority;
2608 pl->os_multilib = os_multilib;
2612 /* Insert after PREV */
2617 /* Same as add_prefix, but prepending target_system_root to prefix. */
2619 add_sysrooted_prefix (pprefix, prefix, component, priority,
2620 require_machine_suffix, warn, os_multilib)
2621 struct path_prefix *pprefix;
2623 const char *component;
2624 /* enum prefix_priority */ int priority;
2625 int require_machine_suffix;
2629 if (!IS_ABSOLUTE_PATHNAME (prefix))
2632 if (target_system_root)
2634 if (target_sysroot_suffix)
2635 prefix = concat (target_sysroot_suffix, prefix, NULL);
2636 prefix = concat (target_system_root, prefix, NULL);
2638 /* We have to override this because GCC's notion of sysroot
2639 moves along with GCC. */
2643 add_prefix (pprefix, prefix, component, priority,
2644 require_machine_suffix, warn, os_multilib);
2647 /* Execute the command specified by the arguments on the current line of spec.
2648 When using pipes, this includes several piped-together commands
2649 with `|' between them.
2651 Return 0 if successful, -1 if failed. */
2657 int n_commands; /* # of command. */
2661 const char *prog; /* program name. */
2662 const char **argv; /* vector of args. */
2663 int pid; /* pid of process for this command. */
2666 struct command *commands; /* each command buffer with above info. */
2668 if (processing_spec_function)
2671 /* Count # of piped commands. */
2672 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2673 if (strcmp (argbuf[i], "|") == 0)
2676 /* Get storage for each command. */
2677 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2679 /* Split argbuf into its separate piped processes,
2680 and record info about each one.
2681 Also search for the programs that are to be run. */
2683 commands[0].prog = argbuf[0]; /* first command. */
2684 commands[0].argv = &argbuf[0];
2685 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2688 commands[0].argv[0] = string;
2690 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2691 if (strcmp (argbuf[i], "|") == 0)
2692 { /* each command. */
2693 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2694 fatal ("-pipe not supported");
2696 argbuf[i] = 0; /* termination of command args. */
2697 commands[n_commands].prog = argbuf[i + 1];
2698 commands[n_commands].argv = &argbuf[i + 1];
2699 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2702 commands[n_commands].argv[0] = string;
2706 argbuf[argbuf_index] = 0;
2708 /* If -v, print what we are about to do, and maybe query. */
2712 /* For help listings, put a blank line between sub-processes. */
2713 if (print_help_list)
2714 fputc ('\n', stderr);
2716 /* Print each piped command as a separate line. */
2717 for (i = 0; i < n_commands; i++)
2719 const char *const *j;
2721 if (verbose_only_flag)
2723 for (j = commands[i].argv; *j; j++)
2726 fprintf (stderr, " \"");
2727 for (p = *j; *p; ++p)
2729 if (*p == '"' || *p == '\\' || *p == '$')
2730 fputc ('\\', stderr);
2733 fputc ('"', stderr);
2737 for (j = commands[i].argv; *j; j++)
2738 fprintf (stderr, " %s", *j);
2740 /* Print a pipe symbol after all but the last command. */
2741 if (i + 1 != n_commands)
2742 fprintf (stderr, " |");
2743 fprintf (stderr, "\n");
2746 if (verbose_only_flag != 0)
2749 notice ("\nGo ahead? (y or n) ");
2753 while (getchar () != '\n')
2756 if (i != 'y' && i != 'Y')
2761 #ifdef ENABLE_VALGRIND_CHECKING
2762 /* Run the each command through valgrind. To simplify prepending the
2763 path to valgrind and the option "-q" (for quiet operation unless
2764 something triggers), we allocate a separate argv array. */
2766 for (i = 0; i < n_commands; i++)
2772 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2775 argv = alloca ((argc + 3) * sizeof (char *));
2777 argv[0] = VALGRIND_PATH;
2779 for (j = 2; j < argc + 2; j++)
2780 argv[j] = commands[i].argv[j - 2];
2783 commands[i].argv = argv;
2784 commands[i].prog = argv[0];
2788 /* Run each piped subprocess. */
2790 for (i = 0; i < n_commands; i++)
2792 char *errmsg_fmt, *errmsg_arg;
2793 const char *string = commands[i].argv[0];
2795 /* For some bizarre reason, the second argument of execvp() is
2796 char *const *, not const char *const *. */
2797 commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2798 programname, temp_filename,
2799 &errmsg_fmt, &errmsg_arg,
2800 ((i == 0 ? PEXECUTE_FIRST : 0)
2801 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2802 | (string == commands[i].prog
2803 ? PEXECUTE_SEARCH : 0)
2804 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2806 if (commands[i].pid == -1)
2807 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2809 if (string != commands[i].prog)
2810 free ((void *) string);
2815 /* Wait for all the subprocesses to finish.
2816 We don't care what order they finish in;
2817 we know that N_COMMANDS waits will get them all.
2818 Ignore subprocesses that we don't know about,
2819 since they can be spawned by the process that exec'ed us. */
2823 #ifdef HAVE_GETRUSAGE
2825 double ut = 0.0, st = 0.0;
2828 for (i = 0; i < n_commands;)
2834 pid = pwait (commands[i].pid, &status, 0);
2838 #ifdef HAVE_GETRUSAGE
2841 /* getrusage returns the total resource usage of all children
2842 up to now. Copy the previous values into prus, get the
2843 current statistics, then take the difference. */
2846 getrusage (RUSAGE_CHILDREN, &rus);
2847 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2848 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2849 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2851 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2852 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2853 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2857 for (j = 0; j < n_commands; j++)
2858 if (commands[j].pid == pid)
2861 if (WIFSIGNALED (status))
2864 /* SIGPIPE is a special case. It happens in -pipe mode
2865 when the compiler dies before the preprocessor is
2866 done, or the assembler dies before the compiler is
2867 done. There's generally been an error already, and
2868 this is just fallout. So don't generate another error
2869 unless we would otherwise have succeeded. */
2870 if (WTERMSIG (status) == SIGPIPE
2871 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2876 Internal error: %s (program %s)\n\
2877 Please submit a full bug report.\n\
2878 See %s for instructions.",
2879 strsignal (WTERMSIG (status)), commands[j].prog,
2884 else if (WIFEXITED (status)
2885 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2887 if (WEXITSTATUS (status) > greatest_status)
2888 greatest_status = WEXITSTATUS (status);
2891 #ifdef HAVE_GETRUSAGE
2892 if (report_times && ut + st != 0)
2893 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2902 /* Find all the switches given to us
2903 and make a vector describing them.
2904 The elements of the vector are strings, one per switch given.
2905 If a switch uses following arguments, then the `part1' field
2906 is the switch itself and the `args' field
2907 is a null-terminated vector containing the following arguments.
2908 The `live_cond' field is:
2910 1 if the switch is true in a conditional spec,
2911 -1 if false (overridden by a later switch)
2912 -2 if this switch should be ignored (used in %<S)
2913 The `validated' field is nonzero if any spec has looked at this switch;
2914 if it remains zero at the end of the run, it must be meaningless. */
2917 #define SWITCH_FALSE -1
2918 #define SWITCH_IGNORE -2
2919 #define SWITCH_LIVE 1
2926 unsigned char validated;
2927 unsigned char ordering;
2930 static struct switchstr *switches;
2932 static int n_switches;
2937 const char *language;
2940 /* Also a vector of input files specified. */
2942 static struct infile *infiles;
2946 /* This counts the number of libraries added by lang_specific_driver, so that
2947 we can tell if there were any user supplied any files or libraries. */
2949 static int added_libraries;
2951 /* And a vector of corresponding output files is made up later. */
2953 const char **outfiles;
2955 /* Used to track if none of the -B paths are used. */
2958 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2959 static int *warn_std_ptr = 0;
2961 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2963 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2964 is true if we should look for an executable suffix. DO_OBJ
2965 is true if we should look for an object suffix. */
2968 convert_filename (name, do_exe, do_obj)
2970 int do_exe ATTRIBUTE_UNUSED;
2971 int do_obj ATTRIBUTE_UNUSED;
2973 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2981 len = strlen (name);
2983 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2984 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2985 if (do_obj && len > 2
2986 && name[len - 2] == '.'
2987 && name[len - 1] == 'o')
2989 obstack_grow (&obstack, name, len - 2);
2990 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2991 name = obstack_finish (&obstack);
2995 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2996 /* If there is no filetype, make it the executable suffix (which includes
2997 the "."). But don't get confused if we have just "-o". */
2998 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3001 for (i = len - 1; i >= 0; i--)
3002 if (IS_DIR_SEPARATOR (name[i]))
3005 for (i++; i < len; i++)
3009 obstack_grow (&obstack, name, len);
3010 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3011 strlen (TARGET_EXECUTABLE_SUFFIX));
3012 name = obstack_finish (&obstack);
3019 /* Display the command line switches accepted by gcc. */
3023 printf (_("Usage: %s [options] file...\n"), programname);
3024 fputs (_("Options:\n"), stdout);
3026 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3027 fputs (_(" --help Display this information\n"), stdout);
3028 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3030 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3031 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3032 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3033 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3034 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3035 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3036 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3037 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3038 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3040 -print-multi-lib Display the mapping between command line options and\n\
3041 multiple library search directories\n"), stdout);
3042 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3043 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3044 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3045 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3046 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3047 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3048 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3049 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3050 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3051 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3052 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3053 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3054 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3055 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
3056 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
3057 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3058 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3059 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3060 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3061 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3062 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3064 -x <language> Specify the language of the following input files\n\
3065 Permissible languages include: c c++ assembler none\n\
3066 'none' means revert to the default behavior of\n\
3067 guessing the language based on the file's extension\n\
3071 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3072 passed on to the various sub-processes invoked by %s. In order to pass\n\
3073 other options on to these processes the -W<letter> options must be used.\n\
3076 /* The rest of the options are displayed by invocations of the various
3081 add_preprocessor_option (option, len)
3085 n_preprocessor_options++;
3087 if (! preprocessor_options)
3088 preprocessor_options
3089 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
3091 preprocessor_options
3092 = (char **) xrealloc (preprocessor_options,
3093 n_preprocessor_options * sizeof (char *));
3095 preprocessor_options [n_preprocessor_options - 1] =
3096 save_string (option, len);
3100 add_assembler_option (option, len)
3104 n_assembler_options++;
3106 if (! assembler_options)
3108 = (char **) xmalloc (n_assembler_options * sizeof (char *));
3111 = (char **) xrealloc (assembler_options,
3112 n_assembler_options * sizeof (char *));
3114 assembler_options [n_assembler_options - 1] = save_string (option, len);
3118 add_linker_option (option, len)
3124 if (! linker_options)
3126 = (char **) xmalloc (n_linker_options * sizeof (char *));
3129 = (char **) xrealloc (linker_options,
3130 n_linker_options * sizeof (char *));
3132 linker_options [n_linker_options - 1] = save_string (option, len);
3135 /* Create the vector `switches' and its contents.
3136 Store its length in `n_switches'. */
3139 process_command (argc, argv)
3141 const char *const *argv;
3146 const char *spec_lang = 0;
3147 int last_language_n_infiles;
3150 int lang_n_infiles = 0;
3151 #ifdef MODIFY_TARGET_NAME
3152 int is_modify_target_name;
3156 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3160 added_libraries = 0;
3162 /* Figure compiler version from version string. */
3164 compiler_version = temp1 = xstrdup (version_string);
3166 for (; *temp1; ++temp1)
3175 /* If there is a -V or -b option (or both), process it now, before
3176 trying to interpret the rest of the command line. */
3177 if (argc > 1 && argv[1][0] == '-'
3178 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3180 const char *new_version = DEFAULT_TARGET_VERSION;
3181 const char *new_machine = DEFAULT_TARGET_MACHINE;
3182 const char *progname = argv[0];
3187 while (argc > 1 && argv[1][0] == '-'
3188 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3190 char opt = argv[1][1];
3192 if (argv[1][2] != '\0')
3205 fatal ("`-%c' option must have argument", opt);
3212 for (baselen = strlen (progname); baselen > 0; baselen--)
3213 if (IS_DIR_SEPARATOR (progname[baselen-1]))
3215 new_argv0 = xmemdup (progname, baselen,
3216 baselen + concat_length (new_version, new_machine,
3217 "-gcc-", NULL) + 1);
3218 strcpy (new_argv0 + baselen, new_machine);
3219 strcat (new_argv0, "-gcc-");
3220 strcat (new_argv0, new_version);
3222 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3223 (argc + 1) * sizeof (argv[0]));
3224 new_argv[0] = new_argv0;
3226 execvp (new_argv0, new_argv);
3227 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
3230 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3231 see if we can create it from the pathname specified in argv[0]. */
3234 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3235 if (!gcc_exec_prefix)
3237 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3238 standard_exec_prefix);
3239 if (gcc_exec_prefix)
3240 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3244 if (gcc_exec_prefix)
3246 int len = strlen (gcc_exec_prefix);
3248 if (len > (int) sizeof ("/lib/gcc-lib/") - 1
3249 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3251 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
3252 if (IS_DIR_SEPARATOR (*temp)
3253 && strncmp (temp + 1, "lib", 3) == 0
3254 && IS_DIR_SEPARATOR (temp[4])
3255 && strncmp (temp + 5, "gcc-lib", 7) == 0)
3256 len -= sizeof ("/lib/gcc-lib/") - 1;
3259 set_std_prefix (gcc_exec_prefix, len);
3260 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC",
3261 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3262 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3263 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3266 /* COMPILER_PATH and LIBRARY_PATH have values
3267 that are lists of directory names with colons. */
3269 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3272 const char *startp, *endp;
3273 char *nstore = (char *) alloca (strlen (temp) + 3);
3275 startp = endp = temp;
3278 if (*endp == PATH_SEPARATOR || *endp == 0)
3280 strncpy (nstore, startp, endp - startp);
3282 strcpy (nstore, concat (".", dir_separator_str, NULL));
3283 else if (!IS_DIR_SEPARATOR (endp[-1]))
3285 nstore[endp - startp] = DIR_SEPARATOR;
3286 nstore[endp - startp + 1] = 0;
3289 nstore[endp - startp] = 0;
3290 add_prefix (&exec_prefixes, nstore, 0,
3291 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3292 add_prefix (&include_prefixes,
3293 concat (nstore, "include", NULL),
3294 0, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3297 endp = startp = endp + 1;
3304 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3305 if (temp && *cross_compile == '0')
3307 const char *startp, *endp;
3308 char *nstore = (char *) alloca (strlen (temp) + 3);
3310 startp = endp = temp;
3313 if (*endp == PATH_SEPARATOR || *endp == 0)
3315 strncpy (nstore, startp, endp - startp);
3317 strcpy (nstore, concat (".", dir_separator_str, NULL));
3318 else if (!IS_DIR_SEPARATOR (endp[-1]))
3320 nstore[endp - startp] = DIR_SEPARATOR;
3321 nstore[endp - startp + 1] = 0;
3324 nstore[endp - startp] = 0;
3325 add_prefix (&startfile_prefixes, nstore, NULL,
3326 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3329 endp = startp = endp + 1;
3336 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3337 GET_ENVIRONMENT (temp, "LPATH");
3338 if (temp && *cross_compile == '0')
3340 const char *startp, *endp;
3341 char *nstore = (char *) alloca (strlen (temp) + 3);
3343 startp = endp = temp;
3346 if (*endp == PATH_SEPARATOR || *endp == 0)
3348 strncpy (nstore, startp, endp - startp);
3350 strcpy (nstore, concat (".", dir_separator_str, NULL));
3351 else if (!IS_DIR_SEPARATOR (endp[-1]))
3353 nstore[endp - startp] = DIR_SEPARATOR;
3354 nstore[endp - startp + 1] = 0;
3357 nstore[endp - startp] = 0;
3358 add_prefix (&startfile_prefixes, nstore, NULL,
3359 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3362 endp = startp = endp + 1;
3369 /* Convert new-style -- options to old-style. */
3370 translate_options (&argc, &argv);
3372 /* Do language-specific adjustment/addition of flags. */
3373 lang_specific_driver (&argc, &argv, &added_libraries);
3375 /* Scan argv twice. Here, the first time, just count how many switches
3376 there will be in their vector, and how many input files in theirs.
3377 Here we also parse the switches that cc itself uses (e.g. -v). */
3379 for (i = 1; i < argc; i++)
3381 if (! strcmp (argv[i], "-dumpspecs"))
3383 struct spec_list *sl;
3385 for (sl = specs; sl; sl = sl->next)
3386 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3387 if (link_command_spec)
3388 printf ("*link_command:\n%s\n\n", link_command_spec);
3391 else if (! strcmp (argv[i], "-dumpversion"))
3393 printf ("%s\n", spec_version);
3396 else if (! strcmp (argv[i], "-dumpmachine"))
3398 printf ("%s\n", spec_machine);
3401 else if (strcmp (argv[i], "-fversion") == 0)
3403 /* translate_options () has turned --version into -fversion. */
3404 printf (_("%s (GCC) %s\n"), programname, version_string);
3405 fputs (_("Copyright (C) 2003 Free Software Foundation, Inc.\n"),
3407 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3408 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3412 else if (strcmp (argv[i], "-fhelp") == 0)
3414 /* translate_options () has turned --help into -fhelp. */
3415 print_help_list = 1;
3417 /* We will be passing a dummy file on to the sub-processes. */
3421 /* CPP driver cannot obtain switch from cc1_options. */
3423 add_preprocessor_option ("--help", 6);
3424 add_assembler_option ("--help", 6);
3425 add_linker_option ("--help", 6);
3427 else if (strcmp (argv[i], "-ftarget-help") == 0)
3429 /* translate_options() has turned --target-help into -ftarget-help. */
3430 target_help_flag = 1;
3432 /* We will be passing a dummy file on to the sub-processes. */
3436 /* CPP driver cannot obtain switch from cc1_options. */
3438 add_preprocessor_option ("--target-help", 13);
3439 add_assembler_option ("--target-help", 13);
3440 add_linker_option ("--target-help", 13);
3442 else if (! strcmp (argv[i], "-pass-exit-codes"))
3444 pass_exit_codes = 1;
3447 else if (! strcmp (argv[i], "-print-search-dirs"))
3448 print_search_dirs = 1;
3449 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3450 print_file_name = "libgcc.a";
3451 else if (! strncmp (argv[i], "-print-file-name=", 17))
3452 print_file_name = argv[i] + 17;
3453 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3454 print_prog_name = argv[i] + 17;
3455 else if (! strcmp (argv[i], "-print-multi-lib"))
3456 print_multi_lib = 1;
3457 else if (! strcmp (argv[i], "-print-multi-directory"))
3458 print_multi_directory = 1;
3459 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3460 print_multi_os_directory = 1;
3461 else if (! strncmp (argv[i], "-Wa,", 4))
3464 /* Pass the rest of this option to the assembler. */
3466 /* Split the argument at commas. */
3468 for (j = 4; argv[i][j]; j++)
3469 if (argv[i][j] == ',')
3471 add_assembler_option (argv[i] + prev, j - prev);
3475 /* Record the part after the last comma. */
3476 add_assembler_option (argv[i] + prev, j - prev);
3478 else if (! strncmp (argv[i], "-Wp,", 4))
3481 /* Pass the rest of this option to the preprocessor. */
3483 /* Split the argument at commas. */
3485 for (j = 4; argv[i][j]; j++)
3486 if (argv[i][j] == ',')
3488 add_preprocessor_option (argv[i] + prev, j - prev);
3492 /* Record the part after the last comma. */
3493 add_preprocessor_option (argv[i] + prev, j - prev);
3495 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3496 /* The +e options to the C++ front-end. */
3498 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3501 /* Split the argument at commas. */
3502 for (j = 3; argv[i][j]; j++)
3503 n_infiles += (argv[i][j] == ',');
3505 else if (strcmp (argv[i], "-Xlinker") == 0)
3508 fatal ("argument to `-Xlinker' is missing");
3513 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3516 fatal ("argument to `-Xpreprocessor' is missing");
3518 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3520 else if (strcmp (argv[i], "-Xassembler") == 0)
3523 fatal ("argument to `-Xassembler' is missing");
3525 add_assembler_option (argv[i+1], strlen (argv[i+1]));
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], "-pipe") == 0)
3576 /* -pipe has to go into the switches array as well as
3581 else if (strcmp (argv[i], "-###") == 0)
3583 /* This is similar to -v except that there is no execution
3584 of the commands and the echoed arguments are quoted. It
3585 is intended for use in shell scripts to capture the
3586 driver-generated command line. */
3587 verbose_only_flag++;
3590 else if (argv[i][0] == '-' && argv[i][1] != 0)
3592 const char *p = &argv[i][1];
3599 fatal ("`-%c' must come at the start of the command line", c);
3607 if (p[1] == 0 && i + 1 == argc)
3608 fatal ("argument to `-B' is missing");
3614 len = strlen (value);
3616 /* Catch the case where the user has forgotten to append a
3617 directory separator to the path. Note, they may be using
3618 -B to add an executable name prefix, eg "i386-elf-", in
3619 order to distinguish between multiple installations of
3620 GCC in the same directory. Hence we must check to see
3621 if appending a directory separator actually makes a
3622 valid directory name. */
3623 if (! IS_DIR_SEPARATOR (value [len - 1])
3624 && is_directory (value, "", 0))
3626 char *tmp = xmalloc (len + 2);
3627 strcpy (tmp, value);
3628 tmp[len] = DIR_SEPARATOR;
3633 /* As a kludge, if the arg is "[foo/]stageN/", just
3634 add "[foo/]include" to the include prefix. */
3637 && (IS_DIR_SEPARATOR (value[len - 8]))))
3638 && strncmp (value + len - 7, "stage", 5) == 0
3639 && ISDIGIT (value[len - 2])
3640 && (IS_DIR_SEPARATOR (value[len - 1])))
3643 add_prefix (&include_prefixes, "include", NULL,
3644 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3647 char * string = xmalloc (len + 1);
3649 strncpy (string, value, len - 7);
3650 strcpy (string + len - 7, "include");
3651 add_prefix (&include_prefixes, string, NULL,
3652 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3656 add_prefix (&exec_prefixes, value, NULL,
3657 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3658 add_prefix (&startfile_prefixes, value, NULL,
3659 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3660 add_prefix (&include_prefixes, concat (value, "include", NULL),
3661 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3666 case 'v': /* Print our subcommands and print versions. */
3668 /* If they do anything other than exactly `-v', don't set
3669 verbose_flag; rather, continue on to give the error. */
3687 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3692 /* Forward scan, just in case -S or -c is specified
3699 if (argv[j][0] == '-')
3701 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3707 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3708 j += skip - (argv[j][2] != 0);
3709 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3716 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3718 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3720 argv[i] = convert_filename (argv[i], ! have_c, 0);
3727 #ifdef MODIFY_TARGET_NAME
3728 is_modify_target_name = 0;
3730 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3731 if (! strcmp (argv[i], modify_target[j].sw))
3734 = (char *) xmalloc (strlen (modify_target[j].str)
3735 + strlen (spec_machine));
3738 int made_addition = 0;
3740 is_modify_target_name = 1;
3741 for (p = spec_machine, q = new_name; *p != 0; )
3743 if (modify_target[j].add_del == DELETE
3744 && (! strncmp (q, modify_target[j].str,
3745 strlen (modify_target[j].str))))
3746 p += strlen (modify_target[j].str);
3747 else if (modify_target[j].add_del == ADD
3748 && ! made_addition && *p == '-')
3750 for (r = modify_target[j].str; *r != 0; )
3758 spec_machine = new_name;
3761 if (is_modify_target_name)
3767 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3768 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3769 else if (WORD_SWITCH_TAKES_ARG (p))
3770 i += WORD_SWITCH_TAKES_ARG (p);
3780 if (have_c && have_o && lang_n_infiles > 1)
3781 fatal ("cannot specify -o with -c or -S and multiple compilations");
3783 if ((save_temps_flag || report_times) && use_pipes)
3785 /* -save-temps overrides -pipe, so that temp files are produced */
3786 if (save_temps_flag)
3787 error ("warning: -pipe ignored because -save-temps specified");
3788 /* -time overrides -pipe because we can't get correct stats when
3789 multiple children are running at once. */
3790 else if (report_times)
3791 error ("warning: -pipe ignored because -time specified");
3796 /* Set up the search paths before we go looking for config files. */
3798 /* These come before the md prefixes so that we will find gcc's subcommands
3799 (such as cpp) rather than those of the host system. */
3800 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3801 as well as trying the machine and the version. */
3803 add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
3804 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3805 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3806 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3807 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3808 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3811 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3812 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3813 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3814 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3816 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3817 dir_separator_str, NULL);
3819 /* If tooldir is relative, base it on exec_prefixes. A relative
3820 tooldir lets us move the installed tree as a unit.
3822 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3823 directories, so that we can search both the user specified directory
3824 and the standard place. */
3826 if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix))
3828 if (gcc_exec_prefix)
3830 char *gcc_exec_tooldir_prefix
3831 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3832 spec_version, dir_separator_str, tooldir_prefix, NULL);
3834 add_prefix (&exec_prefixes,
3835 concat (gcc_exec_tooldir_prefix, "bin",
3836 dir_separator_str, NULL),
3837 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3838 add_prefix (&startfile_prefixes,
3839 concat (gcc_exec_tooldir_prefix, "lib",
3840 dir_separator_str, NULL),
3841 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
3844 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3845 dir_separator_str, spec_version,
3846 dir_separator_str, tooldir_prefix, NULL);
3849 add_prefix (&exec_prefixes,
3850 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3851 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0);
3852 add_prefix (&startfile_prefixes,
3853 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3854 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
3856 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3857 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3858 then consider it to relocate with the rest of the GCC installation
3859 if GCC_EXEC_PREFIX is set.
3860 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3861 if (target_system_root && gcc_exec_prefix)
3863 char *tmp_prefix = make_relative_prefix (argv[0],
3864 standard_bindir_prefix,
3865 target_system_root);
3866 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3868 target_system_root = tmp_prefix;
3869 target_system_root_changed = 1;
3874 /* More prefixes are enabled in main, after we read the specs file
3875 and determine whether this is cross-compilation or not. */
3877 /* Then create the space for the vectors and scan again. */
3879 switches = ((struct switchstr *)
3880 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3881 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3884 last_language_n_infiles = -1;
3886 /* This, time, copy the text of each switch and store a pointer
3887 to the copy in the vector of switches.
3888 Store all the infiles in their vector. */
3890 for (i = 1; i < argc; i++)
3892 /* Just skip the switches that were handled by the preceding loop. */
3893 #ifdef MODIFY_TARGET_NAME
3894 is_modify_target_name = 0;
3896 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3897 if (! strcmp (argv[i], modify_target[j].sw))
3898 is_modify_target_name = 1;
3900 if (is_modify_target_name)
3904 if (! strncmp (argv[i], "-Wa,", 4))
3906 else if (! strncmp (argv[i], "-Wp,", 4))
3908 else if (! strcmp (argv[i], "-pass-exit-codes"))
3910 else if (! strcmp (argv[i], "-print-search-dirs"))
3912 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3914 else if (! strncmp (argv[i], "-print-file-name=", 17))
3916 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3918 else if (! strcmp (argv[i], "-print-multi-lib"))
3920 else if (! strcmp (argv[i], "-print-multi-directory"))
3922 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3924 else if (! strcmp (argv[i], "-ftarget-help"))
3926 else if (! strcmp (argv[i], "-fhelp"))
3928 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3930 /* Compensate for the +e options to the C++ front-end;
3931 they're there simply for cfront call-compatibility. We do
3932 some magic in default_compilers to pass them down properly.
3933 Note we deliberately start at the `+' here, to avoid passing
3934 -e0 or -e1 down into the linker. */
3935 switches[n_switches].part1 = &argv[i][0];
3936 switches[n_switches].args = 0;
3937 switches[n_switches].live_cond = SWITCH_OK;
3938 switches[n_switches].validated = 0;
3941 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3944 /* Split the argument at commas. */
3946 for (j = 4; argv[i][j]; j++)
3947 if (argv[i][j] == ',')
3949 infiles[n_infiles].language = "*";
3950 infiles[n_infiles++].name
3951 = save_string (argv[i] + prev, j - prev);
3954 /* Record the part after the last comma. */
3955 infiles[n_infiles].language = "*";
3956 infiles[n_infiles++].name = argv[i] + prev;
3958 else if (strcmp (argv[i], "-Xlinker") == 0)
3960 infiles[n_infiles].language = "*";
3961 infiles[n_infiles++].name = argv[++i];
3963 else if (strcmp (argv[i], "-Xassembler") == 0)
3965 infiles[n_infiles].language = "*";
3966 infiles[n_infiles++].name = argv[++i];
3968 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3970 infiles[n_infiles].language = "*";
3971 infiles[n_infiles++].name = argv[++i];
3973 else if (strcmp (argv[i], "-l") == 0)
3974 { /* POSIX allows separation of -l and the lib arg;
3975 canonicalize by concatenating -l with its arg */
3976 infiles[n_infiles].language = "*";
3977 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3979 else if (strncmp (argv[i], "-l", 2) == 0)
3981 infiles[n_infiles].language = "*";
3982 infiles[n_infiles++].name = argv[i];
3984 else if (strcmp (argv[i], "-specs") == 0)
3986 else if (strncmp (argv[i], "-specs=", 7) == 0)
3988 else if (strcmp (argv[i], "-time") == 0)
3990 else if (strcmp (argv[i], "-###") == 0)
3992 else if (argv[i][0] == '-' && argv[i][1] != 0)
3994 const char *p = &argv[i][1];
3999 if (p[1] == 0 && i + 1 == argc)
4000 fatal ("argument to `-x' is missing");
4002 spec_lang = argv[++i];
4005 if (! strcmp (spec_lang, "none"))
4006 /* Suppress the warning if -xnone comes after the last input
4007 file, because alternate command interfaces like g++ might
4008 find it useful to place -xnone after each input file. */
4011 last_language_n_infiles = n_infiles;
4014 switches[n_switches].part1 = p;
4015 /* Deal with option arguments in separate argv elements. */
4016 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4017 || WORD_SWITCH_TAKES_ARG (p))
4020 int n_args = WORD_SWITCH_TAKES_ARG (p);
4024 /* Count only the option arguments in separate argv elements. */
4025 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4027 if (i + n_args >= argc)
4028 fatal ("argument to `-%s' is missing", p);
4029 switches[n_switches].args
4030 = (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
4032 switches[n_switches].args[j++] = argv[++i];
4033 /* Null-terminate the vector. */
4034 switches[n_switches].args[j] = 0;
4036 else if (strchr (switches_need_spaces, c))
4038 /* On some systems, ld cannot handle some options without
4039 a space. So split the option from its argument. */
4040 char *part1 = (char *) xmalloc (2);
4044 switches[n_switches].part1 = part1;
4045 switches[n_switches].args
4046 = (const char **) xmalloc (2 * sizeof (const char *));
4047 switches[n_switches].args[0] = xstrdup (p+1);
4048 switches[n_switches].args[1] = 0;
4051 switches[n_switches].args = 0;
4053 switches[n_switches].live_cond = SWITCH_OK;
4054 switches[n_switches].validated = 0;
4055 switches[n_switches].ordering = 0;
4056 /* These are always valid, since gcc.c itself understands them. */
4057 if (!strcmp (p, "save-temps")
4058 || !strcmp (p, "static-libgcc")
4059 || !strcmp (p, "shared-libgcc")
4060 || !strcmp (p, "pipe"))
4061 switches[n_switches].validated = 1;
4064 char ch = switches[n_switches].part1[0];
4066 switches[n_switches].validated = 1;
4072 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4073 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4076 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4078 perror_with_name (argv[i]);
4083 infiles[n_infiles].language = spec_lang;
4084 infiles[n_infiles++].name = argv[i];
4089 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4090 error ("warning: `-x %s' after last input file has no effect", spec_lang);
4092 /* Ensure we only invoke each subprocess once. */
4093 if (target_help_flag || print_help_list)
4097 /* Create a dummy input file, so that we can pass --target-help on to
4098 the various sub-processes. */
4099 infiles[0].language = "c";
4100 infiles[0].name = "help-dummy";
4102 if (target_help_flag)
4104 switches[n_switches].part1 = "--target-help";
4105 switches[n_switches].args = 0;
4106 switches[n_switches].live_cond = SWITCH_OK;
4107 switches[n_switches].validated = 0;
4112 if (print_help_list)
4114 switches[n_switches].part1 = "--help";
4115 switches[n_switches].args = 0;
4116 switches[n_switches].live_cond = SWITCH_OK;
4117 switches[n_switches].validated = 0;
4123 switches[n_switches].part1 = 0;
4124 infiles[n_infiles].name = 0;
4127 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4128 and place that in the environment. */
4131 set_collect_gcc_options ()
4136 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4138 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4139 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4142 for (i = 0; (int) i < n_switches; i++)
4144 const char *const *args;
4147 obstack_grow (&collect_obstack, " ", 1);
4151 /* Ignore elided switches. */
4152 if (switches[i].live_cond == SWITCH_IGNORE)
4155 obstack_grow (&collect_obstack, "'-", 2);
4156 q = switches[i].part1;
4157 while ((p = strchr (q, '\'')))
4159 obstack_grow (&collect_obstack, q, p - q);
4160 obstack_grow (&collect_obstack, "'\\''", 4);
4163 obstack_grow (&collect_obstack, q, strlen (q));
4164 obstack_grow (&collect_obstack, "'", 1);
4166 for (args = switches[i].args; args && *args; args++)
4168 obstack_grow (&collect_obstack, " '", 2);
4170 while ((p = strchr (q, '\'')))
4172 obstack_grow (&collect_obstack, q, p - q);
4173 obstack_grow (&collect_obstack, "'\\''", 4);
4176 obstack_grow (&collect_obstack, q, strlen (q));
4177 obstack_grow (&collect_obstack, "'", 1);
4180 obstack_grow (&collect_obstack, "\0", 1);
4181 putenv (obstack_finish (&collect_obstack));
4184 /* Process a spec string, accumulating and running commands. */
4186 /* These variables describe the input file name.
4187 input_file_number is the index on outfiles of this file,
4188 so that the output file name can be stored for later use by %o.
4189 input_basename is the start of the part of the input file
4190 sans all directory names, and basename_length is the number
4191 of characters starting there excluding the suffix .c or whatever. */
4193 static const char *input_filename;
4194 static int input_file_number;
4195 size_t input_filename_length;
4196 static int basename_length;
4197 static int suffixed_basename_length;
4198 static const char *input_basename;
4199 static const char *input_suffix;
4200 static struct stat input_stat;
4201 static int input_stat_set;
4203 /* The compiler used to process the current input file. */
4204 static struct compiler *input_file_compiler;
4206 /* These are variables used within do_spec and do_spec_1. */
4208 /* Nonzero if an arg has been started and not yet terminated
4209 (with space, tab or newline). */
4210 static int arg_going;
4212 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4213 is a temporary file name. */
4214 static int delete_this_arg;
4216 /* Nonzero means %w has been seen; the next arg to be terminated
4217 is the output file name of this compilation. */
4218 static int this_is_output_file;
4220 /* Nonzero means %s has been seen; the next arg to be terminated
4221 is the name of a library file and we should try the standard
4222 search dirs for it. */
4223 static int this_is_library_file;
4225 /* Nonzero means that the input of this command is coming from a pipe. */
4226 static int input_from_pipe;
4228 /* Nonnull means substitute this for any suffix when outputting a switches
4230 static const char *suffix_subst;
4232 /* Process the spec SPEC and run the commands specified therein.
4233 Returns 0 if the spec is successfully processed; -1 if failed. */
4241 value = do_spec_2 (spec);
4243 /* Force out any unfinished command.
4244 If -pipe, this forces out the last command if it ended in `|'. */
4247 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4250 set_collect_gcc_options ();
4252 if (argbuf_index > 0)
4268 delete_this_arg = 0;
4269 this_is_output_file = 0;
4270 this_is_library_file = 0;
4271 input_from_pipe = 0;
4272 suffix_subst = NULL;
4274 result = do_spec_1 (spec, 0, NULL);
4276 /* End any pending argument. */
4279 obstack_1grow (&obstack, 0);
4280 string = obstack_finish (&obstack);
4281 if (this_is_library_file)
4282 string = find_file (string);
4283 store_arg (string, delete_this_arg, this_is_output_file);
4284 if (this_is_output_file)
4285 outfiles[input_file_number] = string;
4293 /* Process the given spec string and add any new options to the end
4294 of the switches/n_switches array. */
4297 do_option_spec (name, spec)
4301 unsigned int i, value_count, value_len;
4302 const char *p, *q, *value;
4303 char *tmp_spec, *tmp_spec_p;
4305 if (configure_default_options[0].name == NULL)
4308 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4309 if (strcmp (configure_default_options[i].name, name) == 0)
4311 if (i == ARRAY_SIZE (configure_default_options))
4314 value = configure_default_options[i].value;
4315 value_len = strlen (value);
4317 /* Compute the size of the final spec. */
4320 while ((p = strstr (p, "%(VALUE)")) != NULL)
4326 /* Replace each %(VALUE) by the specified value. */
4327 tmp_spec = alloca (strlen (spec) + 1
4328 + value_count * (value_len - strlen ("%(VALUE)")));
4329 tmp_spec_p = tmp_spec;
4331 while ((p = strstr (q, "%(VALUE)")) != NULL)
4333 memcpy (tmp_spec_p, q, p - q);
4334 tmp_spec_p = tmp_spec_p + (p - q);
4335 memcpy (tmp_spec_p, value, value_len);
4336 tmp_spec_p += value_len;
4337 q = p + strlen ("%(VALUE)");
4339 strcpy (tmp_spec_p, q);
4341 do_self_spec (tmp_spec);
4344 /* Process the given spec string and add any new options to the end
4345 of the switches/n_switches array. */
4352 do_spec_1 (" ", 0, NULL);
4354 if (argbuf_index > 0)
4359 n_switches += argbuf_index;
4360 switches = xrealloc (switches,
4361 sizeof (struct switchstr) * (n_switches + 1));
4363 switches[n_switches] = switches[first];
4364 for (i = 0; i < argbuf_index; i++)
4366 struct switchstr *sw;
4368 /* Each switch should start with '-'. */
4369 if (argbuf[i][0] != '-')
4372 sw = &switches[i + first];
4373 sw->part1 = &argbuf[i][1];
4375 sw->live_cond = SWITCH_OK;
4382 /* Process the sub-spec SPEC as a portion of a larger spec.
4383 This is like processing a whole spec except that we do
4384 not initialize at the beginning and we do not supply a
4385 newline by default at the end.
4386 INSWITCH nonzero means don't process %-sequences in SPEC;
4387 in this case, % is treated as an ordinary character.
4388 This is used while substituting switches.
4389 INSWITCH nonzero also causes SPC not to terminate an argument.
4391 Value is zero unless a line was finished
4392 and the command on that line reported an error. */
4395 do_spec_1 (spec, inswitch, soft_matched_part)
4398 const char *soft_matched_part;
4400 const char *p = spec;
4407 /* If substituting a switch, treat all chars like letters.
4408 Otherwise, NL, SPC, TAB and % are special. */
4409 switch (inswitch ? 'a' : c)
4412 /* End of line: finish any pending argument,
4413 then run the pending command if one has been started. */
4416 obstack_1grow (&obstack, 0);
4417 string = obstack_finish (&obstack);
4418 if (this_is_library_file)
4419 string = find_file (string);
4420 store_arg (string, delete_this_arg, this_is_output_file);
4421 if (this_is_output_file)
4422 outfiles[input_file_number] = string;
4426 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4428 /* A `|' before the newline means use a pipe here,
4429 but only if -pipe was specified.
4430 Otherwise, execute now and don't pass the `|' as an arg. */
4433 input_from_pipe = 1;
4440 set_collect_gcc_options ();
4442 if (argbuf_index > 0)
4448 /* Reinitialize for a new command, and for a new argument. */
4451 delete_this_arg = 0;
4452 this_is_output_file = 0;
4453 this_is_library_file = 0;
4454 input_from_pipe = 0;
4458 /* End any pending argument. */
4461 obstack_1grow (&obstack, 0);
4462 string = obstack_finish (&obstack);
4463 if (this_is_library_file)
4464 string = find_file (string);
4465 store_arg (string, delete_this_arg, this_is_output_file);
4466 if (this_is_output_file)
4467 outfiles[input_file_number] = string;
4471 obstack_1grow (&obstack, c);
4477 /* Space or tab ends an argument if one is pending. */
4480 obstack_1grow (&obstack, 0);
4481 string = obstack_finish (&obstack);
4482 if (this_is_library_file)
4483 string = find_file (string);
4484 store_arg (string, delete_this_arg, this_is_output_file);
4485 if (this_is_output_file)
4486 outfiles[input_file_number] = string;
4488 /* Reinitialize for a new argument. */
4490 delete_this_arg = 0;
4491 this_is_output_file = 0;
4492 this_is_library_file = 0;
4499 fatal ("invalid specification! Bug in cc");
4502 obstack_grow (&obstack, input_basename, basename_length);
4507 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4512 delete_this_arg = 2;
4515 /* Dump out the directories specified with LIBRARY_PATH,
4516 followed by the absolute directories
4517 that we search for startfiles. */
4520 struct prefix_list *pl = startfile_prefixes.plist;
4521 size_t bufsize = 100;
4522 char *buffer = (char *) xmalloc (bufsize);
4525 for (; pl; pl = pl->next)
4527 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4528 /* Used on systems which record the specified -L dirs
4529 and use them to search for dynamic linking. */
4530 /* Relative directories always come from -B,
4531 and it is better not to use them for searching
4532 at run time. In particular, stage1 loses. */
4533 if (!IS_ABSOLUTE_PATHNAME (pl->prefix))
4536 /* Try subdirectory if there is one. */
4537 if (multilib_dir != NULL
4538 || (pl->os_multilib && multilib_os_dir != NULL))
4540 const char *multi_dir;
4542 multi_dir = pl->os_multilib ? multilib_os_dir
4544 if (machine_suffix && multilib_dir)
4546 if (strlen (pl->prefix) + strlen (machine_suffix)
4548 bufsize = (strlen (pl->prefix)
4549 + strlen (machine_suffix)) * 2 + 1;
4550 buffer = (char *) xrealloc (buffer, bufsize);
4551 strcpy (buffer, pl->prefix);
4552 strcat (buffer, machine_suffix);
4553 if (is_directory (buffer, multilib_dir, 1))
4555 do_spec_1 ("-L", 0, NULL);
4556 #ifdef SPACE_AFTER_L_OPTION
4557 do_spec_1 (" ", 0, NULL);
4559 do_spec_1 (buffer, 1, NULL);
4560 do_spec_1 (multilib_dir, 1, NULL);
4561 /* Make this a separate argument. */
4562 do_spec_1 (" ", 0, NULL);
4565 if (!pl->require_machine_suffix)
4567 if (is_directory (pl->prefix, multi_dir, 1))
4569 do_spec_1 ("-L", 0, NULL);
4570 #ifdef SPACE_AFTER_L_OPTION
4571 do_spec_1 (" ", 0, NULL);
4573 do_spec_1 (pl->prefix, 1, NULL);
4574 do_spec_1 (multi_dir, 1, NULL);
4575 /* Make this a separate argument. */
4576 do_spec_1 (" ", 0, NULL);
4582 if (is_directory (pl->prefix, machine_suffix, 1))
4584 do_spec_1 ("-L", 0, NULL);
4585 #ifdef SPACE_AFTER_L_OPTION
4586 do_spec_1 (" ", 0, NULL);
4588 do_spec_1 (pl->prefix, 1, NULL);
4589 /* Remove slash from machine_suffix. */
4590 if (strlen (machine_suffix) >= bufsize)
4591 bufsize = strlen (machine_suffix) * 2 + 1;
4592 buffer = (char *) xrealloc (buffer, bufsize);
4593 strcpy (buffer, machine_suffix);
4594 idx = strlen (buffer);
4595 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4596 buffer[idx - 1] = 0;
4597 do_spec_1 (buffer, 1, NULL);
4598 /* Make this a separate argument. */
4599 do_spec_1 (" ", 0, NULL);
4602 if (!pl->require_machine_suffix)
4604 if (is_directory (pl->prefix, "", 1))
4606 do_spec_1 ("-L", 0, NULL);
4607 #ifdef SPACE_AFTER_L_OPTION
4608 do_spec_1 (" ", 0, NULL);
4610 /* Remove slash from pl->prefix. */
4611 if (strlen (pl->prefix) >= bufsize)
4612 bufsize = strlen (pl->prefix) * 2 + 1;
4613 buffer = (char *) xrealloc (buffer, bufsize);
4614 strcpy (buffer, pl->prefix);
4615 idx = strlen (buffer);
4616 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4617 buffer[idx - 1] = 0;
4618 do_spec_1 (buffer, 1, NULL);
4619 /* Make this a separate argument. */
4620 do_spec_1 (" ", 0, NULL);
4629 /* %efoo means report an error with `foo' as error message
4630 and don't execute any more commands for this file. */
4634 while (*p != 0 && *p != '\n')
4636 buf = (char *) alloca (p - q + 1);
4637 strncpy (buf, q, p - q);
4644 /* %nfoo means report a notice with `foo' on stderr. */
4648 while (*p != 0 && *p != '\n')
4650 buf = (char *) alloca (p - q + 1);
4651 strncpy (buf, q, p - q);
4653 notice ("%s\n", buf);
4663 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4664 defined, and it is not a directory, and it is
4665 writable, use it. Otherwise, treat this like any
4666 other temporary file. */
4668 if ((!save_temps_flag)
4669 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4670 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4672 obstack_grow (&obstack, HOST_BIT_BUCKET,
4673 strlen (HOST_BIT_BUCKET));
4674 delete_this_arg = 0;
4679 goto create_temp_file;
4683 obstack_1grow (&obstack, '-');
4684 delete_this_arg = 0;
4687 /* consume suffix */
4688 while (*p == '.' || ISALPHA ((unsigned char) *p))
4690 if (p[0] == '%' && p[1] == 'O')
4695 goto create_temp_file;
4699 /* consume suffix */
4700 while (*p == '.' || ISALPHA ((unsigned char) *p))
4702 if (p[0] == '%' && p[1] == 'O')
4707 goto create_temp_file;
4713 struct temp_name *t;
4715 const char *suffix = p;
4716 char *saved_suffix = NULL;
4718 while (*p == '.' || ISALPHA ((unsigned char) *p))
4720 suffix_length = p - suffix;
4721 if (p[0] == '%' && p[1] == 'O')
4724 /* We don't support extra suffix characters after %O. */
4725 if (*p == '.' || ISALPHA ((unsigned char) *p))
4727 if (suffix_length == 0)
4728 suffix = TARGET_OBJECT_SUFFIX;
4732 = (char *) xmalloc (suffix_length
4733 + strlen (TARGET_OBJECT_SUFFIX));
4734 strncpy (saved_suffix, suffix, suffix_length);
4735 strcpy (saved_suffix + suffix_length,
4736 TARGET_OBJECT_SUFFIX);
4738 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4741 /* If the input_filename has the same suffix specified
4742 for the %g, %u, or %U, and -save-temps is specified,
4743 we could end up using that file as an intermediate
4744 thus clobbering the user's source file (.e.g.,
4745 gcc -save-temps foo.s would clobber foo.s with the
4746 output of cpp0). So check for this condition and
4747 generate a temp file as the intermediate. */
4749 if (save_temps_flag)
4751 temp_filename_length = basename_length + suffix_length;
4752 temp_filename = alloca (temp_filename_length + 1);
4753 strncpy ((char *) temp_filename, input_basename, basename_length);
4754 strncpy ((char *) temp_filename + basename_length, suffix,
4756 *((char *) temp_filename + temp_filename_length) = '\0';
4757 if (strcmp (temp_filename, input_filename) != 0)
4759 struct stat st_temp;
4761 /* Note, set_input() resets input_stat_set to 0. */
4762 if (input_stat_set == 0)
4764 input_stat_set = stat (input_filename, &input_stat);
4765 if (input_stat_set >= 0)
4769 /* If we have the stat for the input_filename
4770 and we can do the stat for the temp_filename
4771 then the they could still refer to the same
4772 file if st_dev/st_ino's are the same. */
4774 if (input_stat_set != 1
4775 || stat (temp_filename, &st_temp) < 0
4776 || input_stat.st_dev != st_temp.st_dev
4777 || input_stat.st_ino != st_temp.st_ino)
4779 temp_filename = save_string (temp_filename,
4780 temp_filename_length + 1);
4781 obstack_grow (&obstack, temp_filename,
4782 temp_filename_length);
4784 delete_this_arg = 0;
4790 /* See if we already have an association of %g/%u/%U and
4792 for (t = temp_names; t; t = t->next)
4793 if (t->length == suffix_length
4794 && strncmp (t->suffix, suffix, suffix_length) == 0
4795 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4798 /* Make a new association if needed. %u and %j
4800 if (t == 0 || c == 'u' || c == 'j')
4804 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
4805 t->next = temp_names;
4808 t->length = suffix_length;
4811 t->suffix = saved_suffix;
4812 saved_suffix = NULL;
4815 t->suffix = save_string (suffix, suffix_length);
4816 t->unique = (c == 'u' || c == 'U' || c == 'j');
4817 temp_filename = make_temp_file (t->suffix);
4818 temp_filename_length = strlen (temp_filename);
4819 t->filename = temp_filename;
4820 t->filename_length = temp_filename_length;
4824 free (saved_suffix);
4826 obstack_grow (&obstack, t->filename, t->filename_length);
4827 delete_this_arg = 1;
4833 obstack_grow (&obstack, input_filename, input_filename_length);
4839 struct prefix_list *pl = include_prefixes.plist;
4841 if (gcc_exec_prefix)
4843 do_spec_1 ("-iprefix", 1, NULL);
4844 /* Make this a separate argument. */
4845 do_spec_1 (" ", 0, NULL);
4846 do_spec_1 (gcc_exec_prefix, 1, NULL);
4847 do_spec_1 (" ", 0, NULL);
4850 if (target_system_root_changed ||
4851 (target_system_root && target_sysroot_hdrs_suffix))
4853 do_spec_1 ("-isysroot", 1, NULL);
4854 /* Make this a separate argument. */
4855 do_spec_1 (" ", 0, NULL);
4856 do_spec_1 (target_system_root, 1, NULL);
4857 if (target_sysroot_hdrs_suffix)
4858 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4859 do_spec_1 (" ", 0, NULL);
4862 for (; pl; pl = pl->next)
4864 do_spec_1 ("-isystem", 1, NULL);
4865 /* Make this a separate argument. */
4866 do_spec_1 (" ", 0, NULL);
4867 do_spec_1 (pl->prefix, 1, NULL);
4868 do_spec_1 (" ", 0, NULL);
4875 int max = n_infiles;
4876 max += lang_specific_extra_outfiles;
4878 for (i = 0; i < max; i++)
4880 store_arg (outfiles[i], 0, 0);
4885 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4890 this_is_library_file = 1;
4894 outfiles[input_file_number] = NULL;
4898 this_is_output_file = 1;
4903 int cur_index = argbuf_index;
4904 /* Handle the {...} following the %W. */
4907 p = handle_braces (p + 1);
4910 /* End any pending argument. */
4913 obstack_1grow (&obstack, 0);
4914 string = obstack_finish (&obstack);
4915 if (this_is_library_file)
4916 string = find_file (string);
4917 store_arg (string, delete_this_arg, this_is_output_file);
4918 if (this_is_output_file)
4919 outfiles[input_file_number] = string;
4922 /* If any args were output, mark the last one for deletion
4924 if (argbuf_index != cur_index)
4925 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4929 /* %x{OPTION} records OPTION for %X to output. */
4935 /* Skip past the option value and make a copy. */
4940 string = save_string (p1 + 1, p - p1 - 2);
4942 /* See if we already recorded this option. */
4943 for (i = 0; i < n_linker_options; i++)
4944 if (! strcmp (string, linker_options[i]))
4950 /* This option is new; add it. */
4951 add_linker_option (string, strlen (string));
4955 /* Dump out the options accumulated previously using %x. */
4957 for (i = 0; i < n_linker_options; i++)
4959 do_spec_1 (linker_options[i], 1, NULL);
4960 /* Make each accumulated option a separate argument. */
4961 do_spec_1 (" ", 0, NULL);
4965 /* Dump out the options accumulated previously using -Wa,. */
4967 for (i = 0; i < n_assembler_options; i++)
4969 do_spec_1 (assembler_options[i], 1, NULL);
4970 /* Make each accumulated option a separate argument. */
4971 do_spec_1 (" ", 0, NULL);
4975 /* Dump out the options accumulated previously using -Wp,. */
4977 for (i = 0; i < n_preprocessor_options; i++)
4979 do_spec_1 (preprocessor_options[i], 1, NULL);
4980 /* Make each accumulated option a separate argument. */
4981 do_spec_1 (" ", 0, NULL);
4985 /* Here are digits and numbers that just process
4986 a certain constant string as a spec. */
4989 value = do_spec_1 (cc1_spec, 0, NULL);
4995 value = do_spec_1 (cc1plus_spec, 0, NULL);
5001 value = do_spec_1 (asm_spec, 0, NULL);
5007 value = do_spec_1 (asm_final_spec, 0, NULL);
5014 const char *const spec
5015 = (input_file_compiler->cpp_spec
5016 ? input_file_compiler->cpp_spec
5018 value = do_spec_1 (spec, 0, NULL);
5025 value = do_spec_1 (endfile_spec, 0, NULL);
5031 value = do_spec_1 (link_spec, 0, NULL);
5037 value = do_spec_1 (lib_spec, 0, NULL);
5043 value = do_spec_1 (libgcc_spec, 0, NULL);
5049 if (multilib_dir && strcmp (multilib_dir, ".") != 0)
5055 len = strlen (multilib_dir);
5056 obstack_blank (&obstack, len + 1);
5057 p = obstack_next_free (&obstack) - (len + 1);
5060 for (q = multilib_dir; *q ; ++q, ++p)
5061 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
5066 /* We assume there is a directory
5067 separator at the end of this string. */
5068 if (target_system_root)
5070 obstack_grow (&obstack, target_system_root,
5071 strlen (target_system_root));
5072 if (target_sysroot_suffix)
5073 obstack_grow (&obstack, target_sysroot_suffix,
5074 strlen (target_sysroot_suffix));
5079 value = do_spec_1 (startfile_spec, 0, NULL);
5084 /* Here we define characters other than letters and digits. */
5087 p = handle_braces (p);
5093 p = handle_spec_function (p);
5099 obstack_1grow (&obstack, '%');
5106 while (p[len] && p[len] != ' ' && p[len] != '%')
5108 suffix_subst = save_string (p - 1, len + 1);
5113 /* Henceforth ignore the option(s) matching the pattern
5118 int have_wildcard = 0;
5121 while (p[len] && p[len] != ' ' && p[len] != '\t')
5124 if (p[len-1] == '*')
5127 for (i = 0; i < n_switches; i++)
5128 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5129 && (have_wildcard || switches[i].part1[len] == '\0'))
5131 switches[i].live_cond = SWITCH_IGNORE;
5132 switches[i].validated = 1;
5140 if (soft_matched_part)
5142 do_spec_1 (soft_matched_part, 1, NULL);
5143 do_spec_1 (" ", 0, NULL);
5146 /* Catch the case where a spec string contains something like
5147 '%{foo:%*}'. ie there is no * in the pattern on the left
5148 hand side of the :. */
5149 error ("spec failure: '%%*' has not been initialized by pattern match");
5152 /* Process a string found as the value of a spec given by name.
5153 This feature allows individual machine descriptions
5154 to add and use their own specs.
5155 %[...] modifies -D options the way %P does;
5156 %(...) uses the spec unmodified. */
5158 error ("warning: use of obsolete %%[ operator in specs");
5161 const char *name = p;
5162 struct spec_list *sl;
5165 /* The string after the S/P is the name of a spec that is to be
5167 while (*p && *p != ')' && *p != ']')
5170 /* See if it's in the list. */
5171 for (len = p - name, sl = specs; sl; sl = sl->next)
5172 if (sl->name_len == len && !strncmp (sl->name, name, len))
5174 name = *(sl->ptr_spec);
5176 notice ("Processing spec %c%s%c, which is '%s'\n",
5177 c, sl->name, (c == '(') ? ')' : ']', name);
5186 value = do_spec_1 (name, 0, NULL);
5192 char *x = (char *) alloca (strlen (name) * 2 + 1);
5194 const char *y = name;
5197 /* Copy all of NAME into BUF, but put __ after
5198 every -D and at the end of each arg. */
5201 if (! strncmp (y, "-D", 2))
5212 && (*y == ' ' || *y == '\t' || *y == '='
5213 || *y == '}' || *y == 0))
5226 value = do_spec_1 (buf, 0, NULL);
5232 /* Discard the closing paren or bracket. */
5239 error ("spec failure: unrecognized spec option '%c'", c);
5245 /* Backslash: treat next character as ordinary. */
5250 /* Ordinary character: put it into the current argument. */
5251 obstack_1grow (&obstack, c);
5255 /* End of string. If we are processing a spec function, we need to
5256 end any pending argument. */
5257 if (processing_spec_function && arg_going)
5259 obstack_1grow (&obstack, 0);
5260 string = obstack_finish (&obstack);
5261 if (this_is_library_file)
5262 string = find_file (string);
5263 store_arg (string, delete_this_arg, this_is_output_file);
5264 if (this_is_output_file)
5265 outfiles[input_file_number] = string;
5272 /* Look up a spec function. */
5274 static const struct spec_function *
5275 lookup_spec_function (name)
5278 static const struct spec_function * const spec_function_tables[] =
5280 static_spec_functions,
5281 lang_specific_spec_functions,
5283 const struct spec_function *sf;
5286 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
5288 for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
5289 if (strcmp (sf->name, name) == 0)
5296 /* Evaluate a spec function. */
5299 eval_spec_function (func, args)
5300 const char *func, *args;
5302 const struct spec_function *sf;
5303 const char *funcval;
5305 /* Saved spec processing context. */
5306 int save_argbuf_index;
5307 int save_argbuf_length;
5308 const char **save_argbuf;
5311 int save_delete_this_arg;
5312 int save_this_is_output_file;
5313 int save_this_is_library_file;
5314 int save_input_from_pipe;
5315 const char *save_suffix_subst;
5318 sf = lookup_spec_function (func);
5320 fatal ("unknown spec function `%s'", func);
5322 /* Push the spec processing context. */
5323 save_argbuf_index = argbuf_index;
5324 save_argbuf_length = argbuf_length;
5325 save_argbuf = argbuf;
5327 save_arg_going = arg_going;
5328 save_delete_this_arg = delete_this_arg;
5329 save_this_is_output_file = this_is_output_file;
5330 save_this_is_library_file = this_is_library_file;
5331 save_input_from_pipe = input_from_pipe;
5332 save_suffix_subst = suffix_subst;
5334 /* Create a new spec processing context, and build the function
5338 if (do_spec_2 (args) < 0)
5339 fatal ("error in args to spec function `%s'", func);
5341 /* argbuf_index is an index for the next argument to be inserted, and
5342 so contains the count of the args already inserted. */
5344 funcval = (*sf->func) (argbuf_index, argbuf);
5346 /* Pop the spec processing context. */
5347 argbuf_index = save_argbuf_index;
5348 argbuf_length = save_argbuf_length;
5350 argbuf = save_argbuf;
5352 arg_going = save_arg_going;
5353 delete_this_arg = save_delete_this_arg;
5354 this_is_output_file = save_this_is_output_file;
5355 this_is_library_file = save_this_is_library_file;
5356 input_from_pipe = save_input_from_pipe;
5357 suffix_subst = save_suffix_subst;
5362 /* Handle a spec function call of the form:
5366 ARGS is processed as a spec in a separate context and split into an
5367 argument vector in the normal fashion. The function returns a string
5368 containing a spec which we then process in the caller's context, or
5369 NULL if no processing is required. */
5372 handle_spec_function (p)
5376 const char *endp, *funcval;
5379 processing_spec_function++;
5381 /* Get the function name. */
5382 for (endp = p; *endp != '\0'; endp++)
5384 if (*endp == '(') /* ) */
5386 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5387 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5388 fatal ("malformed spec function name");
5390 if (*endp != '(') /* ) */
5391 fatal ("no arguments for spec function");
5392 func = save_string (p, endp - p);
5395 /* Get the arguments. */
5396 for (count = 0; *endp != '\0'; endp++)
5405 else if (*endp == '(') /* ) */
5410 fatal ("malformed spec function arguments");
5411 args = save_string (p, endp - p);
5414 /* p now points to just past the end of the spec function expression. */
5416 funcval = eval_spec_function (func, args);
5417 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5423 processing_spec_function--;
5428 /* Inline subroutine of handle_braces. Returns true if the current
5429 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5431 input_suffix_matches (atom, end_atom)
5433 const char *end_atom;
5435 return (input_suffix
5436 && !strncmp (input_suffix, atom, end_atom - atom)
5437 && input_suffix[end_atom - atom] == '\0');
5440 /* Inline subroutine of handle_braces. Returns true if a switch
5441 matching the atom bracketed by ATOM and END_ATOM appeared on the
5444 switch_matches (atom, end_atom, starred)
5446 const char *end_atom;
5450 int len = end_atom - atom;
5451 int plen = starred ? len : -1;
5453 for (i = 0; i < n_switches; i++)
5454 if (!strncmp (switches[i].part1, atom, len)
5455 && (starred || switches[i].part1[len] == '\0')
5456 && check_live_switch (i, plen))
5462 /* Inline subroutine of handle_braces. Mark all of the switches which
5463 match ATOM (extends to END_ATOM; STARRED indicates whether there
5464 was a star after the atom) for later processing. */
5466 mark_matching_switches (atom, end_atom, starred)
5468 const char *end_atom;
5472 int len = end_atom - atom;
5473 int plen = starred ? len : -1;
5475 for (i = 0; i < n_switches; i++)
5476 if (!strncmp (switches[i].part1, atom, len)
5477 && (starred || switches[i].part1[len] == '\0')
5478 && check_live_switch (i, plen))
5479 switches[i].ordering = 1;
5482 /* Inline subroutine of handle_braces. Process all the currently
5483 marked switches through give_switch, and clear the marks. */
5485 process_marked_switches ()
5489 for (i = 0; i < n_switches; i++)
5490 if (switches[i].ordering == 1)
5492 switches[i].ordering = 0;
5497 /* Handle a %{ ... } construct. P points just inside the leading {.
5498 Returns a pointer one past the end of the brace block, or 0
5499 if we call do_spec_1 and that returns -1. */
5505 const char *atom, *end_atom;
5506 const char *d_atom = NULL, *d_end_atom = NULL;
5513 bool a_must_be_last = false;
5514 bool ordered_set = false;
5515 bool disjunct_set = false;
5516 bool disj_matched = false;
5517 bool disj_starred = true;
5518 bool n_way_choice = false;
5519 bool n_way_matched = false;
5521 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5528 /* Scan one "atom" (S in the description above of %{}, possibly
5529 with !, ., or * modifiers). */
5530 a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5534 p++, a_is_negated = true;
5538 p++, a_is_suffix = true;
5541 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5542 || *p == ',' || *p == '.' || *p == '@')
5547 p++, a_is_starred = 1;
5550 if (*p == '&' || *p == '}')
5552 /* Substitute the switch(es) indicated by the current atom. */
5554 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5555 || atom == end_atom)
5558 mark_matching_switches (atom, end_atom, a_is_starred);
5561 process_marked_switches ();
5563 else if (*p == '|' || *p == ':')
5565 /* Substitute some text if the current atom appears as a switch
5567 disjunct_set = true;
5571 if (atom == end_atom)
5573 if (!n_way_choice || disj_matched || *p == '|'
5574 || a_is_negated || a_is_suffix || a_is_starred)
5577 /* An empty term may appear as the last choice of an
5578 N-way choice set; it means "otherwise". */
5579 a_must_be_last = true;
5580 disj_matched = !n_way_matched;
5581 disj_starred = false;
5585 if (a_is_suffix && a_is_starred)
5589 disj_starred = false;
5591 /* Don't bother testing this atom if we already have a
5593 if (!disj_matched && !n_way_matched)
5596 a_matched = input_suffix_matches (atom, end_atom);
5598 a_matched = switch_matches (atom, end_atom, a_is_starred);
5600 if (a_matched != a_is_negated)
5602 disj_matched = true;
5604 d_end_atom = end_atom;
5611 /* Found the body, that is, the text to substitute if the
5612 current disjunction matches. */
5613 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5614 disj_matched && !n_way_matched);
5618 /* If we have an N-way choice, reset state for the next
5622 n_way_choice = true;
5623 n_way_matched |= disj_matched;
5624 disj_matched = false;
5625 disj_starred = true;
5626 d_atom = d_end_atom = NULL;
5633 while (*p++ != '}');
5640 /* Subroutine of handle_braces. Scan and process a brace substitution body
5641 (X in the description of %{} syntax). P points one past the colon;
5642 ATOM and END_ATOM bracket the first atom which was found to be true
5643 (present) in the current disjunction; STARRED indicates whether all
5644 the atoms in the current disjunction were starred (for syntax validation);
5645 MATCHED indicates whether the disjunction matched or not, and therefore
5646 whether or not the body is to be processed through do_spec_1 or just
5647 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5651 process_brace_body (p, atom, end_atom, starred, matched)
5654 const char *end_atom;
5658 const char *body, *end_body;
5659 unsigned int nesting_level;
5660 bool have_subst = false;
5662 /* Locate the closing } or ;, honoring nested braces.
5663 Trim trailing whitespace. */
5672 if (!--nesting_level)
5675 else if (*p == ';' && nesting_level == 1)
5677 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5679 else if (*p == '\0')
5685 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5688 if (have_subst && !starred)
5693 /* Copy the substitution body to permanent storage and execute it.
5694 If have_subst is false, this is a simple matter of running the
5695 body through do_spec_1... */
5696 char *string = save_string (body, end_body - body);
5699 if (do_spec_1 (string, 0, NULL) < 0)
5704 /* ... but if have_subst is true, we have to process the
5705 body once for each matching switch, with %* set to the
5706 variant part of the switch. */
5707 unsigned int hard_match_len = end_atom - atom;
5710 for (i = 0; i < n_switches; i++)
5711 if (!strncmp (switches[i].part1, atom, hard_match_len)
5712 && check_live_switch (i, hard_match_len))
5714 if (do_spec_1 (string, 0,
5715 &switches[i].part1[hard_match_len]) < 0)
5717 /* Pass any arguments this switch has. */
5719 suffix_subst = NULL;
5727 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5728 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5729 spec, or -1 if either exact match or %* is used.
5731 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5732 whose value does not begin with "no-" is obsoleted by the same value
5733 with the "no-", similarly for a switch with the "no-" prefix. */
5736 check_live_switch (switchnum, prefix_length)
5740 const char *name = switches[switchnum].part1;
5743 /* In the common case of {<at-most-one-letter>*}, a negating
5744 switch would always match, so ignore that case. We will just
5745 send the conflicting switches to the compiler phase. */
5746 if (prefix_length >= 0 && prefix_length <= 1)
5749 /* If we already processed this switch and determined if it was
5750 live or not, return our past determination. */
5751 if (switches[switchnum].live_cond != 0)
5752 return switches[switchnum].live_cond > 0;
5754 /* Now search for duplicate in a manner that depends on the name. */
5758 for (i = switchnum + 1; i < n_switches; i++)
5759 if (switches[i].part1[0] == 'O')
5761 switches[switchnum].validated = 1;
5762 switches[switchnum].live_cond = SWITCH_FALSE;
5767 case 'W': case 'f': case 'm':
5768 if (! strncmp (name + 1, "no-", 3))
5770 /* We have Xno-YYY, search for XYYY. */
5771 for (i = switchnum + 1; i < n_switches; i++)
5772 if (switches[i].part1[0] == name[0]
5773 && ! strcmp (&switches[i].part1[1], &name[4]))
5775 switches[switchnum].validated = 1;
5776 switches[switchnum].live_cond = SWITCH_FALSE;
5782 /* We have XYYY, search for Xno-YYY. */
5783 for (i = switchnum + 1; i < n_switches; i++)
5784 if (switches[i].part1[0] == name[0]
5785 && switches[i].part1[1] == 'n'
5786 && switches[i].part1[2] == 'o'
5787 && switches[i].part1[3] == '-'
5788 && !strcmp (&switches[i].part1[4], &name[1]))
5790 switches[switchnum].validated = 1;
5791 switches[switchnum].live_cond = SWITCH_FALSE;
5798 /* Otherwise the switch is live. */
5799 switches[switchnum].live_cond = SWITCH_LIVE;
5803 /* Pass a switch to the current accumulating command
5804 in the same form that we received it.
5805 SWITCHNUM identifies the switch; it is an index into
5806 the vector of switches gcc received, which is `switches'.
5807 This cannot fail since it never finishes a command line.
5809 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5812 give_switch (switchnum, omit_first_word)
5814 int omit_first_word;
5816 if (switches[switchnum].live_cond == SWITCH_IGNORE)
5819 if (!omit_first_word)
5821 do_spec_1 ("-", 0, NULL);
5822 do_spec_1 (switches[switchnum].part1, 1, NULL);
5825 if (switches[switchnum].args != 0)
5828 for (p = switches[switchnum].args; *p; p++)
5830 const char *arg = *p;
5832 do_spec_1 (" ", 0, NULL);
5835 unsigned length = strlen (arg);
5838 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5839 if (arg[length] == '.')
5841 ((char *)arg)[length] = 0;
5845 do_spec_1 (arg, 1, NULL);
5847 ((char *)arg)[length] = '.';
5848 do_spec_1 (suffix_subst, 1, NULL);
5851 do_spec_1 (arg, 1, NULL);
5855 do_spec_1 (" ", 0, NULL);
5856 switches[switchnum].validated = 1;
5859 /* Search for a file named NAME trying various prefixes including the
5860 user's -B prefix and some standard ones.
5861 Return the absolute file name found. If nothing is found, return NAME. */
5869 /* Try multilib_dir if it is defined. */
5870 if (multilib_os_dir != NULL)
5872 newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
5874 /* If we don't find it in the multi library dir, then fall
5875 through and look for it in the normal places. */
5876 if (newname != NULL)
5880 newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
5881 return newname ? newname : name;
5884 /* Determine whether a directory exists. If LINKER, return 0 for
5885 certain fixed names not needed by the linker. If not LINKER, it is
5886 only important to return 0 if the host machine has a small ARG_MAX
5890 is_directory (path1, path2, linker)
5895 int len1 = strlen (path1);
5896 int len2 = strlen (path2);
5897 char *path = (char *) alloca (3 + len1 + len2);
5901 #ifndef SMALL_ARG_MAX
5906 /* Construct the path from the two parts. Ensure the string ends with "/.".
5907 The resulting path will be a directory even if the given path is a
5909 memcpy (path, path1, len1);
5910 memcpy (path + len1, path2, len2);
5911 cp = path + len1 + len2;
5912 if (!IS_DIR_SEPARATOR (cp[-1]))
5913 *cp++ = DIR_SEPARATOR;
5917 /* Exclude directories that the linker is known to search. */
5920 && strcmp (path, concat (dir_separator_str, "lib",
5921 dir_separator_str, ".", NULL)) == 0)
5923 && strcmp (path, concat (dir_separator_str, "usr",
5924 dir_separator_str, "lib",
5925 dir_separator_str, ".", NULL)) == 0)))
5928 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5931 /* Set up the various global variables to indicate that we're processing
5932 the input file named FILENAME. */
5935 set_input (filename)
5936 const char *filename;
5940 input_filename = filename;
5941 input_filename_length = strlen (input_filename);
5943 input_basename = input_filename;
5944 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5945 /* Skip drive name so 'x:foo' is handled properly. */
5946 if (input_basename[1] == ':')
5947 input_basename += 2;
5949 for (p = input_basename; *p; p++)
5950 if (IS_DIR_SEPARATOR (*p))
5951 input_basename = p + 1;
5953 /* Find a suffix starting with the last period,
5954 and set basename_length to exclude that suffix. */
5955 basename_length = strlen (input_basename);
5956 suffixed_basename_length = basename_length;
5957 p = input_basename + basename_length;
5958 while (p != input_basename && *p != '.')
5960 if (*p == '.' && p != input_basename)
5962 basename_length = p - input_basename;
5963 input_suffix = p + 1;
5968 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5969 we will need to do a stat on the input_filename. The
5970 INPUT_STAT_SET signals that the stat is needed. */
5974 /* On fatal signals, delete all the temporary files. */
5977 fatal_error (signum)
5980 signal (signum, SIG_DFL);
5981 delete_failure_queue ();
5982 delete_temp_files ();
5983 /* Get the same signal again, this time not handled,
5984 so its normal effect occurs. */
5985 kill (getpid (), signum);
5988 extern int main PARAMS ((int, const char *const *));
5993 const char *const *argv;
5997 int linker_was_run = 0;
5998 int num_linker_inputs = 0;
5999 char *explicit_link_files;
6002 struct user_specs *uptr;
6004 p = argv[0] + strlen (argv[0]);
6005 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6009 xmalloc_set_program_name (programname);
6011 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6012 /* Perform host dependent initialization when needed. */
6013 GCC_DRIVER_HOST_INITIALIZATION;
6016 gcc_init_libintl ();
6018 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6019 signal (SIGINT, fatal_error);
6021 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6022 signal (SIGHUP, fatal_error);
6024 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6025 signal (SIGTERM, fatal_error);
6027 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6028 signal (SIGPIPE, fatal_error);
6031 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6032 receive the signal. A different setting is inheritable */
6033 signal (SIGCHLD, SIG_DFL);
6036 /* Allocate the argument vector. */
6039 obstack_init (&obstack);
6041 /* Build multilib_select, et. al from the separate lines that make up each
6042 multilib selection. */
6044 const char *const *q = multilib_raw;
6047 obstack_init (&multilib_obstack);
6048 while ((p = *q++) != (char *) 0)
6049 obstack_grow (&multilib_obstack, p, strlen (p));
6051 obstack_1grow (&multilib_obstack, 0);
6052 multilib_select = obstack_finish (&multilib_obstack);
6054 q = multilib_matches_raw;
6055 while ((p = *q++) != (char *) 0)
6056 obstack_grow (&multilib_obstack, p, strlen (p));
6058 obstack_1grow (&multilib_obstack, 0);
6059 multilib_matches = obstack_finish (&multilib_obstack);
6061 q = multilib_exclusions_raw;
6062 while ((p = *q++) != (char *) 0)
6063 obstack_grow (&multilib_obstack, p, strlen (p));
6065 obstack_1grow (&multilib_obstack, 0);
6066 multilib_exclusions = obstack_finish (&multilib_obstack);
6069 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6072 obstack_1grow (&multilib_obstack, ' ');
6073 obstack_grow (&multilib_obstack,
6074 multilib_defaults_raw[i],
6075 strlen (multilib_defaults_raw[i]));
6079 obstack_1grow (&multilib_obstack, 0);
6080 multilib_defaults = obstack_finish (&multilib_obstack);
6083 /* Set up to remember the pathname of gcc and any options
6084 needed for collect. We use argv[0] instead of programname because
6085 we need the complete pathname. */
6086 obstack_init (&collect_obstack);
6087 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6088 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6089 putenv (obstack_finish (&collect_obstack));
6091 #ifdef INIT_ENVIRONMENT
6092 /* Set up any other necessary machine specific environment variables. */
6093 putenv (INIT_ENVIRONMENT);
6096 /* Make a table of what switches there are (switches, n_switches).
6097 Make a table of specified input files (infiles, n_infiles).
6098 Decode switches that are handled locally. */
6100 process_command (argc, argv);
6102 /* Initialize the vector of specs to just the default.
6103 This means one element containing 0s, as a terminator. */
6105 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
6106 memcpy ((char *) compilers, (char *) default_compilers,
6107 sizeof default_compilers);
6108 n_compilers = n_default_compilers;
6110 /* Read specs from a file if there is one. */
6112 machine_suffix = concat (spec_machine, dir_separator_str,
6113 spec_version, dir_separator_str, NULL);
6114 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6116 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
6117 /* Read the specs file unless it is a default one. */
6118 if (specs_file != 0 && strcmp (specs_file, "specs"))
6119 read_specs (specs_file, TRUE);
6123 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6124 for any override of as, ld and libraries. */
6125 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6126 + strlen (just_machine_suffix)
6127 + sizeof ("specs"));
6129 strcpy (specs_file, standard_exec_prefix);
6130 strcat (specs_file, just_machine_suffix);
6131 strcat (specs_file, "specs");
6132 if (access (specs_file, R_OK) == 0)
6133 read_specs (specs_file, TRUE);
6135 /* Process any configure-time defaults specified for the command line
6136 options, via OPTION_DEFAULT_SPECS. */
6137 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6138 do_option_spec (option_default_specs[i].name,
6139 option_default_specs[i].spec);
6141 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6142 of the command line. */
6144 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6145 do_self_spec (driver_self_specs[i]);
6147 /* If not cross-compiling, look for executables in the standard
6149 if (*cross_compile == '0')
6151 if (*md_exec_prefix)
6153 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6154 PREFIX_PRIORITY_LAST, 0, NULL, 0);
6158 /* Process sysroot_suffix_spec. */
6159 if (*sysroot_suffix_spec != 0
6160 && do_spec_2 (sysroot_suffix_spec) == 0)
6162 if (argbuf_index > 1)
6163 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC.");
6164 else if (argbuf_index == 1)
6165 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6168 /* Process sysroot_hdrs_suffix_spec. */
6169 if (*sysroot_hdrs_suffix_spec != 0
6170 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6172 if (argbuf_index > 1)
6173 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC.");
6174 else if (argbuf_index == 1)
6175 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6178 /* Look for startfiles in the standard places. */
6179 if (*startfile_prefix_spec != 0
6180 && do_spec_2 (startfile_prefix_spec) == 0
6181 && do_spec_1 (" ", 0, NULL) == 0)
6184 for (ndx = 0; ndx < argbuf_index; ndx++)
6185 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6186 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6188 /* We should eventually get rid of all these and stick to
6189 startfile_prefix_spec exclusively. */
6190 else if (*cross_compile == '0' || target_system_root)
6192 if (*md_exec_prefix)
6193 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
6194 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6196 if (*md_startfile_prefix)
6197 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6198 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6200 if (*md_startfile_prefix_1)
6201 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6202 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6204 /* If standard_startfile_prefix is relative, base it on
6205 standard_exec_prefix. This lets us move the installed tree
6206 as a unit. If GCC_EXEC_PREFIX is defined, base
6207 standard_startfile_prefix on that as well. */
6208 if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix))
6209 add_sysrooted_prefix (&startfile_prefixes,
6210 standard_startfile_prefix, "BINUTILS",
6211 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6214 if (gcc_exec_prefix)
6215 add_prefix (&startfile_prefixes,
6216 concat (gcc_exec_prefix, machine_suffix,
6217 standard_startfile_prefix, NULL),
6218 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6219 add_prefix (&startfile_prefixes,
6220 concat (standard_exec_prefix,
6222 standard_startfile_prefix, NULL),
6223 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6226 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1,
6227 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6228 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2,
6229 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6230 #if 0 /* Can cause surprises, and one can use -B./ instead. */
6231 add_prefix (&startfile_prefixes, "./", NULL,
6232 PREFIX_PRIORITY_LAST, 1, NULL, 0);
6236 /* Process any user specified specs in the order given on the command
6238 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6240 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6242 read_specs (filename ? filename : uptr->filename, FALSE);
6245 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6246 if (gcc_exec_prefix)
6247 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6248 spec_version, dir_separator_str, NULL);
6250 /* Now we have the specs.
6251 Set the `valid' bits for switches that match anything in any spec. */
6253 validate_all_switches ();
6255 /* Now that we have the switches and the specs, set
6256 the subdirectory based on the options. */
6257 set_multilib_dir ();
6259 /* Warn about any switches that no pass was interested in. */
6261 for (i = 0; (int) i < n_switches; i++)
6262 if (! switches[i].validated)
6263 error ("unrecognized option `-%s'", switches[i].part1);
6265 /* Obey some of the options. */
6267 if (print_search_dirs)
6269 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6270 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6271 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6275 if (print_file_name)
6277 printf ("%s\n", find_file (print_file_name));
6281 if (print_prog_name)
6283 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6284 printf ("%s\n", (newname ? newname : print_prog_name));
6288 if (print_multi_lib)
6290 print_multilib_info ();
6294 if (print_multi_directory)
6296 if (multilib_dir == NULL)
6299 printf ("%s\n", multilib_dir);
6303 if (print_multi_os_directory)
6305 if (multilib_os_dir == NULL)
6308 printf ("%s\n", multilib_os_dir);
6312 if (target_help_flag)
6314 /* Print if any target specific options. */
6316 /* We do not exit here. Instead we have created a fake input file
6317 called 'target-dummy' which needs to be compiled, and we pass this
6318 on to the various sub-processes, along with the --target-help
6322 if (print_help_list)
6328 printf (_("\nFor bug reporting instructions, please see:\n"));
6329 printf ("%s.\n", bug_report_url);
6334 /* We do not exit here. Instead we have created a fake input file
6335 called 'help-dummy' which needs to be compiled, and we pass this
6336 on the various sub-processes, along with the --help switch. */
6344 notice ("Configured with: %s\n", configuration_arguments);
6346 #ifdef THREAD_MODEL_SPEC
6347 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6348 but there's no point in doing all this processing just to get
6349 thread_model back. */
6350 obstack_init (&obstack);
6351 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6352 obstack_1grow (&obstack, '\0');
6353 thrmod = obstack_finish (&obstack);
6355 thrmod = thread_model;
6358 notice ("Thread model: %s\n", thrmod);
6360 /* compiler_version is truncated at the first space when initialized
6361 from version string, so truncate version_string at the first space
6362 before comparing. */
6363 for (n = 0; version_string[n]; n++)
6364 if (version_string[n] == ' ')
6367 if (! strncmp (version_string, compiler_version, n)
6368 && compiler_version[n] == 0)
6369 notice ("gcc version %s\n", version_string);
6371 notice ("gcc driver version %s executing gcc version %s\n",
6372 version_string, compiler_version);
6378 if (n_infiles == added_libraries)
6379 fatal ("no input files");
6381 /* Make a place to record the compiler output file names
6382 that correspond to the input files. */
6385 i += lang_specific_extra_outfiles;
6386 outfiles = (const char **) xcalloc (i, sizeof (char *));
6388 /* Record which files were specified explicitly as link input. */
6390 explicit_link_files = xcalloc (1, n_infiles);
6392 for (i = 0; (int) i < n_infiles; i++)
6394 int this_file_error = 0;
6396 /* Tell do_spec what to substitute for %i. */
6398 input_file_number = i;
6399 set_input (infiles[i].name);
6401 /* Use the same thing in %o, unless cp->spec says otherwise. */
6403 outfiles[i] = input_filename;
6405 /* Figure out which compiler from the file's suffix. */
6408 = lookup_compiler (infiles[i].name, input_filename_length,
6409 infiles[i].language);
6411 if (input_file_compiler)
6413 /* Ok, we found an applicable compiler. Run its spec. */
6415 if (input_file_compiler->spec[0] == '#')
6417 error ("%s: %s compiler not installed on this system",
6418 input_filename, &input_file_compiler->spec[1]);
6419 this_file_error = 1;
6423 value = do_spec (input_file_compiler->spec);
6425 this_file_error = 1;
6429 /* If this file's name does not contain a recognized suffix,
6430 record it as explicit linker input. */
6433 explicit_link_files[i] = 1;
6435 /* Clear the delete-on-failure queue, deleting the files in it
6436 if this compilation failed. */
6438 if (this_file_error)
6440 delete_failure_queue ();
6443 /* If this compilation succeeded, don't delete those files later. */
6444 clear_failure_queue ();
6447 /* Reset the output file name to the first input file name, for use
6448 with %b in LINK_SPEC on a target that prefers not to emit a.out
6451 set_input (infiles[0].name);
6453 if (error_count == 0)
6455 /* Make sure INPUT_FILE_NUMBER points to first available open
6457 input_file_number = n_infiles;
6458 if (lang_specific_pre_link ())
6462 /* Determine if there are any linker input files. */
6463 num_linker_inputs = 0;
6464 for (i = 0; (int) i < n_infiles; i++)
6465 if (explicit_link_files[i] || outfiles[i] != NULL)
6466 num_linker_inputs++;
6468 /* Run ld to link all the compiler output files. */
6470 if (num_linker_inputs > 0 && error_count == 0)
6472 int tmp = execution_count;
6474 /* We'll use ld if we can't find collect2. */
6475 if (! strcmp (linker_name_spec, "collect2"))
6477 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0);
6479 linker_name_spec = "ld";
6481 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6483 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6484 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6486 value = do_spec (link_command_spec);
6489 linker_was_run = (tmp != execution_count);
6492 /* If options said don't run linker,
6493 complain about input files to be given to the linker. */
6495 if (! linker_was_run && error_count == 0)
6496 for (i = 0; (int) i < n_infiles; i++)
6497 if (explicit_link_files[i])
6498 error ("%s: linker input file unused because linking not done",
6501 /* Delete some or all of the temporary files we made. */
6504 delete_failure_queue ();
6505 delete_temp_files ();
6507 if (print_help_list)
6509 printf (("\nFor bug reporting instructions, please see:\n"));
6510 printf ("%s\n", bug_report_url);
6513 return (signal_count != 0 ? 2
6514 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6518 /* Find the proper compilation spec for the file name NAME,
6519 whose length is LENGTH. LANGUAGE is the specified language,
6520 or 0 if this file is to be passed to the linker. */
6522 static struct compiler *
6523 lookup_compiler (name, length, language)
6526 const char *language;
6528 struct compiler *cp;
6530 /* If this was specified by the user to be a linker input, indicate that. */
6531 if (language != 0 && language[0] == '*')
6534 /* Otherwise, look for the language, if one is spec'd. */
6537 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6538 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6541 error ("language %s not recognized", language);
6545 /* Look for a suffix. */
6546 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6548 if (/* The suffix `-' matches only the file name `-'. */
6549 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6550 || (strlen (cp->suffix) < length
6551 /* See if the suffix matches the end of NAME. */
6552 && !strcmp (cp->suffix,
6553 name + length - strlen (cp->suffix))
6558 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6559 /* look again, but case-insensitively this time. */
6561 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6563 if (/* The suffix `-' matches only the file name `-'. */
6564 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6565 || (strlen (cp->suffix) < length
6566 /* See if the suffix matches the end of NAME. */
6567 && ((!strcmp (cp->suffix,
6568 name + length - strlen (cp->suffix))
6569 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6570 && !strcasecmp (cp->suffix,
6571 name + length - strlen (cp->suffix)))
6577 if (cp >= compilers)
6579 if (cp->spec[0] != '@')
6580 /* A non-alias entry: return it. */
6583 /* An alias entry maps a suffix to a language.
6584 Search for the language; pass 0 for NAME and LENGTH
6585 to avoid infinite recursion if language not found. */
6586 return lookup_compiler (NULL, 0, cp->spec + 1);
6592 save_string (s, len)
6596 char *result = xmalloc (len + 1);
6598 memcpy (result, s, len);
6604 pfatal_with_name (name)
6607 perror_with_name (name);
6608 delete_temp_files ();
6613 perror_with_name (name)
6616 error ("%s: %s", name, xstrerror (errno));
6620 pfatal_pexecute (errmsg_fmt, errmsg_arg)
6621 const char *errmsg_fmt;
6622 const char *errmsg_arg;
6626 int save_errno = errno;
6628 /* Space for trailing '\0' is in %s. */
6629 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
6630 sprintf (msg, errmsg_fmt, errmsg_arg);
6636 pfatal_with_name (errmsg_fmt);
6639 /* Output an error message and exit */
6644 fatal ("internal gcc abort");
6647 /* Output an error message and exit */
6650 fatal (const char *msgid, ...)
6654 va_start (ap, msgid);
6656 fprintf (stderr, "%s: ", programname);
6657 vfprintf (stderr, _(msgid), ap);
6659 fprintf (stderr, "\n");
6660 delete_temp_files ();
6665 error (const char *msgid, ...)
6669 va_start (ap, msgid);
6670 fprintf (stderr, "%s: ", programname);
6671 vfprintf (stderr, _(msgid), ap);
6674 fprintf (stderr, "\n");
6678 notice (const char *msgid, ...)
6682 va_start (ap, msgid);
6683 vfprintf (stderr, _(msgid), ap);
6688 validate_switches_from_spec (spec)
6691 const char *p = spec;
6694 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6695 /* We have a switch spec. */
6696 p = validate_switches (p + 1);
6700 validate_all_switches ()
6702 struct compiler *comp;
6703 struct spec_list *spec;
6705 for (comp = compilers; comp->spec; comp++)
6706 validate_switches_from_spec (comp->spec);
6708 /* Look through the linked list of specs read from the specs file. */
6709 for (spec = specs; spec; spec = spec->next)
6710 validate_switches_from_spec (*spec->ptr_spec);
6712 validate_switches_from_spec (link_command_spec);
6715 /* Look at the switch-name that comes after START
6716 and mark as valid all supplied switches that match it. */
6719 validate_switches (start)
6722 const char *p = start;
6726 bool suffix = false;
6727 bool starred = false;
6729 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6742 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
6743 || *p == ',' || *p == '.' || *p == '@')
6748 starred = true, p++;
6754 /* Mark all matching switches as valid. */
6755 for (i = 0; i < n_switches; i++)
6756 if (!strncmp (switches[i].part1, atom, len)
6757 && (starred || switches[i].part1[len] == 0))
6758 switches[i].validated = 1;
6762 if (*p && (p[-1] == '|' || p[-1] == '&'))
6765 if (*p && p[-1] == ':')
6767 while (*p && *p != ';' && *p != '}')
6772 if (*p == '{' || *p == '<')
6773 p = validate_switches (p+1);
6774 else if (p[0] == 'W' && p[1] == '{')
6775 p = validate_switches (p+2);
6782 if (*p && p[-1] == ';')
6796 static struct mdswitchstr *mdswitches;
6797 static int n_mdswitches;
6799 /* Check whether a particular argument was used. The first time we
6800 canonicalize the switches to keep only the ones we care about. */
6810 const char *replace;
6815 static struct mswitchstr *mswitches;
6816 static int n_mswitches;
6821 struct mswitchstr *matches;
6825 /* Break multilib_matches into the component strings of string
6826 and replacement string. */
6827 for (q = multilib_matches; *q != '\0'; q++)
6832 (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
6834 q = multilib_matches;
6844 matches[i].len = q - matches[i].str;
6846 matches[i].replace = ++q;
6847 while (*q != ';' && *q != '\0')
6853 matches[i].rep_len = q - matches[i].replace;
6859 /* Now build a list of the replacement string for switches that we care
6860 about. Make sure we allocate at least one entry. This prevents
6861 xmalloc from calling fatal, and prevents us from re-executing this
6864 = (struct mswitchstr *)
6865 xmalloc (sizeof (struct mswitchstr)
6866 * (n_mdswitches + (n_switches ? n_switches : 1)));
6867 for (i = 0; i < n_switches; i++)
6869 int xlen = strlen (switches[i].part1);
6870 for (j = 0; j < cnt; j++)
6871 if (xlen == matches[j].len
6872 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6874 mswitches[n_mswitches].str = matches[j].replace;
6875 mswitches[n_mswitches].len = matches[j].rep_len;
6876 mswitches[n_mswitches].replace = (char *) 0;
6877 mswitches[n_mswitches].rep_len = 0;
6883 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
6884 on the command line nor any options mutually incompatible with
6886 for (i = 0; i < n_mdswitches; i++)
6890 for (q = multilib_options; *q != '\0'; q++)
6896 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
6897 || strchr (" /", q[mdswitches[i].len]) == NULL)
6899 while (*q != ' ' && *q != '/' && *q != '\0')
6906 if (*q != ' ' && *q != '\0')
6908 while (*r != ' ' && *r != '\0')
6911 while (*q != ' ' && *q != '/' && *q != '\0')
6914 if (used_arg (r, q - r))
6919 mswitches[n_mswitches].str = mdswitches[i].str;
6920 mswitches[n_mswitches].len = mdswitches[i].len;
6921 mswitches[n_mswitches].replace = (char *) 0;
6922 mswitches[n_mswitches].rep_len = 0;
6935 for (i = 0; i < n_mswitches; i++)
6936 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6943 default_arg (p, len)
6949 for (i = 0; i < n_mdswitches; i++)
6950 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
6956 /* Work out the subdirectory to use based on the options. The format of
6957 multilib_select is a list of elements. Each element is a subdirectory
6958 name followed by a list of options followed by a semicolon. The format
6959 of multilib_exclusions is the same, but without the preceding
6960 directory. First gcc will check the exclusions, if none of the options
6961 beginning with an exclamation point are present, and all of the other
6962 options are present, then we will ignore this completely. Passing
6963 that, gcc will consider each multilib_select in turn using the same
6964 rules for matching the options. If a match is found, that subdirectory
6971 unsigned int this_path_len;
6972 const char *this_path, *this_arg;
6973 const char *start, *end;
6975 int ok, ndfltok, first;
6978 start = multilib_defaults;
6979 while (*start == ' ' || *start == '\t')
6981 while (*start != '\0')
6984 while (*start != ' ' && *start != '\t' && *start != '\0')
6986 while (*start == ' ' || *start == '\t')
6995 = (struct mdswitchstr *) xmalloc (sizeof (struct mdswitchstr)
6997 for (start = multilib_defaults; *start != '\0'; start = end + 1)
6999 while (*start == ' ' || *start == '\t')
7005 for (end = start + 1;
7006 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7009 obstack_grow (&multilib_obstack, start, end - start);
7010 obstack_1grow (&multilib_obstack, 0);
7011 mdswitches[i].str = obstack_finish (&multilib_obstack);
7012 mdswitches[i++].len = end - start;
7019 p = multilib_exclusions;
7022 /* Ignore newlines. */
7029 /* Check the arguments. */
7043 while (*p != ' ' && *p != ';')
7050 if (*this_arg != '!')
7058 ok = used_arg (this_arg, p - this_arg);
7073 p = multilib_select;
7076 /* Ignore newlines. */
7083 /* Get the initial path. */
7091 this_path_len = p - this_path;
7093 /* Check the arguments. */
7109 while (*p != ' ' && *p != ';')
7116 if (*this_arg != '!')
7124 /* If this is a default argument, we can just ignore it.
7125 This is true even if this_arg begins with '!'. Beginning
7126 with '!' does not mean that this argument is necessarily
7127 inappropriate for this library: it merely means that
7128 there is a more specific library which uses this
7129 argument. If this argument is a default, we need not
7130 consider that more specific library. */
7131 ok = used_arg (this_arg, p - this_arg);
7138 if (default_arg (this_arg, p - this_arg))
7147 if (this_path_len != 1
7148 || this_path[0] != '.')
7150 char *new_multilib_dir = xmalloc (this_path_len + 1);
7153 strncpy (new_multilib_dir, this_path, this_path_len);
7154 new_multilib_dir[this_path_len] = '\0';
7155 q = strchr (new_multilib_dir, ':');
7158 multilib_dir = new_multilib_dir;
7165 const char *q = this_path, *end = this_path + this_path_len;
7167 while (q < end && *q != ':')
7171 char *new_multilib_os_dir = xmalloc (end - q);
7172 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7173 new_multilib_os_dir[end - q - 1] = '\0';
7174 multilib_os_dir = new_multilib_os_dir;
7182 if (multilib_dir == NULL && multilib_os_dir != NULL
7183 && strcmp (multilib_os_dir, ".") == 0)
7185 free ((char *) multilib_os_dir);
7186 multilib_os_dir = NULL;
7188 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7189 multilib_os_dir = multilib_dir;
7192 /* Print out the multiple library subdirectory selection
7193 information. This prints out a series of lines. Each line looks
7194 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7195 required. Only the desired options are printed out, the negative
7196 matches. The options are print without a leading dash. There are
7197 no spaces to make it easy to use the information in the shell.
7198 Each subdirectory is printed only once. This assumes the ordering
7199 generated by the genmultilib script. Also, we leave out ones that match
7203 print_multilib_info ()
7205 const char *p = multilib_select;
7206 const char *last_path = 0, *this_path;
7208 unsigned int last_path_len = 0;
7213 /* Ignore newlines. */
7220 /* Get the initial path. */
7229 /* When --disable-multilib was used but target defines
7230 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7231 to find multilib_os_dir, so skip them from output. */
7232 if (this_path[0] == '.' && this_path[1] == ':')
7235 /* Check for matches with the multilib_exclusions. We don't bother
7236 with the '!' in either list. If any of the exclusion rules match
7237 all of its options with the select rule, we skip it. */
7239 const char *e = multilib_exclusions;
7240 const char *this_arg;
7245 /* Ignore newlines. */
7252 /* Check the arguments. */
7269 while (*e != ' ' && *e != ';')
7280 int len = e - this_arg;
7287 while (*q != ' ' && *q != ';')
7294 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
7295 default_arg (this_arg, e - this_arg))
7325 /* If this is a duplicate, skip it. */
7326 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len
7327 && ! strncmp (last_path, this_path, last_path_len));
7329 last_path = this_path;
7330 last_path_len = p - this_path;
7333 /* If this directory requires any default arguments, we can skip
7334 it. We will already have printed a directory identical to
7335 this one which does not require that default argument. */
7353 while (*q != ' ' && *q != ';')
7361 && default_arg (arg, q - arg))
7376 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7395 use_arg = *p != '!';
7400 while (*p != ' ' && *p != ';')
7415 /* If there are extra options, print them now. */
7416 if (multilib_extra && *multilib_extra)
7418 int print_at = TRUE;
7421 for (q = multilib_extra; *q != '\0'; q++)
7442 /* if-exists built-in spec function.
7444 Checks to see if the file specified by the absolute pathname in
7445 ARGS exists. Returns that pathname if found.
7447 The usual use for this function is to check for a library file
7448 (whose name has been expanded with %s). */
7451 if_exists_spec_function (argc, argv)
7455 /* Must have only one argument. */
7456 if (argc == 1 && IS_ABSOLUTE_PATHNAME (argv[0]) && ! access (argv[0], R_OK))
7462 /* if-exists-else built-in spec function.
7464 This is like if-exists, but takes an additional argument which
7465 is returned if the first argument does not exist. */
7468 if_exists_else_spec_function (argc, argv)
7472 /* Must have exactly two arguments. */
7476 if (IS_ABSOLUTE_PATHNAME (argv[0]) && ! access (argv[0], R_OK))