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 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
452 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
453 and -B options) as necessary.
454 %s current argument is the name of a library or startup file of some sort.
455 Search for that file in a standard list of directories
456 and substitute the full name found.
457 %eSTR Print STR as an error message. STR is terminated by a newline.
458 Use this when inconsistent options are detected.
459 %nSTR Print STR as a notice. STR is terminated by a newline.
460 %x{OPTION} Accumulate an option for %X.
461 %X Output the accumulated linker options specified by compilations.
462 %Y Output the accumulated assembler options specified by compilations.
463 %Z Output the accumulated preprocessor options specified by compilations.
464 %a process ASM_SPEC as a spec.
465 This allows config.h to specify part of the spec for running as.
466 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
467 used here. This can be used to run a post-processor after the
468 assembler has done its job.
469 %D Dump out a -L option for each directory in startfile_prefixes.
470 If multilib_dir is set, extra entries are generated with it affixed.
471 %l process LINK_SPEC as a spec.
472 %L process LIB_SPEC as a spec.
473 %G process LIBGCC_SPEC as a spec.
474 %M output multilib_dir with directory separators replaced with "_";
475 if multilib_dir is not set or is ".", output "".
476 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
477 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
478 %C process CPP_SPEC as a spec.
479 %1 process CC1_SPEC as a spec.
480 %2 process CC1PLUS_SPEC as a spec.
481 %* substitute the variable part of a matched option. (See below.)
482 Note that each comma in the substituted string is replaced by
484 %<S remove all occurrences of -S from the command line.
485 Note - this command is position dependent. % commands in the
486 spec string before this one will see -S, % commands in the
487 spec string after this one will not.
488 %<S* remove all occurrences of all switches beginning with -S from the
491 Call the named function FUNCTION, passing it ARGS. ARGS is
492 first processed as a nested spec string, then split into an
493 argument vector in the usual fashion. The function returns
494 a string which is processed as if it had appeared literally
495 as part of the current spec.
496 %{S} substitutes the -S switch, if that switch was given to CC.
497 If that switch was not specified, this substitutes nothing.
498 Here S is a metasyntactic variable.
499 %{S*} substitutes all the switches specified to CC whose names start
500 with -S. This is used for -o, -I, etc; switches that take
501 arguments. CC considers `-o foo' as being one switch whose
502 name starts with `o'. %{o*} would substitute this text,
503 including the space; thus, two arguments would be generated.
504 %{S*&T*} likewise, but preserve order of S and T options (the order
505 of S and T in the spec is not significant). Can be any number
506 of ampersand-separated variables; for each the wild card is
507 optional. Useful for CPP as %{D*&U*&A*}.
509 %{S:X} substitutes X, if the -S switch was given to CC.
510 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
511 %{S*:X} substitutes X if one or more switches whose names start
512 with -S was given to CC. Normally X is substituted only
513 once, no matter how many such switches appeared. However,
514 if %* appears somewhere in X, then X will be substituted
515 once for each matching switch, with the %* replaced by the
516 part of that switch that matched the '*'.
517 %{.S:X} substitutes X, if processing a file with suffix S.
518 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
520 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
521 combined with !, ., and * as above binding stronger than the OR.
522 If %* appears in X, all of the alternatives must be starred, and
523 only the first matching alternative is substituted.
524 %{S:X; if S was given to CC, substitutes X;
525 T:Y; else if T was given to CC, substitutes Y;
526 :D} else substitutes D. There can be as many clauses as you need.
527 This may be combined with ., !, |, and * as above.
529 %(Spec) processes a specification defined in a specs file as *Spec:
530 %[Spec] as above, but put __ around -D arguments
532 The conditional text X in a %{S:X} or similar construct may contain
533 other nested % constructs or spaces, or even newlines. They are
534 processed as usual, as described above. Trailing white space in X is
535 ignored. White space may also appear anywhere on the left side of the
536 colon in these constructs, except between . or * and the corresponding
539 The -O, -f, -m, and -W switches are handled specifically in these
540 constructs. If another value of -O or the negated form of a -f, -m, or
541 -W switch is found later in the command line, the earlier switch
542 value is ignored, except with {S*} where S is just one letter; this
543 passes all matching options.
545 The character | at the beginning of the predicate text is used to indicate
546 that a command should be piped to the following command, but only if -pipe
549 Note that it is built into CC which switches take arguments and which
550 do not. You might think it would be useful to generalize this to
551 allow each compiler's spec to say which switches take arguments. But
552 this cannot be done in a consistent fashion. CC cannot even decide
553 which input files have been specified without knowing which switches
554 take arguments, and it must know which input files to compile in order
555 to tell which compilers to run.
557 CC also knows implicitly that arguments starting in `-l' are to be
558 treated as compiler output files, and passed to the linker in their
559 proper position among the other output files. */
561 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
563 /* config.h can define ASM_SPEC to provide extra args to the assembler
564 or extra switch-translations. */
569 /* config.h can define ASM_FINAL_SPEC to run a post processor after
570 the assembler has run. */
571 #ifndef ASM_FINAL_SPEC
572 #define ASM_FINAL_SPEC ""
575 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
576 or extra switch-translations. */
581 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
582 or extra switch-translations. */
587 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
588 or extra switch-translations. */
590 #define CC1PLUS_SPEC ""
593 /* config.h can define LINK_SPEC to provide extra args to the linker
594 or extra switch-translations. */
599 /* config.h can define LIB_SPEC to override the default libraries. */
601 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
604 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
607 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
608 /* Have gcc do the search for libgcc.a. */
609 #define LIBGCC_SPEC "libgcc.a%s"
611 #define LIBGCC_SPEC "-lgcc"
615 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
616 #ifndef STARTFILE_SPEC
617 #define STARTFILE_SPEC \
618 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
621 /* config.h can define SWITCHES_NEED_SPACES to control which options
622 require spaces between the option and the argument. */
623 #ifndef SWITCHES_NEED_SPACES
624 #define SWITCHES_NEED_SPACES ""
627 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
629 #define ENDFILE_SPEC ""
633 #define LINKER_NAME "collect2"
636 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
638 #ifndef ASM_DEBUG_SPEC
639 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
640 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
641 # define ASM_DEBUG_SPEC \
642 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
643 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
644 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
646 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
647 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
649 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
650 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
654 #ifndef ASM_DEBUG_SPEC
655 # define ASM_DEBUG_SPEC ""
658 /* Here is the spec for running the linker, after compiling all files. */
660 /* This is overridable by the target in case they need to specify the
661 -lgcc and -lc order specially, yet not require them to override all
662 of LINK_COMMAND_SPEC. */
663 #ifndef LINK_GCC_C_SEQUENCE_SPEC
664 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
667 /* -u* was put back because both BSD and SysV seem to support it. */
668 /* %{static:} simply prevents an error message if the target machine
669 doesn't handle -static. */
670 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
671 scripts which exist in user specified directories, or in standard
673 #ifndef LINK_COMMAND_SPEC
674 #define LINK_COMMAND_SPEC "\
675 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
676 %(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r} %{s} %{t}\
677 %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
678 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs:-lgcov}\
679 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
680 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
683 #ifndef LINK_LIBGCC_SPEC
684 # ifdef LINK_LIBGCC_SPECIAL
685 /* Don't generate -L options for startfile prefix list. */
686 # define LINK_LIBGCC_SPEC ""
688 /* Do generate them. */
689 # define LINK_LIBGCC_SPEC "%D"
693 #ifndef STARTFILE_PREFIX_SPEC
694 # define STARTFILE_PREFIX_SPEC ""
697 static const char *asm_debug
;
698 static const char *cpp_spec
= CPP_SPEC
;
699 static const char *cc1_spec
= CC1_SPEC
;
700 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
701 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
702 static const char *asm_spec
= ASM_SPEC
;
703 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
704 static const char *link_spec
= LINK_SPEC
;
705 static const char *lib_spec
= LIB_SPEC
;
706 static const char *libgcc_spec
= LIBGCC_SPEC
;
707 static const char *endfile_spec
= ENDFILE_SPEC
;
708 static const char *startfile_spec
= STARTFILE_SPEC
;
709 static const char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
710 static const char *linker_name_spec
= LINKER_NAME
;
711 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
712 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
713 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
715 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
716 There should be no need to override these in target dependent files,
717 but we need to copy them to the specs file so that newer versions
718 of the GCC driver can correctly drive older tool chains with the
719 appropriate -B options. */
721 /* When cpplib handles traditional preprocessing, get rid of this, and
722 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
723 that we default the front end language better. */
724 static const char *trad_capable_cpp
=
725 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
727 /* We don't wrap .d files in %W{} since a missing .d file, and
728 therefore no dependency entry, confuses make into thinking a .o
729 file that happens to exist is up-to-date. */
730 static const char *cpp_unique_options
=
731 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
732 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
733 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
734 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
735 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
736 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
737 %{trigraphs} %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
740 /* This contains cpp options which are common with cc1_options and are passed
741 only when preprocessing only to avoid duplication. We pass the cc1 spec
742 options to the preprocessor so that it the cc1 spec may manipulate
743 options used to set target flags. Those special target flags settings may
744 in turn cause preprocessor symbols to be defined specially. */
745 static const char *cpp_options
=
746 "%(cpp_unique_options) %1 %{m*} %{std*} %{ansi} %{W*&pedantic*} %{w} %{f*}\
749 /* This contains cpp options which are not passed when the preprocessor
750 output will be used by another program. */
751 static const char *cpp_debug_options
= "%{d*}";
753 /* NB: This is shared amongst all front-ends. */
754 static const char *cc1_options
=
755 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
756 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
757 -auxbase%{c|S:%{o*:-strip %*}%{!o*: %b}}%{!c:%{!S: %b}}\
758 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
759 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
760 %{Qn:-fno-ident} %{--help:--help}\
761 %{--target-help:--target-help}\
762 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
763 %{fsyntax-only:-o %j} %{-param*}";
765 static const char *asm_options
=
766 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
768 static const char *invoke_as
=
769 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
770 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
772 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
775 /* Some compilers have limits on line lengths, and the multilib_select
776 and/or multilib_matches strings can be very long, so we build them at
778 static struct obstack multilib_obstack
;
779 static const char *multilib_select
;
780 static const char *multilib_matches
;
781 static const char *multilib_defaults
;
782 static const char *multilib_exclusions
;
783 #include "multilib.h"
785 /* Check whether a particular argument is a default argument. */
787 #ifndef MULTILIB_DEFAULTS
788 #define MULTILIB_DEFAULTS { "" }
791 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
793 #ifndef DRIVER_SELF_SPECS
794 #define DRIVER_SELF_SPECS ""
797 static const char *const driver_self_specs
[] = { DRIVER_SELF_SPECS
};
801 struct user_specs
*next
;
802 const char *filename
;
805 static struct user_specs
*user_specs_head
, *user_specs_tail
;
807 #ifndef SWITCH_TAKES_ARG
808 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
811 #ifndef WORD_SWITCH_TAKES_ARG
812 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
815 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
816 /* This defines which switches stop a full compilation. */
817 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
818 ((CHAR) == 'c' || (CHAR) == 'S')
820 #ifndef SWITCH_CURTAILS_COMPILATION
821 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
822 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
826 /* Record the mapping from file suffixes for compilation specs. */
830 const char *suffix
; /* Use this compiler for input files
831 whose names end in this suffix. */
833 const char *spec
; /* To use this compiler, run this spec. */
835 const char *cpp_spec
; /* If non-NULL, substitute this spec
836 for `%C', rather than the usual
840 /* Pointer to a vector of `struct compiler' that gives the spec for
841 compiling a file, based on its suffix.
842 A file that does not end in any of these suffixes will be passed
843 unchanged to the loader and nothing else will be done to it.
845 An entry containing two 0s is used to terminate the vector.
847 If multiple entries match a file, the last matching one is used. */
849 static struct compiler
*compilers
;
851 /* Number of entries in `compilers', not counting the null terminator. */
853 static int n_compilers
;
855 /* The default list of file name suffixes and their compilation specs. */
857 static const struct compiler default_compilers
[] =
859 /* Add lists of suffixes of known languages here. If those languages
860 were not present when we built the driver, we will hit these copies
861 and be given a more meaningful error than "file not used since
862 linking is not done". */
863 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
864 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
865 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
866 {".CPP", "#C++", 0}, {".ii", "#C++", 0},
867 {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
868 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
869 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
870 {".r", "#Ratfor", 0},
871 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
872 {".java", "#Java", 0}, {".class", "#Java", 0},
873 {".zip", "#Java", 0}, {".jar", "#Java", 0},
874 /* Next come the entries for C. */
877 /* cc1 has an integrated ISO C preprocessor. We should invoke the
878 external preprocessor if -save-temps is given. */
879 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
881 %{traditional|ftraditional:\
882 %eGNU C no longer supports -traditional without -E}\
883 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
884 %(cpp_options) %{save-temps:%b.i} %{!save-temps:%g.i} \n\
885 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} %(cc1_options)}\
886 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
887 cc1 %(cpp_unique_options) %(cc1_options)}}}\
888 %{!fsyntax-only:%(invoke_as)}}}}", 0},
890 "%{!E:%e-E required when input is from standard input}\
891 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0},
892 {".h", "@c-header", 0},
894 /* cc1 has an integrated ISO C preprocessor. We should invoke the
895 external preprocessor if -save-temps is given. */
896 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
898 %{save-temps|traditional-cpp:%(trad_capable_cpp) \
899 %(cpp_options) %b.i \n\
900 cc1 -fpreprocessed %b.i %(cc1_options)\
901 -o %g.s %{!o*:--output-pch=%i.gch}\
902 %W{o*:--output-pch=%*}%V}\
903 %{!save-temps:%{!traditional-cpp:\
904 cc1 %(cpp_unique_options) %(cc1_options)\
905 -o %g.s %{!o*:--output-pch=%i.gch}\
906 %W{o*:--output-pch=%*}%V}}}}}", 0},
907 {".i", "@cpp-output", 0},
909 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
910 {".s", "@assembler", 0},
912 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
913 {".S", "@assembler-with-cpp", 0},
914 {"@assembler-with-cpp",
915 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
916 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
917 %{E|M|MM:%(cpp_debug_options)}\
918 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
919 as %(asm_debug) %(asm_options) %|.s %A }}}}"
921 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
922 %{E|M|MM:%(cpp_debug_options)}\
923 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
924 as %(asm_debug) %(asm_options) %m.s %A }}}}"
929 /* Mark end of table */
933 /* Number of elements in default_compilers, not counting the terminator. */
935 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
937 /* A vector of options to give to the linker.
938 These options are accumulated by %x,
939 and substituted into the linker command with %X. */
940 static int n_linker_options
;
941 static char **linker_options
;
943 /* A vector of options to give to the assembler.
944 These options are accumulated by -Wa,
945 and substituted into the assembler command with %Y. */
946 static int n_assembler_options
;
947 static char **assembler_options
;
949 /* A vector of options to give to the preprocessor.
950 These options are accumulated by -Wp,
951 and substituted into the preprocessor command with %Z. */
952 static int n_preprocessor_options
;
953 static char **preprocessor_options
;
955 /* Define how to map long options into short ones. */
957 /* This structure describes one mapping. */
960 /* The long option's name. */
961 const char *const name
;
962 /* The equivalent short option. */
963 const char *const equivalent
;
964 /* Argument info. A string of flag chars; NULL equals no options.
965 a => argument required.
966 o => argument optional.
967 j => join argument to equivalent, making one word.
968 * => require other text after NAME as an argument. */
969 const char *const arg_info
;
972 /* This is the table of mappings. Mappings are tried sequentially
973 for each option encountered; the first one that matches, wins. */
975 static const struct option_map option_map
[] =
977 {"--all-warnings", "-Wall", 0},
978 {"--ansi", "-ansi", 0},
979 {"--assemble", "-S", 0},
980 {"--assert", "-A", "a"},
981 {"--classpath", "-fclasspath=", "aj"},
982 {"--bootclasspath", "-fbootclasspath=", "aj"},
983 {"--CLASSPATH", "-fclasspath=", "aj"},
984 {"--comments", "-C", 0},
985 {"--comments-in-macros", "-CC", 0},
986 {"--compile", "-c", 0},
987 {"--debug", "-g", "oj"},
988 {"--define-macro", "-D", "aj"},
989 {"--dependencies", "-M", 0},
990 {"--dump", "-d", "a"},
991 {"--dumpbase", "-dumpbase", "a"},
992 {"--entry", "-e", 0},
993 {"--extra-warnings", "-W", 0},
994 {"--for-assembler", "-Wa", "a"},
995 {"--for-linker", "-Xlinker", "a"},
996 {"--force-link", "-u", "a"},
997 {"--imacros", "-imacros", "a"},
998 {"--include", "-include", "a"},
999 {"--include-barrier", "-I-", 0},
1000 {"--include-directory", "-I", "aj"},
1001 {"--include-directory-after", "-idirafter", "a"},
1002 {"--include-prefix", "-iprefix", "a"},
1003 {"--include-with-prefix", "-iwithprefix", "a"},
1004 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1005 {"--include-with-prefix-after", "-iwithprefix", "a"},
1006 {"--language", "-x", "a"},
1007 {"--library-directory", "-L", "a"},
1008 {"--machine", "-m", "aj"},
1009 {"--machine-", "-m", "*j"},
1010 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1011 {"--no-line-commands", "-P", 0},
1012 {"--no-precompiled-includes", "-noprecomp", 0},
1013 {"--no-standard-includes", "-nostdinc", 0},
1014 {"--no-standard-libraries", "-nostdlib", 0},
1015 {"--no-warnings", "-w", 0},
1016 {"--optimize", "-O", "oj"},
1017 {"--output", "-o", "a"},
1018 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1019 {"--param", "--param", "a"},
1020 {"--pedantic", "-pedantic", 0},
1021 {"--pedantic-errors", "-pedantic-errors", 0},
1022 {"--pipe", "-pipe", 0},
1023 {"--prefix", "-B", "a"},
1024 {"--preprocess", "-E", 0},
1025 {"--print-search-dirs", "-print-search-dirs", 0},
1026 {"--print-file-name", "-print-file-name=", "aj"},
1027 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1028 {"--print-missing-file-dependencies", "-MG", 0},
1029 {"--print-multi-lib", "-print-multi-lib", 0},
1030 {"--print-multi-directory", "-print-multi-directory", 0},
1031 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1032 {"--print-prog-name", "-print-prog-name=", "aj"},
1033 {"--profile", "-p", 0},
1034 {"--profile-blocks", "-a", 0},
1035 {"--quiet", "-q", 0},
1036 {"--resource", "-fcompile-resource=", "aj"},
1037 {"--save-temps", "-save-temps", 0},
1038 {"--shared", "-shared", 0},
1039 {"--silent", "-q", 0},
1040 {"--specs", "-specs=", "aj"},
1041 {"--static", "-static", 0},
1042 {"--std", "-std=", "aj"},
1043 {"--symbolic", "-symbolic", 0},
1044 {"--target", "-b", "a"},
1045 {"--time", "-time", 0},
1046 {"--trace-includes", "-H", 0},
1047 {"--traditional", "-traditional", 0},
1048 {"--traditional-cpp", "-traditional-cpp", 0},
1049 {"--trigraphs", "-trigraphs", 0},
1050 {"--undefine-macro", "-U", "aj"},
1051 {"--use-version", "-V", "a"},
1052 {"--user-dependencies", "-MM", 0},
1053 {"--verbose", "-v", 0},
1054 {"--warn-", "-W", "*j"},
1055 {"--write-dependencies", "-MD", 0},
1056 {"--write-user-dependencies", "-MMD", 0},
1061 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1062 static const struct {
1063 const char *const option_found
;
1064 const char *const replacements
;
1065 } target_option_translations
[] =
1067 TARGET_OPTION_TRANSLATE_TABLE
,
1072 /* Translate the options described by *ARGCP and *ARGVP.
1073 Make a new vector and store it back in *ARGVP,
1074 and store its length in *ARGVC. */
1077 translate_options (argcp
, argvp
)
1079 const char *const **argvp
;
1083 const char *const *argv
= *argvp
;
1084 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1086 (const char **) xmalloc (newvsize
);
1090 newv
[newindex
++] = argv
[i
++];
1094 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1098 target_option_translations
[tott_idx
].option_found
;
1101 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1108 for (sp
= target_option_translations
[tott_idx
].replacements
;
1115 newvsize
+= spaces
* sizeof (const char *);
1116 newv
= (const char **) xrealloc (newv
, newvsize
);
1118 sp
= target_option_translations
[tott_idx
].replacements
;
1127 newv
[newindex
++] = np
;
1128 while (*np
!= ' ' && *np
)
1139 if (target_option_translations
[tott_idx
].option_found
)
1143 /* Translate -- options. */
1144 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1147 /* Find a mapping that applies to this option. */
1148 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1150 size_t optlen
= strlen (option_map
[j
].name
);
1151 size_t arglen
= strlen (argv
[i
]);
1152 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1153 const char *arginfo
= option_map
[j
].arg_info
;
1158 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1160 const char *arg
= 0;
1162 if (arglen
< optlen
)
1165 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1166 if (strlen (option_map
[k
].name
) >= arglen
1167 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1169 error ("ambiguous abbreviation %s", argv
[i
]);
1173 if (k
!= ARRAY_SIZE (option_map
))
1177 if (arglen
> optlen
)
1179 /* If the option has an argument, accept that. */
1180 if (argv
[i
][optlen
] == '=')
1181 arg
= argv
[i
] + optlen
+ 1;
1183 /* If this mapping requires extra text at end of name,
1184 accept that as "argument". */
1185 else if (strchr (arginfo
, '*') != 0)
1186 arg
= argv
[i
] + optlen
;
1188 /* Otherwise, extra text at end means mismatch.
1189 Try other mappings. */
1194 else if (strchr (arginfo
, '*') != 0)
1196 error ("incomplete `%s' option", option_map
[j
].name
);
1200 /* Handle arguments. */
1201 if (strchr (arginfo
, 'a') != 0)
1207 error ("missing argument to `%s' option",
1208 option_map
[j
].name
);
1215 else if (strchr (arginfo
, '*') != 0)
1217 else if (strchr (arginfo
, 'o') == 0)
1220 error ("extraneous argument to `%s' option",
1221 option_map
[j
].name
);
1225 /* Store the translation as one argv elt or as two. */
1226 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1227 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1231 newv
[newindex
++] = option_map
[j
].equivalent
;
1232 newv
[newindex
++] = arg
;
1235 newv
[newindex
++] = option_map
[j
].equivalent
;
1243 /* Handle old-fashioned options--just copy them through,
1244 with their arguments. */
1245 else if (argv
[i
][0] == '-')
1247 const char *p
= argv
[i
] + 1;
1251 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1252 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1253 else if (WORD_SWITCH_TAKES_ARG (p
))
1254 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1255 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1258 else if (! strcmp (p
, "Xlinker"))
1260 else if (! strcmp (p
, "Xpreprocessor"))
1262 else if (! strcmp (p
, "Xassembler"))
1265 /* Watch out for an option at the end of the command line that
1266 is missing arguments, and avoid skipping past the end of the
1268 if (nskip
+ i
> argc
)
1273 newv
[newindex
++] = argv
[i
++];
1278 /* Ordinary operands, or +e options. */
1279 newv
[newindex
++] = argv
[i
++];
1294 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1295 be considered whitespace. */
1296 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1298 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1312 /* Structures to keep track of prefixes to try when looking for files. */
1316 const char *prefix
; /* String to prepend to the path. */
1317 struct prefix_list
*next
; /* Next in linked list. */
1318 int require_machine_suffix
; /* Don't use without machine_suffix. */
1319 /* 2 means try both machine_suffix and just_machine_suffix. */
1320 int *used_flag_ptr
; /* 1 if a file was found with this prefix. */
1321 int priority
; /* Sort key - priority within list. */
1322 int os_multilib
; /* 1 if OS multilib scheme should be used,
1323 0 for GCC multilib scheme. */
1328 struct prefix_list
*plist
; /* List of prefixes to try */
1329 int max_len
; /* Max length of a prefix in PLIST */
1330 const char *name
; /* Name of this list (used in config stuff) */
1333 /* List of prefixes to try when looking for executables. */
1335 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1337 /* List of prefixes to try when looking for startup (crt0) files. */
1339 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1341 /* List of prefixes to try when looking for include files. */
1343 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1345 /* Suffix to attach to directories searched for commands.
1346 This looks like `MACHINE/VERSION/'. */
1348 static const char *machine_suffix
= 0;
1350 /* Suffix to attach to directories searched for commands.
1351 This is just `MACHINE/'. */
1353 static const char *just_machine_suffix
= 0;
1355 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1357 static const char *gcc_exec_prefix
;
1359 /* Default prefixes to attach to command names. */
1361 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1362 #undef MD_EXEC_PREFIX
1363 #undef MD_STARTFILE_PREFIX
1364 #undef MD_STARTFILE_PREFIX_1
1367 /* If no prefixes defined, use the null string, which will disable them. */
1368 #ifndef MD_EXEC_PREFIX
1369 #define MD_EXEC_PREFIX ""
1371 #ifndef MD_STARTFILE_PREFIX
1372 #define MD_STARTFILE_PREFIX ""
1374 #ifndef MD_STARTFILE_PREFIX_1
1375 #define MD_STARTFILE_PREFIX_1 ""
1378 /* Supply defaults for the standard prefixes. */
1380 #ifndef STANDARD_EXEC_PREFIX
1381 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1383 #ifndef STANDARD_STARTFILE_PREFIX
1384 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1386 #ifndef TOOLDIR_BASE_PREFIX
1387 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1389 #ifndef STANDARD_BINDIR_PREFIX
1390 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1393 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1394 static const char *const standard_exec_prefix_1
= "/usr/lib/gcc/";
1395 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1397 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1398 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1399 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1400 static const char *const standard_startfile_prefix_1
= "/lib/";
1401 static const char *const standard_startfile_prefix_2
= "/usr/lib/";
1403 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1404 static const char *tooldir_prefix
;
1406 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1408 /* Subdirectory to use for locating libraries. Set by
1409 set_multilib_dir based on the compilation options. */
1411 static const char *multilib_dir
;
1413 /* Subdirectory to use for locating libraries in OS conventions. Set by
1414 set_multilib_dir based on the compilation options. */
1416 static const char *multilib_os_dir
;
1418 /* Structure to keep track of the specs that have been defined so far.
1419 These are accessed using %(specname) or %[specname] in a compiler
1424 /* The following 2 fields must be first */
1425 /* to allow EXTRA_SPECS to be initialized */
1426 const char *name
; /* name of the spec. */
1427 const char *ptr
; /* available ptr if no static pointer */
1429 /* The following fields are not initialized */
1430 /* by EXTRA_SPECS */
1431 const char **ptr_spec
; /* pointer to the spec itself. */
1432 struct spec_list
*next
; /* Next spec in linked list. */
1433 int name_len
; /* length of the name */
1434 int alloc_p
; /* whether string was allocated */
1437 #define INIT_STATIC_SPEC(NAME,PTR) \
1438 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1440 /* List of statically defined specs. */
1441 static struct spec_list static_specs
[] =
1443 INIT_STATIC_SPEC ("asm", &asm_spec
),
1444 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1445 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1446 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1447 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1448 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1449 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1450 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1451 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1452 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1453 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1454 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1455 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1456 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1457 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1458 INIT_STATIC_SPEC ("link", &link_spec
),
1459 INIT_STATIC_SPEC ("lib", &lib_spec
),
1460 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1461 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1462 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces
),
1463 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1464 INIT_STATIC_SPEC ("version", &compiler_version
),
1465 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1466 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1467 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1468 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1469 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1470 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1471 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1472 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1473 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1474 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1475 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1476 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1479 #ifdef EXTRA_SPECS /* additional specs needed */
1480 /* Structure to keep track of just the first two args of a spec_list.
1481 That is all that the EXTRA_SPECS macro gives us. */
1484 const char *const name
;
1485 const char *const ptr
;
1488 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1489 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1492 /* List of dynamically allocates specs that have been defined so far. */
1494 static struct spec_list
*specs
= (struct spec_list
*) 0;
1496 /* List of static spec functions. */
1498 static const struct spec_function static_spec_functions
[] =
1500 { "if-exists", if_exists_spec_function
},
1501 { "if-exists-else", if_exists_else_spec_function
},
1505 static int processing_spec_function
;
1507 /* Add appropriate libgcc specs to OBSTACK, taking into account
1508 various permutations of -shared-libgcc, -shared, and such. */
1510 #ifdef ENABLE_SHARED_LIBGCC
1512 init_gcc_specs (obstack
, shared_name
, static_name
, eh_name
)
1513 struct obstack
*obstack
;
1514 const char *shared_name
;
1515 const char *static_name
;
1516 const char *eh_name
;
1520 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
,
1521 "}%{!static:%{!static-libgcc:",
1522 "%{!shared:%{!shared-libgcc:", static_name
, " ",
1523 eh_name
, "}%{shared-libgcc:", shared_name
, " ",
1524 static_name
, "}}%{shared:",
1526 "%{shared-libgcc:", shared_name
,
1527 "}%{!shared-libgcc:", static_name
, "}",
1533 obstack_grow (obstack
, buf
, strlen (buf
));
1536 #endif /* ENABLE_SHARED_LIBGCC */
1538 /* Initialize the specs lookup routines. */
1543 struct spec_list
*next
= (struct spec_list
*) 0;
1544 struct spec_list
*sl
= (struct spec_list
*) 0;
1548 return; /* Already initialized. */
1551 notice ("Using built-in specs.\n");
1554 extra_specs
= (struct spec_list
*)
1555 xcalloc (sizeof (struct spec_list
), ARRAY_SIZE (extra_specs_1
));
1557 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1559 sl
= &extra_specs
[i
];
1560 sl
->name
= extra_specs_1
[i
].name
;
1561 sl
->ptr
= extra_specs_1
[i
].ptr
;
1563 sl
->name_len
= strlen (sl
->name
);
1564 sl
->ptr_spec
= &sl
->ptr
;
1569 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1570 on ?: in file-scope variable initializations. */
1571 asm_debug
= ASM_DEBUG_SPEC
;
1573 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1575 sl
= &static_specs
[i
];
1580 #ifdef ENABLE_SHARED_LIBGCC
1581 /* ??? If neither -shared-libgcc nor --static-libgcc was
1582 seen, then we should be making an educated guess. Some proposed
1583 heuristics for ELF include:
1585 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1586 program will be doing dynamic loading, which will likely
1587 need the shared libgcc.
1589 (2) If "-ldl", then it's also a fair bet that we're doing
1592 (3) For each ET_DYN we're linking against (either through -lfoo
1593 or /some/path/foo.so), check to see whether it or one of
1594 its dependencies depends on a shared libgcc.
1598 If the runtime is fixed to look for program headers instead
1599 of calling __register_frame_info at all, for each object,
1600 use the shared libgcc if any EH symbol referenced.
1602 If crtstuff is fixed to not invoke __register_frame_info
1603 automatically, for each object, use the shared libgcc if
1604 any non-empty unwind section found.
1606 Doing any of this probably requires invoking an external program to
1607 do the actual object file scanning. */
1609 const char *p
= libgcc_spec
;
1612 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1613 when given the proper command line arguments. */
1616 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1618 init_gcc_specs (&obstack
,
1619 #ifdef NO_SHARED_LIBGCC_MULTILIB
1624 #ifdef USE_LIBUNWIND_EXCEPTIONS
1633 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1635 /* Ug. We don't know shared library extensions. Hope that
1636 systems that use this form don't do shared libraries. */
1637 init_gcc_specs (&obstack
,
1638 #ifdef NO_SHARED_LIBGCC_MULTILIB
1651 obstack_1grow (&obstack
, *p
);
1652 in_sep
= (*p
== ' ');
1657 obstack_1grow (&obstack
, '\0');
1658 libgcc_spec
= obstack_finish (&obstack
);
1661 #ifdef USE_AS_TRADITIONAL_FORMAT
1662 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1664 static const char tf
[] = "--traditional-format ";
1665 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1666 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1667 asm_spec
= obstack_finish (&obstack
);
1671 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1672 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1673 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1674 link_spec
= obstack_finish (&obstack
);
1680 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1681 removed; If the spec starts with a + then SPEC is added to the end of the
1685 set_spec (name
, spec
)
1689 struct spec_list
*sl
;
1690 const char *old_spec
;
1691 int name_len
= strlen (name
);
1694 /* If this is the first call, initialize the statically allocated specs. */
1697 struct spec_list
*next
= (struct spec_list
*) 0;
1698 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1700 sl
= &static_specs
[i
];
1707 /* See if the spec already exists. */
1708 for (sl
= specs
; sl
; sl
= sl
->next
)
1709 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1714 /* Not found - make it. */
1715 sl
= (struct spec_list
*) xmalloc (sizeof (struct spec_list
));
1716 sl
->name
= xstrdup (name
);
1717 sl
->name_len
= name_len
;
1718 sl
->ptr_spec
= &sl
->ptr
;
1720 *(sl
->ptr_spec
) = "";
1725 old_spec
= *(sl
->ptr_spec
);
1726 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1727 ? concat (old_spec
, spec
+ 1, NULL
)
1732 notice ("Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1735 /* Free the old spec. */
1736 if (old_spec
&& sl
->alloc_p
)
1737 free ((PTR
) old_spec
);
1742 /* Accumulate a command (program name and args), and run it. */
1744 /* Vector of pointers to arguments in the current line of specifications. */
1746 static const char **argbuf
;
1748 /* Number of elements allocated in argbuf. */
1750 static int argbuf_length
;
1752 /* Number of elements in argbuf currently in use (containing args). */
1754 static int argbuf_index
;
1756 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1757 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1760 static struct temp_name
{
1761 const char *suffix
; /* suffix associated with the code. */
1762 int length
; /* strlen (suffix). */
1763 int unique
; /* Indicates whether %g or %u/%U was used. */
1764 const char *filename
; /* associated filename. */
1765 int filename_length
; /* strlen (filename). */
1766 struct temp_name
*next
;
1769 /* Number of commands executed so far. */
1771 static int execution_count
;
1773 /* Number of commands that exited with a signal. */
1775 static int signal_count
;
1777 /* Name with which this program was invoked. */
1779 static const char *programname
;
1781 /* Allocate the argument vector. */
1787 argbuf
= (const char **) xmalloc (argbuf_length
* sizeof (const char *));
1790 /* Clear out the vector of arguments (after a command is executed). */
1798 /* Add one argument to the vector at the end.
1799 This is done when a space is seen or at the end of the line.
1800 If DELETE_ALWAYS is nonzero, the arg is a filename
1801 and the file should be deleted eventually.
1802 If DELETE_FAILURE is nonzero, the arg is a filename
1803 and the file should be deleted if this compilation fails. */
1806 store_arg (arg
, delete_always
, delete_failure
)
1808 int delete_always
, delete_failure
;
1810 if (argbuf_index
+ 1 == argbuf_length
)
1812 = (const char **) xrealloc (argbuf
,
1813 (argbuf_length
*= 2) * sizeof (const char *));
1815 argbuf
[argbuf_index
++] = arg
;
1816 argbuf
[argbuf_index
] = 0;
1818 if (delete_always
|| delete_failure
)
1819 record_temp_file (arg
, delete_always
, delete_failure
);
1822 /* Load specs from a file name named FILENAME, replacing occurrences of
1823 various different types of line-endings, \r\n, \n\r and just \r, with
1827 load_specs (filename
)
1828 const char *filename
;
1832 struct stat statbuf
;
1839 notice ("Reading specs from %s\n", filename
);
1841 /* Open and stat the file. */
1842 desc
= open (filename
, O_RDONLY
, 0);
1844 pfatal_with_name (filename
);
1845 if (stat (filename
, &statbuf
) < 0)
1846 pfatal_with_name (filename
);
1848 /* Read contents of file into BUFFER. */
1849 buffer
= xmalloc ((unsigned) statbuf
.st_size
+ 1);
1850 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1852 pfatal_with_name (filename
);
1853 buffer
[readlen
] = 0;
1856 specs
= xmalloc (readlen
+ 1);
1858 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1864 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1866 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1880 /* Read compilation specs from a file named FILENAME,
1881 replacing the default ones.
1883 A suffix which starts with `*' is a definition for
1884 one of the machine-specific sub-specs. The "suffix" should be
1885 *asm, *cc1, *cpp, *link, *startfile, etc.
1886 The corresponding spec is stored in asm_spec, etc.,
1887 rather than in the `compilers' vector.
1889 Anything invalid in the file is a fatal error. */
1892 read_specs (filename
, main_p
)
1893 const char *filename
;
1899 buffer
= load_specs (filename
);
1901 /* Scan BUFFER for specs, putting them in the vector. */
1907 char *in
, *out
, *p1
, *p2
, *p3
;
1909 /* Advance P in BUFFER to the next nonblank nocomment line. */
1910 p
= skip_whitespace (p
);
1914 /* Is this a special command that starts with '%'? */
1915 /* Don't allow this for the main specs file, since it would
1916 encourage people to overwrite it. */
1917 if (*p
== '%' && !main_p
)
1920 while (*p
&& *p
!= '\n')
1926 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1927 && (p1
[sizeof "%include" - 1] == ' '
1928 || p1
[sizeof "%include" - 1] == '\t'))
1932 p1
+= sizeof ("%include");
1933 while (*p1
== ' ' || *p1
== '\t')
1936 if (*p1
++ != '<' || p
[-2] != '>')
1937 fatal ("specs %%include syntax malformed after %ld characters",
1938 (long) (p1
- buffer
+ 1));
1941 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
1942 read_specs (new_filename
? new_filename
: p1
, FALSE
);
1945 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1946 && (p1
[sizeof "%include_noerr" - 1] == ' '
1947 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1951 p1
+= sizeof "%include_noerr";
1952 while (*p1
== ' ' || *p1
== '\t')
1955 if (*p1
++ != '<' || p
[-2] != '>')
1956 fatal ("specs %%include syntax malformed after %ld characters",
1957 (long) (p1
- buffer
+ 1));
1960 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
1962 read_specs (new_filename
, FALSE
);
1963 else if (verbose_flag
)
1964 notice ("could not find specs file %s\n", p1
);
1967 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1968 && (p1
[sizeof "%rename" - 1] == ' '
1969 || p1
[sizeof "%rename" - 1] == '\t'))
1972 struct spec_list
*sl
;
1973 struct spec_list
*newsl
;
1975 /* Get original name. */
1976 p1
+= sizeof "%rename";
1977 while (*p1
== ' ' || *p1
== '\t')
1980 if (! ISALPHA ((unsigned char) *p1
))
1981 fatal ("specs %%rename syntax malformed after %ld characters",
1982 (long) (p1
- buffer
));
1985 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1988 if (*p2
!= ' ' && *p2
!= '\t')
1989 fatal ("specs %%rename syntax malformed after %ld characters",
1990 (long) (p2
- buffer
));
1994 while (*p2
== ' ' || *p2
== '\t')
1997 if (! ISALPHA ((unsigned char) *p2
))
1998 fatal ("specs %%rename syntax malformed after %ld characters",
1999 (long) (p2
- buffer
));
2001 /* Get new spec name. */
2003 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2007 fatal ("specs %%rename syntax malformed after %ld characters",
2008 (long) (p3
- buffer
));
2011 for (sl
= specs
; sl
; sl
= sl
->next
)
2012 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2016 fatal ("specs %s spec was not found to be renamed", p1
);
2018 if (strcmp (p1
, p2
) == 0)
2021 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2022 if (strcmp (newsl
->name
, p2
) == 0)
2023 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2028 notice ("rename spec %s to %s\n", p1
, p2
);
2030 notice ("spec is '%s'\n\n", *(sl
->ptr_spec
));
2034 set_spec (p2
, *(sl
->ptr_spec
));
2036 free ((PTR
) *(sl
->ptr_spec
));
2038 *(sl
->ptr_spec
) = "";
2043 fatal ("specs unknown %% command after %ld characters",
2044 (long) (p1
- buffer
));
2047 /* Find the colon that should end the suffix. */
2049 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2052 /* The colon shouldn't be missing. */
2054 fatal ("specs file malformed after %ld characters",
2055 (long) (p1
- buffer
));
2057 /* Skip back over trailing whitespace. */
2059 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2062 /* Copy the suffix to a string. */
2063 suffix
= save_string (p
, p2
- p
);
2064 /* Find the next line. */
2065 p
= skip_whitespace (p1
+ 1);
2067 fatal ("specs file malformed after %ld characters",
2068 (long) (p
- buffer
));
2071 /* Find next blank line or end of string. */
2072 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2075 /* Specs end at the blank line and do not include the newline. */
2076 spec
= save_string (p
, p1
- p
);
2079 /* Delete backslash-newline sequences from the spec. */
2084 if (in
[0] == '\\' && in
[1] == '\n')
2086 else if (in
[0] == '#')
2087 while (*in
&& *in
!= '\n')
2095 if (suffix
[0] == '*')
2097 if (! strcmp (suffix
, "*link_command"))
2098 link_command_spec
= spec
;
2100 set_spec (suffix
+ 1, spec
);
2104 /* Add this pair to the vector. */
2106 = ((struct compiler
*)
2107 xrealloc (compilers
,
2108 (n_compilers
+ 2) * sizeof (struct compiler
)));
2110 compilers
[n_compilers
].suffix
= suffix
;
2111 compilers
[n_compilers
].spec
= spec
;
2113 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2117 link_command_spec
= spec
;
2120 if (link_command_spec
== 0)
2121 fatal ("spec file has no spec for linking");
2124 /* Record the names of temporary files we tell compilers to write,
2125 and delete them at the end of the run. */
2127 /* This is the common prefix we use to make temp file names.
2128 It is chosen once for each run of this program.
2129 It is substituted into a spec by %g or %j.
2130 Thus, all temp file names contain this prefix.
2131 In practice, all temp file names start with this prefix.
2133 This prefix comes from the envvar TMPDIR if it is defined;
2134 otherwise, from the P_tmpdir macro if that is defined;
2135 otherwise, in /usr/tmp or /tmp;
2136 or finally the current directory if all else fails. */
2138 static const char *temp_filename
;
2140 /* Length of the prefix. */
2142 static int temp_filename_length
;
2144 /* Define the list of temporary files to delete. */
2149 struct temp_file
*next
;
2152 /* Queue of files to delete on success or failure of compilation. */
2153 static struct temp_file
*always_delete_queue
;
2154 /* Queue of files to delete on failure of compilation. */
2155 static struct temp_file
*failure_delete_queue
;
2157 /* Record FILENAME as a file to be deleted automatically.
2158 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2159 otherwise delete it in any case.
2160 FAIL_DELETE nonzero means delete it if a compilation step fails;
2161 otherwise delete it in any case. */
2164 record_temp_file (filename
, always_delete
, fail_delete
)
2165 const char *filename
;
2169 char *const name
= xstrdup (filename
);
2173 struct temp_file
*temp
;
2174 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2175 if (! strcmp (name
, temp
->name
))
2178 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
2179 temp
->next
= always_delete_queue
;
2181 always_delete_queue
= temp
;
2188 struct temp_file
*temp
;
2189 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2190 if (! strcmp (name
, temp
->name
))
2193 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
2194 temp
->next
= failure_delete_queue
;
2196 failure_delete_queue
= temp
;
2202 /* Delete all the temporary files whose names we previously recorded. */
2205 delete_if_ordinary (name
)
2212 printf ("Delete %s? (y or n) ", name
);
2216 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2219 if (i
== 'y' || i
== 'Y')
2221 if (stat (name
, &st
) >= 0 && S_ISREG (st
.st_mode
))
2222 if (unlink (name
) < 0)
2224 perror_with_name (name
);
2228 delete_temp_files ()
2230 struct temp_file
*temp
;
2232 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2233 delete_if_ordinary (temp
->name
);
2234 always_delete_queue
= 0;
2237 /* Delete all the files to be deleted on error. */
2240 delete_failure_queue ()
2242 struct temp_file
*temp
;
2244 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2245 delete_if_ordinary (temp
->name
);
2249 clear_failure_queue ()
2251 failure_delete_queue
= 0;
2254 /* Build a list of search directories from PATHS.
2255 PREFIX is a string to prepend to the list.
2256 If CHECK_DIR_P is nonzero we ensure the directory exists.
2257 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2258 It is also used by the --print-search-dirs flag. */
2261 build_search_list (paths
, prefix
, check_dir_p
)
2262 struct path_prefix
*paths
;
2266 int suffix_len
= (machine_suffix
) ? strlen (machine_suffix
) : 0;
2268 = (just_machine_suffix
) ? strlen (just_machine_suffix
) : 0;
2269 int first_time
= TRUE
;
2270 struct prefix_list
*pprefix
;
2272 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2273 obstack_1grow (&collect_obstack
, '=');
2275 for (pprefix
= paths
->plist
; pprefix
!= 0; pprefix
= pprefix
->next
)
2277 int len
= strlen (pprefix
->prefix
);
2281 || is_directory (pprefix
->prefix
, machine_suffix
, 0)))
2284 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2287 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2288 obstack_grow (&collect_obstack
, machine_suffix
, suffix_len
);
2291 if (just_machine_suffix
2292 && pprefix
->require_machine_suffix
== 2
2294 || is_directory (pprefix
->prefix
, just_machine_suffix
, 0)))
2297 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2300 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2301 obstack_grow (&collect_obstack
, just_machine_suffix
,
2305 if (! pprefix
->require_machine_suffix
)
2308 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2311 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2315 obstack_1grow (&collect_obstack
, '\0');
2316 return obstack_finish (&collect_obstack
);
2319 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2323 putenv_from_prefixes (paths
, env_var
)
2324 struct path_prefix
*paths
;
2325 const char *env_var
;
2327 putenv (build_search_list (paths
, env_var
, 1));
2330 /* Check whether NAME can be accessed in MODE. This is like access,
2331 except that it never considers directories to be executable. */
2334 access_check (name
, mode
)
2342 if (stat (name
, &st
) < 0
2343 || S_ISDIR (st
.st_mode
))
2347 return access (name
, mode
);
2350 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2351 access to check permissions.
2352 Return 0 if not found, otherwise return its name, allocated with malloc. */
2355 find_a_file (pprefix
, name
, mode
, multilib
)
2356 struct path_prefix
*pprefix
;
2361 const char *const file_suffix
=
2362 ((mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "");
2363 struct prefix_list
*pl
;
2364 int len
= pprefix
->max_len
+ strlen (name
) + strlen (file_suffix
) + 1;
2365 const char *multilib_name
, *multilib_os_name
;
2367 #ifdef DEFAULT_ASSEMBLER
2368 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2369 return xstrdup (DEFAULT_ASSEMBLER
);
2372 #ifdef DEFAULT_LINKER
2373 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2374 return xstrdup (DEFAULT_LINKER
);
2378 len
+= strlen (machine_suffix
);
2380 multilib_name
= name
;
2381 multilib_os_name
= name
;
2382 if (multilib
&& multilib_os_dir
)
2384 int len1
= multilib_dir
? strlen (multilib_dir
) + 1 : 0;
2385 int len2
= strlen (multilib_os_dir
) + 1;
2387 len
+= len1
> len2
? len1
: len2
;
2389 multilib_name
= ACONCAT ((multilib_dir
, dir_separator_str
, name
,
2391 if (strcmp (multilib_os_dir
, ".") != 0)
2392 multilib_os_name
= ACONCAT ((multilib_os_dir
, dir_separator_str
, name
,
2396 temp
= xmalloc (len
);
2398 /* Determine the filename to execute (special case for absolute paths). */
2400 if (IS_ABSOLUTE_PATHNAME (name
))
2402 if (access (name
, mode
) == 0)
2404 strcpy (temp
, name
);
2409 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
2411 const char *this_name
2412 = pl
->os_multilib
? multilib_os_name
: multilib_name
;
2416 /* Some systems have a suffix for executable files.
2417 So try appending that first. */
2418 if (file_suffix
[0] != 0)
2420 strcpy (temp
, pl
->prefix
);
2421 strcat (temp
, machine_suffix
);
2422 strcat (temp
, multilib_name
);
2423 strcat (temp
, file_suffix
);
2424 if (access_check (temp
, mode
) == 0)
2426 if (pl
->used_flag_ptr
!= 0)
2427 *pl
->used_flag_ptr
= 1;
2432 /* Now try just the multilib_name. */
2433 strcpy (temp
, pl
->prefix
);
2434 strcat (temp
, machine_suffix
);
2435 strcat (temp
, multilib_name
);
2436 if (access_check (temp
, mode
) == 0)
2438 if (pl
->used_flag_ptr
!= 0)
2439 *pl
->used_flag_ptr
= 1;
2444 /* Certain prefixes are tried with just the machine type,
2445 not the version. This is used for finding as, ld, etc. */
2446 if (just_machine_suffix
&& pl
->require_machine_suffix
== 2)
2448 /* Some systems have a suffix for executable files.
2449 So try appending that first. */
2450 if (file_suffix
[0] != 0)
2452 strcpy (temp
, pl
->prefix
);
2453 strcat (temp
, just_machine_suffix
);
2454 strcat (temp
, multilib_name
);
2455 strcat (temp
, file_suffix
);
2456 if (access_check (temp
, mode
) == 0)
2458 if (pl
->used_flag_ptr
!= 0)
2459 *pl
->used_flag_ptr
= 1;
2464 strcpy (temp
, pl
->prefix
);
2465 strcat (temp
, just_machine_suffix
);
2466 strcat (temp
, multilib_name
);
2467 if (access_check (temp
, mode
) == 0)
2469 if (pl
->used_flag_ptr
!= 0)
2470 *pl
->used_flag_ptr
= 1;
2475 /* Certain prefixes can't be used without the machine suffix
2476 when the machine or version is explicitly specified. */
2477 if (! pl
->require_machine_suffix
)
2479 /* Some systems have a suffix for executable files.
2480 So try appending that first. */
2481 if (file_suffix
[0] != 0)
2483 strcpy (temp
, pl
->prefix
);
2484 strcat (temp
, this_name
);
2485 strcat (temp
, file_suffix
);
2486 if (access_check (temp
, mode
) == 0)
2488 if (pl
->used_flag_ptr
!= 0)
2489 *pl
->used_flag_ptr
= 1;
2494 strcpy (temp
, pl
->prefix
);
2495 strcat (temp
, this_name
);
2496 if (access_check (temp
, mode
) == 0)
2498 if (pl
->used_flag_ptr
!= 0)
2499 *pl
->used_flag_ptr
= 1;
2509 /* Ranking of prefixes in the sort list. -B prefixes are put before
2512 enum path_prefix_priority
2514 PREFIX_PRIORITY_B_OPT
,
2515 PREFIX_PRIORITY_LAST
2518 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2519 order according to PRIORITY. Within each PRIORITY, new entries are
2522 If WARN is nonzero, we will warn if no file is found
2523 through this prefix. WARN should point to an int
2524 which will be set to 1 if this entry is used.
2526 COMPONENT is the value to be passed to update_path.
2528 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2529 the complete value of machine_suffix.
2530 2 means try both machine_suffix and just_machine_suffix. */
2533 add_prefix (pprefix
, prefix
, component
, priority
, require_machine_suffix
,
2535 struct path_prefix
*pprefix
;
2537 const char *component
;
2538 /* enum prefix_priority */ int priority
;
2539 int require_machine_suffix
;
2543 struct prefix_list
*pl
, **prev
;
2546 for (prev
= &pprefix
->plist
;
2547 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2548 prev
= &(*prev
)->next
)
2551 /* Keep track of the longest prefix */
2553 prefix
= update_path (prefix
, component
);
2554 len
= strlen (prefix
);
2555 if (len
> pprefix
->max_len
)
2556 pprefix
->max_len
= len
;
2558 pl
= (struct prefix_list
*) xmalloc (sizeof (struct prefix_list
));
2559 pl
->prefix
= prefix
;
2560 pl
->require_machine_suffix
= require_machine_suffix
;
2561 pl
->used_flag_ptr
= warn
;
2562 pl
->priority
= priority
;
2563 pl
->os_multilib
= os_multilib
;
2567 /* Insert after PREV */
2572 /* Same as add_prefix, but prepending target_system_root to prefix. */
2574 add_sysrooted_prefix (pprefix
, prefix
, component
, priority
,
2575 require_machine_suffix
, warn
, os_multilib
)
2576 struct path_prefix
*pprefix
;
2578 const char *component
;
2579 /* enum prefix_priority */ int priority
;
2580 int require_machine_suffix
;
2584 if (!IS_ABSOLUTE_PATHNAME (prefix
))
2587 if (target_system_root
)
2589 prefix
= concat (target_system_root
, prefix
, NULL
);
2590 /* We have to override this because GCC's notion of sysroot
2591 moves along with GCC. */
2595 add_prefix (pprefix
, prefix
, component
, priority
,
2596 require_machine_suffix
, warn
, os_multilib
);
2599 /* Execute the command specified by the arguments on the current line of spec.
2600 When using pipes, this includes several piped-together commands
2601 with `|' between them.
2603 Return 0 if successful, -1 if failed. */
2609 int n_commands
; /* # of command. */
2613 const char *prog
; /* program name. */
2614 const char **argv
; /* vector of args. */
2615 int pid
; /* pid of process for this command. */
2618 struct command
*commands
; /* each command buffer with above info. */
2620 if (processing_spec_function
)
2623 /* Count # of piped commands. */
2624 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2625 if (strcmp (argbuf
[i
], "|") == 0)
2628 /* Get storage for each command. */
2629 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2631 /* Split argbuf into its separate piped processes,
2632 and record info about each one.
2633 Also search for the programs that are to be run. */
2635 commands
[0].prog
= argbuf
[0]; /* first command. */
2636 commands
[0].argv
= &argbuf
[0];
2637 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, 0);
2640 commands
[0].argv
[0] = string
;
2642 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2643 if (strcmp (argbuf
[i
], "|") == 0)
2644 { /* each command. */
2645 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2646 fatal ("-pipe not supported");
2648 argbuf
[i
] = 0; /* termination of command args. */
2649 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2650 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2651 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2654 commands
[n_commands
].argv
[0] = string
;
2658 argbuf
[argbuf_index
] = 0;
2660 /* If -v, print what we are about to do, and maybe query. */
2664 /* For help listings, put a blank line between sub-processes. */
2665 if (print_help_list
)
2666 fputc ('\n', stderr
);
2668 /* Print each piped command as a separate line. */
2669 for (i
= 0; i
< n_commands
; i
++)
2671 const char *const *j
;
2673 if (verbose_only_flag
)
2675 for (j
= commands
[i
].argv
; *j
; j
++)
2678 fprintf (stderr
, " \"");
2679 for (p
= *j
; *p
; ++p
)
2681 if (*p
== '"' || *p
== '\\' || *p
== '$')
2682 fputc ('\\', stderr
);
2685 fputc ('"', stderr
);
2689 for (j
= commands
[i
].argv
; *j
; j
++)
2690 fprintf (stderr
, " %s", *j
);
2692 /* Print a pipe symbol after all but the last command. */
2693 if (i
+ 1 != n_commands
)
2694 fprintf (stderr
, " |");
2695 fprintf (stderr
, "\n");
2698 if (verbose_only_flag
!= 0)
2701 notice ("\nGo ahead? (y or n) ");
2705 while (getchar () != '\n')
2708 if (i
!= 'y' && i
!= 'Y')
2713 #ifdef ENABLE_VALGRIND_CHECKING
2714 /* Run the each command through valgrind. To simplify prepending the
2715 path to valgrind and the option "-q" (for quiet operation unless
2716 something triggers), we allocate a separate argv array. */
2718 for (i
= 0; i
< n_commands
; i
++)
2724 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2727 argv
= alloca ((argc
+ 3) * sizeof (char *));
2729 argv
[0] = VALGRIND_PATH
;
2731 for (j
= 2; j
< argc
+ 2; j
++)
2732 argv
[j
] = commands
[i
].argv
[j
- 2];
2735 commands
[i
].argv
= argv
;
2736 commands
[i
].prog
= argv
[0];
2740 /* Run each piped subprocess. */
2742 for (i
= 0; i
< n_commands
; i
++)
2744 char *errmsg_fmt
, *errmsg_arg
;
2745 const char *string
= commands
[i
].argv
[0];
2747 /* For some bizarre reason, the second argument of execvp() is
2748 char *const *, not const char *const *. */
2749 commands
[i
].pid
= pexecute (string
, (char *const *) commands
[i
].argv
,
2750 programname
, temp_filename
,
2751 &errmsg_fmt
, &errmsg_arg
,
2752 ((i
== 0 ? PEXECUTE_FIRST
: 0)
2753 | (i
+ 1 == n_commands
? PEXECUTE_LAST
: 0)
2754 | (string
== commands
[i
].prog
2755 ? PEXECUTE_SEARCH
: 0)
2756 | (verbose_flag
? PEXECUTE_VERBOSE
: 0)));
2758 if (commands
[i
].pid
== -1)
2759 pfatal_pexecute (errmsg_fmt
, errmsg_arg
);
2761 if (string
!= commands
[i
].prog
)
2762 free ((PTR
) string
);
2767 /* Wait for all the subprocesses to finish.
2768 We don't care what order they finish in;
2769 we know that N_COMMANDS waits will get them all.
2770 Ignore subprocesses that we don't know about,
2771 since they can be spawned by the process that exec'ed us. */
2775 #ifdef HAVE_GETRUSAGE
2777 double ut
= 0.0, st
= 0.0;
2780 for (i
= 0; i
< n_commands
;)
2786 pid
= pwait (commands
[i
].pid
, &status
, 0);
2790 #ifdef HAVE_GETRUSAGE
2793 /* getrusage returns the total resource usage of all children
2794 up to now. Copy the previous values into prus, get the
2795 current statistics, then take the difference. */
2798 getrusage (RUSAGE_CHILDREN
, &rus
);
2799 d
.tv_sec
= rus
.ru_utime
.tv_sec
- prus
.ru_utime
.tv_sec
;
2800 d
.tv_usec
= rus
.ru_utime
.tv_usec
- prus
.ru_utime
.tv_usec
;
2801 ut
= (double) d
.tv_sec
+ (double) d
.tv_usec
/ 1.0e6
;
2803 d
.tv_sec
= rus
.ru_stime
.tv_sec
- prus
.ru_stime
.tv_sec
;
2804 d
.tv_usec
= rus
.ru_stime
.tv_usec
- prus
.ru_stime
.tv_usec
;
2805 st
= (double) d
.tv_sec
+ (double) d
.tv_usec
/ 1.0e6
;
2809 for (j
= 0; j
< n_commands
; j
++)
2810 if (commands
[j
].pid
== pid
)
2813 if (WIFSIGNALED (status
))
2816 /* SIGPIPE is a special case. It happens in -pipe mode
2817 when the compiler dies before the preprocessor is
2818 done, or the assembler dies before the compiler is
2819 done. There's generally been an error already, and
2820 this is just fallout. So don't generate another error
2821 unless we would otherwise have succeeded. */
2822 if (WTERMSIG (status
) == SIGPIPE
2823 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2828 Internal error: %s (program %s)\n\
2829 Please submit a full bug report.\n\
2830 See %s for instructions.",
2831 strsignal (WTERMSIG (status
)), commands
[j
].prog
,
2836 else if (WIFEXITED (status
)
2837 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2839 if (WEXITSTATUS (status
) > greatest_status
)
2840 greatest_status
= WEXITSTATUS (status
);
2843 #ifdef HAVE_GETRUSAGE
2844 if (report_times
&& ut
+ st
!= 0)
2845 notice ("# %s %.2f %.2f\n", commands
[j
].prog
, ut
, st
);
2854 /* Find all the switches given to us
2855 and make a vector describing them.
2856 The elements of the vector are strings, one per switch given.
2857 If a switch uses following arguments, then the `part1' field
2858 is the switch itself and the `args' field
2859 is a null-terminated vector containing the following arguments.
2860 The `live_cond' field is:
2862 1 if the switch is true in a conditional spec,
2863 -1 if false (overridden by a later switch)
2864 -2 if this switch should be ignored (used in %<S)
2865 The `validated' field is nonzero if any spec has looked at this switch;
2866 if it remains zero at the end of the run, it must be meaningless. */
2869 #define SWITCH_FALSE -1
2870 #define SWITCH_IGNORE -2
2871 #define SWITCH_LIVE 1
2878 unsigned char validated
;
2879 unsigned char ordering
;
2882 static struct switchstr
*switches
;
2884 static int n_switches
;
2889 const char *language
;
2892 /* Also a vector of input files specified. */
2894 static struct infile
*infiles
;
2898 /* This counts the number of libraries added by lang_specific_driver, so that
2899 we can tell if there were any user supplied any files or libraries. */
2901 static int added_libraries
;
2903 /* And a vector of corresponding output files is made up later. */
2905 const char **outfiles
;
2907 /* Used to track if none of the -B paths are used. */
2910 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2911 static int *warn_std_ptr
= 0;
2913 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2915 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2916 is true if we should look for an executable suffix. DO_OBJ
2917 is true if we should look for an object suffix. */
2920 convert_filename (name
, do_exe
, do_obj
)
2922 int do_exe ATTRIBUTE_UNUSED
;
2923 int do_obj ATTRIBUTE_UNUSED
;
2925 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2933 len
= strlen (name
);
2935 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2936 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2937 if (do_obj
&& len
> 2
2938 && name
[len
- 2] == '.'
2939 && name
[len
- 1] == 'o')
2941 obstack_grow (&obstack
, name
, len
- 2);
2942 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
2943 name
= obstack_finish (&obstack
);
2947 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2948 /* If there is no filetype, make it the executable suffix (which includes
2949 the "."). But don't get confused if we have just "-o". */
2950 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
2953 for (i
= len
- 1; i
>= 0; i
--)
2954 if (IS_DIR_SEPARATOR (name
[i
]))
2957 for (i
++; i
< len
; i
++)
2961 obstack_grow (&obstack
, name
, len
);
2962 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
2963 strlen (TARGET_EXECUTABLE_SUFFIX
));
2964 name
= obstack_finish (&obstack
);
2971 /* Display the command line switches accepted by gcc. */
2975 printf (_("Usage: %s [options] file...\n"), programname
);
2976 fputs (_("Options:\n"), stdout
);
2978 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
2979 fputs (_(" --help Display this information\n"), stdout
);
2980 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
2982 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
2983 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
2984 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
2985 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
2986 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
2987 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
2988 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
2989 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
2990 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
2992 -print-multi-lib Display the mapping between command line options and\n\
2993 multiple library search directories\n"), stdout
);
2994 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
2995 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
2996 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
2997 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
2998 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
2999 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3000 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3001 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3002 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3003 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3004 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3005 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3006 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3007 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout
);
3008 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout
);
3009 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3010 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3011 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3012 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3013 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3014 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3016 -x <language> Specify the language of the following input files\n\
3017 Permissible languages include: c c++ assembler none\n\
3018 'none' means revert to the default behavior of\n\
3019 guessing the language based on the file's extension\n\
3023 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3024 passed on to the various sub-processes invoked by %s. In order to pass\n\
3025 other options on to these processes the -W<letter> options must be used.\n\
3028 /* The rest of the options are displayed by invocations of the various
3033 add_preprocessor_option (option
, len
)
3037 n_preprocessor_options
++;
3039 if (! preprocessor_options
)
3040 preprocessor_options
3041 = (char **) xmalloc (n_preprocessor_options
* sizeof (char *));
3043 preprocessor_options
3044 = (char **) xrealloc (preprocessor_options
,
3045 n_preprocessor_options
* sizeof (char *));
3047 preprocessor_options
[n_preprocessor_options
- 1] =
3048 save_string (option
, len
);
3052 add_assembler_option (option
, len
)
3056 n_assembler_options
++;
3058 if (! assembler_options
)
3060 = (char **) xmalloc (n_assembler_options
* sizeof (char *));
3063 = (char **) xrealloc (assembler_options
,
3064 n_assembler_options
* sizeof (char *));
3066 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3070 add_linker_option (option
, len
)
3076 if (! linker_options
)
3078 = (char **) xmalloc (n_linker_options
* sizeof (char *));
3081 = (char **) xrealloc (linker_options
,
3082 n_linker_options
* sizeof (char *));
3084 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3087 /* Create the vector `switches' and its contents.
3088 Store its length in `n_switches'. */
3091 process_command (argc
, argv
)
3093 const char *const *argv
;
3098 const char *spec_lang
= 0;
3099 int last_language_n_infiles
;
3102 int lang_n_infiles
= 0;
3103 #ifdef MODIFY_TARGET_NAME
3104 int is_modify_target_name
;
3108 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3112 added_libraries
= 0;
3114 /* Figure compiler version from version string. */
3116 compiler_version
= temp1
= xstrdup (version_string
);
3118 for (; *temp1
; ++temp1
)
3127 /* If there is a -V or -b option (or both), process it now, before
3128 trying to interpret the rest of the command line. */
3129 if (argc
> 1 && argv
[1][0] == '-'
3130 && (argv
[1][1] == 'V' || argv
[1][1] == 'b'))
3132 const char *new_version
= DEFAULT_TARGET_VERSION
;
3133 const char *new_machine
= DEFAULT_TARGET_MACHINE
;
3134 const char *progname
= argv
[0];
3139 while (argc
> 1 && argv
[1][0] == '-'
3140 && (argv
[1][1] == 'V' || argv
[1][1] == 'b'))
3142 char opt
= argv
[1][1];
3144 if (argv
[1][2] != '\0')
3157 fatal ("`-%c' option must have argument", opt
);
3164 for (baselen
= strlen (progname
); baselen
> 0; baselen
--)
3165 if (IS_DIR_SEPARATOR (progname
[baselen
-1]))
3167 new_argv0
= xmemdup (progname
, baselen
,
3168 baselen
+ concat_length (new_version
, new_machine
,
3169 "-gcc-", NULL
) + 1);
3170 strcpy (new_argv0
+ baselen
, new_machine
);
3171 strcat (new_argv0
, "-gcc-");
3172 strcat (new_argv0
, new_version
);
3174 new_argv
= xmemdup (argv
, (argc
+ 1) * sizeof (argv
[0]),
3175 (argc
+ 1) * sizeof (argv
[0]));
3176 new_argv
[0] = new_argv0
;
3178 execvp (new_argv0
, new_argv
);
3179 fatal ("couldn't run `%s': %s", new_argv0
, xstrerror (errno
));
3182 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3183 see if we can create it from the pathname specified in argv[0]. */
3186 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3187 if (!gcc_exec_prefix
)
3189 gcc_exec_prefix
= make_relative_prefix (argv
[0], standard_bindir_prefix
,
3190 standard_exec_prefix
);
3191 if (gcc_exec_prefix
)
3192 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3196 if (gcc_exec_prefix
)
3198 int len
= strlen (gcc_exec_prefix
);
3200 if (len
> (int) sizeof ("/lib/gcc-lib/") - 1
3201 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3203 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc-lib/") + 1;
3204 if (IS_DIR_SEPARATOR (*temp
)
3205 && strncmp (temp
+ 1, "lib", 3) == 0
3206 && IS_DIR_SEPARATOR (temp
[4])
3207 && strncmp (temp
+ 5, "gcc-lib", 7) == 0)
3208 len
-= sizeof ("/lib/gcc-lib/") - 1;
3211 set_std_prefix (gcc_exec_prefix
, len
);
3212 add_prefix (&exec_prefixes
, gcc_exec_prefix
, "GCC",
3213 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3214 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3215 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3218 /* COMPILER_PATH and LIBRARY_PATH have values
3219 that are lists of directory names with colons. */
3221 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3224 const char *startp
, *endp
;
3225 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3227 startp
= endp
= temp
;
3230 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3232 strncpy (nstore
, startp
, endp
- startp
);
3234 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3235 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3237 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3238 nstore
[endp
- startp
+ 1] = 0;
3241 nstore
[endp
- startp
] = 0;
3242 add_prefix (&exec_prefixes
, nstore
, 0,
3243 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3244 add_prefix (&include_prefixes
,
3245 concat (nstore
, "include", NULL
),
3246 0, PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3249 endp
= startp
= endp
+ 1;
3256 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3257 if (temp
&& *cross_compile
== '0')
3259 const char *startp
, *endp
;
3260 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3262 startp
= endp
= temp
;
3265 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3267 strncpy (nstore
, startp
, endp
- startp
);
3269 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3270 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3272 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3273 nstore
[endp
- startp
+ 1] = 0;
3276 nstore
[endp
- startp
] = 0;
3277 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3278 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3281 endp
= startp
= endp
+ 1;
3288 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3289 GET_ENVIRONMENT (temp
, "LPATH");
3290 if (temp
&& *cross_compile
== '0')
3292 const char *startp
, *endp
;
3293 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3295 startp
= endp
= temp
;
3298 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3300 strncpy (nstore
, startp
, endp
- startp
);
3302 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3303 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3305 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3306 nstore
[endp
- startp
+ 1] = 0;
3309 nstore
[endp
- startp
] = 0;
3310 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3311 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3314 endp
= startp
= endp
+ 1;
3321 /* Convert new-style -- options to old-style. */
3322 translate_options (&argc
, &argv
);
3324 /* Do language-specific adjustment/addition of flags. */
3325 lang_specific_driver (&argc
, &argv
, &added_libraries
);
3327 /* Scan argv twice. Here, the first time, just count how many switches
3328 there will be in their vector, and how many input files in theirs.
3329 Here we also parse the switches that cc itself uses (e.g. -v). */
3331 for (i
= 1; i
< argc
; i
++)
3333 if (! strcmp (argv
[i
], "-dumpspecs"))
3335 struct spec_list
*sl
;
3337 for (sl
= specs
; sl
; sl
= sl
->next
)
3338 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3339 if (link_command_spec
)
3340 printf ("*link_command:\n%s\n\n", link_command_spec
);
3343 else if (! strcmp (argv
[i
], "-dumpversion"))
3345 printf ("%s\n", spec_version
);
3348 else if (! strcmp (argv
[i
], "-dumpmachine"))
3350 printf ("%s\n", spec_machine
);
3353 else if (strcmp (argv
[i
], "-fversion") == 0)
3355 /* translate_options () has turned --version into -fversion. */
3356 printf (_("%s (GCC) %s\n"), programname
, version_string
);
3357 fputs (_("Copyright (C) 2003 Free Software Foundation, Inc.\n"),
3359 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3360 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3364 else if (strcmp (argv
[i
], "-fhelp") == 0)
3366 /* translate_options () has turned --help into -fhelp. */
3367 print_help_list
= 1;
3369 /* We will be passing a dummy file on to the sub-processes. */
3373 /* CPP driver cannot obtain switch from cc1_options. */
3375 add_preprocessor_option ("--help", 6);
3376 add_assembler_option ("--help", 6);
3377 add_linker_option ("--help", 6);
3379 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3381 /* translate_options() has turned --target-help into -ftarget-help. */
3382 target_help_flag
= 1;
3384 /* We will be passing a dummy file on to the sub-processes. */
3388 /* CPP driver cannot obtain switch from cc1_options. */
3390 add_preprocessor_option ("--target-help", 13);
3391 add_assembler_option ("--target-help", 13);
3392 add_linker_option ("--target-help", 13);
3394 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3396 pass_exit_codes
= 1;
3399 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3400 print_search_dirs
= 1;
3401 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3402 print_file_name
= "libgcc.a";
3403 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3404 print_file_name
= argv
[i
] + 17;
3405 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3406 print_prog_name
= argv
[i
] + 17;
3407 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3408 print_multi_lib
= 1;
3409 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3410 print_multi_directory
= 1;
3411 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3412 print_multi_os_directory
= 1;
3413 else if (! strncmp (argv
[i
], "-Wa,", 4))
3416 /* Pass the rest of this option to the assembler. */
3418 /* Split the argument at commas. */
3420 for (j
= 4; argv
[i
][j
]; j
++)
3421 if (argv
[i
][j
] == ',')
3423 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3427 /* Record the part after the last comma. */
3428 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3430 else if (! strncmp (argv
[i
], "-Wp,", 4))
3433 /* Pass the rest of this option to the preprocessor. */
3435 /* Split the argument at commas. */
3437 for (j
= 4; argv
[i
][j
]; j
++)
3438 if (argv
[i
][j
] == ',')
3440 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3444 /* Record the part after the last comma. */
3445 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3447 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3448 /* The +e options to the C++ front-end. */
3450 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3453 /* Split the argument at commas. */
3454 for (j
= 3; argv
[i
][j
]; j
++)
3455 n_infiles
+= (argv
[i
][j
] == ',');
3457 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3460 fatal ("argument to `-Xlinker' is missing");
3465 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3468 fatal ("argument to `-Xpreprocessor' is missing");
3470 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3472 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3475 fatal ("argument to `-Xassembler' is missing");
3477 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3479 else if (strcmp (argv
[i
], "-l") == 0)
3482 fatal ("argument to `-l' is missing");
3487 else if (strncmp (argv
[i
], "-l", 2) == 0)
3489 else if (strcmp (argv
[i
], "-save-temps") == 0)
3491 save_temps_flag
= 1;
3494 else if (strcmp (argv
[i
], "-specs") == 0)
3496 struct user_specs
*user
= (struct user_specs
*)
3497 xmalloc (sizeof (struct user_specs
));
3499 fatal ("argument to `-specs' is missing");
3501 user
->next
= (struct user_specs
*) 0;
3502 user
->filename
= argv
[i
];
3503 if (user_specs_tail
)
3504 user_specs_tail
->next
= user
;
3506 user_specs_head
= user
;
3507 user_specs_tail
= user
;
3509 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3511 struct user_specs
*user
= (struct user_specs
*)
3512 xmalloc (sizeof (struct user_specs
));
3513 if (strlen (argv
[i
]) == 7)
3514 fatal ("argument to `-specs=' is missing");
3516 user
->next
= (struct user_specs
*) 0;
3517 user
->filename
= argv
[i
] + 7;
3518 if (user_specs_tail
)
3519 user_specs_tail
->next
= user
;
3521 user_specs_head
= user
;
3522 user_specs_tail
= user
;
3524 else if (strcmp (argv
[i
], "-time") == 0)
3526 else if (strcmp (argv
[i
], "-pipe") == 0)
3528 /* -pipe has to go into the switches array as well as
3533 else if (strcmp (argv
[i
], "-###") == 0)
3535 /* This is similar to -v except that there is no execution
3536 of the commands and the echoed arguments are quoted. It
3537 is intended for use in shell scripts to capture the
3538 driver-generated command line. */
3539 verbose_only_flag
++;
3542 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3544 const char *p
= &argv
[i
][1];
3551 fatal ("`-%c' must come at the start of the command line", c
);
3559 if (p
[1] == 0 && i
+ 1 == argc
)
3560 fatal ("argument to `-B' is missing");
3566 len
= strlen (value
);
3568 /* Catch the case where the user has forgotten to append a
3569 directory separator to the path. Note, they may be using
3570 -B to add an executable name prefix, eg "i386-elf-", in
3571 order to distinguish between multiple installations of
3572 GCC in the same directory. Hence we must check to see
3573 if appending a directory separator actually makes a
3574 valid directory name. */
3575 if (! IS_DIR_SEPARATOR (value
[len
- 1])
3576 && is_directory (value
, "", 0))
3578 char *tmp
= xmalloc (len
+ 2);
3579 strcpy (tmp
, value
);
3580 tmp
[len
] = DIR_SEPARATOR
;
3585 /* As a kludge, if the arg is "[foo/]stageN/", just
3586 add "[foo/]include" to the include prefix. */
3589 && (IS_DIR_SEPARATOR (value
[len
- 8]))))
3590 && strncmp (value
+ len
- 7, "stage", 5) == 0
3591 && ISDIGIT (value
[len
- 2])
3592 && (IS_DIR_SEPARATOR (value
[len
- 1])))
3595 add_prefix (&include_prefixes
, "include", NULL
,
3596 PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3599 char * string
= xmalloc (len
+ 1);
3601 strncpy (string
, value
, len
- 7);
3602 strcpy (string
+ len
- 7, "include");
3603 add_prefix (&include_prefixes
, string
, NULL
,
3604 PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3608 add_prefix (&exec_prefixes
, value
, NULL
,
3609 PREFIX_PRIORITY_B_OPT
, 0, &warn_B
, 0);
3610 add_prefix (&startfile_prefixes
, value
, NULL
,
3611 PREFIX_PRIORITY_B_OPT
, 0, &warn_B
, 0);
3612 add_prefix (&include_prefixes
, concat (value
, "include", NULL
),
3613 NULL
, PREFIX_PRIORITY_B_OPT
, 0, NULL
, 0);
3618 case 'v': /* Print our subcommands and print versions. */
3620 /* If they do anything other than exactly `-v', don't set
3621 verbose_flag; rather, continue on to give the error. */
3639 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3644 /* Forward scan, just in case -S or -c is specified
3651 if (argv
[j
][0] == '-')
3653 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
3659 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
3660 j
+= skip
- (argv
[j
][2] != 0);
3661 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
3668 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3670 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
3672 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
3679 #ifdef MODIFY_TARGET_NAME
3680 is_modify_target_name
= 0;
3682 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3683 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3686 = (char *) xmalloc (strlen (modify_target
[j
].str
)
3687 + strlen (spec_machine
));
3690 int made_addition
= 0;
3692 is_modify_target_name
= 1;
3693 for (p
= spec_machine
, q
= new_name
; *p
!= 0; )
3695 if (modify_target
[j
].add_del
== DELETE
3696 && (! strncmp (q
, modify_target
[j
].str
,
3697 strlen (modify_target
[j
].str
))))
3698 p
+= strlen (modify_target
[j
].str
);
3699 else if (modify_target
[j
].add_del
== ADD
3700 && ! made_addition
&& *p
== '-')
3702 for (r
= modify_target
[j
].str
; *r
!= 0; )
3710 spec_machine
= new_name
;
3713 if (is_modify_target_name
)
3719 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
3720 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
3721 else if (WORD_SWITCH_TAKES_ARG (p
))
3722 i
+= WORD_SWITCH_TAKES_ARG (p
);
3732 if (have_c
&& have_o
&& lang_n_infiles
> 1)
3733 fatal ("cannot specify -o with -c or -S and multiple compilations");
3735 if ((save_temps_flag
|| report_times
) && use_pipes
)
3737 /* -save-temps overrides -pipe, so that temp files are produced */
3738 if (save_temps_flag
)
3739 error ("warning: -pipe ignored because -save-temps specified");
3740 /* -time overrides -pipe because we can't get correct stats when
3741 multiple children are running at once. */
3742 else if (report_times
)
3743 error ("warning: -pipe ignored because -time specified");
3748 /* Set up the search paths before we go looking for config files. */
3750 /* These come before the md prefixes so that we will find gcc's subcommands
3751 (such as cpp) rather than those of the host system. */
3752 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3753 as well as trying the machine and the version. */
3755 add_prefix (&exec_prefixes
, standard_exec_prefix
, "GCC",
3756 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3757 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3758 PREFIX_PRIORITY_LAST
, 2, warn_std_ptr
, 0);
3759 add_prefix (&exec_prefixes
, standard_exec_prefix_1
, "BINUTILS",
3760 PREFIX_PRIORITY_LAST
, 2, warn_std_ptr
, 0);
3763 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3764 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3765 add_prefix (&startfile_prefixes
, standard_exec_prefix_1
, "BINUTILS",
3766 PREFIX_PRIORITY_LAST
, 1, warn_std_ptr
, 0);
3768 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
3769 dir_separator_str
, NULL
);
3771 /* If tooldir is relative, base it on exec_prefixes. A relative
3772 tooldir lets us move the installed tree as a unit.
3774 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3775 directories, so that we can search both the user specified directory
3776 and the standard place. */
3778 if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix
))
3780 if (gcc_exec_prefix
)
3782 char *gcc_exec_tooldir_prefix
3783 = concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
3784 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
3786 add_prefix (&exec_prefixes
,
3787 concat (gcc_exec_tooldir_prefix
, "bin",
3788 dir_separator_str
, NULL
),
3789 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3790 add_prefix (&startfile_prefixes
,
3791 concat (gcc_exec_tooldir_prefix
, "lib",
3792 dir_separator_str
, NULL
),
3793 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3796 tooldir_prefix
= concat (standard_exec_prefix
, spec_machine
,
3797 dir_separator_str
, spec_version
,
3798 dir_separator_str
, tooldir_prefix
, NULL
);
3801 add_prefix (&exec_prefixes
,
3802 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
3803 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
3804 add_prefix (&startfile_prefixes
,
3805 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
3806 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
3808 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3809 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3810 then consider it to relocate with the rest of the GCC installation
3811 if GCC_EXEC_PREFIX is set.
3812 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3813 if (target_system_root
&& gcc_exec_prefix
)
3815 char *tmp_prefix
= make_relative_prefix (argv
[0],
3816 standard_bindir_prefix
,
3817 target_system_root
);
3818 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
3820 target_system_root
= tmp_prefix
;
3821 target_system_root_changed
= 1;
3826 /* More prefixes are enabled in main, after we read the specs file
3827 and determine whether this is cross-compilation or not. */
3829 /* Then create the space for the vectors and scan again. */
3831 switches
= ((struct switchstr
*)
3832 xmalloc ((n_switches
+ 1) * sizeof (struct switchstr
)));
3833 infiles
= (struct infile
*) xmalloc ((n_infiles
+ 1) * sizeof (struct infile
));
3836 last_language_n_infiles
= -1;
3838 /* This, time, copy the text of each switch and store a pointer
3839 to the copy in the vector of switches.
3840 Store all the infiles in their vector. */
3842 for (i
= 1; i
< argc
; i
++)
3844 /* Just skip the switches that were handled by the preceding loop. */
3845 #ifdef MODIFY_TARGET_NAME
3846 is_modify_target_name
= 0;
3848 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3849 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3850 is_modify_target_name
= 1;
3852 if (is_modify_target_name
)
3856 if (! strncmp (argv
[i
], "-Wa,", 4))
3858 else if (! strncmp (argv
[i
], "-Wp,", 4))
3860 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3862 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3864 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3866 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3868 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3870 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3872 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3874 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3876 else if (! strcmp (argv
[i
], "-ftarget-help"))
3878 else if (! strcmp (argv
[i
], "-fhelp"))
3880 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3882 /* Compensate for the +e options to the C++ front-end;
3883 they're there simply for cfront call-compatibility. We do
3884 some magic in default_compilers to pass them down properly.
3885 Note we deliberately start at the `+' here, to avoid passing
3886 -e0 or -e1 down into the linker. */
3887 switches
[n_switches
].part1
= &argv
[i
][0];
3888 switches
[n_switches
].args
= 0;
3889 switches
[n_switches
].live_cond
= SWITCH_OK
;
3890 switches
[n_switches
].validated
= 0;
3893 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3896 /* Split the argument at commas. */
3898 for (j
= 4; argv
[i
][j
]; j
++)
3899 if (argv
[i
][j
] == ',')
3901 infiles
[n_infiles
].language
= "*";
3902 infiles
[n_infiles
++].name
3903 = save_string (argv
[i
] + prev
, j
- prev
);
3906 /* Record the part after the last comma. */
3907 infiles
[n_infiles
].language
= "*";
3908 infiles
[n_infiles
++].name
= argv
[i
] + prev
;
3910 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3912 infiles
[n_infiles
].language
= "*";
3913 infiles
[n_infiles
++].name
= argv
[++i
];
3915 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3917 infiles
[n_infiles
].language
= "*";
3918 infiles
[n_infiles
++].name
= argv
[++i
];
3920 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3922 infiles
[n_infiles
].language
= "*";
3923 infiles
[n_infiles
++].name
= argv
[++i
];
3925 else if (strcmp (argv
[i
], "-l") == 0)
3926 { /* POSIX allows separation of -l and the lib arg;
3927 canonicalize by concatenating -l with its arg */
3928 infiles
[n_infiles
].language
= "*";
3929 infiles
[n_infiles
++].name
= concat ("-l", argv
[++i
], NULL
);
3931 else if (strncmp (argv
[i
], "-l", 2) == 0)
3933 infiles
[n_infiles
].language
= "*";
3934 infiles
[n_infiles
++].name
= argv
[i
];
3936 else if (strcmp (argv
[i
], "-specs") == 0)
3938 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3940 else if (strcmp (argv
[i
], "-time") == 0)
3942 else if (strcmp (argv
[i
], "-###") == 0)
3944 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3946 const char *p
= &argv
[i
][1];
3951 if (p
[1] == 0 && i
+ 1 == argc
)
3952 fatal ("argument to `-x' is missing");
3954 spec_lang
= argv
[++i
];
3957 if (! strcmp (spec_lang
, "none"))
3958 /* Suppress the warning if -xnone comes after the last input
3959 file, because alternate command interfaces like g++ might
3960 find it useful to place -xnone after each input file. */
3963 last_language_n_infiles
= n_infiles
;
3966 switches
[n_switches
].part1
= p
;
3967 /* Deal with option arguments in separate argv elements. */
3968 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
3969 || WORD_SWITCH_TAKES_ARG (p
))
3972 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
3976 /* Count only the option arguments in separate argv elements. */
3977 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
3979 if (i
+ n_args
>= argc
)
3980 fatal ("argument to `-%s' is missing", p
);
3981 switches
[n_switches
].args
3982 = (const char **) xmalloc ((n_args
+ 1) * sizeof(const char *));
3984 switches
[n_switches
].args
[j
++] = argv
[++i
];
3985 /* Null-terminate the vector. */
3986 switches
[n_switches
].args
[j
] = 0;
3988 else if (strchr (switches_need_spaces
, c
))
3990 /* On some systems, ld cannot handle some options without
3991 a space. So split the option from its argument. */
3992 char *part1
= (char *) xmalloc (2);
3996 switches
[n_switches
].part1
= part1
;
3997 switches
[n_switches
].args
3998 = (const char **) xmalloc (2 * sizeof (const char *));
3999 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4000 switches
[n_switches
].args
[1] = 0;
4003 switches
[n_switches
].args
= 0;
4005 switches
[n_switches
].live_cond
= SWITCH_OK
;
4006 switches
[n_switches
].validated
= 0;
4007 switches
[n_switches
].ordering
= 0;
4008 /* These are always valid, since gcc.c itself understands them. */
4009 if (!strcmp (p
, "save-temps")
4010 || !strcmp (p
, "static-libgcc")
4011 || !strcmp (p
, "shared-libgcc")
4012 || !strcmp (p
, "pipe"))
4013 switches
[n_switches
].validated
= 1;
4016 char ch
= switches
[n_switches
].part1
[0];
4018 switches
[n_switches
].validated
= 1;
4024 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4025 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4028 if (strcmp (argv
[i
], "-") != 0 && access (argv
[i
], F_OK
) < 0)
4030 perror_with_name (argv
[i
]);
4035 infiles
[n_infiles
].language
= spec_lang
;
4036 infiles
[n_infiles
++].name
= argv
[i
];
4041 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4042 error ("warning: `-x %s' after last input file has no effect", spec_lang
);
4044 /* Ensure we only invoke each subprocess once. */
4045 if (target_help_flag
|| print_help_list
)
4049 /* Create a dummy input file, so that we can pass --target-help on to
4050 the various sub-processes. */
4051 infiles
[0].language
= "c";
4052 infiles
[0].name
= "help-dummy";
4054 if (target_help_flag
)
4056 switches
[n_switches
].part1
= "--target-help";
4057 switches
[n_switches
].args
= 0;
4058 switches
[n_switches
].live_cond
= SWITCH_OK
;
4059 switches
[n_switches
].validated
= 0;
4064 if (print_help_list
)
4066 switches
[n_switches
].part1
= "--help";
4067 switches
[n_switches
].args
= 0;
4068 switches
[n_switches
].live_cond
= SWITCH_OK
;
4069 switches
[n_switches
].validated
= 0;
4075 switches
[n_switches
].part1
= 0;
4076 infiles
[n_infiles
].name
= 0;
4079 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4080 and place that in the environment. */
4083 set_collect_gcc_options ()
4088 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4090 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4091 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4094 for (i
= 0; (int) i
< n_switches
; i
++)
4096 const char *const *args
;
4099 obstack_grow (&collect_obstack
, " ", 1);
4103 /* Ignore elided switches. */
4104 if (switches
[i
].live_cond
== SWITCH_IGNORE
)
4107 obstack_grow (&collect_obstack
, "'-", 2);
4108 q
= switches
[i
].part1
;
4109 while ((p
= strchr (q
, '\'')))
4111 obstack_grow (&collect_obstack
, q
, p
- q
);
4112 obstack_grow (&collect_obstack
, "'\\''", 4);
4115 obstack_grow (&collect_obstack
, q
, strlen (q
));
4116 obstack_grow (&collect_obstack
, "'", 1);
4118 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4120 obstack_grow (&collect_obstack
, " '", 2);
4122 while ((p
= strchr (q
, '\'')))
4124 obstack_grow (&collect_obstack
, q
, p
- q
);
4125 obstack_grow (&collect_obstack
, "'\\''", 4);
4128 obstack_grow (&collect_obstack
, q
, strlen (q
));
4129 obstack_grow (&collect_obstack
, "'", 1);
4132 obstack_grow (&collect_obstack
, "\0", 1);
4133 putenv (obstack_finish (&collect_obstack
));
4136 /* Process a spec string, accumulating and running commands. */
4138 /* These variables describe the input file name.
4139 input_file_number is the index on outfiles of this file,
4140 so that the output file name can be stored for later use by %o.
4141 input_basename is the start of the part of the input file
4142 sans all directory names, and basename_length is the number
4143 of characters starting there excluding the suffix .c or whatever. */
4145 static const char *input_filename
;
4146 static int input_file_number
;
4147 size_t input_filename_length
;
4148 static int basename_length
;
4149 static int suffixed_basename_length
;
4150 static const char *input_basename
;
4151 static const char *input_suffix
;
4152 static struct stat input_stat
;
4153 static int input_stat_set
;
4155 /* The compiler used to process the current input file. */
4156 static struct compiler
*input_file_compiler
;
4158 /* These are variables used within do_spec and do_spec_1. */
4160 /* Nonzero if an arg has been started and not yet terminated
4161 (with space, tab or newline). */
4162 static int arg_going
;
4164 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4165 is a temporary file name. */
4166 static int delete_this_arg
;
4168 /* Nonzero means %w has been seen; the next arg to be terminated
4169 is the output file name of this compilation. */
4170 static int this_is_output_file
;
4172 /* Nonzero means %s has been seen; the next arg to be terminated
4173 is the name of a library file and we should try the standard
4174 search dirs for it. */
4175 static int this_is_library_file
;
4177 /* Nonzero means that the input of this command is coming from a pipe. */
4178 static int input_from_pipe
;
4180 /* Nonnull means substitute this for any suffix when outputting a switches
4182 static const char *suffix_subst
;
4184 /* Process the spec SPEC and run the commands specified therein.
4185 Returns 0 if the spec is successfully processed; -1 if failed. */
4193 value
= do_spec_2 (spec
);
4195 /* Force out any unfinished command.
4196 If -pipe, this forces out the last command if it ended in `|'. */
4199 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4202 set_collect_gcc_options ();
4204 if (argbuf_index
> 0)
4220 delete_this_arg
= 0;
4221 this_is_output_file
= 0;
4222 this_is_library_file
= 0;
4223 input_from_pipe
= 0;
4224 suffix_subst
= NULL
;
4226 result
= do_spec_1 (spec
, 0, NULL
);
4228 /* End any pending argument. */
4231 obstack_1grow (&obstack
, 0);
4232 string
= obstack_finish (&obstack
);
4233 if (this_is_library_file
)
4234 string
= find_file (string
);
4235 store_arg (string
, delete_this_arg
, this_is_output_file
);
4236 if (this_is_output_file
)
4237 outfiles
[input_file_number
] = string
;
4245 /* Process the given spec string and add any new options to the end
4246 of the switches/n_switches array. */
4253 do_spec_1 (" ", 0, NULL
);
4255 if (argbuf_index
> 0)
4260 n_switches
+= argbuf_index
;
4261 switches
= xrealloc (switches
,
4262 sizeof (struct switchstr
) * (n_switches
+ 1));
4264 switches
[n_switches
] = switches
[first
];
4265 for (i
= 0; i
< argbuf_index
; i
++)
4267 struct switchstr
*sw
;
4269 /* Each switch should start with '-'. */
4270 if (argbuf
[i
][0] != '-')
4273 sw
= &switches
[i
+ first
];
4274 sw
->part1
= &argbuf
[i
][1];
4276 sw
->live_cond
= SWITCH_OK
;
4283 /* Process the sub-spec SPEC as a portion of a larger spec.
4284 This is like processing a whole spec except that we do
4285 not initialize at the beginning and we do not supply a
4286 newline by default at the end.
4287 INSWITCH nonzero means don't process %-sequences in SPEC;
4288 in this case, % is treated as an ordinary character.
4289 This is used while substituting switches.
4290 INSWITCH nonzero also causes SPC not to terminate an argument.
4292 Value is zero unless a line was finished
4293 and the command on that line reported an error. */
4296 do_spec_1 (spec
, inswitch
, soft_matched_part
)
4299 const char *soft_matched_part
;
4301 const char *p
= spec
;
4308 /* If substituting a switch, treat all chars like letters.
4309 Otherwise, NL, SPC, TAB and % are special. */
4310 switch (inswitch
? 'a' : c
)
4313 /* End of line: finish any pending argument,
4314 then run the pending command if one has been started. */
4317 obstack_1grow (&obstack
, 0);
4318 string
= obstack_finish (&obstack
);
4319 if (this_is_library_file
)
4320 string
= find_file (string
);
4321 store_arg (string
, delete_this_arg
, this_is_output_file
);
4322 if (this_is_output_file
)
4323 outfiles
[input_file_number
] = string
;
4327 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4329 /* A `|' before the newline means use a pipe here,
4330 but only if -pipe was specified.
4331 Otherwise, execute now and don't pass the `|' as an arg. */
4334 input_from_pipe
= 1;
4341 set_collect_gcc_options ();
4343 if (argbuf_index
> 0)
4349 /* Reinitialize for a new command, and for a new argument. */
4352 delete_this_arg
= 0;
4353 this_is_output_file
= 0;
4354 this_is_library_file
= 0;
4355 input_from_pipe
= 0;
4359 /* End any pending argument. */
4362 obstack_1grow (&obstack
, 0);
4363 string
= obstack_finish (&obstack
);
4364 if (this_is_library_file
)
4365 string
= find_file (string
);
4366 store_arg (string
, delete_this_arg
, this_is_output_file
);
4367 if (this_is_output_file
)
4368 outfiles
[input_file_number
] = string
;
4372 obstack_1grow (&obstack
, c
);
4378 /* Space or tab ends an argument if one is pending. */
4381 obstack_1grow (&obstack
, 0);
4382 string
= obstack_finish (&obstack
);
4383 if (this_is_library_file
)
4384 string
= find_file (string
);
4385 store_arg (string
, delete_this_arg
, this_is_output_file
);
4386 if (this_is_output_file
)
4387 outfiles
[input_file_number
] = string
;
4389 /* Reinitialize for a new argument. */
4391 delete_this_arg
= 0;
4392 this_is_output_file
= 0;
4393 this_is_library_file
= 0;
4400 fatal ("invalid specification! Bug in cc");
4403 obstack_grow (&obstack
, input_basename
, basename_length
);
4408 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4413 delete_this_arg
= 2;
4416 /* Dump out the directories specified with LIBRARY_PATH,
4417 followed by the absolute directories
4418 that we search for startfiles. */
4421 struct prefix_list
*pl
= startfile_prefixes
.plist
;
4422 size_t bufsize
= 100;
4423 char *buffer
= (char *) xmalloc (bufsize
);
4426 for (; pl
; pl
= pl
->next
)
4428 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4429 /* Used on systems which record the specified -L dirs
4430 and use them to search for dynamic linking. */
4431 /* Relative directories always come from -B,
4432 and it is better not to use them for searching
4433 at run time. In particular, stage1 loses. */
4434 if (!IS_ABSOLUTE_PATHNAME (pl
->prefix
))
4437 /* Try subdirectory if there is one. */
4438 if (multilib_dir
!= NULL
4439 || (pl
->os_multilib
&& multilib_os_dir
!= NULL
))
4441 const char *multi_dir
;
4443 multi_dir
= pl
->os_multilib
? multilib_os_dir
4445 if (machine_suffix
&& multilib_dir
)
4447 if (strlen (pl
->prefix
) + strlen (machine_suffix
)
4449 bufsize
= (strlen (pl
->prefix
)
4450 + strlen (machine_suffix
)) * 2 + 1;
4451 buffer
= (char *) xrealloc (buffer
, bufsize
);
4452 strcpy (buffer
, pl
->prefix
);
4453 strcat (buffer
, machine_suffix
);
4454 if (is_directory (buffer
, multilib_dir
, 1))
4456 do_spec_1 ("-L", 0, NULL
);
4457 #ifdef SPACE_AFTER_L_OPTION
4458 do_spec_1 (" ", 0, NULL
);
4460 do_spec_1 (buffer
, 1, NULL
);
4461 do_spec_1 (multilib_dir
, 1, NULL
);
4462 /* Make this a separate argument. */
4463 do_spec_1 (" ", 0, NULL
);
4466 if (!pl
->require_machine_suffix
)
4468 if (is_directory (pl
->prefix
, multi_dir
, 1))
4470 do_spec_1 ("-L", 0, NULL
);
4471 #ifdef SPACE_AFTER_L_OPTION
4472 do_spec_1 (" ", 0, NULL
);
4474 do_spec_1 (pl
->prefix
, 1, NULL
);
4475 do_spec_1 (multi_dir
, 1, NULL
);
4476 /* Make this a separate argument. */
4477 do_spec_1 (" ", 0, NULL
);
4483 if (is_directory (pl
->prefix
, machine_suffix
, 1))
4485 do_spec_1 ("-L", 0, NULL
);
4486 #ifdef SPACE_AFTER_L_OPTION
4487 do_spec_1 (" ", 0, NULL
);
4489 do_spec_1 (pl
->prefix
, 1, NULL
);
4490 /* Remove slash from machine_suffix. */
4491 if (strlen (machine_suffix
) >= bufsize
)
4492 bufsize
= strlen (machine_suffix
) * 2 + 1;
4493 buffer
= (char *) xrealloc (buffer
, bufsize
);
4494 strcpy (buffer
, machine_suffix
);
4495 idx
= strlen (buffer
);
4496 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4497 buffer
[idx
- 1] = 0;
4498 do_spec_1 (buffer
, 1, NULL
);
4499 /* Make this a separate argument. */
4500 do_spec_1 (" ", 0, NULL
);
4503 if (!pl
->require_machine_suffix
)
4505 if (is_directory (pl
->prefix
, "", 1))
4507 do_spec_1 ("-L", 0, NULL
);
4508 #ifdef SPACE_AFTER_L_OPTION
4509 do_spec_1 (" ", 0, NULL
);
4511 /* Remove slash from pl->prefix. */
4512 if (strlen (pl
->prefix
) >= bufsize
)
4513 bufsize
= strlen (pl
->prefix
) * 2 + 1;
4514 buffer
= (char *) xrealloc (buffer
, bufsize
);
4515 strcpy (buffer
, pl
->prefix
);
4516 idx
= strlen (buffer
);
4517 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4518 buffer
[idx
- 1] = 0;
4519 do_spec_1 (buffer
, 1, NULL
);
4520 /* Make this a separate argument. */
4521 do_spec_1 (" ", 0, NULL
);
4530 /* %efoo means report an error with `foo' as error message
4531 and don't execute any more commands for this file. */
4535 while (*p
!= 0 && *p
!= '\n')
4537 buf
= (char *) alloca (p
- q
+ 1);
4538 strncpy (buf
, q
, p
- q
);
4545 /* %nfoo means report a notice with `foo' on stderr. */
4549 while (*p
!= 0 && *p
!= '\n')
4551 buf
= (char *) alloca (p
- q
+ 1);
4552 strncpy (buf
, q
, p
- q
);
4554 notice ("%s\n", buf
);
4564 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4565 defined, and it is not a directory, and it is
4566 writable, use it. Otherwise, treat this like any
4567 other temporary file. */
4569 if ((!save_temps_flag
)
4570 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4571 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4573 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4574 strlen (HOST_BIT_BUCKET
));
4575 delete_this_arg
= 0;
4580 goto create_temp_file
;
4584 obstack_1grow (&obstack
, '-');
4585 delete_this_arg
= 0;
4588 /* consume suffix */
4589 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4591 if (p
[0] == '%' && p
[1] == 'O')
4596 goto create_temp_file
;
4600 /* consume suffix */
4601 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4603 if (p
[0] == '%' && p
[1] == 'O')
4608 goto create_temp_file
;
4614 struct temp_name
*t
;
4616 const char *suffix
= p
;
4617 char *saved_suffix
= NULL
;
4619 while (*p
== '.' || ISALPHA ((unsigned char) *p
))
4621 suffix_length
= p
- suffix
;
4622 if (p
[0] == '%' && p
[1] == 'O')
4625 /* We don't support extra suffix characters after %O. */
4626 if (*p
== '.' || ISALPHA ((unsigned char) *p
))
4628 if (suffix_length
== 0)
4629 suffix
= TARGET_OBJECT_SUFFIX
;
4633 = (char *) xmalloc (suffix_length
4634 + strlen (TARGET_OBJECT_SUFFIX
));
4635 strncpy (saved_suffix
, suffix
, suffix_length
);
4636 strcpy (saved_suffix
+ suffix_length
,
4637 TARGET_OBJECT_SUFFIX
);
4639 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4642 /* If the input_filename has the same suffix specified
4643 for the %g, %u, or %U, and -save-temps is specified,
4644 we could end up using that file as an intermediate
4645 thus clobbering the user's source file (.e.g.,
4646 gcc -save-temps foo.s would clobber foo.s with the
4647 output of cpp0). So check for this condition and
4648 generate a temp file as the intermediate. */
4650 if (save_temps_flag
)
4652 temp_filename_length
= basename_length
+ suffix_length
;
4653 temp_filename
= alloca (temp_filename_length
+ 1);
4654 strncpy ((char *) temp_filename
, input_basename
, basename_length
);
4655 strncpy ((char *) temp_filename
+ basename_length
, suffix
,
4657 *((char *) temp_filename
+ temp_filename_length
) = '\0';
4658 if (strcmp (temp_filename
, input_filename
) != 0)
4660 struct stat st_temp
;
4662 /* Note, set_input() resets input_stat_set to 0. */
4663 if (input_stat_set
== 0)
4665 input_stat_set
= stat (input_filename
, &input_stat
);
4666 if (input_stat_set
>= 0)
4670 /* If we have the stat for the input_filename
4671 and we can do the stat for the temp_filename
4672 then the they could still refer to the same
4673 file if st_dev/st_ino's are the same. */
4675 if (input_stat_set
!= 1
4676 || stat (temp_filename
, &st_temp
) < 0
4677 || input_stat
.st_dev
!= st_temp
.st_dev
4678 || input_stat
.st_ino
!= st_temp
.st_ino
)
4680 temp_filename
= save_string (temp_filename
,
4681 temp_filename_length
+ 1);
4682 obstack_grow (&obstack
, temp_filename
,
4683 temp_filename_length
);
4685 delete_this_arg
= 0;
4691 /* See if we already have an association of %g/%u/%U and
4693 for (t
= temp_names
; t
; t
= t
->next
)
4694 if (t
->length
== suffix_length
4695 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4696 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4699 /* Make a new association if needed. %u and %j
4701 if (t
== 0 || c
== 'u' || c
== 'j')
4705 t
= (struct temp_name
*) xmalloc (sizeof (struct temp_name
));
4706 t
->next
= temp_names
;
4709 t
->length
= suffix_length
;
4712 t
->suffix
= saved_suffix
;
4713 saved_suffix
= NULL
;
4716 t
->suffix
= save_string (suffix
, suffix_length
);
4717 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4718 temp_filename
= make_temp_file (t
->suffix
);
4719 temp_filename_length
= strlen (temp_filename
);
4720 t
->filename
= temp_filename
;
4721 t
->filename_length
= temp_filename_length
;
4725 free (saved_suffix
);
4727 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4728 delete_this_arg
= 1;
4734 obstack_grow (&obstack
, input_filename
, input_filename_length
);
4740 struct prefix_list
*pl
= include_prefixes
.plist
;
4742 if (gcc_exec_prefix
)
4744 do_spec_1 ("-iprefix", 1, NULL
);
4745 /* Make this a separate argument. */
4746 do_spec_1 (" ", 0, NULL
);
4747 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
4748 do_spec_1 (" ", 0, NULL
);
4751 if (target_system_root_changed
)
4753 do_spec_1 ("-isysroot", 1, NULL
);
4754 /* Make this a separate argument. */
4755 do_spec_1 (" ", 0, NULL
);
4756 do_spec_1 (target_system_root
, 1, NULL
);
4757 do_spec_1 (" ", 0, NULL
);
4760 for (; pl
; pl
= pl
->next
)
4762 do_spec_1 ("-isystem", 1, NULL
);
4763 /* Make this a separate argument. */
4764 do_spec_1 (" ", 0, NULL
);
4765 do_spec_1 (pl
->prefix
, 1, NULL
);
4766 do_spec_1 (" ", 0, NULL
);
4773 int max
= n_infiles
;
4774 max
+= lang_specific_extra_outfiles
;
4776 for (i
= 0; i
< max
; i
++)
4778 store_arg (outfiles
[i
], 0, 0);
4783 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
4788 this_is_library_file
= 1;
4792 outfiles
[input_file_number
] = NULL
;
4796 this_is_output_file
= 1;
4801 int cur_index
= argbuf_index
;
4802 /* Handle the {...} following the %W. */
4805 p
= handle_braces (p
+ 1);
4808 /* End any pending argument. */
4811 obstack_1grow (&obstack
, 0);
4812 string
= obstack_finish (&obstack
);
4813 if (this_is_library_file
)
4814 string
= find_file (string
);
4815 store_arg (string
, delete_this_arg
, this_is_output_file
);
4816 if (this_is_output_file
)
4817 outfiles
[input_file_number
] = string
;
4820 /* If any args were output, mark the last one for deletion
4822 if (argbuf_index
!= cur_index
)
4823 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
4827 /* %x{OPTION} records OPTION for %X to output. */
4833 /* Skip past the option value and make a copy. */
4838 string
= save_string (p1
+ 1, p
- p1
- 2);
4840 /* See if we already recorded this option. */
4841 for (i
= 0; i
< n_linker_options
; i
++)
4842 if (! strcmp (string
, linker_options
[i
]))
4848 /* This option is new; add it. */
4849 add_linker_option (string
, strlen (string
));
4853 /* Dump out the options accumulated previously using %x. */
4855 for (i
= 0; i
< n_linker_options
; i
++)
4857 do_spec_1 (linker_options
[i
], 1, NULL
);
4858 /* Make each accumulated option a separate argument. */
4859 do_spec_1 (" ", 0, NULL
);
4863 /* Dump out the options accumulated previously using -Wa,. */
4865 for (i
= 0; i
< n_assembler_options
; i
++)
4867 do_spec_1 (assembler_options
[i
], 1, NULL
);
4868 /* Make each accumulated option a separate argument. */
4869 do_spec_1 (" ", 0, NULL
);
4873 /* Dump out the options accumulated previously using -Wp,. */
4875 for (i
= 0; i
< n_preprocessor_options
; i
++)
4877 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
4878 /* Make each accumulated option a separate argument. */
4879 do_spec_1 (" ", 0, NULL
);
4883 /* Here are digits and numbers that just process
4884 a certain constant string as a spec. */
4887 value
= do_spec_1 (cc1_spec
, 0, NULL
);
4893 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
4899 value
= do_spec_1 (asm_spec
, 0, NULL
);
4905 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
4912 const char *const spec
4913 = (input_file_compiler
->cpp_spec
4914 ? input_file_compiler
->cpp_spec
4916 value
= do_spec_1 (spec
, 0, NULL
);
4923 value
= do_spec_1 (endfile_spec
, 0, NULL
);
4929 value
= do_spec_1 (link_spec
, 0, NULL
);
4935 value
= do_spec_1 (lib_spec
, 0, NULL
);
4941 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
4947 if (multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
4953 len
= strlen (multilib_dir
);
4954 obstack_blank (&obstack
, len
+ 1);
4955 p
= obstack_next_free (&obstack
) - (len
+ 1);
4958 for (q
= multilib_dir
; *q
; ++q
, ++p
)
4959 *p
= (IS_DIR_SEPARATOR (*q
) ? '_' : *q
);
4964 /* We assume there is a directory
4965 separator at the end of this string. */
4966 if (target_system_root
)
4967 obstack_grow (&obstack
, target_system_root
,
4968 strlen (target_system_root
));
4972 value
= do_spec_1 (startfile_spec
, 0, NULL
);
4977 /* Here we define characters other than letters and digits. */
4980 p
= handle_braces (p
);
4986 p
= handle_spec_function (p
);
4992 obstack_1grow (&obstack
, '%');
4999 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5001 suffix_subst
= save_string (p
- 1, len
+ 1);
5006 /* Henceforth ignore the option(s) matching the pattern
5011 int have_wildcard
= 0;
5014 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5017 if (p
[len
-1] == '*')
5020 for (i
= 0; i
< n_switches
; i
++)
5021 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5022 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5024 switches
[i
].live_cond
= SWITCH_IGNORE
;
5025 switches
[i
].validated
= 1;
5033 if (soft_matched_part
)
5035 do_spec_1 (soft_matched_part
, 1, NULL
);
5036 do_spec_1 (" ", 0, NULL
);
5039 /* Catch the case where a spec string contains something like
5040 '%{foo:%*}'. ie there is no * in the pattern on the left
5041 hand side of the :. */
5042 error ("spec failure: '%%*' has not been initialized by pattern match");
5045 /* Process a string found as the value of a spec given by name.
5046 This feature allows individual machine descriptions
5047 to add and use their own specs.
5048 %[...] modifies -D options the way %P does;
5049 %(...) uses the spec unmodified. */
5051 error ("warning: use of obsolete %%[ operator in specs");
5054 const char *name
= p
;
5055 struct spec_list
*sl
;
5058 /* The string after the S/P is the name of a spec that is to be
5060 while (*p
&& *p
!= ')' && *p
!= ']')
5063 /* See if it's in the list. */
5064 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5065 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5067 name
= *(sl
->ptr_spec
);
5069 notice ("Processing spec %c%s%c, which is '%s'\n",
5070 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5079 value
= do_spec_1 (name
, 0, NULL
);
5085 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5087 const char *y
= name
;
5090 /* Copy all of NAME into BUF, but put __ after
5091 every -D and at the end of each arg. */
5094 if (! strncmp (y
, "-D", 2))
5105 && (*y
== ' ' || *y
== '\t' || *y
== '='
5106 || *y
== '}' || *y
== 0))
5119 value
= do_spec_1 (buf
, 0, NULL
);
5125 /* Discard the closing paren or bracket. */
5132 error ("spec failure: unrecognized spec option '%c'", c
);
5138 /* Backslash: treat next character as ordinary. */
5143 /* Ordinary character: put it into the current argument. */
5144 obstack_1grow (&obstack
, c
);
5148 /* End of string. If we are processing a spec function, we need to
5149 end any pending argument. */
5150 if (processing_spec_function
&& arg_going
)
5152 obstack_1grow (&obstack
, 0);
5153 string
= obstack_finish (&obstack
);
5154 if (this_is_library_file
)
5155 string
= find_file (string
);
5156 store_arg (string
, delete_this_arg
, this_is_output_file
);
5157 if (this_is_output_file
)
5158 outfiles
[input_file_number
] = string
;
5165 /* Look up a spec function. */
5167 static const struct spec_function
*
5168 lookup_spec_function (name
)
5171 static const struct spec_function
* const spec_function_tables
[] =
5173 static_spec_functions
,
5174 lang_specific_spec_functions
,
5176 const struct spec_function
*sf
;
5179 for (i
= 0; i
< ARRAY_SIZE (spec_function_tables
); i
++)
5181 for (sf
= spec_function_tables
[i
]; sf
->name
!= NULL
; sf
++)
5182 if (strcmp (sf
->name
, name
) == 0)
5189 /* Evaluate a spec function. */
5192 eval_spec_function (func
, args
)
5193 const char *func
, *args
;
5195 const struct spec_function
*sf
;
5196 const char *funcval
;
5198 /* Saved spec processing context. */
5199 int save_argbuf_index
;
5200 int save_argbuf_length
;
5201 const char **save_argbuf
;
5204 int save_delete_this_arg
;
5205 int save_this_is_output_file
;
5206 int save_this_is_library_file
;
5207 int save_input_from_pipe
;
5208 const char *save_suffix_subst
;
5211 sf
= lookup_spec_function (func
);
5213 fatal ("unknown spec function `%s'", func
);
5215 /* Push the spec processing context. */
5216 save_argbuf_index
= argbuf_index
;
5217 save_argbuf_length
= argbuf_length
;
5218 save_argbuf
= argbuf
;
5220 save_arg_going
= arg_going
;
5221 save_delete_this_arg
= delete_this_arg
;
5222 save_this_is_output_file
= this_is_output_file
;
5223 save_this_is_library_file
= this_is_library_file
;
5224 save_input_from_pipe
= input_from_pipe
;
5225 save_suffix_subst
= suffix_subst
;
5227 /* Create a new spec processing context, and build the function
5231 if (do_spec_2 (args
) < 0)
5232 fatal ("error in args to spec function `%s'", func
);
5234 /* argbuf_index is an index for the next argument to be inserted, and
5235 so contains the count of the args already inserted. */
5237 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5239 /* Pop the spec processing context. */
5240 argbuf_index
= save_argbuf_index
;
5241 argbuf_length
= save_argbuf_length
;
5243 argbuf
= save_argbuf
;
5245 arg_going
= save_arg_going
;
5246 delete_this_arg
= save_delete_this_arg
;
5247 this_is_output_file
= save_this_is_output_file
;
5248 this_is_library_file
= save_this_is_library_file
;
5249 input_from_pipe
= save_input_from_pipe
;
5250 suffix_subst
= save_suffix_subst
;
5255 /* Handle a spec function call of the form:
5259 ARGS is processed as a spec in a separate context and split into an
5260 argument vector in the normal fashion. The function returns a string
5261 containing a spec which we then process in the caller's context, or
5262 NULL if no processing is required. */
5265 handle_spec_function (p
)
5269 const char *endp
, *funcval
;
5272 processing_spec_function
++;
5274 /* Get the function name. */
5275 for (endp
= p
; *endp
!= '\0'; endp
++)
5277 if (*endp
== '(') /* ) */
5279 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5280 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5281 fatal ("malformed spec function name");
5283 if (*endp
!= '(') /* ) */
5284 fatal ("no arguments for spec function");
5285 func
= save_string (p
, endp
- p
);
5288 /* Get the arguments. */
5289 for (count
= 0; *endp
!= '\0'; endp
++)
5298 else if (*endp
== '(') /* ) */
5303 fatal ("malformed spec function arguments");
5304 args
= save_string (p
, endp
- p
);
5307 /* p now points to just past the end of the spec function expression. */
5309 funcval
= eval_spec_function (func
, args
);
5310 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5316 processing_spec_function
--;
5321 /* Inline subroutine of handle_braces. Returns true if the current
5322 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5324 input_suffix_matches (atom
, end_atom
)
5326 const char *end_atom
;
5328 return (input_suffix
5329 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5330 && input_suffix
[end_atom
- atom
] == '\0');
5333 /* Inline subroutine of handle_braces. Returns true if a switch
5334 matching the atom bracketed by ATOM and END_ATOM appeared on the
5337 switch_matches (atom
, end_atom
, starred
)
5339 const char *end_atom
;
5343 int len
= end_atom
- atom
;
5344 int plen
= starred
? len
: -1;
5346 for (i
= 0; i
< n_switches
; i
++)
5347 if (!strncmp (switches
[i
].part1
, atom
, len
)
5348 && (starred
|| switches
[i
].part1
[len
] == '\0')
5349 && check_live_switch (i
, plen
))
5355 /* Inline subroutine of handle_braces. Mark all of the switches which
5356 match ATOM (extends to END_ATOM; STARRED indicates whether there
5357 was a star after the atom) for later processing. */
5359 mark_matching_switches (atom
, end_atom
, starred
)
5361 const char *end_atom
;
5365 int len
= end_atom
- atom
;
5366 int plen
= starred
? len
: -1;
5368 for (i
= 0; i
< n_switches
; i
++)
5369 if (!strncmp (switches
[i
].part1
, atom
, len
)
5370 && (starred
|| switches
[i
].part1
[len
] == '\0')
5371 && check_live_switch (i
, plen
))
5372 switches
[i
].ordering
= 1;
5375 /* Inline subroutine of handle_braces. Process all the currently
5376 marked switches through give_switch, and clear the marks. */
5378 process_marked_switches ()
5382 for (i
= 0; i
< n_switches
; i
++)
5383 if (switches
[i
].ordering
== 1)
5385 switches
[i
].ordering
= 0;
5390 /* Handle a %{ ... } construct. P points just inside the leading {.
5391 Returns a pointer one past the end of the brace block, or 0
5392 if we call do_spec_1 and that returns -1. */
5398 const char *atom
, *end_atom
;
5399 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5406 bool a_must_be_last
= false;
5407 bool ordered_set
= false;
5408 bool disjunct_set
= false;
5409 bool disj_matched
= false;
5410 bool disj_starred
= true;
5411 bool n_way_choice
= false;
5412 bool n_way_matched
= false;
5414 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5421 /* Scan one "atom" (S in the description above of %{}, possibly
5422 with !, ., or * modifiers). */
5423 a_matched
= a_is_suffix
= a_is_starred
= a_is_negated
= false;
5427 p
++, a_is_negated
= true;
5431 p
++, a_is_suffix
= true;
5434 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5435 || *p
== ',' || *p
== '.' || *p
== '@')
5440 p
++, a_is_starred
= 1;
5443 if (*p
== '&' || *p
== '}')
5445 /* Substitute the switch(es) indicated by the current atom. */
5447 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5448 || atom
== end_atom
)
5451 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5454 process_marked_switches ();
5456 else if (*p
== '|' || *p
== ':')
5458 /* Substitute some text if the current atom appears as a switch
5460 disjunct_set
= true;
5464 if (atom
== end_atom
)
5466 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5467 || a_is_negated
|| a_is_suffix
|| a_is_starred
)
5470 /* An empty term may appear as the last choice of an
5471 N-way choice set; it means "otherwise". */
5472 a_must_be_last
= true;
5473 disj_matched
= !n_way_matched
;
5474 disj_starred
= false;
5478 if (a_is_suffix
&& a_is_starred
)
5482 disj_starred
= false;
5484 /* Don't bother testing this atom if we already have a
5486 if (!disj_matched
&& !n_way_matched
)
5489 a_matched
= input_suffix_matches (atom
, end_atom
);
5491 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5493 if (a_matched
!= a_is_negated
)
5495 disj_matched
= true;
5497 d_end_atom
= end_atom
;
5504 /* Found the body, that is, the text to substitute if the
5505 current disjunction matches. */
5506 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5507 disj_matched
&& !n_way_matched
);
5511 /* If we have an N-way choice, reset state for the next
5515 n_way_choice
= true;
5516 n_way_matched
|= disj_matched
;
5517 disj_matched
= false;
5518 disj_starred
= true;
5519 d_atom
= d_end_atom
= NULL
;
5526 while (*p
++ != '}');
5533 /* Subroutine of handle_braces. Scan and process a brace substitution body
5534 (X in the description of %{} syntax). P points one past the colon;
5535 ATOM and END_ATOM bracket the first atom which was found to be true
5536 (present) in the current disjunction; STARRED indicates whether all
5537 the atoms in the current disjunction were starred (for syntax validation);
5538 MATCHED indicates whether the disjunction matched or not, and therefore
5539 whether or not the body is to be processed through do_spec_1 or just
5540 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5544 process_brace_body (p
, atom
, end_atom
, starred
, matched
)
5547 const char *end_atom
;
5551 const char *body
, *end_body
;
5552 unsigned int nesting_level
;
5553 bool have_subst
= false;
5555 /* Locate the closing } or ;, honoring nested braces.
5556 Trim trailing whitespace. */
5565 if (!--nesting_level
)
5568 else if (*p
== ';' && nesting_level
== 1)
5570 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5572 else if (*p
== '\0')
5578 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5581 if (have_subst
&& !starred
)
5586 /* Copy the substitution body to permanent storage and execute it.
5587 If have_subst is false, this is a simple matter of running the
5588 body through do_spec_1... */
5589 char *string
= save_string (body
, end_body
- body
);
5592 if (do_spec_1 (string
, 0, NULL
) < 0)
5597 /* ... but if have_subst is true, we have to process the
5598 body once for each matching switch, with %* set to the
5599 variant part of the switch. */
5600 unsigned int hard_match_len
= end_atom
- atom
;
5603 for (i
= 0; i
< n_switches
; i
++)
5604 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5605 && check_live_switch (i
, hard_match_len
))
5607 if (do_spec_1 (string
, 0,
5608 &switches
[i
].part1
[hard_match_len
]) < 0)
5610 /* Pass any arguments this switch has. */
5612 suffix_subst
= NULL
;
5620 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5621 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5622 spec, or -1 if either exact match or %* is used.
5624 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5625 whose value does not begin with "no-" is obsoleted by the same value
5626 with the "no-", similarly for a switch with the "no-" prefix. */
5629 check_live_switch (switchnum
, prefix_length
)
5633 const char *name
= switches
[switchnum
].part1
;
5636 /* In the common case of {<at-most-one-letter>*}, a negating
5637 switch would always match, so ignore that case. We will just
5638 send the conflicting switches to the compiler phase. */
5639 if (prefix_length
>= 0 && prefix_length
<= 1)
5642 /* If we already processed this switch and determined if it was
5643 live or not, return our past determination. */
5644 if (switches
[switchnum
].live_cond
!= 0)
5645 return switches
[switchnum
].live_cond
> 0;
5647 /* Now search for duplicate in a manner that depends on the name. */
5651 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5652 if (switches
[i
].part1
[0] == 'O')
5654 switches
[switchnum
].validated
= 1;
5655 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5660 case 'W': case 'f': case 'm':
5661 if (! strncmp (name
+ 1, "no-", 3))
5663 /* We have Xno-YYY, search for XYYY. */
5664 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5665 if (switches
[i
].part1
[0] == name
[0]
5666 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5668 switches
[switchnum
].validated
= 1;
5669 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5675 /* We have XYYY, search for Xno-YYY. */
5676 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5677 if (switches
[i
].part1
[0] == name
[0]
5678 && switches
[i
].part1
[1] == 'n'
5679 && switches
[i
].part1
[2] == 'o'
5680 && switches
[i
].part1
[3] == '-'
5681 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5683 switches
[switchnum
].validated
= 1;
5684 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5691 /* Otherwise the switch is live. */
5692 switches
[switchnum
].live_cond
= SWITCH_LIVE
;
5696 /* Pass a switch to the current accumulating command
5697 in the same form that we received it.
5698 SWITCHNUM identifies the switch; it is an index into
5699 the vector of switches gcc received, which is `switches'.
5700 This cannot fail since it never finishes a command line.
5702 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5705 give_switch (switchnum
, omit_first_word
)
5707 int omit_first_word
;
5709 if (switches
[switchnum
].live_cond
== SWITCH_IGNORE
)
5712 if (!omit_first_word
)
5714 do_spec_1 ("-", 0, NULL
);
5715 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5718 if (switches
[switchnum
].args
!= 0)
5721 for (p
= switches
[switchnum
].args
; *p
; p
++)
5723 const char *arg
= *p
;
5725 do_spec_1 (" ", 0, NULL
);
5728 unsigned length
= strlen (arg
);
5731 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
5732 if (arg
[length
] == '.')
5734 ((char *)arg
)[length
] = 0;
5738 do_spec_1 (arg
, 1, NULL
);
5740 ((char *)arg
)[length
] = '.';
5741 do_spec_1 (suffix_subst
, 1, NULL
);
5744 do_spec_1 (arg
, 1, NULL
);
5748 do_spec_1 (" ", 0, NULL
);
5749 switches
[switchnum
].validated
= 1;
5752 /* Search for a file named NAME trying various prefixes including the
5753 user's -B prefix and some standard ones.
5754 Return the absolute file name found. If nothing is found, return NAME. */
5762 /* Try multilib_dir if it is defined. */
5763 if (multilib_os_dir
!= NULL
)
5765 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 1);
5767 /* If we don't find it in the multi library dir, then fall
5768 through and look for it in the normal places. */
5769 if (newname
!= NULL
)
5773 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 0);
5774 return newname
? newname
: name
;
5777 /* Determine whether a directory exists. If LINKER, return 0 for
5778 certain fixed names not needed by the linker. If not LINKER, it is
5779 only important to return 0 if the host machine has a small ARG_MAX
5783 is_directory (path1
, path2
, linker
)
5788 int len1
= strlen (path1
);
5789 int len2
= strlen (path2
);
5790 char *path
= (char *) alloca (3 + len1
+ len2
);
5794 #ifndef SMALL_ARG_MAX
5799 /* Construct the path from the two parts. Ensure the string ends with "/.".
5800 The resulting path will be a directory even if the given path is a
5802 memcpy (path
, path1
, len1
);
5803 memcpy (path
+ len1
, path2
, len2
);
5804 cp
= path
+ len1
+ len2
;
5805 if (!IS_DIR_SEPARATOR (cp
[-1]))
5806 *cp
++ = DIR_SEPARATOR
;
5810 /* Exclude directories that the linker is known to search. */
5813 && strcmp (path
, concat (dir_separator_str
, "lib",
5814 dir_separator_str
, ".", NULL
)) == 0)
5816 && strcmp (path
, concat (dir_separator_str
, "usr",
5817 dir_separator_str
, "lib",
5818 dir_separator_str
, ".", NULL
)) == 0)))
5821 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
5824 /* Set up the various global variables to indicate that we're processing
5825 the input file named FILENAME. */
5828 set_input (filename
)
5829 const char *filename
;
5833 input_filename
= filename
;
5834 input_filename_length
= strlen (input_filename
);
5836 input_basename
= input_filename
;
5837 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5838 /* Skip drive name so 'x:foo' is handled properly. */
5839 if (input_basename
[1] == ':')
5840 input_basename
+= 2;
5842 for (p
= input_basename
; *p
; p
++)
5843 if (IS_DIR_SEPARATOR (*p
))
5844 input_basename
= p
+ 1;
5846 /* Find a suffix starting with the last period,
5847 and set basename_length to exclude that suffix. */
5848 basename_length
= strlen (input_basename
);
5849 suffixed_basename_length
= basename_length
;
5850 p
= input_basename
+ basename_length
;
5851 while (p
!= input_basename
&& *p
!= '.')
5853 if (*p
== '.' && p
!= input_basename
)
5855 basename_length
= p
- input_basename
;
5856 input_suffix
= p
+ 1;
5861 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5862 we will need to do a stat on the input_filename. The
5863 INPUT_STAT_SET signals that the stat is needed. */
5867 /* On fatal signals, delete all the temporary files. */
5870 fatal_error (signum
)
5873 signal (signum
, SIG_DFL
);
5874 delete_failure_queue ();
5875 delete_temp_files ();
5876 /* Get the same signal again, this time not handled,
5877 so its normal effect occurs. */
5878 kill (getpid (), signum
);
5881 extern int main
PARAMS ((int, const char *const *));
5886 const char *const *argv
;
5890 int linker_was_run
= 0;
5891 int num_linker_inputs
= 0;
5892 char *explicit_link_files
;
5895 struct user_specs
*uptr
;
5897 p
= argv
[0] + strlen (argv
[0]);
5898 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
5902 xmalloc_set_program_name (programname
);
5904 #ifdef GCC_DRIVER_HOST_INITIALIZATION
5905 /* Perform host dependent initialization when needed. */
5906 GCC_DRIVER_HOST_INITIALIZATION
;
5909 gcc_init_libintl ();
5911 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
5912 signal (SIGINT
, fatal_error
);
5914 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
5915 signal (SIGHUP
, fatal_error
);
5917 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
5918 signal (SIGTERM
, fatal_error
);
5920 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
5921 signal (SIGPIPE
, fatal_error
);
5924 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
5925 receive the signal. A different setting is inheritable */
5926 signal (SIGCHLD
, SIG_DFL
);
5929 /* Allocate the argument vector. */
5932 obstack_init (&obstack
);
5934 /* Build multilib_select, et. al from the separate lines that make up each
5935 multilib selection. */
5937 const char *const *q
= multilib_raw
;
5940 obstack_init (&multilib_obstack
);
5941 while ((p
= *q
++) != (char *) 0)
5942 obstack_grow (&multilib_obstack
, p
, strlen (p
));
5944 obstack_1grow (&multilib_obstack
, 0);
5945 multilib_select
= obstack_finish (&multilib_obstack
);
5947 q
= multilib_matches_raw
;
5948 while ((p
= *q
++) != (char *) 0)
5949 obstack_grow (&multilib_obstack
, p
, strlen (p
));
5951 obstack_1grow (&multilib_obstack
, 0);
5952 multilib_matches
= obstack_finish (&multilib_obstack
);
5954 q
= multilib_exclusions_raw
;
5955 while ((p
= *q
++) != (char *) 0)
5956 obstack_grow (&multilib_obstack
, p
, strlen (p
));
5958 obstack_1grow (&multilib_obstack
, 0);
5959 multilib_exclusions
= obstack_finish (&multilib_obstack
);
5962 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
5965 obstack_1grow (&multilib_obstack
, ' ');
5966 obstack_grow (&multilib_obstack
,
5967 multilib_defaults_raw
[i
],
5968 strlen (multilib_defaults_raw
[i
]));
5972 obstack_1grow (&multilib_obstack
, 0);
5973 multilib_defaults
= obstack_finish (&multilib_obstack
);
5976 /* Set up to remember the pathname of gcc and any options
5977 needed for collect. We use argv[0] instead of programname because
5978 we need the complete pathname. */
5979 obstack_init (&collect_obstack
);
5980 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
5981 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
5982 putenv (obstack_finish (&collect_obstack
));
5984 #ifdef INIT_ENVIRONMENT
5985 /* Set up any other necessary machine specific environment variables. */
5986 putenv (INIT_ENVIRONMENT
);
5989 /* Make a table of what switches there are (switches, n_switches).
5990 Make a table of specified input files (infiles, n_infiles).
5991 Decode switches that are handled locally. */
5993 process_command (argc
, argv
);
5995 /* Initialize the vector of specs to just the default.
5996 This means one element containing 0s, as a terminator. */
5998 compilers
= (struct compiler
*) xmalloc (sizeof default_compilers
);
5999 memcpy ((char *) compilers
, (char *) default_compilers
,
6000 sizeof default_compilers
);
6001 n_compilers
= n_default_compilers
;
6003 /* Read specs from a file if there is one. */
6005 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6006 spec_version
, dir_separator_str
, NULL
);
6007 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6009 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, 0);
6010 /* Read the specs file unless it is a default one. */
6011 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6012 read_specs (specs_file
, TRUE
);
6016 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6017 for any override of as, ld and libraries. */
6018 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6019 + strlen (just_machine_suffix
)
6020 + sizeof ("specs"));
6022 strcpy (specs_file
, standard_exec_prefix
);
6023 strcat (specs_file
, just_machine_suffix
);
6024 strcat (specs_file
, "specs");
6025 if (access (specs_file
, R_OK
) == 0)
6026 read_specs (specs_file
, TRUE
);
6028 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6029 of the command line. */
6031 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6032 do_self_spec (driver_self_specs
[i
]);
6034 /* If not cross-compiling, look for executables in the standard
6036 if (*cross_compile
== '0')
6038 if (*md_exec_prefix
)
6040 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6041 PREFIX_PRIORITY_LAST
, 0, NULL
, 0);
6045 /* Look for startfiles in the standard places. */
6046 if (*startfile_prefix_spec
!= 0
6047 && do_spec_2 (startfile_prefix_spec
) == 0
6048 && do_spec_1 (" ", 0, NULL
) == 0)
6051 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6052 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6053 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6055 /* We should eventually get rid of all these and stick to
6056 startfile_prefix_spec exclusively. */
6057 else if (*cross_compile
== '0' || target_system_root
)
6059 if (*md_exec_prefix
)
6060 add_sysrooted_prefix (&startfile_prefixes
, md_exec_prefix
, "GCC",
6061 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6063 if (*md_startfile_prefix
)
6064 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6065 "GCC", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6067 if (*md_startfile_prefix_1
)
6068 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6069 "GCC", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6071 /* If standard_startfile_prefix is relative, base it on
6072 standard_exec_prefix. This lets us move the installed tree
6073 as a unit. If GCC_EXEC_PREFIX is defined, base
6074 standard_startfile_prefix on that as well. */
6075 if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix
))
6076 add_sysrooted_prefix (&startfile_prefixes
,
6077 standard_startfile_prefix
, "BINUTILS",
6078 PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6081 if (gcc_exec_prefix
)
6082 add_prefix (&startfile_prefixes
,
6083 concat (gcc_exec_prefix
, machine_suffix
,
6084 standard_startfile_prefix
, NULL
),
6085 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6086 add_prefix (&startfile_prefixes
,
6087 concat (standard_exec_prefix
,
6089 standard_startfile_prefix
, NULL
),
6090 NULL
, PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6093 add_sysrooted_prefix (&startfile_prefixes
, standard_startfile_prefix_1
,
6094 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6095 add_sysrooted_prefix (&startfile_prefixes
, standard_startfile_prefix_2
,
6096 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, NULL
, 1);
6097 #if 0 /* Can cause surprises, and one can use -B./ instead. */
6098 add_prefix (&startfile_prefixes
, "./", NULL
,
6099 PREFIX_PRIORITY_LAST
, 1, NULL
, 0);
6103 /* Process any user specified specs in the order given on the command
6105 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6107 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6109 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6112 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6113 if (gcc_exec_prefix
)
6114 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6115 spec_version
, dir_separator_str
, NULL
);
6117 /* Now we have the specs.
6118 Set the `valid' bits for switches that match anything in any spec. */
6120 validate_all_switches ();
6122 /* Now that we have the switches and the specs, set
6123 the subdirectory based on the options. */
6124 set_multilib_dir ();
6126 /* Warn about any switches that no pass was interested in. */
6128 for (i
= 0; (int) i
< n_switches
; i
++)
6129 if (! switches
[i
].validated
)
6130 error ("unrecognized option `-%s'", switches
[i
].part1
);
6132 /* Obey some of the options. */
6134 if (print_search_dirs
)
6136 printf (_("install: %s%s\n"), standard_exec_prefix
, machine_suffix
);
6137 printf (_("programs: %s\n"), build_search_list (&exec_prefixes
, "", 0));
6138 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes
, "", 0));
6142 if (print_file_name
)
6144 printf ("%s\n", find_file (print_file_name
));
6148 if (print_prog_name
)
6150 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6151 printf ("%s\n", (newname
? newname
: print_prog_name
));
6155 if (print_multi_lib
)
6157 print_multilib_info ();
6161 if (print_multi_directory
)
6163 if (multilib_dir
== NULL
)
6166 printf ("%s\n", multilib_dir
);
6170 if (print_multi_os_directory
)
6172 if (multilib_os_dir
== NULL
)
6175 printf ("%s\n", multilib_os_dir
);
6179 if (target_help_flag
)
6181 /* Print if any target specific options. */
6183 /* We do not exit here. Instead we have created a fake input file
6184 called 'target-dummy' which needs to be compiled, and we pass this
6185 on to the various sub-processes, along with the --target-help
6189 if (print_help_list
)
6195 printf (_("\nFor bug reporting instructions, please see:\n"));
6196 printf ("%s.\n", bug_report_url
);
6201 /* We do not exit here. Instead we have created a fake input file
6202 called 'help-dummy' which needs to be compiled, and we pass this
6203 on the various sub-processes, along with the --help switch. */
6211 notice ("Configured with: %s\n", configuration_arguments
);
6213 #ifdef THREAD_MODEL_SPEC
6214 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6215 but there's no point in doing all this processing just to get
6216 thread_model back. */
6217 obstack_init (&obstack
);
6218 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6219 obstack_1grow (&obstack
, '\0');
6220 thrmod
= obstack_finish (&obstack
);
6222 thrmod
= thread_model
;
6225 notice ("Thread model: %s\n", thrmod
);
6227 /* compiler_version is truncated at the first space when initialized
6228 from version string, so truncate version_string at the first space
6229 before comparing. */
6230 for (n
= 0; version_string
[n
]; n
++)
6231 if (version_string
[n
] == ' ')
6234 if (! strncmp (version_string
, compiler_version
, n
)
6235 && compiler_version
[n
] == 0)
6236 notice ("gcc version %s\n", version_string
);
6238 notice ("gcc driver version %s executing gcc version %s\n",
6239 version_string
, compiler_version
);
6245 if (n_infiles
== added_libraries
)
6246 fatal ("no input files");
6248 /* Make a place to record the compiler output file names
6249 that correspond to the input files. */
6252 i
+= lang_specific_extra_outfiles
;
6253 outfiles
= (const char **) xcalloc (i
, sizeof (char *));
6255 /* Record which files were specified explicitly as link input. */
6257 explicit_link_files
= xcalloc (1, n_infiles
);
6259 for (i
= 0; (int) i
< n_infiles
; i
++)
6261 int this_file_error
= 0;
6263 /* Tell do_spec what to substitute for %i. */
6265 input_file_number
= i
;
6266 set_input (infiles
[i
].name
);
6268 /* Use the same thing in %o, unless cp->spec says otherwise. */
6270 outfiles
[i
] = input_filename
;
6272 /* Figure out which compiler from the file's suffix. */
6275 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6276 infiles
[i
].language
);
6278 if (input_file_compiler
)
6280 /* Ok, we found an applicable compiler. Run its spec. */
6282 if (input_file_compiler
->spec
[0] == '#')
6284 error ("%s: %s compiler not installed on this system",
6285 input_filename
, &input_file_compiler
->spec
[1]);
6286 this_file_error
= 1;
6290 value
= do_spec (input_file_compiler
->spec
);
6292 this_file_error
= 1;
6296 /* If this file's name does not contain a recognized suffix,
6297 record it as explicit linker input. */
6300 explicit_link_files
[i
] = 1;
6302 /* Clear the delete-on-failure queue, deleting the files in it
6303 if this compilation failed. */
6305 if (this_file_error
)
6307 delete_failure_queue ();
6310 /* If this compilation succeeded, don't delete those files later. */
6311 clear_failure_queue ();
6314 /* Reset the output file name to the first input file name, for use
6315 with %b in LINK_SPEC on a target that prefers not to emit a.out
6318 set_input (infiles
[0].name
);
6320 if (error_count
== 0)
6322 /* Make sure INPUT_FILE_NUMBER points to first available open
6324 input_file_number
= n_infiles
;
6325 if (lang_specific_pre_link ())
6329 /* Determine if there are any linker input files. */
6330 num_linker_inputs
= 0;
6331 for (i
= 0; (int) i
< n_infiles
; i
++)
6332 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6333 num_linker_inputs
++;
6335 /* Run ld to link all the compiler output files. */
6337 if (num_linker_inputs
> 0 && error_count
== 0)
6339 int tmp
= execution_count
;
6341 /* We'll use ld if we can't find collect2. */
6342 if (! strcmp (linker_name_spec
, "collect2"))
6344 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, 0);
6346 linker_name_spec
= "ld";
6348 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6350 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH");
6351 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
);
6353 value
= do_spec (link_command_spec
);
6356 linker_was_run
= (tmp
!= execution_count
);
6359 /* If options said don't run linker,
6360 complain about input files to be given to the linker. */
6362 if (! linker_was_run
&& error_count
== 0)
6363 for (i
= 0; (int) i
< n_infiles
; i
++)
6364 if (explicit_link_files
[i
])
6365 error ("%s: linker input file unused because linking not done",
6368 /* Delete some or all of the temporary files we made. */
6371 delete_failure_queue ();
6372 delete_temp_files ();
6374 if (print_help_list
)
6376 printf (("\nFor bug reporting instructions, please see:\n"));
6377 printf ("%s\n", bug_report_url
);
6380 return (signal_count
!= 0 ? 2
6381 : error_count
> 0 ? (pass_exit_codes
? greatest_status
: 1)
6385 /* Find the proper compilation spec for the file name NAME,
6386 whose length is LENGTH. LANGUAGE is the specified language,
6387 or 0 if this file is to be passed to the linker. */
6389 static struct compiler
*
6390 lookup_compiler (name
, length
, language
)
6393 const char *language
;
6395 struct compiler
*cp
;
6397 /* If this was specified by the user to be a linker input, indicate that. */
6398 if (language
!= 0 && language
[0] == '*')
6401 /* Otherwise, look for the language, if one is spec'd. */
6404 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6405 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
6408 error ("language %s not recognized", language
);
6412 /* Look for a suffix. */
6413 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6415 if (/* The suffix `-' matches only the file name `-'. */
6416 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6417 || (strlen (cp
->suffix
) < length
6418 /* See if the suffix matches the end of NAME. */
6419 && !strcmp (cp
->suffix
,
6420 name
+ length
- strlen (cp
->suffix
))
6425 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6426 /* look again, but case-insensitively this time. */
6428 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6430 if (/* The suffix `-' matches only the file name `-'. */
6431 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6432 || (strlen (cp
->suffix
) < length
6433 /* See if the suffix matches the end of NAME. */
6434 && ((!strcmp (cp
->suffix
,
6435 name
+ length
- strlen (cp
->suffix
))
6436 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6437 && !strcasecmp (cp
->suffix
,
6438 name
+ length
- strlen (cp
->suffix
)))
6444 if (cp
>= compilers
)
6446 if (cp
->spec
[0] != '@')
6447 /* A non-alias entry: return it. */
6450 /* An alias entry maps a suffix to a language.
6451 Search for the language; pass 0 for NAME and LENGTH
6452 to avoid infinite recursion if language not found. */
6453 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
6459 save_string (s
, len
)
6463 char *result
= xmalloc (len
+ 1);
6465 memcpy (result
, s
, len
);
6471 pfatal_with_name (name
)
6474 perror_with_name (name
);
6475 delete_temp_files ();
6480 perror_with_name (name
)
6483 error ("%s: %s", name
, xstrerror (errno
));
6487 pfatal_pexecute (errmsg_fmt
, errmsg_arg
)
6488 const char *errmsg_fmt
;
6489 const char *errmsg_arg
;
6493 int save_errno
= errno
;
6495 /* Space for trailing '\0' is in %s. */
6496 char *msg
= xmalloc (strlen (errmsg_fmt
) + strlen (errmsg_arg
));
6497 sprintf (msg
, errmsg_fmt
, errmsg_arg
);
6503 pfatal_with_name (errmsg_fmt
);
6506 /* Output an error message and exit */
6511 fatal ("internal gcc abort");
6514 /* Output an error message and exit */
6517 fatal (const char *msgid
, ...)
6521 va_start (ap
, msgid
);
6523 fprintf (stderr
, "%s: ", programname
);
6524 vfprintf (stderr
, _(msgid
), ap
);
6526 fprintf (stderr
, "\n");
6527 delete_temp_files ();
6532 error (const char *msgid
, ...)
6536 va_start (ap
, msgid
);
6537 fprintf (stderr
, "%s: ", programname
);
6538 vfprintf (stderr
, _(msgid
), ap
);
6541 fprintf (stderr
, "\n");
6545 notice (const char *msgid
, ...)
6549 va_start (ap
, msgid
);
6550 vfprintf (stderr
, _(msgid
), ap
);
6555 validate_switches_from_spec (spec
)
6558 const char *p
= spec
;
6561 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
6562 /* We have a switch spec. */
6563 p
= validate_switches (p
+ 1);
6567 validate_all_switches ()
6569 struct compiler
*comp
;
6570 struct spec_list
*spec
;
6572 for (comp
= compilers
; comp
->spec
; comp
++)
6573 validate_switches_from_spec (comp
->spec
);
6575 /* Look through the linked list of specs read from the specs file. */
6576 for (spec
= specs
; spec
; spec
= spec
->next
)
6577 validate_switches_from_spec (*spec
->ptr_spec
);
6579 validate_switches_from_spec (link_command_spec
);
6582 /* Look at the switch-name that comes after START
6583 and mark as valid all supplied switches that match it. */
6586 validate_switches (start
)
6589 const char *p
= start
;
6593 bool suffix
= false;
6594 bool starred
= false;
6596 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6609 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6610 || *p
== ',' || *p
== '.' || *p
== '@')
6615 starred
= true, p
++;
6621 /* Mark all matching switches as valid. */
6622 for (i
= 0; i
< n_switches
; i
++)
6623 if (!strncmp (switches
[i
].part1
, atom
, len
)
6624 && (starred
|| switches
[i
].part1
[len
] == 0))
6625 switches
[i
].validated
= 1;
6629 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
6632 if (*p
&& p
[-1] == ':')
6634 while (*p
&& *p
!= ';' && *p
!= '}')
6639 if (*p
== '{' || *p
== '<')
6640 p
= validate_switches (p
+1);
6641 else if (p
[0] == 'W' && p
[1] == '{')
6642 p
= validate_switches (p
+2);
6649 if (*p
&& p
[-1] == ';')
6663 static struct mdswitchstr
*mdswitches
;
6664 static int n_mdswitches
;
6666 /* Check whether a particular argument was used. The first time we
6667 canonicalize the switches to keep only the ones we care about. */
6677 const char *replace
;
6682 static struct mswitchstr
*mswitches
;
6683 static int n_mswitches
;
6688 struct mswitchstr
*matches
;
6692 /* Break multilib_matches into the component strings of string
6693 and replacement string. */
6694 for (q
= multilib_matches
; *q
!= '\0'; q
++)
6699 (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
6701 q
= multilib_matches
;
6711 matches
[i
].len
= q
- matches
[i
].str
;
6713 matches
[i
].replace
= ++q
;
6714 while (*q
!= ';' && *q
!= '\0')
6720 matches
[i
].rep_len
= q
- matches
[i
].replace
;
6726 /* Now build a list of the replacement string for switches that we care
6727 about. Make sure we allocate at least one entry. This prevents
6728 xmalloc from calling fatal, and prevents us from re-executing this
6731 = (struct mswitchstr
*)
6732 xmalloc (sizeof (struct mswitchstr
)
6733 * (n_mdswitches
+ (n_switches
? n_switches
: 1)));
6734 for (i
= 0; i
< n_switches
; i
++)
6736 int xlen
= strlen (switches
[i
].part1
);
6737 for (j
= 0; j
< cnt
; j
++)
6738 if (xlen
== matches
[j
].len
6739 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
6741 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
6742 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
6743 mswitches
[n_mswitches
].replace
= (char *) 0;
6744 mswitches
[n_mswitches
].rep_len
= 0;
6750 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
6751 on the command line nor any options mutually incompatible with
6753 for (i
= 0; i
< n_mdswitches
; i
++)
6757 for (q
= multilib_options
; *q
!= '\0'; q
++)
6763 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
6764 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
6766 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
6773 if (*q
!= ' ' && *q
!= '\0')
6775 while (*r
!= ' ' && *r
!= '\0')
6778 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
6781 if (used_arg (r
, q
- r
))
6786 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
6787 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
6788 mswitches
[n_mswitches
].replace
= (char *) 0;
6789 mswitches
[n_mswitches
].rep_len
= 0;
6802 for (i
= 0; i
< n_mswitches
; i
++)
6803 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
6810 default_arg (p
, len
)
6816 for (i
= 0; i
< n_mdswitches
; i
++)
6817 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
6823 /* Work out the subdirectory to use based on the options. The format of
6824 multilib_select is a list of elements. Each element is a subdirectory
6825 name followed by a list of options followed by a semicolon. The format
6826 of multilib_exclusions is the same, but without the preceding
6827 directory. First gcc will check the exclusions, if none of the options
6828 beginning with an exclamation point are present, and all of the other
6829 options are present, then we will ignore this completely. Passing
6830 that, gcc will consider each multilib_select in turn using the same
6831 rules for matching the options. If a match is found, that subdirectory
6838 unsigned int this_path_len
;
6839 const char *this_path
, *this_arg
;
6840 const char *start
, *end
;
6842 int ok
, ndfltok
, first
;
6845 start
= multilib_defaults
;
6846 while (*start
== ' ' || *start
== '\t')
6848 while (*start
!= '\0')
6851 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
6853 while (*start
== ' ' || *start
== '\t')
6862 = (struct mdswitchstr
*) xmalloc (sizeof (struct mdswitchstr
)
6864 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
6866 while (*start
== ' ' || *start
== '\t')
6872 for (end
= start
+ 1;
6873 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
6876 obstack_grow (&multilib_obstack
, start
, end
- start
);
6877 obstack_1grow (&multilib_obstack
, 0);
6878 mdswitches
[i
].str
= obstack_finish (&multilib_obstack
);
6879 mdswitches
[i
++].len
= end
- start
;
6886 p
= multilib_exclusions
;
6889 /* Ignore newlines. */
6896 /* Check the arguments. */
6910 while (*p
!= ' ' && *p
!= ';')
6917 if (*this_arg
!= '!')
6925 ok
= used_arg (this_arg
, p
- this_arg
);
6940 p
= multilib_select
;
6943 /* Ignore newlines. */
6950 /* Get the initial path. */
6958 this_path_len
= p
- this_path
;
6960 /* Check the arguments. */
6976 while (*p
!= ' ' && *p
!= ';')
6983 if (*this_arg
!= '!')
6991 /* If this is a default argument, we can just ignore it.
6992 This is true even if this_arg begins with '!'. Beginning
6993 with '!' does not mean that this argument is necessarily
6994 inappropriate for this library: it merely means that
6995 there is a more specific library which uses this
6996 argument. If this argument is a default, we need not
6997 consider that more specific library. */
6998 ok
= used_arg (this_arg
, p
- this_arg
);
7005 if (default_arg (this_arg
, p
- this_arg
))
7014 if (this_path_len
!= 1
7015 || this_path
[0] != '.')
7017 char *new_multilib_dir
= xmalloc (this_path_len
+ 1);
7020 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7021 new_multilib_dir
[this_path_len
] = '\0';
7022 q
= strchr (new_multilib_dir
, ':');
7025 multilib_dir
= new_multilib_dir
;
7032 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7034 while (q
< end
&& *q
!= ':')
7038 char *new_multilib_os_dir
= xmalloc (end
- q
);
7039 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7040 new_multilib_os_dir
[end
- q
- 1] = '\0';
7041 multilib_os_dir
= new_multilib_os_dir
;
7049 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7050 && strcmp (multilib_os_dir
, ".") == 0)
7052 free ((char *) multilib_os_dir
);
7053 multilib_os_dir
= NULL
;
7055 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7056 multilib_os_dir
= multilib_dir
;
7059 /* Print out the multiple library subdirectory selection
7060 information. This prints out a series of lines. Each line looks
7061 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7062 required. Only the desired options are printed out, the negative
7063 matches. The options are print without a leading dash. There are
7064 no spaces to make it easy to use the information in the shell.
7065 Each subdirectory is printed only once. This assumes the ordering
7066 generated by the genmultilib script. Also, we leave out ones that match
7070 print_multilib_info ()
7072 const char *p
= multilib_select
;
7073 const char *last_path
= 0, *this_path
;
7075 unsigned int last_path_len
= 0;
7080 /* Ignore newlines. */
7087 /* Get the initial path. */
7096 /* When --disable-multilib was used but target defines
7097 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7098 to find multilib_os_dir, so skip them from output. */
7099 if (this_path
[0] == '.' && this_path
[1] == ':')
7102 /* Check for matches with the multilib_exclusions. We don't bother
7103 with the '!' in either list. If any of the exclusion rules match
7104 all of its options with the select rule, we skip it. */
7106 const char *e
= multilib_exclusions
;
7107 const char *this_arg
;
7112 /* Ignore newlines. */
7119 /* Check the arguments. */
7136 while (*e
!= ' ' && *e
!= ';')
7147 int len
= e
- this_arg
;
7154 while (*q
!= ' ' && *q
!= ';')
7161 if (! strncmp (arg
, this_arg
, (len
< q
- arg
) ? q
- arg
: len
) ||
7162 default_arg (this_arg
, e
- this_arg
))
7192 /* If this is a duplicate, skip it. */
7193 skip
= (last_path
!= 0 && (unsigned int) (p
- this_path
) == last_path_len
7194 && ! strncmp (last_path
, this_path
, last_path_len
));
7196 last_path
= this_path
;
7197 last_path_len
= p
- this_path
;
7200 /* If this directory requires any default arguments, we can skip
7201 it. We will already have printed a directory identical to
7202 this one which does not require that default argument. */
7220 while (*q
!= ' ' && *q
!= ';')
7228 && default_arg (arg
, q
- arg
))
7243 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7262 use_arg
= *p
!= '!';
7267 while (*p
!= ' ' && *p
!= ';')
7282 /* If there are extra options, print them now. */
7283 if (multilib_extra
&& *multilib_extra
)
7285 int print_at
= TRUE
;
7288 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7309 /* if-exists built-in spec function.
7311 Checks to see if the file specified by the absolute pathname in
7312 ARGS exists. Returns that pathname if found.
7314 The usual use for this function is to check for a library file
7315 (whose name has been expanded with %s). */
7318 if_exists_spec_function (argc
, argv
)
7322 /* Must have only one argument. */
7323 if (argc
== 1 && IS_ABSOLUTE_PATHNAME (argv
[0]) && ! access (argv
[0], R_OK
))
7329 /* if-exists-else built-in spec function.
7331 This is like if-exists, but takes an additional argument which
7332 is returned if the first argument does not exist. */
7335 if_exists_else_spec_function (argc
, argv
)
7339 /* Must have exactly two arguments. */
7343 if (IS_ABSOLUTE_PATHNAME (argv
[0]) && ! access (argv
[0], R_OK
))