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,
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers. It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec". */
33 /* A Short Introduction to Adding a Command-Line Option.
35 Before adding a command-line option, consider if it is really
36 necessary. Each additional command-line option adds complexity and
37 is difficult to remove in subsequent versions.
39 In the following, consider adding the command-line argument
42 1. Each command-line option is specified in the specs file. The
43 notation is described below in the comment entitled "The Specs
46 2. In this file, add an entry to "option_map" equating the long
47 `--' argument version and any shorter, single letter version. Read
48 the comments in the declaration of "struct option_map" for an
49 explanation. Do not omit the first `-'.
51 3. Look in the "specs" file to determine which program or option
52 list should be given the argument, e.g., "cc1_options". Add the
53 appropriate syntax for the shorter option version to the
54 corresponding "const char *" entry in this file. Omit the first
55 `-' from the option. For example, use `-bar', rather than `--bar'.
57 4. If the argument takes an argument, e.g., `--baz argument1',
58 modify either DEFAULT_SWITCH_TAKES_ARG or
59 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
62 5. Document the option in this file's display_help(). If the
63 option is passed to a subprogram, modify its corresponding
64 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
67 6. Compile and test. Make sure that your new specs file is being
68 read. For example, use a debugger to investigate the value of
69 "specs_file" in main(). */
73 #include "coretypes.h"
74 #include "multilib.h" /* before tm.h */
77 #if ! defined( SIGCHLD ) && defined( SIGCLD )
78 # define SIGCHLD SIGCLD
85 #include "diagnostic.h"
90 # include <sys/mman.h>
92 /* This is on Solaris. */
93 # include <sys/types.h>
98 # define MAP_FAILED ((void *)-1)
101 /* By default there is no special suffix for target executables. */
102 /* FIXME: when autoconf is fixed, remove the host check - dj */
103 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
104 #define HAVE_TARGET_EXECUTABLE_SUFFIX
107 /* By default there is no special suffix for host executables. */
108 #ifdef HOST_EXECUTABLE_SUFFIX
109 #define HAVE_HOST_EXECUTABLE_SUFFIX
111 #define HOST_EXECUTABLE_SUFFIX ""
114 /* By default, the suffix for target object files is ".o". */
115 #ifdef TARGET_OBJECT_SUFFIX
116 #define HAVE_TARGET_OBJECT_SUFFIX
118 #define TARGET_OBJECT_SUFFIX ".o"
121 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
123 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
124 #ifndef LIBRARY_PATH_ENV
125 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
129 #define kill(p,s) raise(s)
132 /* If a stage of compilation returns an exit status >= 1,
133 compilation of that file ceases. */
135 #define MIN_FATAL_STATUS 1
137 /* Flag set by cppspec.c to 1. */
140 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
141 static bool at_file_supplied
;
143 /* Definition of string containing the arguments given to configure. */
144 #include "configargs.h"
146 /* Flag saying to print the command line options understood by gcc and its
149 static int print_help_list
;
151 /* Flag saying to print the version of gcc and its sub-processes. */
153 static int print_version
;
155 /* Flag indicating whether we should print the command and arguments */
157 static int verbose_flag
;
159 /* Flag indicating whether we should ONLY print the command and
160 arguments (like verbose_flag) without executing the command.
161 Displayed arguments are quoted so that the generated command
162 line is suitable for execution. This is intended for use in
163 shell scripts to capture the driver-generated command line. */
164 static int verbose_only_flag
;
166 /* Flag indicating how to print command line options of sub-processes. */
168 static int print_subprocess_help
;
170 /* Whether we should report subprocess execution times to a file. */
172 FILE *report_times_to_file
= NULL
;
174 /* Nonzero means place this string before uses of /, so that include
175 and library files can be found in an alternate location. */
177 #ifdef TARGET_SYSTEM_ROOT
178 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
180 static const char *target_system_root
= 0;
183 /* Nonzero means pass the updated target_system_root to the compiler. */
185 static int target_system_root_changed
;
187 /* Nonzero means append this string to target_system_root. */
189 static const char *target_sysroot_suffix
= 0;
191 /* Nonzero means append this string to target_system_root for headers. */
193 static const char *target_sysroot_hdrs_suffix
= 0;
195 /* Nonzero means write "temp" files in source directory
196 and use the source file's name in them, and don't delete them. */
198 static enum save_temps
{
199 SAVE_TEMPS_NONE
, /* no -save-temps */
200 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
201 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
204 /* Output file to use to get the object directory for -save-temps=obj */
205 static char *save_temps_prefix
= 0;
206 static size_t save_temps_length
= 0;
208 /* The compiler version. */
210 static const char *compiler_version
;
212 /* The target version. */
214 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
216 /* The target machine. */
218 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
220 /* Nonzero if cross-compiling.
221 When -b is used, the value comes from the `specs' file. */
223 #ifdef CROSS_DIRECTORY_STRUCTURE
224 static const char *cross_compile
= "1";
226 static const char *cross_compile
= "0";
229 /* Greatest exit code of sub-processes that has been encountered up to
231 static int greatest_status
= 1;
233 /* This is the obstack which we use to allocate many strings. */
235 static struct obstack obstack
;
237 /* This is the obstack to build an environment variable to pass to
238 collect2 that describes all of the relevant switches of what to
239 pass the compiler in building the list of pointers to constructors
242 static struct obstack collect_obstack
;
244 /* Forward declaration for prototypes. */
248 static void init_spec (void);
249 static void store_arg (const char *, int, int);
250 static void insert_wrapper (const char *);
251 static char *load_specs (const char *);
252 static void read_specs (const char *, int);
253 static void set_spec (const char *, const char *);
254 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
255 static char *build_search_list (const struct path_prefix
*, const char *,
257 static void xputenv (const char *);
258 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
260 static int access_check (const char *, int);
261 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
262 static void add_prefix (struct path_prefix
*, const char *, const char *,
264 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
265 const char *, int, int, int);
266 static void translate_options (int *, const char *const **);
267 static char *skip_whitespace (char *);
268 static void delete_if_ordinary (const char *);
269 static void delete_temp_files (void);
270 static void delete_failure_queue (void);
271 static void clear_failure_queue (void);
272 static int check_live_switch (int, int);
273 static const char *handle_braces (const char *);
274 static inline bool input_suffix_matches (const char *, const char *);
275 static inline bool switch_matches (const char *, const char *, int);
276 static inline void mark_matching_switches (const char *, const char *, int);
277 static inline void process_marked_switches (void);
278 static const char *process_brace_body (const char *, const char *, const char *, int, int);
279 static const struct spec_function
*lookup_spec_function (const char *);
280 static const char *eval_spec_function (const char *, const char *);
281 static const char *handle_spec_function (const char *);
282 static char *save_string (const char *, int);
283 static void set_collect_gcc_options (void);
284 static int do_spec_1 (const char *, int, const char *);
285 static int do_spec_2 (const char *);
286 static void do_option_spec (const char *, const char *);
287 static void do_self_spec (const char *);
288 static const char *find_file (const char *);
289 static int is_directory (const char *, bool);
290 static const char *validate_switches (const char *);
291 static void validate_all_switches (void);
292 static inline void validate_switches_from_spec (const char *);
293 static void give_switch (int, int);
294 static int used_arg (const char *, int);
295 static int default_arg (const char *, int);
296 static void set_multilib_dir (void);
297 static void print_multilib_info (void);
298 static void perror_with_name (const char *);
299 static void display_help (void);
300 static void add_preprocessor_option (const char *, int);
301 static void add_assembler_option (const char *, int);
302 static void add_linker_option (const char *, int);
303 static void process_command (int, const char **);
304 static int execute (void);
305 static void alloc_args (void);
306 static void clear_args (void);
307 static void fatal_signal (int);
308 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
309 static void init_gcc_specs (struct obstack
*, const char *, const char *,
312 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
313 static const char *convert_filename (const char *, int, int);
316 static const char *getenv_spec_function (int, const char **);
317 static const char *if_exists_spec_function (int, const char **);
318 static const char *if_exists_else_spec_function (int, const char **);
319 static const char *replace_outfile_spec_function (int, const char **);
320 static const char *remove_outfile_spec_function (int, const char **);
321 static const char *version_compare_spec_function (int, const char **);
322 static const char *include_spec_function (int, const char **);
323 static const char *find_file_spec_function (int, const char **);
324 static const char *find_plugindir_spec_function (int, const char **);
325 static const char *print_asm_header_spec_function (int, const char **);
326 static const char *compare_debug_dump_opt_spec_function (int, const char **);
327 static const char *compare_debug_self_opt_spec_function (int, const char **);
328 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
330 /* The Specs Language
332 Specs are strings containing lines, each of which (if not blank)
333 is made up of a program name, and arguments separated by spaces.
334 The program name must be exact and start from root, since no path
335 is searched and it is unreliable to depend on the current working directory.
336 Redirection of input or output is not supported; the subprograms must
337 accept filenames saying what files to read and write.
339 In addition, the specs can contain %-sequences to substitute variable text
340 or for conditional text. Here is a table of all defined %-sequences.
341 Note that spaces are not generated automatically around the results of
342 expanding these sequences; therefore, you can concatenate them together
343 or with constant text in a single argument.
345 %% substitute one % into the program name or argument.
346 %i substitute the name of the input file being processed.
347 %b substitute the basename of the input file being processed.
348 This is the substring up to (and not including) the last period
349 and not including the directory unless -save-temps was specified
350 to put temporaries in a different location.
351 %B same as %b, but include the file suffix (text after the last period).
353 substitute a file name that has suffix SUFFIX and is chosen
354 once per compilation, and mark the argument a la %d. To reduce
355 exposure to denial-of-service attacks, the file name is now
356 chosen in a way that is hard to predict even when previously
357 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
358 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
359 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
360 had been pre-processed. Previously, %g was simply substituted
361 with a file name chosen once per compilation, without regard
362 to any appended suffix (which was therefore treated just like
363 ordinary text), making such attacks more likely to succeed.
365 like %g, but if -pipe is in effect, expands simply to "-".
367 like %g, but if -pipe is in effect, expands to nothing. (We have both
368 %| and %m to accommodate differences between system assemblers; see
369 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
371 like %g, but generates a new temporary file name even if %uSUFFIX
374 substitutes the last file name generated with %uSUFFIX, generating a
375 new one if there is no such last file name. In the absence of any
376 %uSUFFIX, this is just like %gSUFFIX, except they don't share
377 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
378 would involve the generation of two distinct file names, one
379 for each `%g.s' and another for each `%U.s'. Previously, %U was
380 simply substituted with a file name chosen for the previous %u,
381 without regard to any appended suffix.
383 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
384 writable, and if save-temps is off; otherwise, substitute the name
385 of a temporary file, just like %u. This temporary file is not
386 meant for communication between processes, but rather as a junk
389 substitutes .SUFFIX for the suffixes of a matched switch's args when
390 it is subsequently output with %*. SUFFIX is terminated by the next
392 %d marks the argument containing or following the %d as a
393 temporary file name, so that that file will be deleted if GCC exits
394 successfully. Unlike %g, this contributes no text to the argument.
395 %w marks the argument containing or following the %w as the
396 "output file" of this compilation. This puts the argument
397 into the sequence of arguments that %o will substitute later.
398 %V indicates that this compilation produces no "output file".
400 like %{...} but mark last argument supplied within
401 as a file to be deleted on failure.
402 %o substitutes the names of all the output files, with spaces
403 automatically placed around them. You should write spaces
404 around the %o as well or the results are undefined.
405 %o is for use in the specs for running the linker.
406 Input files whose names have no recognized suffix are not compiled
407 at all, but they are included among the output files, so they will
409 %O substitutes the suffix for object files. Note that this is
410 handled specially when it immediately follows %g, %u, or %U
411 (with or without a suffix argument) because of the need for
412 those to form complete file names. The handling is such that
413 %O is treated exactly as if it had already been substituted,
414 except that %g, %u, and %U do not currently support additional
415 SUFFIX characters following %O as they would following, for
417 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
418 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
419 and -B options) and -imultilib as necessary.
420 %s current argument is the name of a library or startup file of some sort.
421 Search for that file in a standard list of directories
422 and substitute the full name found.
423 %eSTR Print STR as an error message. STR is terminated by a newline.
424 Use this when inconsistent options are detected.
425 %nSTR Print STR as a notice. STR is terminated by a newline.
426 %x{OPTION} Accumulate an option for %X.
427 %X Output the accumulated linker options specified by compilations.
428 %Y Output the accumulated assembler options specified by compilations.
429 %Z Output the accumulated preprocessor options specified by compilations.
430 %a process ASM_SPEC as a spec.
431 This allows config.h to specify part of the spec for running as.
432 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
433 used here. This can be used to run a post-processor after the
434 assembler has done its job.
435 %D Dump out a -L option for each directory in startfile_prefixes.
436 If multilib_dir is set, extra entries are generated with it affixed.
437 %l process LINK_SPEC as a spec.
438 %L process LIB_SPEC as a spec.
439 %G process LIBGCC_SPEC as a spec.
440 %R Output the concatenation of target_system_root and
441 target_sysroot_suffix.
442 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
443 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
444 %C process CPP_SPEC as a spec.
445 %1 process CC1_SPEC as a spec.
446 %2 process CC1PLUS_SPEC as a spec.
447 %* substitute the variable part of a matched option. (See below.)
448 Note that each comma in the substituted string is replaced by
450 %<S remove all occurrences of -S from the command line.
451 Note - this command is position dependent. % commands in the
452 spec string before this one will see -S, % commands in the
453 spec string after this one will not.
454 %<S* remove all occurrences of all switches beginning with -S from the
457 Call the named function FUNCTION, passing it ARGS. ARGS is
458 first processed as a nested spec string, then split into an
459 argument vector in the usual fashion. The function returns
460 a string which is processed as if it had appeared literally
461 as part of the current spec.
462 %{S} substitutes the -S switch, if that switch was given to GCC.
463 If that switch was not specified, this substitutes nothing.
464 Here S is a metasyntactic variable.
465 %{S*} substitutes all the switches specified to GCC whose names start
466 with -S. This is used for -o, -I, etc; switches that take
467 arguments. GCC considers `-o foo' as being one switch whose
468 name starts with `o'. %{o*} would substitute this text,
469 including the space; thus, two arguments would be generated.
470 %{S*&T*} likewise, but preserve order of S and T options (the order
471 of S and T in the spec is not significant). Can be any number
472 of ampersand-separated variables; for each the wild card is
473 optional. Useful for CPP as %{D*&U*&A*}.
475 %{S:X} substitutes X, if the -S switch was given to GCC.
476 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
477 %{S*:X} substitutes X if one or more switches whose names start
478 with -S was given to GCC. Normally X is substituted only
479 once, no matter how many such switches appeared. However,
480 if %* appears somewhere in X, then X will be substituted
481 once for each matching switch, with the %* replaced by the
482 part of that switch that matched the '*'.
483 %{.S:X} substitutes X, if processing a file with suffix S.
484 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
485 %{,S:X} substitutes X, if processing a file which will use spec S.
486 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
488 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
489 combined with '!', '.', ',', and '*' as above binding stronger
491 If %* appears in X, all of the alternatives must be starred, and
492 only the first matching alternative is substituted.
493 %{S:X; if S was given to GCC, substitutes X;
494 T:Y; else if T was given to GCC, substitutes Y;
495 :D} else substitutes D. There can be as many clauses as you need.
496 This may be combined with '.', '!', ',', '|', and '*' as above.
498 %(Spec) processes a specification defined in a specs file as *Spec:
499 %[Spec] as above, but put __ around -D arguments
501 The conditional text X in a %{S:X} or similar construct may contain
502 other nested % constructs or spaces, or even newlines. They are
503 processed as usual, as described above. Trailing white space in X is
504 ignored. White space may also appear anywhere on the left side of the
505 colon in these constructs, except between . or * and the corresponding
508 The -O, -f, -m, and -W switches are handled specifically in these
509 constructs. If another value of -O or the negated form of a -f, -m, or
510 -W switch is found later in the command line, the earlier switch
511 value is ignored, except with {S*} where S is just one letter; this
512 passes all matching options.
514 The character | at the beginning of the predicate text is used to indicate
515 that a command should be piped to the following command, but only if -pipe
518 Note that it is built into GCC which switches take arguments and which
519 do not. You might think it would be useful to generalize this to
520 allow each compiler's spec to say which switches take arguments. But
521 this cannot be done in a consistent fashion. GCC cannot even decide
522 which input files have been specified without knowing which switches
523 take arguments, and it must know which input files to compile in order
524 to tell which compilers to run.
526 GCC also knows implicitly that arguments starting in `-l' are to be
527 treated as compiler output files, and passed to the linker in their
528 proper position among the other output files. */
530 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
532 /* config.h can define ASM_SPEC to provide extra args to the assembler
533 or extra switch-translations. */
538 /* config.h can define ASM_FINAL_SPEC to run a post processor after
539 the assembler has run. */
540 #ifndef ASM_FINAL_SPEC
541 #define ASM_FINAL_SPEC ""
544 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
545 or extra switch-translations. */
550 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
551 or extra switch-translations. */
556 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
557 or extra switch-translations. */
559 #define CC1PLUS_SPEC ""
562 /* config.h can define LINK_SPEC to provide extra args to the linker
563 or extra switch-translations. */
568 /* config.h can define LIB_SPEC to override the default libraries. */
570 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
575 /* XXX: valid only for GNU ld */
576 /* XXX: should exactly match hooks provided by libmudflap.a */
577 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
578 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
579 --wrap=mmap --wrap=munmap --wrap=alloca\
580 } %{fmudflapth: --wrap=pthread_create\
581 }} %{fmudflap|fmudflapth: --wrap=main}"
584 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
587 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
590 #if defined(REAL_LIBGCC_SPEC)
591 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
592 #elif defined(LINK_LIBGCC_SPECIAL_1)
593 /* Have gcc do the search for libgcc.a. */
594 #define LIBGCC_SPEC "libgcc.a%s"
596 #define LIBGCC_SPEC "-lgcc"
600 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
601 #ifndef STARTFILE_SPEC
602 #define STARTFILE_SPEC \
603 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
606 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
608 #define ENDFILE_SPEC ""
612 #define LINKER_NAME "collect2"
615 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
616 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
621 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
623 #ifndef ASM_DEBUG_SPEC
624 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
625 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
626 # define ASM_DEBUG_SPEC \
627 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
628 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
629 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
631 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
632 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
634 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
635 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
639 #ifndef ASM_DEBUG_SPEC
640 # define ASM_DEBUG_SPEC ""
643 /* Here is the spec for running the linker, after compiling all files. */
645 /* This is overridable by the target in case they need to specify the
646 -lgcc and -lc order specially, yet not require them to override all
647 of LINK_COMMAND_SPEC. */
648 #ifndef LINK_GCC_C_SEQUENCE_SPEC
649 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
652 #ifndef LINK_SSP_SPEC
653 #ifdef TARGET_LIBC_PROVIDES_SSP
654 #define LINK_SSP_SPEC "%{fstack-protector:}"
656 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
660 #ifndef LINK_PIE_SPEC
662 #define LINK_PIE_SPEC "%{pie:-pie} "
664 #define LINK_PIE_SPEC "%{pie:} "
668 #ifndef LINK_BUILDID_SPEC
669 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
670 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
675 /* -u* was put back because both BSD and SysV seem to support it. */
676 /* %{static:} simply prevents an error message if the target machine
677 doesn't handle -static. */
678 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
679 scripts which exist in user specified directories, or in standard
681 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
682 to understand them. In practice, this means it had better be collect2. */
683 #ifndef LINK_COMMAND_SPEC
684 #define LINK_COMMAND_SPEC "\
685 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
687 %{fuse-linker-plugin: \
688 -plugin %(linker_plugin_file) \
689 -plugin-opt=%(lto_wrapper) \
690 -plugin-opt=-fresolution=%u.res \
691 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
692 %{static:-plugin-opt=-pass-through=-lc} \
694 %{flto:%<fcompare-debug*} %{fwhopr*:%<fcompare-debug*} \
695 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
696 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
697 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
698 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
699 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
700 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
701 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
702 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
705 #ifndef LINK_LIBGCC_SPEC
706 /* Generate -L options for startfile prefix list. */
707 # define LINK_LIBGCC_SPEC "%D"
710 #ifndef STARTFILE_PREFIX_SPEC
711 # define STARTFILE_PREFIX_SPEC ""
715 # define SYSROOT_SPEC "--sysroot=%R"
718 #ifndef SYSROOT_SUFFIX_SPEC
719 # define SYSROOT_SUFFIX_SPEC ""
722 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
723 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
726 static const char *asm_debug
;
727 static const char *cpp_spec
= CPP_SPEC
;
728 static const char *cc1_spec
= CC1_SPEC
;
729 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
730 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
731 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
732 static const char *asm_spec
= ASM_SPEC
;
733 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
734 static const char *link_spec
= LINK_SPEC
;
735 static const char *lib_spec
= LIB_SPEC
;
736 static const char *mfwrap_spec
= MFWRAP_SPEC
;
737 static const char *mflib_spec
= MFLIB_SPEC
;
738 static const char *link_gomp_spec
= "";
739 static const char *libgcc_spec
= LIBGCC_SPEC
;
740 static const char *endfile_spec
= ENDFILE_SPEC
;
741 static const char *startfile_spec
= STARTFILE_SPEC
;
742 static const char *linker_name_spec
= LINKER_NAME
;
743 static const char *linker_plugin_file_spec
= "";
744 static const char *lto_wrapper_spec
= "";
745 static const char *lto_gcc_spec
= "";
746 static const char *lto_libgcc_spec
= "";
747 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
748 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
749 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
750 static const char *sysroot_spec
= SYSROOT_SPEC
;
751 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
752 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
754 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
755 There should be no need to override these in target dependent files,
756 but we need to copy them to the specs file so that newer versions
757 of the GCC driver can correctly drive older tool chains with the
758 appropriate -B options. */
760 /* When cpplib handles traditional preprocessing, get rid of this, and
761 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
762 that we default the front end language better. */
763 static const char *trad_capable_cpp
=
764 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
766 /* We don't wrap .d files in %W{} since a missing .d file, and
767 therefore no dependency entry, confuses make into thinking a .o
768 file that happens to exist is up-to-date. */
769 static const char *cpp_unique_options
=
770 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
771 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
772 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
773 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
774 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
775 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
776 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
777 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
778 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
779 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
782 /* This contains cpp options which are common with cc1_options and are passed
783 only when preprocessing only to avoid duplication. We pass the cc1 spec
784 options to the preprocessor so that it the cc1 spec may manipulate
785 options used to set target flags. Those special target flags settings may
786 in turn cause preprocessor symbols to be defined specially. */
787 static const char *cpp_options
=
788 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
789 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
790 %{undef} %{save-temps*:-fpch-preprocess}";
792 /* This contains cpp options which are not passed when the preprocessor
793 output will be used by another program. */
794 static const char *cpp_debug_options
= "%{d*}";
796 /* NB: This is shared amongst all front-ends, except for Ada. */
797 static const char *cc1_options
=
798 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
799 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
800 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
801 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
802 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
803 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
804 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
805 %{Qn:-fno-ident} %{--help:--help}\
806 %{--target-help:--target-help}\
807 %{--help=*:--help=%(VALUE)}\
808 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
809 %{fsyntax-only:-o %j} %{-param*}\
810 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
811 %{coverage:-fprofile-arcs -ftest-coverage}";
813 static const char *asm_options
=
814 "%{--target-help:%:print-asm-header()} "
816 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
817 to the assembler equivalents. */
818 "%{v} %{w:-W} %{I*} "
820 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
822 static const char *invoke_as
=
823 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
825 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
826 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
830 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
831 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
835 /* Some compilers have limits on line lengths, and the multilib_select
836 and/or multilib_matches strings can be very long, so we build them at
838 static struct obstack multilib_obstack
;
839 static const char *multilib_select
;
840 static const char *multilib_matches
;
841 static const char *multilib_defaults
;
842 static const char *multilib_exclusions
;
844 /* Check whether a particular argument is a default argument. */
846 #ifndef MULTILIB_DEFAULTS
847 #define MULTILIB_DEFAULTS { "" }
850 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
852 #ifndef DRIVER_SELF_SPECS
853 #define DRIVER_SELF_SPECS ""
856 /* Adding -fopenmp should imply pthreads. This is particularly important
857 for targets that use different start files and suchlike. */
858 #ifndef GOMP_SELF_SPECS
859 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
862 static const char *const driver_self_specs
[] = {
863 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
864 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
867 #ifndef OPTION_DEFAULT_SPECS
868 #define OPTION_DEFAULT_SPECS { "", "" }
877 static const struct default_spec
878 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
882 struct user_specs
*next
;
883 const char *filename
;
886 static struct user_specs
*user_specs_head
, *user_specs_tail
;
889 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
890 /* This defines which switches stop a full compilation. */
891 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
892 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
894 #ifndef SWITCH_CURTAILS_COMPILATION
895 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
896 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
900 /* Record the mapping from file suffixes for compilation specs. */
904 const char *suffix
; /* Use this compiler for input files
905 whose names end in this suffix. */
907 const char *spec
; /* To use this compiler, run this spec. */
909 const char *cpp_spec
; /* If non-NULL, substitute this spec
910 for `%C', rather than the usual
912 const int combinable
; /* If nonzero, compiler can deal with
913 multiple source files at once (IMA). */
914 const int needs_preprocessing
; /* If nonzero, source files need to
915 be run through a preprocessor. */
918 /* Pointer to a vector of `struct compiler' that gives the spec for
919 compiling a file, based on its suffix.
920 A file that does not end in any of these suffixes will be passed
921 unchanged to the loader and nothing else will be done to it.
923 An entry containing two 0s is used to terminate the vector.
925 If multiple entries match a file, the last matching one is used. */
927 static struct compiler
*compilers
;
929 /* Number of entries in `compilers', not counting the null terminator. */
931 static int n_compilers
;
933 /* The default list of file name suffixes and their compilation specs. */
935 static const struct compiler default_compilers
[] =
937 /* Add lists of suffixes of known languages here. If those languages
938 were not present when we built the driver, we will hit these copies
939 and be given a more meaningful error than "file not used since
940 linking is not done". */
941 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
942 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
943 {".mii", "#Objective-C++", 0, 0, 0},
944 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
945 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
946 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
947 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
948 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
949 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
950 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
951 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
952 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
953 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
954 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
955 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
956 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
957 {".r", "#Ratfor", 0, 0, 0},
958 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
959 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
960 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
961 /* Next come the entries for C. */
962 {".c", "@c", 0, 1, 1},
964 /* cc1 has an integrated ISO C preprocessor. We should invoke the
965 external preprocessor if -save-temps is given. */
966 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
968 %{traditional|ftraditional:\
969 %eGNU C no longer supports -traditional without -E}\
971 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
972 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
973 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
975 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
976 cc1 %(cpp_unique_options) %(cc1_options)}}}\
977 %{!fsyntax-only:%(invoke_as)}} \
979 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
980 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
981 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
982 cc1 %(cpp_unique_options) %(cc1_options)}}\
983 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
985 "%{!E:%e-E or -x required when input is from standard input}\
986 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
987 {".h", "@c-header", 0, 0, 0},
989 /* cc1 has an integrated ISO C preprocessor. We should invoke the
990 external preprocessor if -save-temps is given. */
991 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
993 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
994 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
995 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
997 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
998 %W{o*:--output-pch=%*}}%V}\
999 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1000 cc1 %(cpp_unique_options) %(cc1_options)\
1001 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1002 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1003 {".i", "@cpp-output", 0, 1, 0},
1005 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1006 {".s", "@assembler", 0, 1, 0},
1008 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1009 {".sx", "@assembler-with-cpp", 0, 1, 0},
1010 {".S", "@assembler-with-cpp", 0, 1, 0},
1011 {"@assembler-with-cpp",
1012 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1013 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1014 %{E|M|MM:%(cpp_debug_options)}\
1015 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1016 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1018 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1019 %{E|M|MM:%(cpp_debug_options)}\
1020 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1021 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1026 /* Mark end of table. */
1030 /* Number of elements in default_compilers, not counting the terminator. */
1032 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1034 /* A vector of options to give to the linker.
1035 These options are accumulated by %x,
1036 and substituted into the linker command with %X. */
1037 static int n_linker_options
;
1038 static char **linker_options
;
1040 /* A vector of options to give to the assembler.
1041 These options are accumulated by -Wa,
1042 and substituted into the assembler command with %Y. */
1043 static int n_assembler_options
;
1044 static char **assembler_options
;
1046 /* A vector of options to give to the preprocessor.
1047 These options are accumulated by -Wp,
1048 and substituted into the preprocessor command with %Z. */
1049 static int n_preprocessor_options
;
1050 static char **preprocessor_options
;
1052 /* Define how to map long options into short ones. */
1054 /* This structure describes one mapping. */
1057 /* The long option's name. */
1058 const char *const name
;
1059 /* The equivalent short option. */
1060 const char *const equivalent
;
1061 /* Argument info. A string of flag chars; NULL equals no options.
1062 a => argument required.
1063 o => argument optional.
1064 j => join argument to equivalent, making one word.
1065 * => require other text after NAME as an argument. */
1066 const char *const arg_info
;
1069 /* This is the table of mappings. Mappings are tried sequentially
1070 for each option encountered; the first one that matches, wins. */
1072 static const struct option_map option_map
[] =
1074 {"--all-warnings", "-Wall", 0},
1075 {"--ansi", "-ansi", 0},
1076 {"--assemble", "-S", 0},
1077 {"--assert", "-A", "a"},
1078 {"--classpath", "-fclasspath=", "aj"},
1079 {"--bootclasspath", "-fbootclasspath=", "aj"},
1080 {"--CLASSPATH", "-fclasspath=", "aj"},
1081 {"--combine", "-combine", 0},
1082 {"--comments", "-C", 0},
1083 {"--comments-in-macros", "-CC", 0},
1084 {"--compile", "-c", 0},
1085 {"--debug", "-g", "oj"},
1086 {"--define-macro", "-D", "aj"},
1087 {"--dependencies", "-M", 0},
1088 {"--dump", "-d", "a"},
1089 {"--dumpbase", "-dumpbase", "a"},
1090 {"--dumpdir", "-dumpdir", "a"},
1091 {"--encoding", "-fencoding=", "aj"},
1092 {"--entry", "-e", 0},
1093 {"--extra-warnings", "-W", 0},
1094 {"--extdirs", "-fextdirs=", "aj"},
1095 {"--for-assembler", "-Wa", "a"},
1096 {"--for-linker", "-Xlinker", "a"},
1097 {"--force-link", "-u", "a"},
1098 {"--coverage", "-coverage", 0},
1099 {"--imacros", "-imacros", "a"},
1100 {"--include", "-include", "a"},
1101 {"--include-barrier", "-I-", 0},
1102 {"--include-directory", "-I", "aj"},
1103 {"--include-directory-after", "-idirafter", "a"},
1104 {"--include-prefix", "-iprefix", "a"},
1105 {"--include-with-prefix", "-iwithprefix", "a"},
1106 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1107 {"--include-with-prefix-after", "-iwithprefix", "a"},
1108 {"--language", "-x", "a"},
1109 {"--library-directory", "-L", "a"},
1110 {"--machine", "-m", "aj"},
1111 {"--machine-", "-m", "*j"},
1112 {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1113 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1114 {"--no-line-commands", "-P", 0},
1115 {"--no-precompiled-includes", "-noprecomp", 0},
1116 {"--no-standard-includes", "-nostdinc", 0},
1117 {"--no-standard-libraries", "-nostdlib", 0},
1118 {"--no-warnings", "-w", 0},
1119 {"--optimize", "-O", "oj"},
1120 {"--output", "-o", "a"},
1121 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1122 {"--param", "--param", "a"},
1123 {"--pass-exit-codes", "-pass-exit-codes", 0},
1124 {"--pedantic", "-pedantic", 0},
1125 {"--pedantic-errors", "-pedantic-errors", 0},
1126 {"--pie", "-pie", 0},
1127 {"--pipe", "-pipe", 0},
1128 {"--prefix", "-B", "a"},
1129 {"--preprocess", "-E", 0},
1130 {"--print-search-dirs", "-print-search-dirs", 0},
1131 {"--print-file-name", "-print-file-name=", "aj"},
1132 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1133 {"--print-missing-file-dependencies", "-MG", 0},
1134 {"--print-multi-lib", "-print-multi-lib", 0},
1135 {"--print-multi-directory", "-print-multi-directory", 0},
1136 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1137 {"--print-prog-name", "-print-prog-name=", "aj"},
1138 {"--print-sysroot", "-print-sysroot", 0},
1139 {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1140 {"--profile", "-p", 0},
1141 {"--resource", "-fcompile-resource=", "aj"},
1142 {"--save-temps", "-save-temps", 0},
1143 {"--shared", "-shared", 0},
1144 {"--specs", "-specs=", "aj"},
1145 {"--static", "-static", 0},
1146 {"--std", "-std=", "aj"},
1147 {"--symbolic", "-symbolic", 0},
1148 {"--sysroot", "--sysroot=", "aj"},
1149 {"--time", "-time", 0},
1150 {"--trace-includes", "-H", 0},
1151 {"--traditional", "-traditional", 0},
1152 {"--traditional-cpp", "-traditional-cpp", 0},
1153 {"--trigraphs", "-trigraphs", 0},
1154 {"--undefine-macro", "-U", "aj"},
1155 {"--user-dependencies", "-MM", 0},
1156 {"--verbose", "-v", 0},
1157 {"--warn-", "-W", "*j"},
1158 {"--write-dependencies", "-MD", 0},
1159 {"--write-user-dependencies", "-MMD", 0},
1164 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1165 static const struct {
1166 const char *const option_found
;
1167 const char *const replacements
;
1168 } target_option_translations
[] =
1170 TARGET_OPTION_TRANSLATE_TABLE
,
1175 /* Translate the options described by *ARGCP and *ARGVP.
1176 Make a new vector and store it back in *ARGVP,
1177 and store its length in *ARGCP. */
1180 translate_options (int *argcp
, const char *const **argvp
)
1184 const char *const *argv
= *argvp
;
1185 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1186 const char **newv
= XNEWVAR (const char *, newvsize
);
1190 newv
[newindex
++] = argv
[i
++];
1194 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1198 target_option_translations
[tott_idx
].option_found
;
1201 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1208 for (sp
= target_option_translations
[tott_idx
].replacements
;
1215 newvsize
+= spaces
* sizeof (const char *);
1216 newv
= XRESIZEVAR (const char *, newv
, newvsize
);
1218 sp
= target_option_translations
[tott_idx
].replacements
;
1227 newv
[newindex
++] = np
;
1228 while (*np
!= ' ' && *np
)
1239 if (target_option_translations
[tott_idx
].option_found
)
1243 /* Translate -- options. */
1244 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1247 /* Find a mapping that applies to this option. */
1248 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1250 size_t optlen
= strlen (option_map
[j
].name
);
1251 size_t arglen
= strlen (argv
[i
]);
1252 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1253 const char *arginfo
= option_map
[j
].arg_info
;
1258 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1260 const char *arg
= 0;
1262 if (arglen
< optlen
)
1265 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1266 if (strlen (option_map
[k
].name
) >= arglen
1267 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1269 error ("ambiguous abbreviation %s", argv
[i
]);
1273 if (k
!= ARRAY_SIZE (option_map
))
1277 if (arglen
> optlen
)
1279 /* If the option has an argument, accept that. */
1280 if (argv
[i
][optlen
] == '=')
1281 arg
= argv
[i
] + optlen
+ 1;
1283 /* If this mapping requires extra text at end of name,
1284 accept that as "argument". */
1285 else if (strchr (arginfo
, '*') != 0)
1286 arg
= argv
[i
] + optlen
;
1288 /* Otherwise, extra text at end means mismatch.
1289 Try other mappings. */
1294 else if (strchr (arginfo
, '*') != 0)
1296 error ("incomplete %qs option", option_map
[j
].name
);
1300 /* Handle arguments. */
1301 if (strchr (arginfo
, 'a') != 0)
1307 error ("missing argument to %qs option",
1308 option_map
[j
].name
);
1315 else if (strchr (arginfo
, '*') != 0)
1317 else if (strchr (arginfo
, 'o') == 0)
1320 error ("extraneous argument to %qs option",
1321 option_map
[j
].name
);
1325 /* Store the translation as one argv elt or as two. */
1326 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1327 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1331 newv
[newindex
++] = option_map
[j
].equivalent
;
1332 newv
[newindex
++] = arg
;
1335 newv
[newindex
++] = option_map
[j
].equivalent
;
1343 /* Handle old-fashioned options--just copy them through,
1344 with their arguments. */
1345 else if (argv
[i
][0] == '-')
1347 const char *p
= argv
[i
] + 1;
1351 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1352 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1353 else if (WORD_SWITCH_TAKES_ARG (p
))
1354 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1355 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1358 else if (! strcmp (p
, "Xlinker"))
1360 else if (! strcmp (p
, "Xpreprocessor"))
1362 else if (! strcmp (p
, "Xassembler"))
1365 /* Watch out for an option at the end of the command line that
1366 is missing arguments, and avoid skipping past the end of the
1368 if (nskip
+ i
> argc
)
1371 /* Convert -d with a separate argument to
1372 -foutput-class-dir= for Java. */
1373 if (c
== 'd' && p
[1] == 0 && argv
[i
+ 1] != NULL
)
1375 newv
[newindex
++] = concat ("-foutput-class-dir=", argv
[i
+ 1],
1383 newv
[newindex
++] = argv
[i
++];
1388 /* Ordinary operands. */
1389 newv
[newindex
++] = argv
[i
++];
1399 skip_whitespace (char *p
)
1403 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1404 be considered whitespace. */
1405 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1407 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1421 /* Structures to keep track of prefixes to try when looking for files. */
1425 const char *prefix
; /* String to prepend to the path. */
1426 struct prefix_list
*next
; /* Next in linked list. */
1427 int require_machine_suffix
; /* Don't use without machine_suffix. */
1428 /* 2 means try both machine_suffix and just_machine_suffix. */
1429 int priority
; /* Sort key - priority within list. */
1430 int os_multilib
; /* 1 if OS multilib scheme should be used,
1431 0 for GCC multilib scheme. */
1436 struct prefix_list
*plist
; /* List of prefixes to try */
1437 int max_len
; /* Max length of a prefix in PLIST */
1438 const char *name
; /* Name of this list (used in config stuff) */
1441 /* List of prefixes to try when looking for executables. */
1443 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1445 /* List of prefixes to try when looking for startup (crt0) files. */
1447 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1449 /* List of prefixes to try when looking for include files. */
1451 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1453 /* Suffix to attach to directories searched for commands.
1454 This looks like `MACHINE/VERSION/'. */
1456 static const char *machine_suffix
= 0;
1458 /* Suffix to attach to directories searched for commands.
1459 This is just `MACHINE/'. */
1461 static const char *just_machine_suffix
= 0;
1463 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1465 static const char *gcc_exec_prefix
;
1467 /* Adjusted value of standard_libexec_prefix. */
1469 static const char *gcc_libexec_prefix
;
1471 /* Default prefixes to attach to command names. */
1473 #ifndef STANDARD_STARTFILE_PREFIX_1
1474 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1476 #ifndef STANDARD_STARTFILE_PREFIX_2
1477 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1480 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1481 #undef MD_EXEC_PREFIX
1482 #undef MD_STARTFILE_PREFIX
1483 #undef MD_STARTFILE_PREFIX_1
1486 /* If no prefixes defined, use the null string, which will disable them. */
1487 #ifndef MD_EXEC_PREFIX
1488 #define MD_EXEC_PREFIX ""
1490 #ifndef MD_STARTFILE_PREFIX
1491 #define MD_STARTFILE_PREFIX ""
1493 #ifndef MD_STARTFILE_PREFIX_1
1494 #define MD_STARTFILE_PREFIX_1 ""
1497 /* These directories are locations set at configure-time based on the
1498 --prefix option provided to configure. Their initializers are
1499 defined in Makefile.in. These paths are not *directly* used when
1500 gcc_exec_prefix is set because, in that case, we know where the
1501 compiler has been installed, and use paths relative to that
1502 location instead. */
1503 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1504 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1505 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1506 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1508 /* For native compilers, these are well-known paths containing
1509 components that may be provided by the system. For cross
1510 compilers, these paths are not used. */
1511 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1512 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1513 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1514 static const char *const standard_startfile_prefix_1
1515 = STANDARD_STARTFILE_PREFIX_1
;
1516 static const char *const standard_startfile_prefix_2
1517 = STANDARD_STARTFILE_PREFIX_2
;
1519 /* A relative path to be used in finding the location of tools
1520 relative to the driver. */
1521 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1523 /* Subdirectory to use for locating libraries. Set by
1524 set_multilib_dir based on the compilation options. */
1526 static const char *multilib_dir
;
1528 /* Subdirectory to use for locating libraries in OS conventions. Set by
1529 set_multilib_dir based on the compilation options. */
1531 static const char *multilib_os_dir
;
1533 /* Structure to keep track of the specs that have been defined so far.
1534 These are accessed using %(specname) or %[specname] in a compiler
1539 /* The following 2 fields must be first */
1540 /* to allow EXTRA_SPECS to be initialized */
1541 const char *name
; /* name of the spec. */
1542 const char *ptr
; /* available ptr if no static pointer */
1544 /* The following fields are not initialized */
1545 /* by EXTRA_SPECS */
1546 const char **ptr_spec
; /* pointer to the spec itself. */
1547 struct spec_list
*next
; /* Next spec in linked list. */
1548 int name_len
; /* length of the name */
1549 int alloc_p
; /* whether string was allocated */
1552 #define INIT_STATIC_SPEC(NAME,PTR) \
1553 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1555 /* List of statically defined specs. */
1556 static struct spec_list static_specs
[] =
1558 INIT_STATIC_SPEC ("asm", &asm_spec
),
1559 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1560 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1561 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1562 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1563 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1564 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1565 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1566 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1567 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1568 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1569 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1570 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1571 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1572 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1573 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1574 INIT_STATIC_SPEC ("link", &link_spec
),
1575 INIT_STATIC_SPEC ("lib", &lib_spec
),
1576 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1577 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1578 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1579 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1580 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1581 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1582 INIT_STATIC_SPEC ("version", &compiler_version
),
1583 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1584 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1585 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1586 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1587 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1588 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1589 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1590 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1591 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1592 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1593 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec
),
1594 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1595 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1596 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1597 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1598 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1599 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1600 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1601 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1604 #ifdef EXTRA_SPECS /* additional specs needed */
1605 /* Structure to keep track of just the first two args of a spec_list.
1606 That is all that the EXTRA_SPECS macro gives us. */
1609 const char *const name
;
1610 const char *const ptr
;
1613 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1614 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1617 /* List of dynamically allocates specs that have been defined so far. */
1619 static struct spec_list
*specs
= (struct spec_list
*) 0;
1621 /* List of static spec functions. */
1623 static const struct spec_function static_spec_functions
[] =
1625 { "getenv", getenv_spec_function
},
1626 { "if-exists", if_exists_spec_function
},
1627 { "if-exists-else", if_exists_else_spec_function
},
1628 { "replace-outfile", replace_outfile_spec_function
},
1629 { "remove-outfile", remove_outfile_spec_function
},
1630 { "version-compare", version_compare_spec_function
},
1631 { "include", include_spec_function
},
1632 { "find-file", find_file_spec_function
},
1633 { "find-plugindir", find_plugindir_spec_function
},
1634 { "print-asm-header", print_asm_header_spec_function
},
1635 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1636 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1637 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1638 #ifdef EXTRA_SPEC_FUNCTIONS
1639 EXTRA_SPEC_FUNCTIONS
1644 static int processing_spec_function
;
1646 /* Add appropriate libgcc specs to OBSTACK, taking into account
1647 various permutations of -shared-libgcc, -shared, and such. */
1649 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1651 #ifndef USE_LD_AS_NEEDED
1652 #define USE_LD_AS_NEEDED 0
1656 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1657 const char *static_name
, const char *eh_name
)
1661 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1662 "%{!static:%{!static-libgcc:"
1663 #if USE_LD_AS_NEEDED
1664 "%{!shared-libgcc:",
1665 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1668 shared_name
, "%{!shared: ", static_name
, "}"
1672 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1673 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1677 "%{shared-libgcc:", shared_name
, "}"
1678 "%{!shared-libgcc:", static_name
, "}"
1681 "%{shared:", shared_name
, "}"
1686 obstack_grow (obstack
, buf
, strlen (buf
));
1689 #endif /* ENABLE_SHARED_LIBGCC */
1691 /* Initialize the specs lookup routines. */
1696 struct spec_list
*next
= (struct spec_list
*) 0;
1697 struct spec_list
*sl
= (struct spec_list
*) 0;
1701 return; /* Already initialized. */
1704 fnotice (stderr
, "Using built-in specs.\n");
1707 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1709 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1711 sl
= &extra_specs
[i
];
1712 sl
->name
= extra_specs_1
[i
].name
;
1713 sl
->ptr
= extra_specs_1
[i
].ptr
;
1715 sl
->name_len
= strlen (sl
->name
);
1716 sl
->ptr_spec
= &sl
->ptr
;
1721 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1723 sl
= &static_specs
[i
];
1728 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1729 /* ??? If neither -shared-libgcc nor --static-libgcc was
1730 seen, then we should be making an educated guess. Some proposed
1731 heuristics for ELF include:
1733 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1734 program will be doing dynamic loading, which will likely
1735 need the shared libgcc.
1737 (2) If "-ldl", then it's also a fair bet that we're doing
1740 (3) For each ET_DYN we're linking against (either through -lfoo
1741 or /some/path/foo.so), check to see whether it or one of
1742 its dependencies depends on a shared libgcc.
1746 If the runtime is fixed to look for program headers instead
1747 of calling __register_frame_info at all, for each object,
1748 use the shared libgcc if any EH symbol referenced.
1750 If crtstuff is fixed to not invoke __register_frame_info
1751 automatically, for each object, use the shared libgcc if
1752 any non-empty unwind section found.
1754 Doing any of this probably requires invoking an external program to
1755 do the actual object file scanning. */
1757 const char *p
= libgcc_spec
;
1760 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1761 when given the proper command line arguments. */
1764 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1766 init_gcc_specs (&obstack
,
1768 #ifdef USE_LIBUNWIND_EXCEPTIONS
1774 #ifdef USE_LIBUNWIND_EXCEPTIONS
1775 # ifdef HAVE_LD_STATIC_DYNAMIC
1776 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1786 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1788 /* Ug. We don't know shared library extensions. Hope that
1789 systems that use this form don't do shared libraries. */
1790 init_gcc_specs (&obstack
,
1794 #ifdef USE_LIBUNWIND_EXCEPTIONS
1803 obstack_1grow (&obstack
, *p
);
1804 in_sep
= (*p
== ' ');
1809 obstack_1grow (&obstack
, '\0');
1810 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1813 #ifdef USE_AS_TRADITIONAL_FORMAT
1814 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1816 static const char tf
[] = "--traditional-format ";
1817 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1818 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1819 asm_spec
= XOBFINISH (&obstack
, const char *);
1823 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1824 # ifdef LINK_BUILDID_SPEC
1825 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1826 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1828 # ifdef LINK_EH_SPEC
1829 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1830 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1832 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1833 link_spec
= XOBFINISH (&obstack
, const char *);
1839 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1840 removed; If the spec starts with a + then SPEC is added to the end of the
1844 set_spec (const char *name
, const char *spec
)
1846 struct spec_list
*sl
;
1847 const char *old_spec
;
1848 int name_len
= strlen (name
);
1851 /* If this is the first call, initialize the statically allocated specs. */
1854 struct spec_list
*next
= (struct spec_list
*) 0;
1855 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1857 sl
= &static_specs
[i
];
1864 /* See if the spec already exists. */
1865 for (sl
= specs
; sl
; sl
= sl
->next
)
1866 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1871 /* Not found - make it. */
1872 sl
= XNEW (struct spec_list
);
1873 sl
->name
= xstrdup (name
);
1874 sl
->name_len
= name_len
;
1875 sl
->ptr_spec
= &sl
->ptr
;
1877 *(sl
->ptr_spec
) = "";
1882 old_spec
= *(sl
->ptr_spec
);
1883 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1884 ? concat (old_spec
, spec
+ 1, NULL
)
1889 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1892 /* Free the old spec. */
1893 if (old_spec
&& sl
->alloc_p
)
1894 free (CONST_CAST(char *, old_spec
));
1899 /* Accumulate a command (program name and args), and run it. */
1901 /* Vector of pointers to arguments in the current line of specifications. */
1903 static const char **argbuf
;
1905 /* Number of elements allocated in argbuf. */
1907 static int argbuf_length
;
1909 /* Number of elements in argbuf currently in use (containing args). */
1911 static int argbuf_index
;
1913 /* Position in the argbuf array containing the name of the output file
1914 (the value associated with the "-o" flag). */
1916 static int have_o_argbuf_index
= 0;
1918 /* Were the options -c, -S or -E passed. */
1919 static int have_c
= 0;
1921 /* Was the option -o passed. */
1922 static int have_o
= 0;
1924 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1925 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1928 static struct temp_name
{
1929 const char *suffix
; /* suffix associated with the code. */
1930 int length
; /* strlen (suffix). */
1931 int unique
; /* Indicates whether %g or %u/%U was used. */
1932 const char *filename
; /* associated filename. */
1933 int filename_length
; /* strlen (filename). */
1934 struct temp_name
*next
;
1937 /* Number of commands executed so far. */
1939 static int execution_count
;
1941 /* Number of commands that exited with a signal. */
1943 static int signal_count
;
1945 /* Allocate the argument vector. */
1951 argbuf
= XNEWVEC (const char *, argbuf_length
);
1954 /* Clear out the vector of arguments (after a command is executed). */
1962 /* Add one argument to the vector at the end.
1963 This is done when a space is seen or at the end of the line.
1964 If DELETE_ALWAYS is nonzero, the arg is a filename
1965 and the file should be deleted eventually.
1966 If DELETE_FAILURE is nonzero, the arg is a filename
1967 and the file should be deleted if this compilation fails. */
1970 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1972 if (argbuf_index
+ 1 == argbuf_length
)
1973 argbuf
= XRESIZEVEC (const char *, argbuf
, (argbuf_length
*= 2));
1975 argbuf
[argbuf_index
++] = arg
;
1976 argbuf
[argbuf_index
] = 0;
1978 if (strcmp (arg
, "-o") == 0)
1979 have_o_argbuf_index
= argbuf_index
;
1980 if (delete_always
|| delete_failure
)
1983 /* If the temporary file we should delete is specified as
1984 part of a joined argument extract the filename. */
1986 && (p
= strrchr (arg
, '=')))
1988 record_temp_file (arg
, delete_always
, delete_failure
);
1992 /* Load specs from a file name named FILENAME, replacing occurrences of
1993 various different types of line-endings, \r\n, \n\r and just \r, with
1997 load_specs (const char *filename
)
2001 struct stat statbuf
;
2008 fnotice (stderr
, "Reading specs from %s\n", filename
);
2010 /* Open and stat the file. */
2011 desc
= open (filename
, O_RDONLY
, 0);
2013 pfatal_with_name (filename
);
2014 if (stat (filename
, &statbuf
) < 0)
2015 pfatal_with_name (filename
);
2017 /* Read contents of file into BUFFER. */
2018 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2019 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2021 pfatal_with_name (filename
);
2022 buffer
[readlen
] = 0;
2025 specs
= XNEWVEC (char, readlen
+ 1);
2027 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2033 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2035 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2049 /* Read compilation specs from a file named FILENAME,
2050 replacing the default ones.
2052 A suffix which starts with `*' is a definition for
2053 one of the machine-specific sub-specs. The "suffix" should be
2054 *asm, *cc1, *cpp, *link, *startfile, etc.
2055 The corresponding spec is stored in asm_spec, etc.,
2056 rather than in the `compilers' vector.
2058 Anything invalid in the file is a fatal error. */
2061 read_specs (const char *filename
, int main_p
)
2066 buffer
= load_specs (filename
);
2068 /* Scan BUFFER for specs, putting them in the vector. */
2074 char *in
, *out
, *p1
, *p2
, *p3
;
2076 /* Advance P in BUFFER to the next nonblank nocomment line. */
2077 p
= skip_whitespace (p
);
2081 /* Is this a special command that starts with '%'? */
2082 /* Don't allow this for the main specs file, since it would
2083 encourage people to overwrite it. */
2084 if (*p
== '%' && !main_p
)
2087 while (*p
&& *p
!= '\n')
2093 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2094 && (p1
[sizeof "%include" - 1] == ' '
2095 || p1
[sizeof "%include" - 1] == '\t'))
2099 p1
+= sizeof ("%include");
2100 while (*p1
== ' ' || *p1
== '\t')
2103 if (*p1
++ != '<' || p
[-2] != '>')
2104 fatal_error ("specs %%include syntax malformed after "
2106 (long) (p1
- buffer
+ 1));
2109 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2110 read_specs (new_filename
? new_filename
: p1
, FALSE
);
2113 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2114 && (p1
[sizeof "%include_noerr" - 1] == ' '
2115 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2119 p1
+= sizeof "%include_noerr";
2120 while (*p1
== ' ' || *p1
== '\t')
2123 if (*p1
++ != '<' || p
[-2] != '>')
2124 fatal_error ("specs %%include syntax malformed after "
2126 (long) (p1
- buffer
+ 1));
2129 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2131 read_specs (new_filename
, FALSE
);
2132 else if (verbose_flag
)
2133 fnotice (stderr
, "could not find specs file %s\n", p1
);
2136 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2137 && (p1
[sizeof "%rename" - 1] == ' '
2138 || p1
[sizeof "%rename" - 1] == '\t'))
2141 struct spec_list
*sl
;
2142 struct spec_list
*newsl
;
2144 /* Get original name. */
2145 p1
+= sizeof "%rename";
2146 while (*p1
== ' ' || *p1
== '\t')
2149 if (! ISALPHA ((unsigned char) *p1
))
2150 fatal_error ("specs %%rename syntax malformed after "
2152 (long) (p1
- buffer
));
2155 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2158 if (*p2
!= ' ' && *p2
!= '\t')
2159 fatal_error ("specs %%rename syntax malformed after "
2161 (long) (p2
- buffer
));
2165 while (*p2
== ' ' || *p2
== '\t')
2168 if (! ISALPHA ((unsigned char) *p2
))
2169 fatal_error ("specs %%rename syntax malformed after "
2171 (long) (p2
- buffer
));
2173 /* Get new spec name. */
2175 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2179 fatal_error ("specs %%rename syntax malformed after "
2181 (long) (p3
- buffer
));
2184 for (sl
= specs
; sl
; sl
= sl
->next
)
2185 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2189 fatal_error ("specs %s spec was not found to be renamed", p1
);
2191 if (strcmp (p1
, p2
) == 0)
2194 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2195 if (strcmp (newsl
->name
, p2
) == 0)
2196 fatal_error ("%s: attempt to rename spec %qs to "
2197 "already defined spec %qs",
2202 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2204 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2208 set_spec (p2
, *(sl
->ptr_spec
));
2210 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2212 *(sl
->ptr_spec
) = "";
2217 fatal_error ("specs unknown %% command after %ld characters",
2218 (long) (p1
- buffer
));
2221 /* Find the colon that should end the suffix. */
2223 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2226 /* The colon shouldn't be missing. */
2228 fatal_error ("specs file malformed after %ld characters",
2229 (long) (p1
- buffer
));
2231 /* Skip back over trailing whitespace. */
2233 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2236 /* Copy the suffix to a string. */
2237 suffix
= save_string (p
, p2
- p
);
2238 /* Find the next line. */
2239 p
= skip_whitespace (p1
+ 1);
2241 fatal_error ("specs file malformed after %ld characters",
2242 (long) (p
- buffer
));
2245 /* Find next blank line or end of string. */
2246 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2249 /* Specs end at the blank line and do not include the newline. */
2250 spec
= save_string (p
, p1
- p
);
2253 /* Delete backslash-newline sequences from the spec. */
2258 if (in
[0] == '\\' && in
[1] == '\n')
2260 else if (in
[0] == '#')
2261 while (*in
&& *in
!= '\n')
2269 if (suffix
[0] == '*')
2271 if (! strcmp (suffix
, "*link_command"))
2272 link_command_spec
= spec
;
2274 set_spec (suffix
+ 1, spec
);
2278 /* Add this pair to the vector. */
2280 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2282 compilers
[n_compilers
].suffix
= suffix
;
2283 compilers
[n_compilers
].spec
= spec
;
2285 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2289 link_command_spec
= spec
;
2292 if (link_command_spec
== 0)
2293 fatal_error ("spec file has no spec for linking");
2296 /* Record the names of temporary files we tell compilers to write,
2297 and delete them at the end of the run. */
2299 /* This is the common prefix we use to make temp file names.
2300 It is chosen once for each run of this program.
2301 It is substituted into a spec by %g or %j.
2302 Thus, all temp file names contain this prefix.
2303 In practice, all temp file names start with this prefix.
2305 This prefix comes from the envvar TMPDIR if it is defined;
2306 otherwise, from the P_tmpdir macro if that is defined;
2307 otherwise, in /usr/tmp or /tmp;
2308 or finally the current directory if all else fails. */
2310 static const char *temp_filename
;
2312 /* Length of the prefix. */
2314 static int temp_filename_length
;
2316 /* Define the list of temporary files to delete. */
2321 struct temp_file
*next
;
2324 /* Queue of files to delete on success or failure of compilation. */
2325 static struct temp_file
*always_delete_queue
;
2326 /* Queue of files to delete on failure of compilation. */
2327 static struct temp_file
*failure_delete_queue
;
2329 /* Record FILENAME as a file to be deleted automatically.
2330 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2331 otherwise delete it in any case.
2332 FAIL_DELETE nonzero means delete it if a compilation step fails;
2333 otherwise delete it in any case. */
2336 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2338 char *const name
= xstrdup (filename
);
2342 struct temp_file
*temp
;
2343 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2344 if (! strcmp (name
, temp
->name
))
2347 temp
= XNEW (struct temp_file
);
2348 temp
->next
= always_delete_queue
;
2350 always_delete_queue
= temp
;
2357 struct temp_file
*temp
;
2358 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2359 if (! strcmp (name
, temp
->name
))
2362 temp
= XNEW (struct temp_file
);
2363 temp
->next
= failure_delete_queue
;
2365 failure_delete_queue
= temp
;
2371 /* Delete all the temporary files whose names we previously recorded. */
2373 #ifndef DELETE_IF_ORDINARY
2374 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2377 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2378 if (unlink (NAME) < 0) \
2380 perror_with_name (NAME); \
2385 delete_if_ordinary (const char *name
)
2391 printf ("Delete %s? (y or n) ", name
);
2395 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2398 if (i
== 'y' || i
== 'Y')
2400 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2404 delete_temp_files (void)
2406 struct temp_file
*temp
;
2408 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2409 delete_if_ordinary (temp
->name
);
2410 always_delete_queue
= 0;
2413 /* Delete all the files to be deleted on error. */
2416 delete_failure_queue (void)
2418 struct temp_file
*temp
;
2420 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2421 delete_if_ordinary (temp
->name
);
2425 clear_failure_queue (void)
2427 failure_delete_queue
= 0;
2430 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2432 If DO_MULTI is true iterate over the paths twice, first with multilib
2433 suffix then without, otherwise iterate over the paths once without
2434 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2435 to avoid visiting the same path twice, but we could do better. For
2436 instance, /usr/lib/../lib is considered different from /usr/lib.
2437 At least EXTRA_SPACE chars past the end of the path passed to
2438 CALLBACK are available for use by the callback.
2439 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2441 Returns the value returned by CALLBACK. */
2444 for_each_path (const struct path_prefix
*paths
,
2447 void *(*callback
) (char *, void *),
2448 void *callback_info
)
2450 struct prefix_list
*pl
;
2451 const char *multi_dir
= NULL
;
2452 const char *multi_os_dir
= NULL
;
2453 const char *multi_suffix
;
2454 const char *just_multi_suffix
;
2457 bool skip_multi_dir
= false;
2458 bool skip_multi_os_dir
= false;
2460 multi_suffix
= machine_suffix
;
2461 just_multi_suffix
= just_machine_suffix
;
2462 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2464 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2465 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2466 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2468 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2469 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2473 size_t multi_dir_len
= 0;
2474 size_t multi_os_dir_len
= 0;
2476 size_t just_suffix_len
;
2480 multi_dir_len
= strlen (multi_dir
);
2482 multi_os_dir_len
= strlen (multi_os_dir
);
2483 suffix_len
= strlen (multi_suffix
);
2484 just_suffix_len
= strlen (just_multi_suffix
);
2488 len
= paths
->max_len
+ extra_space
+ 1;
2489 if (suffix_len
> multi_os_dir_len
)
2492 len
+= multi_os_dir_len
;
2493 path
= XNEWVEC (char, len
);
2496 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2498 len
= strlen (pl
->prefix
);
2499 memcpy (path
, pl
->prefix
, len
);
2501 /* Look first in MACHINE/VERSION subdirectory. */
2502 if (!skip_multi_dir
)
2504 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2505 ret
= callback (path
, callback_info
);
2510 /* Some paths are tried with just the machine (ie. target)
2511 subdir. This is used for finding as, ld, etc. */
2513 && pl
->require_machine_suffix
== 2)
2515 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2516 ret
= callback (path
, callback_info
);
2521 /* Now try the base path. */
2522 if (!pl
->require_machine_suffix
2523 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2525 const char *this_multi
;
2526 size_t this_multi_len
;
2528 if (pl
->os_multilib
)
2530 this_multi
= multi_os_dir
;
2531 this_multi_len
= multi_os_dir_len
;
2535 this_multi
= multi_dir
;
2536 this_multi_len
= multi_dir_len
;
2540 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2544 ret
= callback (path
, callback_info
);
2552 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2555 /* Run through the paths again, this time without multilibs.
2556 Don't repeat any we have already seen. */
2559 free (CONST_CAST (char *, multi_dir
));
2561 free (CONST_CAST (char *, multi_suffix
));
2562 multi_suffix
= machine_suffix
;
2563 free (CONST_CAST (char *, just_multi_suffix
));
2564 just_multi_suffix
= just_machine_suffix
;
2567 skip_multi_dir
= true;
2570 free (CONST_CAST (char *, multi_os_dir
));
2571 multi_os_dir
= NULL
;
2574 skip_multi_os_dir
= true;
2579 free (CONST_CAST (char *, multi_dir
));
2580 free (CONST_CAST (char *, multi_suffix
));
2581 free (CONST_CAST (char *, just_multi_suffix
));
2584 free (CONST_CAST (char *, multi_os_dir
));
2590 /* Callback for build_search_list. Adds path to obstack being built. */
2592 struct add_to_obstack_info
{
2599 add_to_obstack (char *path
, void *data
)
2601 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2603 if (info
->check_dir
&& !is_directory (path
, false))
2606 if (!info
->first_time
)
2607 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2609 obstack_grow (info
->ob
, path
, strlen (path
));
2611 info
->first_time
= false;
2615 /* Add or change the value of an environment variable, outputting the
2616 change to standard error if in verbose mode. */
2618 xputenv (const char *string
)
2621 fnotice (stderr
, "%s\n", string
);
2622 putenv (CONST_CAST (char *, string
));
2625 /* Build a list of search directories from PATHS.
2626 PREFIX is a string to prepend to the list.
2627 If CHECK_DIR_P is true we ensure the directory exists.
2628 If DO_MULTI is true, multilib paths are output first, then
2630 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2631 It is also used by the --print-search-dirs flag. */
2634 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2635 bool check_dir
, bool do_multi
)
2637 struct add_to_obstack_info info
;
2639 info
.ob
= &collect_obstack
;
2640 info
.check_dir
= check_dir
;
2641 info
.first_time
= true;
2643 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2644 obstack_1grow (&collect_obstack
, '=');
2646 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2648 obstack_1grow (&collect_obstack
, '\0');
2649 return XOBFINISH (&collect_obstack
, char *);
2652 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2656 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2659 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2662 /* Check whether NAME can be accessed in MODE. This is like access,
2663 except that it never considers directories to be executable. */
2666 access_check (const char *name
, int mode
)
2672 if (stat (name
, &st
) < 0
2673 || S_ISDIR (st
.st_mode
))
2677 return access (name
, mode
);
2680 /* Callback for find_a_file. Appends the file name to the directory
2681 path. If the resulting file exists in the right mode, return the
2682 full pathname to the file. */
2684 struct file_at_path_info
{
2693 file_at_path (char *path
, void *data
)
2695 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2696 size_t len
= strlen (path
);
2698 memcpy (path
+ len
, info
->name
, info
->name_len
);
2699 len
+= info
->name_len
;
2701 /* Some systems have a suffix for executable files.
2702 So try appending that first. */
2703 if (info
->suffix_len
)
2705 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2706 if (access_check (path
, info
->mode
) == 0)
2711 if (access_check (path
, info
->mode
) == 0)
2717 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2718 access to check permissions. If DO_MULTI is true, search multilib
2719 paths then non-multilib paths, otherwise do not search multilib paths.
2720 Return 0 if not found, otherwise return its name, allocated with malloc. */
2723 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2726 struct file_at_path_info info
;
2728 #ifdef DEFAULT_ASSEMBLER
2729 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2730 return xstrdup (DEFAULT_ASSEMBLER
);
2733 #ifdef DEFAULT_LINKER
2734 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2735 return xstrdup (DEFAULT_LINKER
);
2738 /* Determine the filename to execute (special case for absolute paths). */
2740 if (IS_ABSOLUTE_PATH (name
))
2742 if (access (name
, mode
) == 0)
2743 return xstrdup (name
);
2749 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2750 info
.name_len
= strlen (info
.name
);
2751 info
.suffix_len
= strlen (info
.suffix
);
2754 return (char*) for_each_path (pprefix
, do_multi
,
2755 info
.name_len
+ info
.suffix_len
,
2756 file_at_path
, &info
);
2759 /* Ranking of prefixes in the sort list. -B prefixes are put before
2762 enum path_prefix_priority
2764 PREFIX_PRIORITY_B_OPT
,
2765 PREFIX_PRIORITY_LAST
2768 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2769 order according to PRIORITY. Within each PRIORITY, new entries are
2772 If WARN is nonzero, we will warn if no file is found
2773 through this prefix. WARN should point to an int
2774 which will be set to 1 if this entry is used.
2776 COMPONENT is the value to be passed to update_path.
2778 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2779 the complete value of machine_suffix.
2780 2 means try both machine_suffix and just_machine_suffix. */
2783 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2784 const char *component
, /* enum prefix_priority */ int priority
,
2785 int require_machine_suffix
, int os_multilib
)
2787 struct prefix_list
*pl
, **prev
;
2790 for (prev
= &pprefix
->plist
;
2791 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2792 prev
= &(*prev
)->next
)
2795 /* Keep track of the longest prefix. */
2797 prefix
= update_path (prefix
, component
);
2798 len
= strlen (prefix
);
2799 if (len
> pprefix
->max_len
)
2800 pprefix
->max_len
= len
;
2802 pl
= XNEW (struct prefix_list
);
2803 pl
->prefix
= prefix
;
2804 pl
->require_machine_suffix
= require_machine_suffix
;
2805 pl
->priority
= priority
;
2806 pl
->os_multilib
= os_multilib
;
2808 /* Insert after PREV. */
2813 /* Same as add_prefix, but prepending target_system_root to prefix. */
2814 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2816 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2817 const char *component
,
2818 /* enum prefix_priority */ int priority
,
2819 int require_machine_suffix
, int os_multilib
)
2821 if (!IS_ABSOLUTE_PATH (prefix
))
2822 fatal_error ("system path %qs is not absolute", prefix
);
2824 if (target_system_root
)
2826 if (target_sysroot_suffix
)
2827 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2828 prefix
= concat (target_system_root
, prefix
, NULL
);
2830 /* We have to override this because GCC's notion of sysroot
2831 moves along with GCC. */
2835 add_prefix (pprefix
, prefix
, component
, priority
,
2836 require_machine_suffix
, os_multilib
);
2839 /* Execute the command specified by the arguments on the current line of spec.
2840 When using pipes, this includes several piped-together commands
2841 with `|' between them.
2843 Return 0 if successful, -1 if failed. */
2849 int n_commands
; /* # of command. */
2851 struct pex_obj
*pex
;
2854 const char *prog
; /* program name. */
2855 const char **argv
; /* vector of args. */
2858 struct command
*commands
; /* each command buffer with above info. */
2860 gcc_assert (!processing_spec_function
);
2864 string
= find_a_file (&exec_prefixes
, argbuf
[0], X_OK
, false);
2865 argbuf
[0] = (string
) ? string
: argbuf
[0];
2866 insert_wrapper (wrapper_string
);
2869 /* Count # of piped commands. */
2870 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2871 if (strcmp (argbuf
[i
], "|") == 0)
2874 /* Get storage for each command. */
2875 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2877 /* Split argbuf into its separate piped processes,
2878 and record info about each one.
2879 Also search for the programs that are to be run. */
2881 commands
[0].prog
= argbuf
[0]; /* first command. */
2882 commands
[0].argv
= &argbuf
[0];
2884 if (!wrapper_string
)
2886 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2887 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2890 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2891 if (strcmp (argbuf
[i
], "|") == 0)
2892 { /* each command. */
2893 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2894 fatal_error ("-pipe not supported");
2896 argbuf
[i
] = 0; /* termination of command args. */
2897 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2898 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2899 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2902 commands
[n_commands
].argv
[0] = string
;
2906 argbuf
[argbuf_index
] = 0;
2908 /* If -v, print what we are about to do, and maybe query. */
2912 /* For help listings, put a blank line between sub-processes. */
2913 if (print_help_list
)
2914 fputc ('\n', stderr
);
2916 /* Print each piped command as a separate line. */
2917 for (i
= 0; i
< n_commands
; i
++)
2919 const char *const *j
;
2921 if (verbose_only_flag
)
2923 for (j
= commands
[i
].argv
; *j
; j
++)
2926 for (p
= *j
; *p
; ++p
)
2927 if (!ISALNUM ((unsigned char) *p
)
2928 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2932 fprintf (stderr
, " \"");
2933 for (p
= *j
; *p
; ++p
)
2935 if (*p
== '"' || *p
== '\\' || *p
== '$')
2936 fputc ('\\', stderr
);
2939 fputc ('"', stderr
);
2942 fprintf (stderr
, " %s", *j
);
2946 for (j
= commands
[i
].argv
; *j
; j
++)
2947 fprintf (stderr
, " %s", *j
);
2949 /* Print a pipe symbol after all but the last command. */
2950 if (i
+ 1 != n_commands
)
2951 fprintf (stderr
, " |");
2952 fprintf (stderr
, "\n");
2955 if (verbose_only_flag
!= 0)
2957 /* verbose_only_flag should act as if the spec was
2958 executed, so increment execution_count before
2959 returning. This prevents spurious warnings about
2960 unused linker input files, etc. */
2965 fnotice (stderr
, "\nGo ahead? (y or n) ");
2969 while (getchar () != '\n')
2972 if (i
!= 'y' && i
!= 'Y')
2977 #ifdef ENABLE_VALGRIND_CHECKING
2978 /* Run the each command through valgrind. To simplify prepending the
2979 path to valgrind and the option "-q" (for quiet operation unless
2980 something triggers), we allocate a separate argv array. */
2982 for (i
= 0; i
< n_commands
; i
++)
2988 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2991 argv
= XALLOCAVEC (const char *, argc
+ 3);
2993 argv
[0] = VALGRIND_PATH
;
2995 for (j
= 2; j
< argc
+ 2; j
++)
2996 argv
[j
] = commands
[i
].argv
[j
- 2];
2999 commands
[i
].argv
= argv
;
3000 commands
[i
].prog
= argv
[0];
3004 /* Run each piped subprocess. */
3006 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3007 ? PEX_RECORD_TIMES
: 0),
3008 progname
, temp_filename
);
3010 fatal_error ("pex_init failed: %m");
3012 for (i
= 0; i
< n_commands
; i
++)
3016 const char *string
= commands
[i
].argv
[0];
3018 errmsg
= pex_run (pex
,
3019 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3020 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3021 string
, CONST_CAST (char **, commands
[i
].argv
),
3026 fatal_error (errmsg
);
3030 pfatal_with_name (errmsg
);
3034 if (string
!= commands
[i
].prog
)
3035 free (CONST_CAST (char *, string
));
3040 /* Wait for all the subprocesses to finish. */
3044 struct pex_time
*times
= NULL
;
3047 statuses
= (int *) alloca (n_commands
* sizeof (int));
3048 if (!pex_get_status (pex
, n_commands
, statuses
))
3049 fatal_error ("failed to get exit status: %m");
3051 if (report_times
|| report_times_to_file
)
3053 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3054 if (!pex_get_times (pex
, n_commands
, times
))
3055 fatal_error ("failed to get process times: %m");
3060 for (i
= 0; i
< n_commands
; ++i
)
3062 int status
= statuses
[i
];
3064 if (WIFSIGNALED (status
))
3067 /* SIGPIPE is a special case. It happens in -pipe mode
3068 when the compiler dies before the preprocessor is done,
3069 or the assembler dies before the compiler is done.
3070 There's generally been an error already, and this is
3071 just fallout. So don't generate another error unless
3072 we would otherwise have succeeded. */
3073 if (WTERMSIG (status
) == SIGPIPE
3074 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3081 internal_error ("%s (program %s)",
3082 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
3084 else if (WIFEXITED (status
)
3085 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3087 if (WEXITSTATUS (status
) > greatest_status
)
3088 greatest_status
= WEXITSTATUS (status
);
3092 if (report_times
|| report_times_to_file
)
3094 struct pex_time
*pt
= ×
[i
];
3097 ut
= ((double) pt
->user_seconds
3098 + (double) pt
->user_microseconds
/ 1.0e6
);
3099 st
= ((double) pt
->system_seconds
3100 + (double) pt
->system_microseconds
/ 1.0e6
);
3105 fnotice (stderr
, "# %s %.2f %.2f\n",
3106 commands
[i
].prog
, ut
, st
);
3108 if (report_times_to_file
)
3111 const char *const *j
;
3113 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3115 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3118 for (p
= *j
; *p
; ++p
)
3119 if (*p
== '"' || *p
== '\\' || *p
== '$'
3125 fprintf (report_times_to_file
, " \"");
3126 for (p
= *j
; *p
; ++p
)
3128 if (*p
== '"' || *p
== '\\' || *p
== '$')
3129 fputc ('\\', report_times_to_file
);
3130 fputc (*p
, report_times_to_file
);
3132 fputc ('"', report_times_to_file
);
3135 fprintf (report_times_to_file
, " %s", *j
);
3138 fputc ('\n', report_times_to_file
);
3148 /* Find all the switches given to us
3149 and make a vector describing them.
3150 The elements of the vector are strings, one per switch given.
3151 If a switch uses following arguments, then the `part1' field
3152 is the switch itself and the `args' field
3153 is a null-terminated vector containing the following arguments.
3154 Bits in the `live_cond' field are:
3155 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3156 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3157 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3158 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3159 in all do_spec calls afterwards. Used for %<S from self specs.
3160 The `validated' field is nonzero if any spec has looked at this switch;
3161 if it remains zero at the end of the run, it must be meaningless. */
3163 #define SWITCH_LIVE 0x1
3164 #define SWITCH_FALSE 0x2
3165 #define SWITCH_IGNORE 0x4
3166 #define SWITCH_IGNORE_PERMANENTLY 0x8
3172 unsigned int live_cond
;
3173 unsigned char validated
;
3174 unsigned char ordering
;
3177 static struct switchstr
*switches
;
3179 static int n_switches
;
3181 static int n_switches_alloc
;
3183 /* Set to zero if -fcompare-debug is disabled, positive if it's
3184 enabled and we're running the first compilation, negative if it's
3185 enabled and we're running the second compilation. For most of the
3186 time, it's in the range -1..1, but it can be temporarily set to 2
3187 or 3 to indicate that the -fcompare-debug flags didn't come from
3188 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3189 variable, until a synthesized -fcompare-debug flag is added to the
3193 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3194 int compare_debug_second
;
3196 /* Set to the flags that should be passed to the second compilation in
3197 a -fcompare-debug compilation. */
3198 const char *compare_debug_opt
;
3200 static struct switchstr
*switches_debug_check
[2];
3202 static int n_switches_debug_check
[2];
3204 static char *debug_check_temp_file
[2];
3206 /* Language is one of three things:
3208 1) The name of a real programming language.
3209 2) NULL, indicating that no one has figured out
3211 3) '*', indicating that the file should be passed
3216 const char *language
;
3217 struct compiler
*incompiler
;
3222 /* Also a vector of input files specified. */
3224 static struct infile
*infiles
;
3228 static int n_infiles_alloc
;
3230 /* True if multiple input files are being compiled to a single
3233 static bool combine_inputs
;
3235 /* This counts the number of libraries added by lang_specific_driver, so that
3236 we can tell if there were any user supplied any files or libraries. */
3238 static int added_libraries
;
3240 /* And a vector of corresponding output files is made up later. */
3242 const char **outfiles
;
3244 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3246 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3247 is true if we should look for an executable suffix. DO_OBJ
3248 is true if we should look for an object suffix. */
3251 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3252 int do_obj ATTRIBUTE_UNUSED
)
3254 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3262 len
= strlen (name
);
3264 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3265 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3266 if (do_obj
&& len
> 2
3267 && name
[len
- 2] == '.'
3268 && name
[len
- 1] == 'o')
3270 obstack_grow (&obstack
, name
, len
- 2);
3271 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3272 name
= XOBFINISH (&obstack
, const char *);
3276 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3277 /* If there is no filetype, make it the executable suffix (which includes
3278 the "."). But don't get confused if we have just "-o". */
3279 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3282 for (i
= len
- 1; i
>= 0; i
--)
3283 if (IS_DIR_SEPARATOR (name
[i
]))
3286 for (i
++; i
< len
; i
++)
3290 obstack_grow (&obstack
, name
, len
);
3291 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3292 strlen (TARGET_EXECUTABLE_SUFFIX
));
3293 name
= XOBFINISH (&obstack
, const char *);
3300 /* Display the command line switches accepted by gcc. */
3304 printf (_("Usage: %s [options] file...\n"), progname
);
3305 fputs (_("Options:\n"), stdout
);
3307 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3308 fputs (_(" --help Display this information\n"), stdout
);
3309 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3310 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3311 fputs (_(" Display specific types of command line options\n"), stdout
);
3313 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3314 fputs (_(" --version Display compiler version information\n"), stdout
);
3315 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3316 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3317 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3318 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3319 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3320 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3321 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3322 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3324 -print-multi-lib Display the mapping between command line options and\n\
3325 multiple library search directories\n"), stdout
);
3326 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3327 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3328 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3329 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3330 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3331 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3332 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3333 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3334 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3335 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout
);
3336 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3337 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3339 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3340 prefixes to other gcc components\n"), stdout
);
3341 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3342 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3343 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3344 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3346 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3347 and libraries\n"), stdout
);
3348 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3349 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3350 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3351 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3352 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3353 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3354 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3356 -x <language> Specify the language of the following input files\n\
3357 Permissible languages include: c c++ assembler none\n\
3358 'none' means revert to the default behavior of\n\
3359 guessing the language based on the file's extension\n\
3363 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3364 passed on to the various sub-processes invoked by %s. In order to pass\n\
3365 other options on to these processes the -W<letter> options must be used.\n\
3368 /* The rest of the options are displayed by invocations of the various
3373 add_preprocessor_option (const char *option
, int len
)
3375 n_preprocessor_options
++;
3377 if (! preprocessor_options
)
3378 preprocessor_options
= XNEWVEC (char *, n_preprocessor_options
);
3380 preprocessor_options
= XRESIZEVEC (char *, preprocessor_options
,
3381 n_preprocessor_options
);
3383 preprocessor_options
[n_preprocessor_options
- 1] =
3384 save_string (option
, len
);
3388 add_assembler_option (const char *option
, int len
)
3390 n_assembler_options
++;
3392 if (! assembler_options
)
3393 assembler_options
= XNEWVEC (char *, n_assembler_options
);
3395 assembler_options
= XRESIZEVEC (char *, assembler_options
,
3396 n_assembler_options
);
3398 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3402 add_linker_option (const char *option
, int len
)
3406 if (! linker_options
)
3407 linker_options
= XNEWVEC (char *, n_linker_options
);
3409 linker_options
= XRESIZEVEC (char *, linker_options
, n_linker_options
);
3411 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3414 /* Allocate space for an input file in infiles. */
3419 if (n_infiles_alloc
== 0)
3421 n_infiles_alloc
= 16;
3422 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3424 else if (n_infiles_alloc
== n_infiles
)
3426 n_infiles_alloc
*= 2;
3427 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3431 /* Store an input file with the given NAME and LANGUAGE in
3435 add_infile (const char *name
, const char *language
)
3438 infiles
[n_infiles
].name
= name
;
3439 infiles
[n_infiles
++].language
= language
;
3442 /* Allocate space for a switch in switches. */
3447 if (n_switches_alloc
== 0)
3449 n_switches_alloc
= 16;
3450 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3452 else if (n_switches_alloc
== n_switches
)
3454 n_switches_alloc
*= 2;
3455 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3459 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3460 as validated if VALIDATED. */
3463 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3467 switches
[n_switches
].part1
= opt
+ 1;
3469 switches
[n_switches
].args
= 0;
3472 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3473 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3474 switches
[n_switches
].args
[n_args
] = NULL
;
3477 switches
[n_switches
].live_cond
= 0;
3478 switches
[n_switches
].validated
= validated
;
3479 switches
[n_switches
].ordering
= 0;
3483 /* Handle an option DECODED that is unknown to the option-processing
3484 machinery, but may be known to specs. */
3487 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3489 save_switch (decoded
->canonical_option
[0],
3490 decoded
->canonical_option_num_elements
- 1,
3491 &decoded
->canonical_option
[1], false);
3496 /* Handle an option DECODED that is not marked as CL_DRIVER.
3497 LANG_MASK will always be CL_DRIVER. */
3500 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3501 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3503 /* At this point, non-driver options are accepted (and expected to
3504 be passed down by specs) unless marked to be rejected by the
3505 driver. Options to be rejected by the driver but accepted by the
3506 compilers proper are treated just like completely unknown
3508 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3510 if (option
->flags
& CL_REJECT_DRIVER
)
3511 error ("unrecognized command line option %qs",
3512 decoded
->orig_option_with_args_text
);
3514 driver_unknown_option_callback (decoded
);
3517 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3518 has been successfully handled with a handler for mask MASK. */
3521 driver_post_handling_callback (const struct cl_decoded_option
*decoded ATTRIBUTE_UNUSED
,
3522 unsigned int mask ATTRIBUTE_UNUSED
)
3524 /* Nothing to do here. */
3527 static const char *spec_lang
= 0;
3528 static int last_language_n_infiles
;
3530 /* Handle a driver option; arguments and return value as for
3534 driver_handle_option (const struct cl_decoded_option
*decoded
,
3535 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3536 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
)
3538 size_t opt_index
= decoded
->opt_index
;
3539 const char *arg
= decoded
->arg
;
3540 const char *compare_debug_replacement_opt
;
3541 int value
= decoded
->value
;
3542 bool validated
= false;
3543 bool do_save
= true;
3545 gcc_assert (kind
== DK_UNSPECIFIED
);
3551 struct spec_list
*sl
;
3553 for (sl
= specs
; sl
; sl
= sl
->next
)
3554 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3555 if (link_command_spec
)
3556 printf ("*link_command:\n%s\n\n", link_command_spec
);
3560 case OPT_dumpversion
:
3561 printf ("%s\n", spec_version
);
3564 case OPT_dumpmachine
:
3565 printf ("%s\n", spec_machine
);
3569 /* translate_options () has turned --version into -fversion. */
3572 /* CPP driver cannot obtain switch from cc1_options. */
3574 add_preprocessor_option ("--version", strlen ("--version"));
3575 add_assembler_option ("--version", strlen ("--version"));
3576 add_linker_option ("--version", strlen ("--version"));
3580 /* translate_options () has turned --help into -fhelp. */
3581 print_help_list
= 1;
3583 /* CPP driver cannot obtain switch from cc1_options. */
3585 add_preprocessor_option ("--help", 6);
3586 add_assembler_option ("--help", 6);
3587 add_linker_option ("--help", 6);
3591 /* translate_options () has turned --help into -fhelp. */
3592 print_subprocess_help
= 2;
3595 case OPT_ftarget_help
:
3596 /* translate_options() has turned --target-help into -ftarget-help. */
3597 print_subprocess_help
= 1;
3599 /* CPP driver cannot obtain switch from cc1_options. */
3601 add_preprocessor_option ("--target-help", 13);
3602 add_assembler_option ("--target-help", 13);
3603 add_linker_option ("--target-help", 13);
3606 case OPT_pass_exit_codes
:
3607 case OPT_print_search_dirs
:
3608 case OPT_print_file_name_
:
3609 case OPT_print_prog_name_
:
3610 case OPT_print_multi_lib
:
3611 case OPT_print_multi_directory
:
3612 case OPT_print_sysroot
:
3613 case OPT_print_multi_os_directory
:
3614 case OPT_print_sysroot_headers_suffix
:
3617 /* These options set the variables specified in common.opt
3618 automatically, and do not need to be saved for spec
3623 case OPT_print_libgcc_file_name
:
3624 print_file_name
= "libgcc.a";
3628 case OPT_fcompare_debug_second
:
3629 compare_debug_second
= 1;
3632 case OPT_fcompare_debug
:
3636 compare_debug_replacement_opt
= "-fcompare-debug=";
3638 goto compare_debug_with_arg
;
3641 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3643 goto compare_debug_with_arg
;
3650 case OPT_fcompare_debug_
:
3651 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3652 compare_debug_with_arg
:
3653 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3654 gcc_assert (arg
!= NULL
);
3659 if (compare_debug
< 0)
3660 compare_debug_opt
= NULL
;
3662 compare_debug_opt
= arg
;
3663 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
);
3669 /* Pass the rest of this option to the assembler. */
3671 /* Split the argument at commas. */
3673 for (j
= 0; arg
[j
]; j
++)
3676 add_assembler_option (arg
+ prev
, j
- prev
);
3680 /* Record the part after the last comma. */
3681 add_assembler_option (arg
+ prev
, j
- prev
);
3689 /* Pass the rest of this option to the preprocessor. */
3691 /* Split the argument at commas. */
3693 for (j
= 0; arg
[j
]; j
++)
3696 add_preprocessor_option (arg
+ prev
, j
- prev
);
3700 /* Record the part after the last comma. */
3701 add_preprocessor_option (arg
+ prev
, j
- prev
);
3709 /* Split the argument at commas. */
3711 for (j
= 0; arg
[j
]; j
++)
3714 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3717 /* Record the part after the last comma. */
3718 add_infile (arg
+ prev
, "*");
3724 add_infile (arg
, "*");
3728 case OPT_Xpreprocessor
:
3729 add_preprocessor_option (arg
, strlen (arg
));
3733 case OPT_Xassembler
:
3734 add_assembler_option (arg
, strlen (arg
));
3739 /* POSIX allows separation of -l and the lib arg; canonicalize
3740 by concatenating -l with its arg */
3741 add_infile (concat ("-l", arg
, NULL
), "*");
3746 /* Similarly, canonicalize -L for linkers that may not accept
3747 separate arguments. */
3748 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
);
3751 case OPT_save_temps
:
3752 save_temps_flag
= SAVE_TEMPS_CWD
;
3756 case OPT_save_temps_
:
3757 if (strcmp (arg
, "cwd") == 0)
3758 save_temps_flag
= SAVE_TEMPS_CWD
;
3759 else if (strcmp (arg
, "obj") == 0
3760 || strcmp (arg
, "object") == 0)
3761 save_temps_flag
= SAVE_TEMPS_OBJ
;
3763 fatal_error ("%qs is an unknown -save-temps option",
3764 decoded
->orig_option_with_args_text
);
3767 case OPT_no_canonical_prefixes
:
3768 /* Already handled as a special case, so ignored here. */
3776 /* These options set the variables specified in common.opt
3777 automatically, but do need to be saved for spec
3783 struct user_specs
*user
= XNEW (struct user_specs
);
3785 user
->next
= (struct user_specs
*) 0;
3786 user
->filename
= arg
;
3787 if (user_specs_tail
)
3788 user_specs_tail
->next
= user
;
3790 user_specs_head
= user
;
3791 user_specs_tail
= user
;
3797 target_system_root
= arg
;
3798 target_system_root_changed
= 1;
3803 if (report_times_to_file
)
3804 fclose (report_times_to_file
);
3805 report_times_to_file
= fopen (arg
, "a");
3811 This is similar to -v except that there is no execution
3812 of the commands and the echoed arguments are quoted. It
3813 is intended for use in shell scripts to capture the
3814 driver-generated command line. */
3815 verbose_only_flag
++;
3822 size_t len
= strlen (arg
);
3824 /* Catch the case where the user has forgotten to append a
3825 directory separator to the path. Note, they may be using
3826 -B to add an executable name prefix, eg "i386-elf-", in
3827 order to distinguish between multiple installations of
3828 GCC in the same directory. Hence we must check to see
3829 if appending a directory separator actually makes a
3830 valid directory name. */
3831 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3832 && is_directory (arg
, false))
3834 char *tmp
= XNEWVEC (char, len
+ 2);
3836 tmp
[len
] = DIR_SEPARATOR
;
3841 add_prefix (&exec_prefixes
, arg
, NULL
,
3842 PREFIX_PRIORITY_B_OPT
, 0, 0);
3843 add_prefix (&startfile_prefixes
, arg
, NULL
,
3844 PREFIX_PRIORITY_B_OPT
, 0, 0);
3845 add_prefix (&include_prefixes
, arg
, NULL
,
3846 PREFIX_PRIORITY_B_OPT
, 0, 0);
3851 case OPT_v
: /* Print our subcommands and print versions. */
3857 if (!strcmp (spec_lang
, "none"))
3858 /* Suppress the warning if -xnone comes after the last input
3859 file, because alternate command interfaces like g++ might
3860 find it useful to place -xnone after each input file. */
3863 last_language_n_infiles
= n_infiles
;
3869 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3870 arg
= convert_filename (arg
, ! have_c
, 0);
3872 /* Save the output name in case -save-temps=obj was used. */
3873 save_temps_prefix
= xstrdup (arg
);
3874 /* On some systems, ld cannot handle "-o" without a space. So
3875 split the option from its argument. */
3876 save_switch ("-o", 1, &arg
, validated
);
3879 case OPT_static_libgcc
:
3880 case OPT_shared_libgcc
:
3881 case OPT_static_libgfortran
:
3882 case OPT_static_libstdc__
:
3883 /* These are always valid, since gcc.c itself understands the
3884 first two, gfortranspec.c understands -static-libgfortran and
3885 g++spec.c understands -static-libstdc++ */
3890 /* Various driver options need no special processing at this
3891 point, having been handled in a prescan above or being
3892 handled by specs. */
3897 save_switch (decoded
->canonical_option
[0],
3898 decoded
->canonical_option_num_elements
- 1,
3899 &decoded
->canonical_option
[1], validated
);
3903 /* Create the vector `switches' and its contents.
3904 Store its length in `n_switches'. */
3907 process_command (int argc
, const char **argv
)
3912 const char *tooldir_prefix
;
3913 char *(*get_relative_prefix
) (const char *, const char *,
3914 const char *) = NULL
;
3915 struct cl_option_handlers handlers
;
3916 struct cl_decoded_option
*decoded_options
;
3917 unsigned int decoded_options_count
, j
;
3919 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3923 added_libraries
= 0;
3925 /* Figure compiler version from version string. */
3927 compiler_version
= temp1
= xstrdup (version_string
);
3929 for (; *temp1
; ++temp1
)
3938 /* Convert new-style -- options to old-style. */
3939 translate_options (&argc
,
3940 CONST_CAST2 (const char *const **, const char ***,
3943 /* Handle any -no-canonical-prefixes flag early, to assign the function
3944 that builds relative prefixes. This function creates default search
3945 paths that are needed later in normal option handling. */
3947 for (i
= 1; i
< argc
; i
++)
3949 if (! strcmp (argv
[i
], "-no-canonical-prefixes"))
3951 get_relative_prefix
= make_relative_prefix_ignore_links
;
3955 if (! get_relative_prefix
)
3956 get_relative_prefix
= make_relative_prefix
;
3958 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3959 see if we can create it from the pathname specified in argv[0]. */
3961 gcc_libexec_prefix
= standard_libexec_prefix
;
3963 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3964 if (!gcc_exec_prefix
)
3966 gcc_exec_prefix
= get_relative_prefix (argv
[0],
3967 standard_bindir_prefix
,
3968 standard_exec_prefix
);
3969 gcc_libexec_prefix
= get_relative_prefix (argv
[0],
3970 standard_bindir_prefix
,
3971 standard_libexec_prefix
);
3972 if (gcc_exec_prefix
)
3973 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3977 /* make_relative_prefix requires a program name, but
3978 GCC_EXEC_PREFIX is typically a directory name with a trailing
3979 / (which is ignored by make_relative_prefix), so append a
3981 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3982 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3983 standard_exec_prefix
,
3984 standard_libexec_prefix
);
3986 /* The path is unrelocated, so fallback to the original setting. */
3987 if (!gcc_libexec_prefix
)
3988 gcc_libexec_prefix
= standard_libexec_prefix
;
3994 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3995 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3996 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3998 decode_cmdline_options_to_array (argc
, argv
, CL_DRIVER
,
3999 &decoded_options
, &decoded_options_count
);
4001 /* Do language-specific adjustment/addition of flags. */
4002 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4005 if (gcc_exec_prefix
)
4007 int len
= strlen (gcc_exec_prefix
);
4009 if (len
> (int) sizeof ("/lib/gcc/") - 1
4010 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4012 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4013 if (IS_DIR_SEPARATOR (*temp
)
4014 && strncmp (temp
+ 1, "lib", 3) == 0
4015 && IS_DIR_SEPARATOR (temp
[4])
4016 && strncmp (temp
+ 5, "gcc", 3) == 0)
4017 len
-= sizeof ("/lib/gcc/") - 1;
4020 set_std_prefix (gcc_exec_prefix
, len
);
4021 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4022 PREFIX_PRIORITY_LAST
, 0, 0);
4023 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4024 PREFIX_PRIORITY_LAST
, 0, 0);
4027 /* COMPILER_PATH and LIBRARY_PATH have values
4028 that are lists of directory names with colons. */
4030 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
4033 const char *startp
, *endp
;
4034 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4036 startp
= endp
= temp
;
4039 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4041 strncpy (nstore
, startp
, endp
- startp
);
4043 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4044 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4046 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4047 nstore
[endp
- startp
+ 1] = 0;
4050 nstore
[endp
- startp
] = 0;
4051 add_prefix (&exec_prefixes
, nstore
, 0,
4052 PREFIX_PRIORITY_LAST
, 0, 0);
4053 add_prefix (&include_prefixes
, nstore
, 0,
4054 PREFIX_PRIORITY_LAST
, 0, 0);
4057 endp
= startp
= endp
+ 1;
4064 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
4065 if (temp
&& *cross_compile
== '0')
4067 const char *startp
, *endp
;
4068 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4070 startp
= endp
= temp
;
4073 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4075 strncpy (nstore
, startp
, endp
- startp
);
4077 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4078 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4080 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4081 nstore
[endp
- startp
+ 1] = 0;
4084 nstore
[endp
- startp
] = 0;
4085 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4086 PREFIX_PRIORITY_LAST
, 0, 1);
4089 endp
= startp
= endp
+ 1;
4096 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4097 GET_ENVIRONMENT (temp
, "LPATH");
4098 if (temp
&& *cross_compile
== '0')
4100 const char *startp
, *endp
;
4101 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4103 startp
= endp
= temp
;
4106 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4108 strncpy (nstore
, startp
, endp
- startp
);
4110 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4111 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4113 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4114 nstore
[endp
- startp
+ 1] = 0;
4117 nstore
[endp
- startp
] = 0;
4118 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4119 PREFIX_PRIORITY_LAST
, 0, 1);
4122 endp
= startp
= endp
+ 1;
4129 /* Process the options and store input files and switches in their
4132 last_language_n_infiles
= -1;
4134 handlers
.unknown_option_callback
= driver_unknown_option_callback
;
4135 handlers
.wrong_lang_callback
= driver_wrong_lang_callback
;
4136 handlers
.post_handling_callback
= driver_post_handling_callback
;
4137 handlers
.num_handlers
= 1;
4138 handlers
.handlers
[0].handler
= driver_handle_option
;
4139 handlers
.handlers
[0].mask
= CL_DRIVER
;
4141 for (j
= 1; j
< decoded_options_count
; j
++)
4143 switch (decoded_options
[j
].opt_index
)
4155 for (j
= 1; j
< decoded_options_count
; j
++)
4157 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4159 const char *arg
= decoded_options
[j
].arg
;
4160 const char *p
= strrchr (arg
, '@');
4164 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4165 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4167 /* For LTO static archive support we handle input file
4168 specifications that are composed of a filename and
4169 an offset like FNAME@OFFSET. */
4172 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4173 && strlen (p
) == (unsigned int)consumed
)
4175 fname
= (char *)xmalloc (p
- arg
+ 1);
4176 memcpy (fname
, arg
, p
- arg
);
4177 fname
[p
- arg
] = '\0';
4178 /* Only accept non-stdin and existing FNAME parts, otherwise
4179 try with the full name. */
4180 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4183 fname
= xstrdup (arg
);
4187 fname
= xstrdup (arg
);
4189 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4190 perror_with_name (fname
);
4192 add_infile (arg
, spec_lang
);
4198 read_cmdline_option (decoded_options
+ j
, CL_DRIVER
, &handlers
);
4201 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4202 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4203 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4205 save_temps_length
= strlen (save_temps_prefix
);
4206 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4209 save_temps_length
-= strlen (temp
);
4210 save_temps_prefix
[save_temps_length
] = '\0';
4214 else if (save_temps_prefix
!= NULL
)
4216 free (save_temps_prefix
);
4217 save_temps_prefix
= NULL
;
4220 if (save_temps_flag
&& use_pipes
)
4222 /* -save-temps overrides -pipe, so that temp files are produced */
4223 if (save_temps_flag
)
4224 warning (0, "-pipe ignored because -save-temps specified");
4230 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
4232 if (gcd
&& gcd
[0] == '-')
4235 compare_debug_opt
= gcd
;
4237 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4240 compare_debug_opt
= "-gtoggle";
4243 else if (compare_debug
< 0)
4246 gcc_assert (!compare_debug_opt
);
4249 /* Set up the search paths. We add directories that we expect to
4250 contain GNU Toolchain components before directories specified by
4251 the machine description so that we will find GNU components (like
4252 the GNU assembler) before those of the host system. */
4254 /* If we don't know where the toolchain has been installed, use the
4255 configured-in locations. */
4256 if (!gcc_exec_prefix
)
4259 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4260 PREFIX_PRIORITY_LAST
, 1, 0);
4261 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4262 PREFIX_PRIORITY_LAST
, 2, 0);
4263 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4264 PREFIX_PRIORITY_LAST
, 2, 0);
4266 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4267 PREFIX_PRIORITY_LAST
, 1, 0);
4270 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4271 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
4272 dir_separator_str
, NULL
);
4274 /* Look for tools relative to the location from which the driver is
4275 running, or, if that is not available, the configured prefix. */
4277 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4278 spec_machine
, dir_separator_str
,
4279 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
4281 add_prefix (&exec_prefixes
,
4282 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4283 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4284 add_prefix (&startfile_prefixes
,
4285 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4286 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4288 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4289 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4290 then consider it to relocate with the rest of the GCC installation
4291 if GCC_EXEC_PREFIX is set.
4292 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4293 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4295 char *tmp_prefix
= get_relative_prefix (argv
[0],
4296 standard_bindir_prefix
,
4297 target_system_root
);
4298 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4300 target_system_root
= tmp_prefix
;
4301 target_system_root_changed
= 1;
4306 /* More prefixes are enabled in main, after we read the specs file
4307 and determine whether this is cross-compilation or not. */
4309 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4310 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4312 if (compare_debug
== 2 || compare_debug
== 3)
4315 switches
[n_switches
].part1
= concat ("fcompare-debug=",
4318 switches
[n_switches
].args
= 0;
4319 switches
[n_switches
].live_cond
= 0;
4320 switches
[n_switches
].validated
= 0;
4321 switches
[n_switches
].ordering
= 0;
4326 /* Ensure we only invoke each subprocess once. */
4327 if (print_subprocess_help
|| print_help_list
|| print_version
)
4331 /* Create a dummy input file, so that we can pass
4332 the help option on to the various sub-processes. */
4333 add_infile ("help-dummy", "c");
4337 switches
[n_switches
].part1
= 0;
4339 infiles
[n_infiles
].name
= 0;
4342 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4343 and place that in the environment. */
4346 set_collect_gcc_options (void)
4351 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4353 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4354 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4357 for (i
= 0; (int) i
< n_switches
; i
++)
4359 const char *const *args
;
4362 obstack_grow (&collect_obstack
, " ", 1);
4366 /* Ignore elided switches. */
4367 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) != 0)
4370 obstack_grow (&collect_obstack
, "'-", 2);
4371 q
= switches
[i
].part1
;
4372 while ((p
= strchr (q
, '\'')))
4374 obstack_grow (&collect_obstack
, q
, p
- q
);
4375 obstack_grow (&collect_obstack
, "'\\''", 4);
4378 obstack_grow (&collect_obstack
, q
, strlen (q
));
4379 obstack_grow (&collect_obstack
, "'", 1);
4381 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4383 obstack_grow (&collect_obstack
, " '", 2);
4385 while ((p
= strchr (q
, '\'')))
4387 obstack_grow (&collect_obstack
, q
, p
- q
);
4388 obstack_grow (&collect_obstack
, "'\\''", 4);
4391 obstack_grow (&collect_obstack
, q
, strlen (q
));
4392 obstack_grow (&collect_obstack
, "'", 1);
4395 obstack_grow (&collect_obstack
, "\0", 1);
4396 xputenv (XOBFINISH (&collect_obstack
, char *));
4399 /* Process a spec string, accumulating and running commands. */
4401 /* These variables describe the input file name.
4402 input_file_number is the index on outfiles of this file,
4403 so that the output file name can be stored for later use by %o.
4404 input_basename is the start of the part of the input file
4405 sans all directory names, and basename_length is the number
4406 of characters starting there excluding the suffix .c or whatever. */
4408 static const char *gcc_input_filename
;
4409 static int input_file_number
;
4410 size_t input_filename_length
;
4411 static int basename_length
;
4412 static int suffixed_basename_length
;
4413 static const char *input_basename
;
4414 static const char *input_suffix
;
4415 #ifndef HOST_LACKS_INODE_NUMBERS
4416 static struct stat input_stat
;
4418 static int input_stat_set
;
4420 /* The compiler used to process the current input file. */
4421 static struct compiler
*input_file_compiler
;
4423 /* These are variables used within do_spec and do_spec_1. */
4425 /* Nonzero if an arg has been started and not yet terminated
4426 (with space, tab or newline). */
4427 static int arg_going
;
4429 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4430 is a temporary file name. */
4431 static int delete_this_arg
;
4433 /* Nonzero means %w has been seen; the next arg to be terminated
4434 is the output file name of this compilation. */
4435 static int this_is_output_file
;
4437 /* Nonzero means %s has been seen; the next arg to be terminated
4438 is the name of a library file and we should try the standard
4439 search dirs for it. */
4440 static int this_is_library_file
;
4442 /* Nonzero means %T has been seen; the next arg to be terminated
4443 is the name of a linker script and we should try all of the
4444 standard search dirs for it. If it is found insert a --script
4445 command line switch and then substitute the full path in place,
4446 otherwise generate an error message. */
4447 static int this_is_linker_script
;
4449 /* Nonzero means that the input of this command is coming from a pipe. */
4450 static int input_from_pipe
;
4452 /* Nonnull means substitute this for any suffix when outputting a switches
4454 static const char *suffix_subst
;
4456 /* If there is an argument being accumulated, terminate it and store it. */
4459 end_going_arg (void)
4465 obstack_1grow (&obstack
, 0);
4466 string
= XOBFINISH (&obstack
, const char *);
4467 if (this_is_library_file
)
4468 string
= find_file (string
);
4469 if (this_is_linker_script
)
4471 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4473 if (full_script_path
== NULL
)
4475 error ("unable to locate default linker script %qs in the library search paths", string
);
4476 /* Script was not found on search path. */
4479 store_arg ("--script", false, false);
4480 string
= full_script_path
;
4482 store_arg (string
, delete_this_arg
, this_is_output_file
);
4483 if (this_is_output_file
)
4484 outfiles
[input_file_number
] = string
;
4490 /* Parse the WRAPPER string which is a comma separated list of the command line
4491 and insert them into the beginning of argbuf. */
4494 insert_wrapper (const char *wrapper
)
4498 char *buf
= xstrdup (wrapper
);
4507 while ((p
= strchr (p
, ',')) != NULL
);
4509 if (argbuf_index
+ n
>= argbuf_length
)
4511 argbuf_length
= argbuf_length
* 2;
4512 while (argbuf_length
< argbuf_index
+ n
)
4514 argbuf
= XRESIZEVEC (const char *, argbuf
, argbuf_length
);
4516 for (i
= argbuf_index
- 1; i
>= 0; i
--)
4517 argbuf
[i
+ n
] = argbuf
[i
];
4530 while ((p
= strchr (p
, ',')) != NULL
);
4531 gcc_assert (i
== n
);
4535 /* Process the spec SPEC and run the commands specified therein.
4536 Returns 0 if the spec is successfully processed; -1 if failed. */
4539 do_spec (const char *spec
)
4543 value
= do_spec_2 (spec
);
4545 /* Force out any unfinished command.
4546 If -pipe, this forces out the last command if it ended in `|'. */
4549 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4552 set_collect_gcc_options ();
4554 if (argbuf_index
> 0)
4562 do_spec_2 (const char *spec
)
4568 delete_this_arg
= 0;
4569 this_is_output_file
= 0;
4570 this_is_library_file
= 0;
4571 this_is_linker_script
= 0;
4572 input_from_pipe
= 0;
4573 suffix_subst
= NULL
;
4575 result
= do_spec_1 (spec
, 0, NULL
);
4583 /* Process the given spec string and add any new options to the end
4584 of the switches/n_switches array. */
4587 do_option_spec (const char *name
, const char *spec
)
4589 unsigned int i
, value_count
, value_len
;
4590 const char *p
, *q
, *value
;
4591 char *tmp_spec
, *tmp_spec_p
;
4593 if (configure_default_options
[0].name
== NULL
)
4596 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4597 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4599 if (i
== ARRAY_SIZE (configure_default_options
))
4602 value
= configure_default_options
[i
].value
;
4603 value_len
= strlen (value
);
4605 /* Compute the size of the final spec. */
4608 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4614 /* Replace each %(VALUE) by the specified value. */
4615 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4616 + value_count
* (value_len
- strlen ("%(VALUE)")));
4617 tmp_spec_p
= tmp_spec
;
4619 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4621 memcpy (tmp_spec_p
, q
, p
- q
);
4622 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4623 memcpy (tmp_spec_p
, value
, value_len
);
4624 tmp_spec_p
+= value_len
;
4625 q
= p
+ strlen ("%(VALUE)");
4627 strcpy (tmp_spec_p
, q
);
4629 do_self_spec (tmp_spec
);
4632 /* Process the given spec string and add any new options to the end
4633 of the switches/n_switches array. */
4636 do_self_spec (const char *spec
)
4641 do_spec_1 (" ", 0, NULL
);
4643 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4644 do_self_specs adds the replacements to switches array, so it shouldn't
4645 be processed afterwards. */
4646 for (i
= 0; i
< n_switches
; i
++)
4647 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4648 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4650 if (argbuf_index
> 0)
4652 switches
= XRESIZEVEC (struct switchstr
, switches
,
4653 n_switches
+ argbuf_index
+ 1);
4655 for (i
= 0; i
< argbuf_index
; i
++)
4657 struct switchstr
*sw
;
4658 const char *p
= argbuf
[i
];
4661 /* Each switch should start with '-'. */
4663 fatal_error ("switch %qs does not start with %<-%>", argbuf
[i
]);
4668 sw
= &switches
[n_switches
++];
4674 /* Deal with option arguments in separate argv elements. */
4675 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4676 || WORD_SWITCH_TAKES_ARG (p
))
4679 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4683 /* Count only the option arguments in separate argv elements. */
4684 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4686 if (i
+ n_args
>= argbuf_index
)
4687 fatal_error ("argument to %<-%s%> is missing", p
);
4689 = XNEWVEC (const char *, n_args
+ 1);
4691 sw
->args
[j
++] = argbuf
[++i
];
4692 /* Null-terminate the vector. */
4697 /* On some systems, ld cannot handle "-o" without
4698 a space. So split the option from its argument. */
4699 char *part1
= XNEWVEC (char, 2);
4704 sw
->args
= XNEWVEC (const char *, 2);
4705 sw
->args
[0] = xstrdup (p
+1);
4712 switches
[n_switches
].part1
= 0;
4716 /* Callback for processing %D and %I specs. */
4718 struct spec_path_info
{
4723 bool separate_options
;
4727 spec_path (char *path
, void *data
)
4729 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4733 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4736 if (info
->append_len
!= 0)
4738 len
= strlen (path
);
4739 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4742 if (!is_directory (path
, true))
4745 do_spec_1 (info
->option
, 1, NULL
);
4746 if (info
->separate_options
)
4747 do_spec_1 (" ", 0, NULL
);
4749 if (info
->append_len
== 0)
4751 len
= strlen (path
);
4752 save
= path
[len
- 1];
4753 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4754 path
[len
- 1] = '\0';
4757 do_spec_1 (path
, 1, NULL
);
4758 do_spec_1 (" ", 0, NULL
);
4760 /* Must not damage the original path. */
4761 if (info
->append_len
== 0)
4762 path
[len
- 1] = save
;
4767 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4771 create_at_file (char **argv
)
4773 char *temp_file
= make_temp_file ("");
4774 char *at_argument
= concat ("@", temp_file
, NULL
);
4775 FILE *f
= fopen (temp_file
, "w");
4779 fatal_error ("could not open temporary response file %s",
4782 status
= writeargv (argv
, f
);
4785 fatal_error ("could not write to temporary response file %s",
4788 status
= fclose (f
);
4791 fatal_error ("could not close temporary response file %s",
4794 store_arg (at_argument
, 0, 0);
4796 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4799 /* True if we should compile INFILE. */
4802 compile_input_file_p (struct infile
*infile
)
4804 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4805 if (infile
->incompiler
== input_file_compiler
)
4810 /* Process the sub-spec SPEC as a portion of a larger spec.
4811 This is like processing a whole spec except that we do
4812 not initialize at the beginning and we do not supply a
4813 newline by default at the end.
4814 INSWITCH nonzero means don't process %-sequences in SPEC;
4815 in this case, % is treated as an ordinary character.
4816 This is used while substituting switches.
4817 INSWITCH nonzero also causes SPC not to terminate an argument.
4819 Value is zero unless a line was finished
4820 and the command on that line reported an error. */
4823 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4825 const char *p
= spec
;
4831 /* If substituting a switch, treat all chars like letters.
4832 Otherwise, NL, SPC, TAB and % are special. */
4833 switch (inswitch
? 'a' : c
)
4838 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4840 /* A `|' before the newline means use a pipe here,
4841 but only if -pipe was specified.
4842 Otherwise, execute now and don't pass the `|' as an arg. */
4845 input_from_pipe
= 1;
4852 set_collect_gcc_options ();
4854 if (argbuf_index
> 0)
4860 /* Reinitialize for a new command, and for a new argument. */
4863 delete_this_arg
= 0;
4864 this_is_output_file
= 0;
4865 this_is_library_file
= 0;
4866 this_is_linker_script
= 0;
4867 input_from_pipe
= 0;
4874 obstack_1grow (&obstack
, c
);
4882 /* Reinitialize for a new argument. */
4883 delete_this_arg
= 0;
4884 this_is_output_file
= 0;
4885 this_is_library_file
= 0;
4886 this_is_linker_script
= 0;
4893 fatal_error ("spec %qs invalid", spec
);
4896 if (save_temps_length
)
4897 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4899 obstack_grow (&obstack
, input_basename
, basename_length
);
4900 if (compare_debug
< 0)
4901 obstack_grow (&obstack
, ".gk", 3);
4906 if (save_temps_length
)
4907 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4909 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4910 if (compare_debug
< 0)
4911 obstack_grow (&obstack
, ".gk", 3);
4916 delete_this_arg
= 2;
4919 /* Dump out the directories specified with LIBRARY_PATH,
4920 followed by the absolute directories
4921 that we search for startfiles. */
4924 struct spec_path_info info
;
4927 info
.append_len
= 0;
4928 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4929 /* Used on systems which record the specified -L dirs
4930 and use them to search for dynamic linking.
4931 Relative directories always come from -B,
4932 and it is better not to use them for searching
4933 at run time. In particular, stage1 loses. */
4934 info
.omit_relative
= true;
4936 info
.omit_relative
= false;
4938 info
.separate_options
= false;
4940 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4945 /* %efoo means report an error with `foo' as error message
4946 and don't execute any more commands for this file. */
4950 while (*p
!= 0 && *p
!= '\n')
4952 buf
= (char *) alloca (p
- q
+ 1);
4953 strncpy (buf
, q
, p
- q
);
4955 error ("%s", _(buf
));
4960 /* %nfoo means report a notice with `foo' on stderr. */
4964 while (*p
!= 0 && *p
!= '\n')
4966 buf
= (char *) alloca (p
- q
+ 1);
4967 strncpy (buf
, q
, p
- q
);
4969 inform (0, "%s", _(buf
));
4979 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4980 defined, and it is not a directory, and it is
4981 writable, use it. Otherwise, treat this like any
4982 other temporary file. */
4984 if ((!save_temps_flag
)
4985 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4986 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4988 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4989 strlen (HOST_BIT_BUCKET
));
4990 delete_this_arg
= 0;
4995 goto create_temp_file
;
4999 obstack_1grow (&obstack
, '-');
5000 delete_this_arg
= 0;
5003 /* consume suffix */
5004 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5006 if (p
[0] == '%' && p
[1] == 'O')
5011 goto create_temp_file
;
5015 /* consume suffix */
5016 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5018 if (p
[0] == '%' && p
[1] == 'O')
5023 goto create_temp_file
;
5029 struct temp_name
*t
;
5031 const char *suffix
= p
;
5032 char *saved_suffix
= NULL
;
5034 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5036 suffix_length
= p
- suffix
;
5037 if (p
[0] == '%' && p
[1] == 'O')
5040 /* We don't support extra suffix characters after %O. */
5041 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5042 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
5043 if (suffix_length
== 0)
5044 suffix
= TARGET_OBJECT_SUFFIX
;
5048 = XNEWVEC (char, suffix_length
5049 + strlen (TARGET_OBJECT_SUFFIX
));
5050 strncpy (saved_suffix
, suffix
, suffix_length
);
5051 strcpy (saved_suffix
+ suffix_length
,
5052 TARGET_OBJECT_SUFFIX
);
5054 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5057 if (compare_debug
< 0)
5059 suffix
= concat (".gk", suffix
, NULL
);
5063 /* If -save-temps=obj and -o were specified, use that for the
5065 if (save_temps_length
)
5068 temp_filename_length
5069 = save_temps_length
+ suffix_length
+ 1;
5070 tmp
= (char *) alloca (temp_filename_length
);
5071 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5072 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5073 tmp
[save_temps_length
+ suffix_length
] = '\0';
5074 temp_filename
= save_string (tmp
,
5075 temp_filename_length
+ 1);
5076 obstack_grow (&obstack
, temp_filename
,
5077 temp_filename_length
);
5079 delete_this_arg
= 0;
5083 /* If the gcc_input_filename has the same suffix specified
5084 for the %g, %u, or %U, and -save-temps is specified,
5085 we could end up using that file as an intermediate
5086 thus clobbering the user's source file (.e.g.,
5087 gcc -save-temps foo.s would clobber foo.s with the
5088 output of cpp0). So check for this condition and
5089 generate a temp file as the intermediate. */
5091 if (save_temps_flag
)
5094 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5095 tmp
= (char *) alloca (temp_filename_length
);
5096 memcpy (tmp
, input_basename
, basename_length
);
5097 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5098 tmp
[basename_length
+ suffix_length
] = '\0';
5099 temp_filename
= tmp
;
5101 if (strcmp (temp_filename
, gcc_input_filename
) != 0)
5103 #ifndef HOST_LACKS_INODE_NUMBERS
5104 struct stat st_temp
;
5106 /* Note, set_input() resets input_stat_set to 0. */
5107 if (input_stat_set
== 0)
5109 input_stat_set
= stat (gcc_input_filename
,
5111 if (input_stat_set
>= 0)
5115 /* If we have the stat for the gcc_input_filename
5116 and we can do the stat for the temp_filename
5117 then the they could still refer to the same
5118 file if st_dev/st_ino's are the same. */
5119 if (input_stat_set
!= 1
5120 || stat (temp_filename
, &st_temp
) < 0
5121 || input_stat
.st_dev
!= st_temp
.st_dev
5122 || input_stat
.st_ino
!= st_temp
.st_ino
)
5124 /* Just compare canonical pathnames. */
5125 char* input_realname
= lrealpath (gcc_input_filename
);
5126 char* temp_realname
= lrealpath (temp_filename
);
5127 bool files_differ
= strcmp (input_realname
, temp_realname
);
5128 free (input_realname
);
5129 free (temp_realname
);
5133 temp_filename
= save_string (temp_filename
,
5134 temp_filename_length
+ 1);
5135 obstack_grow (&obstack
, temp_filename
,
5136 temp_filename_length
);
5138 delete_this_arg
= 0;
5144 /* See if we already have an association of %g/%u/%U and
5146 for (t
= temp_names
; t
; t
= t
->next
)
5147 if (t
->length
== suffix_length
5148 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5149 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5152 /* Make a new association if needed. %u and %j
5154 if (t
== 0 || c
== 'u' || c
== 'j')
5158 t
= XNEW (struct temp_name
);
5159 t
->next
= temp_names
;
5162 t
->length
= suffix_length
;
5165 t
->suffix
= saved_suffix
;
5166 saved_suffix
= NULL
;
5169 t
->suffix
= save_string (suffix
, suffix_length
);
5170 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5171 temp_filename
= make_temp_file (t
->suffix
);
5172 temp_filename_length
= strlen (temp_filename
);
5173 t
->filename
= temp_filename
;
5174 t
->filename_length
= temp_filename_length
;
5178 free (saved_suffix
);
5180 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5181 delete_this_arg
= 1;
5189 if (at_file_supplied
)
5191 /* We are going to expand `%i' to `@FILE', where FILE
5192 is a newly-created temporary filename. The filenames
5193 that would usually be expanded in place of %o will be
5194 written to the temporary file. */
5199 for (i
= 0; i
< n_infiles
; i
++)
5200 if (compile_input_file_p (&infiles
[i
]))
5203 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5205 /* Copy the strings over. */
5206 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5207 if (compile_input_file_p (&infiles
[i
]))
5209 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5210 infiles
[i
].compiled
= true;
5215 create_at_file (argv
);
5218 for (i
= 0; (int) i
< n_infiles
; i
++)
5219 if (compile_input_file_p (&infiles
[i
]))
5221 store_arg (infiles
[i
].name
, 0, 0);
5222 infiles
[i
].compiled
= true;
5227 obstack_grow (&obstack
, gcc_input_filename
,
5228 input_filename_length
);
5235 struct spec_path_info info
;
5239 do_spec_1 ("-imultilib", 1, NULL
);
5240 /* Make this a separate argument. */
5241 do_spec_1 (" ", 0, NULL
);
5242 do_spec_1 (multilib_dir
, 1, NULL
);
5243 do_spec_1 (" ", 0, NULL
);
5246 if (gcc_exec_prefix
)
5248 do_spec_1 ("-iprefix", 1, NULL
);
5249 /* Make this a separate argument. */
5250 do_spec_1 (" ", 0, NULL
);
5251 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5252 do_spec_1 (" ", 0, NULL
);
5255 if (target_system_root_changed
||
5256 (target_system_root
&& target_sysroot_hdrs_suffix
))
5258 do_spec_1 ("-isysroot", 1, NULL
);
5259 /* Make this a separate argument. */
5260 do_spec_1 (" ", 0, NULL
);
5261 do_spec_1 (target_system_root
, 1, NULL
);
5262 if (target_sysroot_hdrs_suffix
)
5263 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5264 do_spec_1 (" ", 0, NULL
);
5267 info
.option
= "-isystem";
5268 info
.append
= "include";
5269 info
.append_len
= strlen (info
.append
);
5270 info
.omit_relative
= false;
5271 info
.separate_options
= true;
5273 for_each_path (&include_prefixes
, false, info
.append_len
,
5276 info
.append
= "include-fixed";
5277 if (*sysroot_hdrs_suffix_spec
)
5278 info
.append
= concat (info
.append
, dir_separator_str
,
5279 multilib_dir
, NULL
);
5280 info
.append_len
= strlen (info
.append
);
5281 for_each_path (&include_prefixes
, false, info
.append_len
,
5288 int max
= n_infiles
;
5289 max
+= lang_specific_extra_outfiles
;
5291 if (HAVE_GNU_LD
&& at_file_supplied
)
5293 /* We are going to expand `%o' to `@FILE', where FILE
5294 is a newly-created temporary filename. The filenames
5295 that would usually be expanded in place of %o will be
5296 written to the temporary file. */
5301 /* Convert OUTFILES into a form suitable for writeargv. */
5303 /* Determine how many are non-NULL. */
5304 for (n_files
= 0, i
= 0; i
< max
; i
++)
5305 n_files
+= outfiles
[i
] != NULL
;
5307 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5309 /* Copy the strings over. */
5310 for (i
= 0, j
= 0; i
< max
; i
++)
5313 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5318 create_at_file (argv
);
5321 for (i
= 0; i
< max
; i
++)
5323 store_arg (outfiles
[i
], 0, 0);
5328 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5333 this_is_library_file
= 1;
5337 this_is_linker_script
= 1;
5341 outfiles
[input_file_number
] = NULL
;
5345 this_is_output_file
= 1;
5350 int cur_index
= argbuf_index
;
5351 /* Handle the {...} following the %W. */
5353 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5354 p
= handle_braces (p
+ 1);
5358 /* If any args were output, mark the last one for deletion
5360 if (argbuf_index
!= cur_index
)
5361 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
5365 /* %x{OPTION} records OPTION for %X to output. */
5371 /* Skip past the option value and make a copy. */
5373 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5376 string
= save_string (p1
+ 1, p
- p1
- 2);
5378 /* See if we already recorded this option. */
5379 for (i
= 0; i
< n_linker_options
; i
++)
5380 if (! strcmp (string
, linker_options
[i
]))
5386 /* This option is new; add it. */
5387 add_linker_option (string
, strlen (string
));
5391 /* Dump out the options accumulated previously using %x. */
5393 for (i
= 0; i
< n_linker_options
; i
++)
5395 do_spec_1 (linker_options
[i
], 1, NULL
);
5396 /* Make each accumulated option a separate argument. */
5397 do_spec_1 (" ", 0, NULL
);
5401 /* Dump out the options accumulated previously using -Wa,. */
5403 for (i
= 0; i
< n_assembler_options
; i
++)
5405 do_spec_1 (assembler_options
[i
], 1, NULL
);
5406 /* Make each accumulated option a separate argument. */
5407 do_spec_1 (" ", 0, NULL
);
5411 /* Dump out the options accumulated previously using -Wp,. */
5413 for (i
= 0; i
< n_preprocessor_options
; i
++)
5415 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5416 /* Make each accumulated option a separate argument. */
5417 do_spec_1 (" ", 0, NULL
);
5421 /* Here are digits and numbers that just process
5422 a certain constant string as a spec. */
5425 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5431 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5437 value
= do_spec_1 (asm_spec
, 0, NULL
);
5443 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5450 const char *const spec
5451 = (input_file_compiler
->cpp_spec
5452 ? input_file_compiler
->cpp_spec
5454 value
= do_spec_1 (spec
, 0, NULL
);
5461 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5467 value
= do_spec_1 (link_spec
, 0, NULL
);
5473 value
= do_spec_1 (lib_spec
, 0, NULL
);
5479 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5485 /* We assume there is a directory
5486 separator at the end of this string. */
5487 if (target_system_root
)
5489 obstack_grow (&obstack
, target_system_root
,
5490 strlen (target_system_root
));
5491 if (target_sysroot_suffix
)
5492 obstack_grow (&obstack
, target_sysroot_suffix
,
5493 strlen (target_sysroot_suffix
));
5498 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5503 /* Here we define characters other than letters and digits. */
5506 p
= handle_braces (p
);
5512 p
= handle_spec_function (p
);
5518 obstack_1grow (&obstack
, '%');
5525 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5527 suffix_subst
= save_string (p
- 1, len
+ 1);
5532 /* Henceforth ignore the option(s) matching the pattern
5537 int have_wildcard
= 0;
5540 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5543 if (p
[len
-1] == '*')
5546 for (i
= 0; i
< n_switches
; i
++)
5547 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5548 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5550 switches
[i
].live_cond
|= SWITCH_IGNORE
;
5551 switches
[i
].validated
= 1;
5559 if (soft_matched_part
)
5561 do_spec_1 (soft_matched_part
, 1, NULL
);
5562 do_spec_1 (" ", 0, NULL
);
5565 /* Catch the case where a spec string contains something like
5566 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5567 hand side of the :. */
5568 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5571 /* Process a string found as the value of a spec given by name.
5572 This feature allows individual machine descriptions
5573 to add and use their own specs.
5574 %[...] modifies -D options the way %P does;
5575 %(...) uses the spec unmodified. */
5577 warning (0, "use of obsolete %%[ operator in specs");
5580 const char *name
= p
;
5581 struct spec_list
*sl
;
5584 /* The string after the S/P is the name of a spec that is to be
5586 while (*p
&& *p
!= ')' && *p
!= ']')
5589 /* See if it's in the list. */
5590 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5591 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5593 name
= *(sl
->ptr_spec
);
5595 fnotice (stderr
, "Processing spec %c%s%c, which is '%s'\n",
5596 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5605 value
= do_spec_1 (name
, 0, NULL
);
5611 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5613 const char *y
= name
;
5616 /* Copy all of NAME into BUF, but put __ after
5617 every -D and at the end of each arg. */
5620 if (! strncmp (y
, "-D", 2))
5631 && (*y
== ' ' || *y
== '\t' || *y
== '='
5632 || *y
== '}' || *y
== 0))
5645 value
= do_spec_1 (buf
, 0, NULL
);
5651 /* Discard the closing paren or bracket. */
5658 error ("spec failure: unrecognized spec option %qc", c
);
5664 /* Backslash: treat next character as ordinary. */
5669 /* Ordinary character: put it into the current argument. */
5670 obstack_1grow (&obstack
, c
);
5674 /* End of string. If we are processing a spec function, we need to
5675 end any pending argument. */
5676 if (processing_spec_function
)
5682 /* Look up a spec function. */
5684 static const struct spec_function
*
5685 lookup_spec_function (const char *name
)
5687 const struct spec_function
*sf
;
5689 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5690 if (strcmp (sf
->name
, name
) == 0)
5696 /* Evaluate a spec function. */
5699 eval_spec_function (const char *func
, const char *args
)
5701 const struct spec_function
*sf
;
5702 const char *funcval
;
5704 /* Saved spec processing context. */
5705 int save_argbuf_index
;
5706 int save_argbuf_length
;
5707 const char **save_argbuf
;
5710 int save_delete_this_arg
;
5711 int save_this_is_output_file
;
5712 int save_this_is_library_file
;
5713 int save_input_from_pipe
;
5714 int save_this_is_linker_script
;
5715 const char *save_suffix_subst
;
5718 sf
= lookup_spec_function (func
);
5720 fatal_error ("unknown spec function %qs", func
);
5722 /* Push the spec processing context. */
5723 save_argbuf_index
= argbuf_index
;
5724 save_argbuf_length
= argbuf_length
;
5725 save_argbuf
= argbuf
;
5727 save_arg_going
= arg_going
;
5728 save_delete_this_arg
= delete_this_arg
;
5729 save_this_is_output_file
= this_is_output_file
;
5730 save_this_is_library_file
= this_is_library_file
;
5731 save_this_is_linker_script
= this_is_linker_script
;
5732 save_input_from_pipe
= input_from_pipe
;
5733 save_suffix_subst
= suffix_subst
;
5735 /* Create a new spec processing context, and build the function
5739 if (do_spec_2 (args
) < 0)
5740 fatal_error ("error in args to spec function %qs", func
);
5742 /* argbuf_index is an index for the next argument to be inserted, and
5743 so contains the count of the args already inserted. */
5745 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5747 /* Pop the spec processing context. */
5748 argbuf_index
= save_argbuf_index
;
5749 argbuf_length
= save_argbuf_length
;
5751 argbuf
= save_argbuf
;
5753 arg_going
= save_arg_going
;
5754 delete_this_arg
= save_delete_this_arg
;
5755 this_is_output_file
= save_this_is_output_file
;
5756 this_is_library_file
= save_this_is_library_file
;
5757 this_is_linker_script
= save_this_is_linker_script
;
5758 input_from_pipe
= save_input_from_pipe
;
5759 suffix_subst
= save_suffix_subst
;
5764 /* Handle a spec function call of the form:
5768 ARGS is processed as a spec in a separate context and split into an
5769 argument vector in the normal fashion. The function returns a string
5770 containing a spec which we then process in the caller's context, or
5771 NULL if no processing is required. */
5774 handle_spec_function (const char *p
)
5777 const char *endp
, *funcval
;
5780 processing_spec_function
++;
5782 /* Get the function name. */
5783 for (endp
= p
; *endp
!= '\0'; endp
++)
5785 if (*endp
== '(') /* ) */
5787 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5788 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5789 fatal_error ("malformed spec function name");
5791 if (*endp
!= '(') /* ) */
5792 fatal_error ("no arguments for spec function");
5793 func
= save_string (p
, endp
- p
);
5796 /* Get the arguments. */
5797 for (count
= 0; *endp
!= '\0'; endp
++)
5806 else if (*endp
== '(') /* ) */
5811 fatal_error ("malformed spec function arguments");
5812 args
= save_string (p
, endp
- p
);
5815 /* p now points to just past the end of the spec function expression. */
5817 funcval
= eval_spec_function (func
, args
);
5818 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5824 processing_spec_function
--;
5829 /* Inline subroutine of handle_braces. Returns true if the current
5830 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5832 input_suffix_matches (const char *atom
, const char *end_atom
)
5834 return (input_suffix
5835 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5836 && input_suffix
[end_atom
- atom
] == '\0');
5839 /* Subroutine of handle_braces. Returns true if the current
5840 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5842 input_spec_matches (const char *atom
, const char *end_atom
)
5844 return (input_file_compiler
5845 && input_file_compiler
->suffix
5846 && input_file_compiler
->suffix
[0] != '\0'
5847 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5849 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5852 /* Subroutine of handle_braces. Returns true if a switch
5853 matching the atom bracketed by ATOM and END_ATOM appeared on the
5856 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5859 int len
= end_atom
- atom
;
5860 int plen
= starred
? len
: -1;
5862 for (i
= 0; i
< n_switches
; i
++)
5863 if (!strncmp (switches
[i
].part1
, atom
, len
)
5864 && (starred
|| switches
[i
].part1
[len
] == '\0')
5865 && check_live_switch (i
, plen
))
5871 /* Inline subroutine of handle_braces. Mark all of the switches which
5872 match ATOM (extends to END_ATOM; STARRED indicates whether there
5873 was a star after the atom) for later processing. */
5875 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5878 int len
= end_atom
- atom
;
5879 int plen
= starred
? len
: -1;
5881 for (i
= 0; i
< n_switches
; i
++)
5882 if (!strncmp (switches
[i
].part1
, atom
, len
)
5883 && (starred
|| switches
[i
].part1
[len
] == '\0')
5884 && check_live_switch (i
, plen
))
5885 switches
[i
].ordering
= 1;
5888 /* Inline subroutine of handle_braces. Process all the currently
5889 marked switches through give_switch, and clear the marks. */
5891 process_marked_switches (void)
5895 for (i
= 0; i
< n_switches
; i
++)
5896 if (switches
[i
].ordering
== 1)
5898 switches
[i
].ordering
= 0;
5903 /* Handle a %{ ... } construct. P points just inside the leading {.
5904 Returns a pointer one past the end of the brace block, or 0
5905 if we call do_spec_1 and that returns -1. */
5908 handle_braces (const char *p
)
5910 const char *atom
, *end_atom
;
5911 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5912 const char *orig
= p
;
5920 bool a_must_be_last
= false;
5921 bool ordered_set
= false;
5922 bool disjunct_set
= false;
5923 bool disj_matched
= false;
5924 bool disj_starred
= true;
5925 bool n_way_choice
= false;
5926 bool n_way_matched
= false;
5928 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5935 /* Scan one "atom" (S in the description above of %{}, possibly
5936 with '!', '.', '@', ',', or '*' modifiers). */
5938 a_is_suffix
= false;
5939 a_is_starred
= false;
5940 a_is_negated
= false;
5941 a_is_spectype
= false;
5945 p
++, a_is_negated
= true;
5949 p
++, a_is_suffix
= true;
5951 p
++, a_is_spectype
= true;
5954 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5955 || *p
== ',' || *p
== '.' || *p
== '@')
5960 p
++, a_is_starred
= 1;
5966 /* Substitute the switch(es) indicated by the current atom. */
5968 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5969 || a_is_spectype
|| atom
== end_atom
)
5972 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5975 process_marked_switches ();
5979 /* Substitute some text if the current atom appears as a switch
5981 disjunct_set
= true;
5985 if (atom
== end_atom
)
5987 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5988 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5992 /* An empty term may appear as the last choice of an
5993 N-way choice set; it means "otherwise". */
5994 a_must_be_last
= true;
5995 disj_matched
= !n_way_matched
;
5996 disj_starred
= false;
6000 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6004 disj_starred
= false;
6006 /* Don't bother testing this atom if we already have a
6008 if (!disj_matched
&& !n_way_matched
)
6011 a_matched
= input_suffix_matches (atom
, end_atom
);
6012 else if (a_is_spectype
)
6013 a_matched
= input_spec_matches (atom
, end_atom
);
6015 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6017 if (a_matched
!= a_is_negated
)
6019 disj_matched
= true;
6021 d_end_atom
= end_atom
;
6028 /* Found the body, that is, the text to substitute if the
6029 current disjunction matches. */
6030 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6031 disj_matched
&& !n_way_matched
);
6035 /* If we have an N-way choice, reset state for the next
6039 n_way_choice
= true;
6040 n_way_matched
|= disj_matched
;
6041 disj_matched
= false;
6042 disj_starred
= true;
6043 d_atom
= d_end_atom
= NULL
;
6052 while (*p
++ != '}');
6057 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
6062 /* Subroutine of handle_braces. Scan and process a brace substitution body
6063 (X in the description of %{} syntax). P points one past the colon;
6064 ATOM and END_ATOM bracket the first atom which was found to be true
6065 (present) in the current disjunction; STARRED indicates whether all
6066 the atoms in the current disjunction were starred (for syntax validation);
6067 MATCHED indicates whether the disjunction matched or not, and therefore
6068 whether or not the body is to be processed through do_spec_1 or just
6069 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6073 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6074 int starred
, int matched
)
6076 const char *body
, *end_body
;
6077 unsigned int nesting_level
;
6078 bool have_subst
= false;
6080 /* Locate the closing } or ;, honoring nested braces.
6081 Trim trailing whitespace. */
6090 if (!--nesting_level
)
6093 else if (*p
== ';' && nesting_level
== 1)
6095 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6097 else if (*p
== '\0')
6103 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6106 if (have_subst
&& !starred
)
6111 /* Copy the substitution body to permanent storage and execute it.
6112 If have_subst is false, this is a simple matter of running the
6113 body through do_spec_1... */
6114 char *string
= save_string (body
, end_body
- body
);
6117 if (do_spec_1 (string
, 0, NULL
) < 0)
6122 /* ... but if have_subst is true, we have to process the
6123 body once for each matching switch, with %* set to the
6124 variant part of the switch. */
6125 unsigned int hard_match_len
= end_atom
- atom
;
6128 for (i
= 0; i
< n_switches
; i
++)
6129 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6130 && check_live_switch (i
, hard_match_len
))
6132 if (do_spec_1 (string
, 0,
6133 &switches
[i
].part1
[hard_match_len
]) < 0)
6135 /* Pass any arguments this switch has. */
6137 suffix_subst
= NULL
;
6145 fatal_error ("braced spec body %qs is invalid", body
);
6148 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6149 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6150 spec, or -1 if either exact match or %* is used.
6152 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
6153 whose value does not begin with "no-" is obsoleted by the same value
6154 with the "no-", similarly for a switch with the "no-" prefix. */
6157 check_live_switch (int switchnum
, int prefix_length
)
6159 const char *name
= switches
[switchnum
].part1
;
6162 /* If we already processed this switch and determined if it was
6163 live or not, return our past determination. */
6164 if (switches
[switchnum
].live_cond
!= 0)
6165 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6166 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6167 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6170 /* In the common case of {<at-most-one-letter>*}, a negating
6171 switch would always match, so ignore that case. We will just
6172 send the conflicting switches to the compiler phase. */
6173 if (prefix_length
>= 0 && prefix_length
<= 1)
6176 /* Now search for duplicate in a manner that depends on the name. */
6180 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6181 if (switches
[i
].part1
[0] == 'O')
6183 switches
[switchnum
].validated
= 1;
6184 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6189 case 'W': case 'f': case 'm':
6190 if (! strncmp (name
+ 1, "no-", 3))
6192 /* We have Xno-YYY, search for XYYY. */
6193 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6194 if (switches
[i
].part1
[0] == name
[0]
6195 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6197 switches
[switchnum
].validated
= 1;
6198 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6204 /* We have XYYY, search for Xno-YYY. */
6205 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6206 if (switches
[i
].part1
[0] == name
[0]
6207 && switches
[i
].part1
[1] == 'n'
6208 && switches
[i
].part1
[2] == 'o'
6209 && switches
[i
].part1
[3] == '-'
6210 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6212 switches
[switchnum
].validated
= 1;
6213 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6220 /* Otherwise the switch is live. */
6221 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6225 /* Pass a switch to the current accumulating command
6226 in the same form that we received it.
6227 SWITCHNUM identifies the switch; it is an index into
6228 the vector of switches gcc received, which is `switches'.
6229 This cannot fail since it never finishes a command line.
6231 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6234 give_switch (int switchnum
, int omit_first_word
)
6236 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6239 if (!omit_first_word
)
6241 do_spec_1 ("-", 0, NULL
);
6242 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6245 if (switches
[switchnum
].args
!= 0)
6248 for (p
= switches
[switchnum
].args
; *p
; p
++)
6250 const char *arg
= *p
;
6252 do_spec_1 (" ", 0, NULL
);
6255 unsigned length
= strlen (arg
);
6258 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6259 if (arg
[length
] == '.')
6261 (CONST_CAST(char *, arg
))[length
] = 0;
6265 do_spec_1 (arg
, 1, NULL
);
6267 (CONST_CAST(char *, arg
))[length
] = '.';
6268 do_spec_1 (suffix_subst
, 1, NULL
);
6271 do_spec_1 (arg
, 1, NULL
);
6275 do_spec_1 (" ", 0, NULL
);
6276 switches
[switchnum
].validated
= 1;
6279 /* Search for a file named NAME trying various prefixes including the
6280 user's -B prefix and some standard ones.
6281 Return the absolute file name found. If nothing is found, return NAME. */
6284 find_file (const char *name
)
6286 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6287 return newname
? newname
: name
;
6290 /* Determine whether a directory exists. If LINKER, return 0 for
6291 certain fixed names not needed by the linker. */
6294 is_directory (const char *path1
, bool linker
)
6301 /* Ensure the string ends with "/.". The resulting path will be a
6302 directory even if the given path is a symbolic link. */
6303 len1
= strlen (path1
);
6304 path
= (char *) alloca (3 + len1
);
6305 memcpy (path
, path1
, len1
);
6307 if (!IS_DIR_SEPARATOR (cp
[-1]))
6308 *cp
++ = DIR_SEPARATOR
;
6312 /* Exclude directories that the linker is known to search. */
6314 && IS_DIR_SEPARATOR (path
[0])
6316 && strncmp (path
+ 1, "lib", 3) == 0)
6318 && strncmp (path
+ 1, "usr", 3) == 0
6319 && IS_DIR_SEPARATOR (path
[4])
6320 && strncmp (path
+ 5, "lib", 3) == 0)))
6323 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6326 /* Set up the various global variables to indicate that we're processing
6327 the input file named FILENAME. */
6330 set_input (const char *filename
)
6334 gcc_input_filename
= filename
;
6335 input_filename_length
= strlen (gcc_input_filename
);
6336 input_basename
= lbasename (gcc_input_filename
);
6338 /* Find a suffix starting with the last period,
6339 and set basename_length to exclude that suffix. */
6340 basename_length
= strlen (input_basename
);
6341 suffixed_basename_length
= basename_length
;
6342 p
= input_basename
+ basename_length
;
6343 while (p
!= input_basename
&& *p
!= '.')
6345 if (*p
== '.' && p
!= input_basename
)
6347 basename_length
= p
- input_basename
;
6348 input_suffix
= p
+ 1;
6353 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6354 we will need to do a stat on the gcc_input_filename. The
6355 INPUT_STAT_SET signals that the stat is needed. */
6359 /* On fatal signals, delete all the temporary files. */
6362 fatal_signal (int signum
)
6364 signal (signum
, SIG_DFL
);
6365 delete_failure_queue ();
6366 delete_temp_files ();
6367 /* Get the same signal again, this time not handled,
6368 so its normal effect occurs. */
6369 kill (getpid (), signum
);
6372 /* Compare the contents of the two files named CMPFILE[0] and
6373 CMPFILE[1]. Return zero if they're identical, nonzero
6377 compare_files (char *cmpfile
[])
6380 FILE *temp
[2] = { NULL
, NULL
};
6386 void *map
[2] = { NULL
, NULL
};
6388 for (i
= 0; i
< 2; i
++)
6392 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6394 error ("%s: could not determine length of compare-debug file %s",
6395 gcc_input_filename
, cmpfile
[i
]);
6400 length
[i
] = st
.st_size
;
6403 if (!ret
&& length
[0] != length
[1])
6405 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6410 for (i
= 0; i
< 2; i
++)
6412 int fd
= open (cmpfile
[i
], O_RDONLY
);
6415 error ("%s: could not open compare-debug file %s",
6416 gcc_input_filename
, cmpfile
[i
]);
6421 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6424 if (map
[i
] == (void *) MAP_FAILED
)
6433 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6435 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6440 for (i
= 0; i
< 2; i
++)
6442 munmap ((caddr_t
) map
[i
], length
[i
]);
6451 for (i
= 0; i
< 2; i
++)
6453 temp
[i
] = fopen (cmpfile
[i
], "r");
6456 error ("%s: could not open compare-debug file %s",
6457 gcc_input_filename
, cmpfile
[i
]);
6463 if (!ret
&& temp
[0] && temp
[1])
6467 c0
= fgetc (temp
[0]);
6468 c1
= fgetc (temp
[1]);
6472 error ("%s: -fcompare-debug failure",
6473 gcc_input_filename
);
6482 for (i
= 1; i
>= 0; i
--)
6491 extern int main (int, char **);
6494 main (int argc
, char **argv
)
6498 int linker_was_run
= 0;
6499 int lang_n_infiles
= 0;
6500 int num_linker_inputs
= 0;
6501 char *explicit_link_files
;
6504 struct user_specs
*uptr
;
6505 char **old_argv
= argv
;
6507 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6508 on ?: in file-scope variable initializations. */
6509 asm_debug
= ASM_DEBUG_SPEC
;
6511 p
= argv
[0] + strlen (argv
[0]);
6512 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6516 xmalloc_set_program_name (progname
);
6518 expandargv (&argc
, &argv
);
6520 /* Determine if any expansions were made. */
6521 if (argv
!= old_argv
)
6522 at_file_supplied
= true;
6524 prune_options (&argc
, &argv
);
6526 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6527 /* Perform host dependent initialization when needed. */
6528 GCC_DRIVER_HOST_INITIALIZATION
;
6531 /* Unlock the stdio streams. */
6532 unlock_std_streams ();
6534 gcc_init_libintl ();
6536 diagnostic_initialize (global_dc
, 0);
6537 if (atexit (delete_temp_files
) != 0)
6538 fatal_error ("atexit failed");
6540 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6541 signal (SIGINT
, fatal_signal
);
6543 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6544 signal (SIGHUP
, fatal_signal
);
6546 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6547 signal (SIGTERM
, fatal_signal
);
6549 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6550 signal (SIGPIPE
, fatal_signal
);
6553 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6554 receive the signal. A different setting is inheritable */
6555 signal (SIGCHLD
, SIG_DFL
);
6558 /* Allocate the argument vector. */
6561 obstack_init (&obstack
);
6563 /* Build multilib_select, et. al from the separate lines that make up each
6564 multilib selection. */
6566 const char *const *q
= multilib_raw
;
6569 obstack_init (&multilib_obstack
);
6570 while ((p
= *q
++) != (char *) 0)
6571 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6573 obstack_1grow (&multilib_obstack
, 0);
6574 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6576 q
= multilib_matches_raw
;
6577 while ((p
= *q
++) != (char *) 0)
6578 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6580 obstack_1grow (&multilib_obstack
, 0);
6581 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6583 q
= multilib_exclusions_raw
;
6584 while ((p
= *q
++) != (char *) 0)
6585 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6587 obstack_1grow (&multilib_obstack
, 0);
6588 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6591 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6594 obstack_1grow (&multilib_obstack
, ' ');
6595 obstack_grow (&multilib_obstack
,
6596 multilib_defaults_raw
[i
],
6597 strlen (multilib_defaults_raw
[i
]));
6601 obstack_1grow (&multilib_obstack
, 0);
6602 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6605 #ifdef INIT_ENVIRONMENT
6606 /* Set up any other necessary machine specific environment variables. */
6607 xputenv (INIT_ENVIRONMENT
);
6610 /* Make a table of what switches there are (switches, n_switches).
6611 Make a table of specified input files (infiles, n_infiles).
6612 Decode switches that are handled locally. */
6614 process_command (argc
, CONST_CAST2 (const char **, char **, argv
));
6616 /* Initialize the vector of specs to just the default.
6617 This means one element containing 0s, as a terminator. */
6619 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6620 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6621 n_compilers
= n_default_compilers
;
6623 /* Read specs from a file if there is one. */
6625 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6626 spec_version
, dir_separator_str
, NULL
);
6627 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6629 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6630 /* Read the specs file unless it is a default one. */
6631 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6632 read_specs (specs_file
, TRUE
);
6636 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6637 for any override of as, ld and libraries. */
6638 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6639 + strlen (just_machine_suffix
) + sizeof ("specs"));
6641 strcpy (specs_file
, standard_exec_prefix
);
6642 strcat (specs_file
, just_machine_suffix
);
6643 strcat (specs_file
, "specs");
6644 if (access (specs_file
, R_OK
) == 0)
6645 read_specs (specs_file
, TRUE
);
6647 /* Process any configure-time defaults specified for the command line
6648 options, via OPTION_DEFAULT_SPECS. */
6649 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6650 do_option_spec (option_default_specs
[i
].name
,
6651 option_default_specs
[i
].spec
);
6653 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6654 of the command line. */
6656 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6657 do_self_spec (driver_self_specs
[i
]);
6661 enum save_temps save
;
6663 if (!compare_debug_second
)
6665 n_switches_debug_check
[1] = n_switches
;
6666 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
6669 do_self_spec ("%:compare-debug-self-opt()");
6670 n_switches_debug_check
[0] = n_switches
;
6671 switches_debug_check
[0] = switches
;
6673 n_switches
= n_switches_debug_check
[1];
6674 switches
= switches_debug_check
[1];
6677 /* Avoid crash when computing %j in this early. */
6678 save
= save_temps_flag
;
6679 save_temps_flag
= SAVE_TEMPS_NONE
;
6681 compare_debug
= -compare_debug
;
6682 do_self_spec ("%:compare-debug-self-opt()");
6684 save_temps_flag
= save
;
6686 if (!compare_debug_second
)
6688 n_switches_debug_check
[1] = n_switches
;
6689 switches_debug_check
[1] = switches
;
6690 compare_debug
= -compare_debug
;
6691 n_switches
= n_switches_debug_check
[0];
6692 switches
= switches_debug_check
[0];
6696 /* If not cross-compiling, look for executables in the standard
6698 if (*cross_compile
== '0')
6700 if (*md_exec_prefix
)
6702 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6703 PREFIX_PRIORITY_LAST
, 0, 0);
6707 /* Process sysroot_suffix_spec. */
6708 if (*sysroot_suffix_spec
!= 0
6709 && do_spec_2 (sysroot_suffix_spec
) == 0)
6711 if (argbuf_index
> 1)
6712 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6713 else if (argbuf_index
== 1)
6714 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6717 #ifdef HAVE_LD_SYSROOT
6718 /* Pass the --sysroot option to the linker, if it supports that. If
6719 there is a sysroot_suffix_spec, it has already been processed by
6720 this point, so target_system_root really is the system root we
6722 if (target_system_root
)
6724 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6725 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6726 set_spec ("link", XOBFINISH (&obstack
, const char *));
6730 /* Process sysroot_hdrs_suffix_spec. */
6731 if (*sysroot_hdrs_suffix_spec
!= 0
6732 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6734 if (argbuf_index
> 1)
6735 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6736 else if (argbuf_index
== 1)
6737 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6740 /* Look for startfiles in the standard places. */
6741 if (*startfile_prefix_spec
!= 0
6742 && do_spec_2 (startfile_prefix_spec
) == 0
6743 && do_spec_1 (" ", 0, NULL
) == 0)
6746 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6747 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6748 PREFIX_PRIORITY_LAST
, 0, 1);
6750 /* We should eventually get rid of all these and stick to
6751 startfile_prefix_spec exclusively. */
6752 else if (*cross_compile
== '0' || target_system_root
)
6754 if (*md_startfile_prefix
)
6755 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6756 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6758 if (*md_startfile_prefix_1
)
6759 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6760 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6762 /* If standard_startfile_prefix is relative, base it on
6763 standard_exec_prefix. This lets us move the installed tree
6764 as a unit. If GCC_EXEC_PREFIX is defined, base
6765 standard_startfile_prefix on that as well.
6767 If the prefix is relative, only search it for native compilers;
6768 otherwise we will search a directory containing host libraries. */
6769 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6770 add_sysrooted_prefix (&startfile_prefixes
,
6771 standard_startfile_prefix
, "BINUTILS",
6772 PREFIX_PRIORITY_LAST
, 0, 1);
6773 else if (*cross_compile
== '0')
6775 add_prefix (&startfile_prefixes
,
6776 concat (gcc_exec_prefix
6777 ? gcc_exec_prefix
: standard_exec_prefix
,
6779 standard_startfile_prefix
, NULL
),
6780 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6783 /* Sysrooted prefixes are relocated because target_system_root is
6784 also relocated by gcc_exec_prefix. */
6785 if (*standard_startfile_prefix_1
)
6786 add_sysrooted_prefix (&startfile_prefixes
,
6787 standard_startfile_prefix_1
, "BINUTILS",
6788 PREFIX_PRIORITY_LAST
, 0, 1);
6789 if (*standard_startfile_prefix_2
)
6790 add_sysrooted_prefix (&startfile_prefixes
,
6791 standard_startfile_prefix_2
, "BINUTILS",
6792 PREFIX_PRIORITY_LAST
, 0, 1);
6795 /* Process any user specified specs in the order given on the command
6797 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6799 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6801 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6804 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6805 if (gcc_exec_prefix
)
6806 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6807 spec_version
, dir_separator_str
, NULL
);
6809 /* Now we have the specs.
6810 Set the `valid' bits for switches that match anything in any spec. */
6812 validate_all_switches ();
6814 /* Now that we have the switches and the specs, set
6815 the subdirectory based on the options. */
6816 set_multilib_dir ();
6818 /* Set up to remember the pathname of gcc and any options
6819 needed for collect. We use argv[0] instead of progname because
6820 we need the complete pathname. */
6821 obstack_init (&collect_obstack
);
6822 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6823 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6824 xputenv (XOBFINISH (&collect_obstack
, char *));
6826 /* Set up to remember the pathname of the lto wrapper. */
6828 lto_wrapper_spec
= find_a_file (&exec_prefixes
, "lto-wrapper", X_OK
, false);
6829 if (lto_wrapper_spec
)
6831 obstack_init (&collect_obstack
);
6832 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
6833 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6834 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
6835 strlen (lto_wrapper_spec
) + 1);
6836 xputenv (XOBFINISH (&collect_obstack
, char *));
6839 /* Warn about any switches that no pass was interested in. */
6841 for (i
= 0; (int) i
< n_switches
; i
++)
6842 if (! switches
[i
].validated
)
6843 error ("unrecognized option %<-%s%>", switches
[i
].part1
);
6845 /* Obey some of the options. */
6847 if (print_search_dirs
)
6849 printf (_("install: %s%s\n"),
6850 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6851 gcc_exec_prefix
? "" : machine_suffix
);
6852 printf (_("programs: %s\n"),
6853 build_search_list (&exec_prefixes
, "", false, false));
6854 printf (_("libraries: %s\n"),
6855 build_search_list (&startfile_prefixes
, "", false, true));
6859 if (print_file_name
)
6861 printf ("%s\n", find_file (print_file_name
));
6865 if (print_prog_name
)
6867 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6868 printf ("%s\n", (newname
? newname
: print_prog_name
));
6872 if (print_multi_lib
)
6874 print_multilib_info ();
6878 if (print_multi_directory
)
6880 if (multilib_dir
== NULL
)
6883 printf ("%s\n", multilib_dir
);
6889 if (target_system_root
)
6891 if (target_sysroot_suffix
)
6892 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6894 printf ("%s\n", target_system_root
);
6899 if (print_multi_os_directory
)
6901 if (multilib_os_dir
== NULL
)
6904 printf ("%s\n", multilib_os_dir
);
6908 if (print_sysroot_headers_suffix
)
6910 if (*sysroot_hdrs_suffix_spec
)
6912 printf("%s\n", (target_sysroot_hdrs_suffix
6913 ? target_sysroot_hdrs_suffix
6918 /* The error status indicates that only one set of fixed
6919 headers should be built. */
6920 fatal_error ("not configured with sysroot headers suffix");
6923 if (print_help_list
)
6929 printf (_("\nFor bug reporting instructions, please see:\n"));
6930 printf ("%s.\n", bug_report_url
);
6935 /* We do not exit here. Instead we have created a fake input file
6936 called 'help-dummy' which needs to be compiled, and we pass this
6937 on the various sub-processes, along with the --help switch.
6938 Ensure their output appears after ours. */
6939 fputc ('\n', stdout
);
6945 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
6947 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
6949 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6950 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6955 /* We do not exit here. We use the same mechanism of --help to print
6956 the version of the sub-processes. */
6957 fputc ('\n', stdout
);
6966 fnotice (stderr
, "Target: %s\n", spec_machine
);
6967 fnotice (stderr
, "Configured with: %s\n", configuration_arguments
);
6969 #ifdef THREAD_MODEL_SPEC
6970 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6971 but there's no point in doing all this processing just to get
6972 thread_model back. */
6973 obstack_init (&obstack
);
6974 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6975 obstack_1grow (&obstack
, '\0');
6976 thrmod
= XOBFINISH (&obstack
, const char *);
6978 thrmod
= thread_model
;
6981 fnotice (stderr
, "Thread model: %s\n", thrmod
);
6983 /* compiler_version is truncated at the first space when initialized
6984 from version string, so truncate version_string at the first space
6985 before comparing. */
6986 for (n
= 0; version_string
[n
]; n
++)
6987 if (version_string
[n
] == ' ')
6990 if (! strncmp (version_string
, compiler_version
, n
)
6991 && compiler_version
[n
] == 0)
6992 fnotice (stderr
, "gcc version %s %s\n", version_string
,
6995 fnotice (stderr
, "gcc driver version %s %sexecuting gcc version %s\n",
6996 version_string
, pkgversion_string
, compiler_version
);
7002 if (n_infiles
== added_libraries
)
7003 fatal_error ("no input files");
7005 /* Make a place to record the compiler output file names
7006 that correspond to the input files. */
7009 i
+= lang_specific_extra_outfiles
;
7010 outfiles
= XCNEWVEC (const char *, i
);
7012 /* Record which files were specified explicitly as link input. */
7014 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7017 combine_inputs
= true;
7019 combine_inputs
= false;
7021 for (i
= 0; (int) i
< n_infiles
; i
++)
7023 const char *name
= infiles
[i
].name
;
7024 struct compiler
*compiler
= lookup_compiler (name
,
7026 infiles
[i
].language
);
7028 if (compiler
&& !(compiler
->combinable
))
7029 combine_inputs
= false;
7031 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7032 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7033 infiles
[i
].incompiler
= compiler
;
7037 input_file_compiler
= compiler
;
7038 infiles
[i
].incompiler
= compiler
;
7042 /* Since there is no compiler for this input file, assume it is a
7044 explicit_link_files
[i
] = 1;
7045 infiles
[i
].incompiler
= NULL
;
7047 infiles
[i
].compiled
= false;
7048 infiles
[i
].preprocessed
= false;
7051 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7052 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7054 if (combine_flag
&& save_temps_flag
)
7056 bool save_combine_inputs
= combine_inputs
;
7057 /* Must do a separate pre-processing pass for C & Objective-C files, to
7058 obtain individual .i files. */
7060 combine_inputs
= false;
7061 for (i
= 0; (int) i
< n_infiles
; i
++)
7063 int this_file_error
= 0;
7065 input_file_number
= i
;
7066 set_input (infiles
[i
].name
);
7067 if (infiles
[i
].incompiler
7068 && (infiles
[i
].incompiler
)->needs_preprocessing
)
7069 input_file_compiler
= infiles
[i
].incompiler
;
7073 if (input_file_compiler
)
7075 if (input_file_compiler
->spec
[0] == '#')
7077 error ("%s: %s compiler not installed on this system",
7078 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7079 this_file_error
= 1;
7083 value
= do_spec (input_file_compiler
->spec
);
7084 infiles
[i
].preprocessed
= true;
7085 if (!have_o_argbuf_index
)
7086 fatal_error ("spec %qs is invalid",
7087 input_file_compiler
->spec
);
7088 infiles
[i
].name
= argbuf
[have_o_argbuf_index
];
7089 infiles
[i
].incompiler
7090 = lookup_compiler (infiles
[i
].name
,
7091 strlen (infiles
[i
].name
),
7092 infiles
[i
].language
);
7095 this_file_error
= 1;
7099 if (this_file_error
)
7101 delete_failure_queue ();
7105 clear_failure_queue ();
7107 combine_inputs
= save_combine_inputs
;
7110 for (i
= 0; (int) i
< n_infiles
; i
++)
7112 int this_file_error
= 0;
7114 /* Tell do_spec what to substitute for %i. */
7116 input_file_number
= i
;
7117 set_input (infiles
[i
].name
);
7119 if (infiles
[i
].compiled
)
7122 /* Use the same thing in %o, unless cp->spec says otherwise. */
7124 outfiles
[i
] = gcc_input_filename
;
7126 /* Figure out which compiler from the file's suffix. */
7128 if (! combine_inputs
)
7130 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7131 infiles
[i
].language
);
7133 input_file_compiler
= infiles
[i
].incompiler
;
7135 if (input_file_compiler
)
7137 /* Ok, we found an applicable compiler. Run its spec. */
7139 if (input_file_compiler
->spec
[0] == '#')
7141 error ("%s: %s compiler not installed on this system",
7142 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7143 this_file_error
= 1;
7149 if (debug_check_temp_file
[0])
7150 free (debug_check_temp_file
[0]);
7151 debug_check_temp_file
[0] = NULL
;
7153 if (debug_check_temp_file
[1])
7154 free (debug_check_temp_file
[1]);
7155 debug_check_temp_file
[1] = NULL
;
7158 value
= do_spec (input_file_compiler
->spec
);
7159 infiles
[i
].compiled
= true;
7161 this_file_error
= 1;
7162 else if (compare_debug
&& debug_check_temp_file
[0])
7165 inform (0, "recompiling with -fcompare-debug");
7167 compare_debug
= -compare_debug
;
7168 n_switches
= n_switches_debug_check
[1];
7169 switches
= switches_debug_check
[1];
7171 value
= do_spec (input_file_compiler
->spec
);
7173 compare_debug
= -compare_debug
;
7174 n_switches
= n_switches_debug_check
[0];
7175 switches
= switches_debug_check
[0];
7179 error ("during -fcompare-debug recompilation");
7180 this_file_error
= 1;
7183 gcc_assert (debug_check_temp_file
[1]
7184 && strcmp (debug_check_temp_file
[0],
7185 debug_check_temp_file
[1]));
7188 inform (0, "comparing final insns dumps");
7190 if (compare_files (debug_check_temp_file
))
7191 this_file_error
= 1;
7196 if (debug_check_temp_file
[0])
7197 free (debug_check_temp_file
[0]);
7198 debug_check_temp_file
[0] = NULL
;
7200 if (debug_check_temp_file
[1])
7201 free (debug_check_temp_file
[1]);
7202 debug_check_temp_file
[1] = NULL
;
7207 /* If this file's name does not contain a recognized suffix,
7208 record it as explicit linker input. */
7211 explicit_link_files
[i
] = 1;
7213 /* Clear the delete-on-failure queue, deleting the files in it
7214 if this compilation failed. */
7216 if (this_file_error
)
7218 delete_failure_queue ();
7221 /* If this compilation succeeded, don't delete those files later. */
7222 clear_failure_queue ();
7225 /* Reset the input file name to the first compile/object file name, for use
7226 with %b in LINK_SPEC. We use the first input file that we can find
7227 a compiler to compile it instead of using infiles.language since for
7228 languages other than C we use aliases that we then lookup later. */
7233 for (i
= 0; i
< n_infiles
; i
++)
7234 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7236 set_input (infiles
[i
].name
);
7243 /* Make sure INPUT_FILE_NUMBER points to first available open
7245 input_file_number
= n_infiles
;
7246 if (lang_specific_pre_link ())
7250 /* Determine if there are any linker input files. */
7251 num_linker_inputs
= 0;
7252 for (i
= 0; (int) i
< n_infiles
; i
++)
7253 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
7254 num_linker_inputs
++;
7256 /* Run ld to link all the compiler output files. */
7258 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
7260 int tmp
= execution_count
;
7261 const char *fuse_linker_plugin
= "fuse-linker-plugin";
7263 /* We'll use ld if we can't find collect2. */
7264 if (! strcmp (linker_name_spec
, "collect2"))
7266 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7268 linker_name_spec
= "ld";
7271 if (switch_matches (fuse_linker_plugin
,
7272 fuse_linker_plugin
+ strlen (fuse_linker_plugin
), 0))
7274 linker_plugin_file_spec
= find_a_file (&exec_prefixes
,
7275 "liblto_plugin.so", R_OK
,
7277 if (!linker_plugin_file_spec
)
7278 fatal_error ("-fuse-linker-plugin, but liblto_plugin.so not found");
7280 lto_libgcc_spec
= find_a_file (&startfile_prefixes
, "libgcc.a",
7282 if (!lto_libgcc_spec
)
7283 fatal_error ("could not find libgcc.a");
7285 lto_gcc_spec
= argv
[0];
7287 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7289 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7290 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7292 if (print_subprocess_help
== 1)
7294 printf (_("\nLinker options\n==============\n\n"));
7295 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7296 " to the linker.\n\n"));
7299 value
= do_spec (link_command_spec
);
7302 linker_was_run
= (tmp
!= execution_count
);
7305 /* If options said don't run linker,
7306 complain about input files to be given to the linker. */
7308 if (! linker_was_run
&& !seen_error ())
7309 for (i
= 0; (int) i
< n_infiles
; i
++)
7310 if (explicit_link_files
[i
]
7311 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7312 warning (0, "%s: linker input file unused because linking not done",
7315 /* Delete some or all of the temporary files we made. */
7318 delete_failure_queue ();
7319 delete_temp_files ();
7321 if (print_help_list
)
7323 printf (("\nFor bug reporting instructions, please see:\n"));
7324 printf ("%s\n", bug_report_url
);
7327 return (signal_count
!= 0 ? 2
7328 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
7332 /* Find the proper compilation spec for the file name NAME,
7333 whose length is LENGTH. LANGUAGE is the specified language,
7334 or 0 if this file is to be passed to the linker. */
7336 static struct compiler
*
7337 lookup_compiler (const char *name
, size_t length
, const char *language
)
7339 struct compiler
*cp
;
7341 /* If this was specified by the user to be a linker input, indicate that. */
7342 if (language
!= 0 && language
[0] == '*')
7345 /* Otherwise, look for the language, if one is spec'd. */
7348 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7349 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7352 error ("language %s not recognized", language
);
7356 /* Look for a suffix. */
7357 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7359 if (/* The suffix `-' matches only the file name `-'. */
7360 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7361 || (strlen (cp
->suffix
) < length
7362 /* See if the suffix matches the end of NAME. */
7363 && !strcmp (cp
->suffix
,
7364 name
+ length
- strlen (cp
->suffix
))
7369 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7370 /* Look again, but case-insensitively this time. */
7372 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7374 if (/* The suffix `-' matches only the file name `-'. */
7375 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7376 || (strlen (cp
->suffix
) < length
7377 /* See if the suffix matches the end of NAME. */
7378 && ((!strcmp (cp
->suffix
,
7379 name
+ length
- strlen (cp
->suffix
))
7380 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7381 && !strcasecmp (cp
->suffix
,
7382 name
+ length
- strlen (cp
->suffix
)))
7388 if (cp
>= compilers
)
7390 if (cp
->spec
[0] != '@')
7391 /* A non-alias entry: return it. */
7394 /* An alias entry maps a suffix to a language.
7395 Search for the language; pass 0 for NAME and LENGTH
7396 to avoid infinite recursion if language not found. */
7397 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7403 save_string (const char *s
, int len
)
7405 char *result
= XNEWVEC (char, len
+ 1);
7407 memcpy (result
, s
, len
);
7413 pfatal_with_name (const char *name
)
7415 perror_with_name (name
);
7416 delete_temp_files ();
7421 perror_with_name (const char *name
)
7423 error ("%s: %m", name
);
7427 validate_switches_from_spec (const char *spec
)
7429 const char *p
= spec
;
7432 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7433 /* We have a switch spec. */
7434 p
= validate_switches (p
+ 1);
7438 validate_all_switches (void)
7440 struct compiler
*comp
;
7441 struct spec_list
*spec
;
7443 for (comp
= compilers
; comp
->spec
; comp
++)
7444 validate_switches_from_spec (comp
->spec
);
7446 /* Look through the linked list of specs read from the specs file. */
7447 for (spec
= specs
; spec
; spec
= spec
->next
)
7448 validate_switches_from_spec (*spec
->ptr_spec
);
7450 validate_switches_from_spec (link_command_spec
);
7453 /* Look at the switch-name that comes after START
7454 and mark as valid all supplied switches that match it. */
7457 validate_switches (const char *start
)
7459 const char *p
= start
;
7463 bool suffix
= false;
7464 bool starred
= false;
7466 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7475 if (*p
== '.' || *p
== ',')
7479 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7480 || *p
== ',' || *p
== '.' || *p
== '@')
7485 starred
= true, p
++;
7491 /* Mark all matching switches as valid. */
7492 for (i
= 0; i
< n_switches
; i
++)
7493 if (!strncmp (switches
[i
].part1
, atom
, len
)
7494 && (starred
|| switches
[i
].part1
[len
] == 0))
7495 switches
[i
].validated
= 1;
7499 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7502 if (*p
&& p
[-1] == ':')
7504 while (*p
&& *p
!= ';' && *p
!= '}')
7509 if (*p
== '{' || *p
== '<')
7510 p
= validate_switches (p
+1);
7511 else if (p
[0] == 'W' && p
[1] == '{')
7512 p
= validate_switches (p
+2);
7519 if (*p
&& p
[-1] == ';')
7533 static struct mdswitchstr
*mdswitches
;
7534 static int n_mdswitches
;
7536 /* Check whether a particular argument was used. The first time we
7537 canonicalize the switches to keep only the ones we care about. */
7540 used_arg (const char *p
, int len
)
7545 const char *replace
;
7550 static struct mswitchstr
*mswitches
;
7551 static int n_mswitches
;
7556 struct mswitchstr
*matches
;
7560 /* Break multilib_matches into the component strings of string
7561 and replacement string. */
7562 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7567 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7569 q
= multilib_matches
;
7578 fatal_error ("multilib spec %qs is invalid",
7583 matches
[i
].len
= q
- matches
[i
].str
;
7585 matches
[i
].replace
= ++q
;
7586 while (*q
!= ';' && *q
!= '\0')
7589 goto invalid_matches
;
7592 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7598 /* Now build a list of the replacement string for switches that we care
7599 about. Make sure we allocate at least one entry. This prevents
7600 xmalloc from calling fatal, and prevents us from re-executing this
7603 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7604 for (i
= 0; i
< n_switches
; i
++)
7605 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7607 int xlen
= strlen (switches
[i
].part1
);
7608 for (j
= 0; j
< cnt
; j
++)
7609 if (xlen
== matches
[j
].len
7610 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7612 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7613 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7614 mswitches
[n_mswitches
].replace
= (char *) 0;
7615 mswitches
[n_mswitches
].rep_len
= 0;
7621 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7622 on the command line nor any options mutually incompatible with
7624 for (i
= 0; i
< n_mdswitches
; i
++)
7628 for (q
= multilib_options
; *q
!= '\0'; q
++)
7634 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7635 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7637 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7644 if (*q
!= ' ' && *q
!= '\0')
7646 while (*r
!= ' ' && *r
!= '\0')
7649 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7652 if (used_arg (r
, q
- r
))
7657 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7658 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7659 mswitches
[n_mswitches
].replace
= (char *) 0;
7660 mswitches
[n_mswitches
].rep_len
= 0;
7673 for (i
= 0; i
< n_mswitches
; i
++)
7674 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7681 default_arg (const char *p
, int len
)
7685 for (i
= 0; i
< n_mdswitches
; i
++)
7686 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7692 /* Work out the subdirectory to use based on the options. The format of
7693 multilib_select is a list of elements. Each element is a subdirectory
7694 name followed by a list of options followed by a semicolon. The format
7695 of multilib_exclusions is the same, but without the preceding
7696 directory. First gcc will check the exclusions, if none of the options
7697 beginning with an exclamation point are present, and all of the other
7698 options are present, then we will ignore this completely. Passing
7699 that, gcc will consider each multilib_select in turn using the same
7700 rules for matching the options. If a match is found, that subdirectory
7704 set_multilib_dir (void)
7707 unsigned int this_path_len
;
7708 const char *this_path
, *this_arg
;
7709 const char *start
, *end
;
7711 int ok
, ndfltok
, first
;
7714 start
= multilib_defaults
;
7715 while (*start
== ' ' || *start
== '\t')
7717 while (*start
!= '\0')
7720 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7722 while (*start
== ' ' || *start
== '\t')
7730 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7731 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7733 while (*start
== ' ' || *start
== '\t')
7739 for (end
= start
+ 1;
7740 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7743 obstack_grow (&multilib_obstack
, start
, end
- start
);
7744 obstack_1grow (&multilib_obstack
, 0);
7745 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7746 mdswitches
[i
++].len
= end
- start
;
7753 p
= multilib_exclusions
;
7756 /* Ignore newlines. */
7763 /* Check the arguments. */
7770 fatal_error ("multilib exclusions %qs is invalid",
7771 multilib_exclusions
);
7781 while (*p
!= ' ' && *p
!= ';')
7784 goto invalid_exclusions
;
7788 if (*this_arg
!= '!')
7796 ok
= used_arg (this_arg
, p
- this_arg
);
7811 p
= multilib_select
;
7814 /* Ignore newlines. */
7821 /* Get the initial path. */
7828 fatal_error ("multilib select %qs is invalid",
7833 this_path_len
= p
- this_path
;
7835 /* Check the arguments. */
7842 goto invalid_select
;
7851 while (*p
!= ' ' && *p
!= ';')
7854 goto invalid_select
;
7858 if (*this_arg
!= '!')
7866 /* If this is a default argument, we can just ignore it.
7867 This is true even if this_arg begins with '!'. Beginning
7868 with '!' does not mean that this argument is necessarily
7869 inappropriate for this library: it merely means that
7870 there is a more specific library which uses this
7871 argument. If this argument is a default, we need not
7872 consider that more specific library. */
7873 ok
= used_arg (this_arg
, p
- this_arg
);
7880 if (default_arg (this_arg
, p
- this_arg
))
7889 if (this_path_len
!= 1
7890 || this_path
[0] != '.')
7892 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7895 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7896 new_multilib_dir
[this_path_len
] = '\0';
7897 q
= strchr (new_multilib_dir
, ':');
7900 multilib_dir
= new_multilib_dir
;
7907 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7909 while (q
< end
&& *q
!= ':')
7913 char *new_multilib_os_dir
= XNEWVEC (char, end
- q
);
7914 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7915 new_multilib_os_dir
[end
- q
- 1] = '\0';
7916 multilib_os_dir
= new_multilib_os_dir
;
7924 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7925 && strcmp (multilib_os_dir
, ".") == 0)
7927 free (CONST_CAST (char *, multilib_os_dir
));
7928 multilib_os_dir
= NULL
;
7930 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7931 multilib_os_dir
= multilib_dir
;
7934 /* Print out the multiple library subdirectory selection
7935 information. This prints out a series of lines. Each line looks
7936 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7937 required. Only the desired options are printed out, the negative
7938 matches. The options are print without a leading dash. There are
7939 no spaces to make it easy to use the information in the shell.
7940 Each subdirectory is printed only once. This assumes the ordering
7941 generated by the genmultilib script. Also, we leave out ones that match
7945 print_multilib_info (void)
7947 const char *p
= multilib_select
;
7948 const char *last_path
= 0, *this_path
;
7950 unsigned int last_path_len
= 0;
7955 /* Ignore newlines. */
7962 /* Get the initial path. */
7969 fatal_error ("multilib select %qs is invalid", multilib_select
);
7975 /* When --disable-multilib was used but target defines
7976 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7977 to find multilib_os_dir, so skip them from output. */
7978 if (this_path
[0] == '.' && this_path
[1] == ':')
7981 /* Check for matches with the multilib_exclusions. We don't bother
7982 with the '!' in either list. If any of the exclusion rules match
7983 all of its options with the select rule, we skip it. */
7985 const char *e
= multilib_exclusions
;
7986 const char *this_arg
;
7991 /* Ignore newlines. */
7998 /* Check the arguments. */
8007 fatal_error ("multilib exclusion %qs is invalid",
8008 multilib_exclusions
);
8019 while (*e
!= ' ' && *e
!= ';')
8022 goto invalid_exclusion
;
8030 int len
= e
- this_arg
;
8033 goto invalid_select
;
8037 while (*q
!= ' ' && *q
!= ';')
8040 goto invalid_select
;
8044 if (! strncmp (arg
, this_arg
,
8045 (len
< q
- arg
) ? q
- arg
: len
)
8046 || default_arg (this_arg
, e
- this_arg
))
8076 /* If this is a duplicate, skip it. */
8077 skip
= (last_path
!= 0
8078 && (unsigned int) (p
- this_path
) == last_path_len
8079 && ! strncmp (last_path
, this_path
, last_path_len
));
8081 last_path
= this_path
;
8082 last_path_len
= p
- this_path
;
8085 /* If this directory requires any default arguments, we can skip
8086 it. We will already have printed a directory identical to
8087 this one which does not require that default argument. */
8098 goto invalid_select
;
8105 while (*q
!= ' ' && *q
!= ';')
8108 goto invalid_select
;
8113 && default_arg (arg
, q
- arg
))
8128 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8139 goto invalid_select
;
8147 use_arg
= *p
!= '!';
8152 while (*p
!= ' ' && *p
!= ';')
8155 goto invalid_select
;
8167 /* If there are extra options, print them now. */
8168 if (multilib_extra
&& *multilib_extra
)
8170 int print_at
= TRUE
;
8173 for (q
= multilib_extra
; *q
!= '\0'; q
++)
8194 /* getenv built-in spec function.
8196 Returns the value of the environment variable given by its first
8197 argument, concatenated with the second argument. If the
8198 environment variable is not defined, a fatal error is issued. */
8201 getenv_spec_function (int argc
, const char **argv
)
8211 value
= getenv (argv
[0]);
8213 fatal_error ("environment variable %qs not defined", argv
[0]);
8215 /* We have to escape every character of the environment variable so
8216 they are not interpreted as active spec characters. A
8217 particularly painful case is when we are reading a variable
8218 holding a windows path complete with \ separators. */
8219 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
8220 result
= XNEWVAR (char, len
);
8221 for (ptr
= result
; *value
; ptr
+= 2)
8227 strcpy (ptr
, argv
[1]);
8232 /* if-exists built-in spec function.
8234 Checks to see if the file specified by the absolute pathname in
8235 ARGS exists. Returns that pathname if found.
8237 The usual use for this function is to check for a library file
8238 (whose name has been expanded with %s). */
8241 if_exists_spec_function (int argc
, const char **argv
)
8243 /* Must have only one argument. */
8244 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8250 /* if-exists-else built-in spec function.
8252 This is like if-exists, but takes an additional argument which
8253 is returned if the first argument does not exist. */
8256 if_exists_else_spec_function (int argc
, const char **argv
)
8258 /* Must have exactly two arguments. */
8262 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8268 /* replace-outfile built-in spec function.
8270 This looks for the first argument in the outfiles array's name and
8271 replaces it with the second argument. */
8274 replace_outfile_spec_function (int argc
, const char **argv
)
8277 /* Must have exactly two arguments. */
8281 for (i
= 0; i
< n_infiles
; i
++)
8283 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
8284 outfiles
[i
] = xstrdup (argv
[1]);
8289 /* remove-outfile built-in spec function.
8291 * This looks for the first argument in the outfiles array's name and
8295 remove_outfile_spec_function (int argc
, const char **argv
)
8298 /* Must have exactly one argument. */
8302 for (i
= 0; i
< n_infiles
; i
++)
8304 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
8310 /* Given two version numbers, compares the two numbers.
8311 A version number must match the regular expression
8312 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8315 compare_version_strings (const char *v1
, const char *v2
)
8320 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8321 REG_EXTENDED
| REG_NOSUB
) != 0)
8323 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8324 if (rresult
== REG_NOMATCH
)
8325 fatal_error ("invalid version number %qs", v1
);
8326 else if (rresult
!= 0)
8328 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8329 if (rresult
== REG_NOMATCH
)
8330 fatal_error ("invalid version number %qs", v2
);
8331 else if (rresult
!= 0)
8334 return strverscmp (v1
, v2
);
8338 /* version_compare built-in spec function.
8340 This takes an argument of the following form:
8342 <comparison-op> <arg1> [<arg2>] <switch> <result>
8344 and produces "result" if the comparison evaluates to true,
8345 and nothing if it doesn't.
8347 The supported <comparison-op> values are:
8349 >= true if switch is a later (or same) version than arg1
8351 < true if switch is an earlier version than arg1
8353 >< true if switch is arg1 or later, and earlier than arg2
8354 <> true if switch is earlier than arg1 or is arg2 or later
8356 If the switch is not present, the condition is false unless
8357 the first character of the <comparison-op> is '!'.
8360 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8361 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8364 version_compare_spec_function (int argc
, const char **argv
)
8368 const char *switch_value
= NULL
;
8373 fatal_error ("too few arguments to %%:version-compare");
8374 if (argv
[0][0] == '\0')
8376 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8378 if (argc
!= nargs
+ 3)
8379 fatal_error ("too many arguments to %%:version-compare");
8381 switch_len
= strlen (argv
[nargs
+ 1]);
8382 for (i
= 0; i
< n_switches
; i
++)
8383 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8384 && check_live_switch (i
, switch_len
))
8385 switch_value
= switches
[i
].part1
+ switch_len
;
8387 if (switch_value
== NULL
)
8391 comp1
= compare_version_strings (switch_value
, argv
[1]);
8393 comp2
= compare_version_strings (switch_value
, argv
[2]);
8395 comp2
= -1; /* This value unused. */
8398 switch (argv
[0][0] << 8 | argv
[0][1])
8400 case '>' << 8 | '=':
8401 result
= comp1
>= 0;
8403 case '!' << 8 | '<':
8404 result
= comp1
>= 0 || switch_value
== NULL
;
8409 case '!' << 8 | '>':
8410 result
= comp1
< 0 || switch_value
== NULL
;
8412 case '>' << 8 | '<':
8413 result
= comp1
>= 0 && comp2
< 0;
8415 case '<' << 8 | '>':
8416 result
= comp1
< 0 || comp2
>= 0;
8420 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
8425 return argv
[nargs
+ 2];
8428 /* %:include builtin spec function. This differs from %include in that it
8429 can be nested inside a spec, and thus be conditionalized. It takes
8430 one argument, the filename, and looks for it in the startfile path.
8431 The result is always NULL, i.e. an empty expansion. */
8434 include_spec_function (int argc
, const char **argv
)
8441 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8442 read_specs (file
? file
: argv
[0], FALSE
);
8447 /* %:find-file spec function. This function replaces its argument by
8448 the file found thru find_file, that is the -print-file-name gcc
8451 find_file_spec_function (int argc
, const char **argv
)
8458 file
= find_file (argv
[0]);
8463 /* %:find-plugindir spec function. This function replaces its argument
8464 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
8465 is the -print-file-name gcc program option. */
8467 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8474 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8479 /* %:print-asm-header spec function. Print a banner to say that the
8480 following output is from the assembler. */
8483 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8484 const char **argv ATTRIBUTE_UNUSED
)
8486 printf (_("Assembler options\n=================\n\n"));
8487 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8492 /* Compute a timestamp to initialize flag_random_seed. */
8495 get_local_tick (void)
8499 /* Get some more or less random data. */
8500 #ifdef HAVE_GETTIMEOFDAY
8504 gettimeofday (&tv
, NULL
);
8505 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8509 time_t now
= time (NULL
);
8511 if (now
!= (time_t)-1)
8512 ret
= (unsigned) now
;
8519 /* %:compare-debug-dump-opt spec function. Save the last argument,
8520 expected to be the last -fdump-final-insns option, or generate a
8524 compare_debug_dump_opt_spec_function (int arg
,
8525 const char **argv ATTRIBUTE_UNUSED
)
8530 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
8533 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8535 do_spec_2 ("%{fdump-final-insns=*:%*}");
8536 do_spec_1 (" ", 0, NULL
);
8538 if (argbuf_index
> 0 && strcmp (argv
[argbuf_index
- 1], "."))
8543 name
= xstrdup (argv
[argbuf_index
- 1]);
8548 const char *ext
= NULL
;
8550 if (argbuf_index
> 0)
8552 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8555 else if (!compare_debug
)
8558 do_spec_2 ("%g.gkd");
8560 do_spec_1 (" ", 0, NULL
);
8562 gcc_assert (argbuf_index
> 0);
8564 name
= concat (argbuf
[argbuf_index
- 1], ext
, NULL
);
8566 ret
= concat ("-fdump-final-insns=", name
, NULL
);
8569 which
= compare_debug
< 0;
8570 debug_check_temp_file
[which
] = name
;
8574 unsigned HOST_WIDE_INT value
= get_local_tick () ^ getpid ();
8576 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
8580 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
8589 static const char *debug_auxbase_opt
;
8591 /* %:compare-debug-self-opt spec function. Expands to the options
8592 that are to be passed in the second compilation of
8596 compare_debug_self_opt_spec_function (int arg
,
8597 const char **argv ATTRIBUTE_UNUSED
)
8600 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8602 if (compare_debug
>= 0)
8605 do_spec_2 ("%{c|S:%{o*:%*}}");
8606 do_spec_1 (" ", 0, NULL
);
8608 if (argbuf_index
> 0)
8609 debug_auxbase_opt
= concat ("-auxbase-strip ",
8610 argbuf
[argbuf_index
- 1],
8613 debug_auxbase_opt
= NULL
;
8616 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8617 %<fdump-final-insns=* -w -S -o %j \
8618 %{!fcompare-debug-second:-fcompare-debug-second} \
8619 ", compare_debug_opt
, NULL
);
8622 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8623 options that are to be passed in the second compilation of
8624 compare-debug. It expects, as an argument, the basename of the
8625 current input file name, with the .gk suffix appended to it. */
8628 compare_debug_auxbase_opt_spec_function (int arg
,
8635 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8638 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8640 if (compare_debug
>= 0)
8643 len
= strlen (argv
[0]);
8644 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
8645 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8646 "does not end in .gk");
8648 if (debug_auxbase_opt
)
8649 return debug_auxbase_opt
;
8651 #define OPT "-auxbase "
8654 name
= (char*) xmalloc (sizeof (OPT
) + len
);
8655 memcpy (name
, OPT
, sizeof (OPT
) - 1);
8656 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
8657 name
[sizeof (OPT
) - 1 + len
] = '\0';