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, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This program is the user interface to the C compiler and possibly to
23 other compilers. It is used because compilation is a complicated procedure
24 which involves running several programs and passing temporary files between
25 them, forwarding the users switches to those programs selectively,
26 and deleting the temporary files at the end.
28 CC recognizes how to compile each input file by suffixes in the file names.
29 Once it knows which kind of compilation to perform, the procedure for
30 compilation is specified by a string called a "spec". */
32 /* A Short Introduction to Adding a Command-Line Option.
34 Before adding a command-line option, consider if it is really
35 necessary. Each additional command-line option adds complexity and
36 is difficult to remove in subsequent versions.
38 In the following, consider adding the command-line argument
41 1. Each command-line option is specified in the specs file. The
42 notation is described below in the comment entitled "The Specs
45 2. In this file, add an entry to "option_map" equating the long
46 `--' argument version and any shorter, single letter version. Read
47 the comments in the declaration of "struct option_map" for an
48 explanation. Do not omit the first `-'.
50 3. Look in the "specs" file to determine which program or option
51 list should be given the argument, e.g., "cc1_options". Add the
52 appropriate syntax for the shorter option version to the
53 corresponding "const char *" entry in this file. Omit the first
54 `-' from the option. For example, use `-bar', rather than `--bar'.
56 4. If the argument takes an argument, e.g., `--baz argument1',
57 modify either DEFAULT_SWITCH_TAKES_ARG or
58 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
61 5. Document the option in this file's display_help(). If the
62 option is passed to a subprogram, modify its corresponding
63 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
66 6. Compile and test. Make sure that your new specs file is being
67 read. For example, use a debugger to investigate the value of
68 "specs_file" in main(). */
72 #include "coretypes.h"
73 #include "multilib.h" /* before tm.h */
76 #if ! defined( SIGCHLD ) && defined( SIGCLD )
77 # define SIGCHLD SIGCLD
87 /* By default there is no special suffix for target executables. */
88 /* FIXME: when autoconf is fixed, remove the host check - dj */
89 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
90 #define HAVE_TARGET_EXECUTABLE_SUFFIX
93 /* By default there is no special suffix for host executables. */
94 #ifdef HOST_EXECUTABLE_SUFFIX
95 #define HAVE_HOST_EXECUTABLE_SUFFIX
97 #define HOST_EXECUTABLE_SUFFIX ""
100 /* By default, the suffix for target object files is ".o". */
101 #ifdef TARGET_OBJECT_SUFFIX
102 #define HAVE_TARGET_OBJECT_SUFFIX
104 #define TARGET_OBJECT_SUFFIX ".o"
107 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
109 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
110 #ifndef LIBRARY_PATH_ENV
111 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
115 #define kill(p,s) raise(s)
118 /* If a stage of compilation returns an exit status >= 1,
119 compilation of that file ceases. */
121 #define MIN_FATAL_STATUS 1
123 /* Flag set by cppspec.c to 1. */
126 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
127 static bool at_file_supplied
;
129 /* Flag saying to pass the greatest exit code returned by a sub-process
130 to the calling program. */
131 static int pass_exit_codes
;
133 /* Definition of string containing the arguments given to configure. */
134 #include "configargs.h"
136 /* Flag saying to print the directories gcc will search through looking for
137 programs, libraries, etc. */
139 static int print_search_dirs
;
141 /* Flag saying to print the full filename of this file
142 as found through our usual search mechanism. */
144 static const char *print_file_name
= NULL
;
146 /* As print_file_name, but search for executable file. */
148 static const char *print_prog_name
= NULL
;
150 /* Flag saying to print the relative path we'd use to
151 find libgcc.a given the current compiler flags. */
153 static int print_multi_directory
;
155 static int print_sysroot
;
157 /* Flag saying to print the relative path we'd use to
158 find OS libraries given the current compiler flags. */
160 static int print_multi_os_directory
;
162 /* Flag saying to print the list of subdirectories and
163 compiler flags used to select them in a standard form. */
165 static int print_multi_lib
;
167 /* Flag saying to print the command line options understood by gcc and its
170 static int print_help_list
;
172 /* Flag saying to print the version of gcc and its sub-processes. */
174 static int print_version
;
176 /* Flag saying to print the sysroot suffix used for searching for
179 static int print_sysroot_headers_suffix
;
181 /* Flag indicating whether we should print the command and arguments */
183 static int verbose_flag
;
185 /* Flag indicating whether we should ONLY print the command and
186 arguments (like verbose_flag) without executing the command.
187 Displayed arguments are quoted so that the generated command
188 line is suitable for execution. This is intended for use in
189 shell scripts to capture the driver-generated command line. */
190 static int verbose_only_flag
;
192 /* Flag indicating how to print command line options of sub-processes. */
194 static int print_subprocess_help
;
196 /* Flag indicating whether we should report subprocess execution times
197 (if this is supported by the system - see pexecute.c). */
199 static int report_times
;
201 /* Nonzero means place this string before uses of /, so that include
202 and library files can be found in an alternate location. */
204 #ifdef TARGET_SYSTEM_ROOT
205 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
207 static const char *target_system_root
= 0;
210 /* Nonzero means pass the updated target_system_root to the compiler. */
212 static int target_system_root_changed
;
214 /* Nonzero means append this string to target_system_root. */
216 static const char *target_sysroot_suffix
= 0;
218 /* Nonzero means append this string to target_system_root for headers. */
220 static const char *target_sysroot_hdrs_suffix
= 0;
222 /* Nonzero means write "temp" files in source directory
223 and use the source file's name in them, and don't delete them. */
225 static enum save_temps
{
226 SAVE_TEMPS_NONE
, /* no -save-temps */
227 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
228 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
231 /* Output file to use to get the object directory for -save-temps=obj */
232 static char *save_temps_prefix
= 0;
233 static size_t save_temps_length
= 0;
235 /* Nonzero means pass multiple source files to the compiler at one time. */
237 static int combine_flag
= 0;
239 /* Nonzero means use pipes to communicate between subprocesses.
240 Overridden by either of the above two flags. */
242 static int use_pipes
;
244 /* The compiler version. */
246 static const char *compiler_version
;
248 /* The target version specified with -V */
250 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
252 /* The target machine specified with -b. */
254 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
256 /* Nonzero if cross-compiling.
257 When -b is used, the value comes from the `specs' file. */
259 #ifdef CROSS_DIRECTORY_STRUCTURE
260 static const char *cross_compile
= "1";
262 static const char *cross_compile
= "0";
265 #ifdef MODIFY_TARGET_NAME
267 /* Information on how to alter the target name based on a command-line
268 switch. The only case we support now is simply appending or deleting a
269 string to or from the end of the first part of the configuration name. */
271 enum add_del
{ADD
, DELETE
};
273 static const struct modify_target
275 const char *const sw
;
276 const enum add_del add_del
;
277 const char *const str
;
279 modify_target
[] = MODIFY_TARGET_NAME
;
282 /* The number of errors that have occurred; the link phase will not be
283 run if this is nonzero. */
284 static int error_count
= 0;
286 /* Greatest exit code of sub-processes that has been encountered up to
288 static int greatest_status
= 1;
290 /* This is the obstack which we use to allocate many strings. */
292 static struct obstack obstack
;
294 /* This is the obstack to build an environment variable to pass to
295 collect2 that describes all of the relevant switches of what to
296 pass the compiler in building the list of pointers to constructors
299 static struct obstack collect_obstack
;
301 /* This is a list of a wrapper program and its arguments.
302 e.g. wrapper_string of "strace,-c"
303 will cause all programs to run as
304 strace -c program arguments
307 static const char *wrapper_string
;
309 /* Forward declaration for prototypes. */
313 static void init_spec (void);
314 static void store_arg (const char *, int, int);
315 static void insert_wrapper (const char *);
316 static char *load_specs (const char *);
317 static void read_specs (const char *, int);
318 static void set_spec (const char *, const char *);
319 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
320 static char *build_search_list (const struct path_prefix
*, const char *,
322 static void xputenv (const char *);
323 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
325 static int access_check (const char *, int);
326 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
327 static void add_prefix (struct path_prefix
*, const char *, const char *,
329 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
330 const char *, int, int, int);
331 static void translate_options (int *, const char *const **);
332 static char *skip_whitespace (char *);
333 static void delete_if_ordinary (const char *);
334 static void delete_temp_files (void);
335 static void delete_failure_queue (void);
336 static void clear_failure_queue (void);
337 static int check_live_switch (int, int);
338 static const char *handle_braces (const char *);
339 static inline bool input_suffix_matches (const char *, const char *);
340 static inline bool switch_matches (const char *, const char *, int);
341 static inline void mark_matching_switches (const char *, const char *, int);
342 static inline void process_marked_switches (void);
343 static const char *process_brace_body (const char *, const char *, const char *, int, int);
344 static const struct spec_function
*lookup_spec_function (const char *);
345 static const char *eval_spec_function (const char *, const char *);
346 static const char *handle_spec_function (const char *);
347 static char *save_string (const char *, int);
348 static void set_collect_gcc_options (void);
349 static int do_spec_1 (const char *, int, const char *);
350 static int do_spec_2 (const char *);
351 static void do_option_spec (const char *, const char *);
352 static void do_self_spec (const char *);
353 static const char *find_file (const char *);
354 static int is_directory (const char *, bool);
355 static const char *validate_switches (const char *);
356 static void validate_all_switches (void);
357 static inline void validate_switches_from_spec (const char *);
358 static void give_switch (int, int);
359 static int used_arg (const char *, int);
360 static int default_arg (const char *, int);
361 static void set_multilib_dir (void);
362 static void print_multilib_info (void);
363 static void perror_with_name (const char *);
364 static void fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN
;
365 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1
;
366 static void display_help (void);
367 static void add_preprocessor_option (const char *, int);
368 static void add_assembler_option (const char *, int);
369 static void add_linker_option (const char *, int);
370 static void process_command (int, const char **);
371 static int execute (void);
372 static void alloc_args (void);
373 static void clear_args (void);
374 static void fatal_error (int);
375 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
376 static void init_gcc_specs (struct obstack
*, const char *, const char *,
379 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
380 static const char *convert_filename (const char *, int, int);
383 static const char *getenv_spec_function (int, const char **);
384 static const char *if_exists_spec_function (int, const char **);
385 static const char *if_exists_else_spec_function (int, const char **);
386 static const char *replace_outfile_spec_function (int, const char **);
387 static const char *version_compare_spec_function (int, const char **);
388 static const char *include_spec_function (int, const char **);
389 static const char *print_asm_header_spec_function (int, const char **);
391 /* The Specs Language
393 Specs are strings containing lines, each of which (if not blank)
394 is made up of a program name, and arguments separated by spaces.
395 The program name must be exact and start from root, since no path
396 is searched and it is unreliable to depend on the current working directory.
397 Redirection of input or output is not supported; the subprograms must
398 accept filenames saying what files to read and write.
400 In addition, the specs can contain %-sequences to substitute variable text
401 or for conditional text. Here is a table of all defined %-sequences.
402 Note that spaces are not generated automatically around the results of
403 expanding these sequences; therefore, you can concatenate them together
404 or with constant text in a single argument.
406 %% substitute one % into the program name or argument.
407 %i substitute the name of the input file being processed.
408 %b substitute the basename of the input file being processed.
409 This is the substring up to (and not including) the last period
410 and not including the directory unless -save-temps was specified
411 to put temporaries in a different location.
412 %B same as %b, but include the file suffix (text after the last period).
414 substitute a file name that has suffix SUFFIX and is chosen
415 once per compilation, and mark the argument a la %d. To reduce
416 exposure to denial-of-service attacks, the file name is now
417 chosen in a way that is hard to predict even when previously
418 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
419 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
420 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
421 had been pre-processed. Previously, %g was simply substituted
422 with a file name chosen once per compilation, without regard
423 to any appended suffix (which was therefore treated just like
424 ordinary text), making such attacks more likely to succeed.
426 like %g, but if -pipe is in effect, expands simply to "-".
428 like %g, but if -pipe is in effect, expands to nothing. (We have both
429 %| and %m to accommodate differences between system assemblers; see
430 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
432 like %g, but generates a new temporary file name even if %uSUFFIX
435 substitutes the last file name generated with %uSUFFIX, generating a
436 new one if there is no such last file name. In the absence of any
437 %uSUFFIX, this is just like %gSUFFIX, except they don't share
438 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
439 would involve the generation of two distinct file names, one
440 for each `%g.s' and another for each `%U.s'. Previously, %U was
441 simply substituted with a file name chosen for the previous %u,
442 without regard to any appended suffix.
444 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
445 writable, and if save-temps is off; otherwise, substitute the name
446 of a temporary file, just like %u. This temporary file is not
447 meant for communication between processes, but rather as a junk
450 substitutes .SUFFIX for the suffixes of a matched switch's args when
451 it is subsequently output with %*. SUFFIX is terminated by the next
453 %d marks the argument containing or following the %d as a
454 temporary file name, so that that file will be deleted if GCC exits
455 successfully. Unlike %g, this contributes no text to the argument.
456 %w marks the argument containing or following the %w as the
457 "output file" of this compilation. This puts the argument
458 into the sequence of arguments that %o will substitute later.
459 %V indicates that this compilation produces no "output file".
461 like %{...} but mark last argument supplied within
462 as a file to be deleted on failure.
463 %o substitutes the names of all the output files, with spaces
464 automatically placed around them. You should write spaces
465 around the %o as well or the results are undefined.
466 %o is for use in the specs for running the linker.
467 Input files whose names have no recognized suffix are not compiled
468 at all, but they are included among the output files, so they will
470 %O substitutes the suffix for object files. Note that this is
471 handled specially when it immediately follows %g, %u, or %U
472 (with or without a suffix argument) because of the need for
473 those to form complete file names. The handling is such that
474 %O is treated exactly as if it had already been substituted,
475 except that %g, %u, and %U do not currently support additional
476 SUFFIX characters following %O as they would following, for
478 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
479 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
480 and -B options) and -imultilib as necessary.
481 %s current argument is the name of a library or startup file of some sort.
482 Search for that file in a standard list of directories
483 and substitute the full name found.
484 %eSTR Print STR as an error message. STR is terminated by a newline.
485 Use this when inconsistent options are detected.
486 %nSTR Print STR as a notice. STR is terminated by a newline.
487 %x{OPTION} Accumulate an option for %X.
488 %X Output the accumulated linker options specified by compilations.
489 %Y Output the accumulated assembler options specified by compilations.
490 %Z Output the accumulated preprocessor options specified by compilations.
491 %a process ASM_SPEC as a spec.
492 This allows config.h to specify part of the spec for running as.
493 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
494 used here. This can be used to run a post-processor after the
495 assembler has done its job.
496 %D Dump out a -L option for each directory in startfile_prefixes.
497 If multilib_dir is set, extra entries are generated with it affixed.
498 %l process LINK_SPEC as a spec.
499 %L process LIB_SPEC as a spec.
500 %G process LIBGCC_SPEC as a spec.
501 %R Output the concatenation of target_system_root and
502 target_sysroot_suffix.
503 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
504 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
505 %C process CPP_SPEC as a spec.
506 %1 process CC1_SPEC as a spec.
507 %2 process CC1PLUS_SPEC as a spec.
508 %* substitute the variable part of a matched option. (See below.)
509 Note that each comma in the substituted string is replaced by
511 %<S remove all occurrences of -S from the command line.
512 Note - this command is position dependent. % commands in the
513 spec string before this one will see -S, % commands in the
514 spec string after this one will not.
515 %<S* remove all occurrences of all switches beginning with -S from the
518 Call the named function FUNCTION, passing it ARGS. ARGS is
519 first processed as a nested spec string, then split into an
520 argument vector in the usual fashion. The function returns
521 a string which is processed as if it had appeared literally
522 as part of the current spec.
523 %{S} substitutes the -S switch, if that switch was given to GCC.
524 If that switch was not specified, this substitutes nothing.
525 Here S is a metasyntactic variable.
526 %{S*} substitutes all the switches specified to GCC whose names start
527 with -S. This is used for -o, -I, etc; switches that take
528 arguments. GCC considers `-o foo' as being one switch whose
529 name starts with `o'. %{o*} would substitute this text,
530 including the space; thus, two arguments would be generated.
531 %{S*&T*} likewise, but preserve order of S and T options (the order
532 of S and T in the spec is not significant). Can be any number
533 of ampersand-separated variables; for each the wild card is
534 optional. Useful for CPP as %{D*&U*&A*}.
536 %{S:X} substitutes X, if the -S switch was given to GCC.
537 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
538 %{S*:X} substitutes X if one or more switches whose names start
539 with -S was given to GCC. Normally X is substituted only
540 once, no matter how many such switches appeared. However,
541 if %* appears somewhere in X, then X will be substituted
542 once for each matching switch, with the %* replaced by the
543 part of that switch that matched the '*'.
544 %{.S:X} substitutes X, if processing a file with suffix S.
545 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
546 %{,S:X} substitutes X, if processing a file which will use spec S.
547 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
549 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
550 combined with '!', '.', ',', and '*' as above binding stronger
552 If %* appears in X, all of the alternatives must be starred, and
553 only the first matching alternative is substituted.
554 %{S:X; if S was given to GCC, substitutes X;
555 T:Y; else if T was given to GCC, substitutes Y;
556 :D} else substitutes D. There can be as many clauses as you need.
557 This may be combined with '.', '!', ',', '|', and '*' as above.
559 %(Spec) processes a specification defined in a specs file as *Spec:
560 %[Spec] as above, but put __ around -D arguments
562 The conditional text X in a %{S:X} or similar construct may contain
563 other nested % constructs or spaces, or even newlines. They are
564 processed as usual, as described above. Trailing white space in X is
565 ignored. White space may also appear anywhere on the left side of the
566 colon in these constructs, except between . or * and the corresponding
569 The -O, -f, -m, and -W switches are handled specifically in these
570 constructs. If another value of -O or the negated form of a -f, -m, or
571 -W switch is found later in the command line, the earlier switch
572 value is ignored, except with {S*} where S is just one letter; this
573 passes all matching options.
575 The character | at the beginning of the predicate text is used to indicate
576 that a command should be piped to the following command, but only if -pipe
579 Note that it is built into GCC which switches take arguments and which
580 do not. You might think it would be useful to generalize this to
581 allow each compiler's spec to say which switches take arguments. But
582 this cannot be done in a consistent fashion. GCC cannot even decide
583 which input files have been specified without knowing which switches
584 take arguments, and it must know which input files to compile in order
585 to tell which compilers to run.
587 GCC also knows implicitly that arguments starting in `-l' are to be
588 treated as compiler output files, and passed to the linker in their
589 proper position among the other output files. */
591 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
593 /* config.h can define ASM_SPEC to provide extra args to the assembler
594 or extra switch-translations. */
599 /* config.h can define ASM_FINAL_SPEC to run a post processor after
600 the assembler has run. */
601 #ifndef ASM_FINAL_SPEC
602 #define ASM_FINAL_SPEC ""
605 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
606 or extra switch-translations. */
611 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
612 or extra switch-translations. */
617 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
618 or extra switch-translations. */
620 #define CC1PLUS_SPEC ""
623 /* config.h can define LINK_SPEC to provide extra args to the linker
624 or extra switch-translations. */
629 /* config.h can define LIB_SPEC to override the default libraries. */
631 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
636 /* XXX: valid only for GNU ld */
637 /* XXX: should exactly match hooks provided by libmudflap.a */
638 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
639 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
640 --wrap=mmap --wrap=munmap --wrap=alloca\
641 } %{fmudflapth: --wrap=pthread_create\
642 }} %{fmudflap|fmudflapth: --wrap=main}"
645 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
648 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
651 #if defined(REAL_LIBGCC_SPEC)
652 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
653 #elif defined(LINK_LIBGCC_SPECIAL_1)
654 /* Have gcc do the search for libgcc.a. */
655 #define LIBGCC_SPEC "libgcc.a%s"
657 #define LIBGCC_SPEC "-lgcc"
661 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
662 #ifndef STARTFILE_SPEC
663 #define STARTFILE_SPEC \
664 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
667 /* config.h can define SWITCHES_NEED_SPACES to control which options
668 require spaces between the option and the argument. */
669 #ifndef SWITCHES_NEED_SPACES
670 #define SWITCHES_NEED_SPACES ""
673 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
675 #define ENDFILE_SPEC ""
679 #define LINKER_NAME "collect2"
682 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
683 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
688 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
690 #ifndef ASM_DEBUG_SPEC
691 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
692 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
693 # define ASM_DEBUG_SPEC \
694 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
695 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
696 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
698 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
699 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
701 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
702 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
706 #ifndef ASM_DEBUG_SPEC
707 # define ASM_DEBUG_SPEC ""
710 /* Here is the spec for running the linker, after compiling all files. */
712 /* This is overridable by the target in case they need to specify the
713 -lgcc and -lc order specially, yet not require them to override all
714 of LINK_COMMAND_SPEC. */
715 #ifndef LINK_GCC_C_SEQUENCE_SPEC
716 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
719 #ifndef LINK_SSP_SPEC
720 #ifdef TARGET_LIBC_PROVIDES_SSP
721 #define LINK_SSP_SPEC "%{fstack-protector:}"
723 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
727 #ifndef LINK_PIE_SPEC
729 #define LINK_PIE_SPEC "%{pie:-pie} "
731 #define LINK_PIE_SPEC "%{pie:} "
735 #ifndef LINK_BUILDID_SPEC
736 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
737 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
742 /* -u* was put back because both BSD and SysV seem to support it. */
743 /* %{static:} simply prevents an error message if the target machine
744 doesn't handle -static. */
745 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
746 scripts which exist in user specified directories, or in standard
748 #ifndef LINK_COMMAND_SPEC
749 #define LINK_COMMAND_SPEC "\
750 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
751 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
752 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
753 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
754 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
755 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
756 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
757 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
760 #ifndef LINK_LIBGCC_SPEC
761 /* Generate -L options for startfile prefix list. */
762 # define LINK_LIBGCC_SPEC "%D"
765 #ifndef STARTFILE_PREFIX_SPEC
766 # define STARTFILE_PREFIX_SPEC ""
770 # define SYSROOT_SPEC "--sysroot=%R"
773 #ifndef SYSROOT_SUFFIX_SPEC
774 # define SYSROOT_SUFFIX_SPEC ""
777 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
778 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
781 static const char *asm_debug
;
782 static const char *cpp_spec
= CPP_SPEC
;
783 static const char *cc1_spec
= CC1_SPEC
;
784 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
785 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
786 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
787 static const char *asm_spec
= ASM_SPEC
;
788 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
789 static const char *link_spec
= LINK_SPEC
;
790 static const char *lib_spec
= LIB_SPEC
;
791 static const char *mfwrap_spec
= MFWRAP_SPEC
;
792 static const char *mflib_spec
= MFLIB_SPEC
;
793 static const char *link_gomp_spec
= "";
794 static const char *libgcc_spec
= LIBGCC_SPEC
;
795 static const char *endfile_spec
= ENDFILE_SPEC
;
796 static const char *startfile_spec
= STARTFILE_SPEC
;
797 static const char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
798 static const char *linker_name_spec
= LINKER_NAME
;
799 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
800 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
801 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
802 static const char *sysroot_spec
= SYSROOT_SPEC
;
803 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
804 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
806 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
807 There should be no need to override these in target dependent files,
808 but we need to copy them to the specs file so that newer versions
809 of the GCC driver can correctly drive older tool chains with the
810 appropriate -B options. */
812 /* When cpplib handles traditional preprocessing, get rid of this, and
813 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
814 that we default the front end language better. */
815 static const char *trad_capable_cpp
=
816 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
818 /* We don't wrap .d files in %W{} since a missing .d file, and
819 therefore no dependency entry, confuses make into thinking a .o
820 file that happens to exist is up-to-date. */
821 static const char *cpp_unique_options
=
822 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
823 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
824 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
825 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
826 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
827 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
828 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
829 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
830 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
831 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
834 /* This contains cpp options which are common with cc1_options and are passed
835 only when preprocessing only to avoid duplication. We pass the cc1 spec
836 options to the preprocessor so that it the cc1 spec may manipulate
837 options used to set target flags. Those special target flags settings may
838 in turn cause preprocessor symbols to be defined specially. */
839 static const char *cpp_options
=
840 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
841 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
842 %{undef} %{save-temps*:-fpch-preprocess}";
844 /* This contains cpp options which are not passed when the preprocessor
845 output will be used by another program. */
846 static const char *cpp_debug_options
= "%{d*}";
848 /* NB: This is shared amongst all front-ends, except for Ada. */
849 static const char *cc1_options
=
850 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
851 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
852 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
853 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
854 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
855 %{Qn:-fno-ident} %{--help:--help}\
856 %{--target-help:--target-help}\
857 %{--help=*:--help=%(VALUE)}\
858 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
859 %{fsyntax-only:-o %j} %{-param*}\
860 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
861 %{coverage:-fprofile-arcs -ftest-coverage}";
863 static const char *asm_options
=
864 "%{--target-help:%:print-asm-header()} "
866 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
867 to the assembler equivalents. */
868 "%{v} %{w:-W} %{I*} "
870 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
872 static const char *invoke_as
=
873 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
874 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
876 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
879 /* Some compilers have limits on line lengths, and the multilib_select
880 and/or multilib_matches strings can be very long, so we build them at
882 static struct obstack multilib_obstack
;
883 static const char *multilib_select
;
884 static const char *multilib_matches
;
885 static const char *multilib_defaults
;
886 static const char *multilib_exclusions
;
888 /* Check whether a particular argument is a default argument. */
890 #ifndef MULTILIB_DEFAULTS
891 #define MULTILIB_DEFAULTS { "" }
894 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
896 #ifndef DRIVER_SELF_SPECS
897 #define DRIVER_SELF_SPECS ""
900 /* Adding -fopenmp should imply pthreads. This is particularly important
901 for targets that use different start files and suchlike. */
902 #ifndef GOMP_SELF_SPECS
903 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
906 static const char *const driver_self_specs
[] = {
907 DRIVER_SELF_SPECS
, GOMP_SELF_SPECS
910 #ifndef OPTION_DEFAULT_SPECS
911 #define OPTION_DEFAULT_SPECS { "", "" }
920 static const struct default_spec
921 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
925 struct user_specs
*next
;
926 const char *filename
;
929 static struct user_specs
*user_specs_head
, *user_specs_tail
;
931 #ifndef SWITCH_TAKES_ARG
932 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
935 #ifndef WORD_SWITCH_TAKES_ARG
936 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
939 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
940 /* This defines which switches stop a full compilation. */
941 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
942 ((CHAR) == 'c' || (CHAR) == 'S')
944 #ifndef SWITCH_CURTAILS_COMPILATION
945 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
946 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
950 /* Record the mapping from file suffixes for compilation specs. */
954 const char *suffix
; /* Use this compiler for input files
955 whose names end in this suffix. */
957 const char *spec
; /* To use this compiler, run this spec. */
959 const char *cpp_spec
; /* If non-NULL, substitute this spec
960 for `%C', rather than the usual
962 const int combinable
; /* If nonzero, compiler can deal with
963 multiple source files at once (IMA). */
964 const int needs_preprocessing
; /* If nonzero, source files need to
965 be run through a preprocessor. */
968 /* Pointer to a vector of `struct compiler' that gives the spec for
969 compiling a file, based on its suffix.
970 A file that does not end in any of these suffixes will be passed
971 unchanged to the loader and nothing else will be done to it.
973 An entry containing two 0s is used to terminate the vector.
975 If multiple entries match a file, the last matching one is used. */
977 static struct compiler
*compilers
;
979 /* Number of entries in `compilers', not counting the null terminator. */
981 static int n_compilers
;
983 /* The default list of file name suffixes and their compilation specs. */
985 static const struct compiler default_compilers
[] =
987 /* Add lists of suffixes of known languages here. If those languages
988 were not present when we built the driver, we will hit these copies
989 and be given a more meaningful error than "file not used since
990 linking is not done". */
991 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
992 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
993 {".mii", "#Objective-C++", 0, 0, 0},
994 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
995 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
996 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
997 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
998 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
999 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1000 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1001 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1002 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1003 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1004 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1005 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1006 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1007 {".r", "#Ratfor", 0, 0, 0},
1008 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1009 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1010 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1011 /* Next come the entries for C. */
1012 {".c", "@c", 0, 1, 1},
1014 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1015 external preprocessor if -save-temps is given. */
1016 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1018 %{traditional|ftraditional:\
1019 %eGNU C no longer supports -traditional without -E}\
1021 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1022 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1023 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1025 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1026 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1027 %{!fsyntax-only:%(invoke_as)}} \
1029 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1030 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1031 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1032 cc1 %(cpp_unique_options) %(cc1_options)}}\
1033 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1035 "%{!E:%e-E or -x required when input is from standard input}\
1036 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1037 {".h", "@c-header", 0, 0, 0},
1039 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1040 external preprocessor if -save-temps is given. */
1041 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1043 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1044 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1045 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1047 -o %g.s %{!o*:--output-pch=%i.gch}\
1048 %W{o*:--output-pch=%*}%V}\
1049 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1050 cc1 %(cpp_unique_options) %(cc1_options)\
1051 -o %g.s %{!o*:--output-pch=%i.gch}\
1052 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1053 {".i", "@cpp-output", 0, 1, 0},
1055 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1056 {".s", "@assembler", 0, 1, 0},
1058 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1059 {".sx", "@assembler-with-cpp", 0, 1, 0},
1060 {".S", "@assembler-with-cpp", 0, 1, 0},
1061 {"@assembler-with-cpp",
1062 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1063 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1064 %{E|M|MM:%(cpp_debug_options)}\
1065 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1066 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1068 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1069 %{E|M|MM:%(cpp_debug_options)}\
1070 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1071 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1076 /* Mark end of table. */
1080 /* Number of elements in default_compilers, not counting the terminator. */
1082 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1084 /* A vector of options to give to the linker.
1085 These options are accumulated by %x,
1086 and substituted into the linker command with %X. */
1087 static int n_linker_options
;
1088 static char **linker_options
;
1090 /* A vector of options to give to the assembler.
1091 These options are accumulated by -Wa,
1092 and substituted into the assembler command with %Y. */
1093 static int n_assembler_options
;
1094 static char **assembler_options
;
1096 /* A vector of options to give to the preprocessor.
1097 These options are accumulated by -Wp,
1098 and substituted into the preprocessor command with %Z. */
1099 static int n_preprocessor_options
;
1100 static char **preprocessor_options
;
1102 /* Define how to map long options into short ones. */
1104 /* This structure describes one mapping. */
1107 /* The long option's name. */
1108 const char *const name
;
1109 /* The equivalent short option. */
1110 const char *const equivalent
;
1111 /* Argument info. A string of flag chars; NULL equals no options.
1112 a => argument required.
1113 o => argument optional.
1114 j => join argument to equivalent, making one word.
1115 * => require other text after NAME as an argument. */
1116 const char *const arg_info
;
1119 /* This is the table of mappings. Mappings are tried sequentially
1120 for each option encountered; the first one that matches, wins. */
1122 static const struct option_map option_map
[] =
1124 {"--all-warnings", "-Wall", 0},
1125 {"--ansi", "-ansi", 0},
1126 {"--assemble", "-S", 0},
1127 {"--assert", "-A", "a"},
1128 {"--classpath", "-fclasspath=", "aj"},
1129 {"--bootclasspath", "-fbootclasspath=", "aj"},
1130 {"--CLASSPATH", "-fclasspath=", "aj"},
1131 {"--combine", "-combine", 0},
1132 {"--comments", "-C", 0},
1133 {"--comments-in-macros", "-CC", 0},
1134 {"--compile", "-c", 0},
1135 {"--debug", "-g", "oj"},
1136 {"--define-macro", "-D", "aj"},
1137 {"--dependencies", "-M", 0},
1138 {"--dump", "-d", "a"},
1139 {"--dumpbase", "-dumpbase", "a"},
1140 {"--encoding", "-fencoding=", "aj"},
1141 {"--entry", "-e", 0},
1142 {"--extra-warnings", "-W", 0},
1143 {"--extdirs", "-fextdirs=", "aj"},
1144 {"--for-assembler", "-Wa", "a"},
1145 {"--for-linker", "-Xlinker", "a"},
1146 {"--force-link", "-u", "a"},
1147 {"--coverage", "-coverage", 0},
1148 {"--imacros", "-imacros", "a"},
1149 {"--include", "-include", "a"},
1150 {"--include-barrier", "-I-", 0},
1151 {"--include-directory", "-I", "aj"},
1152 {"--include-directory-after", "-idirafter", "a"},
1153 {"--include-prefix", "-iprefix", "a"},
1154 {"--include-with-prefix", "-iwithprefix", "a"},
1155 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1156 {"--include-with-prefix-after", "-iwithprefix", "a"},
1157 {"--language", "-x", "a"},
1158 {"--library-directory", "-L", "a"},
1159 {"--machine", "-m", "aj"},
1160 {"--machine-", "-m", "*j"},
1161 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1162 {"--no-line-commands", "-P", 0},
1163 {"--no-precompiled-includes", "-noprecomp", 0},
1164 {"--no-standard-includes", "-nostdinc", 0},
1165 {"--no-standard-libraries", "-nostdlib", 0},
1166 {"--no-warnings", "-w", 0},
1167 {"--optimize", "-O", "oj"},
1168 {"--output", "-o", "a"},
1169 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1170 {"--param", "--param", "a"},
1171 {"--pass-exit-codes", "-pass-exit-codes", 0},
1172 {"--pedantic", "-pedantic", 0},
1173 {"--pedantic-errors", "-pedantic-errors", 0},
1174 {"--pie", "-pie", 0},
1175 {"--pipe", "-pipe", 0},
1176 {"--prefix", "-B", "a"},
1177 {"--preprocess", "-E", 0},
1178 {"--print-search-dirs", "-print-search-dirs", 0},
1179 {"--print-file-name", "-print-file-name=", "aj"},
1180 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1181 {"--print-missing-file-dependencies", "-MG", 0},
1182 {"--print-multi-lib", "-print-multi-lib", 0},
1183 {"--print-multi-directory", "-print-multi-directory", 0},
1184 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1185 {"--print-prog-name", "-print-prog-name=", "aj"},
1186 {"--print-sysroot", "-print-sysroot", 0},
1187 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1188 {"--profile", "-p", 0},
1189 {"--profile-blocks", "-a", 0},
1190 {"--quiet", "-q", 0},
1191 {"--resource", "-fcompile-resource=", "aj"},
1192 {"--save-temps", "-save-temps", 0},
1193 {"--shared", "-shared", 0},
1194 {"--silent", "-q", 0},
1195 {"--specs", "-specs=", "aj"},
1196 {"--static", "-static", 0},
1197 {"--std", "-std=", "aj"},
1198 {"--symbolic", "-symbolic", 0},
1199 {"--sysroot", "--sysroot=", "aj"},
1200 {"--time", "-time", 0},
1201 {"--trace-includes", "-H", 0},
1202 {"--traditional", "-traditional", 0},
1203 {"--traditional-cpp", "-traditional-cpp", 0},
1204 {"--trigraphs", "-trigraphs", 0},
1205 {"--undefine-macro", "-U", "aj"},
1206 {"--user-dependencies", "-MM", 0},
1207 {"--verbose", "-v", 0},
1208 {"--warn-", "-W", "*j"},
1209 {"--write-dependencies", "-MD", 0},
1210 {"--write-user-dependencies", "-MMD", 0},
1215 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1216 static const struct {
1217 const char *const option_found
;
1218 const char *const replacements
;
1219 } target_option_translations
[] =
1221 TARGET_OPTION_TRANSLATE_TABLE
,
1226 /* Translate the options described by *ARGCP and *ARGVP.
1227 Make a new vector and store it back in *ARGVP,
1228 and store its length in *ARGCP. */
1231 translate_options (int *argcp
, const char *const **argvp
)
1235 const char *const *argv
= *argvp
;
1236 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1237 const char **newv
= XNEWVAR (const char *, newvsize
);
1241 newv
[newindex
++] = argv
[i
++];
1245 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1249 target_option_translations
[tott_idx
].option_found
;
1252 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1259 for (sp
= target_option_translations
[tott_idx
].replacements
;
1266 newvsize
+= spaces
* sizeof (const char *);
1267 newv
= XRESIZEVAR (const char *, newv
, newvsize
);
1269 sp
= target_option_translations
[tott_idx
].replacements
;
1278 newv
[newindex
++] = np
;
1279 while (*np
!= ' ' && *np
)
1290 if (target_option_translations
[tott_idx
].option_found
)
1294 /* Translate -- options. */
1295 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1298 /* Find a mapping that applies to this option. */
1299 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1301 size_t optlen
= strlen (option_map
[j
].name
);
1302 size_t arglen
= strlen (argv
[i
]);
1303 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1304 const char *arginfo
= option_map
[j
].arg_info
;
1309 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1311 const char *arg
= 0;
1313 if (arglen
< optlen
)
1316 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1317 if (strlen (option_map
[k
].name
) >= arglen
1318 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1320 error ("ambiguous abbreviation %s", argv
[i
]);
1324 if (k
!= ARRAY_SIZE (option_map
))
1328 if (arglen
> optlen
)
1330 /* If the option has an argument, accept that. */
1331 if (argv
[i
][optlen
] == '=')
1332 arg
= argv
[i
] + optlen
+ 1;
1334 /* If this mapping requires extra text at end of name,
1335 accept that as "argument". */
1336 else if (strchr (arginfo
, '*') != 0)
1337 arg
= argv
[i
] + optlen
;
1339 /* Otherwise, extra text at end means mismatch.
1340 Try other mappings. */
1345 else if (strchr (arginfo
, '*') != 0)
1347 error ("incomplete '%s' option", option_map
[j
].name
);
1351 /* Handle arguments. */
1352 if (strchr (arginfo
, 'a') != 0)
1358 error ("missing argument to '%s' option",
1359 option_map
[j
].name
);
1366 else if (strchr (arginfo
, '*') != 0)
1368 else if (strchr (arginfo
, 'o') == 0)
1371 error ("extraneous argument to '%s' option",
1372 option_map
[j
].name
);
1376 /* Store the translation as one argv elt or as two. */
1377 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1378 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1382 newv
[newindex
++] = option_map
[j
].equivalent
;
1383 newv
[newindex
++] = arg
;
1386 newv
[newindex
++] = option_map
[j
].equivalent
;
1394 /* Handle old-fashioned options--just copy them through,
1395 with their arguments. */
1396 else if (argv
[i
][0] == '-')
1398 const char *p
= argv
[i
] + 1;
1402 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1403 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1404 else if (WORD_SWITCH_TAKES_ARG (p
))
1405 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1406 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1409 else if (! strcmp (p
, "Xlinker"))
1411 else if (! strcmp (p
, "Xpreprocessor"))
1413 else if (! strcmp (p
, "Xassembler"))
1416 /* Watch out for an option at the end of the command line that
1417 is missing arguments, and avoid skipping past the end of the
1419 if (nskip
+ i
> argc
)
1424 newv
[newindex
++] = argv
[i
++];
1429 /* Ordinary operands, or +e options. */
1430 newv
[newindex
++] = argv
[i
++];
1440 skip_whitespace (char *p
)
1444 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1445 be considered whitespace. */
1446 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1448 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1462 /* Structures to keep track of prefixes to try when looking for files. */
1466 const char *prefix
; /* String to prepend to the path. */
1467 struct prefix_list
*next
; /* Next in linked list. */
1468 int require_machine_suffix
; /* Don't use without machine_suffix. */
1469 /* 2 means try both machine_suffix and just_machine_suffix. */
1470 int priority
; /* Sort key - priority within list. */
1471 int os_multilib
; /* 1 if OS multilib scheme should be used,
1472 0 for GCC multilib scheme. */
1477 struct prefix_list
*plist
; /* List of prefixes to try */
1478 int max_len
; /* Max length of a prefix in PLIST */
1479 const char *name
; /* Name of this list (used in config stuff) */
1482 /* List of prefixes to try when looking for executables. */
1484 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1486 /* List of prefixes to try when looking for startup (crt0) files. */
1488 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1490 /* List of prefixes to try when looking for include files. */
1492 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1494 /* Suffix to attach to directories searched for commands.
1495 This looks like `MACHINE/VERSION/'. */
1497 static const char *machine_suffix
= 0;
1499 /* Suffix to attach to directories searched for commands.
1500 This is just `MACHINE/'. */
1502 static const char *just_machine_suffix
= 0;
1504 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1506 static const char *gcc_exec_prefix
;
1508 /* Adjusted value of standard_libexec_prefix. */
1510 static const char *gcc_libexec_prefix
;
1512 /* Default prefixes to attach to command names. */
1514 #ifndef STANDARD_STARTFILE_PREFIX_1
1515 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1517 #ifndef STANDARD_STARTFILE_PREFIX_2
1518 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1521 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1522 #undef MD_EXEC_PREFIX
1523 #undef MD_STARTFILE_PREFIX
1524 #undef MD_STARTFILE_PREFIX_1
1527 /* If no prefixes defined, use the null string, which will disable them. */
1528 #ifndef MD_EXEC_PREFIX
1529 #define MD_EXEC_PREFIX ""
1531 #ifndef MD_STARTFILE_PREFIX
1532 #define MD_STARTFILE_PREFIX ""
1534 #ifndef MD_STARTFILE_PREFIX_1
1535 #define MD_STARTFILE_PREFIX_1 ""
1538 /* These directories are locations set at configure-time based on the
1539 --prefix option provided to configure. Their initializers are
1540 defined in Makefile.in. These paths are not *directly* used when
1541 gcc_exec_prefix is set because, in that case, we know where the
1542 compiler has been installed, and use paths relative to that
1543 location instead. */
1544 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1545 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1546 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1547 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1549 /* For native compilers, these are well-known paths containing
1550 components that may be provided by the system. For cross
1551 compilers, these paths are not used. */
1552 static const char *const standard_exec_prefix_1
= "/usr/libexec/gcc/";
1553 static const char *const standard_exec_prefix_2
= "/usr/lib/gcc/";
1554 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1555 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1556 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1557 static const char *const standard_startfile_prefix_1
1558 = STANDARD_STARTFILE_PREFIX_1
;
1559 static const char *const standard_startfile_prefix_2
1560 = STANDARD_STARTFILE_PREFIX_2
;
1562 /* A relative path to be used in finding the location of tools
1563 relative to the driver. */
1564 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1566 /* Subdirectory to use for locating libraries. Set by
1567 set_multilib_dir based on the compilation options. */
1569 static const char *multilib_dir
;
1571 /* Subdirectory to use for locating libraries in OS conventions. Set by
1572 set_multilib_dir based on the compilation options. */
1574 static const char *multilib_os_dir
;
1576 /* Structure to keep track of the specs that have been defined so far.
1577 These are accessed using %(specname) or %[specname] in a compiler
1582 /* The following 2 fields must be first */
1583 /* to allow EXTRA_SPECS to be initialized */
1584 const char *name
; /* name of the spec. */
1585 const char *ptr
; /* available ptr if no static pointer */
1587 /* The following fields are not initialized */
1588 /* by EXTRA_SPECS */
1589 const char **ptr_spec
; /* pointer to the spec itself. */
1590 struct spec_list
*next
; /* Next spec in linked list. */
1591 int name_len
; /* length of the name */
1592 int alloc_p
; /* whether string was allocated */
1595 #define INIT_STATIC_SPEC(NAME,PTR) \
1596 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1598 /* List of statically defined specs. */
1599 static struct spec_list static_specs
[] =
1601 INIT_STATIC_SPEC ("asm", &asm_spec
),
1602 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1603 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1604 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1605 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1606 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1607 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1608 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1609 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1610 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1611 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1612 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1613 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1614 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1615 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1616 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1617 INIT_STATIC_SPEC ("link", &link_spec
),
1618 INIT_STATIC_SPEC ("lib", &lib_spec
),
1619 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1620 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1621 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1622 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1623 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1624 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces
),
1625 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1626 INIT_STATIC_SPEC ("version", &compiler_version
),
1627 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1628 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1629 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1630 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1631 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1632 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1633 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1634 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1635 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1636 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1637 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1638 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1639 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1640 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1641 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1644 #ifdef EXTRA_SPECS /* additional specs needed */
1645 /* Structure to keep track of just the first two args of a spec_list.
1646 That is all that the EXTRA_SPECS macro gives us. */
1649 const char *const name
;
1650 const char *const ptr
;
1653 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1654 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1657 /* List of dynamically allocates specs that have been defined so far. */
1659 static struct spec_list
*specs
= (struct spec_list
*) 0;
1661 /* List of static spec functions. */
1663 static const struct spec_function static_spec_functions
[] =
1665 { "getenv", getenv_spec_function
},
1666 { "if-exists", if_exists_spec_function
},
1667 { "if-exists-else", if_exists_else_spec_function
},
1668 { "replace-outfile", replace_outfile_spec_function
},
1669 { "version-compare", version_compare_spec_function
},
1670 { "include", include_spec_function
},
1671 { "print-asm-header", print_asm_header_spec_function
},
1672 #ifdef EXTRA_SPEC_FUNCTIONS
1673 EXTRA_SPEC_FUNCTIONS
1678 static int processing_spec_function
;
1680 /* Add appropriate libgcc specs to OBSTACK, taking into account
1681 various permutations of -shared-libgcc, -shared, and such. */
1683 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1685 #ifndef USE_LD_AS_NEEDED
1686 #define USE_LD_AS_NEEDED 0
1690 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1691 const char *static_name
, const char *eh_name
)
1695 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1696 "%{!static:%{!static-libgcc:"
1697 #if USE_LD_AS_NEEDED
1698 "%{!shared-libgcc:",
1699 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1702 shared_name
, "%{!shared: ", static_name
, "}"
1706 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1707 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1711 "%{shared-libgcc:", shared_name
, "}"
1712 "%{!shared-libgcc:", static_name
, "}"
1715 "%{shared:", shared_name
, "}"
1720 obstack_grow (obstack
, buf
, strlen (buf
));
1723 #endif /* ENABLE_SHARED_LIBGCC */
1725 /* Initialize the specs lookup routines. */
1730 struct spec_list
*next
= (struct spec_list
*) 0;
1731 struct spec_list
*sl
= (struct spec_list
*) 0;
1735 return; /* Already initialized. */
1738 notice ("Using built-in specs.\n");
1741 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1743 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1745 sl
= &extra_specs
[i
];
1746 sl
->name
= extra_specs_1
[i
].name
;
1747 sl
->ptr
= extra_specs_1
[i
].ptr
;
1749 sl
->name_len
= strlen (sl
->name
);
1750 sl
->ptr_spec
= &sl
->ptr
;
1755 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1757 sl
= &static_specs
[i
];
1762 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1763 /* ??? If neither -shared-libgcc nor --static-libgcc was
1764 seen, then we should be making an educated guess. Some proposed
1765 heuristics for ELF include:
1767 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1768 program will be doing dynamic loading, which will likely
1769 need the shared libgcc.
1771 (2) If "-ldl", then it's also a fair bet that we're doing
1774 (3) For each ET_DYN we're linking against (either through -lfoo
1775 or /some/path/foo.so), check to see whether it or one of
1776 its dependencies depends on a shared libgcc.
1780 If the runtime is fixed to look for program headers instead
1781 of calling __register_frame_info at all, for each object,
1782 use the shared libgcc if any EH symbol referenced.
1784 If crtstuff is fixed to not invoke __register_frame_info
1785 automatically, for each object, use the shared libgcc if
1786 any non-empty unwind section found.
1788 Doing any of this probably requires invoking an external program to
1789 do the actual object file scanning. */
1791 const char *p
= libgcc_spec
;
1794 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1795 when given the proper command line arguments. */
1798 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1800 init_gcc_specs (&obstack
,
1802 #ifdef USE_LIBUNWIND_EXCEPTIONS
1808 #ifdef USE_LIBUNWIND_EXCEPTIONS
1809 # ifdef HAVE_LD_STATIC_DYNAMIC
1810 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1820 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1822 /* Ug. We don't know shared library extensions. Hope that
1823 systems that use this form don't do shared libraries. */
1824 init_gcc_specs (&obstack
,
1828 #ifdef USE_LIBUNWIND_EXCEPTIONS
1837 obstack_1grow (&obstack
, *p
);
1838 in_sep
= (*p
== ' ');
1843 obstack_1grow (&obstack
, '\0');
1844 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1847 #ifdef USE_AS_TRADITIONAL_FORMAT
1848 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1850 static const char tf
[] = "--traditional-format ";
1851 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1852 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1853 asm_spec
= XOBFINISH (&obstack
, const char *);
1857 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1858 # ifdef LINK_BUILDID_SPEC
1859 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1860 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1862 # ifdef LINK_EH_SPEC
1863 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1864 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1866 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1867 link_spec
= XOBFINISH (&obstack
, const char *);
1873 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1874 removed; If the spec starts with a + then SPEC is added to the end of the
1878 set_spec (const char *name
, const char *spec
)
1880 struct spec_list
*sl
;
1881 const char *old_spec
;
1882 int name_len
= strlen (name
);
1885 /* If this is the first call, initialize the statically allocated specs. */
1888 struct spec_list
*next
= (struct spec_list
*) 0;
1889 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1891 sl
= &static_specs
[i
];
1898 /* See if the spec already exists. */
1899 for (sl
= specs
; sl
; sl
= sl
->next
)
1900 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1905 /* Not found - make it. */
1906 sl
= XNEW (struct spec_list
);
1907 sl
->name
= xstrdup (name
);
1908 sl
->name_len
= name_len
;
1909 sl
->ptr_spec
= &sl
->ptr
;
1911 *(sl
->ptr_spec
) = "";
1916 old_spec
= *(sl
->ptr_spec
);
1917 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1918 ? concat (old_spec
, spec
+ 1, NULL
)
1923 notice ("Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1926 /* Free the old spec. */
1927 if (old_spec
&& sl
->alloc_p
)
1928 free (CONST_CAST(char *, old_spec
));
1933 /* Accumulate a command (program name and args), and run it. */
1935 /* Vector of pointers to arguments in the current line of specifications. */
1937 static const char **argbuf
;
1939 /* Number of elements allocated in argbuf. */
1941 static int argbuf_length
;
1943 /* Number of elements in argbuf currently in use (containing args). */
1945 static int argbuf_index
;
1947 /* Position in the argbuf array containing the name of the output file
1948 (the value associated with the "-o" flag). */
1950 static int have_o_argbuf_index
= 0;
1952 /* Were the options -c or -S passed. */
1953 static int have_c
= 0;
1955 /* Was the option -o passed. */
1956 static int have_o
= 0;
1958 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1959 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1962 static struct temp_name
{
1963 const char *suffix
; /* suffix associated with the code. */
1964 int length
; /* strlen (suffix). */
1965 int unique
; /* Indicates whether %g or %u/%U was used. */
1966 const char *filename
; /* associated filename. */
1967 int filename_length
; /* strlen (filename). */
1968 struct temp_name
*next
;
1971 /* Number of commands executed so far. */
1973 static int execution_count
;
1975 /* Number of commands that exited with a signal. */
1977 static int signal_count
;
1979 /* Name with which this program was invoked. */
1981 static const char *programname
;
1983 /* Allocate the argument vector. */
1989 argbuf
= XNEWVEC (const char *, argbuf_length
);
1992 /* Clear out the vector of arguments (after a command is executed). */
2000 /* Add one argument to the vector at the end.
2001 This is done when a space is seen or at the end of the line.
2002 If DELETE_ALWAYS is nonzero, the arg is a filename
2003 and the file should be deleted eventually.
2004 If DELETE_FAILURE is nonzero, the arg is a filename
2005 and the file should be deleted if this compilation fails. */
2008 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2010 if (argbuf_index
+ 1 == argbuf_length
)
2011 argbuf
= XRESIZEVEC (const char *, argbuf
, (argbuf_length
*= 2));
2013 argbuf
[argbuf_index
++] = arg
;
2014 argbuf
[argbuf_index
] = 0;
2016 if (strcmp (arg
, "-o") == 0)
2017 have_o_argbuf_index
= argbuf_index
;
2018 if (delete_always
|| delete_failure
)
2019 record_temp_file (arg
, delete_always
, delete_failure
);
2022 /* Load specs from a file name named FILENAME, replacing occurrences of
2023 various different types of line-endings, \r\n, \n\r and just \r, with
2027 load_specs (const char *filename
)
2031 struct stat statbuf
;
2038 notice ("Reading specs from %s\n", filename
);
2040 /* Open and stat the file. */
2041 desc
= open (filename
, O_RDONLY
, 0);
2043 pfatal_with_name (filename
);
2044 if (stat (filename
, &statbuf
) < 0)
2045 pfatal_with_name (filename
);
2047 /* Read contents of file into BUFFER. */
2048 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2049 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2051 pfatal_with_name (filename
);
2052 buffer
[readlen
] = 0;
2055 specs
= XNEWVEC (char, readlen
+ 1);
2057 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2063 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2065 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2079 /* Read compilation specs from a file named FILENAME,
2080 replacing the default ones.
2082 A suffix which starts with `*' is a definition for
2083 one of the machine-specific sub-specs. The "suffix" should be
2084 *asm, *cc1, *cpp, *link, *startfile, etc.
2085 The corresponding spec is stored in asm_spec, etc.,
2086 rather than in the `compilers' vector.
2088 Anything invalid in the file is a fatal error. */
2091 read_specs (const char *filename
, int main_p
)
2096 buffer
= load_specs (filename
);
2098 /* Scan BUFFER for specs, putting them in the vector. */
2104 char *in
, *out
, *p1
, *p2
, *p3
;
2106 /* Advance P in BUFFER to the next nonblank nocomment line. */
2107 p
= skip_whitespace (p
);
2111 /* Is this a special command that starts with '%'? */
2112 /* Don't allow this for the main specs file, since it would
2113 encourage people to overwrite it. */
2114 if (*p
== '%' && !main_p
)
2117 while (*p
&& *p
!= '\n')
2123 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2124 && (p1
[sizeof "%include" - 1] == ' '
2125 || p1
[sizeof "%include" - 1] == '\t'))
2129 p1
+= sizeof ("%include");
2130 while (*p1
== ' ' || *p1
== '\t')
2133 if (*p1
++ != '<' || p
[-2] != '>')
2134 fatal ("specs %%include syntax malformed after %ld characters",
2135 (long) (p1
- buffer
+ 1));
2138 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2139 read_specs (new_filename
? new_filename
: p1
, FALSE
);
2142 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2143 && (p1
[sizeof "%include_noerr" - 1] == ' '
2144 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2148 p1
+= sizeof "%include_noerr";
2149 while (*p1
== ' ' || *p1
== '\t')
2152 if (*p1
++ != '<' || p
[-2] != '>')
2153 fatal ("specs %%include syntax malformed after %ld characters",
2154 (long) (p1
- buffer
+ 1));
2157 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2159 read_specs (new_filename
, FALSE
);
2160 else if (verbose_flag
)
2161 notice ("could not find specs file %s\n", p1
);
2164 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2165 && (p1
[sizeof "%rename" - 1] == ' '
2166 || p1
[sizeof "%rename" - 1] == '\t'))
2169 struct spec_list
*sl
;
2170 struct spec_list
*newsl
;
2172 /* Get original name. */
2173 p1
+= sizeof "%rename";
2174 while (*p1
== ' ' || *p1
== '\t')
2177 if (! ISALPHA ((unsigned char) *p1
))
2178 fatal ("specs %%rename syntax malformed after %ld characters",
2179 (long) (p1
- buffer
));
2182 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2185 if (*p2
!= ' ' && *p2
!= '\t')
2186 fatal ("specs %%rename syntax malformed after %ld characters",
2187 (long) (p2
- buffer
));
2191 while (*p2
== ' ' || *p2
== '\t')
2194 if (! ISALPHA ((unsigned char) *p2
))
2195 fatal ("specs %%rename syntax malformed after %ld characters",
2196 (long) (p2
- buffer
));
2198 /* Get new spec name. */
2200 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2204 fatal ("specs %%rename syntax malformed after %ld characters",
2205 (long) (p3
- buffer
));
2208 for (sl
= specs
; sl
; sl
= sl
->next
)
2209 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2213 fatal ("specs %s spec was not found to be renamed", p1
);
2215 if (strcmp (p1
, p2
) == 0)
2218 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2219 if (strcmp (newsl
->name
, p2
) == 0)
2220 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2225 notice ("rename spec %s to %s\n", p1
, p2
);
2227 notice ("spec is '%s'\n\n", *(sl
->ptr_spec
));
2231 set_spec (p2
, *(sl
->ptr_spec
));
2233 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2235 *(sl
->ptr_spec
) = "";
2240 fatal ("specs unknown %% command after %ld characters",
2241 (long) (p1
- buffer
));
2244 /* Find the colon that should end the suffix. */
2246 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2249 /* The colon shouldn't be missing. */
2251 fatal ("specs file malformed after %ld characters",
2252 (long) (p1
- buffer
));
2254 /* Skip back over trailing whitespace. */
2256 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2259 /* Copy the suffix to a string. */
2260 suffix
= save_string (p
, p2
- p
);
2261 /* Find the next line. */
2262 p
= skip_whitespace (p1
+ 1);
2264 fatal ("specs file malformed after %ld characters",
2265 (long) (p
- buffer
));
2268 /* Find next blank line or end of string. */
2269 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2272 /* Specs end at the blank line and do not include the newline. */
2273 spec
= save_string (p
, p1
- p
);
2276 /* Delete backslash-newline sequences from the spec. */
2281 if (in
[0] == '\\' && in
[1] == '\n')
2283 else if (in
[0] == '#')
2284 while (*in
&& *in
!= '\n')
2292 if (suffix
[0] == '*')
2294 if (! strcmp (suffix
, "*link_command"))
2295 link_command_spec
= spec
;
2297 set_spec (suffix
+ 1, spec
);
2301 /* Add this pair to the vector. */
2303 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2305 compilers
[n_compilers
].suffix
= suffix
;
2306 compilers
[n_compilers
].spec
= spec
;
2308 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2312 link_command_spec
= spec
;
2315 if (link_command_spec
== 0)
2316 fatal ("spec file has no spec for linking");
2319 /* Record the names of temporary files we tell compilers to write,
2320 and delete them at the end of the run. */
2322 /* This is the common prefix we use to make temp file names.
2323 It is chosen once for each run of this program.
2324 It is substituted into a spec by %g or %j.
2325 Thus, all temp file names contain this prefix.
2326 In practice, all temp file names start with this prefix.
2328 This prefix comes from the envvar TMPDIR if it is defined;
2329 otherwise, from the P_tmpdir macro if that is defined;
2330 otherwise, in /usr/tmp or /tmp;
2331 or finally the current directory if all else fails. */
2333 static const char *temp_filename
;
2335 /* Length of the prefix. */
2337 static int temp_filename_length
;
2339 /* Define the list of temporary files to delete. */
2344 struct temp_file
*next
;
2347 /* Queue of files to delete on success or failure of compilation. */
2348 static struct temp_file
*always_delete_queue
;
2349 /* Queue of files to delete on failure of compilation. */
2350 static struct temp_file
*failure_delete_queue
;
2352 /* Record FILENAME as a file to be deleted automatically.
2353 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2354 otherwise delete it in any case.
2355 FAIL_DELETE nonzero means delete it if a compilation step fails;
2356 otherwise delete it in any case. */
2359 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2361 char *const name
= xstrdup (filename
);
2365 struct temp_file
*temp
;
2366 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2367 if (! strcmp (name
, temp
->name
))
2370 temp
= XNEW (struct temp_file
);
2371 temp
->next
= always_delete_queue
;
2373 always_delete_queue
= temp
;
2380 struct temp_file
*temp
;
2381 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2382 if (! strcmp (name
, temp
->name
))
2385 temp
= XNEW (struct temp_file
);
2386 temp
->next
= failure_delete_queue
;
2388 failure_delete_queue
= temp
;
2394 /* Delete all the temporary files whose names we previously recorded. */
2396 #ifndef DELETE_IF_ORDINARY
2397 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2400 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2401 if (unlink (NAME) < 0) \
2403 perror_with_name (NAME); \
2408 delete_if_ordinary (const char *name
)
2414 printf ("Delete %s? (y or n) ", name
);
2418 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2421 if (i
== 'y' || i
== 'Y')
2423 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2427 delete_temp_files (void)
2429 struct temp_file
*temp
;
2431 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2432 delete_if_ordinary (temp
->name
);
2433 always_delete_queue
= 0;
2436 /* Delete all the files to be deleted on error. */
2439 delete_failure_queue (void)
2441 struct temp_file
*temp
;
2443 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2444 delete_if_ordinary (temp
->name
);
2448 clear_failure_queue (void)
2450 failure_delete_queue
= 0;
2453 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2455 If DO_MULTI is true iterate over the paths twice, first with multilib
2456 suffix then without, otherwise iterate over the paths once without
2457 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2458 to avoid visiting the same path twice, but we could do better. For
2459 instance, /usr/lib/../lib is considered different from /usr/lib.
2460 At least EXTRA_SPACE chars past the end of the path passed to
2461 CALLBACK are available for use by the callback.
2462 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2464 Returns the value returned by CALLBACK. */
2467 for_each_path (const struct path_prefix
*paths
,
2470 void *(*callback
) (char *, void *),
2471 void *callback_info
)
2473 struct prefix_list
*pl
;
2474 const char *multi_dir
= NULL
;
2475 const char *multi_os_dir
= NULL
;
2476 const char *multi_suffix
;
2477 const char *just_multi_suffix
;
2480 bool skip_multi_dir
= false;
2481 bool skip_multi_os_dir
= false;
2483 multi_suffix
= machine_suffix
;
2484 just_multi_suffix
= just_machine_suffix
;
2485 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2487 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2488 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2489 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2491 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2492 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2496 size_t multi_dir_len
= 0;
2497 size_t multi_os_dir_len
= 0;
2499 size_t just_suffix_len
;
2503 multi_dir_len
= strlen (multi_dir
);
2505 multi_os_dir_len
= strlen (multi_os_dir
);
2506 suffix_len
= strlen (multi_suffix
);
2507 just_suffix_len
= strlen (just_multi_suffix
);
2511 len
= paths
->max_len
+ extra_space
+ 1;
2512 if (suffix_len
> multi_os_dir_len
)
2515 len
+= multi_os_dir_len
;
2516 path
= XNEWVEC (char, len
);
2519 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2521 len
= strlen (pl
->prefix
);
2522 memcpy (path
, pl
->prefix
, len
);
2524 /* Look first in MACHINE/VERSION subdirectory. */
2525 if (!skip_multi_dir
)
2527 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2528 ret
= callback (path
, callback_info
);
2533 /* Some paths are tried with just the machine (ie. target)
2534 subdir. This is used for finding as, ld, etc. */
2536 && pl
->require_machine_suffix
== 2)
2538 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2539 ret
= callback (path
, callback_info
);
2544 /* Now try the base path. */
2545 if (!pl
->require_machine_suffix
2546 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2548 const char *this_multi
;
2549 size_t this_multi_len
;
2551 if (pl
->os_multilib
)
2553 this_multi
= multi_os_dir
;
2554 this_multi_len
= multi_os_dir_len
;
2558 this_multi
= multi_dir
;
2559 this_multi_len
= multi_dir_len
;
2563 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2567 ret
= callback (path
, callback_info
);
2575 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2578 /* Run through the paths again, this time without multilibs.
2579 Don't repeat any we have already seen. */
2582 free (CONST_CAST (char *, multi_dir
));
2584 free (CONST_CAST (char *, multi_suffix
));
2585 multi_suffix
= machine_suffix
;
2586 free (CONST_CAST (char *, just_multi_suffix
));
2587 just_multi_suffix
= just_machine_suffix
;
2590 skip_multi_dir
= true;
2593 free (CONST_CAST (char *, multi_os_dir
));
2594 multi_os_dir
= NULL
;
2597 skip_multi_os_dir
= true;
2602 free (CONST_CAST (char *, multi_dir
));
2603 free (CONST_CAST (char *, multi_suffix
));
2604 free (CONST_CAST (char *, just_multi_suffix
));
2607 free (CONST_CAST (char *, multi_os_dir
));
2613 /* Callback for build_search_list. Adds path to obstack being built. */
2615 struct add_to_obstack_info
{
2622 add_to_obstack (char *path
, void *data
)
2624 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2626 if (info
->check_dir
&& !is_directory (path
, false))
2629 if (!info
->first_time
)
2630 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2632 obstack_grow (info
->ob
, path
, strlen (path
));
2634 info
->first_time
= false;
2638 /* Add or change the value of an environment variable, outputting the
2639 change to standard error if in verbose mode. */
2641 xputenv (const char *string
)
2644 notice ("%s\n", string
);
2645 putenv (CONST_CAST (char *, string
));
2648 /* Build a list of search directories from PATHS.
2649 PREFIX is a string to prepend to the list.
2650 If CHECK_DIR_P is true we ensure the directory exists.
2651 If DO_MULTI is true, multilib paths are output first, then
2653 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2654 It is also used by the --print-search-dirs flag. */
2657 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2658 bool check_dir
, bool do_multi
)
2660 struct add_to_obstack_info info
;
2662 info
.ob
= &collect_obstack
;
2663 info
.check_dir
= check_dir
;
2664 info
.first_time
= true;
2666 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2667 obstack_1grow (&collect_obstack
, '=');
2669 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2671 obstack_1grow (&collect_obstack
, '\0');
2672 return XOBFINISH (&collect_obstack
, char *);
2675 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2679 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2682 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2685 /* Check whether NAME can be accessed in MODE. This is like access,
2686 except that it never considers directories to be executable. */
2689 access_check (const char *name
, int mode
)
2695 if (stat (name
, &st
) < 0
2696 || S_ISDIR (st
.st_mode
))
2700 return access (name
, mode
);
2703 /* Callback for find_a_file. Appends the file name to the directory
2704 path. If the resulting file exists in the right mode, return the
2705 full pathname to the file. */
2707 struct file_at_path_info
{
2716 file_at_path (char *path
, void *data
)
2718 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2719 size_t len
= strlen (path
);
2721 memcpy (path
+ len
, info
->name
, info
->name_len
);
2722 len
+= info
->name_len
;
2724 /* Some systems have a suffix for executable files.
2725 So try appending that first. */
2726 if (info
->suffix_len
)
2728 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2729 if (access_check (path
, info
->mode
) == 0)
2734 if (access_check (path
, info
->mode
) == 0)
2740 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2741 access to check permissions. If DO_MULTI is true, search multilib
2742 paths then non-multilib paths, otherwise do not search multilib paths.
2743 Return 0 if not found, otherwise return its name, allocated with malloc. */
2746 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2749 struct file_at_path_info info
;
2751 #ifdef DEFAULT_ASSEMBLER
2752 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2753 return xstrdup (DEFAULT_ASSEMBLER
);
2756 #ifdef DEFAULT_LINKER
2757 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2758 return xstrdup (DEFAULT_LINKER
);
2761 /* Determine the filename to execute (special case for absolute paths). */
2763 if (IS_ABSOLUTE_PATH (name
))
2765 if (access (name
, mode
) == 0)
2766 return xstrdup (name
);
2772 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2773 info
.name_len
= strlen (info
.name
);
2774 info
.suffix_len
= strlen (info
.suffix
);
2777 return (char*) for_each_path (pprefix
, do_multi
,
2778 info
.name_len
+ info
.suffix_len
,
2779 file_at_path
, &info
);
2782 /* Ranking of prefixes in the sort list. -B prefixes are put before
2785 enum path_prefix_priority
2787 PREFIX_PRIORITY_B_OPT
,
2788 PREFIX_PRIORITY_LAST
2791 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2792 order according to PRIORITY. Within each PRIORITY, new entries are
2795 If WARN is nonzero, we will warn if no file is found
2796 through this prefix. WARN should point to an int
2797 which will be set to 1 if this entry is used.
2799 COMPONENT is the value to be passed to update_path.
2801 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2802 the complete value of machine_suffix.
2803 2 means try both machine_suffix and just_machine_suffix. */
2806 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2807 const char *component
, /* enum prefix_priority */ int priority
,
2808 int require_machine_suffix
, int os_multilib
)
2810 struct prefix_list
*pl
, **prev
;
2813 for (prev
= &pprefix
->plist
;
2814 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2815 prev
= &(*prev
)->next
)
2818 /* Keep track of the longest prefix. */
2820 prefix
= update_path (prefix
, component
);
2821 len
= strlen (prefix
);
2822 if (len
> pprefix
->max_len
)
2823 pprefix
->max_len
= len
;
2825 pl
= XNEW (struct prefix_list
);
2826 pl
->prefix
= prefix
;
2827 pl
->require_machine_suffix
= require_machine_suffix
;
2828 pl
->priority
= priority
;
2829 pl
->os_multilib
= os_multilib
;
2831 /* Insert after PREV. */
2836 /* Same as add_prefix, but prepending target_system_root to prefix. */
2837 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2839 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2840 const char *component
,
2841 /* enum prefix_priority */ int priority
,
2842 int require_machine_suffix
, int os_multilib
)
2844 if (!IS_ABSOLUTE_PATH (prefix
))
2845 fatal ("system path '%s' is not absolute", prefix
);
2847 if (target_system_root
)
2849 if (target_sysroot_suffix
)
2850 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2851 prefix
= concat (target_system_root
, prefix
, NULL
);
2853 /* We have to override this because GCC's notion of sysroot
2854 moves along with GCC. */
2858 add_prefix (pprefix
, prefix
, component
, priority
,
2859 require_machine_suffix
, os_multilib
);
2862 /* Execute the command specified by the arguments on the current line of spec.
2863 When using pipes, this includes several piped-together commands
2864 with `|' between them.
2866 Return 0 if successful, -1 if failed. */
2872 int n_commands
; /* # of command. */
2874 struct pex_obj
*pex
;
2877 const char *prog
; /* program name. */
2878 const char **argv
; /* vector of args. */
2881 struct command
*commands
; /* each command buffer with above info. */
2883 gcc_assert (!processing_spec_function
);
2887 string
= find_a_file (&exec_prefixes
, argbuf
[0], X_OK
, false);
2888 argbuf
[0] = (string
) ? string
: argbuf
[0];
2889 insert_wrapper (wrapper_string
);
2892 /* Count # of piped commands. */
2893 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2894 if (strcmp (argbuf
[i
], "|") == 0)
2897 /* Get storage for each command. */
2898 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2900 /* Split argbuf into its separate piped processes,
2901 and record info about each one.
2902 Also search for the programs that are to be run. */
2904 commands
[0].prog
= argbuf
[0]; /* first command. */
2905 commands
[0].argv
= &argbuf
[0];
2907 if (!wrapper_string
)
2909 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2910 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2913 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2914 if (strcmp (argbuf
[i
], "|") == 0)
2915 { /* each command. */
2916 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2917 fatal ("-pipe not supported");
2919 argbuf
[i
] = 0; /* termination of command args. */
2920 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2921 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2922 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2925 commands
[n_commands
].argv
[0] = string
;
2929 argbuf
[argbuf_index
] = 0;
2931 /* If -v, print what we are about to do, and maybe query. */
2935 /* For help listings, put a blank line between sub-processes. */
2936 if (print_help_list
)
2937 fputc ('\n', stderr
);
2939 /* Print each piped command as a separate line. */
2940 for (i
= 0; i
< n_commands
; i
++)
2942 const char *const *j
;
2944 if (verbose_only_flag
)
2946 for (j
= commands
[i
].argv
; *j
; j
++)
2949 fprintf (stderr
, " \"");
2950 for (p
= *j
; *p
; ++p
)
2952 if (*p
== '"' || *p
== '\\' || *p
== '$')
2953 fputc ('\\', stderr
);
2956 fputc ('"', stderr
);
2960 for (j
= commands
[i
].argv
; *j
; j
++)
2961 fprintf (stderr
, " %s", *j
);
2963 /* Print a pipe symbol after all but the last command. */
2964 if (i
+ 1 != n_commands
)
2965 fprintf (stderr
, " |");
2966 fprintf (stderr
, "\n");
2969 if (verbose_only_flag
!= 0)
2971 /* verbose_only_flag should act as if the spec was
2972 executed, so increment execution_count before
2973 returning. This prevents spurious warnings about
2974 unused linker input files, etc. */
2979 notice ("\nGo ahead? (y or n) ");
2983 while (getchar () != '\n')
2986 if (i
!= 'y' && i
!= 'Y')
2991 #ifdef ENABLE_VALGRIND_CHECKING
2992 /* Run the each command through valgrind. To simplify prepending the
2993 path to valgrind and the option "-q" (for quiet operation unless
2994 something triggers), we allocate a separate argv array. */
2996 for (i
= 0; i
< n_commands
; i
++)
3002 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3005 argv
= XALLOCAVEC (const char *, argc
+ 3);
3007 argv
[0] = VALGRIND_PATH
;
3009 for (j
= 2; j
< argc
+ 2; j
++)
3010 argv
[j
] = commands
[i
].argv
[j
- 2];
3013 commands
[i
].argv
= argv
;
3014 commands
[i
].prog
= argv
[0];
3018 /* Run each piped subprocess. */
3020 pex
= pex_init (PEX_USE_PIPES
| (report_times
? PEX_RECORD_TIMES
: 0),
3021 programname
, temp_filename
);
3023 pfatal_with_name (_("pex_init failed"));
3025 for (i
= 0; i
< n_commands
; i
++)
3029 const char *string
= commands
[i
].argv
[0];
3031 errmsg
= pex_run (pex
,
3032 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3033 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3034 string
, CONST_CAST (char **, commands
[i
].argv
),
3043 pfatal_with_name (errmsg
);
3047 if (string
!= commands
[i
].prog
)
3048 free (CONST_CAST (char *, string
));
3053 /* Wait for all the subprocesses to finish. */
3057 struct pex_time
*times
= NULL
;
3060 statuses
= (int *) alloca (n_commands
* sizeof (int));
3061 if (!pex_get_status (pex
, n_commands
, statuses
))
3062 pfatal_with_name (_("failed to get exit status"));
3066 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3067 if (!pex_get_times (pex
, n_commands
, times
))
3068 pfatal_with_name (_("failed to get process times"));
3073 for (i
= 0; i
< n_commands
; ++i
)
3075 int status
= statuses
[i
];
3077 if (WIFSIGNALED (status
))
3080 /* SIGPIPE is a special case. It happens in -pipe mode
3081 when the compiler dies before the preprocessor is done,
3082 or the assembler dies before the compiler is done.
3083 There's generally been an error already, and this is
3084 just fallout. So don't generate another error unless
3085 we would otherwise have succeeded. */
3086 if (WTERMSIG (status
) == SIGPIPE
3087 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3095 Internal error: %s (program %s)\n\
3096 Please submit a full bug report.\n\
3097 See %s for instructions.",
3098 strsignal (WTERMSIG (status
)), commands
[i
].prog
,
3101 else if (WIFEXITED (status
)
3102 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3104 if (WEXITSTATUS (status
) > greatest_status
)
3105 greatest_status
= WEXITSTATUS (status
);
3111 struct pex_time
*pt
= ×
[i
];
3114 ut
= ((double) pt
->user_seconds
3115 + (double) pt
->user_microseconds
/ 1.0e6
);
3116 st
= ((double) pt
->system_seconds
3117 + (double) pt
->system_microseconds
/ 1.0e6
);
3120 notice ("# %s %.2f %.2f\n", commands
[i
].prog
, ut
, st
);
3128 /* Find all the switches given to us
3129 and make a vector describing them.
3130 The elements of the vector are strings, one per switch given.
3131 If a switch uses following arguments, then the `part1' field
3132 is the switch itself and the `args' field
3133 is a null-terminated vector containing the following arguments.
3134 Bits in the `live_cond' field are:
3135 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3136 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3137 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3138 The `validated' field is nonzero if any spec has looked at this switch;
3139 if it remains zero at the end of the run, it must be meaningless. */
3141 #define SWITCH_LIVE 0x1
3142 #define SWITCH_FALSE 0x2
3143 #define SWITCH_IGNORE 0x4
3149 unsigned int live_cond
;
3150 unsigned char validated
;
3151 unsigned char ordering
;
3154 static struct switchstr
*switches
;
3156 static int n_switches
;
3158 /* Language is one of three things:
3160 1) The name of a real programming language.
3161 2) NULL, indicating that no one has figured out
3163 3) '*', indicating that the file should be passed
3168 const char *language
;
3169 struct compiler
*incompiler
;
3174 /* Also a vector of input files specified. */
3176 static struct infile
*infiles
;
3180 /* True if multiple input files are being compiled to a single
3183 static bool combine_inputs
;
3185 /* This counts the number of libraries added by lang_specific_driver, so that
3186 we can tell if there were any user supplied any files or libraries. */
3188 static int added_libraries
;
3190 /* And a vector of corresponding output files is made up later. */
3192 const char **outfiles
;
3194 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3196 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3197 is true if we should look for an executable suffix. DO_OBJ
3198 is true if we should look for an object suffix. */
3201 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3202 int do_obj ATTRIBUTE_UNUSED
)
3204 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3212 len
= strlen (name
);
3214 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3215 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3216 if (do_obj
&& len
> 2
3217 && name
[len
- 2] == '.'
3218 && name
[len
- 1] == 'o')
3220 obstack_grow (&obstack
, name
, len
- 2);
3221 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3222 name
= XOBFINISH (&obstack
, const char *);
3226 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3227 /* If there is no filetype, make it the executable suffix (which includes
3228 the "."). But don't get confused if we have just "-o". */
3229 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3232 for (i
= len
- 1; i
>= 0; i
--)
3233 if (IS_DIR_SEPARATOR (name
[i
]))
3236 for (i
++; i
< len
; i
++)
3240 obstack_grow (&obstack
, name
, len
);
3241 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3242 strlen (TARGET_EXECUTABLE_SUFFIX
));
3243 name
= XOBFINISH (&obstack
, const char *);
3250 /* Display the command line switches accepted by gcc. */
3254 printf (_("Usage: %s [options] file...\n"), programname
);
3255 fputs (_("Options:\n"), stdout
);
3257 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3258 fputs (_(" --help Display this information\n"), stdout
);
3259 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3260 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3261 fputs (_(" Display specific types of command line options\n"), stdout
);
3263 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3264 fputs (_(" --version Display compiler version information\n"), stdout
);
3265 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3266 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3267 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3268 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3269 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3270 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3271 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3272 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3274 -print-multi-lib Display the mapping between command line options and\n\
3275 multiple library search directories\n"), stdout
);
3276 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3277 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3278 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3279 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3280 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3281 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3282 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3283 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3284 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3285 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout
);
3286 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3287 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3288 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3289 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3290 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3291 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3293 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3294 and libraries\n"), stdout
);
3295 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3296 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout
);
3297 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout
);
3298 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3299 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3300 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3301 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3302 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3303 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3305 -x <language> Specify the language of the following input files\n\
3306 Permissible languages include: c c++ assembler none\n\
3307 'none' means revert to the default behavior of\n\
3308 guessing the language based on the file's extension\n\
3312 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3313 passed on to the various sub-processes invoked by %s. In order to pass\n\
3314 other options on to these processes the -W<letter> options must be used.\n\
3317 /* The rest of the options are displayed by invocations of the various
3322 add_preprocessor_option (const char *option
, int len
)
3324 n_preprocessor_options
++;
3326 if (! preprocessor_options
)
3327 preprocessor_options
= XNEWVEC (char *, n_preprocessor_options
);
3329 preprocessor_options
= XRESIZEVEC (char *, preprocessor_options
,
3330 n_preprocessor_options
);
3332 preprocessor_options
[n_preprocessor_options
- 1] =
3333 save_string (option
, len
);
3337 add_assembler_option (const char *option
, int len
)
3339 n_assembler_options
++;
3341 if (! assembler_options
)
3342 assembler_options
= XNEWVEC (char *, n_assembler_options
);
3344 assembler_options
= XRESIZEVEC (char *, assembler_options
,
3345 n_assembler_options
);
3347 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3351 add_linker_option (const char *option
, int len
)
3355 if (! linker_options
)
3356 linker_options
= XNEWVEC (char *, n_linker_options
);
3358 linker_options
= XRESIZEVEC (char *, linker_options
, n_linker_options
);
3360 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3363 /* Create the vector `switches' and its contents.
3364 Store its length in `n_switches'. */
3367 process_command (int argc
, const char **argv
)
3372 const char *spec_lang
= 0;
3373 int last_language_n_infiles
;
3374 int lang_n_infiles
= 0;
3375 #ifdef MODIFY_TARGET_NAME
3376 int is_modify_target_name
;
3379 const char *tooldir_prefix
;
3381 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3385 added_libraries
= 0;
3387 /* Figure compiler version from version string. */
3389 compiler_version
= temp1
= xstrdup (version_string
);
3391 for (; *temp1
; ++temp1
)
3400 /* If there is a -V or -b option (or both), process it now, before
3401 trying to interpret the rest of the command line.
3402 Use heuristic that all configuration names must have at least
3403 one dash '-'. This allows us to pass options starting with -b. */
3404 if (argc
> 1 && argv
[1][0] == '-'
3405 && (argv
[1][1] == 'V'
3406 || (argv
[1][1] == 'b'
3407 && (argv
[1][2] == '\0'
3408 || NULL
!= strchr (argv
[1] + 2, '-')))))
3410 const char *new_version
= DEFAULT_TARGET_VERSION
;
3411 const char *new_machine
= DEFAULT_TARGET_MACHINE
;
3412 const char *progname
= argv
[0];
3420 while (argc
> 1 && argv
[1][0] == '-'
3421 && (argv
[1][1] == 'V'
3422 || (argv
[1][1] == 'b'
3423 && (argv
[1][2] == '\0'
3424 || NULL
!= strchr (argv
[1] + 2, '-')))))
3426 char opt
= argv
[1][1];
3428 if (argv
[1][2] != '\0')
3441 fatal ("'-%c' option must have argument", opt
);
3448 for (baselen
= strlen (progname
); baselen
> 0; baselen
--)
3449 if (IS_DIR_SEPARATOR (progname
[baselen
-1]))
3451 new_argv0
= XDUPVAR (char, progname
, baselen
,
3452 baselen
+ concat_length (new_version
, new_machine
,
3453 "-gcc-", NULL
) + 1);
3454 strcpy (new_argv0
+ baselen
, new_machine
);
3455 strcat (new_argv0
, "-gcc-");
3456 strcat (new_argv0
, new_version
);
3458 new_argv
= XDUPVEC (char *, argv
, argc
+ 1);
3459 new_argv
[0] = new_argv0
;
3461 errmsg
= pex_one (PEX_SEARCH
, new_argv0
, new_argv
, progname
, NULL
,
3462 NULL
, &status
, &err
);
3467 fatal ("couldn't run '%s': %s", new_argv0
, errmsg
);
3469 fatal ("couldn't run '%s': %s: %s", new_argv0
, errmsg
,
3475 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3476 see if we can create it from the pathname specified in argv[0]. */
3478 gcc_libexec_prefix
= standard_libexec_prefix
;
3480 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3481 if (!gcc_exec_prefix
)
3483 gcc_exec_prefix
= make_relative_prefix (argv
[0], standard_bindir_prefix
,
3484 standard_exec_prefix
);
3485 gcc_libexec_prefix
= make_relative_prefix (argv
[0],
3486 standard_bindir_prefix
,
3487 standard_libexec_prefix
);
3488 if (gcc_exec_prefix
)
3489 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3493 /* make_relative_prefix requires a program name, but
3494 GCC_EXEC_PREFIX is typically a directory name with a trailing
3495 / (which is ignored by make_relative_prefix), so append a
3497 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3498 gcc_libexec_prefix
= make_relative_prefix (tmp_prefix
,
3499 standard_exec_prefix
,
3500 standard_libexec_prefix
);
3502 /* The path is unrelocated, so fallback to the original setting. */
3503 if (!gcc_libexec_prefix
)
3504 gcc_libexec_prefix
= standard_libexec_prefix
;
3510 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3511 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3512 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3514 if (gcc_exec_prefix
)
3516 int len
= strlen (gcc_exec_prefix
);
3518 if (len
> (int) sizeof ("/lib/gcc/") - 1
3519 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3521 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3522 if (IS_DIR_SEPARATOR (*temp
)
3523 && strncmp (temp
+ 1, "lib", 3) == 0
3524 && IS_DIR_SEPARATOR (temp
[4])
3525 && strncmp (temp
+ 5, "gcc", 3) == 0)
3526 len
-= sizeof ("/lib/gcc/") - 1;
3529 set_std_prefix (gcc_exec_prefix
, len
);
3530 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3531 PREFIX_PRIORITY_LAST
, 0, 0);
3532 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3533 PREFIX_PRIORITY_LAST
, 0, 0);
3536 /* COMPILER_PATH and LIBRARY_PATH have values
3537 that are lists of directory names with colons. */
3539 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3542 const char *startp
, *endp
;
3543 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3545 startp
= endp
= temp
;
3548 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3550 strncpy (nstore
, startp
, endp
- startp
);
3552 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3553 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3555 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3556 nstore
[endp
- startp
+ 1] = 0;
3559 nstore
[endp
- startp
] = 0;
3560 add_prefix (&exec_prefixes
, nstore
, 0,
3561 PREFIX_PRIORITY_LAST
, 0, 0);
3562 add_prefix (&include_prefixes
, nstore
, 0,
3563 PREFIX_PRIORITY_LAST
, 0, 0);
3566 endp
= startp
= endp
+ 1;
3573 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3574 if (temp
&& *cross_compile
== '0')
3576 const char *startp
, *endp
;
3577 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3579 startp
= endp
= temp
;
3582 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3584 strncpy (nstore
, startp
, endp
- startp
);
3586 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3587 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3589 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3590 nstore
[endp
- startp
+ 1] = 0;
3593 nstore
[endp
- startp
] = 0;
3594 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3595 PREFIX_PRIORITY_LAST
, 0, 1);
3598 endp
= startp
= endp
+ 1;
3605 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3606 GET_ENVIRONMENT (temp
, "LPATH");
3607 if (temp
&& *cross_compile
== '0')
3609 const char *startp
, *endp
;
3610 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3612 startp
= endp
= temp
;
3615 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3617 strncpy (nstore
, startp
, endp
- startp
);
3619 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3620 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3622 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3623 nstore
[endp
- startp
+ 1] = 0;
3626 nstore
[endp
- startp
] = 0;
3627 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3628 PREFIX_PRIORITY_LAST
, 0, 1);
3631 endp
= startp
= endp
+ 1;
3638 /* Convert new-style -- options to old-style. */
3639 translate_options (&argc
, (const char *const **) &argv
);
3641 /* Do language-specific adjustment/addition of flags. */
3642 lang_specific_driver (&argc
, (const char *const **) &argv
, &added_libraries
);
3644 /* Scan argv twice. Here, the first time, just count how many switches
3645 there will be in their vector, and how many input files in theirs.
3646 Here we also parse the switches that cc itself uses (e.g. -v). */
3648 for (i
= 1; i
< argc
; i
++)
3650 if (! strcmp (argv
[i
], "-dumpspecs"))
3652 struct spec_list
*sl
;
3654 for (sl
= specs
; sl
; sl
= sl
->next
)
3655 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3656 if (link_command_spec
)
3657 printf ("*link_command:\n%s\n\n", link_command_spec
);
3660 else if (! strcmp (argv
[i
], "-dumpversion"))
3662 printf ("%s\n", spec_version
);
3665 else if (! strcmp (argv
[i
], "-dumpmachine"))
3667 printf ("%s\n", spec_machine
);
3670 else if (strcmp (argv
[i
], "-fversion") == 0)
3672 /* translate_options () has turned --version into -fversion. */
3675 /* We will be passing a dummy file on to the sub-processes. */
3679 /* CPP driver cannot obtain switch from cc1_options. */
3681 add_preprocessor_option ("--version", strlen ("--version"));
3682 add_assembler_option ("--version", strlen ("--version"));
3683 add_linker_option ("--version", strlen ("--version"));
3685 else if (strcmp (argv
[i
], "-fhelp") == 0)
3687 /* translate_options () has turned --help into -fhelp. */
3688 print_help_list
= 1;
3690 /* We will be passing a dummy file on to the sub-processes. */
3694 /* CPP driver cannot obtain switch from cc1_options. */
3696 add_preprocessor_option ("--help", 6);
3697 add_assembler_option ("--help", 6);
3698 add_linker_option ("--help", 6);
3700 else if (strncmp (argv
[i
], "-fhelp=", 7) == 0)
3702 /* translate_options () has turned --help into -fhelp. */
3703 print_subprocess_help
= 2;
3705 /* We will be passing a dummy file on to the sub-processes. */
3709 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3711 /* translate_options() has turned --target-help into -ftarget-help. */
3712 print_subprocess_help
= 1;
3714 /* We will be passing a dummy file on to the sub-processes. */
3718 /* CPP driver cannot obtain switch from cc1_options. */
3720 add_preprocessor_option ("--target-help", 13);
3721 add_assembler_option ("--target-help", 13);
3722 add_linker_option ("--target-help", 13);
3724 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3726 pass_exit_codes
= 1;
3729 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3730 print_search_dirs
= 1;
3731 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3732 print_file_name
= "libgcc.a";
3733 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3734 print_file_name
= argv
[i
] + 17;
3735 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3736 print_prog_name
= argv
[i
] + 17;
3737 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3738 print_multi_lib
= 1;
3739 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3740 print_multi_directory
= 1;
3741 else if (! strcmp (argv
[i
], "-print-sysroot"))
3743 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3744 print_multi_os_directory
= 1;
3745 else if (! strcmp (argv
[i
], "-print-sysroot-headers-suffix"))
3746 print_sysroot_headers_suffix
= 1;
3747 else if (! strncmp (argv
[i
], "-Wa,", 4))
3750 /* Pass the rest of this option to the assembler. */
3752 /* Split the argument at commas. */
3754 for (j
= 4; argv
[i
][j
]; j
++)
3755 if (argv
[i
][j
] == ',')
3757 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3761 /* Record the part after the last comma. */
3762 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3764 else if (! strncmp (argv
[i
], "-Wp,", 4))
3767 /* Pass the rest of this option to the preprocessor. */
3769 /* Split the argument at commas. */
3771 for (j
= 4; argv
[i
][j
]; j
++)
3772 if (argv
[i
][j
] == ',')
3774 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3778 /* Record the part after the last comma. */
3779 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3781 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3782 /* The +e options to the C++ front-end. */
3784 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3787 /* Split the argument at commas. */
3788 for (j
= 3; argv
[i
][j
]; j
++)
3789 n_infiles
+= (argv
[i
][j
] == ',');
3791 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3794 fatal ("argument to '-Xlinker' is missing");
3799 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3802 fatal ("argument to '-Xpreprocessor' is missing");
3804 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3806 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3809 fatal ("argument to '-Xassembler' is missing");
3811 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3813 else if (strcmp (argv
[i
], "-l") == 0)
3816 fatal ("argument to '-l' is missing");
3821 else if (strncmp (argv
[i
], "-l", 2) == 0)
3823 else if (strcmp (argv
[i
], "-save-temps") == 0)
3825 save_temps_flag
= SAVE_TEMPS_CWD
;
3828 else if (strncmp (argv
[i
], "-save-temps=", 12) == 0)
3831 if (strcmp (argv
[i
]+12, "cwd") == 0)
3832 save_temps_flag
= SAVE_TEMPS_CWD
;
3833 else if (strcmp (argv
[i
]+12, "obj") == 0
3834 || strcmp (argv
[i
]+12, "object") == 0)
3835 save_temps_flag
= SAVE_TEMPS_OBJ
;
3837 fatal ("'%s' is an unknown -save-temps option", argv
[i
]);
3839 else if (strcmp (argv
[i
], "-combine") == 0)
3844 else if (strcmp (argv
[i
], "-specs") == 0)
3846 struct user_specs
*user
= XNEW (struct user_specs
);
3848 fatal ("argument to '-specs' is missing");
3850 user
->next
= (struct user_specs
*) 0;
3851 user
->filename
= argv
[i
];
3852 if (user_specs_tail
)
3853 user_specs_tail
->next
= user
;
3855 user_specs_head
= user
;
3856 user_specs_tail
= user
;
3858 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3860 struct user_specs
*user
= XNEW (struct user_specs
);
3861 if (strlen (argv
[i
]) == 7)
3862 fatal ("argument to '-specs=' is missing");
3864 user
->next
= (struct user_specs
*) 0;
3865 user
->filename
= argv
[i
] + 7;
3866 if (user_specs_tail
)
3867 user_specs_tail
->next
= user
;
3869 user_specs_head
= user
;
3870 user_specs_tail
= user
;
3872 else if (strcmp (argv
[i
], "-time") == 0)
3874 else if (strcmp (argv
[i
], "-pipe") == 0)
3876 /* -pipe has to go into the switches array as well as
3881 else if (strcmp (argv
[i
], "-wrapper") == 0)
3884 fatal ("argument to '-wrapper' is missing");
3886 wrapper_string
= argv
[i
];
3890 else if (strcmp (argv
[i
], "-###") == 0)
3892 /* This is similar to -v except that there is no execution
3893 of the commands and the echoed arguments are quoted. It
3894 is intended for use in shell scripts to capture the
3895 driver-generated command line. */
3896 verbose_only_flag
++;
3899 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3901 const char *p
= &argv
[i
][1];
3907 if (p
[1] && NULL
== strchr (argv
[i
] + 2, '-'))
3912 fatal ("'-%c' must come at the start of the command line", c
);
3920 if (p
[1] == 0 && i
+ 1 == argc
)
3921 fatal ("argument to '-B' is missing");
3927 len
= strlen (value
);
3929 /* Catch the case where the user has forgotten to append a
3930 directory separator to the path. Note, they may be using
3931 -B to add an executable name prefix, eg "i386-elf-", in
3932 order to distinguish between multiple installations of
3933 GCC in the same directory. Hence we must check to see
3934 if appending a directory separator actually makes a
3935 valid directory name. */
3936 if (! IS_DIR_SEPARATOR (value
[len
- 1])
3937 && is_directory (value
, false))
3939 char *tmp
= XNEWVEC (char, len
+ 2);
3940 strcpy (tmp
, value
);
3941 tmp
[len
] = DIR_SEPARATOR
;
3946 add_prefix (&exec_prefixes
, value
, NULL
,
3947 PREFIX_PRIORITY_B_OPT
, 0, 0);
3948 add_prefix (&startfile_prefixes
, value
, NULL
,
3949 PREFIX_PRIORITY_B_OPT
, 0, 0);
3950 add_prefix (&include_prefixes
, value
, NULL
,
3951 PREFIX_PRIORITY_B_OPT
, 0, 0);
3956 case 'v': /* Print our subcommands and print versions. */
3958 /* If they do anything other than exactly `-v', don't set
3959 verbose_flag; rather, continue on to give the error. */
3977 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3982 /* Forward scan, just in case -S or -c is specified
3989 if (argv
[j
][0] == '-')
3991 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
3997 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
3998 j
+= skip
- (argv
[j
][2] != 0);
3999 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
4006 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4008 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
4010 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
4012 /* Save the output name in case -save-temps=obj was used. */
4013 save_temps_prefix
= xstrdup ((p
[1] == 0) ? argv
[i
+ 1] : argv
[i
] + 1);
4019 #ifdef MODIFY_TARGET_NAME
4020 is_modify_target_name
= 0;
4022 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
4023 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
4025 char *new_name
= XNEWVEC (char, strlen (modify_target
[j
].str
)
4026 + strlen (spec_machine
));
4029 int made_addition
= 0;
4031 is_modify_target_name
= 1;
4032 for (p
= spec_machine
, q
= new_name
; *p
!= 0; )
4034 if (modify_target
[j
].add_del
== DELETE
4035 && (! strncmp (q
, modify_target
[j
].str
,
4036 strlen (modify_target
[j
].str
))))
4037 p
+= strlen (modify_target
[j
].str
);
4038 else if (modify_target
[j
].add_del
== ADD
4039 && ! made_addition
&& *p
== '-')
4041 for (r
= modify_target
[j
].str
; *r
!= 0; )
4049 spec_machine
= new_name
;
4052 if (is_modify_target_name
)
4058 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4059 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4060 else if (WORD_SWITCH_TAKES_ARG (p
))
4061 i
+= WORD_SWITCH_TAKES_ARG (p
);
4071 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4072 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4073 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4075 save_temps_length
= strlen (save_temps_prefix
);
4076 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4079 save_temps_length
-= strlen (temp
);
4080 save_temps_prefix
[save_temps_length
] = '\0';
4084 else if (save_temps_prefix
!= NULL
)
4086 free (save_temps_prefix
);
4087 save_temps_prefix
= NULL
;
4090 if (save_temps_flag
&& use_pipes
)
4092 /* -save-temps overrides -pipe, so that temp files are produced */
4093 if (save_temps_flag
)
4094 error ("warning: -pipe ignored because -save-temps specified");
4098 /* Set up the search paths. We add directories that we expect to
4099 contain GNU Toolchain components before directories specified by
4100 the machine description so that we will find GNU components (like
4101 the GNU assembler) before those of the host system. */
4103 /* If we don't know where the toolchain has been installed, use the
4104 configured-in locations. */
4105 if (!gcc_exec_prefix
)
4108 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4109 PREFIX_PRIORITY_LAST
, 1, 0);
4110 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4111 PREFIX_PRIORITY_LAST
, 2, 0);
4112 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4113 PREFIX_PRIORITY_LAST
, 2, 0);
4115 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4116 PREFIX_PRIORITY_LAST
, 1, 0);
4119 /* If not cross-compiling, search well-known system locations. */
4120 if (*cross_compile
== '0')
4123 add_prefix (&exec_prefixes
, standard_exec_prefix_1
, "BINUTILS",
4124 PREFIX_PRIORITY_LAST
, 2, 0);
4125 add_prefix (&exec_prefixes
, standard_exec_prefix_2
, "BINUTILS",
4126 PREFIX_PRIORITY_LAST
, 2, 0);
4128 add_prefix (&startfile_prefixes
, standard_exec_prefix_2
, "BINUTILS",
4129 PREFIX_PRIORITY_LAST
, 1, 0);
4132 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4133 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
4134 dir_separator_str
, NULL
);
4136 /* Look for tools relative to the location from which the driver is
4137 running, or, if that is not available, the configured prefix. */
4139 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4140 spec_machine
, dir_separator_str
,
4141 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
4143 add_prefix (&exec_prefixes
,
4144 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4145 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4146 add_prefix (&startfile_prefixes
,
4147 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4148 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4150 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4151 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4152 then consider it to relocate with the rest of the GCC installation
4153 if GCC_EXEC_PREFIX is set.
4154 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4155 if (target_system_root
&& gcc_exec_prefix
)
4157 char *tmp_prefix
= make_relative_prefix (argv
[0],
4158 standard_bindir_prefix
,
4159 target_system_root
);
4160 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4162 target_system_root
= tmp_prefix
;
4163 target_system_root_changed
= 1;
4168 /* More prefixes are enabled in main, after we read the specs file
4169 and determine whether this is cross-compilation or not. */
4171 /* Then create the space for the vectors and scan again. */
4173 switches
= XNEWVEC (struct switchstr
, n_switches
+ 1);
4174 infiles
= XNEWVEC (struct infile
, n_infiles
+ 1);
4177 last_language_n_infiles
= -1;
4179 /* This, time, copy the text of each switch and store a pointer
4180 to the copy in the vector of switches.
4181 Store all the infiles in their vector. */
4183 for (i
= 1; i
< argc
; i
++)
4185 /* Just skip the switches that were handled by the preceding loop. */
4186 #ifdef MODIFY_TARGET_NAME
4187 is_modify_target_name
= 0;
4189 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
4190 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
4191 is_modify_target_name
= 1;
4193 if (is_modify_target_name
)
4197 if (! strncmp (argv
[i
], "-Wa,", 4))
4199 else if (! strncmp (argv
[i
], "-Wp,", 4))
4201 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
4203 else if (! strcmp (argv
[i
], "-print-search-dirs"))
4205 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
4207 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
4209 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
4211 else if (! strcmp (argv
[i
], "-print-multi-lib"))
4213 else if (! strcmp (argv
[i
], "-print-multi-directory"))
4215 else if (! strcmp (argv
[i
], "-print-sysroot"))
4217 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
4219 else if (! strcmp (argv
[i
], "-print-sysroot-headers-suffix"))
4221 else if (! strncmp (argv
[i
], "--sysroot=", strlen ("--sysroot=")))
4223 target_system_root
= argv
[i
] + strlen ("--sysroot=");
4224 target_system_root_changed
= 1;
4226 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
4228 /* Compensate for the +e options to the C++ front-end;
4229 they're there simply for cfront call-compatibility. We do
4230 some magic in default_compilers to pass them down properly.
4231 Note we deliberately start at the `+' here, to avoid passing
4232 -e0 or -e1 down into the linker. */
4233 switches
[n_switches
].part1
= &argv
[i
][0];
4234 switches
[n_switches
].args
= 0;
4235 switches
[n_switches
].live_cond
= 0;
4236 switches
[n_switches
].validated
= 0;
4239 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
4242 /* Split the argument at commas. */
4244 for (j
= 4; argv
[i
][j
]; j
++)
4245 if (argv
[i
][j
] == ',')
4247 infiles
[n_infiles
].language
= "*";
4248 infiles
[n_infiles
++].name
4249 = save_string (argv
[i
] + prev
, j
- prev
);
4252 /* Record the part after the last comma. */
4253 infiles
[n_infiles
].language
= "*";
4254 infiles
[n_infiles
++].name
= argv
[i
] + prev
;
4256 else if (strcmp (argv
[i
], "-Xlinker") == 0)
4258 infiles
[n_infiles
].language
= "*";
4259 infiles
[n_infiles
++].name
= argv
[++i
];
4261 /* Xassembler and Xpreprocessor were already handled in the first argv
4262 scan, so all we need to do here is ignore them and their argument. */
4263 else if (strcmp (argv
[i
], "-Xassembler") == 0)
4265 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
4267 else if (strcmp (argv
[i
], "-l") == 0)
4268 { /* POSIX allows separation of -l and the lib arg;
4269 canonicalize by concatenating -l with its arg */
4270 infiles
[n_infiles
].language
= "*";
4271 infiles
[n_infiles
++].name
= concat ("-l", argv
[++i
], NULL
);
4273 else if (strncmp (argv
[i
], "-l", 2) == 0)
4275 infiles
[n_infiles
].language
= "*";
4276 infiles
[n_infiles
++].name
= argv
[i
];
4278 else if (strcmp (argv
[i
], "-wrapper") == 0)
4280 else if (strcmp (argv
[i
], "-specs") == 0)
4282 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
4284 else if (strcmp (argv
[i
], "-time") == 0)
4286 else if (strcmp (argv
[i
], "-###") == 0)
4288 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
4290 const char *p
= &argv
[i
][1];
4295 if (p
[1] == 0 && i
+ 1 == argc
)
4296 fatal ("argument to '-x' is missing");
4298 spec_lang
= argv
[++i
];
4301 if (! strcmp (spec_lang
, "none"))
4302 /* Suppress the warning if -xnone comes after the last input
4303 file, because alternate command interfaces like g++ might
4304 find it useful to place -xnone after each input file. */
4307 last_language_n_infiles
= n_infiles
;
4310 switches
[n_switches
].part1
= p
;
4311 /* Deal with option arguments in separate argv elements. */
4312 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4313 || WORD_SWITCH_TAKES_ARG (p
))
4316 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4320 /* Count only the option arguments in separate argv elements. */
4321 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4323 if (i
+ n_args
>= argc
)
4324 fatal ("argument to '-%s' is missing", p
);
4325 switches
[n_switches
].args
4326 = XNEWVEC (const char *, n_args
+ 1);
4328 switches
[n_switches
].args
[j
++] = argv
[++i
];
4329 /* Null-terminate the vector. */
4330 switches
[n_switches
].args
[j
] = 0;
4332 else if (strchr (switches_need_spaces
, c
))
4334 /* On some systems, ld cannot handle some options without
4335 a space. So split the option from its argument. */
4336 char *part1
= XNEWVEC (char, 2);
4340 switches
[n_switches
].part1
= part1
;
4341 switches
[n_switches
].args
= XNEWVEC (const char *, 2);
4342 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4343 switches
[n_switches
].args
[1] = 0;
4346 switches
[n_switches
].args
= 0;
4348 switches
[n_switches
].live_cond
= 0;
4349 switches
[n_switches
].validated
= 0;
4350 switches
[n_switches
].ordering
= 0;
4351 /* These are always valid, since gcc.c itself understands the
4352 first four and gfortranspec.c understands -static-libgfortran. */
4353 if (!strcmp (p
, "save-temps")
4354 || !strcmp (p
, "static-libgcc")
4355 || !strcmp (p
, "shared-libgcc")
4356 || !strcmp (p
, "pipe")
4357 || !strcmp (p
, "static-libgfortran"))
4358 switches
[n_switches
].validated
= 1;
4361 char ch
= switches
[n_switches
].part1
[0];
4363 switches
[n_switches
].validated
= 1;
4369 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4370 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4373 if (strcmp (argv
[i
], "-") != 0 && access (argv
[i
], F_OK
) < 0)
4375 perror_with_name (argv
[i
]);
4380 infiles
[n_infiles
].language
= spec_lang
;
4381 infiles
[n_infiles
++].name
= argv
[i
];
4386 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4387 error ("warning: '-x %s' after last input file has no effect", spec_lang
);
4389 /* Ensure we only invoke each subprocess once. */
4390 if (print_subprocess_help
|| print_help_list
|| print_version
)
4394 /* Create a dummy input file, so that we can pass
4395 the help option on to the various sub-processes. */
4396 infiles
[0].language
= "c";
4397 infiles
[0].name
= "help-dummy";
4400 switches
[n_switches
].part1
= 0;
4401 infiles
[n_infiles
].name
= 0;
4404 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4405 and place that in the environment. */
4408 set_collect_gcc_options (void)
4413 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4415 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4416 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4419 for (i
= 0; (int) i
< n_switches
; i
++)
4421 const char *const *args
;
4424 obstack_grow (&collect_obstack
, " ", 1);
4428 /* Ignore elided switches. */
4429 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) != 0)
4432 obstack_grow (&collect_obstack
, "'-", 2);
4433 q
= switches
[i
].part1
;
4434 while ((p
= strchr (q
, '\'')))
4436 obstack_grow (&collect_obstack
, q
, p
- q
);
4437 obstack_grow (&collect_obstack
, "'\\''", 4);
4440 obstack_grow (&collect_obstack
, q
, strlen (q
));
4441 obstack_grow (&collect_obstack
, "'", 1);
4443 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4445 obstack_grow (&collect_obstack
, " '", 2);
4447 while ((p
= strchr (q
, '\'')))
4449 obstack_grow (&collect_obstack
, q
, p
- q
);
4450 obstack_grow (&collect_obstack
, "'\\''", 4);
4453 obstack_grow (&collect_obstack
, q
, strlen (q
));
4454 obstack_grow (&collect_obstack
, "'", 1);
4457 obstack_grow (&collect_obstack
, "\0", 1);
4458 xputenv (XOBFINISH (&collect_obstack
, char *));
4461 /* Process a spec string, accumulating and running commands. */
4463 /* These variables describe the input file name.
4464 input_file_number is the index on outfiles of this file,
4465 so that the output file name can be stored for later use by %o.
4466 input_basename is the start of the part of the input file
4467 sans all directory names, and basename_length is the number
4468 of characters starting there excluding the suffix .c or whatever. */
4470 static const char *input_filename
;
4471 static int input_file_number
;
4472 size_t input_filename_length
;
4473 static int basename_length
;
4474 static int suffixed_basename_length
;
4475 static const char *input_basename
;
4476 static const char *input_suffix
;
4477 #ifndef HOST_LACKS_INODE_NUMBERS
4478 static struct stat input_stat
;
4480 static int input_stat_set
;
4482 /* The compiler used to process the current input file. */
4483 static struct compiler
*input_file_compiler
;
4485 /* These are variables used within do_spec and do_spec_1. */
4487 /* Nonzero if an arg has been started and not yet terminated
4488 (with space, tab or newline). */
4489 static int arg_going
;
4491 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4492 is a temporary file name. */
4493 static int delete_this_arg
;
4495 /* Nonzero means %w has been seen; the next arg to be terminated
4496 is the output file name of this compilation. */
4497 static int this_is_output_file
;
4499 /* Nonzero means %s has been seen; the next arg to be terminated
4500 is the name of a library file and we should try the standard
4501 search dirs for it. */
4502 static int this_is_library_file
;
4504 /* Nonzero means that the input of this command is coming from a pipe. */
4505 static int input_from_pipe
;
4507 /* Nonnull means substitute this for any suffix when outputting a switches
4509 static const char *suffix_subst
;
4511 /* If there is an argument being accumulated, terminate it and store it. */
4514 end_going_arg (void)
4520 obstack_1grow (&obstack
, 0);
4521 string
= XOBFINISH (&obstack
, const char *);
4522 if (this_is_library_file
)
4523 string
= find_file (string
);
4524 store_arg (string
, delete_this_arg
, this_is_output_file
);
4525 if (this_is_output_file
)
4526 outfiles
[input_file_number
] = string
;
4532 /* Parse the WRAPPER string which is a comma separated list of the command line
4533 and insert them into the beginning of argbuf. */
4536 insert_wrapper (const char *wrapper
)
4540 char *buf
= xstrdup (wrapper
);
4549 while ((p
= strchr (p
, ',')) != NULL
);
4551 if (argbuf_index
+ n
>= argbuf_length
)
4553 argbuf_length
= argbuf_length
* 2;
4554 while (argbuf_length
< argbuf_index
+ n
)
4556 argbuf
= XRESIZEVEC (const char *, argbuf
, argbuf_length
);
4558 for (i
= argbuf_index
- 1; i
>= 0; i
--)
4559 argbuf
[i
+ n
] = argbuf
[i
];
4572 while ((p
= strchr (p
, ',')) != NULL
);
4573 gcc_assert (i
== n
);
4577 /* Process the spec SPEC and run the commands specified therein.
4578 Returns 0 if the spec is successfully processed; -1 if failed. */
4581 do_spec (const char *spec
)
4585 value
= do_spec_2 (spec
);
4587 /* Force out any unfinished command.
4588 If -pipe, this forces out the last command if it ended in `|'. */
4591 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4594 set_collect_gcc_options ();
4596 if (argbuf_index
> 0)
4604 do_spec_2 (const char *spec
)
4610 delete_this_arg
= 0;
4611 this_is_output_file
= 0;
4612 this_is_library_file
= 0;
4613 input_from_pipe
= 0;
4614 suffix_subst
= NULL
;
4616 result
= do_spec_1 (spec
, 0, NULL
);
4624 /* Process the given spec string and add any new options to the end
4625 of the switches/n_switches array. */
4628 do_option_spec (const char *name
, const char *spec
)
4630 unsigned int i
, value_count
, value_len
;
4631 const char *p
, *q
, *value
;
4632 char *tmp_spec
, *tmp_spec_p
;
4634 if (configure_default_options
[0].name
== NULL
)
4637 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4638 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4640 if (i
== ARRAY_SIZE (configure_default_options
))
4643 value
= configure_default_options
[i
].value
;
4644 value_len
= strlen (value
);
4646 /* Compute the size of the final spec. */
4649 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4655 /* Replace each %(VALUE) by the specified value. */
4656 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4657 + value_count
* (value_len
- strlen ("%(VALUE)")));
4658 tmp_spec_p
= tmp_spec
;
4660 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4662 memcpy (tmp_spec_p
, q
, p
- q
);
4663 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4664 memcpy (tmp_spec_p
, value
, value_len
);
4665 tmp_spec_p
+= value_len
;
4666 q
= p
+ strlen ("%(VALUE)");
4668 strcpy (tmp_spec_p
, q
);
4670 do_self_spec (tmp_spec
);
4673 /* Process the given spec string and add any new options to the end
4674 of the switches/n_switches array. */
4677 do_self_spec (const char *spec
)
4680 do_spec_1 (" ", 0, NULL
);
4682 if (argbuf_index
> 0)
4687 n_switches
+= argbuf_index
;
4688 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches
+ 1);
4690 switches
[n_switches
] = switches
[first
];
4691 for (i
= 0; i
< argbuf_index
; i
++)
4693 struct switchstr
*sw
;
4695 /* Each switch should start with '-'. */
4696 if (argbuf
[i
][0] != '-')
4697 fatal ("switch '%s' does not start with '-'", argbuf
[i
]);
4699 sw
= &switches
[i
+ first
];
4700 sw
->part1
= &argbuf
[i
][1];
4709 /* Callback for processing %D and %I specs. */
4711 struct spec_path_info
{
4716 bool separate_options
;
4720 spec_path (char *path
, void *data
)
4722 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4726 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4729 if (info
->append_len
!= 0)
4731 len
= strlen (path
);
4732 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4735 if (!is_directory (path
, true))
4738 do_spec_1 (info
->option
, 1, NULL
);
4739 if (info
->separate_options
)
4740 do_spec_1 (" ", 0, NULL
);
4742 if (info
->append_len
== 0)
4744 len
= strlen (path
);
4745 save
= path
[len
- 1];
4746 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4747 path
[len
- 1] = '\0';
4750 do_spec_1 (path
, 1, NULL
);
4751 do_spec_1 (" ", 0, NULL
);
4753 /* Must not damage the original path. */
4754 if (info
->append_len
== 0)
4755 path
[len
- 1] = save
;
4760 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4764 create_at_file (char **argv
)
4766 char *temp_file
= make_temp_file ("");
4767 char *at_argument
= concat ("@", temp_file
, NULL
);
4768 FILE *f
= fopen (temp_file
, "w");
4772 fatal ("could not open temporary response file %s",
4775 status
= writeargv (argv
, f
);
4778 fatal ("could not write to temporary response file %s",
4781 status
= fclose (f
);
4784 fatal ("could not close temporary response file %s",
4787 store_arg (at_argument
, 0, 0);
4789 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4792 /* True if we should compile INFILE. */
4795 compile_input_file_p (struct infile
*infile
)
4797 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4798 if (infile
->incompiler
== input_file_compiler
)
4803 /* Process the sub-spec SPEC as a portion of a larger spec.
4804 This is like processing a whole spec except that we do
4805 not initialize at the beginning and we do not supply a
4806 newline by default at the end.
4807 INSWITCH nonzero means don't process %-sequences in SPEC;
4808 in this case, % is treated as an ordinary character.
4809 This is used while substituting switches.
4810 INSWITCH nonzero also causes SPC not to terminate an argument.
4812 Value is zero unless a line was finished
4813 and the command on that line reported an error. */
4816 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4818 const char *p
= spec
;
4824 /* If substituting a switch, treat all chars like letters.
4825 Otherwise, NL, SPC, TAB and % are special. */
4826 switch (inswitch
? 'a' : c
)
4831 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4833 /* A `|' before the newline means use a pipe here,
4834 but only if -pipe was specified.
4835 Otherwise, execute now and don't pass the `|' as an arg. */
4838 input_from_pipe
= 1;
4845 set_collect_gcc_options ();
4847 if (argbuf_index
> 0)
4853 /* Reinitialize for a new command, and for a new argument. */
4856 delete_this_arg
= 0;
4857 this_is_output_file
= 0;
4858 this_is_library_file
= 0;
4859 input_from_pipe
= 0;
4866 obstack_1grow (&obstack
, c
);
4874 /* Reinitialize for a new argument. */
4875 delete_this_arg
= 0;
4876 this_is_output_file
= 0;
4877 this_is_library_file
= 0;
4884 fatal ("spec '%s' invalid", spec
);
4887 if (save_temps_length
)
4888 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4890 obstack_grow (&obstack
, input_basename
, basename_length
);
4895 if (save_temps_length
)
4896 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4898 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4903 delete_this_arg
= 2;
4906 /* Dump out the directories specified with LIBRARY_PATH,
4907 followed by the absolute directories
4908 that we search for startfiles. */
4911 struct spec_path_info info
;
4914 info
.append_len
= 0;
4915 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4916 /* Used on systems which record the specified -L dirs
4917 and use them to search for dynamic linking.
4918 Relative directories always come from -B,
4919 and it is better not to use them for searching
4920 at run time. In particular, stage1 loses. */
4921 info
.omit_relative
= true;
4923 info
.omit_relative
= false;
4925 info
.separate_options
= false;
4927 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4932 /* %efoo means report an error with `foo' as error message
4933 and don't execute any more commands for this file. */
4937 while (*p
!= 0 && *p
!= '\n')
4939 buf
= (char *) alloca (p
- q
+ 1);
4940 strncpy (buf
, q
, p
- q
);
4947 /* %nfoo means report a notice with `foo' on stderr. */
4951 while (*p
!= 0 && *p
!= '\n')
4953 buf
= (char *) alloca (p
- q
+ 1);
4954 strncpy (buf
, q
, p
- q
);
4956 notice ("%s\n", buf
);
4966 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4967 defined, and it is not a directory, and it is
4968 writable, use it. Otherwise, treat this like any
4969 other temporary file. */
4971 if ((!save_temps_flag
)
4972 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4973 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4975 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4976 strlen (HOST_BIT_BUCKET
));
4977 delete_this_arg
= 0;
4982 goto create_temp_file
;
4986 obstack_1grow (&obstack
, '-');
4987 delete_this_arg
= 0;
4990 /* consume suffix */
4991 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4993 if (p
[0] == '%' && p
[1] == 'O')
4998 goto create_temp_file
;
5002 /* consume suffix */
5003 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5005 if (p
[0] == '%' && p
[1] == 'O')
5010 goto create_temp_file
;
5016 struct temp_name
*t
;
5018 const char *suffix
= p
;
5019 char *saved_suffix
= NULL
;
5021 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5023 suffix_length
= p
- suffix
;
5024 if (p
[0] == '%' && p
[1] == 'O')
5027 /* We don't support extra suffix characters after %O. */
5028 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5029 fatal ("spec '%s' has invalid '%%0%c'", spec
, *p
);
5030 if (suffix_length
== 0)
5031 suffix
= TARGET_OBJECT_SUFFIX
;
5035 = XNEWVEC (char, suffix_length
5036 + strlen (TARGET_OBJECT_SUFFIX
));
5037 strncpy (saved_suffix
, suffix
, suffix_length
);
5038 strcpy (saved_suffix
+ suffix_length
,
5039 TARGET_OBJECT_SUFFIX
);
5041 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5044 /* If -save-temps=obj and -o were specified, use that for the
5046 if (save_temps_length
)
5049 temp_filename_length
5050 = save_temps_length
+ suffix_length
+ 1;
5051 tmp
= (char *) alloca (temp_filename_length
);
5052 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5053 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5054 tmp
[save_temps_length
+ suffix_length
] = '\0';
5055 temp_filename
= save_string (tmp
,
5056 temp_filename_length
+ 1);
5057 obstack_grow (&obstack
, temp_filename
,
5058 temp_filename_length
);
5060 delete_this_arg
= 0;
5064 /* If the input_filename has the same suffix specified
5065 for the %g, %u, or %U, and -save-temps is specified,
5066 we could end up using that file as an intermediate
5067 thus clobbering the user's source file (.e.g.,
5068 gcc -save-temps foo.s would clobber foo.s with the
5069 output of cpp0). So check for this condition and
5070 generate a temp file as the intermediate. */
5072 if (save_temps_flag
)
5075 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5076 tmp
= (char *) alloca (temp_filename_length
);
5077 memcpy (tmp
, input_basename
, basename_length
);
5078 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5079 tmp
[basename_length
+ suffix_length
] = '\0';
5080 temp_filename
= tmp
;
5082 if (strcmp (temp_filename
, input_filename
) != 0)
5084 #ifndef HOST_LACKS_INODE_NUMBERS
5085 struct stat st_temp
;
5087 /* Note, set_input() resets input_stat_set to 0. */
5088 if (input_stat_set
== 0)
5090 input_stat_set
= stat (input_filename
, &input_stat
);
5091 if (input_stat_set
>= 0)
5095 /* If we have the stat for the input_filename
5096 and we can do the stat for the temp_filename
5097 then the they could still refer to the same
5098 file if st_dev/st_ino's are the same. */
5099 if (input_stat_set
!= 1
5100 || stat (temp_filename
, &st_temp
) < 0
5101 || input_stat
.st_dev
!= st_temp
.st_dev
5102 || input_stat
.st_ino
!= st_temp
.st_ino
)
5104 /* Just compare canonical pathnames. */
5105 char* input_realname
= lrealpath (input_filename
);
5106 char* temp_realname
= lrealpath (temp_filename
);
5107 bool files_differ
= strcmp (input_realname
, temp_realname
);
5108 free (input_realname
);
5109 free (temp_realname
);
5113 temp_filename
= save_string (temp_filename
,
5114 temp_filename_length
+ 1);
5115 obstack_grow (&obstack
, temp_filename
,
5116 temp_filename_length
);
5118 delete_this_arg
= 0;
5124 /* See if we already have an association of %g/%u/%U and
5126 for (t
= temp_names
; t
; t
= t
->next
)
5127 if (t
->length
== suffix_length
5128 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5129 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5132 /* Make a new association if needed. %u and %j
5134 if (t
== 0 || c
== 'u' || c
== 'j')
5138 t
= XNEW (struct temp_name
);
5139 t
->next
= temp_names
;
5142 t
->length
= suffix_length
;
5145 t
->suffix
= saved_suffix
;
5146 saved_suffix
= NULL
;
5149 t
->suffix
= save_string (suffix
, suffix_length
);
5150 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5151 temp_filename
= make_temp_file (t
->suffix
);
5152 temp_filename_length
= strlen (temp_filename
);
5153 t
->filename
= temp_filename
;
5154 t
->filename_length
= temp_filename_length
;
5158 free (saved_suffix
);
5160 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5161 delete_this_arg
= 1;
5169 if (at_file_supplied
)
5171 /* We are going to expand `%i' to `@FILE', where FILE
5172 is a newly-created temporary filename. The filenames
5173 that would usually be expanded in place of %o will be
5174 written to the temporary file. */
5179 for (i
= 0; i
< n_infiles
; i
++)
5180 if (compile_input_file_p (&infiles
[i
]))
5183 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5185 /* Copy the strings over. */
5186 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5187 if (compile_input_file_p (&infiles
[i
]))
5189 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5190 infiles
[i
].compiled
= true;
5195 create_at_file (argv
);
5198 for (i
= 0; (int) i
< n_infiles
; i
++)
5199 if (compile_input_file_p (&infiles
[i
]))
5201 store_arg (infiles
[i
].name
, 0, 0);
5202 infiles
[i
].compiled
= true;
5207 obstack_grow (&obstack
, input_filename
, input_filename_length
);
5214 struct spec_path_info info
;
5218 do_spec_1 ("-imultilib", 1, NULL
);
5219 /* Make this a separate argument. */
5220 do_spec_1 (" ", 0, NULL
);
5221 do_spec_1 (multilib_dir
, 1, NULL
);
5222 do_spec_1 (" ", 0, NULL
);
5225 if (gcc_exec_prefix
)
5227 do_spec_1 ("-iprefix", 1, NULL
);
5228 /* Make this a separate argument. */
5229 do_spec_1 (" ", 0, NULL
);
5230 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5231 do_spec_1 (" ", 0, NULL
);
5234 if (target_system_root_changed
||
5235 (target_system_root
&& target_sysroot_hdrs_suffix
))
5237 do_spec_1 ("-isysroot", 1, NULL
);
5238 /* Make this a separate argument. */
5239 do_spec_1 (" ", 0, NULL
);
5240 do_spec_1 (target_system_root
, 1, NULL
);
5241 if (target_sysroot_hdrs_suffix
)
5242 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5243 do_spec_1 (" ", 0, NULL
);
5246 info
.option
= "-isystem";
5247 info
.append
= "include";
5248 info
.append_len
= strlen (info
.append
);
5249 info
.omit_relative
= false;
5250 info
.separate_options
= true;
5252 for_each_path (&include_prefixes
, false, info
.append_len
,
5255 info
.append
= "include-fixed";
5256 if (*sysroot_hdrs_suffix_spec
)
5257 info
.append
= concat (info
.append
, dir_separator_str
,
5258 multilib_dir
, NULL
);
5259 info
.append_len
= strlen (info
.append
);
5260 for_each_path (&include_prefixes
, false, info
.append_len
,
5267 int max
= n_infiles
;
5268 max
+= lang_specific_extra_outfiles
;
5270 if (HAVE_GNU_LD
&& at_file_supplied
)
5272 /* We are going to expand `%o' to `@FILE', where FILE
5273 is a newly-created temporary filename. The filenames
5274 that would usually be expanded in place of %o will be
5275 written to the temporary file. */
5280 /* Convert OUTFILES into a form suitable for writeargv. */
5282 /* Determine how many are non-NULL. */
5283 for (n_files
= 0, i
= 0; i
< max
; i
++)
5284 n_files
+= outfiles
[i
] != NULL
;
5286 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5288 /* Copy the strings over. */
5289 for (i
= 0, j
= 0; i
< max
; i
++)
5292 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5297 create_at_file (argv
);
5300 for (i
= 0; i
< max
; i
++)
5302 store_arg (outfiles
[i
], 0, 0);
5307 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5312 this_is_library_file
= 1;
5316 outfiles
[input_file_number
] = NULL
;
5320 this_is_output_file
= 1;
5325 int cur_index
= argbuf_index
;
5326 /* Handle the {...} following the %W. */
5328 fatal ("spec '%s' has invalid '%%W%c", spec
, *p
);
5329 p
= handle_braces (p
+ 1);
5333 /* If any args were output, mark the last one for deletion
5335 if (argbuf_index
!= cur_index
)
5336 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
5340 /* %x{OPTION} records OPTION for %X to output. */
5346 /* Skip past the option value and make a copy. */
5348 fatal ("spec '%s' has invalid '%%x%c'", spec
, *p
);
5351 string
= save_string (p1
+ 1, p
- p1
- 2);
5353 /* See if we already recorded this option. */
5354 for (i
= 0; i
< n_linker_options
; i
++)
5355 if (! strcmp (string
, linker_options
[i
]))
5361 /* This option is new; add it. */
5362 add_linker_option (string
, strlen (string
));
5366 /* Dump out the options accumulated previously using %x. */
5368 for (i
= 0; i
< n_linker_options
; i
++)
5370 do_spec_1 (linker_options
[i
], 1, NULL
);
5371 /* Make each accumulated option a separate argument. */
5372 do_spec_1 (" ", 0, NULL
);
5376 /* Dump out the options accumulated previously using -Wa,. */
5378 for (i
= 0; i
< n_assembler_options
; i
++)
5380 do_spec_1 (assembler_options
[i
], 1, NULL
);
5381 /* Make each accumulated option a separate argument. */
5382 do_spec_1 (" ", 0, NULL
);
5386 /* Dump out the options accumulated previously using -Wp,. */
5388 for (i
= 0; i
< n_preprocessor_options
; i
++)
5390 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5391 /* Make each accumulated option a separate argument. */
5392 do_spec_1 (" ", 0, NULL
);
5396 /* Here are digits and numbers that just process
5397 a certain constant string as a spec. */
5400 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5406 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5412 value
= do_spec_1 (asm_spec
, 0, NULL
);
5418 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5425 const char *const spec
5426 = (input_file_compiler
->cpp_spec
5427 ? input_file_compiler
->cpp_spec
5429 value
= do_spec_1 (spec
, 0, NULL
);
5436 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5442 value
= do_spec_1 (link_spec
, 0, NULL
);
5448 value
= do_spec_1 (lib_spec
, 0, NULL
);
5454 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5460 /* We assume there is a directory
5461 separator at the end of this string. */
5462 if (target_system_root
)
5464 obstack_grow (&obstack
, target_system_root
,
5465 strlen (target_system_root
));
5466 if (target_sysroot_suffix
)
5467 obstack_grow (&obstack
, target_sysroot_suffix
,
5468 strlen (target_sysroot_suffix
));
5473 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5478 /* Here we define characters other than letters and digits. */
5481 p
= handle_braces (p
);
5487 p
= handle_spec_function (p
);
5493 obstack_1grow (&obstack
, '%');
5500 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5502 suffix_subst
= save_string (p
- 1, len
+ 1);
5507 /* Henceforth ignore the option(s) matching the pattern
5512 int have_wildcard
= 0;
5515 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5518 if (p
[len
-1] == '*')
5521 for (i
= 0; i
< n_switches
; i
++)
5522 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5523 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5525 switches
[i
].live_cond
|= SWITCH_IGNORE
;
5526 switches
[i
].validated
= 1;
5534 if (soft_matched_part
)
5536 do_spec_1 (soft_matched_part
, 1, NULL
);
5537 do_spec_1 (" ", 0, NULL
);
5540 /* Catch the case where a spec string contains something like
5541 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5542 hand side of the :. */
5543 error ("spec failure: '%%*' has not been initialized by pattern match");
5546 /* Process a string found as the value of a spec given by name.
5547 This feature allows individual machine descriptions
5548 to add and use their own specs.
5549 %[...] modifies -D options the way %P does;
5550 %(...) uses the spec unmodified. */
5552 error ("warning: use of obsolete %%[ operator in specs");
5555 const char *name
= p
;
5556 struct spec_list
*sl
;
5559 /* The string after the S/P is the name of a spec that is to be
5561 while (*p
&& *p
!= ')' && *p
!= ']')
5564 /* See if it's in the list. */
5565 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5566 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5568 name
= *(sl
->ptr_spec
);
5570 notice ("Processing spec %c%s%c, which is '%s'\n",
5571 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5580 value
= do_spec_1 (name
, 0, NULL
);
5586 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5588 const char *y
= name
;
5591 /* Copy all of NAME into BUF, but put __ after
5592 every -D and at the end of each arg. */
5595 if (! strncmp (y
, "-D", 2))
5606 && (*y
== ' ' || *y
== '\t' || *y
== '='
5607 || *y
== '}' || *y
== 0))
5620 value
= do_spec_1 (buf
, 0, NULL
);
5626 /* Discard the closing paren or bracket. */
5633 error ("spec failure: unrecognized spec option '%c'", c
);
5639 /* Backslash: treat next character as ordinary. */
5644 /* Ordinary character: put it into the current argument. */
5645 obstack_1grow (&obstack
, c
);
5649 /* End of string. If we are processing a spec function, we need to
5650 end any pending argument. */
5651 if (processing_spec_function
)
5657 /* Look up a spec function. */
5659 static const struct spec_function
*
5660 lookup_spec_function (const char *name
)
5662 const struct spec_function
*sf
;
5664 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5665 if (strcmp (sf
->name
, name
) == 0)
5671 /* Evaluate a spec function. */
5674 eval_spec_function (const char *func
, const char *args
)
5676 const struct spec_function
*sf
;
5677 const char *funcval
;
5679 /* Saved spec processing context. */
5680 int save_argbuf_index
;
5681 int save_argbuf_length
;
5682 const char **save_argbuf
;
5685 int save_delete_this_arg
;
5686 int save_this_is_output_file
;
5687 int save_this_is_library_file
;
5688 int save_input_from_pipe
;
5689 const char *save_suffix_subst
;
5692 sf
= lookup_spec_function (func
);
5694 fatal ("unknown spec function '%s'", func
);
5696 /* Push the spec processing context. */
5697 save_argbuf_index
= argbuf_index
;
5698 save_argbuf_length
= argbuf_length
;
5699 save_argbuf
= argbuf
;
5701 save_arg_going
= arg_going
;
5702 save_delete_this_arg
= delete_this_arg
;
5703 save_this_is_output_file
= this_is_output_file
;
5704 save_this_is_library_file
= this_is_library_file
;
5705 save_input_from_pipe
= input_from_pipe
;
5706 save_suffix_subst
= suffix_subst
;
5708 /* Create a new spec processing context, and build the function
5712 if (do_spec_2 (args
) < 0)
5713 fatal ("error in args to spec function '%s'", func
);
5715 /* argbuf_index is an index for the next argument to be inserted, and
5716 so contains the count of the args already inserted. */
5718 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5720 /* Pop the spec processing context. */
5721 argbuf_index
= save_argbuf_index
;
5722 argbuf_length
= save_argbuf_length
;
5724 argbuf
= save_argbuf
;
5726 arg_going
= save_arg_going
;
5727 delete_this_arg
= save_delete_this_arg
;
5728 this_is_output_file
= save_this_is_output_file
;
5729 this_is_library_file
= save_this_is_library_file
;
5730 input_from_pipe
= save_input_from_pipe
;
5731 suffix_subst
= save_suffix_subst
;
5736 /* Handle a spec function call of the form:
5740 ARGS is processed as a spec in a separate context and split into an
5741 argument vector in the normal fashion. The function returns a string
5742 containing a spec which we then process in the caller's context, or
5743 NULL if no processing is required. */
5746 handle_spec_function (const char *p
)
5749 const char *endp
, *funcval
;
5752 processing_spec_function
++;
5754 /* Get the function name. */
5755 for (endp
= p
; *endp
!= '\0'; endp
++)
5757 if (*endp
== '(') /* ) */
5759 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5760 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5761 fatal ("malformed spec function name");
5763 if (*endp
!= '(') /* ) */
5764 fatal ("no arguments for spec function");
5765 func
= save_string (p
, endp
- p
);
5768 /* Get the arguments. */
5769 for (count
= 0; *endp
!= '\0'; endp
++)
5778 else if (*endp
== '(') /* ) */
5783 fatal ("malformed spec function arguments");
5784 args
= save_string (p
, endp
- p
);
5787 /* p now points to just past the end of the spec function expression. */
5789 funcval
= eval_spec_function (func
, args
);
5790 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5796 processing_spec_function
--;
5801 /* Inline subroutine of handle_braces. Returns true if the current
5802 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5804 input_suffix_matches (const char *atom
, const char *end_atom
)
5806 return (input_suffix
5807 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5808 && input_suffix
[end_atom
- atom
] == '\0');
5811 /* Subroutine of handle_braces. Returns true if the current
5812 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5814 input_spec_matches (const char *atom
, const char *end_atom
)
5816 return (input_file_compiler
5817 && input_file_compiler
->suffix
5818 && input_file_compiler
->suffix
[0] != '\0'
5819 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5821 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5824 /* Subroutine of handle_braces. Returns true if a switch
5825 matching the atom bracketed by ATOM and END_ATOM appeared on the
5828 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5831 int len
= end_atom
- atom
;
5832 int plen
= starred
? len
: -1;
5834 for (i
= 0; i
< n_switches
; i
++)
5835 if (!strncmp (switches
[i
].part1
, atom
, len
)
5836 && (starred
|| switches
[i
].part1
[len
] == '\0')
5837 && check_live_switch (i
, plen
))
5843 /* Inline subroutine of handle_braces. Mark all of the switches which
5844 match ATOM (extends to END_ATOM; STARRED indicates whether there
5845 was a star after the atom) for later processing. */
5847 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5850 int len
= end_atom
- atom
;
5851 int plen
= starred
? len
: -1;
5853 for (i
= 0; i
< n_switches
; i
++)
5854 if (!strncmp (switches
[i
].part1
, atom
, len
)
5855 && (starred
|| switches
[i
].part1
[len
] == '\0')
5856 && check_live_switch (i
, plen
))
5857 switches
[i
].ordering
= 1;
5860 /* Inline subroutine of handle_braces. Process all the currently
5861 marked switches through give_switch, and clear the marks. */
5863 process_marked_switches (void)
5867 for (i
= 0; i
< n_switches
; i
++)
5868 if (switches
[i
].ordering
== 1)
5870 switches
[i
].ordering
= 0;
5875 /* Handle a %{ ... } construct. P points just inside the leading {.
5876 Returns a pointer one past the end of the brace block, or 0
5877 if we call do_spec_1 and that returns -1. */
5880 handle_braces (const char *p
)
5882 const char *atom
, *end_atom
;
5883 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5884 const char *orig
= p
;
5892 bool a_must_be_last
= false;
5893 bool ordered_set
= false;
5894 bool disjunct_set
= false;
5895 bool disj_matched
= false;
5896 bool disj_starred
= true;
5897 bool n_way_choice
= false;
5898 bool n_way_matched
= false;
5900 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5907 /* Scan one "atom" (S in the description above of %{}, possibly
5908 with '!', '.', '@', ',', or '*' modifiers). */
5910 a_is_suffix
= false;
5911 a_is_starred
= false;
5912 a_is_negated
= false;
5913 a_is_spectype
= false;
5917 p
++, a_is_negated
= true;
5921 p
++, a_is_suffix
= true;
5923 p
++, a_is_spectype
= true;
5926 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5927 || *p
== ',' || *p
== '.' || *p
== '@')
5932 p
++, a_is_starred
= 1;
5938 /* Substitute the switch(es) indicated by the current atom. */
5940 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5941 || a_is_spectype
|| atom
== end_atom
)
5944 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5947 process_marked_switches ();
5951 /* Substitute some text if the current atom appears as a switch
5953 disjunct_set
= true;
5957 if (atom
== end_atom
)
5959 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5960 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5964 /* An empty term may appear as the last choice of an
5965 N-way choice set; it means "otherwise". */
5966 a_must_be_last
= true;
5967 disj_matched
= !n_way_matched
;
5968 disj_starred
= false;
5972 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5976 disj_starred
= false;
5978 /* Don't bother testing this atom if we already have a
5980 if (!disj_matched
&& !n_way_matched
)
5983 a_matched
= input_suffix_matches (atom
, end_atom
);
5984 else if (a_is_spectype
)
5985 a_matched
= input_spec_matches (atom
, end_atom
);
5987 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5989 if (a_matched
!= a_is_negated
)
5991 disj_matched
= true;
5993 d_end_atom
= end_atom
;
6000 /* Found the body, that is, the text to substitute if the
6001 current disjunction matches. */
6002 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6003 disj_matched
&& !n_way_matched
);
6007 /* If we have an N-way choice, reset state for the next
6011 n_way_choice
= true;
6012 n_way_matched
|= disj_matched
;
6013 disj_matched
= false;
6014 disj_starred
= true;
6015 d_atom
= d_end_atom
= NULL
;
6024 while (*p
++ != '}');
6029 fatal ("braced spec '%s' is invalid at '%c'", orig
, *p
);
6034 /* Subroutine of handle_braces. Scan and process a brace substitution body
6035 (X in the description of %{} syntax). P points one past the colon;
6036 ATOM and END_ATOM bracket the first atom which was found to be true
6037 (present) in the current disjunction; STARRED indicates whether all
6038 the atoms in the current disjunction were starred (for syntax validation);
6039 MATCHED indicates whether the disjunction matched or not, and therefore
6040 whether or not the body is to be processed through do_spec_1 or just
6041 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6045 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6046 int starred
, int matched
)
6048 const char *body
, *end_body
;
6049 unsigned int nesting_level
;
6050 bool have_subst
= false;
6052 /* Locate the closing } or ;, honoring nested braces.
6053 Trim trailing whitespace. */
6062 if (!--nesting_level
)
6065 else if (*p
== ';' && nesting_level
== 1)
6067 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6069 else if (*p
== '\0')
6075 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6078 if (have_subst
&& !starred
)
6083 /* Copy the substitution body to permanent storage and execute it.
6084 If have_subst is false, this is a simple matter of running the
6085 body through do_spec_1... */
6086 char *string
= save_string (body
, end_body
- body
);
6089 if (do_spec_1 (string
, 0, NULL
) < 0)
6094 /* ... but if have_subst is true, we have to process the
6095 body once for each matching switch, with %* set to the
6096 variant part of the switch. */
6097 unsigned int hard_match_len
= end_atom
- atom
;
6100 for (i
= 0; i
< n_switches
; i
++)
6101 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6102 && check_live_switch (i
, hard_match_len
))
6104 if (do_spec_1 (string
, 0,
6105 &switches
[i
].part1
[hard_match_len
]) < 0)
6107 /* Pass any arguments this switch has. */
6109 suffix_subst
= NULL
;
6117 fatal ("braced spec body '%s' is invalid", body
);
6120 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6121 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6122 spec, or -1 if either exact match or %* is used.
6124 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6125 whose value does not begin with "no-" is obsoleted by the same value
6126 with the "no-", similarly for a switch with the "no-" prefix. */
6129 check_live_switch (int switchnum
, int prefix_length
)
6131 const char *name
= switches
[switchnum
].part1
;
6134 /* In the common case of {<at-most-one-letter>*}, a negating
6135 switch would always match, so ignore that case. We will just
6136 send the conflicting switches to the compiler phase. */
6137 if (prefix_length
>= 0 && prefix_length
<= 1)
6140 /* If we already processed this switch and determined if it was
6141 live or not, return our past determination. */
6142 if (switches
[switchnum
].live_cond
!= 0)
6143 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6144 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0);
6146 /* Now search for duplicate in a manner that depends on the name. */
6150 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6151 if (switches
[i
].part1
[0] == 'O')
6153 switches
[switchnum
].validated
= 1;
6154 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6159 case 'W': case 'f': case 'm':
6160 if (! strncmp (name
+ 1, "no-", 3))
6162 /* We have Xno-YYY, search for XYYY. */
6163 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6164 if (switches
[i
].part1
[0] == name
[0]
6165 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6167 switches
[switchnum
].validated
= 1;
6168 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6174 /* We have XYYY, search for Xno-YYY. */
6175 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6176 if (switches
[i
].part1
[0] == name
[0]
6177 && switches
[i
].part1
[1] == 'n'
6178 && switches
[i
].part1
[2] == 'o'
6179 && switches
[i
].part1
[3] == '-'
6180 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6182 switches
[switchnum
].validated
= 1;
6183 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6190 /* Otherwise the switch is live. */
6191 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6195 /* Pass a switch to the current accumulating command
6196 in the same form that we received it.
6197 SWITCHNUM identifies the switch; it is an index into
6198 the vector of switches gcc received, which is `switches'.
6199 This cannot fail since it never finishes a command line.
6201 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6204 give_switch (int switchnum
, int omit_first_word
)
6206 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6209 if (!omit_first_word
)
6211 do_spec_1 ("-", 0, NULL
);
6212 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6215 if (switches
[switchnum
].args
!= 0)
6218 for (p
= switches
[switchnum
].args
; *p
; p
++)
6220 const char *arg
= *p
;
6222 do_spec_1 (" ", 0, NULL
);
6225 unsigned length
= strlen (arg
);
6228 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6229 if (arg
[length
] == '.')
6231 (CONST_CAST(char *, arg
))[length
] = 0;
6235 do_spec_1 (arg
, 1, NULL
);
6237 (CONST_CAST(char *, arg
))[length
] = '.';
6238 do_spec_1 (suffix_subst
, 1, NULL
);
6241 do_spec_1 (arg
, 1, NULL
);
6245 do_spec_1 (" ", 0, NULL
);
6246 switches
[switchnum
].validated
= 1;
6249 /* Search for a file named NAME trying various prefixes including the
6250 user's -B prefix and some standard ones.
6251 Return the absolute file name found. If nothing is found, return NAME. */
6254 find_file (const char *name
)
6256 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6257 return newname
? newname
: name
;
6260 /* Determine whether a directory exists. If LINKER, return 0 for
6261 certain fixed names not needed by the linker. */
6264 is_directory (const char *path1
, bool linker
)
6271 /* Ensure the string ends with "/.". The resulting path will be a
6272 directory even if the given path is a symbolic link. */
6273 len1
= strlen (path1
);
6274 path
= (char *) alloca (3 + len1
);
6275 memcpy (path
, path1
, len1
);
6277 if (!IS_DIR_SEPARATOR (cp
[-1]))
6278 *cp
++ = DIR_SEPARATOR
;
6282 /* Exclude directories that the linker is known to search. */
6284 && IS_DIR_SEPARATOR (path
[0])
6286 && strncmp (path
+ 1, "lib", 3) == 0)
6288 && strncmp (path
+ 1, "usr", 3) == 0
6289 && IS_DIR_SEPARATOR (path
[4])
6290 && strncmp (path
+ 5, "lib", 3) == 0)))
6293 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6296 /* Set up the various global variables to indicate that we're processing
6297 the input file named FILENAME. */
6300 set_input (const char *filename
)
6304 input_filename
= filename
;
6305 input_filename_length
= strlen (input_filename
);
6306 input_basename
= lbasename (input_filename
);
6308 /* Find a suffix starting with the last period,
6309 and set basename_length to exclude that suffix. */
6310 basename_length
= strlen (input_basename
);
6311 suffixed_basename_length
= basename_length
;
6312 p
= input_basename
+ basename_length
;
6313 while (p
!= input_basename
&& *p
!= '.')
6315 if (*p
== '.' && p
!= input_basename
)
6317 basename_length
= p
- input_basename
;
6318 input_suffix
= p
+ 1;
6323 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6324 we will need to do a stat on the input_filename. The
6325 INPUT_STAT_SET signals that the stat is needed. */
6329 /* On fatal signals, delete all the temporary files. */
6332 fatal_error (int signum
)
6334 signal (signum
, SIG_DFL
);
6335 delete_failure_queue ();
6336 delete_temp_files ();
6337 /* Get the same signal again, this time not handled,
6338 so its normal effect occurs. */
6339 kill (getpid (), signum
);
6342 extern int main (int, char **);
6345 main (int argc
, char **argv
)
6349 int linker_was_run
= 0;
6350 int lang_n_infiles
= 0;
6351 int num_linker_inputs
= 0;
6352 char *explicit_link_files
;
6355 struct user_specs
*uptr
;
6356 char **old_argv
= argv
;
6358 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6359 on ?: in file-scope variable initializations. */
6360 asm_debug
= ASM_DEBUG_SPEC
;
6362 p
= argv
[0] + strlen (argv
[0]);
6363 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6367 xmalloc_set_program_name (programname
);
6369 expandargv (&argc
, &argv
);
6371 /* Determine if any expansions were made. */
6372 if (argv
!= old_argv
)
6373 at_file_supplied
= true;
6375 prune_options (&argc
, &argv
);
6377 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6378 /* Perform host dependent initialization when needed. */
6379 GCC_DRIVER_HOST_INITIALIZATION
;
6382 /* Unlock the stdio streams. */
6383 unlock_std_streams ();
6385 gcc_init_libintl ();
6387 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6388 signal (SIGINT
, fatal_error
);
6390 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6391 signal (SIGHUP
, fatal_error
);
6393 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6394 signal (SIGTERM
, fatal_error
);
6396 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6397 signal (SIGPIPE
, fatal_error
);
6400 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6401 receive the signal. A different setting is inheritable */
6402 signal (SIGCHLD
, SIG_DFL
);
6405 /* Allocate the argument vector. */
6408 obstack_init (&obstack
);
6410 /* Build multilib_select, et. al from the separate lines that make up each
6411 multilib selection. */
6413 const char *const *q
= multilib_raw
;
6416 obstack_init (&multilib_obstack
);
6417 while ((p
= *q
++) != (char *) 0)
6418 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6420 obstack_1grow (&multilib_obstack
, 0);
6421 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6423 q
= multilib_matches_raw
;
6424 while ((p
= *q
++) != (char *) 0)
6425 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6427 obstack_1grow (&multilib_obstack
, 0);
6428 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6430 q
= multilib_exclusions_raw
;
6431 while ((p
= *q
++) != (char *) 0)
6432 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6434 obstack_1grow (&multilib_obstack
, 0);
6435 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6438 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6441 obstack_1grow (&multilib_obstack
, ' ');
6442 obstack_grow (&multilib_obstack
,
6443 multilib_defaults_raw
[i
],
6444 strlen (multilib_defaults_raw
[i
]));
6448 obstack_1grow (&multilib_obstack
, 0);
6449 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6452 /* Set up to remember the pathname of gcc and any options
6453 needed for collect. We use argv[0] instead of programname because
6454 we need the complete pathname. */
6455 obstack_init (&collect_obstack
);
6456 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6457 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6458 xputenv (XOBFINISH (&collect_obstack
, char *));
6460 #ifdef INIT_ENVIRONMENT
6461 /* Set up any other necessary machine specific environment variables. */
6462 xputenv (INIT_ENVIRONMENT
);
6465 /* Make a table of what switches there are (switches, n_switches).
6466 Make a table of specified input files (infiles, n_infiles).
6467 Decode switches that are handled locally. */
6469 process_command (argc
, (const char **) argv
);
6471 /* Initialize the vector of specs to just the default.
6472 This means one element containing 0s, as a terminator. */
6474 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6475 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6476 n_compilers
= n_default_compilers
;
6478 /* Read specs from a file if there is one. */
6480 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6481 spec_version
, dir_separator_str
, NULL
);
6482 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6484 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6485 /* Read the specs file unless it is a default one. */
6486 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6487 read_specs (specs_file
, TRUE
);
6491 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6492 for any override of as, ld and libraries. */
6493 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6494 + strlen (just_machine_suffix
) + sizeof ("specs"));
6496 strcpy (specs_file
, standard_exec_prefix
);
6497 strcat (specs_file
, just_machine_suffix
);
6498 strcat (specs_file
, "specs");
6499 if (access (specs_file
, R_OK
) == 0)
6500 read_specs (specs_file
, TRUE
);
6502 /* Process any configure-time defaults specified for the command line
6503 options, via OPTION_DEFAULT_SPECS. */
6504 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6505 do_option_spec (option_default_specs
[i
].name
,
6506 option_default_specs
[i
].spec
);
6508 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6509 of the command line. */
6511 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6512 do_self_spec (driver_self_specs
[i
]);
6514 /* If not cross-compiling, look for executables in the standard
6516 if (*cross_compile
== '0')
6518 if (*md_exec_prefix
)
6520 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6521 PREFIX_PRIORITY_LAST
, 0, 0);
6525 /* Process sysroot_suffix_spec. */
6526 if (*sysroot_suffix_spec
!= 0
6527 && do_spec_2 (sysroot_suffix_spec
) == 0)
6529 if (argbuf_index
> 1)
6530 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6531 else if (argbuf_index
== 1)
6532 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6535 #ifdef HAVE_LD_SYSROOT
6536 /* Pass the --sysroot option to the linker, if it supports that. If
6537 there is a sysroot_suffix_spec, it has already been processed by
6538 this point, so target_system_root really is the system root we
6540 if (target_system_root
)
6542 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6543 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6544 set_spec ("link", XOBFINISH (&obstack
, const char *));
6548 /* Process sysroot_hdrs_suffix_spec. */
6549 if (*sysroot_hdrs_suffix_spec
!= 0
6550 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6552 if (argbuf_index
> 1)
6553 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6554 else if (argbuf_index
== 1)
6555 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6558 /* Look for startfiles in the standard places. */
6559 if (*startfile_prefix_spec
!= 0
6560 && do_spec_2 (startfile_prefix_spec
) == 0
6561 && do_spec_1 (" ", 0, NULL
) == 0)
6564 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6565 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6566 PREFIX_PRIORITY_LAST
, 0, 1);
6568 /* We should eventually get rid of all these and stick to
6569 startfile_prefix_spec exclusively. */
6570 else if (*cross_compile
== '0' || target_system_root
)
6572 if (*md_startfile_prefix
)
6573 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6574 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6576 if (*md_startfile_prefix_1
)
6577 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6578 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6580 /* If standard_startfile_prefix is relative, base it on
6581 standard_exec_prefix. This lets us move the installed tree
6582 as a unit. If GCC_EXEC_PREFIX is defined, base
6583 standard_startfile_prefix on that as well.
6585 If the prefix is relative, only search it for native compilers;
6586 otherwise we will search a directory containing host libraries. */
6587 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6588 add_sysrooted_prefix (&startfile_prefixes
,
6589 standard_startfile_prefix
, "BINUTILS",
6590 PREFIX_PRIORITY_LAST
, 0, 1);
6591 else if (*cross_compile
== '0')
6593 add_prefix (&startfile_prefixes
,
6594 concat (gcc_exec_prefix
6595 ? gcc_exec_prefix
: standard_exec_prefix
,
6597 standard_startfile_prefix
, NULL
),
6598 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6601 /* Sysrooted prefixes are relocated because target_system_root is
6602 also relocated by gcc_exec_prefix. */
6603 if (*standard_startfile_prefix_1
)
6604 add_sysrooted_prefix (&startfile_prefixes
,
6605 standard_startfile_prefix_1
, "BINUTILS",
6606 PREFIX_PRIORITY_LAST
, 0, 1);
6607 if (*standard_startfile_prefix_2
)
6608 add_sysrooted_prefix (&startfile_prefixes
,
6609 standard_startfile_prefix_2
, "BINUTILS",
6610 PREFIX_PRIORITY_LAST
, 0, 1);
6613 /* Process any user specified specs in the order given on the command
6615 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6617 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6619 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6622 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6623 if (gcc_exec_prefix
)
6624 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6625 spec_version
, dir_separator_str
, NULL
);
6627 /* Now we have the specs.
6628 Set the `valid' bits for switches that match anything in any spec. */
6630 validate_all_switches ();
6632 /* Now that we have the switches and the specs, set
6633 the subdirectory based on the options. */
6634 set_multilib_dir ();
6636 /* Warn about any switches that no pass was interested in. */
6638 for (i
= 0; (int) i
< n_switches
; i
++)
6639 if (! switches
[i
].validated
)
6640 error ("unrecognized option '-%s'", switches
[i
].part1
);
6642 /* Obey some of the options. */
6644 if (print_search_dirs
)
6646 printf (_("install: %s%s\n"),
6647 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6648 gcc_exec_prefix
? "" : machine_suffix
);
6649 printf (_("programs: %s\n"),
6650 build_search_list (&exec_prefixes
, "", false, false));
6651 printf (_("libraries: %s\n"),
6652 build_search_list (&startfile_prefixes
, "", false, true));
6656 if (print_file_name
)
6658 printf ("%s\n", find_file (print_file_name
));
6662 if (print_prog_name
)
6664 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6665 printf ("%s\n", (newname
? newname
: print_prog_name
));
6669 if (print_multi_lib
)
6671 print_multilib_info ();
6675 if (print_multi_directory
)
6677 if (multilib_dir
== NULL
)
6680 printf ("%s\n", multilib_dir
);
6686 if (target_system_root
)
6688 if (target_sysroot_suffix
)
6689 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6691 printf ("%s\n", target_system_root
);
6696 if (print_multi_os_directory
)
6698 if (multilib_os_dir
== NULL
)
6701 printf ("%s\n", multilib_os_dir
);
6705 if (print_sysroot_headers_suffix
)
6707 if (*sysroot_hdrs_suffix_spec
)
6709 printf("%s\n", (target_sysroot_hdrs_suffix
6710 ? target_sysroot_hdrs_suffix
6715 /* The error status indicates that only one set of fixed
6716 headers should be built. */
6717 fatal ("not configured with sysroot headers suffix");
6720 if (print_help_list
)
6726 printf (_("\nFor bug reporting instructions, please see:\n"));
6727 printf ("%s.\n", bug_report_url
);
6732 /* We do not exit here. Instead we have created a fake input file
6733 called 'help-dummy' which needs to be compiled, and we pass this
6734 on the various sub-processes, along with the --help switch.
6735 Ensure their output appears after ours. */
6736 fputc ('\n', stdout
);
6742 printf (_("%s %s%s\n"), programname
, pkgversion_string
,
6744 printf ("Copyright %s 2009 Free Software Foundation, Inc.\n",
6746 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6747 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6752 /* We do not exit here. We use the same mechanism of --help to print
6753 the version of the sub-processes. */
6754 fputc ('\n', stdout
);
6763 notice ("Target: %s\n", spec_machine
);
6764 notice ("Configured with: %s\n", configuration_arguments
);
6766 #ifdef THREAD_MODEL_SPEC
6767 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6768 but there's no point in doing all this processing just to get
6769 thread_model back. */
6770 obstack_init (&obstack
);
6771 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6772 obstack_1grow (&obstack
, '\0');
6773 thrmod
= XOBFINISH (&obstack
, const char *);
6775 thrmod
= thread_model
;
6778 notice ("Thread model: %s\n", thrmod
);
6780 /* compiler_version is truncated at the first space when initialized
6781 from version string, so truncate version_string at the first space
6782 before comparing. */
6783 for (n
= 0; version_string
[n
]; n
++)
6784 if (version_string
[n
] == ' ')
6787 if (! strncmp (version_string
, compiler_version
, n
)
6788 && compiler_version
[n
] == 0)
6789 notice ("gcc version %s %s\n", version_string
, pkgversion_string
);
6791 notice ("gcc driver version %s %sexecuting gcc version %s\n",
6792 version_string
, pkgversion_string
, compiler_version
);
6798 if (n_infiles
== added_libraries
)
6799 fatal ("no input files");
6801 /* Make a place to record the compiler output file names
6802 that correspond to the input files. */
6805 i
+= lang_specific_extra_outfiles
;
6806 outfiles
= XCNEWVEC (const char *, i
);
6808 /* Record which files were specified explicitly as link input. */
6810 explicit_link_files
= XCNEWVEC (char, n_infiles
);
6813 combine_inputs
= true;
6815 combine_inputs
= false;
6817 for (i
= 0; (int) i
< n_infiles
; i
++)
6819 const char *name
= infiles
[i
].name
;
6820 struct compiler
*compiler
= lookup_compiler (name
,
6822 infiles
[i
].language
);
6824 if (compiler
&& !(compiler
->combinable
))
6825 combine_inputs
= false;
6827 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6828 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6829 infiles
[i
].incompiler
= compiler
;
6833 input_file_compiler
= compiler
;
6834 infiles
[i
].incompiler
= compiler
;
6838 /* Since there is no compiler for this input file, assume it is a
6840 explicit_link_files
[i
] = 1;
6841 infiles
[i
].incompiler
= NULL
;
6843 infiles
[i
].compiled
= false;
6844 infiles
[i
].preprocessed
= false;
6847 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6848 fatal ("cannot specify -o with -c or -S with multiple files");
6850 if (combine_flag
&& save_temps_flag
)
6852 bool save_combine_inputs
= combine_inputs
;
6853 /* Must do a separate pre-processing pass for C & Objective-C files, to
6854 obtain individual .i files. */
6856 combine_inputs
= false;
6857 for (i
= 0; (int) i
< n_infiles
; i
++)
6859 int this_file_error
= 0;
6861 input_file_number
= i
;
6862 set_input (infiles
[i
].name
);
6863 if (infiles
[i
].incompiler
6864 && (infiles
[i
].incompiler
)->needs_preprocessing
)
6865 input_file_compiler
= infiles
[i
].incompiler
;
6869 if (input_file_compiler
)
6871 if (input_file_compiler
->spec
[0] == '#')
6873 error ("%s: %s compiler not installed on this system",
6874 input_filename
, &input_file_compiler
->spec
[1]);
6875 this_file_error
= 1;
6879 value
= do_spec (input_file_compiler
->spec
);
6880 infiles
[i
].preprocessed
= true;
6881 if (!have_o_argbuf_index
)
6882 fatal ("spec '%s' is invalid", input_file_compiler
->spec
);
6883 infiles
[i
].name
= argbuf
[have_o_argbuf_index
];
6884 infiles
[i
].incompiler
6885 = lookup_compiler (infiles
[i
].name
,
6886 strlen (infiles
[i
].name
),
6887 infiles
[i
].language
);
6890 this_file_error
= 1;
6894 if (this_file_error
)
6896 delete_failure_queue ();
6900 clear_failure_queue ();
6902 combine_inputs
= save_combine_inputs
;
6905 for (i
= 0; (int) i
< n_infiles
; i
++)
6907 int this_file_error
= 0;
6909 /* Tell do_spec what to substitute for %i. */
6911 input_file_number
= i
;
6912 set_input (infiles
[i
].name
);
6914 if (infiles
[i
].compiled
)
6917 /* Use the same thing in %o, unless cp->spec says otherwise. */
6919 outfiles
[i
] = input_filename
;
6921 /* Figure out which compiler from the file's suffix. */
6923 if (! combine_inputs
)
6925 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6926 infiles
[i
].language
);
6928 input_file_compiler
= infiles
[i
].incompiler
;
6930 if (input_file_compiler
)
6932 /* Ok, we found an applicable compiler. Run its spec. */
6934 if (input_file_compiler
->spec
[0] == '#')
6936 error ("%s: %s compiler not installed on this system",
6937 input_filename
, &input_file_compiler
->spec
[1]);
6938 this_file_error
= 1;
6942 value
= do_spec (input_file_compiler
->spec
);
6943 infiles
[i
].compiled
= true;
6945 this_file_error
= 1;
6949 /* If this file's name does not contain a recognized suffix,
6950 record it as explicit linker input. */
6953 explicit_link_files
[i
] = 1;
6955 /* Clear the delete-on-failure queue, deleting the files in it
6956 if this compilation failed. */
6958 if (this_file_error
)
6960 delete_failure_queue ();
6963 /* If this compilation succeeded, don't delete those files later. */
6964 clear_failure_queue ();
6967 /* Reset the input file name to the first compile/object file name, for use
6968 with %b in LINK_SPEC. We use the first input file that we can find
6969 a compiler to compile it instead of using infiles.language since for
6970 languages other than C we use aliases that we then lookup later. */
6975 for (i
= 0; i
< n_infiles
; i
++)
6976 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6978 set_input (infiles
[i
].name
);
6983 if (error_count
== 0)
6985 /* Make sure INPUT_FILE_NUMBER points to first available open
6987 input_file_number
= n_infiles
;
6988 if (lang_specific_pre_link ())
6992 /* Determine if there are any linker input files. */
6993 num_linker_inputs
= 0;
6994 for (i
= 0; (int) i
< n_infiles
; i
++)
6995 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6996 num_linker_inputs
++;
6998 /* Run ld to link all the compiler output files. */
7000 if (num_linker_inputs
> 0 && error_count
== 0 && print_subprocess_help
< 2)
7002 int tmp
= execution_count
;
7004 /* We'll use ld if we can't find collect2. */
7005 if (! strcmp (linker_name_spec
, "collect2"))
7007 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7009 linker_name_spec
= "ld";
7011 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7013 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7014 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7016 if (print_subprocess_help
== 1)
7018 printf (_("\nLinker options\n==============\n\n"));
7019 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7020 " to the linker.\n\n"));
7023 value
= do_spec (link_command_spec
);
7026 linker_was_run
= (tmp
!= execution_count
);
7029 /* If options said don't run linker,
7030 complain about input files to be given to the linker. */
7032 if (! linker_was_run
&& error_count
== 0)
7033 for (i
= 0; (int) i
< n_infiles
; i
++)
7034 if (explicit_link_files
[i
]
7035 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7036 error ("%s: linker input file unused because linking not done",
7039 /* Delete some or all of the temporary files we made. */
7042 delete_failure_queue ();
7043 delete_temp_files ();
7045 if (print_help_list
)
7047 printf (("\nFor bug reporting instructions, please see:\n"));
7048 printf ("%s\n", bug_report_url
);
7051 return (signal_count
!= 0 ? 2
7052 : error_count
> 0 ? (pass_exit_codes
? greatest_status
: 1)
7056 /* Find the proper compilation spec for the file name NAME,
7057 whose length is LENGTH. LANGUAGE is the specified language,
7058 or 0 if this file is to be passed to the linker. */
7060 static struct compiler
*
7061 lookup_compiler (const char *name
, size_t length
, const char *language
)
7063 struct compiler
*cp
;
7065 /* If this was specified by the user to be a linker input, indicate that. */
7066 if (language
!= 0 && language
[0] == '*')
7069 /* Otherwise, look for the language, if one is spec'd. */
7072 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7073 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7076 error ("language %s not recognized", language
);
7080 /* Look for a suffix. */
7081 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7083 if (/* The suffix `-' matches only the file name `-'. */
7084 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7085 || (strlen (cp
->suffix
) < length
7086 /* See if the suffix matches the end of NAME. */
7087 && !strcmp (cp
->suffix
,
7088 name
+ length
- strlen (cp
->suffix
))
7093 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7094 /* Look again, but case-insensitively this time. */
7096 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7098 if (/* The suffix `-' matches only the file name `-'. */
7099 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7100 || (strlen (cp
->suffix
) < length
7101 /* See if the suffix matches the end of NAME. */
7102 && ((!strcmp (cp
->suffix
,
7103 name
+ length
- strlen (cp
->suffix
))
7104 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7105 && !strcasecmp (cp
->suffix
,
7106 name
+ length
- strlen (cp
->suffix
)))
7112 if (cp
>= compilers
)
7114 if (cp
->spec
[0] != '@')
7115 /* A non-alias entry: return it. */
7118 /* An alias entry maps a suffix to a language.
7119 Search for the language; pass 0 for NAME and LENGTH
7120 to avoid infinite recursion if language not found. */
7121 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7127 save_string (const char *s
, int len
)
7129 char *result
= XNEWVEC (char, len
+ 1);
7131 memcpy (result
, s
, len
);
7137 pfatal_with_name (const char *name
)
7139 perror_with_name (name
);
7140 delete_temp_files ();
7145 perror_with_name (const char *name
)
7147 error ("%s: %s", name
, xstrerror (errno
));
7150 /* Output an error message and exit. */
7153 fancy_abort (const char *file
, int line
, const char *func
)
7155 fatal_ice ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
7158 /* Output an error message and exit. */
7161 fatal_ice (const char *cmsgid
, ...)
7165 va_start (ap
, cmsgid
);
7167 fprintf (stderr
, "%s: ", programname
);
7168 vfprintf (stderr
, _(cmsgid
), ap
);
7170 fprintf (stderr
, "\n");
7171 delete_temp_files ();
7172 exit (pass_exit_codes
? ICE_EXIT_CODE
: 1);
7176 fatal (const char *cmsgid
, ...)
7180 va_start (ap
, cmsgid
);
7182 fprintf (stderr
, "%s: ", programname
);
7183 vfprintf (stderr
, _(cmsgid
), ap
);
7185 fprintf (stderr
, "\n");
7186 delete_temp_files ();
7190 /* The argument is actually c-format, not gcc-internal-format,
7191 but because functions with identical names are used through
7192 the rest of the compiler with gcc-internal-format, we just
7193 need to hope all users of these functions use the common
7194 subset between c-format and gcc-internal-format. */
7197 error (const char *gmsgid
, ...)
7201 va_start (ap
, gmsgid
);
7202 fprintf (stderr
, "%s: ", programname
);
7203 vfprintf (stderr
, _(gmsgid
), ap
);
7206 fprintf (stderr
, "\n");
7210 notice (const char *cmsgid
, ...)
7214 va_start (ap
, cmsgid
);
7215 vfprintf (stderr
, _(cmsgid
), ap
);
7220 validate_switches_from_spec (const char *spec
)
7222 const char *p
= spec
;
7225 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7226 /* We have a switch spec. */
7227 p
= validate_switches (p
+ 1);
7231 validate_all_switches (void)
7233 struct compiler
*comp
;
7234 struct spec_list
*spec
;
7236 for (comp
= compilers
; comp
->spec
; comp
++)
7237 validate_switches_from_spec (comp
->spec
);
7239 /* Look through the linked list of specs read from the specs file. */
7240 for (spec
= specs
; spec
; spec
= spec
->next
)
7241 validate_switches_from_spec (*spec
->ptr_spec
);
7243 validate_switches_from_spec (link_command_spec
);
7246 /* Look at the switch-name that comes after START
7247 and mark as valid all supplied switches that match it. */
7250 validate_switches (const char *start
)
7252 const char *p
= start
;
7256 bool suffix
= false;
7257 bool starred
= false;
7259 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7268 if (*p
== '.' || *p
== ',')
7272 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7273 || *p
== ',' || *p
== '.' || *p
== '@')
7278 starred
= true, p
++;
7284 /* Mark all matching switches as valid. */
7285 for (i
= 0; i
< n_switches
; i
++)
7286 if (!strncmp (switches
[i
].part1
, atom
, len
)
7287 && (starred
|| switches
[i
].part1
[len
] == 0))
7288 switches
[i
].validated
= 1;
7292 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7295 if (*p
&& p
[-1] == ':')
7297 while (*p
&& *p
!= ';' && *p
!= '}')
7302 if (*p
== '{' || *p
== '<')
7303 p
= validate_switches (p
+1);
7304 else if (p
[0] == 'W' && p
[1] == '{')
7305 p
= validate_switches (p
+2);
7312 if (*p
&& p
[-1] == ';')
7326 static struct mdswitchstr
*mdswitches
;
7327 static int n_mdswitches
;
7329 /* Check whether a particular argument was used. The first time we
7330 canonicalize the switches to keep only the ones we care about. */
7333 used_arg (const char *p
, int len
)
7338 const char *replace
;
7343 static struct mswitchstr
*mswitches
;
7344 static int n_mswitches
;
7349 struct mswitchstr
*matches
;
7353 /* Break multilib_matches into the component strings of string
7354 and replacement string. */
7355 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7360 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7362 q
= multilib_matches
;
7371 fatal ("multilib spec '%s' is invalid", multilib_matches
);
7375 matches
[i
].len
= q
- matches
[i
].str
;
7377 matches
[i
].replace
= ++q
;
7378 while (*q
!= ';' && *q
!= '\0')
7381 goto invalid_matches
;
7384 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7390 /* Now build a list of the replacement string for switches that we care
7391 about. Make sure we allocate at least one entry. This prevents
7392 xmalloc from calling fatal, and prevents us from re-executing this
7395 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7396 for (i
= 0; i
< n_switches
; i
++)
7397 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7399 int xlen
= strlen (switches
[i
].part1
);
7400 for (j
= 0; j
< cnt
; j
++)
7401 if (xlen
== matches
[j
].len
7402 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7404 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7405 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7406 mswitches
[n_mswitches
].replace
= (char *) 0;
7407 mswitches
[n_mswitches
].rep_len
= 0;
7413 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7414 on the command line nor any options mutually incompatible with
7416 for (i
= 0; i
< n_mdswitches
; i
++)
7420 for (q
= multilib_options
; *q
!= '\0'; q
++)
7426 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7427 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7429 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7436 if (*q
!= ' ' && *q
!= '\0')
7438 while (*r
!= ' ' && *r
!= '\0')
7441 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7444 if (used_arg (r
, q
- r
))
7449 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7450 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7451 mswitches
[n_mswitches
].replace
= (char *) 0;
7452 mswitches
[n_mswitches
].rep_len
= 0;
7465 for (i
= 0; i
< n_mswitches
; i
++)
7466 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7473 default_arg (const char *p
, int len
)
7477 for (i
= 0; i
< n_mdswitches
; i
++)
7478 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7484 /* Work out the subdirectory to use based on the options. The format of
7485 multilib_select is a list of elements. Each element is a subdirectory
7486 name followed by a list of options followed by a semicolon. The format
7487 of multilib_exclusions is the same, but without the preceding
7488 directory. First gcc will check the exclusions, if none of the options
7489 beginning with an exclamation point are present, and all of the other
7490 options are present, then we will ignore this completely. Passing
7491 that, gcc will consider each multilib_select in turn using the same
7492 rules for matching the options. If a match is found, that subdirectory
7496 set_multilib_dir (void)
7499 unsigned int this_path_len
;
7500 const char *this_path
, *this_arg
;
7501 const char *start
, *end
;
7503 int ok
, ndfltok
, first
;
7506 start
= multilib_defaults
;
7507 while (*start
== ' ' || *start
== '\t')
7509 while (*start
!= '\0')
7512 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7514 while (*start
== ' ' || *start
== '\t')
7522 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7523 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7525 while (*start
== ' ' || *start
== '\t')
7531 for (end
= start
+ 1;
7532 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7535 obstack_grow (&multilib_obstack
, start
, end
- start
);
7536 obstack_1grow (&multilib_obstack
, 0);
7537 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7538 mdswitches
[i
++].len
= end
- start
;
7545 p
= multilib_exclusions
;
7548 /* Ignore newlines. */
7555 /* Check the arguments. */
7562 fatal ("multilib exclusions '%s' is invalid",
7563 multilib_exclusions
);
7573 while (*p
!= ' ' && *p
!= ';')
7576 goto invalid_exclusions
;
7580 if (*this_arg
!= '!')
7588 ok
= used_arg (this_arg
, p
- this_arg
);
7603 p
= multilib_select
;
7606 /* Ignore newlines. */
7613 /* Get the initial path. */
7620 fatal ("multilib select '%s' is invalid",
7625 this_path_len
= p
- this_path
;
7627 /* Check the arguments. */
7634 goto invalid_select
;
7643 while (*p
!= ' ' && *p
!= ';')
7646 goto invalid_select
;
7650 if (*this_arg
!= '!')
7658 /* If this is a default argument, we can just ignore it.
7659 This is true even if this_arg begins with '!'. Beginning
7660 with '!' does not mean that this argument is necessarily
7661 inappropriate for this library: it merely means that
7662 there is a more specific library which uses this
7663 argument. If this argument is a default, we need not
7664 consider that more specific library. */
7665 ok
= used_arg (this_arg
, p
- this_arg
);
7672 if (default_arg (this_arg
, p
- this_arg
))
7681 if (this_path_len
!= 1
7682 || this_path
[0] != '.')
7684 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7687 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7688 new_multilib_dir
[this_path_len
] = '\0';
7689 q
= strchr (new_multilib_dir
, ':');
7692 multilib_dir
= new_multilib_dir
;
7699 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7701 while (q
< end
&& *q
!= ':')
7705 char *new_multilib_os_dir
= XNEWVEC (char, end
- q
);
7706 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7707 new_multilib_os_dir
[end
- q
- 1] = '\0';
7708 multilib_os_dir
= new_multilib_os_dir
;
7716 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7717 && strcmp (multilib_os_dir
, ".") == 0)
7719 free (CONST_CAST (char *, multilib_os_dir
));
7720 multilib_os_dir
= NULL
;
7722 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7723 multilib_os_dir
= multilib_dir
;
7726 /* Print out the multiple library subdirectory selection
7727 information. This prints out a series of lines. Each line looks
7728 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7729 required. Only the desired options are printed out, the negative
7730 matches. The options are print without a leading dash. There are
7731 no spaces to make it easy to use the information in the shell.
7732 Each subdirectory is printed only once. This assumes the ordering
7733 generated by the genmultilib script. Also, we leave out ones that match
7737 print_multilib_info (void)
7739 const char *p
= multilib_select
;
7740 const char *last_path
= 0, *this_path
;
7742 unsigned int last_path_len
= 0;
7747 /* Ignore newlines. */
7754 /* Get the initial path. */
7761 fatal ("multilib select '%s' is invalid", multilib_select
);
7767 /* When --disable-multilib was used but target defines
7768 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7769 to find multilib_os_dir, so skip them from output. */
7770 if (this_path
[0] == '.' && this_path
[1] == ':')
7773 /* Check for matches with the multilib_exclusions. We don't bother
7774 with the '!' in either list. If any of the exclusion rules match
7775 all of its options with the select rule, we skip it. */
7777 const char *e
= multilib_exclusions
;
7778 const char *this_arg
;
7783 /* Ignore newlines. */
7790 /* Check the arguments. */
7799 fatal ("multilib exclusion '%s' is invalid",
7800 multilib_exclusions
);
7811 while (*e
!= ' ' && *e
!= ';')
7814 goto invalid_exclusion
;
7822 int len
= e
- this_arg
;
7825 goto invalid_select
;
7829 while (*q
!= ' ' && *q
!= ';')
7832 goto invalid_select
;
7836 if (! strncmp (arg
, this_arg
,
7837 (len
< q
- arg
) ? q
- arg
: len
)
7838 || default_arg (this_arg
, e
- this_arg
))
7868 /* If this is a duplicate, skip it. */
7869 skip
= (last_path
!= 0
7870 && (unsigned int) (p
- this_path
) == last_path_len
7871 && ! strncmp (last_path
, this_path
, last_path_len
));
7873 last_path
= this_path
;
7874 last_path_len
= p
- this_path
;
7877 /* If this directory requires any default arguments, we can skip
7878 it. We will already have printed a directory identical to
7879 this one which does not require that default argument. */
7890 goto invalid_select
;
7897 while (*q
!= ' ' && *q
!= ';')
7900 goto invalid_select
;
7905 && default_arg (arg
, q
- arg
))
7920 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7931 goto invalid_select
;
7939 use_arg
= *p
!= '!';
7944 while (*p
!= ' ' && *p
!= ';')
7947 goto invalid_select
;
7959 /* If there are extra options, print them now. */
7960 if (multilib_extra
&& *multilib_extra
)
7962 int print_at
= TRUE
;
7965 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7986 /* getenv built-in spec function.
7988 Returns the value of the environment variable given by its first
7989 argument, concatenated with the second argument. If the
7990 environment variable is not defined, a fatal error is issued. */
7993 getenv_spec_function (int argc
, const char **argv
)
8003 value
= getenv (argv
[0]);
8005 fatal ("environment variable \"%s\" not defined", argv
[0]);
8007 /* We have to escape every character of the environment variable so
8008 they are not interpreted as active spec characters. A
8009 particularly painful case is when we are reading a variable
8010 holding a windows path complete with \ separators. */
8011 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
8012 result
= XNEWVAR (char, len
);
8013 for (ptr
= result
; *value
; ptr
+= 2)
8019 strcpy (ptr
, argv
[1]);
8024 /* if-exists built-in spec function.
8026 Checks to see if the file specified by the absolute pathname in
8027 ARGS exists. Returns that pathname if found.
8029 The usual use for this function is to check for a library file
8030 (whose name has been expanded with %s). */
8033 if_exists_spec_function (int argc
, const char **argv
)
8035 /* Must have only one argument. */
8036 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8042 /* if-exists-else built-in spec function.
8044 This is like if-exists, but takes an additional argument which
8045 is returned if the first argument does not exist. */
8048 if_exists_else_spec_function (int argc
, const char **argv
)
8050 /* Must have exactly two arguments. */
8054 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8060 /* replace-outfile built-in spec function.
8062 This looks for the first argument in the outfiles array's name and
8063 replaces it with the second argument. */
8066 replace_outfile_spec_function (int argc
, const char **argv
)
8069 /* Must have exactly two arguments. */
8073 for (i
= 0; i
< n_infiles
; i
++)
8075 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
8076 outfiles
[i
] = xstrdup (argv
[1]);
8081 /* Given two version numbers, compares the two numbers.
8082 A version number must match the regular expression
8083 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8086 compare_version_strings (const char *v1
, const char *v2
)
8091 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8092 REG_EXTENDED
| REG_NOSUB
) != 0)
8094 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8095 if (rresult
== REG_NOMATCH
)
8096 fatal ("invalid version number `%s'", v1
);
8097 else if (rresult
!= 0)
8099 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8100 if (rresult
== REG_NOMATCH
)
8101 fatal ("invalid version number `%s'", v2
);
8102 else if (rresult
!= 0)
8105 return strverscmp (v1
, v2
);
8109 /* version_compare built-in spec function.
8111 This takes an argument of the following form:
8113 <comparison-op> <arg1> [<arg2>] <switch> <result>
8115 and produces "result" if the comparison evaluates to true,
8116 and nothing if it doesn't.
8118 The supported <comparison-op> values are:
8120 >= true if switch is a later (or same) version than arg1
8122 < true if switch is an earlier version than arg1
8124 >< true if switch is arg1 or later, and earlier than arg2
8125 <> true if switch is earlier than arg1 or is arg2 or later
8127 If the switch is not present, the condition is false unless
8128 the first character of the <comparison-op> is '!'.
8131 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8132 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8135 version_compare_spec_function (int argc
, const char **argv
)
8139 const char *switch_value
= NULL
;
8144 fatal ("too few arguments to %%:version-compare");
8145 if (argv
[0][0] == '\0')
8147 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8149 if (argc
!= nargs
+ 3)
8150 fatal ("too many arguments to %%:version-compare");
8152 switch_len
= strlen (argv
[nargs
+ 1]);
8153 for (i
= 0; i
< n_switches
; i
++)
8154 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8155 && check_live_switch (i
, switch_len
))
8156 switch_value
= switches
[i
].part1
+ switch_len
;
8158 if (switch_value
== NULL
)
8162 comp1
= compare_version_strings (switch_value
, argv
[1]);
8164 comp2
= compare_version_strings (switch_value
, argv
[2]);
8166 comp2
= -1; /* This value unused. */
8169 switch (argv
[0][0] << 8 | argv
[0][1])
8171 case '>' << 8 | '=':
8172 result
= comp1
>= 0;
8174 case '!' << 8 | '<':
8175 result
= comp1
>= 0 || switch_value
== NULL
;
8180 case '!' << 8 | '>':
8181 result
= comp1
< 0 || switch_value
== NULL
;
8183 case '>' << 8 | '<':
8184 result
= comp1
>= 0 && comp2
< 0;
8186 case '<' << 8 | '>':
8187 result
= comp1
< 0 || comp2
>= 0;
8191 fatal ("unknown operator '%s' in %%:version-compare", argv
[0]);
8196 return argv
[nargs
+ 2];
8199 /* %:include builtin spec function. This differs from %include in that it
8200 can be nested inside a spec, and thus be conditionalized. It takes
8201 one argument, the filename, and looks for it in the startfile path.
8202 The result is always NULL, i.e. an empty expansion. */
8205 include_spec_function (int argc
, const char **argv
)
8212 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8213 read_specs (file
? file
: argv
[0], FALSE
);
8218 /* %:print-asm-header spec function. Print a banner to say that the
8219 following output is from the assembler. */
8222 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8223 const char **argv ATTRIBUTE_UNUSED
)
8225 printf (_("Assembler options\n=================\n\n"));
8226 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));