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 write "temp" files in source directory
216 and use the source file's name in them, and don't delete them. */
218 static int save_temps_flag
;
220 /* Nonzero means use pipes to communicate between subprocesses.
221 Overridden by either of the above two flags. */
223 static int use_pipes
;
225 /* The compiler version. */
227 static const char *compiler_version
;
229 /* The target version specified with -V */
231 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
233 /* The target machine specified with -b. */
235 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
237 /* Nonzero if cross-compiling.
238 When -b is used, the value comes from the `specs' file. */
241 static const char *cross_compile
= "1";
243 static const char *cross_compile
= "0";
246 #ifdef MODIFY_TARGET_NAME
248 /* Information on how to alter the target name based on a command-line
249 switch. The only case we support now is simply appending or deleting a
250 string to or from the end of the first part of the configuration name. */
252 static const struct modify_target
254 const char *const sw
;
255 const enum add_del
{ADD
, DELETE
} add_del
;
256 const char *const str
;
258 modify_target
[] = MODIFY_TARGET_NAME
;
261 /* The number of errors that have occurred; the link phase will not be
262 run if this is nonzero. */
263 static int error_count
= 0;
265 /* Greatest exit code of sub-processes that has been encountered up to
267 static int greatest_status
= 1;
269 /* This is the obstack which we use to allocate many strings. */
271 static struct obstack obstack
;
273 /* This is the obstack to build an environment variable to pass to
274 collect2 that describes all of the relevant switches of what to
275 pass the compiler in building the list of pointers to constructors
278 static struct obstack collect_obstack
;
280 /* These structs are used to collect resource usage information for
282 #ifdef HAVE_GETRUSAGE
283 static struct rusage rus
, prus
;
286 /* Forward declaration for prototypes. */
289 static void init_spec
PARAMS ((void));
290 static void store_arg
PARAMS ((const char *, int, int));
291 static char *load_specs
PARAMS ((const char *));
292 static void read_specs
PARAMS ((const char *, int));
293 static void set_spec
PARAMS ((const char *, const char *));
294 static struct compiler
*lookup_compiler
PARAMS ((const char *, size_t, const char *));
295 static char *build_search_list
PARAMS ((struct path_prefix
*, const char *, int));
296 static void putenv_from_prefixes
PARAMS ((struct path_prefix
*, const char *));
297 static int access_check
PARAMS ((const char *, int));
298 static char *find_a_file
PARAMS ((struct path_prefix
*, const char *,
300 static void add_prefix
PARAMS ((struct path_prefix
*, const char *,
301 const char *, int, int, int *, int));
302 static void add_sysrooted_prefix
PARAMS ((struct path_prefix
*, const char *,
303 const char *, int, int, int *, int));
304 static void translate_options
PARAMS ((int *, const char *const **));
305 static char *skip_whitespace
PARAMS ((char *));
306 static void delete_if_ordinary
PARAMS ((const char *));
307 static void delete_temp_files
PARAMS ((void));
308 static void delete_failure_queue
PARAMS ((void));
309 static void clear_failure_queue
PARAMS ((void));
310 static int check_live_switch
PARAMS ((int, int));
311 static const char *handle_braces
PARAMS ((const char *));
312 static inline bool input_suffix_matches
PARAMS ((const char *,
314 static inline bool switch_matches
PARAMS ((const char *,
316 static inline void mark_matching_switches
PARAMS ((const char *,
318 static inline void process_marked_switches
PARAMS ((void));
319 static const char *process_brace_body
PARAMS ((const char *, const char *,
320 const char *, int, int));
321 static const struct spec_function
*lookup_spec_function
PARAMS ((const char *));
322 static const char *eval_spec_function
PARAMS ((const char *, const char *));
323 static const char *handle_spec_function
PARAMS ((const char *));
324 static char *save_string
PARAMS ((const char *, int));
325 static void set_collect_gcc_options
PARAMS ((void));
326 static int do_spec_1
PARAMS ((const char *, int, const char *));
327 static int do_spec_2
PARAMS ((const char *));
328 static void do_self_spec
PARAMS ((const char *));
329 static const char *find_file
PARAMS ((const char *));
330 static int is_directory
PARAMS ((const char *, const char *, int));
331 static const char *validate_switches
PARAMS ((const char *));
332 static void validate_all_switches
PARAMS ((void));
333 static inline void validate_switches_from_spec
PARAMS ((const char *));
334 static void give_switch
PARAMS ((int, int));
335 static int used_arg
PARAMS ((const char *, int));
336 static int default_arg
PARAMS ((const char *, int));
337 static void set_multilib_dir
PARAMS ((void));
338 static void print_multilib_info
PARAMS ((void));
339 static void perror_with_name
PARAMS ((const char *));
340 static void pfatal_pexecute
PARAMS ((const char *, const char *))
342 static void notice
PARAMS ((const char *, ...))
344 static void display_help
PARAMS ((void));
345 static void add_preprocessor_option
PARAMS ((const char *, int));
346 static void add_assembler_option
PARAMS ((const char *, int));
347 static void add_linker_option
PARAMS ((const char *, int));
348 static void process_command
PARAMS ((int, const char *const *));
349 static int execute
PARAMS ((void));
350 static void alloc_args
PARAMS ((void));
351 static void clear_args
PARAMS ((void));
352 static void fatal_error
PARAMS ((int));
353 #ifdef ENABLE_SHARED_LIBGCC
354 static void init_gcc_specs
PARAMS ((struct obstack
*,
355 const char *, const char *,
358 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
359 static const char *convert_filename
PARAMS ((const char *, int, int));
362 static const char *if_exists_spec_function
PARAMS ((int, const char **));
363 static const char *if_exists_else_spec_function
PARAMS ((int, const char **));
365 /* The Specs Language
367 Specs are strings containing lines, each of which (if not blank)
368 is made up of a program name, and arguments separated by spaces.
369 The program name must be exact and start from root, since no path
370 is searched and it is unreliable to depend on the current working directory.
371 Redirection of input or output is not supported; the subprograms must
372 accept filenames saying what files to read and write.
374 In addition, the specs can contain %-sequences to substitute variable text
375 or for conditional text. Here is a table of all defined %-sequences.
376 Note that spaces are not generated automatically around the results of
377 expanding these sequences; therefore, you can concatenate them together
378 or with constant text in a single argument.
380 %% substitute one % into the program name or argument.
381 %i substitute the name of the input file being processed.
382 %b substitute the basename of the input file being processed.
383 This is the substring up to (and not including) the last period
384 and not including the directory.
385 %B same as %b, but include the file suffix (text after the last period).
387 substitute a file name that has suffix SUFFIX and is chosen
388 once per compilation, and mark the argument a la %d. To reduce
389 exposure to denial-of-service attacks, the file name is now
390 chosen in a way that is hard to predict even when previously
391 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
392 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
393 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
394 had been pre-processed. Previously, %g was simply substituted
395 with a file name chosen once per compilation, without regard
396 to any appended suffix (which was therefore treated just like
397 ordinary text), making such attacks more likely to succeed.
399 like %g, but if -pipe is in effect, expands simply to "-".
401 like %g, but if -pipe is in effect, expands to nothing. (We have both
402 %| and %m to accommodate differences between system assemblers; see
403 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
405 like %g, but generates a new temporary file name even if %uSUFFIX
408 substitutes the last file name generated with %uSUFFIX, generating a
409 new one if there is no such last file name. In the absence of any
410 %uSUFFIX, this is just like %gSUFFIX, except they don't share
411 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
412 would involve the generation of two distinct file names, one
413 for each `%g.s' and another for each `%U.s'. Previously, %U was
414 simply substituted with a file name chosen for the previous %u,
415 without regard to any appended suffix.
417 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
418 writable, and if save-temps is off; otherwise, substitute the name
419 of a temporary file, just like %u. This temporary file is not
420 meant for communication between processes, but rather as a junk
423 substitutes .SUFFIX for the suffixes of a matched switch's args when
424 it is subsequently output with %*. SUFFIX is terminated by the next
426 %d marks the argument containing or following the %d as a
427 temporary file name, so that that file will be deleted if CC exits
428 successfully. Unlike %g, this contributes no text to the argument.
429 %w marks the argument containing or following the %w as the
430 "output file" of this compilation. This puts the argument
431 into the sequence of arguments that %o will substitute later.
432 %V indicates that this compilation produces no "output file".
434 like %{...} but mark last argument supplied within
435 as a file to be deleted on failure.
436 %o substitutes the names of all the output files, with spaces
437 automatically placed around them. You should write spaces
438 around the %o as well or the results are undefined.
439 %o is for use in the specs for running the linker.
440 Input files whose names have no recognized suffix are not compiled
441 at all, but they are included among the output files, so they will
443 %O substitutes the suffix for object files. Note that this is
444 handled specially when it immediately follows %g, %u, or %U
445 (with or without a suffix argument) because of the need for
446 those to form complete file names. The handling is such that
447 %O is treated exactly as if it had already been substituted,
448 except that %g, %u, and %U do not currently support additional
449 SUFFIX characters following %O as they would following, for
451 %p substitutes the standard macro predefinitions for the
452 current target machine. Use this when running cpp.
453 %P like %p, but puts `__' before and after the name of each macro.
454 (Except macros that already have __.)
456 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
457 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
458 and -B options) as necessary.
459 %s current argument is the name of a library or startup file of some sort.
460 Search for that file in a standard list of directories
461 and substitute the full name found.
462 %eSTR Print STR as an error message. STR is terminated by a newline.
463 Use this when inconsistent options are detected.
464 %nSTR Print STR as a notice. STR is terminated by a newline.
465 %x{OPTION} Accumulate an option for %X.
466 %X Output the accumulated linker options specified by compilations.
467 %Y Output the accumulated assembler options specified by compilations.
468 %Z Output the accumulated preprocessor options specified by compilations.
469 %a process ASM_SPEC as a spec.
470 This allows config.h to specify part of the spec for running as.
471 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
472 used here. This can be used to run a post-processor after the
473 assembler has done its job.
474 %D Dump out a -L option for each directory in startfile_prefixes.
475 If multilib_dir is set, extra entries are generated with it affixed.
476 %l process LINK_SPEC as a spec.
477 %L process LIB_SPEC as a spec.
478 %G process LIBGCC_SPEC as a spec.
479 %M output multilib_dir with directory separators replaced with "_";
480 if multilib_dir is not set or is ".", output "".
481 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
482 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
483 %C process CPP_SPEC as a spec.
484 %1 process CC1_SPEC as a spec.
485 %2 process CC1PLUS_SPEC as a spec.
486 %* substitute the variable part of a matched option. (See below.)
487 Note that each comma in the substituted string is replaced by
489 %<S remove all occurrences of -S from the command line.
490 Note - this command is position dependent. % commands in the
491 spec string before this one will see -S, % commands in the
492 spec string after this one will not.
493 %<S* remove all occurrences of all switches beginning with -S from the
496 Call the named function FUNCTION, passing it ARGS. ARGS is
497 first processed as a nested spec string, then split into an
498 argument vector in the usual fashion. The function returns
499 a string which is processed as if it had appeared literally
500 as part of the current spec.
501 %{S} substitutes the -S switch, if that switch was given to CC.
502 If that switch was not specified, this substitutes nothing.
503 Here S is a metasyntactic variable.
504 %{S*} substitutes all the switches specified to CC whose names start
505 with -S. This is used for -o, -I, etc; switches that take
506 arguments. CC considers `-o foo' as being one switch whose
507 name starts with `o'. %{o*} would substitute this text,
508 including the space; thus, two arguments would be generated.
509 %{S*&T*} likewise, but preserve order of S and T options (the order
510 of S and T in the spec is not significant). Can be any number
511 of ampersand-separated variables; for each the wild card is
512 optional. Useful for CPP as %{D*&U*&A*}.
514 %{S:X} substitutes X, if the -S switch was given to CC.
515 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
516 %{S*:X} substitutes X if one or more switches whose names start
517 with -S was given to CC. Normally X is substituted only
518 once, no matter how many such switches appeared. However,
519 if %* appears somewhere in X, then X will be substituted
520 once for each matching switch, with the %* replaced by the
521 part of that switch that matched the '*'.
522 %{.S:X} substitutes X, if processing a file with suffix S.
523 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
525 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
526 combined with !, ., and * as above binding stronger than the OR.
527 If %* appears in X, all of the alternatives must be starred, and
528 only the first matching alternative is substituted.
529 %{S:X; if S was given to CC, substitutes X;
530 T:Y; else if T was given to CC, substitutes Y;
531 :D} else substitutes D. There can be as many clauses as you need.
532 This may be combined with ., !, |, and * as above.
534 %(Spec) processes a specification defined in a specs file as *Spec:
535 %[Spec] as above, but put __ around -D arguments
537 The conditional text X in a %{S:X} or similar construct may contain
538 other nested % constructs or spaces, or even newlines. They are
539 processed as usual, as described above. Trailing white space in X is
540 ignored. White space may also appear anywhere on the left side of the
541 colon in these constructs, except between . or * and the corresponding
544 The -O, -f, -m, and -W switches are handled specifically in these
545 constructs. If another value of -O or the negated form of a -f, -m, or
546 -W switch is found later in the command line, the earlier switch
547 value is ignored, except with {S*} where S is just one letter; this
548 passes all matching options.
550 The character | at the beginning of the predicate text is used to indicate
551 that a command should be piped to the following command, but only if -pipe
554 Note that it is built into CC which switches take arguments and which
555 do not. You might think it would be useful to generalize this to
556 allow each compiler's spec to say which switches take arguments. But
557 this cannot be done in a consistent fashion. CC cannot even decide
558 which input files have been specified without knowing which switches
559 take arguments, and it must know which input files to compile in order
560 to tell which compilers to run.
562 CC also knows implicitly that arguments starting in `-l' are to be
563 treated as compiler output files, and passed to the linker in their
564 proper position among the other output files. */
566 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
568 /* config.h can define ASM_SPEC to provide extra args to the assembler
569 or extra switch-translations. */
574 /* config.h can define ASM_FINAL_SPEC to run a post processor after
575 the assembler has run. */
576 #ifndef ASM_FINAL_SPEC
577 #define ASM_FINAL_SPEC ""
580 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
581 or extra switch-translations. */
586 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
587 or extra switch-translations. */
592 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
593 or extra switch-translations. */
595 #define CC1PLUS_SPEC ""
598 /* config.h can define LINK_SPEC to provide extra args to the linker
599 or extra switch-translations. */
604 /* config.h can define LIB_SPEC to override the default libraries. */
606 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
609 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
612 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
613 /* Have gcc do the search for libgcc.a. */
614 #define LIBGCC_SPEC "libgcc.a%s"
616 #define LIBGCC_SPEC "-lgcc"
620 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
621 #ifndef STARTFILE_SPEC
622 #define STARTFILE_SPEC \
623 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
626 /* config.h can define SWITCHES_NEED_SPACES to control which options
627 require spaces between the option and the argument. */
628 #ifndef SWITCHES_NEED_SPACES
629 #define SWITCHES_NEED_SPACES ""
632 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
634 #define ENDFILE_SPEC ""
638 #define LINKER_NAME "collect2"
641 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
643 #ifndef ASM_DEBUG_SPEC
644 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
645 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
646 # define ASM_DEBUG_SPEC \
647 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
648 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
649 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
651 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
652 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
654 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
655 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
659 #ifndef ASM_DEBUG_SPEC
660 # define ASM_DEBUG_SPEC ""
663 /* Here is the spec for running the linker, after compiling all files. */
665 /* This is overridable by the target in case they need to specify the
666 -lgcc and -lc order specially, yet not require them to override all
667 of LINK_COMMAND_SPEC. */
668 #ifndef LINK_GCC_C_SEQUENCE_SPEC
669 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
672 /* -u* was put back because both BSD and SysV seem to support it. */
673 /* %{static:} simply prevents an error message if the target machine
674 doesn't handle -static. */
675 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
676 scripts which exist in user specified directories, or in standard
678 #ifndef LINK_COMMAND_SPEC
679 #define LINK_COMMAND_SPEC "\
680 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
681 %(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r} %{s} %{t}\
682 %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
683 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs:-lgcov}\
684 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
685 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
688 #ifndef LINK_LIBGCC_SPEC
689 # ifdef LINK_LIBGCC_SPECIAL
690 /* Don't generate -L options for startfile prefix list. */
691 # define LINK_LIBGCC_SPEC ""
693 /* Do generate them. */
694 # define LINK_LIBGCC_SPEC "%D"
698 #ifndef STARTFILE_PREFIX_SPEC
699 # define STARTFILE_PREFIX_SPEC ""
702 static const char *asm_debug
;
703 static const char *cpp_spec
= CPP_SPEC
;
704 static const char *cpp_predefines
= CPP_PREDEFINES
;
705 static const char *cc1_spec
= CC1_SPEC
;
706 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
707 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
708 static const char *asm_spec
= ASM_SPEC
;
709 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
710 static const char *link_spec
= LINK_SPEC
;
711 static const char *lib_spec
= LIB_SPEC
;
712 static const char *libgcc_spec
= LIBGCC_SPEC
;
713 static const char *endfile_spec
= ENDFILE_SPEC
;
714 static const char *startfile_spec
= STARTFILE_SPEC
;
715 static const char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
716 static const char *linker_name_spec
= LINKER_NAME
;
717 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
718 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
719 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
721 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
722 There should be no need to override these in target dependent files,
723 but we need to copy them to the specs file so that newer versions
724 of the GCC driver can correctly drive older tool chains with the
725 appropriate -B options. */
727 /* When cpplib handles traditional preprocessing, get rid of this, and
728 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
729 that we default the front end language better. */
730 static const char *trad_capable_cpp
=
731 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
733 /* We don't wrap .d files in %W{} since a missing .d file, and
734 therefore no dependency entry, confuses make into thinking a .o
735 file that happens to exist is up-to-date. */
736 static const char *cpp_unique_options
=
737 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
738 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
739 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
740 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
741 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
742 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
743 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
744 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
747 /* This contains cpp options which are common with cc1_options and are passed
748 only when preprocessing only to avoid duplication. We pass the cc1 spec
749 options to the preprocessor so that it the cc1 spec may manipulate
750 options used to set target flags. Those special target flags settings may
751 in turn cause preprocessor symbols to be defined specially. */
752 static const char *cpp_options
=
753 "%(cpp_unique_options) %1 %{m*} %{std*} %{ansi} %{W*&pedantic*} %{w} %{f*}\
756 /* This contains cpp options which are not passed when the preprocessor
757 output will be used by another program. */
758 static const char *cpp_debug_options
= "%{d*}";
760 /* NB: This is shared amongst all front-ends. */
761 static const char *cc1_options
=
762 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
763 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
764 -auxbase%{c|S:%{o*:-strip %*}%{!o*: %b}}%{!c:%{!S: %b}}\
765 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
766 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
767 %{Qn:-fno-ident} %{--help:--help}\
768 %{--target-help:--target-help}\
769 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
770 %{fsyntax-only:-o %j} %{-param*}";
772 static const char *asm_options
=
773 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
775 static const char *invoke_as
=
776 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
777 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
779 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
782 /* Some compilers have limits on line lengths, and the multilib_select
783 and/or multilib_matches strings can be very long, so we build them at
785 static struct obstack multilib_obstack
;
786 static const char *multilib_select
;
787 static const char *multilib_matches
;
788 static const char *multilib_defaults
;
789 static const char *multilib_exclusions
;
790 #include "multilib.h"
792 /* Check whether a particular argument is a default argument. */
794 #ifndef MULTILIB_DEFAULTS
795 #define MULTILIB_DEFAULTS { "" }
798 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
800 #ifndef DRIVER_SELF_SPECS
801 #define DRIVER_SELF_SPECS ""
804 static const char *const driver_self_specs
[] = { DRIVER_SELF_SPECS
};
808 struct user_specs
*next
;
809 const char *filename
;
812 static struct user_specs
*user_specs_head
, *user_specs_tail
;
814 #ifndef SWITCH_TAKES_ARG
815 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
818 #ifndef WORD_SWITCH_TAKES_ARG
819 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
822 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
823 /* This defines which switches stop a full compilation. */
824 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
825 ((CHAR) == 'c' || (CHAR) == 'S')
827 #ifndef SWITCH_CURTAILS_COMPILATION
828 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
829 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
833 /* Record the mapping from file suffixes for compilation specs. */
837 const char *suffix
; /* Use this compiler for input files
838 whose names end in this suffix. */
840 const char *spec
; /* To use this compiler, run this spec. */
842 const char *cpp_spec
; /* If non-NULL, substitute this spec
843 for `%C', rather than the usual
847 /* Pointer to a vector of `struct compiler' that gives the spec for
848 compiling a file, based on its suffix.
849 A file that does not end in any of these suffixes will be passed
850 unchanged to the loader and nothing else will be done to it.
852 An entry containing two 0s is used to terminate the vector.
854 If multiple entries match a file, the last matching one is used. */
856 static struct compiler
*compilers
;
858 /* Number of entries in `compilers', not counting the null terminator. */
860 static int n_compilers
;
862 /* The default list of file name suffixes and their compilation specs. */
864 static const struct compiler default_compilers
[] =
866 /* Add lists of suffixes of known languages here. If those languages
867 were not present when we built the driver, we will hit these copies
868 and be given a more meaningful error than "file not used since
869 linking is not done". */
870 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
871 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
872 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
873 {".CPP", "#C++", 0}, {".ii", "#C++", 0},
874 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
875 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
876 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
877 {".r", "#Ratfor", 0},
878 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
879 {".java", "#Java", 0}, {".class", "#Java", 0},
880 {".zip", "#Java", 0}, {".jar", "#Java", 0},
881 /* Next come the entries for C. */
884 /* cc1 has an integrated ISO C preprocessor. We should invoke the
885 external preprocessor if -save-temps is given. */
886 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
888 %{traditional|ftraditional:\
889 %eGNU C no longer supports -traditional without -E}\
890 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
891 %(cpp_options) %{save-temps:%b.i} %{!save-temps:%g.i} \n\
892 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} %(cc1_options)}\
893 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
894 cc1 %(cpp_unique_options) %(cc1_options)}}}\
895 %{!fsyntax-only:%(invoke_as)}}}}", 0},
897 "%{!E:%e-E required when input is from standard input}\
898 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0},
899 {".h", "@c-header", 0},
901 /* cc1 has an integrated ISO C preprocessor. We should invoke the
902 external preprocessor if -save-temps is given. */
903 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
905 %{save-temps|traditional-cpp:%(trad_capable_cpp) \
906 %(cpp_options) %b.i \n\
907 cc1 -fpreprocessed %b.i %(cc1_options)\
908 -o %g.s %{!o*:--output-pch=%i.gch}\
909 %W{o*:--output-pch=%*}%V}\
910 %{!save-temps:%{!traditional-cpp:\
911 cc1 %(cpp_unique_options) %(cc1_options)\
912 -o %g.s %{!o*:--output-pch=%i.gch}\
913 %W{o*:--output-pch=%*}%V}}}}}", 0},
914 {".i", "@cpp-output", 0},
916 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
917 {".s", "@assembler", 0},
919 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
920 {".S", "@assembler-with-cpp", 0},
921 {"@assembler-with-cpp",
922 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
923 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
924 %{E|M|MM:%(cpp_debug_options)}\
925 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
926 as %(asm_debug) %(asm_options) %|.s %A }}}}"
928 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
929 %{E|M|MM:%(cpp_debug_options)}\
930 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
931 as %(asm_debug) %(asm_options) %m.s %A }}}}"
936 /* Mark end of table */
940 /* Number of elements in default_compilers, not counting the terminator. */
942 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
944 /* A vector of options to give to the linker.
945 These options are accumulated by %x,
946 and substituted into the linker command with %X. */
947 static int n_linker_options
;
948 static char **linker_options
;
950 /* A vector of options to give to the assembler.
951 These options are accumulated by -Wa,
952 and substituted into the assembler command with %Y. */
953 static int n_assembler_options
;
954 static char **assembler_options
;
956 /* A vector of options to give to the preprocessor.
957 These options are accumulated by -Wp,
958 and substituted into the preprocessor command with %Z. */
959 static int n_preprocessor_options
;
960 static char **preprocessor_options
;
962 /* Define how to map long options into short ones. */
964 /* This structure describes one mapping. */
967 /* The long option's name. */
968 const char *const name
;
969 /* The equivalent short option. */
970 const char *const equivalent
;
971 /* Argument info. A string of flag chars; NULL equals no options.
972 a => argument required.
973 o => argument optional.
974 j => join argument to equivalent, making one word.
975 * => require other text after NAME as an argument. */
976 const char *const arg_info
;
979 /* This is the table of mappings. Mappings are tried sequentially
980 for each option encountered; the first one that matches, wins. */
982 static const struct option_map option_map
[] =
984 {"--all-warnings", "-Wall", 0},
985 {"--ansi", "-ansi", 0},
986 {"--assemble", "-S", 0},
987 {"--assert", "-A", "a"},
988 {"--classpath", "-fclasspath=", "aj"},
989 {"--bootclasspath", "-fbootclasspath=", "aj"},
990 {"--CLASSPATH", "-fclasspath=", "aj"},
991 {"--comments", "-C", 0},
992 {"--comments-in-macros", "-CC", 0},
993 {"--compile", "-c", 0},
994 {"--debug", "-g", "oj"},
995 {"--define-macro", "-D", "aj"},
996 {"--dependencies", "-M", 0},
997 {"--dump", "-d", "a"},
998 {"--dumpbase", "-dumpbase", "a"},
999 {"--entry", "-e", 0},
1000 {"--extra-warnings", "-W", 0},
1001 {"--for-assembler", "-Wa", "a"},
1002 {"--for-linker", "-Xlinker", "a"},
1003 {"--force-link", "-u", "a"},
1004 {"--imacros", "-imacros", "a"},
1005 {"--include", "-include", "a"},
1006 {"--include-barrier", "-I-", 0},
1007 {"--include-directory", "-I", "aj"},
1008 {"--include-directory-after", "-idirafter", "a"},
1009 {"--include-prefix", "-iprefix", "a"},
1010 {"--include-with-prefix", "-iwithprefix", "a"},
1011 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1012 {"--include-with-prefix-after", "-iwithprefix", "a"},
1013 {"--language", "-x", "a"},
1014 {"--library-directory", "-L", "a"},
1015 {"--machine", "-m", "aj"},
1016 {"--machine-", "-m", "*j"},
1017 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1018 {"--no-line-commands", "-P", 0},
1019 {"--no-precompiled-includes", "-noprecomp", 0},
1020 {"--no-standard-includes", "-nostdinc", 0},
1021 {"--no-standard-libraries", "-nostdlib", 0},
1022 {"--no-warnings", "-w", 0},
1023 {"--optimize", "-O", "oj"},
1024 {"--output", "-o", "a"},
1025 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1026 {"--param", "--param", "a"},
1027 {"--pedantic", "-pedantic", 0},
1028 {"--pedantic-errors", "-pedantic-errors", 0},
1029 {"--pipe", "-pipe", 0},
1030 {"--prefix", "-B", "a"},
1031 {"--preprocess", "-E", 0},
1032 {"--print-search-dirs", "-print-search-dirs", 0},
1033 {"--print-file-name", "-print-file-name=", "aj"},
1034 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1035 {"--print-missing-file-dependencies", "-MG", 0},
1036 {"--print-multi-lib", "-print-multi-lib", 0},
1037 {"--print-multi-directory", "-print-multi-directory", 0},
1038 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1039 {"--print-prog-name", "-print-prog-name=", "aj"},
1040 {"--profile", "-p", 0},
1041 {"--profile-blocks", "-a", 0},
1042 {"--quiet", "-q", 0},
1043 {"--resource", "-fcompile-resource=", "aj"},
1044 {"--save-temps", "-save-temps", 0},
1045 {"--shared", "-shared", 0},
1046 {"--silent", "-q", 0},
1047 {"--specs", "-specs=", "aj"},
1048 {"--static", "-static", 0},
1049 {"--std", "-std=", "aj"},
1050 {"--symbolic", "-symbolic", 0},
1051 {"--target", "-b", "a"},
1052 {"--time", "-time", 0},
1053 {"--trace-includes", "-H", 0},
1054 {"--traditional", "-traditional", 0},
1055 {"--traditional-cpp", "-traditional-cpp", 0},
1056 {"--trigraphs", "-trigraphs", 0},
1057 {"--undefine-macro", "-U", "aj"},
1058 {"--use-version", "-V", "a"},
1059 {"--user-dependencies", "-MM", 0},
1060 {"--verbose", "-v", 0},
1061 {"--warn-", "-W", "*j"},
1062 {"--write-dependencies", "-MD", 0},
1063 {"--write-user-dependencies", "-MMD", 0},
1068 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1069 static const struct {
1070 const char *const option_found
;
1071 const char *const replacements
;
1072 } target_option_translations
[] =
1074 TARGET_OPTION_TRANSLATE_TABLE
,
1079 /* Translate the options described by *ARGCP and *ARGVP.
1080 Make a new vector and store it back in *ARGVP,
1081 and store its length in *ARGVC. */
1084 translate_options (argcp
, argvp
)
1086 const char *const **argvp
;
1090 const char *const *argv
= *argvp
;
1091 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1093 (const char **) xmalloc (newvsize
);
1097 newv
[newindex
++] = argv
[i
++];
1101 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1105 target_option_translations
[tott_idx
].option_found
;
1108 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1115 for (sp
= target_option_translations
[tott_idx
].replacements
;
1122 newvsize
+= spaces
* sizeof (const char *);
1123 newv
= (const char **) xrealloc (newv
, newvsize
);
1125 sp
= target_option_translations
[tott_idx
].replacements
;
1134 newv
[newindex
++] = np
;
1135 while (*np
!= ' ' && *np
)
1146 if (target_option_translations
[tott_idx
].option_found
)
1150 /* Translate -- options. */
1151 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1154 /* Find a mapping that applies to this option. */
1155 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1157 size_t optlen
= strlen (option_map
[j
].name
);
1158 size_t arglen
= strlen (argv
[i
]);
1159 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1160 const char *arginfo
= option_map
[j
].arg_info
;
1165 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1167 const char *arg
= 0;
1169 if (arglen
< optlen
)
1172 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1173 if (strlen (option_map
[k
].name
) >= arglen
1174 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1176 error ("ambiguous abbreviation %s", argv
[i
]);
1180 if (k
!= ARRAY_SIZE (option_map
))
1184 if (arglen
> optlen
)
1186 /* If the option has an argument, accept that. */
1187 if (argv
[i
][optlen
] == '=')
1188 arg
= argv
[i
] + optlen
+ 1;
1190 /* If this mapping requires extra text at end of name,
1191 accept that as "argument". */
1192 else if (strchr (arginfo
, '*') != 0)
1193 arg
= argv
[i
] + optlen
;
1195 /* Otherwise, extra text at end means mismatch.
1196 Try other mappings. */
1201 else if (strchr (arginfo
, '*') != 0)
1203 error ("incomplete `%s' option", option_map
[j
].name
);
1207 /* Handle arguments. */
1208 if (strchr (arginfo
, 'a') != 0)
1214 error ("missing argument to `%s' option",
1215 option_map
[j
].name
);
1222 else if (strchr (arginfo
, '*') != 0)
1224 else if (strchr (arginfo
, 'o') == 0)
1227 error ("extraneous argument to `%s' option",
1228 option_map
[j
].name
);
1232 /* Store the translation as one argv elt or as two. */
1233 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1234 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1238 newv
[newindex
++] = option_map
[j
].equivalent
;
1239 newv
[newindex
++] = arg
;
1242 newv
[newindex
++] = option_map
[j
].equivalent
;
1250 /* Handle old-fashioned options--just copy them through,
1251 with their arguments. */
1252 else if (argv
[i
][0] == '-')
1254 const char *p
= argv
[i
] + 1;
1258 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1259 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1260 else if (WORD_SWITCH_TAKES_ARG (p
))
1261 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1262 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1265 else if (! strcmp (p
, "Xlinker"))
1267 else if (! strcmp (p
, "Xpreprocessor"))
1269 else if (! strcmp (p
, "Xassembler"))
1272 /* Watch out for an option at the end of the command line that
1273 is missing arguments, and avoid skipping past the end of the
1275 if (nskip
+ i
> argc
)
1280 newv
[newindex
++] = argv
[i
++];
1285 /* Ordinary operands, or +e options. */
1286 newv
[newindex
++] = argv
[i
++];
1301 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1302 be considered whitespace. */
1303 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1305 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1319 /* Structures to keep track of prefixes to try when looking for files. */
1323 const char *prefix
; /* String to prepend to the path. */
1324 struct prefix_list
*next
; /* Next in linked list. */
1325 int require_machine_suffix
; /* Don't use without machine_suffix. */
1326 /* 2 means try both machine_suffix and just_machine_suffix. */
1327 int *used_flag_ptr
; /* 1 if a file was found with this prefix. */
1328 int priority
; /* Sort key - priority within list. */
1329 int os_multilib
; /* 1 if OS multilib scheme should be used,
1330 0 for GCC multilib scheme. */
1335 struct prefix_list
*plist
; /* List of prefixes to try */
1336 int max_len
; /* Max length of a prefix in PLIST */
1337 const char *name
; /* Name of this list (used in config stuff) */
1340 /* List of prefixes to try when looking for executables. */
1342 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1344 /* List of prefixes to try when looking for startup (crt0) files. */
1346 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1348 /* List of prefixes to try when looking for include files. */
1350 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1352 /* Suffix to attach to directories searched for commands.
1353 This looks like `MACHINE/VERSION/'. */
1355 static const char *machine_suffix
= 0;
1357 /* Suffix to attach to directories searched for commands.
1358 This is just `MACHINE/'. */
1360 static const char *just_machine_suffix
= 0;
1362 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1364 static const char *gcc_exec_prefix
;
1366 /* Default prefixes to attach to command names. */
1368 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1369 #undef MD_EXEC_PREFIX
1370 #undef MD_STARTFILE_PREFIX
1371 #undef MD_STARTFILE_PREFIX_1
1374 /* If no prefixes defined, use the null string, which will disable them. */
1375 #ifndef MD_EXEC_PREFIX
1376 #define MD_EXEC_PREFIX ""
1378 #ifndef MD_STARTFILE_PREFIX
1379 #define MD_STARTFILE_PREFIX ""
1381 #ifndef MD_STARTFILE_PREFIX_1
1382 #define MD_STARTFILE_PREFIX_1 ""
1385 /* Supply defaults for the standard prefixes. */
1387 #ifndef STANDARD_EXEC_PREFIX
1388 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1390 #ifndef STANDARD_STARTFILE_PREFIX
1391 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1393 #ifndef TOOLDIR_BASE_PREFIX
1394 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1396 #ifndef STANDARD_BINDIR_PREFIX
1397 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1400 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1401 static const char *const standard_exec_prefix_1
= "/usr/lib/gcc/";
1402 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1404 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1405 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1406 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1407 static const char *const standard_startfile_prefix_1
= "/lib/";
1408 static const char *const standard_startfile_prefix_2
= "/usr/lib/";
1410 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1411 static const char *tooldir_prefix
;
1413 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1415 /* Subdirectory to use for locating libraries. Set by
1416 set_multilib_dir based on the compilation options. */
1418 static const char *multilib_dir
;
1420 /* Subdirectory to use for locating libraries in OS conventions. Set by
1421 set_multilib_dir based on the compilation options. */
1423 static const char *multilib_os_dir
;
1425 /* Structure to keep track of the specs that have been defined so far.
1426 These are accessed using %(specname) or %[specname] in a compiler
1431 /* The following 2 fields must be first */
1432 /* to allow EXTRA_SPECS to be initialized */
1433 const char *name
; /* name of the spec. */
1434 const char *ptr
; /* available ptr if no static pointer */
1436 /* The following fields are not initialized */
1437 /* by EXTRA_SPECS */
1438 const char **ptr_spec
; /* pointer to the spec itself. */
1439 struct spec_list
*next
; /* Next spec in linked list. */
1440 int name_len
; /* length of the name */
1441 int alloc_p
; /* whether string was allocated */
1444 #define INIT_STATIC_SPEC(NAME,PTR) \
1445 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1447 /* List of statically defined specs. */
1448 static struct spec_list static_specs
[] =
1450 INIT_STATIC_SPEC ("asm", &asm_spec
),
1451 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1452 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1453 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1454 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1455 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1456 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1457 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1458 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1459 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1460 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1461 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1462 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1463 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1464 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1465 INIT_STATIC_SPEC ("link", &link_spec
),
1466 INIT_STATIC_SPEC ("lib", &lib_spec
),
1467 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1468 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1469 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces
),
1470 INIT_STATIC_SPEC ("predefines", &cpp_predefines
),
1471 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1472 INIT_STATIC_SPEC ("version", &compiler_version
),
1473 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1474 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1475 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1476 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1477 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1478 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1479 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1480 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1481 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1482 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1483 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1484 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1487 #ifdef EXTRA_SPECS /* additional specs needed */
1488 /* Structure to keep track of just the first two args of a spec_list.
1489 That is all that the EXTRA_SPECS macro gives us. */
1492 const char *const name
;
1493 const char *const ptr
;
1496 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1497 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1500 /* List of dynamically allocates specs that have been defined so far. */
1502 static struct spec_list
*specs
= (struct spec_list
*) 0;
1504 /* List of static spec functions. */
1506 static const struct spec_function static_spec_functions
[] =
1508 { "if-exists", if_exists_spec_function
},
1509 { "if-exists-else", if_exists_else_spec_function
},
1513 static int processing_spec_function
;
1515 /* Add appropriate libgcc specs to OBSTACK, taking into account
1516 various permutations of -shared-libgcc, -shared, and such. */
1518 #ifdef ENABLE_SHARED_LIBGCC
1520 init_gcc_specs (obstack
, shared_name
, static_name
, eh_name
)
1521 struct obstack
*obstack
;
1522 const char *shared_name
;
1523 const char *static_name
;
1524 const char *eh_name
;
1528 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
,
1529 "}%{!static:%{!static-libgcc:",
1530 "%{!shared:%{!shared-libgcc:", static_name
, " ",
1531 eh_name
, "}%{shared-libgcc:", shared_name
, " ",
1532 static_name
, "}}%{shared:",
1534 "%{shared-libgcc:", shared_name
,
1535 "}%{!shared-libgcc:", static_name
, "}",
1541 obstack_grow (obstack
, buf
, strlen (buf
));
1544 #endif /* ENABLE_SHARED_LIBGCC */
1546 /* Initialize the specs lookup routines. */
1551 struct spec_list
*next
= (struct spec_list
*) 0;
1552 struct spec_list
*sl
= (struct spec_list
*) 0;
1556 return; /* Already initialized. */
1559 notice ("Using built-in specs.\n");
1562 extra_specs
= (struct spec_list
*)
1563 xcalloc (sizeof (struct spec_list
), ARRAY_SIZE (extra_specs_1
));
1565 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1567 sl
= &extra_specs
[i
];
1568 sl
->name
= extra_specs_1
[i
].name
;
1569 sl
->ptr
= extra_specs_1
[i
].ptr
;
1571 sl
->name_len
= strlen (sl
->name
);
1572 sl
->ptr_spec
= &sl
->ptr
;
1577 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1578 on ?: in file-scope variable initializations. */
1579 asm_debug
= ASM_DEBUG_SPEC
;
1581 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1583 sl
= &static_specs
[i
];
1588 #ifdef ENABLE_SHARED_LIBGCC
1589 /* ??? If neither -shared-libgcc nor --static-libgcc was
1590 seen, then we should be making an educated guess. Some proposed
1591 heuristics for ELF include:
1593 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1594 program will be doing dynamic loading, which will likely
1595 need the shared libgcc.
1597 (2) If "-ldl", then it's also a fair bet that we're doing
1600 (3) For each ET_DYN we're linking against (either through -lfoo
1601 or /some/path/foo.so), check to see whether it or one of
1602 its dependencies depends on a shared libgcc.
1606 If the runtime is fixed to look for program headers instead
1607 of calling __register_frame_info at all, for each object,
1608 use the shared libgcc if any EH symbol referenced.
1610 If crtstuff is fixed to not invoke __register_frame_info
1611 automatically, for each object, use the shared libgcc if
1612 any non-empty unwind section found.
1614 Doing any of this probably requires invoking an external program to
1615 do the actual object file scanning. */
1617 const char *p
= libgcc_spec
;
1620 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1621 when given the proper command line arguments. */
1624 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1626 init_gcc_specs (&obstack
,
1627 #ifdef NO_SHARED_LIBGCC_MULTILIB
1632 #ifdef USE_LIBUNWIND_EXCEPTIONS
1641 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1643 /* Ug. We don't know shared library extensions. Hope that
1644 systems that use this form don't do shared libraries. */
1645 init_gcc_specs (&obstack
,
1646 #ifdef NO_SHARED_LIBGCC_MULTILIB
1659 obstack_1grow (&obstack
, *p
);
1660 in_sep
= (*p
== ' ');
1665 obstack_1grow (&obstack
, '\0');
1666 libgcc_spec
= obstack_finish (&obstack
);
1669 #ifdef USE_AS_TRADITIONAL_FORMAT
1670 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1672 static const char tf
[] = "--traditional-format ";
1673 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1674 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1675 asm_spec
= obstack_finish (&obstack
);
1679 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1680 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1681 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1682 link_spec
= obstack_finish (&obstack
);
1688 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1689 removed; If the spec starts with a + then SPEC is added to the end of the
1693 set_spec (name
, spec
)
1697 struct spec_list
*sl
;
1698 const char *old_spec
;
1699 int name_len
= strlen (name
);
1702 /* If this is the first call, initialize the statically allocated specs. */
1705 struct spec_list
*next
= (struct spec_list
*) 0;
1706 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1708 sl
= &static_specs
[i
];
1715 /* See if the spec already exists. */
1716 for (sl
= specs
; sl
; sl
= sl
->next
)
1717 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1722 /* Not found - make it. */
1723 sl
= (struct spec_list
*) xmalloc (sizeof (struct spec_list
));
1724 sl
->name
= xstrdup (name
);
1725 sl
->name_len
= name_len
;
1726 sl
->ptr_spec
= &sl
->ptr
;
1728 *(sl
->ptr_spec
) = "";
1733 old_spec
= *(sl
->ptr_spec
);
1734 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1735 ? concat (old_spec
, spec
+ 1, NULL
)
1740 notice ("Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1743 /* Free the old spec. */
1744 if (old_spec
&& sl
->alloc_p
)
1745 free ((PTR
) old_spec
);
1750 /* Accumulate a command (program name and args), and run it. */
1752 /* Vector of pointers to arguments in the current line of specifications. */
1754 static const char **argbuf
;
1756 /* Number of elements allocated in argbuf. */
1758 static int argbuf_length
;
1760 /* Number of elements in argbuf currently in use (containing args). */
1762 static int argbuf_index
;
1764 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1765 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1768 static struct temp_name
{
1769 const char *suffix
; /* suffix associated with the code. */
1770 int length
; /* strlen (suffix). */
1771 int unique
; /* Indicates whether %g or %u/%U was used. */
1772 const char *filename
; /* associated filename. */
1773 int filename_length
; /* strlen (filename). */
1774 struct temp_name
*next
;
1777 /* Number of commands executed so far. */
1779 static int execution_count
;
1781 /* Number of commands that exited with a signal. */
1783 static int signal_count
;
1785 /* Name with which this program was invoked. */
1787 static const char *programname
;
1789 /* Allocate the argument vector. */
1795 argbuf
= (const char **) xmalloc (argbuf_length
* sizeof (const char *));
1798 /* Clear out the vector of arguments (after a command is executed). */
1806 /* Add one argument to the vector at the end.
1807 This is done when a space is seen or at the end of the line.
1808 If DELETE_ALWAYS is nonzero, the arg is a filename
1809 and the file should be deleted eventually.
1810 If DELETE_FAILURE is nonzero, the arg is a filename
1811 and the file should be deleted if this compilation fails. */
1814 store_arg (arg
, delete_always
, delete_failure
)
1816 int delete_always
, delete_failure
;
1818 if (argbuf_index
+ 1 == argbuf_length
)
1820 = (const char **) xrealloc (argbuf
,
1821 (argbuf_length
*= 2) * sizeof (const char *));
1823 argbuf
[argbuf_index
++] = arg
;
1824 argbuf
[argbuf_index
] = 0;
1826 if (delete_always
|| delete_failure
)
1827 record_temp_file (arg
, delete_always
, delete_failure
);
1830 /* Load specs from a file name named FILENAME, replacing occurrences of
1831 various different types of line-endings, \r\n, \n\r and just \r, with
1835 load_specs (filename
)
1836 const char *filename
;
1840 struct stat statbuf
;
1847 notice ("Reading specs from %s\n", filename
);
1849 /* Open and stat the file. */
1850 desc
= open (filename
, O_RDONLY
, 0);
1852 pfatal_with_name (filename
);
1853 if (stat (filename
, &statbuf
) < 0)
1854 pfatal_with_name (filename
);
1856 /* Read contents of file into BUFFER. */
1857 buffer
= xmalloc ((unsigned) statbuf
.st_size
+ 1);
1858 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1860 pfatal_with_name (filename
);
1861 buffer
[readlen
] = 0;
1864 specs
= xmalloc (readlen
+ 1);
1866 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1872 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1874 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1888 /* Read compilation specs from a file named FILENAME,
1889 replacing the default ones.
1891 A suffix which starts with `*' is a definition for
1892 one of the machine-specific sub-specs. The "suffix" should be
1893 *asm, *cc1, *cpp, *link, *startfile, etc.
1894 The corresponding spec is stored in asm_spec, etc.,
1895 rather than in the `compilers' vector.
1897 Anything invalid in the file is a fatal error. */
1900 read_specs (filename
, main_p
)
1901 const char *filename
;
1907 buffer
= load_specs (filename
);
1909 /* Scan BUFFER for specs, putting them in the vector. */
1915 char *in
, *out
, *p1
, *p2
, *p3
;
1917 /* Advance P in BUFFER to the next nonblank nocomment line. */
1918 p
= skip_whitespace (p
);
1922 /* Is this a special command that starts with '%'? */
1923 /* Don't allow this for the main specs file, since it would
1924 encourage people to overwrite it. */
1925 if (*p
== '%' && !main_p
)
1928 while (*p
&& *p
!= '\n')
1934 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1935 && (p1
[sizeof "%include" - 1] == ' '
1936 || p1
[sizeof "%include" - 1] == '\t'))
1940 p1
+= sizeof ("%include");
1941 while (*p1
== ' ' || *p1
== '\t')
1944 if (*p1
++ != '<' || p
[-2] != '>')
1945 fatal ("specs %%include syntax malformed after %ld characters",
1946 (long) (p1
- buffer
+ 1));
1949 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
1950 read_specs (new_filename
? new_filename
: p1
, FALSE
);
1953 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1954 && (p1
[sizeof "%include_noerr" - 1] == ' '
1955 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1959 p1
+= sizeof "%include_noerr";
1960 while (*p1
== ' ' || *p1
== '\t')
1963 if (*p1
++ != '<' || p
[-2] != '>')
1964 fatal ("specs %%include syntax malformed after %ld characters",
1965 (long) (p1
- buffer
+ 1));
1968 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
1970 read_specs (new_filename
, FALSE
);
1971 else if (verbose_flag
)
1972 notice ("could not find specs file %s\n", p1
);
1975 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1976 && (p1
[sizeof "%rename" - 1] == ' '
1977 || p1
[sizeof "%rename" - 1] == '\t'))
1980 struct spec_list
*sl
;
1981 struct spec_list
*newsl
;
1983 /* Get original name. */
1984 p1
+= sizeof "%rename";
1985 while (*p1
== ' ' || *p1
== '\t')
1988 if (! ISALPHA ((unsigned char) *p1
))
1989 fatal ("specs %%rename syntax malformed after %ld characters",
1990 (long) (p1
- buffer
));
1993 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1996 if (*p2
!= ' ' && *p2
!= '\t')
1997 fatal ("specs %%rename syntax malformed after %ld characters",
1998 (long) (p2
- buffer
));
2002 while (*p2
== ' ' || *p2
== '\t')
2005 if (! ISALPHA ((unsigned char) *p2
))
2006 fatal ("specs %%rename syntax malformed after %ld characters",
2007 (long) (p2
- buffer
));
2009 /* Get new spec name. */
2011 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2015 fatal ("specs %%rename syntax malformed after %ld characters",
2016 (long) (p3
- buffer
));
2019 for (sl
= specs
; sl
; sl
= sl
->next
)
2020 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2024 fatal ("specs %s spec was not found to be renamed", p1
);
2026 if (strcmp (p1
, p2
) == 0)
2029 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2030 if (strcmp (newsl
->name
, p2
) == 0)
2031 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2036 notice ("rename spec %s to %s\n", p1
, p2
);
2038 notice ("spec is '%s'\n\n", *(sl
->ptr_spec
));
2042 set_spec (p2
, *(sl
->ptr_spec
));
2044 free ((PTR
) *(sl
->ptr_spec
));
2046 *(sl
->ptr_spec
) = "";
2051 fatal ("specs unknown %% command after %ld characters",
2052 (long) (p1
- buffer
));
2055 /* Find the colon that should end the suffix. */
2057 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2060 /* The colon shouldn't be missing. */
2062 fatal ("specs file malformed after %ld characters",
2063 (long) (p1
- buffer
));
2065 /* Skip back over trailing whitespace. */
2067 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2070 /* Copy the suffix to a string. */
2071 suffix
= save_string (p
, p2
- p
);
2072 /* Find the next line. */
2073 p
= skip_whitespace (p1
+ 1);
2075 fatal ("specs file malformed after %ld characters",
2076 (long) (p
- buffer
));
2079 /* Find next blank line or end of string. */
2080 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2083 /* Specs end at the blank line and do not include the newline. */
2084 spec
= save_string (p
, p1
- p
);
2087 /* Delete backslash-newline sequences from the spec. */
2092 if (in
[0] == '\\' && in
[1] == '\n')
2094 else if (in
[0] == '#')
2095 while (*in
&& *in
!= '\n')
2103 if (suffix
[0] == '*')
2105 if (! strcmp (suffix
, "*link_command"))
2106 link_command_spec
= spec
;
2108 set_spec (suffix
+ 1, spec
);
2112 /* Add this pair to the vector. */
2114 = ((struct compiler
*)
2115 xrealloc (compilers
,
2116 (n_compilers
+ 2) * sizeof (struct compiler
)));
2118 compilers
[n_compilers
].suffix
= suffix
;
2119 compilers
[n_compilers
].spec
= spec
;
2121 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2125 link_command_spec
= spec
;
2128 if (link_command_spec
== 0)
2129 fatal ("spec file has no spec for linking");
2132 /* Record the names of temporary files we tell compilers to write,
2133 and delete them at the end of the run. */
2135 /* This is the common prefix we use to make temp file names.
2136 It is chosen once for each run of this program.
2137 It is substituted into a spec by %g or %j.
2138 Thus, all temp file names contain this prefix.
2139 In practice, all temp file names start with this prefix.
2141 This prefix comes from the envvar TMPDIR if it is defined;
2142 otherwise, from the P_tmpdir macro if that is defined;
2143 otherwise, in /usr/tmp or /tmp;
2144 or finally the current directory if all else fails. */
2146 static const char *temp_filename
;
2148 /* Length of the prefix. */
2150 static int temp_filename_length
;
2152 /* Define the list of temporary files to delete. */
2157 struct temp_file
*next
;
2160 /* Queue of files to delete on success or failure of compilation. */
2161 static struct temp_file
*always_delete_queue
;
2162 /* Queue of files to delete on failure of compilation. */
2163 static struct temp_file
*failure_delete_queue
;
2165 /* Record FILENAME as a file to be deleted automatically.
2166 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2167 otherwise delete it in any case.
2168 FAIL_DELETE nonzero means delete it if a compilation step fails;
2169 otherwise delete it in any case. */
2172 record_temp_file (filename
, always_delete
, fail_delete
)
2173 const char *filename
;
2177 char *const name
= xstrdup (filename
);
2181 struct temp_file
*temp
;
2182 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2183 if (! strcmp (name
, temp
->name
))
2186 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
2187 temp
->next
= always_delete_queue
;
2189 always_delete_queue
= temp
;
2196 struct temp_file
*temp
;
2197 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2198 if (! strcmp (name
, temp
->name
))
2201 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
2202 temp
->next
= failure_delete_queue
;
2204 failure_delete_queue
= temp
;
2210 /* Delete all the temporary files whose names we previously recorded. */
2213 delete_if_ordinary (name
)
2220 printf ("Delete %s? (y or n) ", name
);
2224 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2227 if (i
== 'y' || i
== 'Y')
2229 if (stat (name
, &st
) >= 0 && S_ISREG (st
.st_mode
))
2230 if (unlink (name
) < 0)
2232 perror_with_name (name
);
2236 delete_temp_files ()
2238 struct temp_file
*temp
;
2240 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2241 delete_if_ordinary (temp
->name
);
2242 always_delete_queue
= 0;
2245 /* Delete all the files to be deleted on error. */
2248 delete_failure_queue ()
2250 struct temp_file
*temp
;
2252 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2253 delete_if_ordinary (temp
->name
);
2257 clear_failure_queue ()
2259 failure_delete_queue
= 0;
2262 /* Build a list of search directories from PATHS.
2263 PREFIX is a string to prepend to the list.
2264 If CHECK_DIR_P is nonzero we ensure the directory exists.
2265 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2266 It is also used by the --print-search-dirs flag. */
2269 build_search_list (paths
, prefix
, check_dir_p
)
2270 struct path_prefix
*paths
;
2274 int suffix_len
= (machine_suffix
) ? strlen (machine_suffix
) : 0;
2276 = (just_machine_suffix
) ? strlen (just_machine_suffix
) : 0;
2277 int first_time
= TRUE
;
2278 struct prefix_list
*pprefix
;
2280 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2281 obstack_1grow (&collect_obstack
, '=');
2283 for (pprefix
= paths
->plist
; pprefix
!= 0; pprefix
= pprefix
->next
)
2285 int len
= strlen (pprefix
->prefix
);
2289 || is_directory (pprefix
->prefix
, machine_suffix
, 0)))
2292 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2295 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2296 obstack_grow (&collect_obstack
, machine_suffix
, suffix_len
);
2299 if (just_machine_suffix
2300 && pprefix
->require_machine_suffix
== 2
2302 || is_directory (pprefix
->prefix
, just_machine_suffix
, 0)))
2305 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2308 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2309 obstack_grow (&collect_obstack
, just_machine_suffix
,
2313 if (! pprefix
->require_machine_suffix
)
2316 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2319 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2323 obstack_1grow (&collect_obstack
, '\0');
2324 return obstack_finish (&collect_obstack
);
2327 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2331 putenv_from_prefixes (paths
, env_var
)
2332 struct path_prefix
*paths
;
2333 const char *env_var
;
2335 putenv (build_search_list (paths
, env_var
, 1));
2338 /* Check whether NAME can be accessed in MODE. This is like access,
2339 except that it never considers directories to be executable. */
2342 access_check (name
, mode
)
2350 if (stat (name
, &st
) < 0
2351 || S_ISDIR (st
.st_mode
))
2355 return access (name
, mode
);
2358 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2359 access to check permissions.
2360 Return 0 if not found, otherwise return its name, allocated with malloc. */
2363 find_a_file (pprefix
, name
, mode
, multilib
)
2364 struct path_prefix
*pprefix
;
2369 const char *const file_suffix
=
2370 ((mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "");
2371 struct prefix_list
*pl
;
2372 int len
= pprefix
->max_len
+ strlen (name
) + strlen (file_suffix
) + 1;
2373 const char *multilib_name
, *multilib_os_name
;
2375 #ifdef DEFAULT_ASSEMBLER
2376 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2377 return xstrdup (DEFAULT_ASSEMBLER
);
2380 #ifdef DEFAULT_LINKER
2381 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2382 return xstrdup (DEFAULT_LINKER
);
2386 len
+= strlen (machine_suffix
);
2388 multilib_name
= name
;
2389 multilib_os_name
= name
;
2390 if (multilib
&& multilib_os_dir
)
2392 int len1
= multilib_dir
? strlen (multilib_dir
) + 1 : 0;
2393 int len2
= strlen (multilib_os_dir
) + 1;
2395 len
+= len1
> len2
? len1
: len2
;
2397 multilib_name
= ACONCAT ((multilib_dir
, dir_separator_str
, name
,
2399 if (strcmp (multilib_os_dir
, ".") != 0)
2400 multilib_os_name
= ACONCAT ((multilib_os_dir
, dir_separator_str
, name
,
2404 temp
= xmalloc (len
);
2406 /* Determine the filename to execute (special case for absolute paths). */
2408 if (IS_ABSOLUTE_PATHNAME (name
))
2410 if (access (name
, mode
) == 0)
2412 strcpy (temp
, name
);
2417 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
2419 const char *this_name
2420 = pl
->os_multilib
? multilib_os_name
: multilib_name
;
2424 /* Some systems have a suffix for executable files.
2425 So try appending that first. */
2426 if (file_suffix
[0] != 0)
2428 strcpy (temp
, pl
->prefix
);
2429 strcat (temp
, machine_suffix
);
2430 strcat (temp
, multilib_name
);
2431 strcat (temp
, file_suffix
);
2432 if (access_check (temp
, mode
) == 0)
2434 if (pl
->used_flag_ptr
!= 0)
2435 *pl
->used_flag_ptr
= 1;
2440 /* Now try just the multilib_name. */
2441 strcpy (temp
, pl
->prefix
);
2442 strcat (temp
, machine_suffix
);
2443 strcat (temp
, multilib_name
);
2444 if (access_check (temp
, mode
) == 0)
2446 if (pl
->used_flag_ptr
!= 0)
2447 *pl
->used_flag_ptr
= 1;
2452 /* Certain prefixes are tried with just the machine type,
2453 not the version. This is used for finding as, ld, etc. */
2454 if (just_machine_suffix
&& pl
->require_machine_suffix
== 2)
2456 /* Some systems have a suffix for executable files.
2457 So try appending that first. */
2458 if (file_suffix
[0] != 0)
2460 strcpy (temp
, pl
->prefix
);
2461 strcat (temp
, just_machine_suffix
);
2462 strcat (temp
, multilib_name
);
2463 strcat (temp
, file_suffix
);
2464 if (access_check (temp
, mode
) == 0)
2466 if (pl
->used_flag_ptr
!= 0)
2467 *pl
->used_flag_ptr
= 1;
2472 strcpy (temp
, pl
->prefix
);
2473 strcat (temp
, just_machine_suffix
);
2474 strcat (temp
, multilib_name
);
2475 if (access_check (temp
, mode
) == 0)
2477 if (pl
->used_flag_ptr
!= 0)
2478 *pl
->used_flag_ptr
= 1;
2483 /* Certain prefixes can't be used without the machine suffix
2484 when the machine or version is explicitly specified. */
2485 if (! pl
->require_machine_suffix
)
2487 /* Some systems have a suffix for executable files.
2488 So try appending that first. */
2489 if (file_suffix
[0] != 0)
2491 strcpy (temp
, pl
->prefix
);
2492 strcat (temp
, this_name
);
2493 strcat (temp
, file_suffix
);
2494 if (access_check (temp
, mode
) == 0)
2496 if (pl
->used_flag_ptr
!= 0)
2497 *pl
->used_flag_ptr
= 1;
2502 strcpy (temp
, pl
->prefix
);
2503 strcat (temp
, this_name
);
2504 if (access_check (temp
, mode
) == 0)
2506 if (pl
->used_flag_ptr
!= 0)
2507 *pl
->used_flag_ptr
= 1;
2517 /* Ranking of prefixes in the sort list. -B prefixes are put before
2520 enum path_prefix_priority
2522 PREFIX_PRIORITY_B_OPT
,
2523 PREFIX_PRIORITY_LAST
2526 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2527 order according to PRIORITY. Within each PRIORITY, new entries are
2530 If WARN is nonzero, we will warn if no file is found
2531 through this prefix. WARN should point to an int
2532 which will be set to 1 if this entry is used.
2534 COMPONENT is the value to be passed to update_path.
2536 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2537 the complete value of machine_suffix.
2538 2 means try both machine_suffix and just_machine_suffix. */
2541 add_prefix (pprefix
, prefix
, component
, priority
, require_machine_suffix
,
2543 struct path_prefix
*pprefix
;
2545 const char *component
;
2546 /* enum prefix_priority */ int priority
;
2547 int require_machine_suffix
;
2551 struct prefix_list
*pl
, **prev
;
2554 for (prev
= &pprefix
->plist
;
2555 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2556 prev
= &(*prev
)->next
)
2559 /* Keep track of the longest prefix */
2561 prefix
= update_path (prefix
, component
);
2562 len
= strlen (prefix
);
2563 if (len
> pprefix
->max_len
)
2564 pprefix
->max_len
= len
;
2566 pl
= (struct prefix_list
*) xmalloc (sizeof (struct prefix_list
));
2567 pl
->prefix
= prefix
;
2568 pl
->require_machine_suffix
= require_machine_suffix
;
2569 pl
->used_flag_ptr
= warn
;
2570 pl
->priority
= priority
;
2571 pl
->os_multilib
= os_multilib
;
2575 /* Insert after PREV */
2580 /* Same as add_prefix, but prepending target_system_root to prefix. */
2582 add_sysrooted_prefix (pprefix
, prefix
, component
, priority
,
2583 require_machine_suffix
, warn
, os_multilib
)
2584 struct path_prefix
*pprefix
;
2586 const char *component
;
2587 /* enum prefix_priority */ int priority
;
2588 int require_machine_suffix
;
2592 if (!IS_ABSOLUTE_PATHNAME (prefix
))
2595 if (target_system_root
)
2597 prefix
= concat (target_system_root
, prefix
, NULL
);
2598 /* We have to override this because GCC's notion of sysroot
2599 moves along with GCC. */
2603 add_prefix (pprefix
, prefix
, component
, priority
,
2604 require_machine_suffix
, warn
, os_multilib
);
2607 /* Execute the command specified by the arguments on the current line of spec.
2608 When using pipes, this includes several piped-together commands
2609 with `|' between them.
2611 Return 0 if successful, -1 if failed. */
2617 int n_commands
; /* # of command. */
2621 const char *prog
; /* program name. */
2622 const char **argv
; /* vector of args. */
2623 int pid
; /* pid of process for this command. */
2626 struct command
*commands
; /* each command buffer with above info. */
2628 if (processing_spec_function
)
2631 /* Count # of piped commands. */
2632 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2633 if (strcmp (argbuf
[i
], "|") == 0)
2636 /* Get storage for each command. */
2637 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2639 /* Split argbuf into its separate piped processes,
2640 and record info about each one.
2641 Also search for the programs that are to be run. */
2643 commands
[0].prog
= argbuf
[0]; /* first command. */
2644 commands
[0].argv
= &argbuf
[0];
2645 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, 0);
2648 commands
[0].argv
[0] = string
;
2650 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2651 if (strcmp (argbuf
[i
], "|") == 0)
2652 { /* each command. */
2653 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2654 fatal ("-pipe not supported");
2656 argbuf
[i
] = 0; /* termination of command args. */
2657 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2658 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2659 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2662 commands
[n_commands
].argv
[0] = string
;
2666 argbuf
[argbuf_index
] = 0;
2668 /* If -v, print what we are about to do, and maybe query. */
2672 /* For help listings, put a blank line between sub-processes. */
2673 if (print_help_list
)
2674 fputc ('\n', stderr
);
2676 /* Print each piped command as a separate line. */
2677 for (i
= 0; i
< n_commands
; i
++)
2679 const char *const *j
;
2681 if (verbose_only_flag
)
2683 for (j
= commands
[i
].argv
; *j
; j
++)
2686 fprintf (stderr
, " \"");
2687 for (p
= *j
; *p
; ++p
)
2689 if (*p
== '"' || *p
== '\\' || *p
== '$')
2690 fputc ('\\', stderr
);
2693 fputc ('"', stderr
);
2697 for (j
= commands
[i
].argv
; *j
; j
++)
2698 fprintf (stderr
, " %s", *j
);
2700 /* Print a pipe symbol after all but the last command. */
2701 if (i
+ 1 != n_commands
)
2702 fprintf (stderr
, " |");
2703 fprintf (stderr
, "\n");
2706 if (verbose_only_flag
!= 0)
2709 notice ("\nGo ahead? (y or n) ");
2713 while (getchar () != '\n')
2716 if (i
!= 'y' && i
!= 'Y')
2721 #ifdef ENABLE_VALGRIND_CHECKING
2722 /* Run the each command through valgrind. To simplify prepending the
2723 path to valgrind and the option "-q" (for quiet operation unless
2724 something triggers), we allocate a separate argv array. */
2726 for (i
= 0; i
< n_commands
; i
++)
2732 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2735 argv
= alloca ((argc
+ 3) * sizeof (char *));
2737 argv
[0] = VALGRIND_PATH
;
2739 for (j
= 2; j
< argc
+ 2; j
++)
2740 argv
[j
] = commands
[i
].argv
[j
- 2];
2743 commands
[i
].argv
= argv
;
2744 commands
[i
].prog
= argv
[0];
2748 /* Run each piped subprocess. */
2750 for (i
= 0; i
< n_commands
; i
++)
2752 char *errmsg_fmt
, *errmsg_arg
;
2753 const char *string
= commands
[i
].argv
[0];
2755 /* For some bizarre reason, the second argument of execvp() is
2756 char *const *, not const char *const *. */
2757 commands
[i
].pid
= pexecute (string
, (char *const *) commands
[i
].argv
,
2758 programname
, temp_filename
,
2759 &errmsg_fmt
, &errmsg_arg
,
2760 ((i
== 0 ? PEXECUTE_FIRST
: 0)
2761 | (i
+ 1 == n_commands
? PEXECUTE_LAST
: 0)
2762 | (string
== commands
[i
].prog
2763 ? PEXECUTE_SEARCH
: 0)
2764 | (verbose_flag
? PEXECUTE_VERBOSE
: 0)));
2766 if (commands
[i
].pid
== -1)
2767 pfatal_pexecute (errmsg_fmt
, errmsg_arg
);
2769 if (string
!= commands
[i
].prog
)
2770 free ((PTR
) string
);
2775 /* Wait for all the subprocesses to finish.
2776 We don't care what order they finish in;
2777 we know that N_COMMANDS waits will get them all.
2778 Ignore subprocesses that we don't know about,
2779 since they can be spawned by the process that exec'ed us. */
2783 #ifdef HAVE_GETRUSAGE
2785 double ut
= 0.0, st
= 0.0;
2788 for (i
= 0; i
< n_commands
;)
2794 pid
= pwait (commands
[i
].pid
, &status
, 0);
2798 #ifdef HAVE_GETRUSAGE
2801 /* getrusage returns the total resource usage of all children
2802 up to now. Copy the previous values into prus, get the
2803 current statistics, then take the difference. */
2806 getrusage (RUSAGE_CHILDREN
, &rus
);
2807 d
.tv_sec
= rus
.ru_utime
.tv_sec
- prus
.ru_utime
.tv_sec
;
2808 d
.tv_usec
= rus
.ru_utime
.tv_usec
- prus
.ru_utime
.tv_usec
;
2809 ut
= (double) d
.tv_sec
+ (double) d
.tv_usec
/ 1.0e6
;
2811 d
.tv_sec
= rus
.ru_stime
.tv_sec
- prus
.ru_stime
.tv_sec
;
2812 d
.tv_usec
= rus
.ru_stime
.tv_usec
- prus
.ru_stime
.tv_usec
;
2813 st
= (double) d
.tv_sec
+ (double) d
.tv_usec
/ 1.0e6
;
2817 for (j
= 0; j
< n_commands
; j
++)
2818 if (commands
[j
].pid
== pid
)
2821 if (WIFSIGNALED (status
))
2824 /* SIGPIPE is a special case. It happens in -pipe mode
2825 when the compiler dies before the preprocessor is
2826 done, or the assembler dies before the compiler is
2827 done. There's generally been an error already, and
2828 this is just fallout. So don't generate another error
2829 unless we would otherwise have succeeded. */
2830 if (WTERMSIG (status
) == SIGPIPE
2831 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2836 Internal error: %s (program %s)\n\
2837 Please submit a full bug report.\n\
2838 See %s for instructions.",
2839 strsignal (WTERMSIG (status
)), commands
[j
].prog
,
2844 else if (WIFEXITED (status
)
2845 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2847 if (WEXITSTATUS (status
) > greatest_status
)
2848 greatest_status
= WEXITSTATUS (status
);
2851 #ifdef HAVE_GETRUSAGE
2852 if (report_times
&& ut
+ st
!= 0)
2853 notice ("# %s %.2f %.2f\n", commands
[j
].prog
, ut
, st
);
2862 /* Find all the switches given to us
2863 and make a vector describing them.
2864 The elements of the vector are strings, one per switch given.
2865 If a switch uses following arguments, then the `part1' field
2866 is the switch itself and the `args' field
2867 is a null-terminated vector containing the following arguments.
2868 The `live_cond' field is:
2870 1 if the switch is true in a conditional spec,
2871 -1 if false (overridden by a later switch)
2872 -2 if this switch should be ignored (used in %<S)
2873 The `validated' field is nonzero if any spec has looked at this switch;
2874 if it remains zero at the end of the run, it must be meaningless. */
2877 #define SWITCH_FALSE -1
2878 #define SWITCH_IGNORE -2
2879 #define SWITCH_LIVE 1
2886 unsigned char validated
;
2887 unsigned char ordering
;
2890 static struct switchstr
*switches
;
2892 static int n_switches
;
2897 const char *language
;
2900 /* Also a vector of input files specified. */
2902 static struct infile
*infiles
;
2906 /* This counts the number of libraries added by lang_specific_driver, so that
2907 we can tell if there were any user supplied any files or libraries. */
2909 static int added_libraries
;
2911 /* And a vector of corresponding output files is made up later. */
2913 const char **outfiles
;
2915 /* Used to track if none of the -B paths are used. */
2918 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2919 static int *warn_std_ptr
= 0;
2921 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2923 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2924 is true if we should look for an executable suffix. DO_OBJ
2925 is true if we should look for an object suffix. */
2928 convert_filename (name
, do_exe
, do_obj
)
2930 int do_exe ATTRIBUTE_UNUSED
;
2931 int do_obj ATTRIBUTE_UNUSED
;
2933 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2941 len
= strlen (name
);
2943 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2944 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2945 if (do_obj
&& len
> 2
2946 && name
[len
- 2] == '.'
2947 && name
[len
- 1] == 'o')
2949 obstack_grow (&obstack
, name
, len
- 2);
2950 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
2951 name
= obstack_finish (&obstack
);
2955 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2956 /* If there is no filetype, make it the executable suffix (which includes
2957 the "."). But don't get confused if we have just "-o". */
2958 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
2961 for (i
= len
- 1; i
>= 0; i
--)
2962 if (IS_DIR_SEPARATOR (name
[i
]))
2965 for (i
++; i
< len
; i
++)
2969 obstack_grow (&obstack
, name
, len
);
2970 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
2971 strlen (TARGET_EXECUTABLE_SUFFIX
));
2972 name
= obstack_finish (&obstack
);
2979 /* Display the command line switches accepted by gcc. */
2983 printf (_("Usage: %s [options] file...\n"), programname
);
2984 fputs (_("Options:\n"), stdout
);
2986 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
2987 fputs (_(" --help Display this information\n"), stdout
);
2988 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
2990 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
2991 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
2992 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
2993 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
2994 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
2995 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
2996 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
2997 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
2998 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3000 -print-multi-lib Display the mapping between command line options and\n\
3001 multiple library search directories\n"), stdout
);
3002 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3003 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3004 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3005 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3006 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3007 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3008 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3009 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3010 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3011 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3012 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3013 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3014 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3015 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout
);
3016 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout
);
3017 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3018 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3019 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3020 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3021 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3022 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3024 -x <language> Specify the language of the following input files\n\
3025 Permissable languages include: c c++ assembler none\n\
3026 'none' means revert to the default behavior of\n\
3027 guessing the language based on the file's extension\n\
3031 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3032 passed on to the various sub-processes invoked by %s. In order to pass\n\
3033 other options on to these processes the -W<letter> options must be used.\n\
3036 /* The rest of the options are displayed by invocations of the various
3041 add_preprocessor_option (option
, len
)
3045 n_preprocessor_options
++;
3047 if (! preprocessor_options
)
3048 preprocessor_options
3049 = (char **) xmalloc (n_preprocessor_options
* sizeof (char *));
3051 preprocessor_options
3052 = (char **) xrealloc (preprocessor_options
,
3053 n_preprocessor_options
* sizeof (char *));
3055 preprocessor_options
[n_preprocessor_options
- 1] =
3056 save_string (option
, len
);
3060 add_assembler_option (option
, len
)
3064 n_assembler_options
++;
3066 if (! assembler_options
)
3068 = (char **) xmalloc (n_assembler_options
* sizeof (char *));
3071 = (char **) xrealloc (assembler_options
,
3072 n_assembler_options
* sizeof (char *));
3074 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3078 add_linker_option (option
, len
)
3084 if (! linker_options
)
3086 = (char **) xmalloc (n_linker_options
* sizeof (char *));
3089 = (char **) xrealloc (linker_options
,
3090 n_linker_options
* sizeof (char *));
3092 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3095 /* Create the vector `switches' and its contents.
3096 Store its length in `n_switches'. */
3099 process_command (argc
, argv
)
3101 const char *const *argv
;
3106 const char *spec_lang
= 0;
3107 int last_language_n_infiles
;
3110 int lang_n_infiles
= 0;
3111 #ifdef MODIFY_TARGET_NAME
3112 int is_modify_target_name
;
3116 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3120 added_libraries
= 0;
3122 /* Figure compiler version from version string. */
3124 compiler_version
= temp1
= xstrdup (version_string
);
3126 for (; *temp1
; ++temp1
)
3135 /* If there is a -V or -b option (or both), process it now, before
3136 trying to interpret the rest of the command line. */
3137 if (argc
> 1 && argv
[1][0] == '-'
3138 && (argv
[1][1] == 'V' || argv
[1][1] == 'b'))
3140 const char *new_version
= DEFAULT_TARGET_VERSION
;
3141 const char *new_machine
= DEFAULT_TARGET_MACHINE
;
3142 const char *progname
= argv
[0];
3147 while (argc
> 1 && argv
[1][0] == '-'
3148 && (argv
[1][1] == 'V' || argv
[1][1] == 'b'))
3150 char opt
= argv
[1][1];
3152 if (argv
[1][2] != '\0')
3165 fatal ("`-%c' option must have argument", opt
);
3172 for (baselen
= strlen (progname
); baselen
> 0; baselen
--)
3173 if (IS_DIR_SEPARATOR (progname
[baselen
-1]))
3175 new_argv0
= xmemdup (progname
, baselen
,
3176 baselen
+ concat_length (new_version
, new_machine
,
3177 "-gcc-", NULL
) + 1);
3178 strcpy (new_argv0
+ baselen
, new_machine
);
3179 strcat (new_argv0
, "-gcc-");
3180 strcat (new_argv0
, new_version
);
3182 new_argv
= xmemdup (argv
, (argc
+ 1) * sizeof (argv
[0]),
3183 (argc
+ 1) * sizeof (argv
[0]));
3184 new_argv
[0] = new_argv0
;
3186 execvp (new_argv0
, new_argv
);
3187 fatal ("couldn't run `%s': %s", new_argv0
, xstrerror (errno
));
3190 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3191 see if we can create it from the pathname specified in argv[0]. */
3194 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3195 if (!gcc_exec_prefix
)
3197 gcc_exec_prefix
= make_relative_prefix (argv
[0], standard_bindir_prefix
,
3198 standard_exec_prefix
);
3199 if (gcc_exec_prefix
)
3200 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3204 if (gcc_exec_prefix
)
3206 int len
= strlen (gcc_exec_prefix
);
3208 if (len
> (int) sizeof ("/lib/gcc-lib/") - 1
3209 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3211 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc-lib/") + 1;
3212 if (IS_DIR_SEPARATOR (*temp
)
3213 && strncmp (temp
+ 1, "lib", 3) == 0
3214 && IS_DIR_SEPARATOR (temp
[4])
3215 && strncmp (temp
+ 5, "gcc-lib", 7) == 0)
3216 len
-= sizeof ("/lib/gcc-lib/") - 1;
3219 set_std_prefix (gcc_exec_prefix
, len
);
3220 add_prefix (&exec_prefixes
, gcc_exec_prefix
, "GCC",
3221 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3222 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3223 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3226 /* COMPILER_PATH and LIBRARY_PATH have values
3227 that are lists of directory names with colons. */
3229 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3232 const char *startp
, *endp
;
3233 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3235 startp
= endp
= temp
;
3238 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3240 strncpy (nstore
, startp
, endp
- startp
);
3242 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3243 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3245 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3246 nstore
[endp
- startp
+ 1] = 0;
3249 nstore
[endp
- startp
] = 0;
3250 add_prefix (&exec_prefixes
, nstore
, 0,
3251 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3252 add_prefix (&include_prefixes
,
3253 concat (nstore
, "include", NULL
),
3254 0, PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3257 endp
= startp
= endp
+ 1;
3264 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3265 if (temp
&& *cross_compile
== '0')
3267 const char *startp
, *endp
;
3268 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3270 startp
= endp
= temp
;
3273 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3275 strncpy (nstore
, startp
, endp
- startp
);
3277 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3278 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3280 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3281 nstore
[endp
- startp
+ 1] = 0;
3284 nstore
[endp
- startp
] = 0;
3285 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3286 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3289 endp
= startp
= endp
+ 1;
3296 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3297 GET_ENVIRONMENT (temp
, "LPATH");
3298 if (temp
&& *cross_compile
== '0')
3300 const char *startp
, *endp
;
3301 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3303 startp
= endp
= temp
;
3306 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3308 strncpy (nstore
, startp
, endp
- startp
);
3310 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3311 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3313 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3314 nstore
[endp
- startp
+ 1] = 0;
3317 nstore
[endp
- startp
] = 0;
3318 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3319 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3322 endp
= startp
= endp
+ 1;
3329 /* Convert new-style -- options to old-style. */
3330 translate_options (&argc
, &argv
);
3332 /* Do language-specific adjustment/addition of flags. */
3333 lang_specific_driver (&argc
, &argv
, &added_libraries
);
3335 /* Scan argv twice. Here, the first time, just count how many switches
3336 there will be in their vector, and how many input files in theirs.
3337 Here we also parse the switches that cc itself uses (e.g. -v). */
3339 for (i
= 1; i
< argc
; i
++)
3341 if (! strcmp (argv
[i
], "-dumpspecs"))
3343 struct spec_list
*sl
;
3345 for (sl
= specs
; sl
; sl
= sl
->next
)
3346 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3347 if (link_command_spec
)
3348 printf ("*link_command:\n%s\n\n", link_command_spec
);
3351 else if (! strcmp (argv
[i
], "-dumpversion"))
3353 printf ("%s\n", spec_version
);
3356 else if (! strcmp (argv
[i
], "-dumpmachine"))
3358 printf ("%s\n", spec_machine
);
3361 else if (strcmp (argv
[i
], "-fversion") == 0)
3363 /* translate_options () has turned --version into -fversion. */
3364 printf (_("%s (GCC) %s\n"), programname
, version_string
);
3365 fputs (_("Copyright (C) 2002 Free Software Foundation, Inc.\n"),
3367 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3368 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3372 else if (strcmp (argv
[i
], "-fhelp") == 0)
3374 /* translate_options () has turned --help into -fhelp. */
3375 print_help_list
= 1;
3377 /* We will be passing a dummy file on to the sub-processes. */
3381 /* CPP driver cannot obtain switch from cc1_options. */
3383 add_preprocessor_option ("--help", 6);
3384 add_assembler_option ("--help", 6);
3385 add_linker_option ("--help", 6);
3387 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3389 /* translate_options() has turned --target-help into -ftarget-help. */
3390 target_help_flag
= 1;
3392 /* We will be passing a dummy file on to the sub-processes. */
3396 /* CPP driver cannot obtain switch from cc1_options. */
3398 add_preprocessor_option ("--target-help", 13);
3399 add_assembler_option ("--target-help", 13);
3400 add_linker_option ("--target-help", 13);
3402 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3404 pass_exit_codes
= 1;
3407 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3408 print_search_dirs
= 1;
3409 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3410 print_file_name
= "libgcc.a";
3411 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3412 print_file_name
= argv
[i
] + 17;
3413 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3414 print_prog_name
= argv
[i
] + 17;
3415 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3416 print_multi_lib
= 1;
3417 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3418 print_multi_directory
= 1;
3419 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3420 print_multi_os_directory
= 1;
3421 else if (! strncmp (argv
[i
], "-Wa,", 4))
3424 /* Pass the rest of this option to the assembler. */
3426 /* Split the argument at commas. */
3428 for (j
= 4; argv
[i
][j
]; j
++)
3429 if (argv
[i
][j
] == ',')
3431 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3435 /* Record the part after the last comma. */
3436 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3438 else if (! strncmp (argv
[i
], "-Wp,", 4))
3441 /* Pass the rest of this option to the preprocessor. */
3443 /* Split the argument at commas. */
3445 for (j
= 4; argv
[i
][j
]; j
++)
3446 if (argv
[i
][j
] == ',')
3448 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3452 /* Record the part after the last comma. */
3453 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3455 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3456 /* The +e options to the C++ front-end. */
3458 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3461 /* Split the argument at commas. */
3462 for (j
= 3; argv
[i
][j
]; j
++)
3463 n_infiles
+= (argv
[i
][j
] == ',');
3465 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3468 fatal ("argument to `-Xlinker' is missing");
3473 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3476 fatal ("argument to `-Xpreprocessor' is missing");
3478 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3480 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3483 fatal ("argument to `-Xassembler' is missing");
3485 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3487 else if (strcmp (argv
[i
], "-l") == 0)
3490 fatal ("argument to `-l' is missing");
3495 else if (strncmp (argv
[i
], "-l", 2) == 0)
3497 else if (strcmp (argv
[i
], "-save-temps") == 0)
3499 save_temps_flag
= 1;
3502 else if (strcmp (argv
[i
], "-specs") == 0)
3504 struct user_specs
*user
= (struct user_specs
*)
3505 xmalloc (sizeof (struct user_specs
));
3507 fatal ("argument to `-specs' is missing");
3509 user
->next
= (struct user_specs
*) 0;
3510 user
->filename
= argv
[i
];
3511 if (user_specs_tail
)
3512 user_specs_tail
->next
= user
;
3514 user_specs_head
= user
;
3515 user_specs_tail
= user
;
3517 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3519 struct user_specs
*user
= (struct user_specs
*)
3520 xmalloc (sizeof (struct user_specs
));
3521 if (strlen (argv
[i
]) == 7)
3522 fatal ("argument to `-specs=' is missing");
3524 user
->next
= (struct user_specs
*) 0;
3525 user
->filename
= argv
[i
] + 7;
3526 if (user_specs_tail
)
3527 user_specs_tail
->next
= user
;
3529 user_specs_head
= user
;
3530 user_specs_tail
= user
;
3532 else if (strcmp (argv
[i
], "-time") == 0)
3534 else if (strcmp (argv
[i
], "-pipe") == 0)
3536 /* -pipe has to go into the switches array as well as
3541 else if (strcmp (argv
[i
], "-###") == 0)
3543 /* This is similar to -v except that there is no execution
3544 of the commands and the echoed arguments are quoted. It
3545 is intended for use in shell scripts to capture the
3546 driver-generated command line. */
3547 verbose_only_flag
++;
3550 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3552 const char *p
= &argv
[i
][1];
3559 fatal ("`-%c' must come at the start of the command line", c
);
3567 if (p
[1] == 0 && i
+ 1 == argc
)
3568 fatal ("argument to `-B' is missing");
3574 len
= strlen (value
);
3576 /* Catch the case where the user has forgotten to append a
3577 directory separator to the path. Note, they may be using
3578 -B to add an executable name prefix, eg "i386-elf-", in
3579 order to distinguish between multiple installations of
3580 GCC in the same directory. Hence we must check to see
3581 if appending a directory separator actually makes a
3582 valid directory name. */
3583 if (! IS_DIR_SEPARATOR (value
[len
- 1])
3584 && is_directory (value
, "", 0))
3586 char *tmp
= xmalloc (len
+ 2);
3587 strcpy (tmp
, value
);
3588 tmp
[len
] = DIR_SEPARATOR
;
3593 /* As a kludge, if the arg is "[foo/]stageN/", just
3594 add "[foo/]include" to the include prefix. */
3597 && (IS_DIR_SEPARATOR (value
[len
- 8]))))
3598 && strncmp (value
+ len
- 7, "stage", 5) == 0
3599 && ISDIGIT (value
[len
- 2])
3600 && (IS_DIR_SEPARATOR (value
[len
- 1])))
3603 add_prefix (&include_prefixes
, "include", NULL
,
3604 PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3607 char * string
= xmalloc (len
+ 1);
3609 strncpy (string
, value
, len
- 7);
3610 strcpy (string
+ len
- 7, "include");
3611 add_prefix (&include_prefixes
, string
, NULL
,
3612 PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3616 add_prefix (&exec_prefixes
, value
, NULL
,
3617 PREFIX_PRIORITY_B_OPT
, 0, &warn_B
, 0);
3618 add_prefix (&startfile_prefixes
, value
, NULL
,
3619 PREFIX_PRIORITY_B_OPT
, 0, &warn_B
, 0);
3620 add_prefix (&include_prefixes
, concat (value
, "include", NULL
),
3621 NULL
, PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3626 case 'v': /* Print our subcommands and print versions. */
3628 /* If they do anything other than exactly `-v', don't set
3629 verbose_flag; rather, continue on to give the error. */
3647 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3652 /* Forward scan, just in case -S or -c is specified
3659 if (argv
[j
][0] == '-')
3661 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
3667 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
3668 j
+= skip
- (argv
[j
][2] != 0);
3669 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
3676 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3678 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
3680 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
3687 #ifdef MODIFY_TARGET_NAME
3688 is_modify_target_name
= 0;
3690 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3691 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3694 = (char *) xmalloc (strlen (modify_target
[j
].str
)
3695 + strlen (spec_machine
));
3698 int made_addition
= 0;
3700 is_modify_target_name
= 1;
3701 for (p
= spec_machine
, q
= new_name
; *p
!= 0; )
3703 if (modify_target
[j
].add_del
== DELETE
3704 && (! strncmp (q
, modify_target
[j
].str
,
3705 strlen (modify_target
[j
].str
))))
3706 p
+= strlen (modify_target
[j
].str
);
3707 else if (modify_target
[j
].add_del
== ADD
3708 && ! made_addition
&& *p
== '-')
3710 for (r
= modify_target
[j
].str
; *r
!= 0; )
3718 spec_machine
= new_name
;
3721 if (is_modify_target_name
)
3727 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
3728 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
3729 else if (WORD_SWITCH_TAKES_ARG (p
))
3730 i
+= WORD_SWITCH_TAKES_ARG (p
);
3740 if (have_c
&& have_o
&& lang_n_infiles
> 1)
3741 fatal ("cannot specify -o with -c or -S and multiple compilations");
3743 if ((save_temps_flag
|| report_times
) && use_pipes
)
3745 /* -save-temps overrides -pipe, so that temp files are produced */
3746 if (save_temps_flag
)
3747 error ("warning: -pipe ignored because -save-temps specified");
3748 /* -time overrides -pipe because we can't get correct stats when
3749 multiple children are running at once. */
3750 else if (report_times
)
3751 error ("warning: -pipe ignored because -time specified");
3756 /* Set up the search paths before we go looking for config files. */
3758 /* These come before the md prefixes so that we will find gcc's subcommands
3759 (such as cpp) rather than those of the host system. */
3760 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3761 as well as trying the machine and the version. */
3763 add_prefix (&exec_prefixes
, standard_exec_prefix
, "GCC",
3764 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3765 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3766 PREFIX_PRIORITY_LAST
, 2, warn_std_ptr
, 0);
3767 add_prefix (&exec_prefixes
, standard_exec_prefix_1
, "BINUTILS",
3768 PREFIX_PRIORITY_LAST
, 2, warn_std_ptr
, 0);
3771 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3772 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3773 add_prefix (&startfile_prefixes
, standard_exec_prefix_1
, "BINUTILS",
3774 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3776 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
3777 dir_separator_str
, NULL
);
3779 /* If tooldir is relative, base it on exec_prefixes. A relative
3780 tooldir lets us move the installed tree as a unit.
3782 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3783 directories, so that we can search both the user specified directory
3784 and the standard place. */
3786 if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix
))
3788 if (gcc_exec_prefix
)
3790 char *gcc_exec_tooldir_prefix
3791 = concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
3792 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
3794 add_prefix (&exec_prefixes
,
3795 concat (gcc_exec_tooldir_prefix
, "bin",
3796 dir_separator_str
, NULL
),
3797 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3798 add_prefix (&startfile_prefixes
,
3799 concat (gcc_exec_tooldir_prefix
, "lib",
3800 dir_separator_str
, NULL
),
3801 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3804 tooldir_prefix
= concat (standard_exec_prefix
, spec_machine
,
3805 dir_separator_str
, spec_version
,
3806 dir_separator_str
, tooldir_prefix
, NULL
);
3809 add_prefix (&exec_prefixes
,
3810 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
3811 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3812 add_prefix (&startfile_prefixes
,
3813 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
3814 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3816 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3817 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3818 then consider it to relocate with the rest of the GCC installation
3819 if GCC_EXEC_PREFIX is set.
3820 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3821 if (target_system_root
&& gcc_exec_prefix
)
3823 char *tmp_prefix
= make_relative_prefix (argv
[0],
3824 standard_bindir_prefix
,
3825 target_system_root
);
3826 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
3828 target_system_root
= tmp_prefix
;
3829 target_system_root_changed
= 1;
3834 /* More prefixes are enabled in main, after we read the specs file
3835 and determine whether this is cross-compilation or not. */
3837 /* Then create the space for the vectors and scan again. */
3839 switches
= ((struct switchstr
*)
3840 xmalloc ((n_switches
+ 1) * sizeof (struct switchstr
)));
3841 infiles
= (struct infile
*) xmalloc ((n_infiles
+ 1) * sizeof (struct infile
));
3844 last_language_n_infiles
= -1;
3846 /* This, time, copy the text of each switch and store a pointer
3847 to the copy in the vector of switches.
3848 Store all the infiles in their vector. */
3850 for (i
= 1; i
< argc
; i
++)
3852 /* Just skip the switches that were handled by the preceding loop. */
3853 #ifdef MODIFY_TARGET_NAME
3854 is_modify_target_name
= 0;
3856 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3857 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3858 is_modify_target_name
= 1;
3860 if (is_modify_target_name
)
3864 if (! strncmp (argv
[i
], "-Wa,", 4))
3866 else if (! strncmp (argv
[i
], "-Wp,", 4))
3868 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3870 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3872 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3874 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3876 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3878 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3880 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3882 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3884 else if (! strcmp (argv
[i
], "-ftarget-help"))
3886 else if (! strcmp (argv
[i
], "-fhelp"))
3888 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3890 /* Compensate for the +e options to the C++ front-end;
3891 they're there simply for cfront call-compatibility. We do
3892 some magic in default_compilers to pass them down properly.
3893 Note we deliberately start at the `+' here, to avoid passing
3894 -e0 or -e1 down into the linker. */
3895 switches
[n_switches
].part1
= &argv
[i
][0];
3896 switches
[n_switches
].args
= 0;
3897 switches
[n_switches
].live_cond
= SWITCH_OK
;
3898 switches
[n_switches
].validated
= 0;
3901 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3904 /* Split the argument at commas. */
3906 for (j
= 4; argv
[i
][j
]; j
++)
3907 if (argv
[i
][j
] == ',')
3909 infiles
[n_infiles
].language
= "*";
3910 infiles
[n_infiles
++].name
3911 = save_string (argv
[i
] + prev
, j
- prev
);
3914 /* Record the part after the last comma. */
3915 infiles
[n_infiles
].language
= "*";
3916 infiles
[n_infiles
++].name
= argv
[i
] + prev
;
3918 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3920 infiles
[n_infiles
].language
= "*";
3921 infiles
[n_infiles
++].name
= argv
[++i
];
3923 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3925 infiles
[n_infiles
].language
= "*";
3926 infiles
[n_infiles
++].name
= argv
[++i
];
3928 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3930 infiles
[n_infiles
].language
= "*";
3931 infiles
[n_infiles
++].name
= argv
[++i
];
3933 else if (strcmp (argv
[i
], "-l") == 0)
3934 { /* POSIX allows separation of -l and the lib arg;
3935 canonicalize by concatenating -l with its arg */
3936 infiles
[n_infiles
].language
= "*";
3937 infiles
[n_infiles
++].name
= concat ("-l", argv
[++i
], NULL
);
3939 else if (strncmp (argv
[i
], "-l", 2) == 0)
3941 infiles
[n_infiles
].language
= "*";
3942 infiles
[n_infiles
++].name
= argv
[i
];
3944 else if (strcmp (argv
[i
], "-specs") == 0)
3946 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3948 else if (strcmp (argv
[i
], "-time") == 0)
3950 else if (strcmp (argv
[i
], "-###") == 0)
3952 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3954 const char *p
= &argv
[i
][1];
3959 if (p
[1] == 0 && i
+ 1 == argc
)
3960 fatal ("argument to `-x' is missing");
3962 spec_lang
= argv
[++i
];
3965 if (! strcmp (spec_lang
, "none"))
3966 /* Suppress the warning if -xnone comes after the last input
3967 file, because alternate command interfaces like g++ might
3968 find it useful to place -xnone after each input file. */
3971 last_language_n_infiles
= n_infiles
;
3974 switches
[n_switches
].part1
= p
;
3975 /* Deal with option arguments in separate argv elements. */
3976 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
3977 || WORD_SWITCH_TAKES_ARG (p
))
3980 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
3984 /* Count only the option arguments in separate argv elements. */
3985 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
3987 if (i
+ n_args
>= argc
)
3988 fatal ("argument to `-%s' is missing", p
);
3989 switches
[n_switches
].args
3990 = (const char **) xmalloc ((n_args
+ 1) * sizeof(const char *));
3992 switches
[n_switches
].args
[j
++] = argv
[++i
];
3993 /* Null-terminate the vector. */
3994 switches
[n_switches
].args
[j
] = 0;
3996 else if (strchr (switches_need_spaces
, c
))
3998 /* On some systems, ld cannot handle some options without
3999 a space. So split the option from its argument. */
4000 char *part1
= (char *) xmalloc (2);
4004 switches
[n_switches
].part1
= part1
;
4005 switches
[n_switches
].args
4006 = (const char **) xmalloc (2 * sizeof (const char *));
4007 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4008 switches
[n_switches
].args
[1] = 0;
4011 switches
[n_switches
].args
= 0;
4013 switches
[n_switches
].live_cond
= SWITCH_OK
;
4014 switches
[n_switches
].validated
= 0;
4015 switches
[n_switches
].ordering
= 0;
4016 /* These are always valid, since gcc.c itself understands them. */
4017 if (!strcmp (p
, "save-temps")
4018 || !strcmp (p
, "static-libgcc")
4019 || !strcmp (p
, "shared-libgcc")
4020 || !strcmp (p
, "pipe"))
4021 switches
[n_switches
].validated
= 1;
4024 char ch
= switches
[n_switches
].part1
[0];
4026 switches
[n_switches
].validated
= 1;
4032 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4033 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4036 if (strcmp (argv
[i
], "-") != 0 && access (argv
[i
], F_OK
) < 0)
4038 perror_with_name (argv
[i
]);
4043 infiles
[n_infiles
].language
= spec_lang
;
4044 infiles
[n_infiles
++].name
= argv
[i
];
4049 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4050 error ("warning: `-x %s' after last input file has no effect", spec_lang
);
4052 /* Ensure we only invoke each subprocess once. */
4053 if (target_help_flag
|| print_help_list
)
4057 /* Create a dummy input file, so that we can pass --target-help on to
4058 the various sub-processes. */
4059 infiles
[0].language
= "c";
4060 infiles
[0].name
= "help-dummy";
4062 if (target_help_flag
)
4064 switches
[n_switches
].part1
= "--target-help";
4065 switches
[n_switches
].args
= 0;
4066 switches
[n_switches
].live_cond
= SWITCH_OK
;
4067 switches
[n_switches
].validated
= 0;
4072 if (print_help_list
)
4074 switches
[n_switches
].part1
= "--help";
4075 switches
[n_switches
].args
= 0;
4076 switches
[n_switches
].live_cond
= SWITCH_OK
;
4077 switches
[n_switches
].validated
= 0;
4083 switches
[n_switches
].part1
= 0;
4084 infiles
[n_infiles
].name
= 0;
4087 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4088 and place that in the environment. */
4091 set_collect_gcc_options ()
4096 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4098 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4099 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4102 for (i
= 0; (int) i
< n_switches
; i
++)
4104 const char *const *args
;
4107 obstack_grow (&collect_obstack
, " ", 1);
4111 /* Ignore elided switches. */
4112 if (switches
[i
].live_cond
== SWITCH_IGNORE
)
4115 obstack_grow (&collect_obstack
, "'-", 2);
4116 q
= switches
[i
].part1
;
4117 while ((p
= strchr (q
, '\'')))
4119 obstack_grow (&collect_obstack
, q
, p
- q
);
4120 obstack_grow (&collect_obstack
, "'\\''", 4);
4123 obstack_grow (&collect_obstack
, q
, strlen (q
));
4124 obstack_grow (&collect_obstack
, "'", 1);
4126 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4128 obstack_grow (&collect_obstack
, " '", 2);
4130 while ((p
= strchr (q
, '\'')))
4132 obstack_grow (&collect_obstack
, q
, p
- q
);
4133 obstack_grow (&collect_obstack
, "'\\''", 4);
4136 obstack_grow (&collect_obstack
, q
, strlen (q
));
4137 obstack_grow (&collect_obstack
, "'", 1);
4140 obstack_grow (&collect_obstack
, "\0", 1);
4141 putenv (obstack_finish (&collect_obstack
));
4144 /* Process a spec string, accumulating and running commands. */
4146 /* These variables describe the input file name.
4147 input_file_number is the index on outfiles of this file,
4148 so that the output file name can be stored for later use by %o.
4149 input_basename is the start of the part of the input file
4150 sans all directory names, and basename_length is the number
4151 of characters starting there excluding the suffix .c or whatever. */
4153 const char *input_filename
;
4154 static int input_file_number
;
4155 size_t input_filename_length
;
4156 static int basename_length
;
4157 static int suffixed_basename_length
;
4158 static const char *input_basename
;
4159 static const char *input_suffix
;
4160 static struct stat input_stat
;
4161 static int input_stat_set
;
4163 /* The compiler used to process the current input file. */
4164 static struct compiler
*input_file_compiler
;
4166 /* These are variables used within do_spec and do_spec_1. */
4168 /* Nonzero if an arg has been started and not yet terminated
4169 (with space, tab or newline). */
4170 static int arg_going
;
4172 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4173 is a temporary file name. */
4174 static int delete_this_arg
;
4176 /* Nonzero means %w has been seen; the next arg to be terminated
4177 is the output file name of this compilation. */
4178 static int this_is_output_file
;
4180 /* Nonzero means %s has been seen; the next arg to be terminated
4181 is the name of a library file and we should try the standard
4182 search dirs for it. */
4183 static int this_is_library_file
;
4185 /* Nonzero means that the input of this command is coming from a pipe. */
4186 static int input_from_pipe
;
4188 /* Nonnull means substitute this for any suffix when outputting a switches
4190 static const char *suffix_subst
;
4192 /* Process the spec SPEC and run the commands specified therein.
4193 Returns 0 if the spec is successfully processed; -1 if failed. */
4201 value
= do_spec_2 (spec
);
4203 /* Force out any unfinished command.
4204 If -pipe, this forces out the last command if it ended in `|'. */
4207 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4210 set_collect_gcc_options ();
4212 if (argbuf_index
> 0)
4228 delete_this_arg
= 0;
4229 this_is_output_file
= 0;
4230 this_is_library_file
= 0;
4231 input_from_pipe
= 0;
4232 suffix_subst
= NULL
;
4234 result
= do_spec_1 (spec
, 0, NULL
);
4236 /* End any pending argument. */
4239 obstack_1grow (&obstack
, 0);
4240 string
= obstack_finish (&obstack
);
4241 if (this_is_library_file
)
4242 string
= find_file (string
);
4243 store_arg (string
, delete_this_arg
, this_is_output_file
);
4244 if (this_is_output_file
)
4245 outfiles
[input_file_number
] = string
;
4253 /* Process the given spec string and add any new options to the end
4254 of the switches/n_switches array. */
4261 do_spec_1 (" ", 0, NULL
);
4263 if (argbuf_index
> 0)
4268 n_switches
+= argbuf_index
;
4269 switches
= xrealloc (switches
,
4270 sizeof (struct switchstr
) * (n_switches
+ 1));
4272 switches
[n_switches
] = switches
[first
];
4273 for (i
= 0; i
< argbuf_index
; i
++)
4275 struct switchstr
*sw
;
4277 /* Each switch should start with '-'. */
4278 if (argbuf
[i
][0] != '-')
4281 sw
= &switches
[i
+ first
];
4282 sw
->part1
= &argbuf
[i
][1];
4284 sw
->live_cond
= SWITCH_OK
;
4291 /* Process the sub-spec SPEC as a portion of a larger spec.
4292 This is like processing a whole spec except that we do
4293 not initialize at the beginning and we do not supply a
4294 newline by default at the end.
4295 INSWITCH nonzero means don't process %-sequences in SPEC;
4296 in this case, % is treated as an ordinary character.
4297 This is used while substituting switches.
4298 INSWITCH nonzero also causes SPC not to terminate an argument.
4300 Value is zero unless a line was finished
4301 and the command on that line reported an error. */
4304 do_spec_1 (spec
, inswitch
, soft_matched_part
)
4307 const char *soft_matched_part
;
4309 const char *p
= spec
;
4316 /* If substituting a switch, treat all chars like letters.
4317 Otherwise, NL, SPC, TAB and % are special. */
4318 switch (inswitch
? 'a' : c
)
4321 /* End of line: finish any pending argument,
4322 then run the pending command if one has been started. */
4325 obstack_1grow (&obstack
, 0);
4326 string
= obstack_finish (&obstack
);
4327 if (this_is_library_file
)
4328 string
= find_file (string
);
4329 store_arg (string
, delete_this_arg
, this_is_output_file
);
4330 if (this_is_output_file
)
4331 outfiles
[input_file_number
] = string
;
4335 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4337 /* A `|' before the newline means use a pipe here,
4338 but only if -pipe was specified.
4339 Otherwise, execute now and don't pass the `|' as an arg. */
4342 input_from_pipe
= 1;
4349 set_collect_gcc_options ();
4351 if (argbuf_index
> 0)
4357 /* Reinitialize for a new command, and for a new argument. */
4360 delete_this_arg
= 0;
4361 this_is_output_file
= 0;
4362 this_is_library_file
= 0;
4363 input_from_pipe
= 0;
4367 /* End any pending argument. */
4370 obstack_1grow (&obstack
, 0);
4371 string
= obstack_finish (&obstack
);
4372 if (this_is_library_file
)
4373 string
= find_file (string
);
4374 store_arg (string
, delete_this_arg
, this_is_output_file
);
4375 if (this_is_output_file
)
4376 outfiles
[input_file_number
] = string
;
4380 obstack_1grow (&obstack
, c
);
4386 /* Space or tab ends an argument if one is pending. */
4389 obstack_1grow (&obstack
, 0);
4390 string
= obstack_finish (&obstack
);
4391 if (this_is_library_file
)
4392 string
= find_file (string
);
4393 store_arg (string
, delete_this_arg
, this_is_output_file
);
4394 if (this_is_output_file
)
4395 outfiles
[input_file_number
] = string
;
4397 /* Reinitialize for a new argument. */
4399 delete_this_arg
= 0;
4400 this_is_output_file
= 0;
4401 this_is_library_file
= 0;
4408 fatal ("invalid specification! Bug in cc");
4411 obstack_grow (&obstack
, input_basename
, basename_length
);
4416 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4421 delete_this_arg
= 2;
4424 /* Dump out the directories specified with LIBRARY_PATH,
4425 followed by the absolute directories
4426 that we search for startfiles. */
4429 struct prefix_list
*pl
= startfile_prefixes
.plist
;
4430 size_t bufsize
= 100;
4431 char *buffer
= (char *) xmalloc (bufsize
);
4434 for (; pl
; pl
= pl
->next
)
4436 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4437 /* Used on systems which record the specified -L dirs
4438 and use them to search for dynamic linking. */
4439 /* Relative directories always come from -B,
4440 and it is better not to use them for searching
4441 at run time. In particular, stage1 loses. */
4442 if (!IS_ABSOLUTE_PATHNAME (pl
->prefix
))
4445 /* Try subdirectory if there is one. */
4446 if (multilib_dir
!= NULL
4447 || (pl
->os_multilib
&& multilib_os_dir
!= NULL
))
4449 const char *multi_dir
;
4451 multi_dir
= pl
->os_multilib
? multilib_os_dir
4453 if (machine_suffix
&& multilib_dir
)
4455 if (strlen (pl
->prefix
) + strlen (machine_suffix
)
4457 bufsize
= (strlen (pl
->prefix
)
4458 + strlen (machine_suffix
)) * 2 + 1;
4459 buffer
= (char *) xrealloc (buffer
, bufsize
);
4460 strcpy (buffer
, pl
->prefix
);
4461 strcat (buffer
, machine_suffix
);
4462 if (is_directory (buffer
, multilib_dir
, 1))
4464 do_spec_1 ("-L", 0, NULL
);
4465 #ifdef SPACE_AFTER_L_OPTION
4466 do_spec_1 (" ", 0, NULL
);
4468 do_spec_1 (buffer
, 1, NULL
);
4469 do_spec_1 (multilib_dir
, 1, NULL
);
4470 /* Make this a separate argument. */
4471 do_spec_1 (" ", 0, NULL
);
4474 if (!pl
->require_machine_suffix
)
4476 if (is_directory (pl
->prefix
, multi_dir
, 1))
4478 do_spec_1 ("-L", 0, NULL
);
4479 #ifdef SPACE_AFTER_L_OPTION
4480 do_spec_1 (" ", 0, NULL
);
4482 do_spec_1 (pl
->prefix
, 1, NULL
);
4483 do_spec_1 (multi_dir
, 1, NULL
);
4484 /* Make this a separate argument. */
4485 do_spec_1 (" ", 0, NULL
);
4491 if (is_directory (pl
->prefix
, machine_suffix
, 1))
4493 do_spec_1 ("-L", 0, NULL
);
4494 #ifdef SPACE_AFTER_L_OPTION
4495 do_spec_1 (" ", 0, NULL
);
4497 do_spec_1 (pl
->prefix
, 1, NULL
);
4498 /* Remove slash from machine_suffix. */
4499 if (strlen (machine_suffix
) >= bufsize
)
4500 bufsize
= strlen (machine_suffix
) * 2 + 1;
4501 buffer
= (char *) xrealloc (buffer
, bufsize
);
4502 strcpy (buffer
, machine_suffix
);
4503 idx
= strlen (buffer
);
4504 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4505 buffer
[idx
- 1] = 0;
4506 do_spec_1 (buffer
, 1, NULL
);
4507 /* Make this a separate argument. */
4508 do_spec_1 (" ", 0, NULL
);
4511 if (!pl
->require_machine_suffix
)
4513 if (is_directory (pl
->prefix
, "", 1))
4515 do_spec_1 ("-L", 0, NULL
);
4516 #ifdef SPACE_AFTER_L_OPTION
4517 do_spec_1 (" ", 0, NULL
);
4519 /* Remove slash from pl->prefix. */
4520 if (strlen (pl
->prefix
) >= bufsize
)
4521 bufsize
= strlen (pl
->prefix
) * 2 + 1;
4522 buffer
= (char *) xrealloc (buffer
, bufsize
);
4523 strcpy (buffer
, pl
->prefix
);
4524 idx
= strlen (buffer
);
4525 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4526 buffer
[idx
- 1] = 0;
4527 do_spec_1 (buffer
, 1, NULL
);
4528 /* Make this a separate argument. */
4529 do_spec_1 (" ", 0, NULL
);
4538 /* %efoo means report an error with `foo' as error message
4539 and don't execute any more commands for this file. */
4543 while (*p
!= 0 && *p
!= '\n')
4545 buf
= (char *) alloca (p
- q
+ 1);
4546 strncpy (buf
, q
, p
- q
);
4553 /* %nfoo means report a notice with `foo' on stderr. */
4557 while (*p
!= 0 && *p
!= '\n')
4559 buf
= (char *) alloca (p
- q
+ 1);
4560 strncpy (buf
, q
, p
- q
);
4562 notice ("%s\n", buf
);
4572 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4573 defined, and it is not a directory, and it is
4574 writable, use it. Otherwise, treat this like any
4575 other temporary file. */
4577 if ((!save_temps_flag
)
4578 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4579 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4581 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4582 strlen (HOST_BIT_BUCKET
));
4583 delete_this_arg
= 0;
4588 goto create_temp_file
;
4592 obstack_1grow (&obstack
, '-');
4593 delete_this_arg
= 0;
4596 /* consume suffix */
4597 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4599 if (p
[0] == '%' && p
[1] == 'O')
4604 goto create_temp_file
;
4608 /* consume suffix */
4609 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4611 if (p
[0] == '%' && p
[1] == 'O')
4616 goto create_temp_file
;
4622 struct temp_name
*t
;
4624 const char *suffix
= p
;
4625 char *saved_suffix
= NULL
;
4627 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4629 suffix_length
= p
- suffix
;
4630 if (p
[0] == '%' && p
[1] == 'O')
4633 /* We don't support extra suffix characters after %O. */
4634 if (*p
== '.' || ISALPHA ((unsigned char) *p
))
4636 if (suffix_length
== 0)
4637 suffix
= TARGET_OBJECT_SUFFIX
;
4641 = (char *) xmalloc (suffix_length
4642 + strlen (TARGET_OBJECT_SUFFIX
));
4643 strncpy (saved_suffix
, suffix
, suffix_length
);
4644 strcpy (saved_suffix
+ suffix_length
,
4645 TARGET_OBJECT_SUFFIX
);
4647 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4650 /* If the input_filename has the same suffix specified
4651 for the %g, %u, or %U, and -save-temps is specified,
4652 we could end up using that file as an intermediate
4653 thus clobbering the user's source file (.e.g.,
4654 gcc -save-temps foo.s would clobber foo.s with the
4655 output of cpp0). So check for this condition and
4656 generate a temp file as the intermediate. */
4658 if (save_temps_flag
)
4660 temp_filename_length
= basename_length
+ suffix_length
;
4661 temp_filename
= alloca (temp_filename_length
+ 1);
4662 strncpy ((char *) temp_filename
, input_basename
, basename_length
);
4663 strncpy ((char *) temp_filename
+ basename_length
, suffix
,
4665 *((char *) temp_filename
+ temp_filename_length
) = '\0';
4666 if (strcmp (temp_filename
, input_filename
) != 0)
4668 struct stat st_temp
;
4670 /* Note, set_input() resets input_stat_set to 0. */
4671 if (input_stat_set
== 0)
4673 input_stat_set
= stat (input_filename
, &input_stat
);
4674 if (input_stat_set
>= 0)
4678 /* If we have the stat for the input_filename
4679 and we can do the stat for the temp_filename
4680 then the they could still refer to the same
4681 file if st_dev/st_ino's are the same. */
4683 if (input_stat_set
!= 1
4684 || stat (temp_filename
, &st_temp
) < 0
4685 || input_stat
.st_dev
!= st_temp
.st_dev
4686 || input_stat
.st_ino
!= st_temp
.st_ino
)
4688 temp_filename
= save_string (temp_filename
,
4689 temp_filename_length
+ 1);
4690 obstack_grow (&obstack
, temp_filename
,
4691 temp_filename_length
);
4693 delete_this_arg
= 0;
4699 /* See if we already have an association of %g/%u/%U and
4701 for (t
= temp_names
; t
; t
= t
->next
)
4702 if (t
->length
== suffix_length
4703 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4704 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4707 /* Make a new association if needed. %u and %j
4709 if (t
== 0 || c
== 'u' || c
== 'j')
4713 t
= (struct temp_name
*) xmalloc (sizeof (struct temp_name
));
4714 t
->next
= temp_names
;
4717 t
->length
= suffix_length
;
4720 t
->suffix
= saved_suffix
;
4721 saved_suffix
= NULL
;
4724 t
->suffix
= save_string (suffix
, suffix_length
);
4725 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4726 temp_filename
= make_temp_file (t
->suffix
);
4727 temp_filename_length
= strlen (temp_filename
);
4728 t
->filename
= temp_filename
;
4729 t
->filename_length
= temp_filename_length
;
4733 free (saved_suffix
);
4735 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4736 delete_this_arg
= 1;
4742 obstack_grow (&obstack
, input_filename
, input_filename_length
);
4748 struct prefix_list
*pl
= include_prefixes
.plist
;
4750 if (gcc_exec_prefix
)
4752 do_spec_1 ("-iprefix", 1, NULL
);
4753 /* Make this a separate argument. */
4754 do_spec_1 (" ", 0, NULL
);
4755 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
4756 do_spec_1 (" ", 0, NULL
);
4759 if (target_system_root_changed
)
4761 do_spec_1 ("-isysroot", 1, NULL
);
4762 /* Make this a separate argument. */
4763 do_spec_1 (" ", 0, NULL
);
4764 do_spec_1 (target_system_root
, 1, NULL
);
4765 do_spec_1 (" ", 0, NULL
);
4768 for (; pl
; pl
= pl
->next
)
4770 do_spec_1 ("-isystem", 1, NULL
);
4771 /* Make this a separate argument. */
4772 do_spec_1 (" ", 0, NULL
);
4773 do_spec_1 (pl
->prefix
, 1, NULL
);
4774 do_spec_1 (" ", 0, NULL
);
4781 int max
= n_infiles
;
4782 max
+= lang_specific_extra_outfiles
;
4784 for (i
= 0; i
< max
; i
++)
4786 store_arg (outfiles
[i
], 0, 0);
4791 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
4796 this_is_library_file
= 1;
4800 outfiles
[input_file_number
] = NULL
;
4804 this_is_output_file
= 1;
4809 int cur_index
= argbuf_index
;
4810 /* Handle the {...} following the %W. */
4813 p
= handle_braces (p
+ 1);
4816 /* End any pending argument. */
4819 obstack_1grow (&obstack
, 0);
4820 string
= obstack_finish (&obstack
);
4821 if (this_is_library_file
)
4822 string
= find_file (string
);
4823 store_arg (string
, delete_this_arg
, this_is_output_file
);
4824 if (this_is_output_file
)
4825 outfiles
[input_file_number
] = string
;
4828 /* If any args were output, mark the last one for deletion
4830 if (argbuf_index
!= cur_index
)
4831 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
4835 /* %x{OPTION} records OPTION for %X to output. */
4841 /* Skip past the option value and make a copy. */
4846 string
= save_string (p1
+ 1, p
- p1
- 2);
4848 /* See if we already recorded this option. */
4849 for (i
= 0; i
< n_linker_options
; i
++)
4850 if (! strcmp (string
, linker_options
[i
]))
4856 /* This option is new; add it. */
4857 add_linker_option (string
, strlen (string
));
4861 /* Dump out the options accumulated previously using %x. */
4863 for (i
= 0; i
< n_linker_options
; i
++)
4865 do_spec_1 (linker_options
[i
], 1, NULL
);
4866 /* Make each accumulated option a separate argument. */
4867 do_spec_1 (" ", 0, NULL
);
4871 /* Dump out the options accumulated previously using -Wa,. */
4873 for (i
= 0; i
< n_assembler_options
; i
++)
4875 do_spec_1 (assembler_options
[i
], 1, NULL
);
4876 /* Make each accumulated option a separate argument. */
4877 do_spec_1 (" ", 0, NULL
);
4881 /* Dump out the options accumulated previously using -Wp,. */
4883 for (i
= 0; i
< n_preprocessor_options
; i
++)
4885 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
4886 /* Make each accumulated option a separate argument. */
4887 do_spec_1 (" ", 0, NULL
);
4891 /* Here are digits and numbers that just process
4892 a certain constant string as a spec. */
4895 value
= do_spec_1 (cc1_spec
, 0, NULL
);
4901 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
4907 value
= do_spec_1 (asm_spec
, 0, NULL
);
4913 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
4920 const char *const spec
4921 = (input_file_compiler
->cpp_spec
4922 ? input_file_compiler
->cpp_spec
4924 value
= do_spec_1 (spec
, 0, NULL
);
4931 value
= do_spec_1 (endfile_spec
, 0, NULL
);
4937 value
= do_spec_1 (link_spec
, 0, NULL
);
4943 value
= do_spec_1 (lib_spec
, 0, NULL
);
4949 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
4955 if (multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
4961 len
= strlen (multilib_dir
);
4962 obstack_blank (&obstack
, len
+ 1);
4963 p
= obstack_next_free (&obstack
) - (len
+ 1);
4966 for (q
= multilib_dir
; *q
; ++q
, ++p
)
4967 *p
= (IS_DIR_SEPARATOR (*q
) ? '_' : *q
);
4973 char *x
= (char *) alloca (strlen (cpp_predefines
) + 1);
4977 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4981 if (! strncmp (y
, "-D", 2))
4982 /* Copy the whole option. */
4983 while (*y
&& *y
!= ' ' && *y
!= '\t')
4985 else if (*y
== ' ' || *y
== '\t')
4986 /* Copy whitespace to the result. */
4988 /* Don't copy other options. */
4995 value
= do_spec_1 (buf
, 0, NULL
);
5003 char *x
= (char *) alloca (strlen (cpp_predefines
) * 4 + 1);
5007 /* Copy all of CPP_PREDEFINES into BUF,
5008 but force them all into the reserved name space if they
5009 aren't already there. The reserved name space is all
5010 identifiers beginning with two underscores or with one
5011 underscore and a capital letter. We do the forcing by
5012 adding up to two underscores to the beginning and end
5013 of each symbol. e.g. mips, _mips, mips_, and _mips_ all
5018 if (! strncmp (y
, "-D", 2))
5027 && ! ISUPPER ((unsigned char) *(y
+ 1))))
5029 /* Stick __ at front of macro name. */
5033 /* Arrange to stick __ at the end as well. */
5037 /* Copy the macro name. */
5038 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
5051 /* Copy the value given, if any. */
5052 while (*y
&& *y
!= ' ' && *y
!= '\t')
5055 else if (*y
== ' ' || *y
== '\t')
5056 /* Copy whitespace to the result. */
5058 /* Don't copy -A options */
5064 /* Copy all of CPP_PREDEFINES into BUF,
5065 but put __ after every -D. */
5069 if (! strncmp (y
, "-D", 2))
5075 && ! ISUPPER ((unsigned char) *(y
+ 1))))
5077 /* Stick -D__ at front of macro name. */
5084 /* Copy the macro name. */
5085 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
5088 /* Copy the value given, if any. */
5089 while (*y
&& *y
!= ' ' && *y
!= '\t')
5094 /* Do not copy this macro - we have just done it before */
5095 while (*y
&& *y
!= ' ' && *y
!= '\t')
5099 else if (*y
== ' ' || *y
== '\t')
5100 /* Copy whitespace to the result. */
5102 /* Don't copy -A options. */
5108 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
5112 if (! strncmp (y
, "-A", 2))
5113 /* Copy the whole option. */
5114 while (*y
&& *y
!= ' ' && *y
!= '\t')
5116 else if (*y
== ' ' || *y
== '\t')
5117 /* Copy whitespace to the result. */
5119 /* Don't copy other options. */
5126 value
= do_spec_1 (buf
, 0, NULL
);
5133 /* We assume there is a directory
5134 separator at the end of this string. */
5135 if (target_system_root
)
5136 obstack_grow (&obstack
, target_system_root
,
5137 strlen (target_system_root
));
5141 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5146 /* Here we define characters other than letters and digits. */
5149 p
= handle_braces (p
);
5155 p
= handle_spec_function (p
);
5161 obstack_1grow (&obstack
, '%');
5168 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5170 suffix_subst
= save_string (p
- 1, len
+ 1);
5175 /* Henceforth ignore the option(s) matching the pattern
5180 int have_wildcard
= 0;
5183 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5186 if (p
[len
-1] == '*')
5189 for (i
= 0; i
< n_switches
; i
++)
5190 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5191 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5193 switches
[i
].live_cond
= SWITCH_IGNORE
;
5194 switches
[i
].validated
= 1;
5202 if (soft_matched_part
)
5204 do_spec_1 (soft_matched_part
, 1, NULL
);
5205 do_spec_1 (" ", 0, NULL
);
5208 /* Catch the case where a spec string contains something like
5209 '%{foo:%*}'. ie there is no * in the pattern on the left
5210 hand side of the :. */
5211 error ("spec failure: '%%*' has not been initialized by pattern match");
5214 /* Process a string found as the value of a spec given by name.
5215 This feature allows individual machine descriptions
5216 to add and use their own specs.
5217 %[...] modifies -D options the way %P does;
5218 %(...) uses the spec unmodified. */
5220 error ("warning: use of obsolete %%[ operator in specs");
5223 const char *name
= p
;
5224 struct spec_list
*sl
;
5227 /* The string after the S/P is the name of a spec that is to be
5229 while (*p
&& *p
!= ')' && *p
!= ']')
5232 /* See if it's in the list. */
5233 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5234 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5236 name
= *(sl
->ptr_spec
);
5238 notice ("Processing spec %c%s%c, which is '%s'\n",
5239 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5248 value
= do_spec_1 (name
, 0, NULL
);
5254 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5256 const char *y
= name
;
5259 /* Copy all of NAME into BUF, but put __ after
5260 every -D and at the end of each arg. */
5263 if (! strncmp (y
, "-D", 2))
5274 && (*y
== ' ' || *y
== '\t' || *y
== '='
5275 || *y
== '}' || *y
== 0))
5288 value
= do_spec_1 (buf
, 0, NULL
);
5294 /* Discard the closing paren or bracket. */
5301 error ("spec failure: unrecognized spec option '%c'", c
);
5307 /* Backslash: treat next character as ordinary. */
5312 /* Ordinary character: put it into the current argument. */
5313 obstack_1grow (&obstack
, c
);
5317 /* End of string. If we are processing a spec function, we need to
5318 end any pending argument. */
5319 if (processing_spec_function
&& arg_going
)
5321 obstack_1grow (&obstack
, 0);
5322 string
= obstack_finish (&obstack
);
5323 if (this_is_library_file
)
5324 string
= find_file (string
);
5325 store_arg (string
, delete_this_arg
, this_is_output_file
);
5326 if (this_is_output_file
)
5327 outfiles
[input_file_number
] = string
;
5334 /* Look up a spec function. */
5336 static const struct spec_function
*
5337 lookup_spec_function (name
)
5340 static const struct spec_function
* const spec_function_tables
[] =
5342 static_spec_functions
,
5343 lang_specific_spec_functions
,
5345 const struct spec_function
*sf
;
5348 for (i
= 0; i
< ARRAY_SIZE (spec_function_tables
); i
++)
5350 for (sf
= spec_function_tables
[i
]; sf
->name
!= NULL
; sf
++)
5351 if (strcmp (sf
->name
, name
) == 0)
5358 /* Evaluate a spec function. */
5361 eval_spec_function (func
, args
)
5362 const char *func
, *args
;
5364 const struct spec_function
*sf
;
5365 const char *funcval
;
5367 /* Saved spec processing context. */
5368 int save_argbuf_index
;
5369 int save_argbuf_length
;
5370 const char **save_argbuf
;
5373 int save_delete_this_arg
;
5374 int save_this_is_output_file
;
5375 int save_this_is_library_file
;
5376 int save_input_from_pipe
;
5377 const char *save_suffix_subst
;
5380 sf
= lookup_spec_function (func
);
5382 fatal ("unknown spec function `%s'", func
);
5384 /* Push the spec processing context. */
5385 save_argbuf_index
= argbuf_index
;
5386 save_argbuf_length
= argbuf_length
;
5387 save_argbuf
= argbuf
;
5389 save_arg_going
= arg_going
;
5390 save_delete_this_arg
= delete_this_arg
;
5391 save_this_is_output_file
= this_is_output_file
;
5392 save_this_is_library_file
= this_is_library_file
;
5393 save_input_from_pipe
= input_from_pipe
;
5394 save_suffix_subst
= suffix_subst
;
5396 /* Create a new spec processing context, and build the function
5400 if (do_spec_2 (args
) < 0)
5401 fatal ("error in args to spec function `%s'", func
);
5403 /* argbuf_index is an index for the next argument to be inserted, and
5404 so contains the count of the args already inserted. */
5406 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5408 /* Pop the spec processing context. */
5409 argbuf_index
= save_argbuf_index
;
5410 argbuf_length
= save_argbuf_length
;
5412 argbuf
= save_argbuf
;
5414 arg_going
= save_arg_going
;
5415 delete_this_arg
= save_delete_this_arg
;
5416 this_is_output_file
= save_this_is_output_file
;
5417 this_is_library_file
= save_this_is_library_file
;
5418 input_from_pipe
= save_input_from_pipe
;
5419 suffix_subst
= save_suffix_subst
;
5424 /* Handle a spec function call of the form:
5428 ARGS is processed as a spec in a separate context and split into an
5429 argument vector in the normal fashion. The function returns a string
5430 containing a spec which we then process in the caller's context, or
5431 NULL if no processing is required. */
5434 handle_spec_function (p
)
5438 const char *endp
, *funcval
;
5441 processing_spec_function
++;
5443 /* Get the function name. */
5444 for (endp
= p
; *endp
!= '\0'; endp
++)
5446 if (*endp
== '(') /* ) */
5448 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5449 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5450 fatal ("malformed spec function name");
5452 if (*endp
!= '(') /* ) */
5453 fatal ("no arguments for spec function");
5454 func
= save_string (p
, endp
- p
);
5457 /* Get the arguments. */
5458 for (count
= 0; *endp
!= '\0'; endp
++)
5467 else if (*endp
== '(') /* ) */
5472 fatal ("malformed spec function arguments");
5473 args
= save_string (p
, endp
- p
);
5476 /* p now points to just past the end of the spec function expression. */
5478 funcval
= eval_spec_function (func
, args
);
5479 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5485 processing_spec_function
--;
5490 /* Inline subroutine of handle_braces. Returns true if the current
5491 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5493 input_suffix_matches (atom
, end_atom
)
5495 const char *end_atom
;
5497 return (input_suffix
5498 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5499 && input_suffix
[end_atom
- atom
] == '\0');
5502 /* Inline subroutine of handle_braces. Returns true if a switch
5503 matching the atom bracketed by ATOM and END_ATOM appeared on the
5506 switch_matches (atom
, end_atom
, starred
)
5508 const char *end_atom
;
5512 int len
= end_atom
- atom
;
5513 int plen
= starred
? len
: -1;
5515 for (i
= 0; i
< n_switches
; i
++)
5516 if (!strncmp (switches
[i
].part1
, atom
, len
)
5517 && (starred
|| switches
[i
].part1
[len
] == '\0')
5518 && check_live_switch (i
, plen
))
5524 /* Inline subroutine of handle_braces. Mark all of the switches which
5525 match ATOM (extends to END_ATOM; STARRED indicates whether there
5526 was a star after the atom) for later processing. */
5528 mark_matching_switches (atom
, end_atom
, starred
)
5530 const char *end_atom
;
5534 int len
= end_atom
- atom
;
5535 int plen
= starred
? len
: -1;
5537 for (i
= 0; i
< n_switches
; i
++)
5538 if (!strncmp (switches
[i
].part1
, atom
, len
)
5539 && (starred
|| switches
[i
].part1
[len
] == '\0')
5540 && check_live_switch (i
, plen
))
5541 switches
[i
].ordering
= 1;
5544 /* Inline subroutine of handle_braces. Process all the currently
5545 marked switches through give_switch, and clear the marks. */
5547 process_marked_switches ()
5551 for (i
= 0; i
< n_switches
; i
++)
5552 if (switches
[i
].ordering
== 1)
5554 switches
[i
].ordering
= 0;
5559 /* Handle a %{ ... } construct. P points just inside the leading {.
5560 Returns a pointer one past the end of the brace block, or 0
5561 if we call do_spec_1 and that returns -1. */
5567 const char *atom
, *end_atom
;
5568 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5575 bool a_must_be_last
= false;
5576 bool ordered_set
= false;
5577 bool disjunct_set
= false;
5578 bool disj_matched
= false;
5579 bool disj_starred
= true;
5580 bool n_way_choice
= false;
5581 bool n_way_matched
= false;
5583 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5590 /* Scan one "atom" (S in the description above of %{}, possibly
5591 with !, ., or * modifiers). */
5592 a_matched
= a_is_suffix
= a_is_starred
= a_is_negated
= false;
5596 p
++, a_is_negated
= true;
5600 p
++, a_is_suffix
= true;
5603 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5604 || *p
== ',' || *p
== '.' || *p
== '@')
5609 p
++, a_is_starred
= 1;
5612 if (*p
== '&' || *p
== '}')
5614 /* Substitute the switch(es) indicated by the current atom. */
5616 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5617 || atom
== end_atom
)
5620 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5623 process_marked_switches ();
5625 else if (*p
== '|' || *p
== ':')
5627 /* Substitute some text if the current atom appears as a switch
5629 disjunct_set
= true;
5633 if (atom
== end_atom
)
5635 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5636 || a_is_negated
|| a_is_suffix
|| a_is_starred
)
5639 /* An empty term may appear as the last choice of an
5640 N-way choice set; it means "otherwise". */
5641 a_must_be_last
= true;
5642 disj_matched
= !n_way_matched
;
5643 disj_starred
= false;
5647 if (a_is_suffix
&& a_is_starred
)
5651 disj_starred
= false;
5653 /* Don't bother testing this atom if we already have a
5655 if (!disj_matched
&& !n_way_matched
)
5658 a_matched
= input_suffix_matches (atom
, end_atom
);
5660 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5662 if (a_matched
!= a_is_negated
)
5664 disj_matched
= true;
5666 d_end_atom
= end_atom
;
5673 /* Found the body, that is, the text to substitute if the
5674 current disjunction matches. */
5675 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5676 disj_matched
&& !n_way_matched
);
5680 /* If we have an N-way choice, reset state for the next
5684 n_way_choice
= true;
5685 n_way_matched
|= disj_matched
;
5686 disj_matched
= false;
5687 disj_starred
= true;
5688 d_atom
= d_end_atom
= NULL
;
5695 while (*p
++ != '}');
5702 /* Subroutine of handle_braces. Scan and process a brace substitution body
5703 (X in the description of %{} syntax). P points one past the colon;
5704 ATOM and END_ATOM bracket the first atom which was found to be true
5705 (present) in the current disjunction; STARRED indicates whether all
5706 the atoms in the current disjunction were starred (for syntax validation);
5707 MATCHED indicates whether the disjunction matched or not, and therefore
5708 whether or not the body is to be processed through do_spec_1 or just
5709 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5713 process_brace_body (p
, atom
, end_atom
, starred
, matched
)
5716 const char *end_atom
;
5720 const char *body
, *end_body
;
5721 unsigned int nesting_level
;
5722 bool have_subst
= false;
5724 /* Locate the closing } or ;, honoring nested braces.
5725 Trim trailing whitespace. */
5734 if (!--nesting_level
)
5737 else if (*p
== ';' && nesting_level
== 1)
5739 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5741 else if (*p
== '\0')
5747 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5750 if (have_subst
&& !starred
)
5755 /* Copy the substitution body to permanent storage and execute it.
5756 If have_subst is false, this is a simple matter of running the
5757 body through do_spec_1... */
5758 char *string
= save_string (body
, end_body
- body
);
5761 if (do_spec_1 (string
, 0, NULL
) < 0)
5766 /* ... but if have_subst is true, we have to process the
5767 body once for each matching switch, with %* set to the
5768 variant part of the switch. */
5769 unsigned int hard_match_len
= end_atom
- atom
;
5772 for (i
= 0; i
< n_switches
; i
++)
5773 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5774 && check_live_switch (i
, hard_match_len
))
5776 if (do_spec_1 (string
, 0,
5777 &switches
[i
].part1
[hard_match_len
]) < 0)
5779 /* Pass any arguments this switch has. */
5781 suffix_subst
= NULL
;
5789 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5790 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5791 spec, or -1 if either exact match or %* is used.
5793 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5794 whose value does not begin with "no-" is obsoleted by the same value
5795 with the "no-", similarly for a switch with the "no-" prefix. */
5798 check_live_switch (switchnum
, prefix_length
)
5802 const char *name
= switches
[switchnum
].part1
;
5805 /* In the common case of {<at-most-one-letter>*}, a negating
5806 switch would always match, so ignore that case. We will just
5807 send the conflicting switches to the compiler phase. */
5808 if (prefix_length
>= 0 && prefix_length
<= 1)
5811 /* If we already processed this switch and determined if it was
5812 live or not, return our past determination. */
5813 if (switches
[switchnum
].live_cond
!= 0)
5814 return switches
[switchnum
].live_cond
> 0;
5816 /* Now search for duplicate in a manner that depends on the name. */
5820 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5821 if (switches
[i
].part1
[0] == 'O')
5823 switches
[switchnum
].validated
= 1;
5824 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5829 case 'W': case 'f': case 'm':
5830 if (! strncmp (name
+ 1, "no-", 3))
5832 /* We have Xno-YYY, search for XYYY. */
5833 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5834 if (switches
[i
].part1
[0] == name
[0]
5835 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5837 switches
[switchnum
].validated
= 1;
5838 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5844 /* We have XYYY, search for Xno-YYY. */
5845 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5846 if (switches
[i
].part1
[0] == name
[0]
5847 && switches
[i
].part1
[1] == 'n'
5848 && switches
[i
].part1
[2] == 'o'
5849 && switches
[i
].part1
[3] == '-'
5850 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5852 switches
[switchnum
].validated
= 1;
5853 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5860 /* Otherwise the switch is live. */
5861 switches
[switchnum
].live_cond
= SWITCH_LIVE
;
5865 /* Pass a switch to the current accumulating command
5866 in the same form that we received it.
5867 SWITCHNUM identifies the switch; it is an index into
5868 the vector of switches gcc received, which is `switches'.
5869 This cannot fail since it never finishes a command line.
5871 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5874 give_switch (switchnum
, omit_first_word
)
5876 int omit_first_word
;
5878 if (switches
[switchnum
].live_cond
== SWITCH_IGNORE
)
5881 if (!omit_first_word
)
5883 do_spec_1 ("-", 0, NULL
);
5884 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5887 if (switches
[switchnum
].args
!= 0)
5890 for (p
= switches
[switchnum
].args
; *p
; p
++)
5892 const char *arg
= *p
;
5894 do_spec_1 (" ", 0, NULL
);
5897 unsigned length
= strlen (arg
);
5900 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
5901 if (arg
[length
] == '.')
5903 ((char *)arg
)[length
] = 0;
5907 do_spec_1 (arg
, 1, NULL
);
5909 ((char *)arg
)[length
] = '.';
5910 do_spec_1 (suffix_subst
, 1, NULL
);
5913 do_spec_1 (arg
, 1, NULL
);
5917 do_spec_1 (" ", 0, NULL
);
5918 switches
[switchnum
].validated
= 1;
5921 /* Search for a file named NAME trying various prefixes including the
5922 user's -B prefix and some standard ones.
5923 Return the absolute file name found. If nothing is found, return NAME. */
5931 /* Try multilib_dir if it is defined. */
5932 if (multilib_os_dir
!= NULL
)
5934 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 1);
5936 /* If we don't find it in the multi library dir, then fall
5937 through and look for it in the normal places. */
5938 if (newname
!= NULL
)
5942 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 0);
5943 return newname
? newname
: name
;
5946 /* Determine whether a directory exists. If LINKER, return 0 for
5947 certain fixed names not needed by the linker. If not LINKER, it is
5948 only important to return 0 if the host machine has a small ARG_MAX
5952 is_directory (path1
, path2
, linker
)
5957 int len1
= strlen (path1
);
5958 int len2
= strlen (path2
);
5959 char *path
= (char *) alloca (3 + len1
+ len2
);
5963 #ifndef SMALL_ARG_MAX
5968 /* Construct the path from the two parts. Ensure the string ends with "/.".
5969 The resulting path will be a directory even if the given path is a
5971 memcpy (path
, path1
, len1
);
5972 memcpy (path
+ len1
, path2
, len2
);
5973 cp
= path
+ len1
+ len2
;
5974 if (!IS_DIR_SEPARATOR (cp
[-1]))
5975 *cp
++ = DIR_SEPARATOR
;
5979 /* Exclude directories that the linker is known to search. */
5982 && strcmp (path
, concat (dir_separator_str
, "lib",
5983 dir_separator_str
, ".", NULL
)) == 0)
5985 && strcmp (path
, concat (dir_separator_str
, "usr",
5986 dir_separator_str
, "lib",
5987 dir_separator_str
, ".", NULL
)) == 0)))
5990 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
5993 /* Set up the various global variables to indicate that we're processing
5994 the input file named FILENAME. */
5997 set_input (filename
)
5998 const char *filename
;
6002 input_filename
= filename
;
6003 input_filename_length
= strlen (input_filename
);
6005 input_basename
= input_filename
;
6006 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
6007 /* Skip drive name so 'x:foo' is handled properly. */
6008 if (input_basename
[1] == ':')
6009 input_basename
+= 2;
6011 for (p
= input_basename
; *p
; p
++)
6012 if (IS_DIR_SEPARATOR (*p
))
6013 input_basename
= p
+ 1;
6015 /* Find a suffix starting with the last period,
6016 and set basename_length to exclude that suffix. */
6017 basename_length
= strlen (input_basename
);
6018 suffixed_basename_length
= basename_length
;
6019 p
= input_basename
+ basename_length
;
6020 while (p
!= input_basename
&& *p
!= '.')
6022 if (*p
== '.' && p
!= input_basename
)
6024 basename_length
= p
- input_basename
;
6025 input_suffix
= p
+ 1;
6030 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6031 we will need to do a stat on the input_filename. The
6032 INPUT_STAT_SET signals that the stat is needed. */
6036 /* On fatal signals, delete all the temporary files. */
6039 fatal_error (signum
)
6042 signal (signum
, SIG_DFL
);
6043 delete_failure_queue ();
6044 delete_temp_files ();
6045 /* Get the same signal again, this time not handled,
6046 so its normal effect occurs. */
6047 kill (getpid (), signum
);
6050 extern int main
PARAMS ((int, const char *const *));
6055 const char *const *argv
;
6059 int linker_was_run
= 0;
6060 int num_linker_inputs
= 0;
6061 char *explicit_link_files
;
6064 struct user_specs
*uptr
;
6066 p
= argv
[0] + strlen (argv
[0]);
6067 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6071 xmalloc_set_program_name (programname
);
6073 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6074 /* Perform host dependent initialization when needed. */
6075 GCC_DRIVER_HOST_INITIALIZATION
;
6078 gcc_init_libintl ();
6080 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6081 signal (SIGINT
, fatal_error
);
6083 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6084 signal (SIGHUP
, fatal_error
);
6086 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6087 signal (SIGTERM
, fatal_error
);
6089 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6090 signal (SIGPIPE
, fatal_error
);
6093 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6094 receive the signal. A different setting is inheritable */
6095 signal (SIGCHLD
, SIG_DFL
);
6098 /* Allocate the argument vector. */
6101 obstack_init (&obstack
);
6103 /* Build multilib_select, et. al from the separate lines that make up each
6104 multilib selection. */
6106 const char *const *q
= multilib_raw
;
6109 obstack_init (&multilib_obstack
);
6110 while ((p
= *q
++) != (char *) 0)
6111 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6113 obstack_1grow (&multilib_obstack
, 0);
6114 multilib_select
= obstack_finish (&multilib_obstack
);
6116 q
= multilib_matches_raw
;
6117 while ((p
= *q
++) != (char *) 0)
6118 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6120 obstack_1grow (&multilib_obstack
, 0);
6121 multilib_matches
= obstack_finish (&multilib_obstack
);
6123 q
= multilib_exclusions_raw
;
6124 while ((p
= *q
++) != (char *) 0)
6125 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6127 obstack_1grow (&multilib_obstack
, 0);
6128 multilib_exclusions
= obstack_finish (&multilib_obstack
);
6131 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6134 obstack_1grow (&multilib_obstack
, ' ');
6135 obstack_grow (&multilib_obstack
,
6136 multilib_defaults_raw
[i
],
6137 strlen (multilib_defaults_raw
[i
]));
6141 obstack_1grow (&multilib_obstack
, 0);
6142 multilib_defaults
= obstack_finish (&multilib_obstack
);
6145 /* Set up to remember the pathname of gcc and any options
6146 needed for collect. We use argv[0] instead of programname because
6147 we need the complete pathname. */
6148 obstack_init (&collect_obstack
);
6149 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6150 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6151 putenv (obstack_finish (&collect_obstack
));
6153 #ifdef INIT_ENVIRONMENT
6154 /* Set up any other necessary machine specific environment variables. */
6155 putenv (INIT_ENVIRONMENT
);
6158 /* Make a table of what switches there are (switches, n_switches).
6159 Make a table of specified input files (infiles, n_infiles).
6160 Decode switches that are handled locally. */
6162 process_command (argc
, argv
);
6164 /* Initialize the vector of specs to just the default.
6165 This means one element containing 0s, as a terminator. */
6167 compilers
= (struct compiler
*) xmalloc (sizeof default_compilers
);
6168 memcpy ((char *) compilers
, (char *) default_compilers
,
6169 sizeof default_compilers
);
6170 n_compilers
= n_default_compilers
;
6172 /* Read specs from a file if there is one. */
6174 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6175 spec_version
, dir_separator_str
, NULL
);
6176 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6178 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, 0);
6179 /* Read the specs file unless it is a default one. */
6180 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6181 read_specs (specs_file
, TRUE
);
6185 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6186 for any override of as, ld and libraries. */
6187 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6188 + strlen (just_machine_suffix
)
6189 + sizeof ("specs"));
6191 strcpy (specs_file
, standard_exec_prefix
);
6192 strcat (specs_file
, just_machine_suffix
);
6193 strcat (specs_file
, "specs");
6194 if (access (specs_file
, R_OK
) == 0)
6195 read_specs (specs_file
, TRUE
);
6197 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6198 of the command line. */
6200 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6201 do_self_spec (driver_self_specs
[i
]);
6203 /* If not cross-compiling, look for executables in the standard
6205 if (*cross_compile
== '0')
6207 if (*md_exec_prefix
)
6209 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6210 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
6214 /* Look for startfiles in the standard places. */
6215 if (*startfile_prefix_spec
!= 0
6216 && do_spec_2 (startfile_prefix_spec
) == 0
6217 && do_spec_1 (" ", 0, NULL
) == 0)
6220 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6221 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6222 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6224 /* We should eventually get rid of all these and stick to
6225 startfile_prefix_spec exclusively. */
6226 else if (*cross_compile
== '0' || target_system_root
)
6228 if (*md_exec_prefix
)
6229 add_sysrooted_prefix (&startfile_prefixes
, md_exec_prefix
, "GCC",
6230 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6232 if (*md_startfile_prefix
)
6233 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6234 "GCC", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6236 if (*md_startfile_prefix_1
)
6237 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6238 "GCC", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6240 /* If standard_startfile_prefix is relative, base it on
6241 standard_exec_prefix. This lets us move the installed tree
6242 as a unit. If GCC_EXEC_PREFIX is defined, base
6243 standard_startfile_prefix on that as well. */
6244 if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix
))
6245 add_sysrooted_prefix (&startfile_prefixes
,
6246 standard_startfile_prefix
, "BINUTILS",
6247 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6250 if (gcc_exec_prefix
)
6251 add_prefix (&startfile_prefixes
,
6252 concat (gcc_exec_prefix
, machine_suffix
,
6253 standard_startfile_prefix
, NULL
),
6254 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6255 add_prefix (&startfile_prefixes
,
6256 concat (standard_exec_prefix
,
6258 standard_startfile_prefix
, NULL
),
6259 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6262 add_sysrooted_prefix (&startfile_prefixes
, standard_startfile_prefix_1
,
6263 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6264 add_sysrooted_prefix (&startfile_prefixes
, standard_startfile_prefix_2
,
6265 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6266 #if 0 /* Can cause surprises, and one can use -B./ instead. */
6267 add_prefix (&startfile_prefixes
, "./", NULL
,
6268 PREFIX_PRIORITY_LAST
, 1, NULL
, 0);
6272 /* Process any user specified specs in the order given on the command
6274 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6276 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6278 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6281 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6282 if (gcc_exec_prefix
)
6283 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6284 spec_version
, dir_separator_str
, NULL
);
6286 /* Now we have the specs.
6287 Set the `valid' bits for switches that match anything in any spec. */
6289 validate_all_switches ();
6291 /* Now that we have the switches and the specs, set
6292 the subdirectory based on the options. */
6293 set_multilib_dir ();
6295 /* Warn about any switches that no pass was interested in. */
6297 for (i
= 0; (int) i
< n_switches
; i
++)
6298 if (! switches
[i
].validated
)
6299 error ("unrecognized option `-%s'", switches
[i
].part1
);
6301 /* Obey some of the options. */
6303 if (print_search_dirs
)
6305 printf (_("install: %s%s\n"), standard_exec_prefix
, machine_suffix
);
6306 printf (_("programs: %s\n"), build_search_list (&exec_prefixes
, "", 0));
6307 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes
, "", 0));
6311 if (print_file_name
)
6313 printf ("%s\n", find_file (print_file_name
));
6317 if (print_prog_name
)
6319 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6320 printf ("%s\n", (newname
? newname
: print_prog_name
));
6324 if (print_multi_lib
)
6326 print_multilib_info ();
6330 if (print_multi_directory
)
6332 if (multilib_dir
== NULL
)
6335 printf ("%s\n", multilib_dir
);
6339 if (print_multi_os_directory
)
6341 if (multilib_os_dir
== NULL
)
6344 printf ("%s\n", multilib_os_dir
);
6348 if (target_help_flag
)
6350 /* Print if any target specific options. */
6352 /* We do not exit here. Instead we have created a fake input file
6353 called 'target-dummy' which needs to be compiled, and we pass this
6354 on to the various sub-processes, along with the --target-help
6358 if (print_help_list
)
6364 printf (_("\nFor bug reporting instructions, please see:\n"));
6365 printf ("%s.\n", bug_report_url
);
6370 /* We do not exit here. Instead we have created a fake input file
6371 called 'help-dummy' which needs to be compiled, and we pass this
6372 on the various sub-processes, along with the --help switch. */
6380 notice ("Configured with: %s\n", configuration_arguments
);
6382 #ifdef THREAD_MODEL_SPEC
6383 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6384 but there's no point in doing all this processing just to get
6385 thread_model back. */
6386 obstack_init (&obstack
);
6387 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6388 obstack_1grow (&obstack
, '\0');
6389 thrmod
= obstack_finish (&obstack
);
6391 thrmod
= thread_model
;
6394 notice ("Thread model: %s\n", thrmod
);
6396 /* compiler_version is truncated at the first space when initialized
6397 from version string, so truncate version_string at the first space
6398 before comparing. */
6399 for (n
= 0; version_string
[n
]; n
++)
6400 if (version_string
[n
] == ' ')
6403 if (! strncmp (version_string
, compiler_version
, n
)
6404 && compiler_version
[n
] == 0)
6405 notice ("gcc version %s\n", version_string
);
6407 notice ("gcc driver version %s executing gcc version %s\n",
6408 version_string
, compiler_version
);
6414 if (n_infiles
== added_libraries
)
6415 fatal ("no input files");
6417 /* Make a place to record the compiler output file names
6418 that correspond to the input files. */
6421 i
+= lang_specific_extra_outfiles
;
6422 outfiles
= (const char **) xcalloc (i
, sizeof (char *));
6424 /* Record which files were specified explicitly as link input. */
6426 explicit_link_files
= xcalloc (1, n_infiles
);
6428 for (i
= 0; (int) i
< n_infiles
; i
++)
6430 int this_file_error
= 0;
6432 /* Tell do_spec what to substitute for %i. */
6434 input_file_number
= i
;
6435 set_input (infiles
[i
].name
);
6437 /* Use the same thing in %o, unless cp->spec says otherwise. */
6439 outfiles
[i
] = input_filename
;
6441 /* Figure out which compiler from the file's suffix. */
6444 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6445 infiles
[i
].language
);
6447 if (input_file_compiler
)
6449 /* Ok, we found an applicable compiler. Run its spec. */
6451 if (input_file_compiler
->spec
[0] == '#')
6453 error ("%s: %s compiler not installed on this system",
6454 input_filename
, &input_file_compiler
->spec
[1]);
6455 this_file_error
= 1;
6459 value
= do_spec (input_file_compiler
->spec
);
6461 this_file_error
= 1;
6465 /* If this file's name does not contain a recognized suffix,
6466 record it as explicit linker input. */
6469 explicit_link_files
[i
] = 1;
6471 /* Clear the delete-on-failure queue, deleting the files in it
6472 if this compilation failed. */
6474 if (this_file_error
)
6476 delete_failure_queue ();
6479 /* If this compilation succeeded, don't delete those files later. */
6480 clear_failure_queue ();
6483 /* Reset the output file name to the first input file name, for use
6484 with %b in LINK_SPEC on a target that prefers not to emit a.out
6487 set_input (infiles
[0].name
);
6489 if (error_count
== 0)
6491 /* Make sure INPUT_FILE_NUMBER points to first available open
6493 input_file_number
= n_infiles
;
6494 if (lang_specific_pre_link ())
6498 /* Determine if there are any linker input files. */
6499 num_linker_inputs
= 0;
6500 for (i
= 0; (int) i
< n_infiles
; i
++)
6501 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6502 num_linker_inputs
++;
6504 /* Run ld to link all the compiler output files. */
6506 if (num_linker_inputs
> 0 && error_count
== 0)
6508 int tmp
= execution_count
;
6510 /* We'll use ld if we can't find collect2. */
6511 if (! strcmp (linker_name_spec
, "collect2"))
6513 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, 0);
6515 linker_name_spec
= "ld";
6517 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6519 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH");
6520 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
);
6522 value
= do_spec (link_command_spec
);
6525 linker_was_run
= (tmp
!= execution_count
);
6528 /* If options said don't run linker,
6529 complain about input files to be given to the linker. */
6531 if (! linker_was_run
&& error_count
== 0)
6532 for (i
= 0; (int) i
< n_infiles
; i
++)
6533 if (explicit_link_files
[i
])
6534 error ("%s: linker input file unused because linking not done",
6537 /* Delete some or all of the temporary files we made. */
6540 delete_failure_queue ();
6541 delete_temp_files ();
6543 if (print_help_list
)
6545 printf (("\nFor bug reporting instructions, please see:\n"));
6546 printf ("%s\n", bug_report_url
);
6549 return (signal_count
!= 0 ? 2
6550 : error_count
> 0 ? (pass_exit_codes
? greatest_status
: 1)
6554 /* Find the proper compilation spec for the file name NAME,
6555 whose length is LENGTH. LANGUAGE is the specified language,
6556 or 0 if this file is to be passed to the linker. */
6558 static struct compiler
*
6559 lookup_compiler (name
, length
, language
)
6562 const char *language
;
6564 struct compiler
*cp
;
6566 /* If this was specified by the user to be a linker input, indicate that. */
6567 if (language
!= 0 && language
[0] == '*')
6570 /* Otherwise, look for the language, if one is spec'd. */
6573 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6574 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
6577 error ("language %s not recognized", language
);
6581 /* Look for a suffix. */
6582 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6584 if (/* The suffix `-' matches only the file name `-'. */
6585 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6586 || (strlen (cp
->suffix
) < length
6587 /* See if the suffix matches the end of NAME. */
6588 && !strcmp (cp
->suffix
,
6589 name
+ length
- strlen (cp
->suffix
))
6594 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6595 /* look again, but case-insensitively this time. */
6597 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6599 if (/* The suffix `-' matches only the file name `-'. */
6600 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6601 || (strlen (cp
->suffix
) < length
6602 /* See if the suffix matches the end of NAME. */
6603 && ((!strcmp (cp
->suffix
,
6604 name
+ length
- strlen (cp
->suffix
))
6605 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6606 && !strcasecmp (cp
->suffix
,
6607 name
+ length
- strlen (cp
->suffix
)))
6613 if (cp
>= compilers
)
6615 if (cp
->spec
[0] != '@')
6616 /* A non-alias entry: return it. */
6619 /* An alias entry maps a suffix to a language.
6620 Search for the language; pass 0 for NAME and LENGTH
6621 to avoid infinite recursion if language not found. */
6622 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
6628 save_string (s
, len
)
6632 char *result
= xmalloc (len
+ 1);
6634 memcpy (result
, s
, len
);
6640 pfatal_with_name (name
)
6643 perror_with_name (name
);
6644 delete_temp_files ();
6649 perror_with_name (name
)
6652 error ("%s: %s", name
, xstrerror (errno
));
6656 pfatal_pexecute (errmsg_fmt
, errmsg_arg
)
6657 const char *errmsg_fmt
;
6658 const char *errmsg_arg
;
6662 int save_errno
= errno
;
6664 /* Space for trailing '\0' is in %s. */
6665 char *msg
= xmalloc (strlen (errmsg_fmt
) + strlen (errmsg_arg
));
6666 sprintf (msg
, errmsg_fmt
, errmsg_arg
);
6672 pfatal_with_name (errmsg_fmt
);
6675 /* Output an error message and exit */
6680 fatal ("internal gcc abort");
6683 /* Output an error message and exit */
6686 fatal
VPARAMS ((const char *msgid
, ...))
6688 VA_OPEN (ap
, msgid
);
6689 VA_FIXEDARG (ap
, const char *, msgid
);
6691 fprintf (stderr
, "%s: ", programname
);
6692 vfprintf (stderr
, _(msgid
), ap
);
6694 fprintf (stderr
, "\n");
6695 delete_temp_files ();
6700 error
VPARAMS ((const char *msgid
, ...))
6702 VA_OPEN (ap
, msgid
);
6703 VA_FIXEDARG (ap
, const char *, msgid
);
6705 fprintf (stderr
, "%s: ", programname
);
6706 vfprintf (stderr
, _(msgid
), ap
);
6709 fprintf (stderr
, "\n");
6713 notice
VPARAMS ((const char *msgid
, ...))
6715 VA_OPEN (ap
, msgid
);
6716 VA_FIXEDARG (ap
, const char *, msgid
);
6718 vfprintf (stderr
, _(msgid
), ap
);
6723 validate_switches_from_spec (spec
)
6726 const char *p
= spec
;
6729 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
6730 /* We have a switch spec. */
6731 p
= validate_switches (p
+ 1);
6735 validate_all_switches ()
6737 struct compiler
*comp
;
6738 struct spec_list
*spec
;
6740 for (comp
= compilers
; comp
->spec
; comp
++)
6741 validate_switches_from_spec (comp
->spec
);
6743 /* Look through the linked list of specs read from the specs file. */
6744 for (spec
= specs
; spec
; spec
= spec
->next
)
6745 validate_switches_from_spec (*spec
->ptr_spec
);
6747 validate_switches_from_spec (link_command_spec
);
6750 /* Look at the switch-name that comes after START
6751 and mark as valid all supplied switches that match it. */
6754 validate_switches (start
)
6757 const char *p
= start
;
6761 bool suffix
= false;
6762 bool starred
= false;
6764 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6777 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6778 || *p
== ',' || *p
== '.' || *p
== '@')
6783 starred
= true, p
++;
6789 /* Mark all matching switches as valid. */
6790 for (i
= 0; i
< n_switches
; i
++)
6791 if (!strncmp (switches
[i
].part1
, atom
, len
)
6792 && (starred
|| switches
[i
].part1
[len
] == 0))
6793 switches
[i
].validated
= 1;
6797 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
6800 if (*p
&& p
[-1] == ':')
6802 while (*p
&& *p
!= ';' && *p
!= '}')
6807 if (*p
== '{' || *p
== '<')
6808 p
= validate_switches (p
+1);
6809 else if (p
[0] == 'W' && p
[1] == '{')
6810 p
= validate_switches (p
+2);
6817 if (*p
&& p
[-1] == ';')
6831 static struct mdswitchstr
*mdswitches
;
6832 static int n_mdswitches
;
6834 /* Check whether a particular argument was used. The first time we
6835 canonicalize the switches to keep only the ones we care about. */
6845 const char *replace
;
6850 static struct mswitchstr
*mswitches
;
6851 static int n_mswitches
;
6856 struct mswitchstr
*matches
;
6860 /* Break multilib_matches into the component strings of string
6861 and replacement string. */
6862 for (q
= multilib_matches
; *q
!= '\0'; q
++)
6867 (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
6869 q
= multilib_matches
;
6879 matches
[i
].len
= q
- matches
[i
].str
;
6881 matches
[i
].replace
= ++q
;
6882 while (*q
!= ';' && *q
!= '\0')
6888 matches
[i
].rep_len
= q
- matches
[i
].replace
;
6894 /* Now build a list of the replacement string for switches that we care
6895 about. Make sure we allocate at least one entry. This prevents
6896 xmalloc from calling fatal, and prevents us from re-executing this
6899 = (struct mswitchstr
*)
6900 xmalloc (sizeof (struct mswitchstr
)
6901 * (n_mdswitches
+ (n_switches
? n_switches
: 1)));
6902 for (i
= 0; i
< n_switches
; i
++)
6904 int xlen
= strlen (switches
[i
].part1
);
6905 for (j
= 0; j
< cnt
; j
++)
6906 if (xlen
== matches
[j
].len
6907 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
6909 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
6910 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
6911 mswitches
[n_mswitches
].replace
= (char *) 0;
6912 mswitches
[n_mswitches
].rep_len
= 0;
6918 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
6919 on the command line nor any options mutually incompatible with
6921 for (i
= 0; i
< n_mdswitches
; i
++)
6925 for (q
= multilib_options
; *q
!= '\0'; q
++)
6931 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
6932 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
6934 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
6941 if (*q
!= ' ' && *q
!= '\0')
6943 while (*r
!= ' ' && *r
!= '\0')
6946 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
6949 if (used_arg (r
, q
- r
))
6954 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
6955 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
6956 mswitches
[n_mswitches
].replace
= (char *) 0;
6957 mswitches
[n_mswitches
].rep_len
= 0;
6970 for (i
= 0; i
< n_mswitches
; i
++)
6971 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
6978 default_arg (p
, len
)
6984 for (i
= 0; i
< n_mdswitches
; i
++)
6985 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
6991 /* Work out the subdirectory to use based on the options. The format of
6992 multilib_select is a list of elements. Each element is a subdirectory
6993 name followed by a list of options followed by a semicolon. The format
6994 of multilib_exclusions is the same, but without the preceding
6995 directory. First gcc will check the exclusions, if none of the options
6996 beginning with an exclamation point are present, and all of the other
6997 options are present, then we will ignore this completely. Passing
6998 that, gcc will consider each multilib_select in turn using the same
6999 rules for matching the options. If a match is found, that subdirectory
7006 unsigned int this_path_len
;
7007 const char *this_path
, *this_arg
;
7008 const char *start
, *end
;
7010 int ok
, ndfltok
, first
;
7013 start
= multilib_defaults
;
7014 while (*start
== ' ' || *start
== '\t')
7016 while (*start
!= '\0')
7019 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7021 while (*start
== ' ' || *start
== '\t')
7030 = (struct mdswitchstr
*) xmalloc (sizeof (struct mdswitchstr
)
7032 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7034 while (*start
== ' ' || *start
== '\t')
7040 for (end
= start
+ 1;
7041 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7044 obstack_grow (&multilib_obstack
, start
, end
- start
);
7045 obstack_1grow (&multilib_obstack
, 0);
7046 mdswitches
[i
].str
= obstack_finish (&multilib_obstack
);
7047 mdswitches
[i
++].len
= end
- start
;
7054 p
= multilib_exclusions
;
7057 /* Ignore newlines. */
7064 /* Check the arguments. */
7078 while (*p
!= ' ' && *p
!= ';')
7085 if (*this_arg
!= '!')
7093 ok
= used_arg (this_arg
, p
- this_arg
);
7108 p
= multilib_select
;
7111 /* Ignore newlines. */
7118 /* Get the initial path. */
7126 this_path_len
= p
- this_path
;
7128 /* Check the arguments. */
7144 while (*p
!= ' ' && *p
!= ';')
7151 if (*this_arg
!= '!')
7159 /* If this is a default argument, we can just ignore it.
7160 This is true even if this_arg begins with '!'. Beginning
7161 with '!' does not mean that this argument is necessarily
7162 inappropriate for this library: it merely means that
7163 there is a more specific library which uses this
7164 argument. If this argument is a default, we need not
7165 consider that more specific library. */
7166 ok
= used_arg (this_arg
, p
- this_arg
);
7173 if (default_arg (this_arg
, p
- this_arg
))
7182 if (this_path_len
!= 1
7183 || this_path
[0] != '.')
7185 char *new_multilib_dir
= xmalloc (this_path_len
+ 1);
7188 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7189 new_multilib_dir
[this_path_len
] = '\0';
7190 q
= strchr (new_multilib_dir
, ':');
7193 multilib_dir
= new_multilib_dir
;
7200 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7202 while (q
< end
&& *q
!= ':')
7206 char *new_multilib_os_dir
= xmalloc (end
- q
);
7207 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7208 new_multilib_os_dir
[end
- q
- 1] = '\0';
7209 multilib_os_dir
= new_multilib_os_dir
;
7217 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7218 && strcmp (multilib_os_dir
, ".") == 0)
7220 free ((char *) multilib_os_dir
);
7221 multilib_os_dir
= NULL
;
7223 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7224 multilib_os_dir
= multilib_dir
;
7227 /* Print out the multiple library subdirectory selection
7228 information. This prints out a series of lines. Each line looks
7229 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7230 required. Only the desired options are printed out, the negative
7231 matches. The options are print without a leading dash. There are
7232 no spaces to make it easy to use the information in the shell.
7233 Each subdirectory is printed only once. This assumes the ordering
7234 generated by the genmultilib script. Also, we leave out ones that match
7238 print_multilib_info ()
7240 const char *p
= multilib_select
;
7241 const char *last_path
= 0, *this_path
;
7243 unsigned int last_path_len
= 0;
7248 /* Ignore newlines. */
7255 /* Get the initial path. */
7264 /* When --disable-multilib was used but target defines
7265 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7266 to find multilib_os_dir, so skip them from output. */
7267 if (this_path
[0] == '.' && this_path
[1] == ':')
7270 /* Check for matches with the multilib_exclusions. We don't bother
7271 with the '!' in either list. If any of the exclusion rules match
7272 all of its options with the select rule, we skip it. */
7274 const char *e
= multilib_exclusions
;
7275 const char *this_arg
;
7280 /* Ignore newlines. */
7287 /* Check the arguments. */
7304 while (*e
!= ' ' && *e
!= ';')
7315 int len
= e
- this_arg
;
7322 while (*q
!= ' ' && *q
!= ';')
7329 if (! strncmp (arg
, this_arg
, (len
< q
- arg
) ? q
- arg
: len
) ||
7330 default_arg (this_arg
, e
- this_arg
))
7360 /* If this is a duplicate, skip it. */
7361 skip
= (last_path
!= 0 && (unsigned int) (p
- this_path
) == last_path_len
7362 && ! strncmp (last_path
, this_path
, last_path_len
));
7364 last_path
= this_path
;
7365 last_path_len
= p
- this_path
;
7368 /* If this directory requires any default arguments, we can skip
7369 it. We will already have printed a directory identical to
7370 this one which does not require that default argument. */
7388 while (*q
!= ' ' && *q
!= ';')
7396 && default_arg (arg
, q
- arg
))
7411 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7430 use_arg
= *p
!= '!';
7435 while (*p
!= ' ' && *p
!= ';')
7450 /* If there are extra options, print them now. */
7451 if (multilib_extra
&& *multilib_extra
)
7453 int print_at
= TRUE
;
7456 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7477 /* if-exists built-in spec function.
7479 Checks to see if the file specified by the absolute pathname in
7480 ARGS exists. Returns that pathname if found.
7482 The usual use for this function is to check for a library file
7483 (whose name has been expanded with %s). */
7486 if_exists_spec_function (argc
, argv
)
7490 /* Must have only one argument. */
7491 if (argc
== 1 && IS_ABSOLUTE_PATHNAME (argv
[0]) && ! access (argv
[0], R_OK
))
7497 /* if-exists-else built-in spec function.
7499 This is like if-exists, but takes an additional argument which
7500 is returned if the first argument does not exist. */
7503 if_exists_else_spec_function (argc
, argv
)
7507 /* Must have exactly two arguments. */
7511 if (IS_ABSOLUTE_PATHNAME (argv
[0]) && ! access (argv
[0], R_OK
))