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". */
35 #include "coretypes.h"
36 #include "multilib.h" /* before tm.h */
39 #if ! defined( SIGCHLD ) && defined( SIGCLD )
40 # define SIGCHLD SIGCLD
47 #include "diagnostic.h"
52 # include <sys/mman.h>
54 /* This is on Solaris. */
55 # include <sys/types.h>
60 # define MAP_FAILED ((void *)-1)
63 /* By default there is no special suffix for target executables. */
64 /* FIXME: when autoconf is fixed, remove the host check - dj */
65 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
66 #define HAVE_TARGET_EXECUTABLE_SUFFIX
69 /* By default there is no special suffix for host executables. */
70 #ifdef HOST_EXECUTABLE_SUFFIX
71 #define HAVE_HOST_EXECUTABLE_SUFFIX
73 #define HOST_EXECUTABLE_SUFFIX ""
76 /* By default, the suffix for target object files is ".o". */
77 #ifdef TARGET_OBJECT_SUFFIX
78 #define HAVE_TARGET_OBJECT_SUFFIX
80 #define TARGET_OBJECT_SUFFIX ".o"
83 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
85 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
86 #ifndef LIBRARY_PATH_ENV
87 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
91 #define kill(p,s) raise(s)
94 /* If a stage of compilation returns an exit status >= 1,
95 compilation of that file ceases. */
97 #define MIN_FATAL_STATUS 1
99 /* Flag set by cppspec.c to 1. */
102 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
103 static bool at_file_supplied
;
105 /* Definition of string containing the arguments given to configure. */
106 #include "configargs.h"
108 /* Flag saying to print the command line options understood by gcc and its
111 static int print_help_list
;
113 /* Flag saying to print the version of gcc and its sub-processes. */
115 static int print_version
;
117 /* Flag indicating whether we should print the command and arguments */
119 static int verbose_flag
;
121 /* Flag indicating whether we should ONLY print the command and
122 arguments (like verbose_flag) without executing the command.
123 Displayed arguments are quoted so that the generated command
124 line is suitable for execution. This is intended for use in
125 shell scripts to capture the driver-generated command line. */
126 static int verbose_only_flag
;
128 /* Flag indicating how to print command line options of sub-processes. */
130 static int print_subprocess_help
;
132 /* Whether we should report subprocess execution times to a file. */
134 FILE *report_times_to_file
= NULL
;
136 /* Nonzero means place this string before uses of /, so that include
137 and library files can be found in an alternate location. */
139 #ifdef TARGET_SYSTEM_ROOT
140 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
142 static const char *target_system_root
= 0;
145 /* Nonzero means pass the updated target_system_root to the compiler. */
147 static int target_system_root_changed
;
149 /* Nonzero means append this string to target_system_root. */
151 static const char *target_sysroot_suffix
= 0;
153 /* Nonzero means append this string to target_system_root for headers. */
155 static const char *target_sysroot_hdrs_suffix
= 0;
157 /* Nonzero means write "temp" files in source directory
158 and use the source file's name in them, and don't delete them. */
160 static enum save_temps
{
161 SAVE_TEMPS_NONE
, /* no -save-temps */
162 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
163 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
166 /* Output file to use to get the object directory for -save-temps=obj */
167 static char *save_temps_prefix
= 0;
168 static size_t save_temps_length
= 0;
170 /* The compiler version. */
172 static const char *compiler_version
;
174 /* The target version. */
176 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
178 /* The target machine. */
180 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
182 /* Nonzero if cross-compiling.
183 When -b is used, the value comes from the `specs' file. */
185 #ifdef CROSS_DIRECTORY_STRUCTURE
186 static const char *cross_compile
= "1";
188 static const char *cross_compile
= "0";
191 /* Greatest exit code of sub-processes that has been encountered up to
193 static int greatest_status
= 1;
195 /* This is the obstack which we use to allocate many strings. */
197 static struct obstack obstack
;
199 /* This is the obstack to build an environment variable to pass to
200 collect2 that describes all of the relevant switches of what to
201 pass the compiler in building the list of pointers to constructors
204 static struct obstack collect_obstack
;
206 /* Forward declaration for prototypes. */
210 static void init_spec (void);
211 static void store_arg (const char *, int, int);
212 static void insert_wrapper (const char *);
213 static char *load_specs (const char *);
214 static void read_specs (const char *, int);
215 static void set_spec (const char *, const char *);
216 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
217 static char *build_search_list (const struct path_prefix
*, const char *,
219 static void xputenv (const char *);
220 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
222 static int access_check (const char *, int);
223 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
224 static void add_prefix (struct path_prefix
*, const char *, const char *,
226 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
227 const char *, int, int, int);
228 static char *skip_whitespace (char *);
229 static void delete_if_ordinary (const char *);
230 static void delete_temp_files (void);
231 static void delete_failure_queue (void);
232 static void clear_failure_queue (void);
233 static int check_live_switch (int, int);
234 static const char *handle_braces (const char *);
235 static inline bool input_suffix_matches (const char *, const char *);
236 static inline bool switch_matches (const char *, const char *, int);
237 static inline void mark_matching_switches (const char *, const char *, int);
238 static inline void process_marked_switches (void);
239 static const char *process_brace_body (const char *, const char *, const char *, int, int);
240 static const struct spec_function
*lookup_spec_function (const char *);
241 static const char *eval_spec_function (const char *, const char *);
242 static const char *handle_spec_function (const char *);
243 static char *save_string (const char *, int);
244 static void set_collect_gcc_options (void);
245 static int do_spec_1 (const char *, int, const char *);
246 static int do_spec_2 (const char *);
247 static void do_option_spec (const char *, const char *);
248 static void do_self_spec (const char *);
249 static const char *find_file (const char *);
250 static int is_directory (const char *, bool);
251 static const char *validate_switches (const char *);
252 static void validate_all_switches (void);
253 static inline void validate_switches_from_spec (const char *);
254 static void give_switch (int, int);
255 static int used_arg (const char *, int);
256 static int default_arg (const char *, int);
257 static void set_multilib_dir (void);
258 static void print_multilib_info (void);
259 static void perror_with_name (const char *);
260 static void display_help (void);
261 static void add_preprocessor_option (const char *, int);
262 static void add_assembler_option (const char *, int);
263 static void add_linker_option (const char *, int);
264 static void process_command (int, const char **);
265 static int execute (void);
266 static void alloc_args (void);
267 static void clear_args (void);
268 static void fatal_signal (int);
269 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
270 static void init_gcc_specs (struct obstack
*, const char *, const char *,
273 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
274 static const char *convert_filename (const char *, int, int);
277 static const char *getenv_spec_function (int, const char **);
278 static const char *if_exists_spec_function (int, const char **);
279 static const char *if_exists_else_spec_function (int, const char **);
280 static const char *replace_outfile_spec_function (int, const char **);
281 static const char *remove_outfile_spec_function (int, const char **);
282 static const char *version_compare_spec_function (int, const char **);
283 static const char *include_spec_function (int, const char **);
284 static const char *find_file_spec_function (int, const char **);
285 static const char *find_plugindir_spec_function (int, const char **);
286 static const char *print_asm_header_spec_function (int, const char **);
287 static const char *compare_debug_dump_opt_spec_function (int, const char **);
288 static const char *compare_debug_self_opt_spec_function (int, const char **);
289 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
291 /* The Specs Language
293 Specs are strings containing lines, each of which (if not blank)
294 is made up of a program name, and arguments separated by spaces.
295 The program name must be exact and start from root, since no path
296 is searched and it is unreliable to depend on the current working directory.
297 Redirection of input or output is not supported; the subprograms must
298 accept filenames saying what files to read and write.
300 In addition, the specs can contain %-sequences to substitute variable text
301 or for conditional text. Here is a table of all defined %-sequences.
302 Note that spaces are not generated automatically around the results of
303 expanding these sequences; therefore, you can concatenate them together
304 or with constant text in a single argument.
306 %% substitute one % into the program name or argument.
307 %i substitute the name of the input file being processed.
308 %b substitute the basename of the input file being processed.
309 This is the substring up to (and not including) the last period
310 and not including the directory unless -save-temps was specified
311 to put temporaries in a different location.
312 %B same as %b, but include the file suffix (text after the last period).
314 substitute a file name that has suffix SUFFIX and is chosen
315 once per compilation, and mark the argument a la %d. To reduce
316 exposure to denial-of-service attacks, the file name is now
317 chosen in a way that is hard to predict even when previously
318 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
319 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
320 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
321 had been pre-processed. Previously, %g was simply substituted
322 with a file name chosen once per compilation, without regard
323 to any appended suffix (which was therefore treated just like
324 ordinary text), making such attacks more likely to succeed.
326 like %g, but if -pipe is in effect, expands simply to "-".
328 like %g, but if -pipe is in effect, expands to nothing. (We have both
329 %| and %m to accommodate differences between system assemblers; see
330 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
332 like %g, but generates a new temporary file name even if %uSUFFIX
335 substitutes the last file name generated with %uSUFFIX, generating a
336 new one if there is no such last file name. In the absence of any
337 %uSUFFIX, this is just like %gSUFFIX, except they don't share
338 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
339 would involve the generation of two distinct file names, one
340 for each `%g.s' and another for each `%U.s'. Previously, %U was
341 simply substituted with a file name chosen for the previous %u,
342 without regard to any appended suffix.
344 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
345 writable, and if save-temps is off; otherwise, substitute the name
346 of a temporary file, just like %u. This temporary file is not
347 meant for communication between processes, but rather as a junk
350 substitutes .SUFFIX for the suffixes of a matched switch's args when
351 it is subsequently output with %*. SUFFIX is terminated by the next
353 %d marks the argument containing or following the %d as a
354 temporary file name, so that that file will be deleted if GCC exits
355 successfully. Unlike %g, this contributes no text to the argument.
356 %w marks the argument containing or following the %w as the
357 "output file" of this compilation. This puts the argument
358 into the sequence of arguments that %o will substitute later.
359 %V indicates that this compilation produces no "output file".
361 like %{...} but mark last argument supplied within
362 as a file to be deleted on failure.
363 %o substitutes the names of all the output files, with spaces
364 automatically placed around them. You should write spaces
365 around the %o as well or the results are undefined.
366 %o is for use in the specs for running the linker.
367 Input files whose names have no recognized suffix are not compiled
368 at all, but they are included among the output files, so they will
370 %O substitutes the suffix for object files. Note that this is
371 handled specially when it immediately follows %g, %u, or %U
372 (with or without a suffix argument) because of the need for
373 those to form complete file names. The handling is such that
374 %O is treated exactly as if it had already been substituted,
375 except that %g, %u, and %U do not currently support additional
376 SUFFIX characters following %O as they would following, for
378 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
379 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
380 and -B options) and -imultilib as necessary.
381 %s current argument is the name of a library or startup file of some sort.
382 Search for that file in a standard list of directories
383 and substitute the full name found.
384 %eSTR Print STR as an error message. STR is terminated by a newline.
385 Use this when inconsistent options are detected.
386 %nSTR Print STR as a notice. STR is terminated by a newline.
387 %x{OPTION} Accumulate an option for %X.
388 %X Output the accumulated linker options specified by compilations.
389 %Y Output the accumulated assembler options specified by compilations.
390 %Z Output the accumulated preprocessor options specified by compilations.
391 %a process ASM_SPEC as a spec.
392 This allows config.h to specify part of the spec for running as.
393 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
394 used here. This can be used to run a post-processor after the
395 assembler has done its job.
396 %D Dump out a -L option for each directory in startfile_prefixes.
397 If multilib_dir is set, extra entries are generated with it affixed.
398 %l process LINK_SPEC as a spec.
399 %L process LIB_SPEC as a spec.
400 %G process LIBGCC_SPEC as a spec.
401 %R Output the concatenation of target_system_root and
402 target_sysroot_suffix.
403 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
404 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
405 %C process CPP_SPEC as a spec.
406 %1 process CC1_SPEC as a spec.
407 %2 process CC1PLUS_SPEC as a spec.
408 %* substitute the variable part of a matched option. (See below.)
409 Note that each comma in the substituted string is replaced by
411 %<S remove all occurrences of -S from the command line.
412 Note - this command is position dependent. % commands in the
413 spec string before this one will see -S, % commands in the
414 spec string after this one will not.
415 %<S* remove all occurrences of all switches beginning with -S from the
418 Call the named function FUNCTION, passing it ARGS. ARGS is
419 first processed as a nested spec string, then split into an
420 argument vector in the usual fashion. The function returns
421 a string which is processed as if it had appeared literally
422 as part of the current spec.
423 %{S} substitutes the -S switch, if that switch was given to GCC.
424 If that switch was not specified, this substitutes nothing.
425 Here S is a metasyntactic variable.
426 %{S*} substitutes all the switches specified to GCC whose names start
427 with -S. This is used for -o, -I, etc; switches that take
428 arguments. GCC considers `-o foo' as being one switch whose
429 name starts with `o'. %{o*} would substitute this text,
430 including the space; thus, two arguments would be generated.
431 %{S*&T*} likewise, but preserve order of S and T options (the order
432 of S and T in the spec is not significant). Can be any number
433 of ampersand-separated variables; for each the wild card is
434 optional. Useful for CPP as %{D*&U*&A*}.
436 %{S:X} substitutes X, if the -S switch was given to GCC.
437 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
438 %{S*:X} substitutes X if one or more switches whose names start
439 with -S was given to GCC. Normally X is substituted only
440 once, no matter how many such switches appeared. However,
441 if %* appears somewhere in X, then X will be substituted
442 once for each matching switch, with the %* replaced by the
443 part of that switch that matched the '*'.
444 %{.S:X} substitutes X, if processing a file with suffix S.
445 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
446 %{,S:X} substitutes X, if processing a file which will use spec S.
447 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
449 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
450 combined with '!', '.', ',', and '*' as above binding stronger
452 If %* appears in X, all of the alternatives must be starred, and
453 only the first matching alternative is substituted.
454 %{S:X; if S was given to GCC, substitutes X;
455 T:Y; else if T was given to GCC, substitutes Y;
456 :D} else substitutes D. There can be as many clauses as you need.
457 This may be combined with '.', '!', ',', '|', and '*' as above.
459 %(Spec) processes a specification defined in a specs file as *Spec:
460 %[Spec] as above, but put __ around -D arguments
462 The conditional text X in a %{S:X} or similar construct may contain
463 other nested % constructs or spaces, or even newlines. They are
464 processed as usual, as described above. Trailing white space in X is
465 ignored. White space may also appear anywhere on the left side of the
466 colon in these constructs, except between . or * and the corresponding
469 The -O, -f, -m, and -W switches are handled specifically in these
470 constructs. If another value of -O or the negated form of a -f, -m, or
471 -W switch is found later in the command line, the earlier switch
472 value is ignored, except with {S*} where S is just one letter; this
473 passes all matching options.
475 The character | at the beginning of the predicate text is used to indicate
476 that a command should be piped to the following command, but only if -pipe
479 Note that it is built into GCC which switches take arguments and which
480 do not. You might think it would be useful to generalize this to
481 allow each compiler's spec to say which switches take arguments. But
482 this cannot be done in a consistent fashion. GCC cannot even decide
483 which input files have been specified without knowing which switches
484 take arguments, and it must know which input files to compile in order
485 to tell which compilers to run.
487 GCC also knows implicitly that arguments starting in `-l' are to be
488 treated as compiler output files, and passed to the linker in their
489 proper position among the other output files. */
491 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
493 /* config.h can define ASM_SPEC to provide extra args to the assembler
494 or extra switch-translations. */
499 /* config.h can define ASM_FINAL_SPEC to run a post processor after
500 the assembler has run. */
501 #ifndef ASM_FINAL_SPEC
502 #define ASM_FINAL_SPEC ""
505 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
506 or extra switch-translations. */
511 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
512 or extra switch-translations. */
517 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
518 or extra switch-translations. */
520 #define CC1PLUS_SPEC ""
523 /* config.h can define LINK_SPEC to provide extra args to the linker
524 or extra switch-translations. */
529 /* config.h can define LIB_SPEC to override the default libraries. */
531 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
536 /* XXX: valid only for GNU ld */
537 /* XXX: should exactly match hooks provided by libmudflap.a */
538 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
539 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
540 --wrap=mmap --wrap=munmap --wrap=alloca\
541 } %{fmudflapth: --wrap=pthread_create\
542 }} %{fmudflap|fmudflapth: --wrap=main}"
545 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
548 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
551 #if defined(REAL_LIBGCC_SPEC)
552 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
553 #elif defined(LINK_LIBGCC_SPECIAL_1)
554 /* Have gcc do the search for libgcc.a. */
555 #define LIBGCC_SPEC "libgcc.a%s"
557 #define LIBGCC_SPEC "-lgcc"
561 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
562 #ifndef STARTFILE_SPEC
563 #define STARTFILE_SPEC \
564 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
567 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
569 #define ENDFILE_SPEC ""
573 #define LINKER_NAME "collect2"
576 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
577 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
582 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
584 #ifndef ASM_DEBUG_SPEC
585 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
586 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
587 # define ASM_DEBUG_SPEC \
588 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
589 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
590 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
592 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
593 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
595 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
596 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
600 #ifndef ASM_DEBUG_SPEC
601 # define ASM_DEBUG_SPEC ""
604 /* Here is the spec for running the linker, after compiling all files. */
606 /* This is overridable by the target in case they need to specify the
607 -lgcc and -lc order specially, yet not require them to override all
608 of LINK_COMMAND_SPEC. */
609 #ifndef LINK_GCC_C_SEQUENCE_SPEC
610 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
613 #ifndef LINK_SSP_SPEC
614 #ifdef TARGET_LIBC_PROVIDES_SSP
615 #define LINK_SSP_SPEC "%{fstack-protector:}"
617 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
621 #ifndef LINK_PIE_SPEC
623 #define LINK_PIE_SPEC "%{pie:-pie} "
625 #define LINK_PIE_SPEC "%{pie:} "
629 #ifndef LINK_BUILDID_SPEC
630 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
631 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
636 /* -u* was put back because both BSD and SysV seem to support it. */
637 /* %{static:} simply prevents an error message if the target machine
638 doesn't handle -static. */
639 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
640 scripts which exist in user specified directories, or in standard
642 /* We pass any -flto and -fwhopr flags on to the linker, which is expected
643 to understand them. In practice, this means it had better be collect2. */
644 #ifndef LINK_COMMAND_SPEC
645 #define LINK_COMMAND_SPEC "\
646 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
648 %{fuse-linker-plugin: \
649 -plugin %(linker_plugin_file) \
650 -plugin-opt=%(lto_wrapper) \
651 -plugin-opt=-fresolution=%u.res \
652 %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)} \
653 %{static:-plugin-opt=-pass-through=-lc} \
655 %{flto:%<fcompare-debug*} %{fwhopr*:%<fcompare-debug*} \
656 %{flto} %{fwhopr*} %l " LINK_PIE_SPEC \
657 "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
658 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
659 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
660 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
661 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
662 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
663 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
666 #ifndef LINK_LIBGCC_SPEC
667 /* Generate -L options for startfile prefix list. */
668 # define LINK_LIBGCC_SPEC "%D"
671 #ifndef STARTFILE_PREFIX_SPEC
672 # define STARTFILE_PREFIX_SPEC ""
676 # define SYSROOT_SPEC "--sysroot=%R"
679 #ifndef SYSROOT_SUFFIX_SPEC
680 # define SYSROOT_SUFFIX_SPEC ""
683 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
684 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
687 static const char *asm_debug
;
688 static const char *cpp_spec
= CPP_SPEC
;
689 static const char *cc1_spec
= CC1_SPEC
;
690 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
691 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
692 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
693 static const char *asm_spec
= ASM_SPEC
;
694 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
695 static const char *link_spec
= LINK_SPEC
;
696 static const char *lib_spec
= LIB_SPEC
;
697 static const char *mfwrap_spec
= MFWRAP_SPEC
;
698 static const char *mflib_spec
= MFLIB_SPEC
;
699 static const char *link_gomp_spec
= "";
700 static const char *libgcc_spec
= LIBGCC_SPEC
;
701 static const char *endfile_spec
= ENDFILE_SPEC
;
702 static const char *startfile_spec
= STARTFILE_SPEC
;
703 static const char *linker_name_spec
= LINKER_NAME
;
704 static const char *linker_plugin_file_spec
= "";
705 static const char *lto_wrapper_spec
= "";
706 static const char *lto_gcc_spec
= "";
707 static const char *lto_libgcc_spec
= "";
708 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
709 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
710 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
711 static const char *sysroot_spec
= SYSROOT_SPEC
;
712 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
713 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
715 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
716 There should be no need to override these in target dependent files,
717 but we need to copy them to the specs file so that newer versions
718 of the GCC driver can correctly drive older tool chains with the
719 appropriate -B options. */
721 /* When cpplib handles traditional preprocessing, get rid of this, and
722 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
723 that we default the front end language better. */
724 static const char *trad_capable_cpp
=
725 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
727 /* We don't wrap .d files in %W{} since a missing .d file, and
728 therefore no dependency entry, confuses make into thinking a .o
729 file that happens to exist is up-to-date. */
730 static const char *cpp_unique_options
=
731 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
732 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
733 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
734 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
735 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
736 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
737 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
738 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
739 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
740 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
743 /* This contains cpp options which are common with cc1_options and are passed
744 only when preprocessing only to avoid duplication. We pass the cc1 spec
745 options to the preprocessor so that it the cc1 spec may manipulate
746 options used to set target flags. Those special target flags settings may
747 in turn cause preprocessor symbols to be defined specially. */
748 static const char *cpp_options
=
749 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
750 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
751 %{undef} %{save-temps*:-fpch-preprocess}";
753 /* This contains cpp options which are not passed when the preprocessor
754 output will be used by another program. */
755 static const char *cpp_debug_options
= "%{d*}";
757 /* NB: This is shared amongst all front-ends, except for Ada. */
758 static const char *cc1_options
=
759 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
760 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
761 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
762 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
763 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
764 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
765 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
766 %{Qn:-fno-ident} %{-help:--help}\
767 %{-target-help:--target-help}\
768 %{-version:--version}\
769 %{-help=*:--help=%*}\
770 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
771 %{fsyntax-only:-o %j} %{-param*}\
772 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
773 %{coverage:-fprofile-arcs -ftest-coverage}";
775 static const char *asm_options
=
776 "%{--target-help:%:print-asm-header()} "
778 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
779 to the assembler equivalents. */
780 "%{v} %{w:-W} %{I*} "
782 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
784 static const char *invoke_as
=
785 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
787 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
788 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
792 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
793 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
797 /* Some compilers have limits on line lengths, and the multilib_select
798 and/or multilib_matches strings can be very long, so we build them at
800 static struct obstack multilib_obstack
;
801 static const char *multilib_select
;
802 static const char *multilib_matches
;
803 static const char *multilib_defaults
;
804 static const char *multilib_exclusions
;
806 /* Check whether a particular argument is a default argument. */
808 #ifndef MULTILIB_DEFAULTS
809 #define MULTILIB_DEFAULTS { "" }
812 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
814 #ifndef DRIVER_SELF_SPECS
815 #define DRIVER_SELF_SPECS ""
818 /* Adding -fopenmp should imply pthreads. This is particularly important
819 for targets that use different start files and suchlike. */
820 #ifndef GOMP_SELF_SPECS
821 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
824 static const char *const driver_self_specs
[] = {
825 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
826 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
829 #ifndef OPTION_DEFAULT_SPECS
830 #define OPTION_DEFAULT_SPECS { "", "" }
839 static const struct default_spec
840 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
844 struct user_specs
*next
;
845 const char *filename
;
848 static struct user_specs
*user_specs_head
, *user_specs_tail
;
851 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
852 /* This defines which switches stop a full compilation. */
853 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
854 ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
856 #ifndef SWITCH_CURTAILS_COMPILATION
857 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
858 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
862 /* Record the mapping from file suffixes for compilation specs. */
866 const char *suffix
; /* Use this compiler for input files
867 whose names end in this suffix. */
869 const char *spec
; /* To use this compiler, run this spec. */
871 const char *cpp_spec
; /* If non-NULL, substitute this spec
872 for `%C', rather than the usual
874 const int combinable
; /* If nonzero, compiler can deal with
875 multiple source files at once (IMA). */
876 const int needs_preprocessing
; /* If nonzero, source files need to
877 be run through a preprocessor. */
880 /* Pointer to a vector of `struct compiler' that gives the spec for
881 compiling a file, based on its suffix.
882 A file that does not end in any of these suffixes will be passed
883 unchanged to the loader and nothing else will be done to it.
885 An entry containing two 0s is used to terminate the vector.
887 If multiple entries match a file, the last matching one is used. */
889 static struct compiler
*compilers
;
891 /* Number of entries in `compilers', not counting the null terminator. */
893 static int n_compilers
;
895 /* The default list of file name suffixes and their compilation specs. */
897 static const struct compiler default_compilers
[] =
899 /* Add lists of suffixes of known languages here. If those languages
900 were not present when we built the driver, we will hit these copies
901 and be given a more meaningful error than "file not used since
902 linking is not done". */
903 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
904 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
905 {".mii", "#Objective-C++", 0, 0, 0},
906 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
907 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
908 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
909 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
910 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
911 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
912 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
913 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
914 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
915 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
916 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
917 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
918 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
919 {".r", "#Ratfor", 0, 0, 0},
920 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
921 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
922 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
923 /* Next come the entries for C. */
924 {".c", "@c", 0, 0, 1},
926 /* cc1 has an integrated ISO C preprocessor. We should invoke the
927 external preprocessor if -save-temps is given. */
928 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
930 %{traditional|ftraditional:\
931 %eGNU C no longer supports -traditional without -E}\
932 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
933 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
934 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
936 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
937 cc1 %(cpp_unique_options) %(cc1_options)}}}\
938 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
940 "%{!E:%e-E or -x required when input is from standard input}\
941 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
942 {".h", "@c-header", 0, 0, 0},
944 /* cc1 has an integrated ISO C preprocessor. We should invoke the
945 external preprocessor if -save-temps is given. */
946 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
948 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
949 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
950 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
952 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
953 %W{o*:--output-pch=%*}}%V}\
954 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
955 cc1 %(cpp_unique_options) %(cc1_options)\
956 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
957 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
958 {".i", "@cpp-output", 0, 0, 0},
960 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
961 {".s", "@assembler", 0, 1, 0},
963 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
964 {".sx", "@assembler-with-cpp", 0, 1, 0},
965 {".S", "@assembler-with-cpp", 0, 1, 0},
966 {"@assembler-with-cpp",
967 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
968 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
969 %{E|M|MM:%(cpp_debug_options)}\
970 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
971 as %(asm_debug) %(asm_options) %|.s %A }}}}"
973 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
974 %{E|M|MM:%(cpp_debug_options)}\
975 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
976 as %(asm_debug) %(asm_options) %m.s %A }}}}"
981 /* Mark end of table. */
985 /* Number of elements in default_compilers, not counting the terminator. */
987 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
989 /* A vector of options to give to the linker.
990 These options are accumulated by %x,
991 and substituted into the linker command with %X. */
992 static int n_linker_options
;
993 static char **linker_options
;
995 /* A vector of options to give to the assembler.
996 These options are accumulated by -Wa,
997 and substituted into the assembler command with %Y. */
998 static int n_assembler_options
;
999 static char **assembler_options
;
1001 /* A vector of options to give to the preprocessor.
1002 These options are accumulated by -Wp,
1003 and substituted into the preprocessor command with %Z. */
1004 static int n_preprocessor_options
;
1005 static char **preprocessor_options
;
1008 skip_whitespace (char *p
)
1012 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1013 be considered whitespace. */
1014 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1016 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1030 /* Structures to keep track of prefixes to try when looking for files. */
1034 const char *prefix
; /* String to prepend to the path. */
1035 struct prefix_list
*next
; /* Next in linked list. */
1036 int require_machine_suffix
; /* Don't use without machine_suffix. */
1037 /* 2 means try both machine_suffix and just_machine_suffix. */
1038 int priority
; /* Sort key - priority within list. */
1039 int os_multilib
; /* 1 if OS multilib scheme should be used,
1040 0 for GCC multilib scheme. */
1045 struct prefix_list
*plist
; /* List of prefixes to try */
1046 int max_len
; /* Max length of a prefix in PLIST */
1047 const char *name
; /* Name of this list (used in config stuff) */
1050 /* List of prefixes to try when looking for executables. */
1052 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1054 /* List of prefixes to try when looking for startup (crt0) files. */
1056 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1058 /* List of prefixes to try when looking for include files. */
1060 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1062 /* Suffix to attach to directories searched for commands.
1063 This looks like `MACHINE/VERSION/'. */
1065 static const char *machine_suffix
= 0;
1067 /* Suffix to attach to directories searched for commands.
1068 This is just `MACHINE/'. */
1070 static const char *just_machine_suffix
= 0;
1072 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1074 static const char *gcc_exec_prefix
;
1076 /* Adjusted value of standard_libexec_prefix. */
1078 static const char *gcc_libexec_prefix
;
1080 /* Default prefixes to attach to command names. */
1082 #ifndef STANDARD_STARTFILE_PREFIX_1
1083 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1085 #ifndef STANDARD_STARTFILE_PREFIX_2
1086 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1089 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1090 #undef MD_EXEC_PREFIX
1091 #undef MD_STARTFILE_PREFIX
1092 #undef MD_STARTFILE_PREFIX_1
1095 /* If no prefixes defined, use the null string, which will disable them. */
1096 #ifndef MD_EXEC_PREFIX
1097 #define MD_EXEC_PREFIX ""
1099 #ifndef MD_STARTFILE_PREFIX
1100 #define MD_STARTFILE_PREFIX ""
1102 #ifndef MD_STARTFILE_PREFIX_1
1103 #define MD_STARTFILE_PREFIX_1 ""
1106 /* These directories are locations set at configure-time based on the
1107 --prefix option provided to configure. Their initializers are
1108 defined in Makefile.in. These paths are not *directly* used when
1109 gcc_exec_prefix is set because, in that case, we know where the
1110 compiler has been installed, and use paths relative to that
1111 location instead. */
1112 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1113 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1114 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1115 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1117 /* For native compilers, these are well-known paths containing
1118 components that may be provided by the system. For cross
1119 compilers, these paths are not used. */
1120 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1121 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1122 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1123 static const char *const standard_startfile_prefix_1
1124 = STANDARD_STARTFILE_PREFIX_1
;
1125 static const char *const standard_startfile_prefix_2
1126 = STANDARD_STARTFILE_PREFIX_2
;
1128 /* A relative path to be used in finding the location of tools
1129 relative to the driver. */
1130 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1132 /* Subdirectory to use for locating libraries. Set by
1133 set_multilib_dir based on the compilation options. */
1135 static const char *multilib_dir
;
1137 /* Subdirectory to use for locating libraries in OS conventions. Set by
1138 set_multilib_dir based on the compilation options. */
1140 static const char *multilib_os_dir
;
1142 /* Structure to keep track of the specs that have been defined so far.
1143 These are accessed using %(specname) or %[specname] in a compiler
1148 /* The following 2 fields must be first */
1149 /* to allow EXTRA_SPECS to be initialized */
1150 const char *name
; /* name of the spec. */
1151 const char *ptr
; /* available ptr if no static pointer */
1153 /* The following fields are not initialized */
1154 /* by EXTRA_SPECS */
1155 const char **ptr_spec
; /* pointer to the spec itself. */
1156 struct spec_list
*next
; /* Next spec in linked list. */
1157 int name_len
; /* length of the name */
1158 int alloc_p
; /* whether string was allocated */
1161 #define INIT_STATIC_SPEC(NAME,PTR) \
1162 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1164 /* List of statically defined specs. */
1165 static struct spec_list static_specs
[] =
1167 INIT_STATIC_SPEC ("asm", &asm_spec
),
1168 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1169 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1170 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1171 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1172 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1173 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1174 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1175 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1176 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1177 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1178 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1179 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1180 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1181 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1182 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1183 INIT_STATIC_SPEC ("link", &link_spec
),
1184 INIT_STATIC_SPEC ("lib", &lib_spec
),
1185 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1186 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1187 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1188 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1189 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1190 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1191 INIT_STATIC_SPEC ("version", &compiler_version
),
1192 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1193 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1194 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1195 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1196 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1197 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1198 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1199 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1200 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1201 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1202 INIT_STATIC_SPEC ("lto_libgcc", <o_libgcc_spec
),
1203 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1204 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1205 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1206 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1207 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1208 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1209 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1210 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1213 #ifdef EXTRA_SPECS /* additional specs needed */
1214 /* Structure to keep track of just the first two args of a spec_list.
1215 That is all that the EXTRA_SPECS macro gives us. */
1218 const char *const name
;
1219 const char *const ptr
;
1222 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1223 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1226 /* List of dynamically allocates specs that have been defined so far. */
1228 static struct spec_list
*specs
= (struct spec_list
*) 0;
1230 /* List of static spec functions. */
1232 static const struct spec_function static_spec_functions
[] =
1234 { "getenv", getenv_spec_function
},
1235 { "if-exists", if_exists_spec_function
},
1236 { "if-exists-else", if_exists_else_spec_function
},
1237 { "replace-outfile", replace_outfile_spec_function
},
1238 { "remove-outfile", remove_outfile_spec_function
},
1239 { "version-compare", version_compare_spec_function
},
1240 { "include", include_spec_function
},
1241 { "find-file", find_file_spec_function
},
1242 { "find-plugindir", find_plugindir_spec_function
},
1243 { "print-asm-header", print_asm_header_spec_function
},
1244 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1245 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1246 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1247 #ifdef EXTRA_SPEC_FUNCTIONS
1248 EXTRA_SPEC_FUNCTIONS
1253 static int processing_spec_function
;
1255 /* Add appropriate libgcc specs to OBSTACK, taking into account
1256 various permutations of -shared-libgcc, -shared, and such. */
1258 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1260 #ifndef USE_LD_AS_NEEDED
1261 #define USE_LD_AS_NEEDED 0
1265 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1266 const char *static_name
, const char *eh_name
)
1270 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1271 "%{!static:%{!static-libgcc:"
1272 #if USE_LD_AS_NEEDED
1273 "%{!shared-libgcc:",
1274 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1277 shared_name
, "%{!shared: ", static_name
, "}"
1281 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1282 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1286 "%{shared-libgcc:", shared_name
, "}"
1287 "%{!shared-libgcc:", static_name
, "}"
1290 "%{shared:", shared_name
, "}"
1295 obstack_grow (obstack
, buf
, strlen (buf
));
1298 #endif /* ENABLE_SHARED_LIBGCC */
1300 /* Initialize the specs lookup routines. */
1305 struct spec_list
*next
= (struct spec_list
*) 0;
1306 struct spec_list
*sl
= (struct spec_list
*) 0;
1310 return; /* Already initialized. */
1313 fnotice (stderr
, "Using built-in specs.\n");
1316 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1318 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1320 sl
= &extra_specs
[i
];
1321 sl
->name
= extra_specs_1
[i
].name
;
1322 sl
->ptr
= extra_specs_1
[i
].ptr
;
1324 sl
->name_len
= strlen (sl
->name
);
1325 sl
->ptr_spec
= &sl
->ptr
;
1330 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1332 sl
= &static_specs
[i
];
1337 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1338 /* ??? If neither -shared-libgcc nor --static-libgcc was
1339 seen, then we should be making an educated guess. Some proposed
1340 heuristics for ELF include:
1342 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1343 program will be doing dynamic loading, which will likely
1344 need the shared libgcc.
1346 (2) If "-ldl", then it's also a fair bet that we're doing
1349 (3) For each ET_DYN we're linking against (either through -lfoo
1350 or /some/path/foo.so), check to see whether it or one of
1351 its dependencies depends on a shared libgcc.
1355 If the runtime is fixed to look for program headers instead
1356 of calling __register_frame_info at all, for each object,
1357 use the shared libgcc if any EH symbol referenced.
1359 If crtstuff is fixed to not invoke __register_frame_info
1360 automatically, for each object, use the shared libgcc if
1361 any non-empty unwind section found.
1363 Doing any of this probably requires invoking an external program to
1364 do the actual object file scanning. */
1366 const char *p
= libgcc_spec
;
1369 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1370 when given the proper command line arguments. */
1373 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1375 init_gcc_specs (&obstack
,
1377 #ifdef USE_LIBUNWIND_EXCEPTIONS
1383 #ifdef USE_LIBUNWIND_EXCEPTIONS
1384 # ifdef HAVE_LD_STATIC_DYNAMIC
1385 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1395 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1397 /* Ug. We don't know shared library extensions. Hope that
1398 systems that use this form don't do shared libraries. */
1399 init_gcc_specs (&obstack
,
1403 #ifdef USE_LIBUNWIND_EXCEPTIONS
1412 obstack_1grow (&obstack
, *p
);
1413 in_sep
= (*p
== ' ');
1418 obstack_1grow (&obstack
, '\0');
1419 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1422 #ifdef USE_AS_TRADITIONAL_FORMAT
1423 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1425 static const char tf
[] = "--traditional-format ";
1426 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1427 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1428 asm_spec
= XOBFINISH (&obstack
, const char *);
1432 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1433 # ifdef LINK_BUILDID_SPEC
1434 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1435 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1437 # ifdef LINK_EH_SPEC
1438 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1439 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1441 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1442 link_spec
= XOBFINISH (&obstack
, const char *);
1448 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1449 removed; If the spec starts with a + then SPEC is added to the end of the
1453 set_spec (const char *name
, const char *spec
)
1455 struct spec_list
*sl
;
1456 const char *old_spec
;
1457 int name_len
= strlen (name
);
1460 /* If this is the first call, initialize the statically allocated specs. */
1463 struct spec_list
*next
= (struct spec_list
*) 0;
1464 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1466 sl
= &static_specs
[i
];
1473 /* See if the spec already exists. */
1474 for (sl
= specs
; sl
; sl
= sl
->next
)
1475 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1480 /* Not found - make it. */
1481 sl
= XNEW (struct spec_list
);
1482 sl
->name
= xstrdup (name
);
1483 sl
->name_len
= name_len
;
1484 sl
->ptr_spec
= &sl
->ptr
;
1486 *(sl
->ptr_spec
) = "";
1491 old_spec
= *(sl
->ptr_spec
);
1492 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1493 ? concat (old_spec
, spec
+ 1, NULL
)
1498 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1501 /* Free the old spec. */
1502 if (old_spec
&& sl
->alloc_p
)
1503 free (CONST_CAST(char *, old_spec
));
1508 /* Accumulate a command (program name and args), and run it. */
1510 /* Vector of pointers to arguments in the current line of specifications. */
1512 static const char **argbuf
;
1514 /* Number of elements allocated in argbuf. */
1516 static int argbuf_length
;
1518 /* Number of elements in argbuf currently in use (containing args). */
1520 static int argbuf_index
;
1522 /* Position in the argbuf array containing the name of the output file
1523 (the value associated with the "-o" flag). */
1525 static int have_o_argbuf_index
= 0;
1527 /* Were the options -c, -S or -E passed. */
1528 static int have_c
= 0;
1530 /* Was the option -o passed. */
1531 static int have_o
= 0;
1533 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1534 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1537 static struct temp_name
{
1538 const char *suffix
; /* suffix associated with the code. */
1539 int length
; /* strlen (suffix). */
1540 int unique
; /* Indicates whether %g or %u/%U was used. */
1541 const char *filename
; /* associated filename. */
1542 int filename_length
; /* strlen (filename). */
1543 struct temp_name
*next
;
1546 /* Number of commands executed so far. */
1548 static int execution_count
;
1550 /* Number of commands that exited with a signal. */
1552 static int signal_count
;
1554 /* Allocate the argument vector. */
1560 argbuf
= XNEWVEC (const char *, argbuf_length
);
1563 /* Clear out the vector of arguments (after a command is executed). */
1571 /* Add one argument to the vector at the end.
1572 This is done when a space is seen or at the end of the line.
1573 If DELETE_ALWAYS is nonzero, the arg is a filename
1574 and the file should be deleted eventually.
1575 If DELETE_FAILURE is nonzero, the arg is a filename
1576 and the file should be deleted if this compilation fails. */
1579 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1581 if (argbuf_index
+ 1 == argbuf_length
)
1582 argbuf
= XRESIZEVEC (const char *, argbuf
, (argbuf_length
*= 2));
1584 argbuf
[argbuf_index
++] = arg
;
1585 argbuf
[argbuf_index
] = 0;
1587 if (strcmp (arg
, "-o") == 0)
1588 have_o_argbuf_index
= argbuf_index
;
1589 if (delete_always
|| delete_failure
)
1592 /* If the temporary file we should delete is specified as
1593 part of a joined argument extract the filename. */
1595 && (p
= strrchr (arg
, '=')))
1597 record_temp_file (arg
, delete_always
, delete_failure
);
1601 /* Load specs from a file name named FILENAME, replacing occurrences of
1602 various different types of line-endings, \r\n, \n\r and just \r, with
1606 load_specs (const char *filename
)
1610 struct stat statbuf
;
1617 fnotice (stderr
, "Reading specs from %s\n", filename
);
1619 /* Open and stat the file. */
1620 desc
= open (filename
, O_RDONLY
, 0);
1622 pfatal_with_name (filename
);
1623 if (stat (filename
, &statbuf
) < 0)
1624 pfatal_with_name (filename
);
1626 /* Read contents of file into BUFFER. */
1627 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
1628 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1630 pfatal_with_name (filename
);
1631 buffer
[readlen
] = 0;
1634 specs
= XNEWVEC (char, readlen
+ 1);
1636 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1642 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1644 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1658 /* Read compilation specs from a file named FILENAME,
1659 replacing the default ones.
1661 A suffix which starts with `*' is a definition for
1662 one of the machine-specific sub-specs. The "suffix" should be
1663 *asm, *cc1, *cpp, *link, *startfile, etc.
1664 The corresponding spec is stored in asm_spec, etc.,
1665 rather than in the `compilers' vector.
1667 Anything invalid in the file is a fatal error. */
1670 read_specs (const char *filename
, int main_p
)
1675 buffer
= load_specs (filename
);
1677 /* Scan BUFFER for specs, putting them in the vector. */
1683 char *in
, *out
, *p1
, *p2
, *p3
;
1685 /* Advance P in BUFFER to the next nonblank nocomment line. */
1686 p
= skip_whitespace (p
);
1690 /* Is this a special command that starts with '%'? */
1691 /* Don't allow this for the main specs file, since it would
1692 encourage people to overwrite it. */
1693 if (*p
== '%' && !main_p
)
1696 while (*p
&& *p
!= '\n')
1702 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1703 && (p1
[sizeof "%include" - 1] == ' '
1704 || p1
[sizeof "%include" - 1] == '\t'))
1708 p1
+= sizeof ("%include");
1709 while (*p1
== ' ' || *p1
== '\t')
1712 if (*p1
++ != '<' || p
[-2] != '>')
1713 fatal_error ("specs %%include syntax malformed after "
1715 (long) (p1
- buffer
+ 1));
1718 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1719 read_specs (new_filename
? new_filename
: p1
, FALSE
);
1722 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1723 && (p1
[sizeof "%include_noerr" - 1] == ' '
1724 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1728 p1
+= sizeof "%include_noerr";
1729 while (*p1
== ' ' || *p1
== '\t')
1732 if (*p1
++ != '<' || p
[-2] != '>')
1733 fatal_error ("specs %%include syntax malformed after "
1735 (long) (p1
- buffer
+ 1));
1738 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1740 read_specs (new_filename
, FALSE
);
1741 else if (verbose_flag
)
1742 fnotice (stderr
, "could not find specs file %s\n", p1
);
1745 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1746 && (p1
[sizeof "%rename" - 1] == ' '
1747 || p1
[sizeof "%rename" - 1] == '\t'))
1750 struct spec_list
*sl
;
1751 struct spec_list
*newsl
;
1753 /* Get original name. */
1754 p1
+= sizeof "%rename";
1755 while (*p1
== ' ' || *p1
== '\t')
1758 if (! ISALPHA ((unsigned char) *p1
))
1759 fatal_error ("specs %%rename syntax malformed after "
1761 (long) (p1
- buffer
));
1764 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1767 if (*p2
!= ' ' && *p2
!= '\t')
1768 fatal_error ("specs %%rename syntax malformed after "
1770 (long) (p2
- buffer
));
1774 while (*p2
== ' ' || *p2
== '\t')
1777 if (! ISALPHA ((unsigned char) *p2
))
1778 fatal_error ("specs %%rename syntax malformed after "
1780 (long) (p2
- buffer
));
1782 /* Get new spec name. */
1784 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
1788 fatal_error ("specs %%rename syntax malformed after "
1790 (long) (p3
- buffer
));
1793 for (sl
= specs
; sl
; sl
= sl
->next
)
1794 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
1798 fatal_error ("specs %s spec was not found to be renamed", p1
);
1800 if (strcmp (p1
, p2
) == 0)
1803 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
1804 if (strcmp (newsl
->name
, p2
) == 0)
1805 fatal_error ("%s: attempt to rename spec %qs to "
1806 "already defined spec %qs",
1811 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
1813 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
1817 set_spec (p2
, *(sl
->ptr_spec
));
1819 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
1821 *(sl
->ptr_spec
) = "";
1826 fatal_error ("specs unknown %% command after %ld characters",
1827 (long) (p1
- buffer
));
1830 /* Find the colon that should end the suffix. */
1832 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
1835 /* The colon shouldn't be missing. */
1837 fatal_error ("specs file malformed after %ld characters",
1838 (long) (p1
- buffer
));
1840 /* Skip back over trailing whitespace. */
1842 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
1845 /* Copy the suffix to a string. */
1846 suffix
= save_string (p
, p2
- p
);
1847 /* Find the next line. */
1848 p
= skip_whitespace (p1
+ 1);
1850 fatal_error ("specs file malformed after %ld characters",
1851 (long) (p
- buffer
));
1854 /* Find next blank line or end of string. */
1855 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
1858 /* Specs end at the blank line and do not include the newline. */
1859 spec
= save_string (p
, p1
- p
);
1862 /* Delete backslash-newline sequences from the spec. */
1867 if (in
[0] == '\\' && in
[1] == '\n')
1869 else if (in
[0] == '#')
1870 while (*in
&& *in
!= '\n')
1878 if (suffix
[0] == '*')
1880 if (! strcmp (suffix
, "*link_command"))
1881 link_command_spec
= spec
;
1883 set_spec (suffix
+ 1, spec
);
1887 /* Add this pair to the vector. */
1889 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
1891 compilers
[n_compilers
].suffix
= suffix
;
1892 compilers
[n_compilers
].spec
= spec
;
1894 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
1898 link_command_spec
= spec
;
1901 if (link_command_spec
== 0)
1902 fatal_error ("spec file has no spec for linking");
1905 /* Record the names of temporary files we tell compilers to write,
1906 and delete them at the end of the run. */
1908 /* This is the common prefix we use to make temp file names.
1909 It is chosen once for each run of this program.
1910 It is substituted into a spec by %g or %j.
1911 Thus, all temp file names contain this prefix.
1912 In practice, all temp file names start with this prefix.
1914 This prefix comes from the envvar TMPDIR if it is defined;
1915 otherwise, from the P_tmpdir macro if that is defined;
1916 otherwise, in /usr/tmp or /tmp;
1917 or finally the current directory if all else fails. */
1919 static const char *temp_filename
;
1921 /* Length of the prefix. */
1923 static int temp_filename_length
;
1925 /* Define the list of temporary files to delete. */
1930 struct temp_file
*next
;
1933 /* Queue of files to delete on success or failure of compilation. */
1934 static struct temp_file
*always_delete_queue
;
1935 /* Queue of files to delete on failure of compilation. */
1936 static struct temp_file
*failure_delete_queue
;
1938 /* Record FILENAME as a file to be deleted automatically.
1939 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1940 otherwise delete it in any case.
1941 FAIL_DELETE nonzero means delete it if a compilation step fails;
1942 otherwise delete it in any case. */
1945 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
1947 char *const name
= xstrdup (filename
);
1951 struct temp_file
*temp
;
1952 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1953 if (! strcmp (name
, temp
->name
))
1956 temp
= XNEW (struct temp_file
);
1957 temp
->next
= always_delete_queue
;
1959 always_delete_queue
= temp
;
1966 struct temp_file
*temp
;
1967 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1968 if (! strcmp (name
, temp
->name
))
1971 temp
= XNEW (struct temp_file
);
1972 temp
->next
= failure_delete_queue
;
1974 failure_delete_queue
= temp
;
1980 /* Delete all the temporary files whose names we previously recorded. */
1982 #ifndef DELETE_IF_ORDINARY
1983 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
1986 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
1987 if (unlink (NAME) < 0) \
1989 perror_with_name (NAME); \
1994 delete_if_ordinary (const char *name
)
2000 printf ("Delete %s? (y or n) ", name
);
2004 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2007 if (i
== 'y' || i
== 'Y')
2009 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2013 delete_temp_files (void)
2015 struct temp_file
*temp
;
2017 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2018 delete_if_ordinary (temp
->name
);
2019 always_delete_queue
= 0;
2022 /* Delete all the files to be deleted on error. */
2025 delete_failure_queue (void)
2027 struct temp_file
*temp
;
2029 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2030 delete_if_ordinary (temp
->name
);
2034 clear_failure_queue (void)
2036 failure_delete_queue
= 0;
2039 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2041 If DO_MULTI is true iterate over the paths twice, first with multilib
2042 suffix then without, otherwise iterate over the paths once without
2043 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2044 to avoid visiting the same path twice, but we could do better. For
2045 instance, /usr/lib/../lib is considered different from /usr/lib.
2046 At least EXTRA_SPACE chars past the end of the path passed to
2047 CALLBACK are available for use by the callback.
2048 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2050 Returns the value returned by CALLBACK. */
2053 for_each_path (const struct path_prefix
*paths
,
2056 void *(*callback
) (char *, void *),
2057 void *callback_info
)
2059 struct prefix_list
*pl
;
2060 const char *multi_dir
= NULL
;
2061 const char *multi_os_dir
= NULL
;
2062 const char *multi_suffix
;
2063 const char *just_multi_suffix
;
2066 bool skip_multi_dir
= false;
2067 bool skip_multi_os_dir
= false;
2069 multi_suffix
= machine_suffix
;
2070 just_multi_suffix
= just_machine_suffix
;
2071 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2073 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2074 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2075 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2077 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2078 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2082 size_t multi_dir_len
= 0;
2083 size_t multi_os_dir_len
= 0;
2085 size_t just_suffix_len
;
2089 multi_dir_len
= strlen (multi_dir
);
2091 multi_os_dir_len
= strlen (multi_os_dir
);
2092 suffix_len
= strlen (multi_suffix
);
2093 just_suffix_len
= strlen (just_multi_suffix
);
2097 len
= paths
->max_len
+ extra_space
+ 1;
2098 if (suffix_len
> multi_os_dir_len
)
2101 len
+= multi_os_dir_len
;
2102 path
= XNEWVEC (char, len
);
2105 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2107 len
= strlen (pl
->prefix
);
2108 memcpy (path
, pl
->prefix
, len
);
2110 /* Look first in MACHINE/VERSION subdirectory. */
2111 if (!skip_multi_dir
)
2113 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2114 ret
= callback (path
, callback_info
);
2119 /* Some paths are tried with just the machine (ie. target)
2120 subdir. This is used for finding as, ld, etc. */
2122 && pl
->require_machine_suffix
== 2)
2124 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2125 ret
= callback (path
, callback_info
);
2130 /* Now try the base path. */
2131 if (!pl
->require_machine_suffix
2132 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2134 const char *this_multi
;
2135 size_t this_multi_len
;
2137 if (pl
->os_multilib
)
2139 this_multi
= multi_os_dir
;
2140 this_multi_len
= multi_os_dir_len
;
2144 this_multi
= multi_dir
;
2145 this_multi_len
= multi_dir_len
;
2149 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2153 ret
= callback (path
, callback_info
);
2161 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2164 /* Run through the paths again, this time without multilibs.
2165 Don't repeat any we have already seen. */
2168 free (CONST_CAST (char *, multi_dir
));
2170 free (CONST_CAST (char *, multi_suffix
));
2171 multi_suffix
= machine_suffix
;
2172 free (CONST_CAST (char *, just_multi_suffix
));
2173 just_multi_suffix
= just_machine_suffix
;
2176 skip_multi_dir
= true;
2179 free (CONST_CAST (char *, multi_os_dir
));
2180 multi_os_dir
= NULL
;
2183 skip_multi_os_dir
= true;
2188 free (CONST_CAST (char *, multi_dir
));
2189 free (CONST_CAST (char *, multi_suffix
));
2190 free (CONST_CAST (char *, just_multi_suffix
));
2193 free (CONST_CAST (char *, multi_os_dir
));
2199 /* Callback for build_search_list. Adds path to obstack being built. */
2201 struct add_to_obstack_info
{
2208 add_to_obstack (char *path
, void *data
)
2210 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2212 if (info
->check_dir
&& !is_directory (path
, false))
2215 if (!info
->first_time
)
2216 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2218 obstack_grow (info
->ob
, path
, strlen (path
));
2220 info
->first_time
= false;
2224 /* Add or change the value of an environment variable, outputting the
2225 change to standard error if in verbose mode. */
2227 xputenv (const char *string
)
2230 fnotice (stderr
, "%s\n", string
);
2231 putenv (CONST_CAST (char *, string
));
2234 /* Build a list of search directories from PATHS.
2235 PREFIX is a string to prepend to the list.
2236 If CHECK_DIR_P is true we ensure the directory exists.
2237 If DO_MULTI is true, multilib paths are output first, then
2239 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2240 It is also used by the --print-search-dirs flag. */
2243 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2244 bool check_dir
, bool do_multi
)
2246 struct add_to_obstack_info info
;
2248 info
.ob
= &collect_obstack
;
2249 info
.check_dir
= check_dir
;
2250 info
.first_time
= true;
2252 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2253 obstack_1grow (&collect_obstack
, '=');
2255 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2257 obstack_1grow (&collect_obstack
, '\0');
2258 return XOBFINISH (&collect_obstack
, char *);
2261 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2265 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2268 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2271 /* Check whether NAME can be accessed in MODE. This is like access,
2272 except that it never considers directories to be executable. */
2275 access_check (const char *name
, int mode
)
2281 if (stat (name
, &st
) < 0
2282 || S_ISDIR (st
.st_mode
))
2286 return access (name
, mode
);
2289 /* Callback for find_a_file. Appends the file name to the directory
2290 path. If the resulting file exists in the right mode, return the
2291 full pathname to the file. */
2293 struct file_at_path_info
{
2302 file_at_path (char *path
, void *data
)
2304 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2305 size_t len
= strlen (path
);
2307 memcpy (path
+ len
, info
->name
, info
->name_len
);
2308 len
+= info
->name_len
;
2310 /* Some systems have a suffix for executable files.
2311 So try appending that first. */
2312 if (info
->suffix_len
)
2314 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2315 if (access_check (path
, info
->mode
) == 0)
2320 if (access_check (path
, info
->mode
) == 0)
2326 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2327 access to check permissions. If DO_MULTI is true, search multilib
2328 paths then non-multilib paths, otherwise do not search multilib paths.
2329 Return 0 if not found, otherwise return its name, allocated with malloc. */
2332 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2335 struct file_at_path_info info
;
2337 #ifdef DEFAULT_ASSEMBLER
2338 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2339 return xstrdup (DEFAULT_ASSEMBLER
);
2342 #ifdef DEFAULT_LINKER
2343 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2344 return xstrdup (DEFAULT_LINKER
);
2347 /* Determine the filename to execute (special case for absolute paths). */
2349 if (IS_ABSOLUTE_PATH (name
))
2351 if (access (name
, mode
) == 0)
2352 return xstrdup (name
);
2358 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2359 info
.name_len
= strlen (info
.name
);
2360 info
.suffix_len
= strlen (info
.suffix
);
2363 return (char*) for_each_path (pprefix
, do_multi
,
2364 info
.name_len
+ info
.suffix_len
,
2365 file_at_path
, &info
);
2368 /* Ranking of prefixes in the sort list. -B prefixes are put before
2371 enum path_prefix_priority
2373 PREFIX_PRIORITY_B_OPT
,
2374 PREFIX_PRIORITY_LAST
2377 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2378 order according to PRIORITY. Within each PRIORITY, new entries are
2381 If WARN is nonzero, we will warn if no file is found
2382 through this prefix. WARN should point to an int
2383 which will be set to 1 if this entry is used.
2385 COMPONENT is the value to be passed to update_path.
2387 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2388 the complete value of machine_suffix.
2389 2 means try both machine_suffix and just_machine_suffix. */
2392 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2393 const char *component
, /* enum prefix_priority */ int priority
,
2394 int require_machine_suffix
, int os_multilib
)
2396 struct prefix_list
*pl
, **prev
;
2399 for (prev
= &pprefix
->plist
;
2400 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2401 prev
= &(*prev
)->next
)
2404 /* Keep track of the longest prefix. */
2406 prefix
= update_path (prefix
, component
);
2407 len
= strlen (prefix
);
2408 if (len
> pprefix
->max_len
)
2409 pprefix
->max_len
= len
;
2411 pl
= XNEW (struct prefix_list
);
2412 pl
->prefix
= prefix
;
2413 pl
->require_machine_suffix
= require_machine_suffix
;
2414 pl
->priority
= priority
;
2415 pl
->os_multilib
= os_multilib
;
2417 /* Insert after PREV. */
2422 /* Same as add_prefix, but prepending target_system_root to prefix. */
2423 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2425 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2426 const char *component
,
2427 /* enum prefix_priority */ int priority
,
2428 int require_machine_suffix
, int os_multilib
)
2430 if (!IS_ABSOLUTE_PATH (prefix
))
2431 fatal_error ("system path %qs is not absolute", prefix
);
2433 if (target_system_root
)
2435 if (target_sysroot_suffix
)
2436 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2437 prefix
= concat (target_system_root
, prefix
, NULL
);
2439 /* We have to override this because GCC's notion of sysroot
2440 moves along with GCC. */
2444 add_prefix (pprefix
, prefix
, component
, priority
,
2445 require_machine_suffix
, os_multilib
);
2448 /* Execute the command specified by the arguments on the current line of spec.
2449 When using pipes, this includes several piped-together commands
2450 with `|' between them.
2452 Return 0 if successful, -1 if failed. */
2458 int n_commands
; /* # of command. */
2460 struct pex_obj
*pex
;
2463 const char *prog
; /* program name. */
2464 const char **argv
; /* vector of args. */
2467 struct command
*commands
; /* each command buffer with above info. */
2469 gcc_assert (!processing_spec_function
);
2473 string
= find_a_file (&exec_prefixes
, argbuf
[0], X_OK
, false);
2474 argbuf
[0] = (string
) ? string
: argbuf
[0];
2475 insert_wrapper (wrapper_string
);
2478 /* Count # of piped commands. */
2479 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2480 if (strcmp (argbuf
[i
], "|") == 0)
2483 /* Get storage for each command. */
2484 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2486 /* Split argbuf into its separate piped processes,
2487 and record info about each one.
2488 Also search for the programs that are to be run. */
2490 commands
[0].prog
= argbuf
[0]; /* first command. */
2491 commands
[0].argv
= &argbuf
[0];
2493 if (!wrapper_string
)
2495 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2496 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2499 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2500 if (strcmp (argbuf
[i
], "|") == 0)
2501 { /* each command. */
2502 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2503 fatal_error ("-pipe not supported");
2505 argbuf
[i
] = 0; /* termination of command args. */
2506 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2507 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2508 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2511 commands
[n_commands
].argv
[0] = string
;
2515 argbuf
[argbuf_index
] = 0;
2517 /* If -v, print what we are about to do, and maybe query. */
2521 /* For help listings, put a blank line between sub-processes. */
2522 if (print_help_list
)
2523 fputc ('\n', stderr
);
2525 /* Print each piped command as a separate line. */
2526 for (i
= 0; i
< n_commands
; i
++)
2528 const char *const *j
;
2530 if (verbose_only_flag
)
2532 for (j
= commands
[i
].argv
; *j
; j
++)
2535 for (p
= *j
; *p
; ++p
)
2536 if (!ISALNUM ((unsigned char) *p
)
2537 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2541 fprintf (stderr
, " \"");
2542 for (p
= *j
; *p
; ++p
)
2544 if (*p
== '"' || *p
== '\\' || *p
== '$')
2545 fputc ('\\', stderr
);
2548 fputc ('"', stderr
);
2551 fprintf (stderr
, " %s", *j
);
2555 for (j
= commands
[i
].argv
; *j
; j
++)
2556 fprintf (stderr
, " %s", *j
);
2558 /* Print a pipe symbol after all but the last command. */
2559 if (i
+ 1 != n_commands
)
2560 fprintf (stderr
, " |");
2561 fprintf (stderr
, "\n");
2564 if (verbose_only_flag
!= 0)
2566 /* verbose_only_flag should act as if the spec was
2567 executed, so increment execution_count before
2568 returning. This prevents spurious warnings about
2569 unused linker input files, etc. */
2574 fnotice (stderr
, "\nGo ahead? (y or n) ");
2578 while (getchar () != '\n')
2581 if (i
!= 'y' && i
!= 'Y')
2586 #ifdef ENABLE_VALGRIND_CHECKING
2587 /* Run the each command through valgrind. To simplify prepending the
2588 path to valgrind and the option "-q" (for quiet operation unless
2589 something triggers), we allocate a separate argv array. */
2591 for (i
= 0; i
< n_commands
; i
++)
2597 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2600 argv
= XALLOCAVEC (const char *, argc
+ 3);
2602 argv
[0] = VALGRIND_PATH
;
2604 for (j
= 2; j
< argc
+ 2; j
++)
2605 argv
[j
] = commands
[i
].argv
[j
- 2];
2608 commands
[i
].argv
= argv
;
2609 commands
[i
].prog
= argv
[0];
2613 /* Run each piped subprocess. */
2615 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
2616 ? PEX_RECORD_TIMES
: 0),
2617 progname
, temp_filename
);
2619 fatal_error ("pex_init failed: %m");
2621 for (i
= 0; i
< n_commands
; i
++)
2625 const char *string
= commands
[i
].argv
[0];
2627 errmsg
= pex_run (pex
,
2628 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2629 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2630 string
, CONST_CAST (char **, commands
[i
].argv
),
2635 fatal_error (errmsg
);
2639 pfatal_with_name (errmsg
);
2643 if (string
!= commands
[i
].prog
)
2644 free (CONST_CAST (char *, string
));
2649 /* Wait for all the subprocesses to finish. */
2653 struct pex_time
*times
= NULL
;
2656 statuses
= (int *) alloca (n_commands
* sizeof (int));
2657 if (!pex_get_status (pex
, n_commands
, statuses
))
2658 fatal_error ("failed to get exit status: %m");
2660 if (report_times
|| report_times_to_file
)
2662 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
2663 if (!pex_get_times (pex
, n_commands
, times
))
2664 fatal_error ("failed to get process times: %m");
2669 for (i
= 0; i
< n_commands
; ++i
)
2671 int status
= statuses
[i
];
2673 if (WIFSIGNALED (status
))
2676 /* SIGPIPE is a special case. It happens in -pipe mode
2677 when the compiler dies before the preprocessor is done,
2678 or the assembler dies before the compiler is done.
2679 There's generally been an error already, and this is
2680 just fallout. So don't generate another error unless
2681 we would otherwise have succeeded. */
2682 if (WTERMSIG (status
) == SIGPIPE
2683 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2690 internal_error ("%s (program %s)",
2691 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
2693 else if (WIFEXITED (status
)
2694 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2696 if (WEXITSTATUS (status
) > greatest_status
)
2697 greatest_status
= WEXITSTATUS (status
);
2701 if (report_times
|| report_times_to_file
)
2703 struct pex_time
*pt
= ×
[i
];
2706 ut
= ((double) pt
->user_seconds
2707 + (double) pt
->user_microseconds
/ 1.0e6
);
2708 st
= ((double) pt
->system_seconds
2709 + (double) pt
->system_microseconds
/ 1.0e6
);
2714 fnotice (stderr
, "# %s %.2f %.2f\n",
2715 commands
[i
].prog
, ut
, st
);
2717 if (report_times_to_file
)
2720 const char *const *j
;
2722 fprintf (report_times_to_file
, "%g %g", ut
, st
);
2724 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
2727 for (p
= *j
; *p
; ++p
)
2728 if (*p
== '"' || *p
== '\\' || *p
== '$'
2734 fprintf (report_times_to_file
, " \"");
2735 for (p
= *j
; *p
; ++p
)
2737 if (*p
== '"' || *p
== '\\' || *p
== '$')
2738 fputc ('\\', report_times_to_file
);
2739 fputc (*p
, report_times_to_file
);
2741 fputc ('"', report_times_to_file
);
2744 fprintf (report_times_to_file
, " %s", *j
);
2747 fputc ('\n', report_times_to_file
);
2757 /* Find all the switches given to us
2758 and make a vector describing them.
2759 The elements of the vector are strings, one per switch given.
2760 If a switch uses following arguments, then the `part1' field
2761 is the switch itself and the `args' field
2762 is a null-terminated vector containing the following arguments.
2763 Bits in the `live_cond' field are:
2764 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2765 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2766 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2767 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2768 in all do_spec calls afterwards. Used for %<S from self specs.
2769 The `validated' field is nonzero if any spec has looked at this switch;
2770 if it remains zero at the end of the run, it must be meaningless. */
2772 #define SWITCH_LIVE 0x1
2773 #define SWITCH_FALSE 0x2
2774 #define SWITCH_IGNORE 0x4
2775 #define SWITCH_IGNORE_PERMANENTLY 0x8
2781 unsigned int live_cond
;
2782 unsigned char validated
;
2783 unsigned char ordering
;
2786 static struct switchstr
*switches
;
2788 static int n_switches
;
2790 static int n_switches_alloc
;
2792 /* Set to zero if -fcompare-debug is disabled, positive if it's
2793 enabled and we're running the first compilation, negative if it's
2794 enabled and we're running the second compilation. For most of the
2795 time, it's in the range -1..1, but it can be temporarily set to 2
2796 or 3 to indicate that the -fcompare-debug flags didn't come from
2797 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2798 variable, until a synthesized -fcompare-debug flag is added to the
2802 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2803 int compare_debug_second
;
2805 /* Set to the flags that should be passed to the second compilation in
2806 a -fcompare-debug compilation. */
2807 const char *compare_debug_opt
;
2809 static struct switchstr
*switches_debug_check
[2];
2811 static int n_switches_debug_check
[2];
2813 static char *debug_check_temp_file
[2];
2815 /* Language is one of three things:
2817 1) The name of a real programming language.
2818 2) NULL, indicating that no one has figured out
2820 3) '*', indicating that the file should be passed
2825 const char *language
;
2826 struct compiler
*incompiler
;
2831 /* Also a vector of input files specified. */
2833 static struct infile
*infiles
;
2837 static int n_infiles_alloc
;
2839 /* True if multiple input files are being compiled to a single
2842 static bool combine_inputs
;
2844 /* This counts the number of libraries added by lang_specific_driver, so that
2845 we can tell if there were any user supplied any files or libraries. */
2847 static int added_libraries
;
2849 /* And a vector of corresponding output files is made up later. */
2851 const char **outfiles
;
2853 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2855 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2856 is true if we should look for an executable suffix. DO_OBJ
2857 is true if we should look for an object suffix. */
2860 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
2861 int do_obj ATTRIBUTE_UNUSED
)
2863 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2871 len
= strlen (name
);
2873 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2874 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2875 if (do_obj
&& len
> 2
2876 && name
[len
- 2] == '.'
2877 && name
[len
- 1] == 'o')
2879 obstack_grow (&obstack
, name
, len
- 2);
2880 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
2881 name
= XOBFINISH (&obstack
, const char *);
2885 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2886 /* If there is no filetype, make it the executable suffix (which includes
2887 the "."). But don't get confused if we have just "-o". */
2888 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
2891 for (i
= len
- 1; i
>= 0; i
--)
2892 if (IS_DIR_SEPARATOR (name
[i
]))
2895 for (i
++; i
< len
; i
++)
2899 obstack_grow (&obstack
, name
, len
);
2900 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
2901 strlen (TARGET_EXECUTABLE_SUFFIX
));
2902 name
= XOBFINISH (&obstack
, const char *);
2909 /* Display the command line switches accepted by gcc. */
2913 printf (_("Usage: %s [options] file...\n"), progname
);
2914 fputs (_("Options:\n"), stdout
);
2916 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
2917 fputs (_(" --help Display this information\n"), stdout
);
2918 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
2919 fputs (_(" --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
2920 fputs (_(" Display specific types of command line options\n"), stdout
);
2922 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
2923 fputs (_(" --version Display compiler version information\n"), stdout
);
2924 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
2925 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
2926 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
2927 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
2928 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
2929 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
2930 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
2931 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
2933 -print-multi-lib Display the mapping between command line options and\n\
2934 multiple library search directories\n"), stdout
);
2935 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
2936 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
2937 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
2938 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
2939 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
2940 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
2941 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
2942 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
2943 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
2944 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
2945 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
2947 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
2948 prefixes to other gcc components\n"), stdout
);
2949 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
2950 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
2951 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
2952 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
2954 --sysroot=<directory> Use <directory> as the root directory for headers\n\
2955 and libraries\n"), stdout
);
2956 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
2957 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
2958 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
2959 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
2960 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
2961 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
2962 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
2964 -x <language> Specify the language of the following input files\n\
2965 Permissible languages include: c c++ assembler none\n\
2966 'none' means revert to the default behavior of\n\
2967 guessing the language based on the file's extension\n\
2971 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
2972 passed on to the various sub-processes invoked by %s. In order to pass\n\
2973 other options on to these processes the -W<letter> options must be used.\n\
2976 /* The rest of the options are displayed by invocations of the various
2981 add_preprocessor_option (const char *option
, int len
)
2983 n_preprocessor_options
++;
2985 if (! preprocessor_options
)
2986 preprocessor_options
= XNEWVEC (char *, n_preprocessor_options
);
2988 preprocessor_options
= XRESIZEVEC (char *, preprocessor_options
,
2989 n_preprocessor_options
);
2991 preprocessor_options
[n_preprocessor_options
- 1] =
2992 save_string (option
, len
);
2996 add_assembler_option (const char *option
, int len
)
2998 n_assembler_options
++;
3000 if (! assembler_options
)
3001 assembler_options
= XNEWVEC (char *, n_assembler_options
);
3003 assembler_options
= XRESIZEVEC (char *, assembler_options
,
3004 n_assembler_options
);
3006 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3010 add_linker_option (const char *option
, int len
)
3014 if (! linker_options
)
3015 linker_options
= XNEWVEC (char *, n_linker_options
);
3017 linker_options
= XRESIZEVEC (char *, linker_options
, n_linker_options
);
3019 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3022 /* Allocate space for an input file in infiles. */
3027 if (n_infiles_alloc
== 0)
3029 n_infiles_alloc
= 16;
3030 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3032 else if (n_infiles_alloc
== n_infiles
)
3034 n_infiles_alloc
*= 2;
3035 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3039 /* Store an input file with the given NAME and LANGUAGE in
3043 add_infile (const char *name
, const char *language
)
3046 infiles
[n_infiles
].name
= name
;
3047 infiles
[n_infiles
++].language
= language
;
3050 /* Allocate space for a switch in switches. */
3055 if (n_switches_alloc
== 0)
3057 n_switches_alloc
= 16;
3058 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3060 else if (n_switches_alloc
== n_switches
)
3062 n_switches_alloc
*= 2;
3063 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3067 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3068 as validated if VALIDATED. */
3071 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3075 switches
[n_switches
].part1
= opt
+ 1;
3077 switches
[n_switches
].args
= 0;
3080 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3081 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3082 switches
[n_switches
].args
[n_args
] = NULL
;
3085 switches
[n_switches
].live_cond
= 0;
3086 switches
[n_switches
].validated
= validated
;
3087 switches
[n_switches
].ordering
= 0;
3091 /* Handle an option DECODED that is unknown to the option-processing
3092 machinery, but may be known to specs. */
3095 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3097 save_switch (decoded
->canonical_option
[0],
3098 decoded
->canonical_option_num_elements
- 1,
3099 &decoded
->canonical_option
[1], false);
3104 /* Handle an option DECODED that is not marked as CL_DRIVER.
3105 LANG_MASK will always be CL_DRIVER. */
3108 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3109 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3111 /* At this point, non-driver options are accepted (and expected to
3112 be passed down by specs) unless marked to be rejected by the
3113 driver. Options to be rejected by the driver but accepted by the
3114 compilers proper are treated just like completely unknown
3116 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3118 if (option
->flags
& CL_REJECT_DRIVER
)
3119 error ("unrecognized command line option %qs",
3120 decoded
->orig_option_with_args_text
);
3122 driver_unknown_option_callback (decoded
);
3125 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3126 has been successfully handled with a handler for mask MASK. */
3129 driver_post_handling_callback (const struct cl_decoded_option
*decoded ATTRIBUTE_UNUSED
,
3130 unsigned int mask ATTRIBUTE_UNUSED
)
3132 /* Nothing to do here. */
3135 static const char *spec_lang
= 0;
3136 static int last_language_n_infiles
;
3138 /* Handle a driver option; arguments and return value as for
3142 driver_handle_option (const struct cl_decoded_option
*decoded
,
3143 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3144 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
)
3146 size_t opt_index
= decoded
->opt_index
;
3147 const char *arg
= decoded
->arg
;
3148 const char *compare_debug_replacement_opt
;
3149 int value
= decoded
->value
;
3150 bool validated
= false;
3151 bool do_save
= true;
3153 gcc_assert (kind
== DK_UNSPECIFIED
);
3159 struct spec_list
*sl
;
3161 for (sl
= specs
; sl
; sl
= sl
->next
)
3162 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3163 if (link_command_spec
)
3164 printf ("*link_command:\n%s\n\n", link_command_spec
);
3168 case OPT_dumpversion
:
3169 printf ("%s\n", spec_version
);
3172 case OPT_dumpmachine
:
3173 printf ("%s\n", spec_machine
);
3179 /* CPP driver cannot obtain switch from cc1_options. */
3181 add_preprocessor_option ("--version", strlen ("--version"));
3182 add_assembler_option ("--version", strlen ("--version"));
3183 add_linker_option ("--version", strlen ("--version"));
3187 print_help_list
= 1;
3189 /* CPP driver cannot obtain switch from cc1_options. */
3191 add_preprocessor_option ("--help", 6);
3192 add_assembler_option ("--help", 6);
3193 add_linker_option ("--help", 6);
3197 print_subprocess_help
= 2;
3200 case OPT__target_help
:
3201 print_subprocess_help
= 1;
3203 /* CPP driver cannot obtain switch from cc1_options. */
3205 add_preprocessor_option ("--target-help", 13);
3206 add_assembler_option ("--target-help", 13);
3207 add_linker_option ("--target-help", 13);
3210 case OPT_pass_exit_codes
:
3211 case OPT_print_search_dirs
:
3212 case OPT_print_file_name_
:
3213 case OPT_print_prog_name_
:
3214 case OPT_print_multi_lib
:
3215 case OPT_print_multi_directory
:
3216 case OPT_print_sysroot
:
3217 case OPT_print_multi_os_directory
:
3218 case OPT_print_sysroot_headers_suffix
:
3221 /* These options set the variables specified in common.opt
3222 automatically, and do not need to be saved for spec
3227 case OPT_print_libgcc_file_name
:
3228 print_file_name
= "libgcc.a";
3232 case OPT_fcompare_debug_second
:
3233 compare_debug_second
= 1;
3236 case OPT_fcompare_debug
:
3240 compare_debug_replacement_opt
= "-fcompare-debug=";
3242 goto compare_debug_with_arg
;
3245 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3247 goto compare_debug_with_arg
;
3254 case OPT_fcompare_debug_
:
3255 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3256 compare_debug_with_arg
:
3257 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3258 gcc_assert (arg
!= NULL
);
3263 if (compare_debug
< 0)
3264 compare_debug_opt
= NULL
;
3266 compare_debug_opt
= arg
;
3267 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
);
3273 /* Pass the rest of this option to the assembler. */
3275 /* Split the argument at commas. */
3277 for (j
= 0; arg
[j
]; j
++)
3280 add_assembler_option (arg
+ prev
, j
- prev
);
3284 /* Record the part after the last comma. */
3285 add_assembler_option (arg
+ prev
, j
- prev
);
3293 /* Pass the rest of this option to the preprocessor. */
3295 /* Split the argument at commas. */
3297 for (j
= 0; arg
[j
]; j
++)
3300 add_preprocessor_option (arg
+ prev
, j
- prev
);
3304 /* Record the part after the last comma. */
3305 add_preprocessor_option (arg
+ prev
, j
- prev
);
3313 /* Split the argument at commas. */
3315 for (j
= 0; arg
[j
]; j
++)
3318 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3321 /* Record the part after the last comma. */
3322 add_infile (arg
+ prev
, "*");
3328 add_infile (arg
, "*");
3332 case OPT_Xpreprocessor
:
3333 add_preprocessor_option (arg
, strlen (arg
));
3337 case OPT_Xassembler
:
3338 add_assembler_option (arg
, strlen (arg
));
3343 /* POSIX allows separation of -l and the lib arg; canonicalize
3344 by concatenating -l with its arg */
3345 add_infile (concat ("-l", arg
, NULL
), "*");
3350 /* Similarly, canonicalize -L for linkers that may not accept
3351 separate arguments. */
3352 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
);
3355 case OPT_save_temps
:
3356 save_temps_flag
= SAVE_TEMPS_CWD
;
3360 case OPT_save_temps_
:
3361 if (strcmp (arg
, "cwd") == 0)
3362 save_temps_flag
= SAVE_TEMPS_CWD
;
3363 else if (strcmp (arg
, "obj") == 0
3364 || strcmp (arg
, "object") == 0)
3365 save_temps_flag
= SAVE_TEMPS_OBJ
;
3367 fatal_error ("%qs is an unknown -save-temps option",
3368 decoded
->orig_option_with_args_text
);
3371 case OPT_no_canonical_prefixes
:
3372 /* Already handled as a special case, so ignored here. */
3378 /* These options set the variables specified in common.opt
3379 automatically, but do need to be saved for spec
3385 struct user_specs
*user
= XNEW (struct user_specs
);
3387 user
->next
= (struct user_specs
*) 0;
3388 user
->filename
= arg
;
3389 if (user_specs_tail
)
3390 user_specs_tail
->next
= user
;
3392 user_specs_head
= user
;
3393 user_specs_tail
= user
;
3399 target_system_root
= arg
;
3400 target_system_root_changed
= 1;
3405 if (report_times_to_file
)
3406 fclose (report_times_to_file
);
3407 report_times_to_file
= fopen (arg
, "a");
3413 This is similar to -v except that there is no execution
3414 of the commands and the echoed arguments are quoted. It
3415 is intended for use in shell scripts to capture the
3416 driver-generated command line. */
3417 verbose_only_flag
++;
3424 size_t len
= strlen (arg
);
3426 /* Catch the case where the user has forgotten to append a
3427 directory separator to the path. Note, they may be using
3428 -B to add an executable name prefix, eg "i386-elf-", in
3429 order to distinguish between multiple installations of
3430 GCC in the same directory. Hence we must check to see
3431 if appending a directory separator actually makes a
3432 valid directory name. */
3433 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3434 && is_directory (arg
, false))
3436 char *tmp
= XNEWVEC (char, len
+ 2);
3438 tmp
[len
] = DIR_SEPARATOR
;
3443 add_prefix (&exec_prefixes
, arg
, NULL
,
3444 PREFIX_PRIORITY_B_OPT
, 0, 0);
3445 add_prefix (&startfile_prefixes
, arg
, NULL
,
3446 PREFIX_PRIORITY_B_OPT
, 0, 0);
3447 add_prefix (&include_prefixes
, arg
, NULL
,
3448 PREFIX_PRIORITY_B_OPT
, 0, 0);
3453 case OPT_v
: /* Print our subcommands and print versions. */
3459 if (!strcmp (spec_lang
, "none"))
3460 /* Suppress the warning if -xnone comes after the last input
3461 file, because alternate command interfaces like g++ might
3462 find it useful to place -xnone after each input file. */
3465 last_language_n_infiles
= n_infiles
;
3471 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3472 arg
= convert_filename (arg
, ! have_c
, 0);
3474 /* Save the output name in case -save-temps=obj was used. */
3475 save_temps_prefix
= xstrdup (arg
);
3476 /* On some systems, ld cannot handle "-o" without a space. So
3477 split the option from its argument. */
3478 save_switch ("-o", 1, &arg
, validated
);
3481 case OPT_static_libgcc
:
3482 case OPT_shared_libgcc
:
3483 case OPT_static_libgfortran
:
3484 case OPT_static_libstdc__
:
3485 /* These are always valid, since gcc.c itself understands the
3486 first two, gfortranspec.c understands -static-libgfortran and
3487 g++spec.c understands -static-libstdc++ */
3492 /* Various driver options need no special processing at this
3493 point, having been handled in a prescan above or being
3494 handled by specs. */
3499 save_switch (decoded
->canonical_option
[0],
3500 decoded
->canonical_option_num_elements
- 1,
3501 &decoded
->canonical_option
[1], validated
);
3505 /* Create the vector `switches' and its contents.
3506 Store its length in `n_switches'. */
3509 process_command (int argc
, const char **argv
)
3513 const char *tooldir_prefix
;
3514 char *(*get_relative_prefix
) (const char *, const char *,
3515 const char *) = NULL
;
3516 struct cl_option_handlers handlers
;
3517 struct cl_decoded_option
*decoded_options
;
3518 unsigned int decoded_options_count
, j
;
3520 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3524 added_libraries
= 0;
3526 /* Figure compiler version from version string. */
3528 compiler_version
= temp1
= xstrdup (version_string
);
3530 for (; *temp1
; ++temp1
)
3539 decode_cmdline_options_to_array (argc
, argv
, CL_DRIVER
,
3540 &decoded_options
, &decoded_options_count
);
3542 /* Handle any -no-canonical-prefixes flag early, to assign the function
3543 that builds relative prefixes. This function creates default search
3544 paths that are needed later in normal option handling. */
3546 for (j
= 1; j
< decoded_options_count
; j
++)
3548 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
3550 get_relative_prefix
= make_relative_prefix_ignore_links
;
3554 if (! get_relative_prefix
)
3555 get_relative_prefix
= make_relative_prefix
;
3557 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3558 see if we can create it from the pathname specified in argv[0]. */
3560 gcc_libexec_prefix
= standard_libexec_prefix
;
3562 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3563 if (!gcc_exec_prefix
)
3565 gcc_exec_prefix
= get_relative_prefix (argv
[0],
3566 standard_bindir_prefix
,
3567 standard_exec_prefix
);
3568 gcc_libexec_prefix
= get_relative_prefix (argv
[0],
3569 standard_bindir_prefix
,
3570 standard_libexec_prefix
);
3571 if (gcc_exec_prefix
)
3572 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3576 /* make_relative_prefix requires a program name, but
3577 GCC_EXEC_PREFIX is typically a directory name with a trailing
3578 / (which is ignored by make_relative_prefix), so append a
3580 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3581 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3582 standard_exec_prefix
,
3583 standard_libexec_prefix
);
3585 /* The path is unrelocated, so fallback to the original setting. */
3586 if (!gcc_libexec_prefix
)
3587 gcc_libexec_prefix
= standard_libexec_prefix
;
3593 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3594 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3595 or an automatically created GCC_EXEC_PREFIX from argv[0]. */
3597 /* Do language-specific adjustment/addition of flags. */
3598 lang_specific_driver (&decoded_options
, &decoded_options_count
,
3601 if (gcc_exec_prefix
)
3603 int len
= strlen (gcc_exec_prefix
);
3605 if (len
> (int) sizeof ("/lib/gcc/") - 1
3606 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3608 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3609 if (IS_DIR_SEPARATOR (*temp
)
3610 && strncmp (temp
+ 1, "lib", 3) == 0
3611 && IS_DIR_SEPARATOR (temp
[4])
3612 && strncmp (temp
+ 5, "gcc", 3) == 0)
3613 len
-= sizeof ("/lib/gcc/") - 1;
3616 set_std_prefix (gcc_exec_prefix
, len
);
3617 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3618 PREFIX_PRIORITY_LAST
, 0, 0);
3619 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3620 PREFIX_PRIORITY_LAST
, 0, 0);
3623 /* COMPILER_PATH and LIBRARY_PATH have values
3624 that are lists of directory names with colons. */
3626 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3629 const char *startp
, *endp
;
3630 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3632 startp
= endp
= temp
;
3635 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3637 strncpy (nstore
, startp
, endp
- startp
);
3639 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3640 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3642 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3643 nstore
[endp
- startp
+ 1] = 0;
3646 nstore
[endp
- startp
] = 0;
3647 add_prefix (&exec_prefixes
, nstore
, 0,
3648 PREFIX_PRIORITY_LAST
, 0, 0);
3649 add_prefix (&include_prefixes
, nstore
, 0,
3650 PREFIX_PRIORITY_LAST
, 0, 0);
3653 endp
= startp
= endp
+ 1;
3660 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3661 if (temp
&& *cross_compile
== '0')
3663 const char *startp
, *endp
;
3664 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3666 startp
= endp
= temp
;
3669 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3671 strncpy (nstore
, startp
, endp
- startp
);
3673 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3674 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3676 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3677 nstore
[endp
- startp
+ 1] = 0;
3680 nstore
[endp
- startp
] = 0;
3681 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3682 PREFIX_PRIORITY_LAST
, 0, 1);
3685 endp
= startp
= endp
+ 1;
3692 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3693 GET_ENVIRONMENT (temp
, "LPATH");
3694 if (temp
&& *cross_compile
== '0')
3696 const char *startp
, *endp
;
3697 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3699 startp
= endp
= temp
;
3702 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3704 strncpy (nstore
, startp
, endp
- startp
);
3706 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3707 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3709 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3710 nstore
[endp
- startp
+ 1] = 0;
3713 nstore
[endp
- startp
] = 0;
3714 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3715 PREFIX_PRIORITY_LAST
, 0, 1);
3718 endp
= startp
= endp
+ 1;
3725 /* Process the options and store input files and switches in their
3728 last_language_n_infiles
= -1;
3730 handlers
.unknown_option_callback
= driver_unknown_option_callback
;
3731 handlers
.wrong_lang_callback
= driver_wrong_lang_callback
;
3732 handlers
.post_handling_callback
= driver_post_handling_callback
;
3733 handlers
.num_handlers
= 1;
3734 handlers
.handlers
[0].handler
= driver_handle_option
;
3735 handlers
.handlers
[0].mask
= CL_DRIVER
;
3737 for (j
= 1; j
< decoded_options_count
; j
++)
3739 switch (decoded_options
[j
].opt_index
)
3751 for (j
= 1; j
< decoded_options_count
; j
++)
3753 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
3755 const char *arg
= decoded_options
[j
].arg
;
3756 const char *p
= strrchr (arg
, '@');
3760 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3761 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
3763 /* For LTO static archive support we handle input file
3764 specifications that are composed of a filename and
3765 an offset like FNAME@OFFSET. */
3768 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
3769 && strlen (p
) == (unsigned int)consumed
)
3771 fname
= (char *)xmalloc (p
- arg
+ 1);
3772 memcpy (fname
, arg
, p
- arg
);
3773 fname
[p
- arg
] = '\0';
3774 /* Only accept non-stdin and existing FNAME parts, otherwise
3775 try with the full name. */
3776 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
3779 fname
= xstrdup (arg
);
3783 fname
= xstrdup (arg
);
3785 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
3786 perror_with_name (fname
);
3788 add_infile (arg
, spec_lang
);
3794 read_cmdline_option (decoded_options
+ j
, CL_DRIVER
, &handlers
);
3797 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3798 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3799 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
3801 save_temps_length
= strlen (save_temps_prefix
);
3802 temp
= strrchr (lbasename (save_temps_prefix
), '.');
3805 save_temps_length
-= strlen (temp
);
3806 save_temps_prefix
[save_temps_length
] = '\0';
3810 else if (save_temps_prefix
!= NULL
)
3812 free (save_temps_prefix
);
3813 save_temps_prefix
= NULL
;
3816 if (save_temps_flag
&& use_pipes
)
3818 /* -save-temps overrides -pipe, so that temp files are produced */
3819 if (save_temps_flag
)
3820 warning (0, "-pipe ignored because -save-temps specified");
3826 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
3828 if (gcd
&& gcd
[0] == '-')
3831 compare_debug_opt
= gcd
;
3833 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
3836 compare_debug_opt
= "-gtoggle";
3839 else if (compare_debug
< 0)
3842 gcc_assert (!compare_debug_opt
);
3845 /* Set up the search paths. We add directories that we expect to
3846 contain GNU Toolchain components before directories specified by
3847 the machine description so that we will find GNU components (like
3848 the GNU assembler) before those of the host system. */
3850 /* If we don't know where the toolchain has been installed, use the
3851 configured-in locations. */
3852 if (!gcc_exec_prefix
)
3855 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
3856 PREFIX_PRIORITY_LAST
, 1, 0);
3857 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
3858 PREFIX_PRIORITY_LAST
, 2, 0);
3859 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3860 PREFIX_PRIORITY_LAST
, 2, 0);
3862 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3863 PREFIX_PRIORITY_LAST
, 1, 0);
3866 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
3867 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
3868 dir_separator_str
, NULL
);
3870 /* Look for tools relative to the location from which the driver is
3871 running, or, if that is not available, the configured prefix. */
3873 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
3874 spec_machine
, dir_separator_str
,
3875 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
3877 add_prefix (&exec_prefixes
,
3878 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
3879 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
3880 add_prefix (&startfile_prefixes
,
3881 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
3882 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
3884 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3885 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3886 then consider it to relocate with the rest of the GCC installation
3887 if GCC_EXEC_PREFIX is set.
3888 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3889 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
3891 char *tmp_prefix
= get_relative_prefix (argv
[0],
3892 standard_bindir_prefix
,
3893 target_system_root
);
3894 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
3896 target_system_root
= tmp_prefix
;
3897 target_system_root_changed
= 1;
3902 /* More prefixes are enabled in main, after we read the specs file
3903 and determine whether this is cross-compilation or not. */
3905 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
3906 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
3908 if (compare_debug
== 2 || compare_debug
== 3)
3911 switches
[n_switches
].part1
= concat ("fcompare-debug=",
3914 switches
[n_switches
].args
= 0;
3915 switches
[n_switches
].live_cond
= 0;
3916 switches
[n_switches
].validated
= 0;
3917 switches
[n_switches
].ordering
= 0;
3922 /* Ensure we only invoke each subprocess once. */
3923 if (print_subprocess_help
|| print_help_list
|| print_version
)
3927 /* Create a dummy input file, so that we can pass
3928 the help option on to the various sub-processes. */
3929 add_infile ("help-dummy", "c");
3933 switches
[n_switches
].part1
= 0;
3935 infiles
[n_infiles
].name
= 0;
3938 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
3939 and place that in the environment. */
3942 set_collect_gcc_options (void)
3947 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3949 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
3950 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
3953 for (i
= 0; (int) i
< n_switches
; i
++)
3955 const char *const *args
;
3958 obstack_grow (&collect_obstack
, " ", 1);
3962 /* Ignore elided switches. */
3963 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) != 0)
3966 obstack_grow (&collect_obstack
, "'-", 2);
3967 q
= switches
[i
].part1
;
3968 while ((p
= strchr (q
, '\'')))
3970 obstack_grow (&collect_obstack
, q
, p
- q
);
3971 obstack_grow (&collect_obstack
, "'\\''", 4);
3974 obstack_grow (&collect_obstack
, q
, strlen (q
));
3975 obstack_grow (&collect_obstack
, "'", 1);
3977 for (args
= switches
[i
].args
; args
&& *args
; args
++)
3979 obstack_grow (&collect_obstack
, " '", 2);
3981 while ((p
= strchr (q
, '\'')))
3983 obstack_grow (&collect_obstack
, q
, p
- q
);
3984 obstack_grow (&collect_obstack
, "'\\''", 4);
3987 obstack_grow (&collect_obstack
, q
, strlen (q
));
3988 obstack_grow (&collect_obstack
, "'", 1);
3991 obstack_grow (&collect_obstack
, "\0", 1);
3992 xputenv (XOBFINISH (&collect_obstack
, char *));
3995 /* Process a spec string, accumulating and running commands. */
3997 /* These variables describe the input file name.
3998 input_file_number is the index on outfiles of this file,
3999 so that the output file name can be stored for later use by %o.
4000 input_basename is the start of the part of the input file
4001 sans all directory names, and basename_length is the number
4002 of characters starting there excluding the suffix .c or whatever. */
4004 static const char *gcc_input_filename
;
4005 static int input_file_number
;
4006 size_t input_filename_length
;
4007 static int basename_length
;
4008 static int suffixed_basename_length
;
4009 static const char *input_basename
;
4010 static const char *input_suffix
;
4011 #ifndef HOST_LACKS_INODE_NUMBERS
4012 static struct stat input_stat
;
4014 static int input_stat_set
;
4016 /* The compiler used to process the current input file. */
4017 static struct compiler
*input_file_compiler
;
4019 /* These are variables used within do_spec and do_spec_1. */
4021 /* Nonzero if an arg has been started and not yet terminated
4022 (with space, tab or newline). */
4023 static int arg_going
;
4025 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4026 is a temporary file name. */
4027 static int delete_this_arg
;
4029 /* Nonzero means %w has been seen; the next arg to be terminated
4030 is the output file name of this compilation. */
4031 static int this_is_output_file
;
4033 /* Nonzero means %s has been seen; the next arg to be terminated
4034 is the name of a library file and we should try the standard
4035 search dirs for it. */
4036 static int this_is_library_file
;
4038 /* Nonzero means %T has been seen; the next arg to be terminated
4039 is the name of a linker script and we should try all of the
4040 standard search dirs for it. If it is found insert a --script
4041 command line switch and then substitute the full path in place,
4042 otherwise generate an error message. */
4043 static int this_is_linker_script
;
4045 /* Nonzero means that the input of this command is coming from a pipe. */
4046 static int input_from_pipe
;
4048 /* Nonnull means substitute this for any suffix when outputting a switches
4050 static const char *suffix_subst
;
4052 /* If there is an argument being accumulated, terminate it and store it. */
4055 end_going_arg (void)
4061 obstack_1grow (&obstack
, 0);
4062 string
= XOBFINISH (&obstack
, const char *);
4063 if (this_is_library_file
)
4064 string
= find_file (string
);
4065 if (this_is_linker_script
)
4067 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4069 if (full_script_path
== NULL
)
4071 error ("unable to locate default linker script %qs in the library search paths", string
);
4072 /* Script was not found on search path. */
4075 store_arg ("--script", false, false);
4076 string
= full_script_path
;
4078 store_arg (string
, delete_this_arg
, this_is_output_file
);
4079 if (this_is_output_file
)
4080 outfiles
[input_file_number
] = string
;
4086 /* Parse the WRAPPER string which is a comma separated list of the command line
4087 and insert them into the beginning of argbuf. */
4090 insert_wrapper (const char *wrapper
)
4094 char *buf
= xstrdup (wrapper
);
4103 while ((p
= strchr (p
, ',')) != NULL
);
4105 if (argbuf_index
+ n
>= argbuf_length
)
4107 argbuf_length
= argbuf_length
* 2;
4108 while (argbuf_length
< argbuf_index
+ n
)
4110 argbuf
= XRESIZEVEC (const char *, argbuf
, argbuf_length
);
4112 for (i
= argbuf_index
- 1; i
>= 0; i
--)
4113 argbuf
[i
+ n
] = argbuf
[i
];
4126 while ((p
= strchr (p
, ',')) != NULL
);
4127 gcc_assert (i
== n
);
4131 /* Process the spec SPEC and run the commands specified therein.
4132 Returns 0 if the spec is successfully processed; -1 if failed. */
4135 do_spec (const char *spec
)
4139 value
= do_spec_2 (spec
);
4141 /* Force out any unfinished command.
4142 If -pipe, this forces out the last command if it ended in `|'. */
4145 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4148 set_collect_gcc_options ();
4150 if (argbuf_index
> 0)
4158 do_spec_2 (const char *spec
)
4164 delete_this_arg
= 0;
4165 this_is_output_file
= 0;
4166 this_is_library_file
= 0;
4167 this_is_linker_script
= 0;
4168 input_from_pipe
= 0;
4169 suffix_subst
= NULL
;
4171 result
= do_spec_1 (spec
, 0, NULL
);
4179 /* Process the given spec string and add any new options to the end
4180 of the switches/n_switches array. */
4183 do_option_spec (const char *name
, const char *spec
)
4185 unsigned int i
, value_count
, value_len
;
4186 const char *p
, *q
, *value
;
4187 char *tmp_spec
, *tmp_spec_p
;
4189 if (configure_default_options
[0].name
== NULL
)
4192 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4193 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4195 if (i
== ARRAY_SIZE (configure_default_options
))
4198 value
= configure_default_options
[i
].value
;
4199 value_len
= strlen (value
);
4201 /* Compute the size of the final spec. */
4204 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4210 /* Replace each %(VALUE) by the specified value. */
4211 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4212 + value_count
* (value_len
- strlen ("%(VALUE)")));
4213 tmp_spec_p
= tmp_spec
;
4215 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4217 memcpy (tmp_spec_p
, q
, p
- q
);
4218 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4219 memcpy (tmp_spec_p
, value
, value_len
);
4220 tmp_spec_p
+= value_len
;
4221 q
= p
+ strlen ("%(VALUE)");
4223 strcpy (tmp_spec_p
, q
);
4225 do_self_spec (tmp_spec
);
4228 /* Process the given spec string and add any new options to the end
4229 of the switches/n_switches array. */
4232 do_self_spec (const char *spec
)
4237 do_spec_1 (" ", 0, NULL
);
4239 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4240 do_self_specs adds the replacements to switches array, so it shouldn't
4241 be processed afterwards. */
4242 for (i
= 0; i
< n_switches
; i
++)
4243 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4244 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4246 if (argbuf_index
> 0)
4248 switches
= XRESIZEVEC (struct switchstr
, switches
,
4249 n_switches
+ argbuf_index
+ 1);
4251 for (i
= 0; i
< argbuf_index
; i
++)
4253 struct switchstr
*sw
;
4254 const char *p
= argbuf
[i
];
4257 /* Each switch should start with '-'. */
4259 fatal_error ("switch %qs does not start with %<-%>", argbuf
[i
]);
4264 sw
= &switches
[n_switches
++];
4270 /* Deal with option arguments in separate argv elements. */
4271 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4272 || WORD_SWITCH_TAKES_ARG (p
))
4275 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4279 /* Count only the option arguments in separate argv elements. */
4280 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4282 if (i
+ n_args
>= argbuf_index
)
4283 fatal_error ("argument to %<-%s%> is missing", p
);
4285 = XNEWVEC (const char *, n_args
+ 1);
4287 sw
->args
[j
++] = argbuf
[++i
];
4288 /* Null-terminate the vector. */
4293 /* On some systems, ld cannot handle "-o" without
4294 a space. So split the option from its argument. */
4295 char *part1
= XNEWVEC (char, 2);
4300 sw
->args
= XNEWVEC (const char *, 2);
4301 sw
->args
[0] = xstrdup (p
+1);
4308 switches
[n_switches
].part1
= 0;
4312 /* Callback for processing %D and %I specs. */
4314 struct spec_path_info
{
4319 bool separate_options
;
4323 spec_path (char *path
, void *data
)
4325 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4329 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4332 if (info
->append_len
!= 0)
4334 len
= strlen (path
);
4335 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4338 if (!is_directory (path
, true))
4341 do_spec_1 (info
->option
, 1, NULL
);
4342 if (info
->separate_options
)
4343 do_spec_1 (" ", 0, NULL
);
4345 if (info
->append_len
== 0)
4347 len
= strlen (path
);
4348 save
= path
[len
- 1];
4349 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4350 path
[len
- 1] = '\0';
4353 do_spec_1 (path
, 1, NULL
);
4354 do_spec_1 (" ", 0, NULL
);
4356 /* Must not damage the original path. */
4357 if (info
->append_len
== 0)
4358 path
[len
- 1] = save
;
4363 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4367 create_at_file (char **argv
)
4369 char *temp_file
= make_temp_file ("");
4370 char *at_argument
= concat ("@", temp_file
, NULL
);
4371 FILE *f
= fopen (temp_file
, "w");
4375 fatal_error ("could not open temporary response file %s",
4378 status
= writeargv (argv
, f
);
4381 fatal_error ("could not write to temporary response file %s",
4384 status
= fclose (f
);
4387 fatal_error ("could not close temporary response file %s",
4390 store_arg (at_argument
, 0, 0);
4392 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4395 /* True if we should compile INFILE. */
4398 compile_input_file_p (struct infile
*infile
)
4400 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4401 if (infile
->incompiler
== input_file_compiler
)
4406 /* Process the sub-spec SPEC as a portion of a larger spec.
4407 This is like processing a whole spec except that we do
4408 not initialize at the beginning and we do not supply a
4409 newline by default at the end.
4410 INSWITCH nonzero means don't process %-sequences in SPEC;
4411 in this case, % is treated as an ordinary character.
4412 This is used while substituting switches.
4413 INSWITCH nonzero also causes SPC not to terminate an argument.
4415 Value is zero unless a line was finished
4416 and the command on that line reported an error. */
4419 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4421 const char *p
= spec
;
4427 /* If substituting a switch, treat all chars like letters.
4428 Otherwise, NL, SPC, TAB and % are special. */
4429 switch (inswitch
? 'a' : c
)
4434 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4436 /* A `|' before the newline means use a pipe here,
4437 but only if -pipe was specified.
4438 Otherwise, execute now and don't pass the `|' as an arg. */
4441 input_from_pipe
= 1;
4448 set_collect_gcc_options ();
4450 if (argbuf_index
> 0)
4456 /* Reinitialize for a new command, and for a new argument. */
4459 delete_this_arg
= 0;
4460 this_is_output_file
= 0;
4461 this_is_library_file
= 0;
4462 this_is_linker_script
= 0;
4463 input_from_pipe
= 0;
4470 obstack_1grow (&obstack
, c
);
4478 /* Reinitialize for a new argument. */
4479 delete_this_arg
= 0;
4480 this_is_output_file
= 0;
4481 this_is_library_file
= 0;
4482 this_is_linker_script
= 0;
4489 fatal_error ("spec %qs invalid", spec
);
4492 if (save_temps_length
)
4493 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4495 obstack_grow (&obstack
, input_basename
, basename_length
);
4496 if (compare_debug
< 0)
4497 obstack_grow (&obstack
, ".gk", 3);
4502 if (save_temps_length
)
4503 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4505 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4506 if (compare_debug
< 0)
4507 obstack_grow (&obstack
, ".gk", 3);
4512 delete_this_arg
= 2;
4515 /* Dump out the directories specified with LIBRARY_PATH,
4516 followed by the absolute directories
4517 that we search for startfiles. */
4520 struct spec_path_info info
;
4523 info
.append_len
= 0;
4524 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4525 /* Used on systems which record the specified -L dirs
4526 and use them to search for dynamic linking.
4527 Relative directories always come from -B,
4528 and it is better not to use them for searching
4529 at run time. In particular, stage1 loses. */
4530 info
.omit_relative
= true;
4532 info
.omit_relative
= false;
4534 info
.separate_options
= false;
4536 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4541 /* %efoo means report an error with `foo' as error message
4542 and don't execute any more commands for this file. */
4546 while (*p
!= 0 && *p
!= '\n')
4548 buf
= (char *) alloca (p
- q
+ 1);
4549 strncpy (buf
, q
, p
- q
);
4551 error ("%s", _(buf
));
4556 /* %nfoo means report a notice with `foo' on stderr. */
4560 while (*p
!= 0 && *p
!= '\n')
4562 buf
= (char *) alloca (p
- q
+ 1);
4563 strncpy (buf
, q
, p
- q
);
4565 inform (0, "%s", _(buf
));
4575 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4576 defined, and it is not a directory, and it is
4577 writable, use it. Otherwise, treat this like any
4578 other temporary file. */
4580 if ((!save_temps_flag
)
4581 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4582 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4584 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4585 strlen (HOST_BIT_BUCKET
));
4586 delete_this_arg
= 0;
4591 goto create_temp_file
;
4595 obstack_1grow (&obstack
, '-');
4596 delete_this_arg
= 0;
4599 /* consume suffix */
4600 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4602 if (p
[0] == '%' && p
[1] == 'O')
4607 goto create_temp_file
;
4611 /* consume suffix */
4612 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4614 if (p
[0] == '%' && p
[1] == 'O')
4619 goto create_temp_file
;
4625 struct temp_name
*t
;
4627 const char *suffix
= p
;
4628 char *saved_suffix
= NULL
;
4630 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4632 suffix_length
= p
- suffix
;
4633 if (p
[0] == '%' && p
[1] == 'O')
4636 /* We don't support extra suffix characters after %O. */
4637 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4638 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
4639 if (suffix_length
== 0)
4640 suffix
= TARGET_OBJECT_SUFFIX
;
4644 = XNEWVEC (char, suffix_length
4645 + strlen (TARGET_OBJECT_SUFFIX
));
4646 strncpy (saved_suffix
, suffix
, suffix_length
);
4647 strcpy (saved_suffix
+ suffix_length
,
4648 TARGET_OBJECT_SUFFIX
);
4650 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4653 if (compare_debug
< 0)
4655 suffix
= concat (".gk", suffix
, NULL
);
4659 /* If -save-temps=obj and -o were specified, use that for the
4661 if (save_temps_length
)
4664 temp_filename_length
4665 = save_temps_length
+ suffix_length
+ 1;
4666 tmp
= (char *) alloca (temp_filename_length
);
4667 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
4668 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
4669 tmp
[save_temps_length
+ suffix_length
] = '\0';
4670 temp_filename
= save_string (tmp
,
4671 temp_filename_length
+ 1);
4672 obstack_grow (&obstack
, temp_filename
,
4673 temp_filename_length
);
4675 delete_this_arg
= 0;
4679 /* If the gcc_input_filename has the same suffix specified
4680 for the %g, %u, or %U, and -save-temps is specified,
4681 we could end up using that file as an intermediate
4682 thus clobbering the user's source file (.e.g.,
4683 gcc -save-temps foo.s would clobber foo.s with the
4684 output of cpp0). So check for this condition and
4685 generate a temp file as the intermediate. */
4687 if (save_temps_flag
)
4690 temp_filename_length
= basename_length
+ suffix_length
+ 1;
4691 tmp
= (char *) alloca (temp_filename_length
);
4692 memcpy (tmp
, input_basename
, basename_length
);
4693 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
4694 tmp
[basename_length
+ suffix_length
] = '\0';
4695 temp_filename
= tmp
;
4697 if (strcmp (temp_filename
, gcc_input_filename
) != 0)
4699 #ifndef HOST_LACKS_INODE_NUMBERS
4700 struct stat st_temp
;
4702 /* Note, set_input() resets input_stat_set to 0. */
4703 if (input_stat_set
== 0)
4705 input_stat_set
= stat (gcc_input_filename
,
4707 if (input_stat_set
>= 0)
4711 /* If we have the stat for the gcc_input_filename
4712 and we can do the stat for the temp_filename
4713 then the they could still refer to the same
4714 file if st_dev/st_ino's are the same. */
4715 if (input_stat_set
!= 1
4716 || stat (temp_filename
, &st_temp
) < 0
4717 || input_stat
.st_dev
!= st_temp
.st_dev
4718 || input_stat
.st_ino
!= st_temp
.st_ino
)
4720 /* Just compare canonical pathnames. */
4721 char* input_realname
= lrealpath (gcc_input_filename
);
4722 char* temp_realname
= lrealpath (temp_filename
);
4723 bool files_differ
= strcmp (input_realname
, temp_realname
);
4724 free (input_realname
);
4725 free (temp_realname
);
4729 temp_filename
= save_string (temp_filename
,
4730 temp_filename_length
+ 1);
4731 obstack_grow (&obstack
, temp_filename
,
4732 temp_filename_length
);
4734 delete_this_arg
= 0;
4740 /* See if we already have an association of %g/%u/%U and
4742 for (t
= temp_names
; t
; t
= t
->next
)
4743 if (t
->length
== suffix_length
4744 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4745 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4748 /* Make a new association if needed. %u and %j
4750 if (t
== 0 || c
== 'u' || c
== 'j')
4754 t
= XNEW (struct temp_name
);
4755 t
->next
= temp_names
;
4758 t
->length
= suffix_length
;
4761 t
->suffix
= saved_suffix
;
4762 saved_suffix
= NULL
;
4765 t
->suffix
= save_string (suffix
, suffix_length
);
4766 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4767 temp_filename
= make_temp_file (t
->suffix
);
4768 temp_filename_length
= strlen (temp_filename
);
4769 t
->filename
= temp_filename
;
4770 t
->filename_length
= temp_filename_length
;
4774 free (saved_suffix
);
4776 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4777 delete_this_arg
= 1;
4785 if (at_file_supplied
)
4787 /* We are going to expand `%i' to `@FILE', where FILE
4788 is a newly-created temporary filename. The filenames
4789 that would usually be expanded in place of %o will be
4790 written to the temporary file. */
4795 for (i
= 0; i
< n_infiles
; i
++)
4796 if (compile_input_file_p (&infiles
[i
]))
4799 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
4801 /* Copy the strings over. */
4802 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
4803 if (compile_input_file_p (&infiles
[i
]))
4805 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
4806 infiles
[i
].compiled
= true;
4811 create_at_file (argv
);
4814 for (i
= 0; (int) i
< n_infiles
; i
++)
4815 if (compile_input_file_p (&infiles
[i
]))
4817 store_arg (infiles
[i
].name
, 0, 0);
4818 infiles
[i
].compiled
= true;
4823 obstack_grow (&obstack
, gcc_input_filename
,
4824 input_filename_length
);
4831 struct spec_path_info info
;
4835 do_spec_1 ("-imultilib", 1, NULL
);
4836 /* Make this a separate argument. */
4837 do_spec_1 (" ", 0, NULL
);
4838 do_spec_1 (multilib_dir
, 1, NULL
);
4839 do_spec_1 (" ", 0, NULL
);
4842 if (gcc_exec_prefix
)
4844 do_spec_1 ("-iprefix", 1, NULL
);
4845 /* Make this a separate argument. */
4846 do_spec_1 (" ", 0, NULL
);
4847 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
4848 do_spec_1 (" ", 0, NULL
);
4851 if (target_system_root_changed
||
4852 (target_system_root
&& target_sysroot_hdrs_suffix
))
4854 do_spec_1 ("-isysroot", 1, NULL
);
4855 /* Make this a separate argument. */
4856 do_spec_1 (" ", 0, NULL
);
4857 do_spec_1 (target_system_root
, 1, NULL
);
4858 if (target_sysroot_hdrs_suffix
)
4859 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
4860 do_spec_1 (" ", 0, NULL
);
4863 info
.option
= "-isystem";
4864 info
.append
= "include";
4865 info
.append_len
= strlen (info
.append
);
4866 info
.omit_relative
= false;
4867 info
.separate_options
= true;
4869 for_each_path (&include_prefixes
, false, info
.append_len
,
4872 info
.append
= "include-fixed";
4873 if (*sysroot_hdrs_suffix_spec
)
4874 info
.append
= concat (info
.append
, dir_separator_str
,
4875 multilib_dir
, NULL
);
4876 info
.append_len
= strlen (info
.append
);
4877 for_each_path (&include_prefixes
, false, info
.append_len
,
4884 int max
= n_infiles
;
4885 max
+= lang_specific_extra_outfiles
;
4887 if (HAVE_GNU_LD
&& at_file_supplied
)
4889 /* We are going to expand `%o' to `@FILE', where FILE
4890 is a newly-created temporary filename. The filenames
4891 that would usually be expanded in place of %o will be
4892 written to the temporary file. */
4897 /* Convert OUTFILES into a form suitable for writeargv. */
4899 /* Determine how many are non-NULL. */
4900 for (n_files
= 0, i
= 0; i
< max
; i
++)
4901 n_files
+= outfiles
[i
] != NULL
;
4903 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
4905 /* Copy the strings over. */
4906 for (i
= 0, j
= 0; i
< max
; i
++)
4909 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
4914 create_at_file (argv
);
4917 for (i
= 0; i
< max
; i
++)
4919 store_arg (outfiles
[i
], 0, 0);
4924 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
4929 this_is_library_file
= 1;
4933 this_is_linker_script
= 1;
4937 outfiles
[input_file_number
] = NULL
;
4941 this_is_output_file
= 1;
4946 int cur_index
= argbuf_index
;
4947 /* Handle the {...} following the %W. */
4949 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
4950 p
= handle_braces (p
+ 1);
4954 /* If any args were output, mark the last one for deletion
4956 if (argbuf_index
!= cur_index
)
4957 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
4961 /* %x{OPTION} records OPTION for %X to output. */
4967 /* Skip past the option value and make a copy. */
4969 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
4972 string
= save_string (p1
+ 1, p
- p1
- 2);
4974 /* See if we already recorded this option. */
4975 for (i
= 0; i
< n_linker_options
; i
++)
4976 if (! strcmp (string
, linker_options
[i
]))
4982 /* This option is new; add it. */
4983 add_linker_option (string
, strlen (string
));
4987 /* Dump out the options accumulated previously using %x. */
4989 for (i
= 0; i
< n_linker_options
; i
++)
4991 do_spec_1 (linker_options
[i
], 1, NULL
);
4992 /* Make each accumulated option a separate argument. */
4993 do_spec_1 (" ", 0, NULL
);
4997 /* Dump out the options accumulated previously using -Wa,. */
4999 for (i
= 0; i
< n_assembler_options
; i
++)
5001 do_spec_1 (assembler_options
[i
], 1, NULL
);
5002 /* Make each accumulated option a separate argument. */
5003 do_spec_1 (" ", 0, NULL
);
5007 /* Dump out the options accumulated previously using -Wp,. */
5009 for (i
= 0; i
< n_preprocessor_options
; i
++)
5011 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5012 /* Make each accumulated option a separate argument. */
5013 do_spec_1 (" ", 0, NULL
);
5017 /* Here are digits and numbers that just process
5018 a certain constant string as a spec. */
5021 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5027 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5033 value
= do_spec_1 (asm_spec
, 0, NULL
);
5039 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5046 const char *const spec
5047 = (input_file_compiler
->cpp_spec
5048 ? input_file_compiler
->cpp_spec
5050 value
= do_spec_1 (spec
, 0, NULL
);
5057 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5063 value
= do_spec_1 (link_spec
, 0, NULL
);
5069 value
= do_spec_1 (lib_spec
, 0, NULL
);
5075 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5081 /* We assume there is a directory
5082 separator at the end of this string. */
5083 if (target_system_root
)
5085 obstack_grow (&obstack
, target_system_root
,
5086 strlen (target_system_root
));
5087 if (target_sysroot_suffix
)
5088 obstack_grow (&obstack
, target_sysroot_suffix
,
5089 strlen (target_sysroot_suffix
));
5094 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5099 /* Here we define characters other than letters and digits. */
5102 p
= handle_braces (p
);
5108 p
= handle_spec_function (p
);
5114 obstack_1grow (&obstack
, '%');
5121 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5123 suffix_subst
= save_string (p
- 1, len
+ 1);
5128 /* Henceforth ignore the option(s) matching the pattern
5133 int have_wildcard
= 0;
5136 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5139 if (p
[len
-1] == '*')
5142 for (i
= 0; i
< n_switches
; i
++)
5143 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5144 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5146 switches
[i
].live_cond
|= SWITCH_IGNORE
;
5147 switches
[i
].validated
= 1;
5155 if (soft_matched_part
)
5157 do_spec_1 (soft_matched_part
, 1, NULL
);
5158 do_spec_1 (" ", 0, NULL
);
5161 /* Catch the case where a spec string contains something like
5162 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5163 hand side of the :. */
5164 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5167 /* Process a string found as the value of a spec given by name.
5168 This feature allows individual machine descriptions
5169 to add and use their own specs.
5170 %[...] modifies -D options the way %P does;
5171 %(...) uses the spec unmodified. */
5173 warning (0, "use of obsolete %%[ operator in specs");
5176 const char *name
= p
;
5177 struct spec_list
*sl
;
5180 /* The string after the S/P is the name of a spec that is to be
5182 while (*p
&& *p
!= ')' && *p
!= ']')
5185 /* See if it's in the list. */
5186 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5187 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5189 name
= *(sl
->ptr_spec
);
5191 fnotice (stderr
, "Processing spec %c%s%c, which is '%s'\n",
5192 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5201 value
= do_spec_1 (name
, 0, NULL
);
5207 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
5209 const char *y
= name
;
5212 /* Copy all of NAME into BUF, but put __ after
5213 every -D and at the end of each arg. */
5216 if (! strncmp (y
, "-D", 2))
5227 && (*y
== ' ' || *y
== '\t' || *y
== '='
5228 || *y
== '}' || *y
== 0))
5241 value
= do_spec_1 (buf
, 0, NULL
);
5247 /* Discard the closing paren or bracket. */
5254 error ("spec failure: unrecognized spec option %qc", c
);
5260 /* Backslash: treat next character as ordinary. */
5265 /* Ordinary character: put it into the current argument. */
5266 obstack_1grow (&obstack
, c
);
5270 /* End of string. If we are processing a spec function, we need to
5271 end any pending argument. */
5272 if (processing_spec_function
)
5278 /* Look up a spec function. */
5280 static const struct spec_function
*
5281 lookup_spec_function (const char *name
)
5283 const struct spec_function
*sf
;
5285 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5286 if (strcmp (sf
->name
, name
) == 0)
5292 /* Evaluate a spec function. */
5295 eval_spec_function (const char *func
, const char *args
)
5297 const struct spec_function
*sf
;
5298 const char *funcval
;
5300 /* Saved spec processing context. */
5301 int save_argbuf_index
;
5302 int save_argbuf_length
;
5303 const char **save_argbuf
;
5306 int save_delete_this_arg
;
5307 int save_this_is_output_file
;
5308 int save_this_is_library_file
;
5309 int save_input_from_pipe
;
5310 int save_this_is_linker_script
;
5311 const char *save_suffix_subst
;
5314 sf
= lookup_spec_function (func
);
5316 fatal_error ("unknown spec function %qs", func
);
5318 /* Push the spec processing context. */
5319 save_argbuf_index
= argbuf_index
;
5320 save_argbuf_length
= argbuf_length
;
5321 save_argbuf
= argbuf
;
5323 save_arg_going
= arg_going
;
5324 save_delete_this_arg
= delete_this_arg
;
5325 save_this_is_output_file
= this_is_output_file
;
5326 save_this_is_library_file
= this_is_library_file
;
5327 save_this_is_linker_script
= this_is_linker_script
;
5328 save_input_from_pipe
= input_from_pipe
;
5329 save_suffix_subst
= suffix_subst
;
5331 /* Create a new spec processing context, and build the function
5335 if (do_spec_2 (args
) < 0)
5336 fatal_error ("error in args to spec function %qs", func
);
5338 /* argbuf_index is an index for the next argument to be inserted, and
5339 so contains the count of the args already inserted. */
5341 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5343 /* Pop the spec processing context. */
5344 argbuf_index
= save_argbuf_index
;
5345 argbuf_length
= save_argbuf_length
;
5347 argbuf
= save_argbuf
;
5349 arg_going
= save_arg_going
;
5350 delete_this_arg
= save_delete_this_arg
;
5351 this_is_output_file
= save_this_is_output_file
;
5352 this_is_library_file
= save_this_is_library_file
;
5353 this_is_linker_script
= save_this_is_linker_script
;
5354 input_from_pipe
= save_input_from_pipe
;
5355 suffix_subst
= save_suffix_subst
;
5360 /* Handle a spec function call of the form:
5364 ARGS is processed as a spec in a separate context and split into an
5365 argument vector in the normal fashion. The function returns a string
5366 containing a spec which we then process in the caller's context, or
5367 NULL if no processing is required. */
5370 handle_spec_function (const char *p
)
5373 const char *endp
, *funcval
;
5376 processing_spec_function
++;
5378 /* Get the function name. */
5379 for (endp
= p
; *endp
!= '\0'; endp
++)
5381 if (*endp
== '(') /* ) */
5383 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5384 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5385 fatal_error ("malformed spec function name");
5387 if (*endp
!= '(') /* ) */
5388 fatal_error ("no arguments for spec function");
5389 func
= save_string (p
, endp
- p
);
5392 /* Get the arguments. */
5393 for (count
= 0; *endp
!= '\0'; endp
++)
5402 else if (*endp
== '(') /* ) */
5407 fatal_error ("malformed spec function arguments");
5408 args
= save_string (p
, endp
- p
);
5411 /* p now points to just past the end of the spec function expression. */
5413 funcval
= eval_spec_function (func
, args
);
5414 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5420 processing_spec_function
--;
5425 /* Inline subroutine of handle_braces. Returns true if the current
5426 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5428 input_suffix_matches (const char *atom
, const char *end_atom
)
5430 return (input_suffix
5431 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5432 && input_suffix
[end_atom
- atom
] == '\0');
5435 /* Subroutine of handle_braces. Returns true if the current
5436 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5438 input_spec_matches (const char *atom
, const char *end_atom
)
5440 return (input_file_compiler
5441 && input_file_compiler
->suffix
5442 && input_file_compiler
->suffix
[0] != '\0'
5443 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5445 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5448 /* Subroutine of handle_braces. Returns true if a switch
5449 matching the atom bracketed by ATOM and END_ATOM appeared on the
5452 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5455 int len
= end_atom
- atom
;
5456 int plen
= starred
? len
: -1;
5458 for (i
= 0; i
< n_switches
; i
++)
5459 if (!strncmp (switches
[i
].part1
, atom
, len
)
5460 && (starred
|| switches
[i
].part1
[len
] == '\0')
5461 && check_live_switch (i
, plen
))
5467 /* Inline subroutine of handle_braces. Mark all of the switches which
5468 match ATOM (extends to END_ATOM; STARRED indicates whether there
5469 was a star after the atom) for later processing. */
5471 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5474 int len
= end_atom
- atom
;
5475 int plen
= starred
? len
: -1;
5477 for (i
= 0; i
< n_switches
; i
++)
5478 if (!strncmp (switches
[i
].part1
, atom
, len
)
5479 && (starred
|| switches
[i
].part1
[len
] == '\0')
5480 && check_live_switch (i
, plen
))
5481 switches
[i
].ordering
= 1;
5484 /* Inline subroutine of handle_braces. Process all the currently
5485 marked switches through give_switch, and clear the marks. */
5487 process_marked_switches (void)
5491 for (i
= 0; i
< n_switches
; i
++)
5492 if (switches
[i
].ordering
== 1)
5494 switches
[i
].ordering
= 0;
5499 /* Handle a %{ ... } construct. P points just inside the leading {.
5500 Returns a pointer one past the end of the brace block, or 0
5501 if we call do_spec_1 and that returns -1. */
5504 handle_braces (const char *p
)
5506 const char *atom
, *end_atom
;
5507 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5508 const char *orig
= p
;
5516 bool a_must_be_last
= false;
5517 bool ordered_set
= false;
5518 bool disjunct_set
= false;
5519 bool disj_matched
= false;
5520 bool disj_starred
= true;
5521 bool n_way_choice
= false;
5522 bool n_way_matched
= false;
5524 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5531 /* Scan one "atom" (S in the description above of %{}, possibly
5532 with '!', '.', '@', ',', or '*' modifiers). */
5534 a_is_suffix
= false;
5535 a_is_starred
= false;
5536 a_is_negated
= false;
5537 a_is_spectype
= false;
5541 p
++, a_is_negated
= true;
5545 p
++, a_is_suffix
= true;
5547 p
++, a_is_spectype
= true;
5550 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5551 || *p
== ',' || *p
== '.' || *p
== '@')
5556 p
++, a_is_starred
= 1;
5562 /* Substitute the switch(es) indicated by the current atom. */
5564 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5565 || a_is_spectype
|| atom
== end_atom
)
5568 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5571 process_marked_switches ();
5575 /* Substitute some text if the current atom appears as a switch
5577 disjunct_set
= true;
5581 if (atom
== end_atom
)
5583 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5584 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5588 /* An empty term may appear as the last choice of an
5589 N-way choice set; it means "otherwise". */
5590 a_must_be_last
= true;
5591 disj_matched
= !n_way_matched
;
5592 disj_starred
= false;
5596 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5600 disj_starred
= false;
5602 /* Don't bother testing this atom if we already have a
5604 if (!disj_matched
&& !n_way_matched
)
5607 a_matched
= input_suffix_matches (atom
, end_atom
);
5608 else if (a_is_spectype
)
5609 a_matched
= input_spec_matches (atom
, end_atom
);
5611 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5613 if (a_matched
!= a_is_negated
)
5615 disj_matched
= true;
5617 d_end_atom
= end_atom
;
5624 /* Found the body, that is, the text to substitute if the
5625 current disjunction matches. */
5626 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5627 disj_matched
&& !n_way_matched
);
5631 /* If we have an N-way choice, reset state for the next
5635 n_way_choice
= true;
5636 n_way_matched
|= disj_matched
;
5637 disj_matched
= false;
5638 disj_starred
= true;
5639 d_atom
= d_end_atom
= NULL
;
5648 while (*p
++ != '}');
5653 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
5658 /* Subroutine of handle_braces. Scan and process a brace substitution body
5659 (X in the description of %{} syntax). P points one past the colon;
5660 ATOM and END_ATOM bracket the first atom which was found to be true
5661 (present) in the current disjunction; STARRED indicates whether all
5662 the atoms in the current disjunction were starred (for syntax validation);
5663 MATCHED indicates whether the disjunction matched or not, and therefore
5664 whether or not the body is to be processed through do_spec_1 or just
5665 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5669 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5670 int starred
, int matched
)
5672 const char *body
, *end_body
;
5673 unsigned int nesting_level
;
5674 bool have_subst
= false;
5676 /* Locate the closing } or ;, honoring nested braces.
5677 Trim trailing whitespace. */
5686 if (!--nesting_level
)
5689 else if (*p
== ';' && nesting_level
== 1)
5691 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5693 else if (*p
== '\0')
5699 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5702 if (have_subst
&& !starred
)
5707 /* Copy the substitution body to permanent storage and execute it.
5708 If have_subst is false, this is a simple matter of running the
5709 body through do_spec_1... */
5710 char *string
= save_string (body
, end_body
- body
);
5713 if (do_spec_1 (string
, 0, NULL
) < 0)
5718 /* ... but if have_subst is true, we have to process the
5719 body once for each matching switch, with %* set to the
5720 variant part of the switch. */
5721 unsigned int hard_match_len
= end_atom
- atom
;
5724 for (i
= 0; i
< n_switches
; i
++)
5725 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5726 && check_live_switch (i
, hard_match_len
))
5728 if (do_spec_1 (string
, 0,
5729 &switches
[i
].part1
[hard_match_len
]) < 0)
5731 /* Pass any arguments this switch has. */
5733 suffix_subst
= NULL
;
5741 fatal_error ("braced spec body %qs is invalid", body
);
5744 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5745 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5746 spec, or -1 if either exact match or %* is used.
5748 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5749 whose value does not begin with "no-" is obsoleted by the same value
5750 with the "no-", similarly for a switch with the "no-" prefix. */
5753 check_live_switch (int switchnum
, int prefix_length
)
5755 const char *name
= switches
[switchnum
].part1
;
5758 /* If we already processed this switch and determined if it was
5759 live or not, return our past determination. */
5760 if (switches
[switchnum
].live_cond
!= 0)
5761 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
5762 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
5763 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
5766 /* In the common case of {<at-most-one-letter>*}, a negating
5767 switch would always match, so ignore that case. We will just
5768 send the conflicting switches to the compiler phase. */
5769 if (prefix_length
>= 0 && prefix_length
<= 1)
5772 /* Now search for duplicate in a manner that depends on the name. */
5776 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5777 if (switches
[i
].part1
[0] == 'O')
5779 switches
[switchnum
].validated
= 1;
5780 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5785 case 'W': case 'f': case 'm':
5786 if (! strncmp (name
+ 1, "no-", 3))
5788 /* We have Xno-YYY, search for XYYY. */
5789 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5790 if (switches
[i
].part1
[0] == name
[0]
5791 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5793 switches
[switchnum
].validated
= 1;
5794 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5800 /* We have XYYY, search for Xno-YYY. */
5801 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5802 if (switches
[i
].part1
[0] == name
[0]
5803 && switches
[i
].part1
[1] == 'n'
5804 && switches
[i
].part1
[2] == 'o'
5805 && switches
[i
].part1
[3] == '-'
5806 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5808 switches
[switchnum
].validated
= 1;
5809 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5816 /* Otherwise the switch is live. */
5817 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
5821 /* Pass a switch to the current accumulating command
5822 in the same form that we received it.
5823 SWITCHNUM identifies the switch; it is an index into
5824 the vector of switches gcc received, which is `switches'.
5825 This cannot fail since it never finishes a command line.
5827 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5830 give_switch (int switchnum
, int omit_first_word
)
5832 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
5835 if (!omit_first_word
)
5837 do_spec_1 ("-", 0, NULL
);
5838 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5841 if (switches
[switchnum
].args
!= 0)
5844 for (p
= switches
[switchnum
].args
; *p
; p
++)
5846 const char *arg
= *p
;
5848 do_spec_1 (" ", 0, NULL
);
5851 unsigned length
= strlen (arg
);
5854 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
5855 if (arg
[length
] == '.')
5857 (CONST_CAST(char *, arg
))[length
] = 0;
5861 do_spec_1 (arg
, 1, NULL
);
5863 (CONST_CAST(char *, arg
))[length
] = '.';
5864 do_spec_1 (suffix_subst
, 1, NULL
);
5867 do_spec_1 (arg
, 1, NULL
);
5871 do_spec_1 (" ", 0, NULL
);
5872 switches
[switchnum
].validated
= 1;
5875 /* Search for a file named NAME trying various prefixes including the
5876 user's -B prefix and some standard ones.
5877 Return the absolute file name found. If nothing is found, return NAME. */
5880 find_file (const char *name
)
5882 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
5883 return newname
? newname
: name
;
5886 /* Determine whether a directory exists. If LINKER, return 0 for
5887 certain fixed names not needed by the linker. */
5890 is_directory (const char *path1
, bool linker
)
5897 /* Ensure the string ends with "/.". The resulting path will be a
5898 directory even if the given path is a symbolic link. */
5899 len1
= strlen (path1
);
5900 path
= (char *) alloca (3 + len1
);
5901 memcpy (path
, path1
, len1
);
5903 if (!IS_DIR_SEPARATOR (cp
[-1]))
5904 *cp
++ = DIR_SEPARATOR
;
5908 /* Exclude directories that the linker is known to search. */
5910 && IS_DIR_SEPARATOR (path
[0])
5912 && strncmp (path
+ 1, "lib", 3) == 0)
5914 && strncmp (path
+ 1, "usr", 3) == 0
5915 && IS_DIR_SEPARATOR (path
[4])
5916 && strncmp (path
+ 5, "lib", 3) == 0)))
5919 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
5922 /* Set up the various global variables to indicate that we're processing
5923 the input file named FILENAME. */
5926 set_input (const char *filename
)
5930 gcc_input_filename
= filename
;
5931 input_filename_length
= strlen (gcc_input_filename
);
5932 input_basename
= lbasename (gcc_input_filename
);
5934 /* Find a suffix starting with the last period,
5935 and set basename_length to exclude that suffix. */
5936 basename_length
= strlen (input_basename
);
5937 suffixed_basename_length
= basename_length
;
5938 p
= input_basename
+ basename_length
;
5939 while (p
!= input_basename
&& *p
!= '.')
5941 if (*p
== '.' && p
!= input_basename
)
5943 basename_length
= p
- input_basename
;
5944 input_suffix
= p
+ 1;
5949 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5950 we will need to do a stat on the gcc_input_filename. The
5951 INPUT_STAT_SET signals that the stat is needed. */
5955 /* On fatal signals, delete all the temporary files. */
5958 fatal_signal (int signum
)
5960 signal (signum
, SIG_DFL
);
5961 delete_failure_queue ();
5962 delete_temp_files ();
5963 /* Get the same signal again, this time not handled,
5964 so its normal effect occurs. */
5965 kill (getpid (), signum
);
5968 /* Compare the contents of the two files named CMPFILE[0] and
5969 CMPFILE[1]. Return zero if they're identical, nonzero
5973 compare_files (char *cmpfile
[])
5976 FILE *temp
[2] = { NULL
, NULL
};
5982 void *map
[2] = { NULL
, NULL
};
5984 for (i
= 0; i
< 2; i
++)
5988 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
5990 error ("%s: could not determine length of compare-debug file %s",
5991 gcc_input_filename
, cmpfile
[i
]);
5996 length
[i
] = st
.st_size
;
5999 if (!ret
&& length
[0] != length
[1])
6001 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6006 for (i
= 0; i
< 2; i
++)
6008 int fd
= open (cmpfile
[i
], O_RDONLY
);
6011 error ("%s: could not open compare-debug file %s",
6012 gcc_input_filename
, cmpfile
[i
]);
6017 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6020 if (map
[i
] == (void *) MAP_FAILED
)
6029 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6031 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6036 for (i
= 0; i
< 2; i
++)
6038 munmap ((caddr_t
) map
[i
], length
[i
]);
6047 for (i
= 0; i
< 2; i
++)
6049 temp
[i
] = fopen (cmpfile
[i
], "r");
6052 error ("%s: could not open compare-debug file %s",
6053 gcc_input_filename
, cmpfile
[i
]);
6059 if (!ret
&& temp
[0] && temp
[1])
6063 c0
= fgetc (temp
[0]);
6064 c1
= fgetc (temp
[1]);
6068 error ("%s: -fcompare-debug failure",
6069 gcc_input_filename
);
6078 for (i
= 1; i
>= 0; i
--)
6087 extern int main (int, char **);
6090 main (int argc
, char **argv
)
6094 int linker_was_run
= 0;
6095 int lang_n_infiles
= 0;
6096 int num_linker_inputs
= 0;
6097 char *explicit_link_files
;
6100 struct user_specs
*uptr
;
6101 char **old_argv
= argv
;
6103 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6104 on ?: in file-scope variable initializations. */
6105 asm_debug
= ASM_DEBUG_SPEC
;
6107 p
= argv
[0] + strlen (argv
[0]);
6108 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6112 xmalloc_set_program_name (progname
);
6114 expandargv (&argc
, &argv
);
6116 /* Determine if any expansions were made. */
6117 if (argv
!= old_argv
)
6118 at_file_supplied
= true;
6120 prune_options (&argc
, &argv
);
6122 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6123 /* Perform host dependent initialization when needed. */
6124 GCC_DRIVER_HOST_INITIALIZATION
;
6127 /* Unlock the stdio streams. */
6128 unlock_std_streams ();
6130 gcc_init_libintl ();
6132 diagnostic_initialize (global_dc
, 0);
6133 if (atexit (delete_temp_files
) != 0)
6134 fatal_error ("atexit failed");
6136 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6137 signal (SIGINT
, fatal_signal
);
6139 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6140 signal (SIGHUP
, fatal_signal
);
6142 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6143 signal (SIGTERM
, fatal_signal
);
6145 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6146 signal (SIGPIPE
, fatal_signal
);
6149 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6150 receive the signal. A different setting is inheritable */
6151 signal (SIGCHLD
, SIG_DFL
);
6154 /* Allocate the argument vector. */
6157 obstack_init (&obstack
);
6159 /* Build multilib_select, et. al from the separate lines that make up each
6160 multilib selection. */
6162 const char *const *q
= multilib_raw
;
6165 obstack_init (&multilib_obstack
);
6166 while ((p
= *q
++) != (char *) 0)
6167 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6169 obstack_1grow (&multilib_obstack
, 0);
6170 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6172 q
= multilib_matches_raw
;
6173 while ((p
= *q
++) != (char *) 0)
6174 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6176 obstack_1grow (&multilib_obstack
, 0);
6177 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6179 q
= multilib_exclusions_raw
;
6180 while ((p
= *q
++) != (char *) 0)
6181 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6183 obstack_1grow (&multilib_obstack
, 0);
6184 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6187 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6190 obstack_1grow (&multilib_obstack
, ' ');
6191 obstack_grow (&multilib_obstack
,
6192 multilib_defaults_raw
[i
],
6193 strlen (multilib_defaults_raw
[i
]));
6197 obstack_1grow (&multilib_obstack
, 0);
6198 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6201 #ifdef INIT_ENVIRONMENT
6202 /* Set up any other necessary machine specific environment variables. */
6203 xputenv (INIT_ENVIRONMENT
);
6206 /* Make a table of what switches there are (switches, n_switches).
6207 Make a table of specified input files (infiles, n_infiles).
6208 Decode switches that are handled locally. */
6210 process_command (argc
, CONST_CAST2 (const char **, char **, argv
));
6212 /* Initialize the vector of specs to just the default.
6213 This means one element containing 0s, as a terminator. */
6215 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6216 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6217 n_compilers
= n_default_compilers
;
6219 /* Read specs from a file if there is one. */
6221 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6222 spec_version
, dir_separator_str
, NULL
);
6223 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6225 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6226 /* Read the specs file unless it is a default one. */
6227 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6228 read_specs (specs_file
, TRUE
);
6232 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6233 for any override of as, ld and libraries. */
6234 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6235 + strlen (just_machine_suffix
) + sizeof ("specs"));
6237 strcpy (specs_file
, standard_exec_prefix
);
6238 strcat (specs_file
, just_machine_suffix
);
6239 strcat (specs_file
, "specs");
6240 if (access (specs_file
, R_OK
) == 0)
6241 read_specs (specs_file
, TRUE
);
6243 /* Process any configure-time defaults specified for the command line
6244 options, via OPTION_DEFAULT_SPECS. */
6245 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6246 do_option_spec (option_default_specs
[i
].name
,
6247 option_default_specs
[i
].spec
);
6249 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6250 of the command line. */
6252 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6253 do_self_spec (driver_self_specs
[i
]);
6257 enum save_temps save
;
6259 if (!compare_debug_second
)
6261 n_switches_debug_check
[1] = n_switches
;
6262 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
6265 do_self_spec ("%:compare-debug-self-opt()");
6266 n_switches_debug_check
[0] = n_switches
;
6267 switches_debug_check
[0] = switches
;
6269 n_switches
= n_switches_debug_check
[1];
6270 switches
= switches_debug_check
[1];
6273 /* Avoid crash when computing %j in this early. */
6274 save
= save_temps_flag
;
6275 save_temps_flag
= SAVE_TEMPS_NONE
;
6277 compare_debug
= -compare_debug
;
6278 do_self_spec ("%:compare-debug-self-opt()");
6280 save_temps_flag
= save
;
6282 if (!compare_debug_second
)
6284 n_switches_debug_check
[1] = n_switches
;
6285 switches_debug_check
[1] = switches
;
6286 compare_debug
= -compare_debug
;
6287 n_switches
= n_switches_debug_check
[0];
6288 switches
= switches_debug_check
[0];
6292 /* If not cross-compiling, look for executables in the standard
6294 if (*cross_compile
== '0')
6296 if (*md_exec_prefix
)
6298 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6299 PREFIX_PRIORITY_LAST
, 0, 0);
6303 /* Process sysroot_suffix_spec. */
6304 if (*sysroot_suffix_spec
!= 0
6305 && do_spec_2 (sysroot_suffix_spec
) == 0)
6307 if (argbuf_index
> 1)
6308 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6309 else if (argbuf_index
== 1)
6310 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6313 #ifdef HAVE_LD_SYSROOT
6314 /* Pass the --sysroot option to the linker, if it supports that. If
6315 there is a sysroot_suffix_spec, it has already been processed by
6316 this point, so target_system_root really is the system root we
6318 if (target_system_root
)
6320 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6321 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6322 set_spec ("link", XOBFINISH (&obstack
, const char *));
6326 /* Process sysroot_hdrs_suffix_spec. */
6327 if (*sysroot_hdrs_suffix_spec
!= 0
6328 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6330 if (argbuf_index
> 1)
6331 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6332 else if (argbuf_index
== 1)
6333 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6336 /* Look for startfiles in the standard places. */
6337 if (*startfile_prefix_spec
!= 0
6338 && do_spec_2 (startfile_prefix_spec
) == 0
6339 && do_spec_1 (" ", 0, NULL
) == 0)
6342 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6343 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6344 PREFIX_PRIORITY_LAST
, 0, 1);
6346 /* We should eventually get rid of all these and stick to
6347 startfile_prefix_spec exclusively. */
6348 else if (*cross_compile
== '0' || target_system_root
)
6350 if (*md_startfile_prefix
)
6351 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6352 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6354 if (*md_startfile_prefix_1
)
6355 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6356 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6358 /* If standard_startfile_prefix is relative, base it on
6359 standard_exec_prefix. This lets us move the installed tree
6360 as a unit. If GCC_EXEC_PREFIX is defined, base
6361 standard_startfile_prefix on that as well.
6363 If the prefix is relative, only search it for native compilers;
6364 otherwise we will search a directory containing host libraries. */
6365 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6366 add_sysrooted_prefix (&startfile_prefixes
,
6367 standard_startfile_prefix
, "BINUTILS",
6368 PREFIX_PRIORITY_LAST
, 0, 1);
6369 else if (*cross_compile
== '0')
6371 add_prefix (&startfile_prefixes
,
6372 concat (gcc_exec_prefix
6373 ? gcc_exec_prefix
: standard_exec_prefix
,
6375 standard_startfile_prefix
, NULL
),
6376 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6379 /* Sysrooted prefixes are relocated because target_system_root is
6380 also relocated by gcc_exec_prefix. */
6381 if (*standard_startfile_prefix_1
)
6382 add_sysrooted_prefix (&startfile_prefixes
,
6383 standard_startfile_prefix_1
, "BINUTILS",
6384 PREFIX_PRIORITY_LAST
, 0, 1);
6385 if (*standard_startfile_prefix_2
)
6386 add_sysrooted_prefix (&startfile_prefixes
,
6387 standard_startfile_prefix_2
, "BINUTILS",
6388 PREFIX_PRIORITY_LAST
, 0, 1);
6391 /* Process any user specified specs in the order given on the command
6393 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6395 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6397 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6400 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6401 if (gcc_exec_prefix
)
6402 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6403 spec_version
, dir_separator_str
, NULL
);
6405 /* Now we have the specs.
6406 Set the `valid' bits for switches that match anything in any spec. */
6408 validate_all_switches ();
6410 /* Now that we have the switches and the specs, set
6411 the subdirectory based on the options. */
6412 set_multilib_dir ();
6414 /* Set up to remember the pathname of gcc and any options
6415 needed for collect. We use argv[0] instead of progname because
6416 we need the complete pathname. */
6417 obstack_init (&collect_obstack
);
6418 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6419 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6420 xputenv (XOBFINISH (&collect_obstack
, char *));
6422 /* Set up to remember the pathname of the lto wrapper. */
6424 lto_wrapper_spec
= find_a_file (&exec_prefixes
, "lto-wrapper", X_OK
, false);
6425 if (lto_wrapper_spec
)
6427 obstack_init (&collect_obstack
);
6428 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
6429 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6430 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
6431 strlen (lto_wrapper_spec
) + 1);
6432 xputenv (XOBFINISH (&collect_obstack
, char *));
6435 /* Warn about any switches that no pass was interested in. */
6437 for (i
= 0; (int) i
< n_switches
; i
++)
6438 if (! switches
[i
].validated
)
6439 error ("unrecognized option %<-%s%>", switches
[i
].part1
);
6441 /* Obey some of the options. */
6443 if (print_search_dirs
)
6445 printf (_("install: %s%s\n"),
6446 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6447 gcc_exec_prefix
? "" : machine_suffix
);
6448 printf (_("programs: %s\n"),
6449 build_search_list (&exec_prefixes
, "", false, false));
6450 printf (_("libraries: %s\n"),
6451 build_search_list (&startfile_prefixes
, "", false, true));
6455 if (print_file_name
)
6457 printf ("%s\n", find_file (print_file_name
));
6461 if (print_prog_name
)
6463 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6464 printf ("%s\n", (newname
? newname
: print_prog_name
));
6468 if (print_multi_lib
)
6470 print_multilib_info ();
6474 if (print_multi_directory
)
6476 if (multilib_dir
== NULL
)
6479 printf ("%s\n", multilib_dir
);
6485 if (target_system_root
)
6487 if (target_sysroot_suffix
)
6488 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6490 printf ("%s\n", target_system_root
);
6495 if (print_multi_os_directory
)
6497 if (multilib_os_dir
== NULL
)
6500 printf ("%s\n", multilib_os_dir
);
6504 if (print_sysroot_headers_suffix
)
6506 if (*sysroot_hdrs_suffix_spec
)
6508 printf("%s\n", (target_sysroot_hdrs_suffix
6509 ? target_sysroot_hdrs_suffix
6514 /* The error status indicates that only one set of fixed
6515 headers should be built. */
6516 fatal_error ("not configured with sysroot headers suffix");
6519 if (print_help_list
)
6525 printf (_("\nFor bug reporting instructions, please see:\n"));
6526 printf ("%s.\n", bug_report_url
);
6531 /* We do not exit here. Instead we have created a fake input file
6532 called 'help-dummy' which needs to be compiled, and we pass this
6533 on the various sub-processes, along with the --help switch.
6534 Ensure their output appears after ours. */
6535 fputc ('\n', stdout
);
6541 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
6543 printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
6545 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6546 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6551 /* We do not exit here. We use the same mechanism of --help to print
6552 the version of the sub-processes. */
6553 fputc ('\n', stdout
);
6562 fnotice (stderr
, "Target: %s\n", spec_machine
);
6563 fnotice (stderr
, "Configured with: %s\n", configuration_arguments
);
6565 #ifdef THREAD_MODEL_SPEC
6566 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6567 but there's no point in doing all this processing just to get
6568 thread_model back. */
6569 obstack_init (&obstack
);
6570 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6571 obstack_1grow (&obstack
, '\0');
6572 thrmod
= XOBFINISH (&obstack
, const char *);
6574 thrmod
= thread_model
;
6577 fnotice (stderr
, "Thread model: %s\n", thrmod
);
6579 /* compiler_version is truncated at the first space when initialized
6580 from version string, so truncate version_string at the first space
6581 before comparing. */
6582 for (n
= 0; version_string
[n
]; n
++)
6583 if (version_string
[n
] == ' ')
6586 if (! strncmp (version_string
, compiler_version
, n
)
6587 && compiler_version
[n
] == 0)
6588 fnotice (stderr
, "gcc version %s %s\n", version_string
,
6591 fnotice (stderr
, "gcc driver version %s %sexecuting gcc version %s\n",
6592 version_string
, pkgversion_string
, compiler_version
);
6598 if (n_infiles
== added_libraries
)
6599 fatal_error ("no input files");
6601 /* Make a place to record the compiler output file names
6602 that correspond to the input files. */
6605 i
+= lang_specific_extra_outfiles
;
6606 outfiles
= XCNEWVEC (const char *, i
);
6608 /* Record which files were specified explicitly as link input. */
6610 explicit_link_files
= XCNEWVEC (char, n_infiles
);
6612 combine_inputs
= have_o
|| flag_wpa
;
6614 for (i
= 0; (int) i
< n_infiles
; i
++)
6616 const char *name
= infiles
[i
].name
;
6617 struct compiler
*compiler
= lookup_compiler (name
,
6619 infiles
[i
].language
);
6621 if (compiler
&& !(compiler
->combinable
))
6622 combine_inputs
= false;
6624 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6625 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6626 infiles
[i
].incompiler
= compiler
;
6630 input_file_compiler
= compiler
;
6631 infiles
[i
].incompiler
= compiler
;
6635 /* Since there is no compiler for this input file, assume it is a
6637 explicit_link_files
[i
] = 1;
6638 infiles
[i
].incompiler
= NULL
;
6640 infiles
[i
].compiled
= false;
6641 infiles
[i
].preprocessed
= false;
6644 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6645 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6647 for (i
= 0; (int) i
< n_infiles
; i
++)
6649 int this_file_error
= 0;
6651 /* Tell do_spec what to substitute for %i. */
6653 input_file_number
= i
;
6654 set_input (infiles
[i
].name
);
6656 if (infiles
[i
].compiled
)
6659 /* Use the same thing in %o, unless cp->spec says otherwise. */
6661 outfiles
[i
] = gcc_input_filename
;
6663 /* Figure out which compiler from the file's suffix. */
6666 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6667 infiles
[i
].language
);
6669 if (input_file_compiler
)
6671 /* Ok, we found an applicable compiler. Run its spec. */
6673 if (input_file_compiler
->spec
[0] == '#')
6675 error ("%s: %s compiler not installed on this system",
6676 gcc_input_filename
, &input_file_compiler
->spec
[1]);
6677 this_file_error
= 1;
6683 if (debug_check_temp_file
[0])
6684 free (debug_check_temp_file
[0]);
6685 debug_check_temp_file
[0] = NULL
;
6687 if (debug_check_temp_file
[1])
6688 free (debug_check_temp_file
[1]);
6689 debug_check_temp_file
[1] = NULL
;
6692 value
= do_spec (input_file_compiler
->spec
);
6693 infiles
[i
].compiled
= true;
6695 this_file_error
= 1;
6696 else if (compare_debug
&& debug_check_temp_file
[0])
6699 inform (0, "recompiling with -fcompare-debug");
6701 compare_debug
= -compare_debug
;
6702 n_switches
= n_switches_debug_check
[1];
6703 switches
= switches_debug_check
[1];
6705 value
= do_spec (input_file_compiler
->spec
);
6707 compare_debug
= -compare_debug
;
6708 n_switches
= n_switches_debug_check
[0];
6709 switches
= switches_debug_check
[0];
6713 error ("during -fcompare-debug recompilation");
6714 this_file_error
= 1;
6717 gcc_assert (debug_check_temp_file
[1]
6718 && strcmp (debug_check_temp_file
[0],
6719 debug_check_temp_file
[1]));
6722 inform (0, "comparing final insns dumps");
6724 if (compare_files (debug_check_temp_file
))
6725 this_file_error
= 1;
6730 if (debug_check_temp_file
[0])
6731 free (debug_check_temp_file
[0]);
6732 debug_check_temp_file
[0] = NULL
;
6734 if (debug_check_temp_file
[1])
6735 free (debug_check_temp_file
[1]);
6736 debug_check_temp_file
[1] = NULL
;
6741 /* If this file's name does not contain a recognized suffix,
6742 record it as explicit linker input. */
6745 explicit_link_files
[i
] = 1;
6747 /* Clear the delete-on-failure queue, deleting the files in it
6748 if this compilation failed. */
6750 if (this_file_error
)
6752 delete_failure_queue ();
6755 /* If this compilation succeeded, don't delete those files later. */
6756 clear_failure_queue ();
6759 /* Reset the input file name to the first compile/object file name, for use
6760 with %b in LINK_SPEC. We use the first input file that we can find
6761 a compiler to compile it instead of using infiles.language since for
6762 languages other than C we use aliases that we then lookup later. */
6767 for (i
= 0; i
< n_infiles
; i
++)
6768 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6770 set_input (infiles
[i
].name
);
6777 /* Make sure INPUT_FILE_NUMBER points to first available open
6779 input_file_number
= n_infiles
;
6780 if (lang_specific_pre_link ())
6784 /* Determine if there are any linker input files. */
6785 num_linker_inputs
= 0;
6786 for (i
= 0; (int) i
< n_infiles
; i
++)
6787 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6788 num_linker_inputs
++;
6790 /* Run ld to link all the compiler output files. */
6792 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
6794 int tmp
= execution_count
;
6795 const char *fuse_linker_plugin
= "fuse-linker-plugin";
6797 /* We'll use ld if we can't find collect2. */
6798 if (! strcmp (linker_name_spec
, "collect2"))
6800 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
6802 linker_name_spec
= "ld";
6805 if (switch_matches (fuse_linker_plugin
,
6806 fuse_linker_plugin
+ strlen (fuse_linker_plugin
), 0))
6808 linker_plugin_file_spec
= find_a_file (&exec_prefixes
,
6809 "liblto_plugin.so", R_OK
,
6811 if (!linker_plugin_file_spec
)
6812 fatal_error ("-fuse-linker-plugin, but liblto_plugin.so not found");
6814 lto_libgcc_spec
= find_a_file (&startfile_prefixes
, "libgcc.a",
6816 if (!lto_libgcc_spec
)
6817 fatal_error ("could not find libgcc.a");
6819 lto_gcc_spec
= argv
[0];
6821 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6823 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
6824 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
6826 if (print_subprocess_help
== 1)
6828 printf (_("\nLinker options\n==============\n\n"));
6829 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6830 " to the linker.\n\n"));
6833 value
= do_spec (link_command_spec
);
6836 linker_was_run
= (tmp
!= execution_count
);
6839 /* If options said don't run linker,
6840 complain about input files to be given to the linker. */
6842 if (! linker_was_run
&& !seen_error ())
6843 for (i
= 0; (int) i
< n_infiles
; i
++)
6844 if (explicit_link_files
[i
]
6845 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
6846 warning (0, "%s: linker input file unused because linking not done",
6849 /* Delete some or all of the temporary files we made. */
6852 delete_failure_queue ();
6853 delete_temp_files ();
6855 if (print_help_list
)
6857 printf (("\nFor bug reporting instructions, please see:\n"));
6858 printf ("%s\n", bug_report_url
);
6861 return (signal_count
!= 0 ? 2
6862 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
6866 /* Find the proper compilation spec for the file name NAME,
6867 whose length is LENGTH. LANGUAGE is the specified language,
6868 or 0 if this file is to be passed to the linker. */
6870 static struct compiler
*
6871 lookup_compiler (const char *name
, size_t length
, const char *language
)
6873 struct compiler
*cp
;
6875 /* If this was specified by the user to be a linker input, indicate that. */
6876 if (language
!= 0 && language
[0] == '*')
6879 /* Otherwise, look for the language, if one is spec'd. */
6882 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6883 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
6886 error ("language %s not recognized", language
);
6890 /* Look for a suffix. */
6891 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6893 if (/* The suffix `-' matches only the file name `-'. */
6894 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6895 || (strlen (cp
->suffix
) < length
6896 /* See if the suffix matches the end of NAME. */
6897 && !strcmp (cp
->suffix
,
6898 name
+ length
- strlen (cp
->suffix
))
6903 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6904 /* Look again, but case-insensitively this time. */
6906 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6908 if (/* The suffix `-' matches only the file name `-'. */
6909 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6910 || (strlen (cp
->suffix
) < length
6911 /* See if the suffix matches the end of NAME. */
6912 && ((!strcmp (cp
->suffix
,
6913 name
+ length
- strlen (cp
->suffix
))
6914 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6915 && !strcasecmp (cp
->suffix
,
6916 name
+ length
- strlen (cp
->suffix
)))
6922 if (cp
>= compilers
)
6924 if (cp
->spec
[0] != '@')
6925 /* A non-alias entry: return it. */
6928 /* An alias entry maps a suffix to a language.
6929 Search for the language; pass 0 for NAME and LENGTH
6930 to avoid infinite recursion if language not found. */
6931 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
6937 save_string (const char *s
, int len
)
6939 char *result
= XNEWVEC (char, len
+ 1);
6941 memcpy (result
, s
, len
);
6947 pfatal_with_name (const char *name
)
6949 perror_with_name (name
);
6950 delete_temp_files ();
6955 perror_with_name (const char *name
)
6957 error ("%s: %m", name
);
6961 validate_switches_from_spec (const char *spec
)
6963 const char *p
= spec
;
6966 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
6967 /* We have a switch spec. */
6968 p
= validate_switches (p
+ 1);
6972 validate_all_switches (void)
6974 struct compiler
*comp
;
6975 struct spec_list
*spec
;
6977 for (comp
= compilers
; comp
->spec
; comp
++)
6978 validate_switches_from_spec (comp
->spec
);
6980 /* Look through the linked list of specs read from the specs file. */
6981 for (spec
= specs
; spec
; spec
= spec
->next
)
6982 validate_switches_from_spec (*spec
->ptr_spec
);
6984 validate_switches_from_spec (link_command_spec
);
6987 /* Look at the switch-name that comes after START
6988 and mark as valid all supplied switches that match it. */
6991 validate_switches (const char *start
)
6993 const char *p
= start
;
6997 bool suffix
= false;
6998 bool starred
= false;
7000 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7009 if (*p
== '.' || *p
== ',')
7013 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7014 || *p
== ',' || *p
== '.' || *p
== '@')
7019 starred
= true, p
++;
7025 /* Mark all matching switches as valid. */
7026 for (i
= 0; i
< n_switches
; i
++)
7027 if (!strncmp (switches
[i
].part1
, atom
, len
)
7028 && (starred
|| switches
[i
].part1
[len
] == 0))
7029 switches
[i
].validated
= 1;
7033 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7036 if (*p
&& p
[-1] == ':')
7038 while (*p
&& *p
!= ';' && *p
!= '}')
7043 if (*p
== '{' || *p
== '<')
7044 p
= validate_switches (p
+1);
7045 else if (p
[0] == 'W' && p
[1] == '{')
7046 p
= validate_switches (p
+2);
7053 if (*p
&& p
[-1] == ';')
7067 static struct mdswitchstr
*mdswitches
;
7068 static int n_mdswitches
;
7070 /* Check whether a particular argument was used. The first time we
7071 canonicalize the switches to keep only the ones we care about. */
7074 used_arg (const char *p
, int len
)
7079 const char *replace
;
7084 static struct mswitchstr
*mswitches
;
7085 static int n_mswitches
;
7090 struct mswitchstr
*matches
;
7094 /* Break multilib_matches into the component strings of string
7095 and replacement string. */
7096 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7101 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7103 q
= multilib_matches
;
7112 fatal_error ("multilib spec %qs is invalid",
7117 matches
[i
].len
= q
- matches
[i
].str
;
7119 matches
[i
].replace
= ++q
;
7120 while (*q
!= ';' && *q
!= '\0')
7123 goto invalid_matches
;
7126 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7132 /* Now build a list of the replacement string for switches that we care
7133 about. Make sure we allocate at least one entry. This prevents
7134 xmalloc from calling fatal, and prevents us from re-executing this
7137 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7138 for (i
= 0; i
< n_switches
; i
++)
7139 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7141 int xlen
= strlen (switches
[i
].part1
);
7142 for (j
= 0; j
< cnt
; j
++)
7143 if (xlen
== matches
[j
].len
7144 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7146 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7147 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7148 mswitches
[n_mswitches
].replace
= (char *) 0;
7149 mswitches
[n_mswitches
].rep_len
= 0;
7155 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7156 on the command line nor any options mutually incompatible with
7158 for (i
= 0; i
< n_mdswitches
; i
++)
7162 for (q
= multilib_options
; *q
!= '\0'; q
++)
7168 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7169 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7171 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7178 if (*q
!= ' ' && *q
!= '\0')
7180 while (*r
!= ' ' && *r
!= '\0')
7183 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7186 if (used_arg (r
, q
- r
))
7191 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7192 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7193 mswitches
[n_mswitches
].replace
= (char *) 0;
7194 mswitches
[n_mswitches
].rep_len
= 0;
7207 for (i
= 0; i
< n_mswitches
; i
++)
7208 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7215 default_arg (const char *p
, int len
)
7219 for (i
= 0; i
< n_mdswitches
; i
++)
7220 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7226 /* Work out the subdirectory to use based on the options. The format of
7227 multilib_select is a list of elements. Each element is a subdirectory
7228 name followed by a list of options followed by a semicolon. The format
7229 of multilib_exclusions is the same, but without the preceding
7230 directory. First gcc will check the exclusions, if none of the options
7231 beginning with an exclamation point are present, and all of the other
7232 options are present, then we will ignore this completely. Passing
7233 that, gcc will consider each multilib_select in turn using the same
7234 rules for matching the options. If a match is found, that subdirectory
7238 set_multilib_dir (void)
7241 unsigned int this_path_len
;
7242 const char *this_path
, *this_arg
;
7243 const char *start
, *end
;
7245 int ok
, ndfltok
, first
;
7248 start
= multilib_defaults
;
7249 while (*start
== ' ' || *start
== '\t')
7251 while (*start
!= '\0')
7254 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7256 while (*start
== ' ' || *start
== '\t')
7264 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7265 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7267 while (*start
== ' ' || *start
== '\t')
7273 for (end
= start
+ 1;
7274 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7277 obstack_grow (&multilib_obstack
, start
, end
- start
);
7278 obstack_1grow (&multilib_obstack
, 0);
7279 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7280 mdswitches
[i
++].len
= end
- start
;
7287 p
= multilib_exclusions
;
7290 /* Ignore newlines. */
7297 /* Check the arguments. */
7304 fatal_error ("multilib exclusions %qs is invalid",
7305 multilib_exclusions
);
7315 while (*p
!= ' ' && *p
!= ';')
7318 goto invalid_exclusions
;
7322 if (*this_arg
!= '!')
7330 ok
= used_arg (this_arg
, p
- this_arg
);
7345 p
= multilib_select
;
7348 /* Ignore newlines. */
7355 /* Get the initial path. */
7362 fatal_error ("multilib select %qs is invalid",
7367 this_path_len
= p
- this_path
;
7369 /* Check the arguments. */
7376 goto invalid_select
;
7385 while (*p
!= ' ' && *p
!= ';')
7388 goto invalid_select
;
7392 if (*this_arg
!= '!')
7400 /* If this is a default argument, we can just ignore it.
7401 This is true even if this_arg begins with '!'. Beginning
7402 with '!' does not mean that this argument is necessarily
7403 inappropriate for this library: it merely means that
7404 there is a more specific library which uses this
7405 argument. If this argument is a default, we need not
7406 consider that more specific library. */
7407 ok
= used_arg (this_arg
, p
- this_arg
);
7414 if (default_arg (this_arg
, p
- this_arg
))
7423 if (this_path_len
!= 1
7424 || this_path
[0] != '.')
7426 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7429 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7430 new_multilib_dir
[this_path_len
] = '\0';
7431 q
= strchr (new_multilib_dir
, ':');
7434 multilib_dir
= new_multilib_dir
;
7441 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7443 while (q
< end
&& *q
!= ':')
7447 char *new_multilib_os_dir
= XNEWVEC (char, end
- q
);
7448 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7449 new_multilib_os_dir
[end
- q
- 1] = '\0';
7450 multilib_os_dir
= new_multilib_os_dir
;
7458 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7459 && strcmp (multilib_os_dir
, ".") == 0)
7461 free (CONST_CAST (char *, multilib_os_dir
));
7462 multilib_os_dir
= NULL
;
7464 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7465 multilib_os_dir
= multilib_dir
;
7468 /* Print out the multiple library subdirectory selection
7469 information. This prints out a series of lines. Each line looks
7470 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7471 required. Only the desired options are printed out, the negative
7472 matches. The options are print without a leading dash. There are
7473 no spaces to make it easy to use the information in the shell.
7474 Each subdirectory is printed only once. This assumes the ordering
7475 generated by the genmultilib script. Also, we leave out ones that match
7479 print_multilib_info (void)
7481 const char *p
= multilib_select
;
7482 const char *last_path
= 0, *this_path
;
7484 unsigned int last_path_len
= 0;
7489 /* Ignore newlines. */
7496 /* Get the initial path. */
7503 fatal_error ("multilib select %qs is invalid", multilib_select
);
7509 /* When --disable-multilib was used but target defines
7510 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7511 to find multilib_os_dir, so skip them from output. */
7512 if (this_path
[0] == '.' && this_path
[1] == ':')
7515 /* Check for matches with the multilib_exclusions. We don't bother
7516 with the '!' in either list. If any of the exclusion rules match
7517 all of its options with the select rule, we skip it. */
7519 const char *e
= multilib_exclusions
;
7520 const char *this_arg
;
7525 /* Ignore newlines. */
7532 /* Check the arguments. */
7541 fatal_error ("multilib exclusion %qs is invalid",
7542 multilib_exclusions
);
7553 while (*e
!= ' ' && *e
!= ';')
7556 goto invalid_exclusion
;
7564 int len
= e
- this_arg
;
7567 goto invalid_select
;
7571 while (*q
!= ' ' && *q
!= ';')
7574 goto invalid_select
;
7578 if (! strncmp (arg
, this_arg
,
7579 (len
< q
- arg
) ? q
- arg
: len
)
7580 || default_arg (this_arg
, e
- this_arg
))
7610 /* If this is a duplicate, skip it. */
7611 skip
= (last_path
!= 0
7612 && (unsigned int) (p
- this_path
) == last_path_len
7613 && ! strncmp (last_path
, this_path
, last_path_len
));
7615 last_path
= this_path
;
7616 last_path_len
= p
- this_path
;
7619 /* If this directory requires any default arguments, we can skip
7620 it. We will already have printed a directory identical to
7621 this one which does not require that default argument. */
7632 goto invalid_select
;
7639 while (*q
!= ' ' && *q
!= ';')
7642 goto invalid_select
;
7647 && default_arg (arg
, q
- arg
))
7662 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7673 goto invalid_select
;
7681 use_arg
= *p
!= '!';
7686 while (*p
!= ' ' && *p
!= ';')
7689 goto invalid_select
;
7701 /* If there are extra options, print them now. */
7702 if (multilib_extra
&& *multilib_extra
)
7704 int print_at
= TRUE
;
7707 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7728 /* getenv built-in spec function.
7730 Returns the value of the environment variable given by its first
7731 argument, concatenated with the second argument. If the
7732 environment variable is not defined, a fatal error is issued. */
7735 getenv_spec_function (int argc
, const char **argv
)
7745 value
= getenv (argv
[0]);
7747 fatal_error ("environment variable %qs not defined", argv
[0]);
7749 /* We have to escape every character of the environment variable so
7750 they are not interpreted as active spec characters. A
7751 particularly painful case is when we are reading a variable
7752 holding a windows path complete with \ separators. */
7753 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
7754 result
= XNEWVAR (char, len
);
7755 for (ptr
= result
; *value
; ptr
+= 2)
7761 strcpy (ptr
, argv
[1]);
7766 /* if-exists built-in spec function.
7768 Checks to see if the file specified by the absolute pathname in
7769 ARGS exists. Returns that pathname if found.
7771 The usual use for this function is to check for a library file
7772 (whose name has been expanded with %s). */
7775 if_exists_spec_function (int argc
, const char **argv
)
7777 /* Must have only one argument. */
7778 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7784 /* if-exists-else built-in spec function.
7786 This is like if-exists, but takes an additional argument which
7787 is returned if the first argument does not exist. */
7790 if_exists_else_spec_function (int argc
, const char **argv
)
7792 /* Must have exactly two arguments. */
7796 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7802 /* replace-outfile built-in spec function.
7804 This looks for the first argument in the outfiles array's name and
7805 replaces it with the second argument. */
7808 replace_outfile_spec_function (int argc
, const char **argv
)
7811 /* Must have exactly two arguments. */
7815 for (i
= 0; i
< n_infiles
; i
++)
7817 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
7818 outfiles
[i
] = xstrdup (argv
[1]);
7823 /* remove-outfile built-in spec function.
7825 * This looks for the first argument in the outfiles array's name and
7829 remove_outfile_spec_function (int argc
, const char **argv
)
7832 /* Must have exactly one argument. */
7836 for (i
= 0; i
< n_infiles
; i
++)
7838 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
7844 /* Given two version numbers, compares the two numbers.
7845 A version number must match the regular expression
7846 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7849 compare_version_strings (const char *v1
, const char *v2
)
7854 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7855 REG_EXTENDED
| REG_NOSUB
) != 0)
7857 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
7858 if (rresult
== REG_NOMATCH
)
7859 fatal_error ("invalid version number %qs", v1
);
7860 else if (rresult
!= 0)
7862 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
7863 if (rresult
== REG_NOMATCH
)
7864 fatal_error ("invalid version number %qs", v2
);
7865 else if (rresult
!= 0)
7868 return strverscmp (v1
, v2
);
7872 /* version_compare built-in spec function.
7874 This takes an argument of the following form:
7876 <comparison-op> <arg1> [<arg2>] <switch> <result>
7878 and produces "result" if the comparison evaluates to true,
7879 and nothing if it doesn't.
7881 The supported <comparison-op> values are:
7883 >= true if switch is a later (or same) version than arg1
7885 < true if switch is an earlier version than arg1
7887 >< true if switch is arg1 or later, and earlier than arg2
7888 <> true if switch is earlier than arg1 or is arg2 or later
7890 If the switch is not present, the condition is false unless
7891 the first character of the <comparison-op> is '!'.
7894 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7895 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
7898 version_compare_spec_function (int argc
, const char **argv
)
7902 const char *switch_value
= NULL
;
7907 fatal_error ("too few arguments to %%:version-compare");
7908 if (argv
[0][0] == '\0')
7910 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
7912 if (argc
!= nargs
+ 3)
7913 fatal_error ("too many arguments to %%:version-compare");
7915 switch_len
= strlen (argv
[nargs
+ 1]);
7916 for (i
= 0; i
< n_switches
; i
++)
7917 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
7918 && check_live_switch (i
, switch_len
))
7919 switch_value
= switches
[i
].part1
+ switch_len
;
7921 if (switch_value
== NULL
)
7925 comp1
= compare_version_strings (switch_value
, argv
[1]);
7927 comp2
= compare_version_strings (switch_value
, argv
[2]);
7929 comp2
= -1; /* This value unused. */
7932 switch (argv
[0][0] << 8 | argv
[0][1])
7934 case '>' << 8 | '=':
7935 result
= comp1
>= 0;
7937 case '!' << 8 | '<':
7938 result
= comp1
>= 0 || switch_value
== NULL
;
7943 case '!' << 8 | '>':
7944 result
= comp1
< 0 || switch_value
== NULL
;
7946 case '>' << 8 | '<':
7947 result
= comp1
>= 0 && comp2
< 0;
7949 case '<' << 8 | '>':
7950 result
= comp1
< 0 || comp2
>= 0;
7954 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
7959 return argv
[nargs
+ 2];
7962 /* %:include builtin spec function. This differs from %include in that it
7963 can be nested inside a spec, and thus be conditionalized. It takes
7964 one argument, the filename, and looks for it in the startfile path.
7965 The result is always NULL, i.e. an empty expansion. */
7968 include_spec_function (int argc
, const char **argv
)
7975 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
7976 read_specs (file
? file
: argv
[0], FALSE
);
7981 /* %:find-file spec function. This function replaces its argument by
7982 the file found thru find_file, that is the -print-file-name gcc
7985 find_file_spec_function (int argc
, const char **argv
)
7992 file
= find_file (argv
[0]);
7997 /* %:find-plugindir spec function. This function replaces its argument
7998 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
7999 is the -print-file-name gcc program option. */
8001 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8008 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8013 /* %:print-asm-header spec function. Print a banner to say that the
8014 following output is from the assembler. */
8017 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8018 const char **argv ATTRIBUTE_UNUSED
)
8020 printf (_("Assembler options\n=================\n\n"));
8021 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8026 /* Compute a timestamp to initialize flag_random_seed. */
8029 get_local_tick (void)
8033 /* Get some more or less random data. */
8034 #ifdef HAVE_GETTIMEOFDAY
8038 gettimeofday (&tv
, NULL
);
8039 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8043 time_t now
= time (NULL
);
8045 if (now
!= (time_t)-1)
8046 ret
= (unsigned) now
;
8053 /* %:compare-debug-dump-opt spec function. Save the last argument,
8054 expected to be the last -fdump-final-insns option, or generate a
8058 compare_debug_dump_opt_spec_function (int arg
,
8059 const char **argv ATTRIBUTE_UNUSED
)
8064 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
8067 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8069 do_spec_2 ("%{fdump-final-insns=*:%*}");
8070 do_spec_1 (" ", 0, NULL
);
8072 if (argbuf_index
> 0 && strcmp (argv
[argbuf_index
- 1], "."))
8077 name
= xstrdup (argv
[argbuf_index
- 1]);
8082 const char *ext
= NULL
;
8084 if (argbuf_index
> 0)
8086 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8089 else if (!compare_debug
)
8092 do_spec_2 ("%g.gkd");
8094 do_spec_1 (" ", 0, NULL
);
8096 gcc_assert (argbuf_index
> 0);
8098 name
= concat (argbuf
[argbuf_index
- 1], ext
, NULL
);
8100 ret
= concat ("-fdump-final-insns=", name
, NULL
);
8103 which
= compare_debug
< 0;
8104 debug_check_temp_file
[which
] = name
;
8108 unsigned HOST_WIDE_INT value
= get_local_tick () ^ getpid ();
8110 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
8114 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
8123 static const char *debug_auxbase_opt
;
8125 /* %:compare-debug-self-opt spec function. Expands to the options
8126 that are to be passed in the second compilation of
8130 compare_debug_self_opt_spec_function (int arg
,
8131 const char **argv ATTRIBUTE_UNUSED
)
8134 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8136 if (compare_debug
>= 0)
8139 do_spec_2 ("%{c|S:%{o*:%*}}");
8140 do_spec_1 (" ", 0, NULL
);
8142 if (argbuf_index
> 0)
8143 debug_auxbase_opt
= concat ("-auxbase-strip ",
8144 argbuf
[argbuf_index
- 1],
8147 debug_auxbase_opt
= NULL
;
8150 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8151 %<fdump-final-insns=* -w -S -o %j \
8152 %{!fcompare-debug-second:-fcompare-debug-second} \
8153 ", compare_debug_opt
, NULL
);
8156 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8157 options that are to be passed in the second compilation of
8158 compare-debug. It expects, as an argument, the basename of the
8159 current input file name, with the .gk suffix appended to it. */
8162 compare_debug_auxbase_opt_spec_function (int arg
,
8169 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8172 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8174 if (compare_debug
>= 0)
8177 len
= strlen (argv
[0]);
8178 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
8179 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8180 "does not end in .gk");
8182 if (debug_auxbase_opt
)
8183 return debug_auxbase_opt
;
8185 #define OPT "-auxbase "
8188 name
= (char*) xmalloc (sizeof (OPT
) + len
);
8189 memcpy (name
, OPT
, sizeof (OPT
) - 1);
8190 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
8191 name
[sizeof (OPT
) - 1 + len
] = '\0';